<h2>Editing: Int64.php</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'>&lt;?php

/**
 * Class ParagonIE_Sodium_Core32_Int64
 *
 * Encapsulates a 64-bit integer.
 *
 * These are immutable. It always returns a new instance.
 */
class ParagonIE_Sodium_Core32_Int64
{
    /**
     * @var array&lt;int, int&gt; - four 16-bit integers
     */
    public $limbs = array(0, 0, 0, 0);

    /**
     * @var int
     */
    public $overflow = 0;

    /**
     * @var bool
     */
    public $unsignedInt = false;

    /**
     * ParagonIE_Sodium_Core32_Int64 constructor.
     * @param array $array
     * @param bool $unsignedInt
     */
    public function __construct($array = array(0, 0, 0, 0), $unsignedInt = false)
    {
        $this-&gt;limbs = array(
            (int) $array[0],
            (int) $array[1],
            (int) $array[2],
            (int) $array[3]
        );
        $this-&gt;overflow = 0;
        $this-&gt;unsignedInt = $unsignedInt;
    }

    /**
     * Adds two int64 objects
     *
     * @param ParagonIE_Sodium_Core32_Int64 $addend
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function addInt64(ParagonIE_Sodium_Core32_Int64 $addend)
    {
        $i0 = $this-&gt;limbs[0];
        $i1 = $this-&gt;limbs[1];
        $i2 = $this-&gt;limbs[2];
        $i3 = $this-&gt;limbs[3];
        $j0 = $addend-&gt;limbs[0];
        $j1 = $addend-&gt;limbs[1];
        $j2 = $addend-&gt;limbs[2];
        $j3 = $addend-&gt;limbs[3];

        $r3 = $i3 + ($j3 &amp; 0xffff);
        $carry = $r3 &gt;&gt; 16;

        $r2 = $i2 + ($j2 &amp; 0xffff) + $carry;
        $carry = $r2 &gt;&gt; 16;

        $r1 = $i1 + ($j1 &amp; 0xffff) + $carry;
        $carry = $r1 &gt;&gt; 16;

        $r0 = $i0 + ($j0 &amp; 0xffff) + $carry;
        $carry = $r0 &gt;&gt; 16;

        $r0 &amp;= 0xffff;
        $r1 &amp;= 0xffff;
        $r2 &amp;= 0xffff;
        $r3 &amp;= 0xffff;

        $return = new ParagonIE_Sodium_Core32_Int64(
            array($r0, $r1, $r2, $r3)
        );
        $return-&gt;overflow = $carry;
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        return $return;
    }

    /**
     * Adds a normal integer to an int64 object
     *
     * @param int $int
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     */
    public function addInt($int)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
        /** @var int $int */
        $int = (int) $int;

        $i0 = $this-&gt;limbs[0];
        $i1 = $this-&gt;limbs[1];
        $i2 = $this-&gt;limbs[2];
        $i3 = $this-&gt;limbs[3];

        $r3 = $i3 + ($int &amp; 0xffff);
        $carry = $r3 &gt;&gt; 16;

        $r2 = $i2 + (($int &gt;&gt; 16) &amp; 0xffff) + $carry;
        $carry = $r2 &gt;&gt; 16;

        $r1 = $i1 + $carry;
        $carry = $r1 &gt;&gt; 16;

        $r0 = $i0 + $carry;
        $carry = $r0 &gt;&gt; 16;

        $r0 &amp;= 0xffff;
        $r1 &amp;= 0xffff;
        $r2 &amp;= 0xffff;
        $r3 &amp;= 0xffff;
        $return = new ParagonIE_Sodium_Core32_Int64(
            array($r0, $r1, $r2, $r3)
        );
        $return-&gt;overflow = $carry;
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        return $return;
    }

    /**
     * @param int $b
     * @return int
     */
    public function compareInt($b = 0)
    {
        $gt = 0;
        $eq = 1;

        $i = 4;
        $j = 0;
        while ($i &gt; 0) {
            --$i;
            /** @var int $x1 */
            $x1 = $this-&gt;limbs[$i];
            /** @var int $x2 */
            $x2 = ($b &gt;&gt; ($j &lt;&lt; 4)) &amp; 0xffff;
            /** int */
            $gt |= (($x2 - $x1) &gt;&gt; 8) &amp; $eq;
            /** int */
            $eq &amp;= (($x2 ^ $x1) - 1) &gt;&gt; 8;
        }
        return ($gt + $gt - $eq) + 1;
    }

    /**
     * @param int $b
     * @return bool
     */
    public function isGreaterThan($b = 0)
    {
        return $this-&gt;compareInt($b) &gt; 0;
    }

    /**
     * @param int $b
     * @return bool
     */
    public function isLessThanInt($b = 0)
    {
        return $this-&gt;compareInt($b) &lt; 0;
    }

    /**
     * @param int $hi
     * @param int $lo
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function mask64($hi = 0, $lo = 0)
    {
        /** @var int $a */
        $a = ($hi &gt;&gt; 16) &amp; 0xffff;
        /** @var int $b */
        $b = ($hi) &amp; 0xffff;
        /** @var int $c */
        $c = ($lo &gt;&gt; 16) &amp; 0xffff;
        /** @var int $d */
        $d = ($lo &amp; 0xffff);
        return new ParagonIE_Sodium_Core32_Int64(
            array(
                $this-&gt;limbs[0] &amp; $a,
                $this-&gt;limbs[1] &amp; $b,
                $this-&gt;limbs[2] &amp; $c,
                $this-&gt;limbs[3] &amp; $d
            ),
            $this-&gt;unsignedInt
        );
    }

    /**
     * @param int $int
     * @param int $size
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     * @psalm-suppress MixedAssignment
     */
    public function mulInt($int = 0, $size = 0)
    {
        if (ParagonIE_Sodium_Compat::$fastMult) {
            return $this-&gt;mulIntFast($int);
        }
        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
        /** @var int $int */
        $int = (int) $int;
        /** @var int $size */
        $size = (int) $size;

        if (!$size) {
            $size = 63;
        }

        $a = clone $this;
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;

        // Initialize:
        $ret0 = 0;
        $ret1 = 0;
        $ret2 = 0;
        $ret3 = 0;
        $a0 = $a-&gt;limbs[0];
        $a1 = $a-&gt;limbs[1];
        $a2 = $a-&gt;limbs[2];
        $a3 = $a-&gt;limbs[3];

        /** @var int $size */
        /** @var int $i */
        for ($i = $size; $i &gt;= 0; --$i) {
            $mask = -($int &amp; 1);
            $x0 = $a0 &amp; $mask;
            $x1 = $a1 &amp; $mask;
            $x2 = $a2 &amp; $mask;
            $x3 = $a3 &amp; $mask;

            $ret3 += $x3;
            $c = $ret3 &gt;&gt; 16;

            $ret2 += $x2 + $c;
            $c = $ret2 &gt;&gt; 16;

            $ret1 += $x1 + $c;
            $c = $ret1 &gt;&gt; 16;

            $ret0 += $x0 + $c;

            $ret0 &amp;= 0xffff;
            $ret1 &amp;= 0xffff;
            $ret2 &amp;= 0xffff;
            $ret3 &amp;= 0xffff;

            $a3 = $a3 &lt;&lt; 1;
            $x3 = $a3 &gt;&gt; 16;
            $a2 = ($a2 &lt;&lt; 1) | $x3;
            $x2 = $a2 &gt;&gt; 16;
            $a1 = ($a1 &lt;&lt; 1) | $x2;
            $x1 = $a1 &gt;&gt; 16;
            $a0 = ($a0 &lt;&lt; 1) | $x1;
            $a0 &amp;= 0xffff;
            $a1 &amp;= 0xffff;
            $a2 &amp;= 0xffff;
            $a3 &amp;= 0xffff;

            $int &gt;&gt;= 1;
        }
        $return-&gt;limbs[0] = $ret0;
        $return-&gt;limbs[1] = $ret1;
        $return-&gt;limbs[2] = $ret2;
        $return-&gt;limbs[3] = $ret3;
        return $return;
    }

    /**
     * @param ParagonIE_Sodium_Core32_Int64 $A
     * @param ParagonIE_Sodium_Core32_Int64 $B
     * @return array&lt;int, ParagonIE_Sodium_Core32_Int64&gt;
     * @throws SodiumException
     * @throws TypeError
     * @psalm-suppress MixedInferredReturnType
     */
    public static function ctSelect(
        ParagonIE_Sodium_Core32_Int64 $A,
        ParagonIE_Sodium_Core32_Int64 $B
    ) {
        $a = clone $A;
        $b = clone $B;
        /** @var int $aNeg */
        $aNeg = ($a-&gt;limbs[0] &gt;&gt; 15) &amp; 1;
        /** @var int $bNeg */
        $bNeg = ($b-&gt;limbs[0] &gt;&gt; 15) &amp; 1;
        /** @var int $m */
        $m = (-($aNeg &amp; $bNeg)) | 1;
        /** @var int $swap */
        $swap = $bNeg &amp; ~$aNeg;
        /** @var int $d */
        $d = -$swap;

        /*
        if ($bNeg &amp;&amp; !$aNeg) {
            $a = clone $int;
            $b = clone $this;
        } elseif($bNeg &amp;&amp; $aNeg) {
            $a = $this-&gt;mulInt(-1);
            $b = $int-&gt;mulInt(-1);
        }
         */
        $x = $a-&gt;xorInt64($b)-&gt;mask64($d, $d);
        return array(
            $a-&gt;xorInt64($x)-&gt;mulInt($m),
            $b-&gt;xorInt64($x)-&gt;mulInt($m)
        );
    }

    /**
     * @param array&lt;int, int&gt; $a
     * @param array&lt;int, int&gt; $b
     * @param int $baseLog2
     * @return array&lt;int, int&gt;
     */
    public function multiplyLong(array $a, array $b, $baseLog2 = 16)
    {
        $a_l = count($a);
        $b_l = count($b);
        /** @var array&lt;int, int&gt; $r */
        $r = array_fill(0, $a_l + $b_l + 1, 0);
        $base = 1 &lt;&lt; $baseLog2;
        for ($i = 0; $i &lt; $a_l; ++$i) {
            $a_i = $a[$i];
            for ($j = 0; $j &lt; $a_l; ++$j) {
                $b_j = $b[$j];
                $product = (($a_i * $b_j) + $r[$i + $j]);
                $carry = (((int) $product &gt;&gt; $baseLog2) &amp; 0xffff);
                $r[$i + $j] = ((int) $product - (int) ($carry * $base)) &amp; 0xffff;
                $r[$i + $j + 1] += $carry;
            }
        }
        return array_slice($r, 0, 5);
    }

    /**
     * @param int $int
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function mulIntFast($int)
    {
        // Handle negative numbers
        $aNeg = ($this-&gt;limbs[0] &gt;&gt; 15) &amp; 1;
        $bNeg = ($int &gt;&gt; 31) &amp; 1;
        $a = array_reverse($this-&gt;limbs);
        $b = array(
            $int &amp; 0xffff,
            ($int &gt;&gt; 16) &amp; 0xffff,
            -$bNeg &amp; 0xffff,
            -$bNeg &amp; 0xffff
        );
        if ($aNeg) {
            for ($i = 0; $i &lt; 4; ++$i) {
                $a[$i] = ($a[$i] ^ 0xffff) &amp; 0xffff;
            }
            ++$a[0];
        }
        if ($bNeg) {
            for ($i = 0; $i &lt; 4; ++$i) {
                $b[$i] = ($b[$i] ^ 0xffff) &amp; 0xffff;
            }
            ++$b[0];
        }
        // Multiply
        $res = $this-&gt;multiplyLong($a, $b);

        // Re-apply negation to results
        if ($aNeg !== $bNeg) {
            for ($i = 0; $i &lt; 4; ++$i) {
                $res[$i] = (0xffff ^ $res[$i]) &amp; 0xffff;
            }
            // Handle integer overflow
            $c = 1;
            for ($i = 0; $i &lt; 4; ++$i) {
                $res[$i] += $c;
                $c = $res[$i] &gt;&gt; 16;
                $res[$i] &amp;= 0xffff;
            }
        }

        // Return our values
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;limbs = array(
            $res[3] &amp; 0xffff,
            $res[2] &amp; 0xffff,
            $res[1] &amp; 0xffff,
            $res[0] &amp; 0xffff
        );
        if (count($res) &gt; 4) {
            $return-&gt;overflow = $res[4] &amp; 0xffff;
        }
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        return $return;
    }

    /**
     * @param ParagonIE_Sodium_Core32_Int64 $right
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function mulInt64Fast(ParagonIE_Sodium_Core32_Int64 $right)
    {
        $aNeg = ($this-&gt;limbs[0] &gt;&gt; 15) &amp; 1;
        $bNeg = ($right-&gt;limbs[0] &gt;&gt; 15) &amp; 1;

        $a = array_reverse($this-&gt;limbs);
        $b = array_reverse($right-&gt;limbs);
        if ($aNeg) {
            for ($i = 0; $i &lt; 4; ++$i) {
                $a[$i] = ($a[$i] ^ 0xffff) &amp; 0xffff;
            }
            ++$a[0];
        }
        if ($bNeg) {
            for ($i = 0; $i &lt; 4; ++$i) {
                $b[$i] = ($b[$i] ^ 0xffff) &amp; 0xffff;
            }
            ++$b[0];
        }
        $res = $this-&gt;multiplyLong($a, $b);
        if ($aNeg !== $bNeg) {
            if ($aNeg !== $bNeg) {
                for ($i = 0; $i &lt; 4; ++$i) {
                    $res[$i] = ($res[$i] ^ 0xffff) &amp; 0xffff;
                }
                $c = 1;
                for ($i = 0; $i &lt; 4; ++$i) {
                    $res[$i] += $c;
                    $c = $res[$i] &gt;&gt; 16;
                    $res[$i] &amp;= 0xffff;
                }
            }
        }
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;limbs = array(
            $res[3] &amp; 0xffff,
            $res[2] &amp; 0xffff,
            $res[1] &amp; 0xffff,
            $res[0] &amp; 0xffff
        );
        if (count($res) &gt; 4) {
            $return-&gt;overflow = $res[4];
        }
        return $return;
    }

    /**
     * @param ParagonIE_Sodium_Core32_Int64 $int
     * @param int $size
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     * @psalm-suppress MixedAssignment
     */
    public function mulInt64(ParagonIE_Sodium_Core32_Int64 $int, $size = 0)
    {
        if (ParagonIE_Sodium_Compat::$fastMult) {
            return $this-&gt;mulInt64Fast($int);
        }
        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);
        if (!$size) {
            $size = 63;
        }
        list($a, $b) = self::ctSelect($this, $int);

        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;

        // Initialize:
        $ret0 = 0;
        $ret1 = 0;
        $ret2 = 0;
        $ret3 = 0;
        $a0 = $a-&gt;limbs[0];
        $a1 = $a-&gt;limbs[1];
        $a2 = $a-&gt;limbs[2];
        $a3 = $a-&gt;limbs[3];
        $b0 = $b-&gt;limbs[0];
        $b1 = $b-&gt;limbs[1];
        $b2 = $b-&gt;limbs[2];
        $b3 = $b-&gt;limbs[3];

        /** @var int $size */
        /** @var int $i */
        for ($i = (int) $size; $i &gt;= 0; --$i) {
            $mask = -($b3 &amp; 1);
            $x0 = $a0 &amp; $mask;
            $x1 = $a1 &amp; $mask;
            $x2 = $a2 &amp; $mask;
            $x3 = $a3 &amp; $mask;

            $ret3 += $x3;
            $c = $ret3 &gt;&gt; 16;

            $ret2 += $x2 + $c;
            $c = $ret2 &gt;&gt; 16;

            $ret1 += $x1 + $c;
            $c = $ret1 &gt;&gt; 16;

            $ret0 += $x0 + $c;

            $ret0 &amp;= 0xffff;
            $ret1 &amp;= 0xffff;
            $ret2 &amp;= 0xffff;
            $ret3 &amp;= 0xffff;

            $a3 = $a3 &lt;&lt; 1;
            $x3 = $a3 &gt;&gt; 16;
            $a2 = ($a2 &lt;&lt; 1) | $x3;
            $x2 = $a2 &gt;&gt; 16;
            $a1 = ($a1 &lt;&lt; 1) | $x2;
            $x1 = $a1 &gt;&gt; 16;
            $a0 = ($a0 &lt;&lt; 1) | $x1;
            $a0 &amp;= 0xffff;
            $a1 &amp;= 0xffff;
            $a2 &amp;= 0xffff;
            $a3 &amp;= 0xffff;

            $x0 = ($b0 &amp; 1) &lt;&lt; 16;
            $x1 = ($b1 &amp; 1) &lt;&lt; 16;
            $x2 = ($b2 &amp; 1) &lt;&lt; 16;

            $b0 = ($b0 &gt;&gt; 1);
            $b1 = (($b1 | $x0) &gt;&gt; 1);
            $b2 = (($b2 | $x1) &gt;&gt; 1);
            $b3 = (($b3 | $x2) &gt;&gt; 1);

            $b0 &amp;= 0xffff;
            $b1 &amp;= 0xffff;
            $b2 &amp;= 0xffff;
            $b3 &amp;= 0xffff;

        }
        $return-&gt;limbs[0] = $ret0;
        $return-&gt;limbs[1] = $ret1;
        $return-&gt;limbs[2] = $ret2;
        $return-&gt;limbs[3] = $ret3;

        return $return;
    }

    /**
     * OR this 64-bit integer with another.
     *
     * @param ParagonIE_Sodium_Core32_Int64 $b
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function orInt64(ParagonIE_Sodium_Core32_Int64 $b)
    {
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $return-&gt;limbs = array(
            (int) ($this-&gt;limbs[0] | $b-&gt;limbs[0]),
            (int) ($this-&gt;limbs[1] | $b-&gt;limbs[1]),
            (int) ($this-&gt;limbs[2] | $b-&gt;limbs[2]),
            (int) ($this-&gt;limbs[3] | $b-&gt;limbs[3])
        );
        return $return;
    }

    /**
     * @param int $c
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     * @psalm-suppress MixedArrayAccess
     */
    public function rotateLeft($c = 0)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
        /** @var int $c */
        $c = (int) $c;

        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $c &amp;= 63;
        if ($c === 0) {
            // NOP, but we want a copy.
            $return-&gt;limbs = $this-&gt;limbs;
        } else {
            /** @var array&lt;int, int&gt; $limbs */
            $limbs =&amp; $return-&gt;limbs;

            /** @var array&lt;int, int&gt; $myLimbs */
            $myLimbs =&amp; $this-&gt;limbs;

            /** @var int $idx_shift */
            $idx_shift = ($c &gt;&gt; 4) &amp; 3;
            /** @var int $sub_shift */
            $sub_shift = $c &amp; 15;

            for ($i = 3; $i &gt;= 0; --$i) {
                /** @var int $j */
                $j = ($i + $idx_shift) &amp; 3;
                /** @var int $k */
                $k = ($i + $idx_shift + 1) &amp; 3;
                $limbs[$i] = (int) (
                    (
                        ((int) ($myLimbs[$j]) &lt;&lt; $sub_shift)
                            |
                        ((int) ($myLimbs[$k]) &gt;&gt; (16 - $sub_shift))
                    ) &amp; 0xffff
                );
            }
        }
        return $return;
    }

    /**
     * Rotate to the right
     *
     * @param int $c
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     * @psalm-suppress MixedArrayAccess
     */
    public function rotateRight($c = 0)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
        /** @var int $c */
        $c = (int) $c;

        /** @var ParagonIE_Sodium_Core32_Int64 $return */
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $c &amp;= 63;
        /** @var int $c */
        if ($c === 0) {
            // NOP, but we want a copy.
            $return-&gt;limbs = $this-&gt;limbs;
        } else {
            /** @var array&lt;int, int&gt; $limbs */
            $limbs =&amp; $return-&gt;limbs;

            /** @var array&lt;int, int&gt; $myLimbs */
            $myLimbs =&amp; $this-&gt;limbs;

            /** @var int $idx_shift */
            $idx_shift = ($c &gt;&gt; 4) &amp; 3;
            /** @var int $sub_shift */
            $sub_shift = $c &amp; 15;

            for ($i = 3; $i &gt;= 0; --$i) {
                /** @var int $j */
                $j = ($i - $idx_shift) &amp; 3;
                /** @var int $k */
                $k = ($i - $idx_shift - 1) &amp; 3;
                $limbs[$i] = (int) (
                    (
                        ((int) ($myLimbs[$j]) &gt;&gt; (int) ($sub_shift))
                            |
                        ((int) ($myLimbs[$k]) &lt;&lt; (16 - (int) ($sub_shift)))
                    ) &amp; 0xffff
                );
            }
        }
        return $return;
    }
    /**
     * @param int $c
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     */
    public function shiftLeft($c = 0)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
        /** @var int $c */
        $c = (int) $c;

        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $c &amp;= 63;

        if ($c &gt;= 16) {
            if ($c &gt;= 48) {
                $return-&gt;limbs = array(
                    $this-&gt;limbs[3], 0, 0, 0
                );
            } elseif ($c &gt;= 32) {
                $return-&gt;limbs = array(
                    $this-&gt;limbs[2], $this-&gt;limbs[3], 0, 0
                );
            } else {
                $return-&gt;limbs = array(
                    $this-&gt;limbs[1], $this-&gt;limbs[2], $this-&gt;limbs[3], 0
                );
            }
            return $return-&gt;shiftLeft($c &amp; 15);
        }
        if ($c === 0) {
            $return-&gt;limbs = $this-&gt;limbs;
        } elseif ($c &lt; 0) {
            /** @var int $c */
            return $this-&gt;shiftRight(-$c);
        } else {
            if (!is_int($c)) {
                throw new TypeError();
            }
            /** @var int $carry */
            $carry = 0;
            for ($i = 3; $i &gt;= 0; --$i) {
                /** @var int $tmp */
                $tmp = ($this-&gt;limbs[$i] &lt;&lt; $c) | ($carry &amp; 0xffff);
                $return-&gt;limbs[$i] = (int) ($tmp &amp; 0xffff);
                /** @var int $carry */
                $carry = $tmp &gt;&gt; 16;
            }
        }
        return $return;
    }

    /**
     * @param int $c
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     */
    public function shiftRight($c = 0)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);
        $c = (int) $c;
        /** @var int $c */
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $c &amp;= 63;

        $negative = -(($this-&gt;limbs[0] &gt;&gt; 15) &amp; 1);
        if ($c &gt;= 16) {
            if ($c &gt;= 48) {
                $return-&gt;limbs = array(
                    (int) ($negative &amp; 0xffff),
                    (int) ($negative &amp; 0xffff),
                    (int) ($negative &amp; 0xffff),
                    (int) $this-&gt;limbs[0]
                );
            } elseif ($c &gt;= 32) {
                $return-&gt;limbs = array(
                    (int) ($negative &amp; 0xffff),
                    (int) ($negative &amp; 0xffff),
                    (int) $this-&gt;limbs[0],
                    (int) $this-&gt;limbs[1]
                );
            } else {
                $return-&gt;limbs = array(
                    (int) ($negative &amp; 0xffff),
                    (int) $this-&gt;limbs[0],
                    (int) $this-&gt;limbs[1],
                    (int) $this-&gt;limbs[2]
                );
            }
            return $return-&gt;shiftRight($c &amp; 15);
        }

        if ($c === 0) {
            $return-&gt;limbs = $this-&gt;limbs;
        } elseif ($c &lt; 0) {
            return $this-&gt;shiftLeft(-$c);
        } else {
            if (!is_int($c)) {
                throw new TypeError();
            }
            /** @var int $carryRight */
            $carryRight = ($negative &amp; 0xffff);
            $mask = (int) (((1 &lt;&lt; ($c + 1)) - 1) &amp; 0xffff);
            for ($i = 0; $i &lt; 4; ++$i) {
                $return-&gt;limbs[$i] = (int) (
                    (($this-&gt;limbs[$i] &gt;&gt; $c) | ($carryRight &lt;&lt; (16 - $c))) &amp; 0xffff
                );
                $carryRight = (int) ($this-&gt;limbs[$i] &amp; $mask);
            }
        }
        return $return;
    }


    /**
     * Subtract a normal integer from an int64 object.
     *
     * @param int $int
     * @return ParagonIE_Sodium_Core32_Int64
     * @throws SodiumException
     * @throws TypeError
     */
    public function subInt($int)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);
        $int = (int) $int;

        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;

        /** @var int $carry */
        $carry = 0;
        for ($i = 3; $i &gt;= 0; --$i) {
            /** @var int $tmp */
            $tmp = $this-&gt;limbs[$i] - (($int &gt;&gt; 16) &amp; 0xffff) + $carry;
            /** @var int $carry */
            $carry = $tmp &gt;&gt; 16;
            $return-&gt;limbs[$i] = (int) ($tmp &amp; 0xffff);
        }
        return $return;
    }

    /**
     * The difference between two Int64 objects.
     *
     * @param ParagonIE_Sodium_Core32_Int64 $b
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function subInt64(ParagonIE_Sodium_Core32_Int64 $b)
    {
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        /** @var int $carry */
        $carry = 0;
        for ($i = 3; $i &gt;= 0; --$i) {
            /** @var int $tmp */
            $tmp = $this-&gt;limbs[$i] - $b-&gt;limbs[$i] + $carry;
            /** @var int $carry */
            $carry = ($tmp &gt;&gt; 16);
            $return-&gt;limbs[$i] = (int) ($tmp &amp; 0xffff);
        }
        return $return;
    }

    /**
     * XOR this 64-bit integer with another.
     *
     * @param ParagonIE_Sodium_Core32_Int64 $b
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function xorInt64(ParagonIE_Sodium_Core32_Int64 $b)
    {
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $return-&gt;limbs = array(
            (int) ($this-&gt;limbs[0] ^ $b-&gt;limbs[0]),
            (int) ($this-&gt;limbs[1] ^ $b-&gt;limbs[1]),
            (int) ($this-&gt;limbs[2] ^ $b-&gt;limbs[2]),
            (int) ($this-&gt;limbs[3] ^ $b-&gt;limbs[3])
        );
        return $return;
    }

    /**
     * @param int $low
     * @param int $high
     * @return self
     * @throws SodiumException
     * @throws TypeError
     */
    public static function fromInts($low, $high)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($low, 'int', 1);
        ParagonIE_Sodium_Core32_Util::declareScalarType($high, 'int', 2);

        $high = (int) $high;
        $low = (int) $low;
        return new ParagonIE_Sodium_Core32_Int64(
            array(
                (int) (($high &gt;&gt; 16) &amp; 0xffff),
                (int) ($high &amp; 0xffff),
                (int) (($low &gt;&gt; 16) &amp; 0xffff),
                (int) ($low &amp; 0xffff)
            )
        );
    }

    /**
     * @param int $low
     * @return self
     * @throws SodiumException
     * @throws TypeError
     */
    public static function fromInt($low)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($low, 'int', 1);
        $low = (int) $low;

        return new ParagonIE_Sodium_Core32_Int64(
            array(
                0,
                0,
                (int) (($low &gt;&gt; 16) &amp; 0xffff),
                (int) ($low &amp; 0xffff)
            )
        );
    }

    /**
     * @return int
     */
    public function toInt()
    {
        return (int) (
            (($this-&gt;limbs[2] &amp; 0xffff) &lt;&lt; 16)
                |
            ($this-&gt;limbs[3] &amp; 0xffff)
        );
    }

    /**
     * @param string $string
     * @return self
     * @throws SodiumException
     * @throws TypeError
     */
    public static function fromString($string)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
        $string = (string) $string;
        if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 8) {
            throw new RangeException(
                'String must be 8 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
            );
        }
        $return = new ParagonIE_Sodium_Core32_Int64();

        $return-&gt;limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) &amp; 0xff);
        $return-&gt;limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) &amp; 0xff);
        $return-&gt;limbs[2]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[4]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[2] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[5]) &amp; 0xff);
        $return-&gt;limbs[3]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[6]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[3] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[7]) &amp; 0xff);
        return $return;
    }

    /**
     * @param string $string
     * @return self
     * @throws SodiumException
     * @throws TypeError
     */
    public static function fromReverseString($string)
    {
        ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);
        $string = (string) $string;
        if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 8) {
            throw new RangeException(
                'String must be 8 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'
            );
        }
        $return = new ParagonIE_Sodium_Core32_Int64();

        $return-&gt;limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[7]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[6]) &amp; 0xff);
        $return-&gt;limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[5]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[4]) &amp; 0xff);
        $return-&gt;limbs[2]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[2] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) &amp; 0xff);
        $return-&gt;limbs[3]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) &amp; 0xff) &lt;&lt; 8);
        $return-&gt;limbs[3] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) &amp; 0xff);
        return $return;
    }

    /**
     * @return array&lt;int, int&gt;
     */
    public function toArray()
    {
        return array(
            (int) ((($this-&gt;limbs[0] &amp; 0xffff) &lt;&lt; 16) | ($this-&gt;limbs[1] &amp; 0xffff)),
            (int) ((($this-&gt;limbs[2] &amp; 0xffff) &lt;&lt; 16) | ($this-&gt;limbs[3] &amp; 0xffff))
        );
    }

    /**
     * @return ParagonIE_Sodium_Core32_Int32
     */
    public function toInt32()
    {
        $return = new ParagonIE_Sodium_Core32_Int32();
        $return-&gt;limbs[0] = (int) ($this-&gt;limbs[2]);
        $return-&gt;limbs[1] = (int) ($this-&gt;limbs[3]);
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $return-&gt;overflow = (int) (ParagonIE_Sodium_Core32_Util::abs($this-&gt;limbs[1], 16) &amp; 0xffff);
        return $return;
    }

    /**
     * @return ParagonIE_Sodium_Core32_Int64
     */
    public function toInt64()
    {
        $return = new ParagonIE_Sodium_Core32_Int64();
        $return-&gt;limbs[0] = (int) ($this-&gt;limbs[0]);
        $return-&gt;limbs[1] = (int) ($this-&gt;limbs[1]);
        $return-&gt;limbs[2] = (int) ($this-&gt;limbs[2]);
        $return-&gt;limbs[3] = (int) ($this-&gt;limbs[3]);
        $return-&gt;unsignedInt = $this-&gt;unsignedInt;
        $return-&gt;overflow = ParagonIE_Sodium_Core32_Util::abs($this-&gt;overflow);
        return $return;
    }

    /**
     * @param bool $bool
     * @return self
     */
    public function setUnsignedInt($bool = false)
    {
        $this-&gt;unsignedInt = !empty($bool);
        return $this;
    }

    /**
     * @return string
     * @throws TypeError
     */
    public function toString()
    {
        return ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[0] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[0] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[1] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[1] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[2] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[2] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[3] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[3] &amp; 0xff);
    }

    /**
     * @return string
     * @throws TypeError
     */
    public function toReverseString()
    {
        return ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[3] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[3] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[2] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[2] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[1] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[1] &gt;&gt; 8) &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr($this-&gt;limbs[0] &amp; 0xff) .
            ParagonIE_Sodium_Core32_Util::intToChr(($this-&gt;limbs[0] &gt;&gt; 8) &amp; 0xff);
    }

    /**
     * @return string
     */
    public function __toString()
    {
        try {
            return $this-&gt;toString();
        } catch (TypeError $ex) {
            // PHP engine can't handle exceptions from __toString()
            return '';
        }
    }
}
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fhome%2Fu256179654%2Fdomains%2Ffilingmonk.in%2Fpublic_html%2Fwp-includes%2Fsodium_compat%2Fsrc%2FCore32' class='btn'>Cancel</a>
        </form>