1 <?php

     2 

     3 /**

     4  * Class ParagonIE_Sodium_Core32_Int64

     5  *

     6  * Encapsulates a 64-bit integer.

     7  *

     8  * These are immutable. It always returns a new instance.

     9  */

    10 class ParagonIE_Sodium_Core32_Int64

    11 {

    12     /**

    13      * @var array<int, int> - four 16-bit integers

    14      */

    15     public $limbs = array(0, 0, 0, 0);

    16 

    17     /**

    18      * @var int

    19      */

    20     public $overflow = 0;

    21 

    22     /**

    23      * @var bool

    24      */

    25     public $unsignedInt = false;

    26 

    27     /**

    28      * ParagonIE_Sodium_Core32_Int64 constructor.

    29      * @param array $array

    30      * @param bool $unsignedInt

    31      */

    32     public function __construct($array = array(0, 0, 0, 0), $unsignedInt = false)

    33     {

    34         $this->limbs = array(

    35             (int) $array[0],

    36             (int) $array[1],

    37             (int) $array[2],

    38             (int) $array[3]

    39         );

    40         $this->overflow = 0;

    41         $this->unsignedInt = $unsignedInt;

    42     }

    43 

    44     /**

    45      * Adds two int64 objects

    46      *

    47      * @param ParagonIE_Sodium_Core32_Int64 $addend

    48      * @return ParagonIE_Sodium_Core32_Int64

    49      */

    50     public function addInt64(ParagonIE_Sodium_Core32_Int64 $addend)

    51     {

    52         $i0 = $this->limbs[0];

    53         $i1 = $this->limbs[1];

    54         $i2 = $this->limbs[2];

    55         $i3 = $this->limbs[3];

    56         $j0 = $addend->limbs[0];

    57         $j1 = $addend->limbs[1];

    58         $j2 = $addend->limbs[2];

    59         $j3 = $addend->limbs[3];

    60 

    61         $r3 = $i3 + ($j3 & 0xffff);

    62         $carry = $r3 >> 16;

    63 

    64         $r2 = $i2 + ($j2 & 0xffff) + $carry;

    65         $carry = $r2 >> 16;

    66 

    67         $r1 = $i1 + ($j1 & 0xffff) + $carry;

    68         $carry = $r1 >> 16;

    69 

    70         $r0 = $i0 + ($j0 & 0xffff) + $carry;

    71         $carry = $r0 >> 16;

    72 

    73         $r0 &= 0xffff;

    74         $r1 &= 0xffff;

    75         $r2 &= 0xffff;

    76         $r3 &= 0xffff;

    77 

    78         $return = new ParagonIE_Sodium_Core32_Int64(

    79             array($r0, $r1, $r2, $r3)

    80         );

    81         $return->overflow = $carry;

    82         $return->unsignedInt = $this->unsignedInt;

    83         return $return;

    84     }

    85 

    86     /**

    87      * Adds a normal integer to an int64 object

    88      *

    89      * @param int $int

    90      * @return ParagonIE_Sodium_Core32_Int64

    91      * @throws SodiumException

    92      * @throws TypeError

    93      */

    94     public function addInt($int)

    95     {

    96         ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);

    97         /** @var int $int */

    98         $int = (int) $int;

    99 

   100         $i0 = $this->limbs[0];

   101         $i1 = $this->limbs[1];

   102         $i2 = $this->limbs[2];

   103         $i3 = $this->limbs[3];

   104 

   105         $r3 = $i3 + ($int & 0xffff);

   106         $carry = $r3 >> 16;

   107 

   108         $r2 = $i2 + (($int >> 16) & 0xffff) + $carry;

   109         $carry = $r2 >> 16;

   110 

   111         $r1 = $i1 + $carry;

   112         $carry = $r1 >> 16;

   113 

   114         $r0 = $i0 + $carry;

   115         $carry = $r0 >> 16;

   116 

   117         $r0 &= 0xffff;

   118         $r1 &= 0xffff;

   119         $r2 &= 0xffff;

   120         $r3 &= 0xffff;

   121         $return = new ParagonIE_Sodium_Core32_Int64(

   122             array($r0, $r1, $r2, $r3)

   123         );

   124         $return->overflow = $carry;

   125         $return->unsignedInt = $this->unsignedInt;

   126         return $return;

   127     }

   128 

   129     /**

   130      * @param int $b

   131      * @return int

   132      */

   133     public function compareInt($b = 0)

   134     {

   135         $gt = 0;

   136         $eq = 1;

   137 

   138         $i = 4;

   139         $j = 0;

   140         while ($i > 0) {

   141             --$i;

   142             /** @var int $x1 */

   143             $x1 = $this->limbs[$i];

   144             /** @var int $x2 */

   145             $x2 = ($b >> ($j << 4)) & 0xffff;

   146             /** int */

   147             $gt |= (($x2 - $x1) >> 8) & $eq;

   148             /** int */

   149             $eq &= (($x2 ^ $x1) - 1) >> 8;

   150         }

   151         return ($gt + $gt - $eq) + 1;

   152     }

   153 

   154     /**

   155      * @param int $b

   156      * @return bool

   157      */

   158     public function isGreaterThan($b = 0)

   159     {

   160         return $this->compareInt($b) > 0;

   161     }

   162 

   163     /**

   164      * @param int $b

   165      * @return bool

   166      */

   167     public function isLessThanInt($b = 0)

   168     {

   169         return $this->compareInt($b) < 0;

   170     }

   171 

   172     /**

   173      * @param int $hi

   174      * @param int $lo

   175      * @return ParagonIE_Sodium_Core32_Int64

   176      */

   177     public function mask64($hi = 0, $lo = 0)

   178     {

   179         /** @var int $a */

   180         $a = ($hi >> 16) & 0xffff;

   181         /** @var int $b */

   182         $b = ($hi) & 0xffff;

   183         /** @var int $c */

   184         $c = ($lo >> 16) & 0xffff;

   185         /** @var int $d */

   186         $d = ($lo & 0xffff);

   187         return new ParagonIE_Sodium_Core32_Int64(

   188             array(

   189                 $this->limbs[0] & $a,

   190                 $this->limbs[1] & $b,

   191                 $this->limbs[2] & $c,

   192                 $this->limbs[3] & $d

   193             ),

   194             $this->unsignedInt

   195         );

   196     }

   197 

   198     /**

   199      * @param int $int

   200      * @param int $size

   201      * @return ParagonIE_Sodium_Core32_Int64

   202      * @throws SodiumException

   203      * @throws TypeError

   204      * @psalm-suppress MixedAssignment

   205      */

   206     public function mulInt($int = 0, $size = 0)

   207     {

   208         if (ParagonIE_Sodium_Compat::$fastMult) {

   209             return $this->mulIntFast($int);

   210         }

   211         ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);

   212         ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);

   213         /** @var int $int */

   214         $int = (int) $int;

   215         /** @var int $size */

   216         $size = (int) $size;

   217 

   218         if (!$size) {

   219             $size = 63;

   220         }

   221 

   222         $a = clone $this;

   223         $return = new ParagonIE_Sodium_Core32_Int64();

   224         $return->unsignedInt = $this->unsignedInt;

   225 

   226         // Initialize:

   227         $ret0 = 0;

   228         $ret1 = 0;

   229         $ret2 = 0;

   230         $ret3 = 0;

   231         $a0 = $a->limbs[0];

   232         $a1 = $a->limbs[1];

   233         $a2 = $a->limbs[2];

   234         $a3 = $a->limbs[3];

   235 

   236         /** @var int $size */

   237         /** @var int $i */

   238         for ($i = $size; $i >= 0; --$i) {

   239             $mask = -($int & 1);

   240             $x0 = $a0 & $mask;

   241             $x1 = $a1 & $mask;

   242             $x2 = $a2 & $mask;

   243             $x3 = $a3 & $mask;

   244 

   245             $ret3 += $x3;

   246             $c = $ret3 >> 16;

   247 

   248             $ret2 += $x2 + $c;

   249             $c = $ret2 >> 16;

   250 

   251             $ret1 += $x1 + $c;

   252             $c = $ret1 >> 16;

   253 

   254             $ret0 += $x0 + $c;

   255 

   256             $ret0 &= 0xffff;

   257             $ret1 &= 0xffff;

   258             $ret2 &= 0xffff;

   259             $ret3 &= 0xffff;

   260 

   261             $a3 = $a3 << 1;

   262             $x3 = $a3 >> 16;

   263             $a2 = ($a2 << 1) | $x3;

   264             $x2 = $a2 >> 16;

   265             $a1 = ($a1 << 1) | $x2;

   266             $x1 = $a1 >> 16;

   267             $a0 = ($a0 << 1) | $x1;

   268             $a0 &= 0xffff;

   269             $a1 &= 0xffff;

   270             $a2 &= 0xffff;

   271             $a3 &= 0xffff;

   272 

   273             $int >>= 1;

   274         }

   275         $return->limbs[0] = $ret0;

   276         $return->limbs[1] = $ret1;

   277         $return->limbs[2] = $ret2;

   278         $return->limbs[3] = $ret3;

   279         return $return;

   280     }

   281 

   282     /**

   283      * @param ParagonIE_Sodium_Core32_Int64 $A

   284      * @param ParagonIE_Sodium_Core32_Int64 $B

   285      * @return array<int, ParagonIE_Sodium_Core32_Int64>

   286      * @throws SodiumException

   287      * @throws TypeError

   288      * @psalm-suppress MixedInferredReturnType

   289      */

   290     public static function ctSelect(

   291         ParagonIE_Sodium_Core32_Int64 $A,

   292         ParagonIE_Sodium_Core32_Int64 $B

   293     ) {

   294         $a = clone $A;

   295         $b = clone $B;

   296         /** @var int $aNeg */

   297         $aNeg = ($a->limbs[0] >> 15) & 1;

   298         /** @var int $bNeg */

   299         $bNeg = ($b->limbs[0] >> 15) & 1;

   300         /** @var int $m */

   301         $m = (-($aNeg & $bNeg)) | 1;

   302         /** @var int $swap */

   303         $swap = $bNeg & ~$aNeg;

   304         /** @var int $d */

   305         $d = -$swap;

   306 

   307         /*

   308         if ($bNeg && !$aNeg) {

   309             $a = clone $int;

   310             $b = clone $this;

   311         } elseif($bNeg && $aNeg) {

   312             $a = $this->mulInt(-1);

   313             $b = $int->mulInt(-1);

   314         }

   315          */

   316         $x = $a->xorInt64($b)->mask64($d, $d);

   317         return array(

   318             $a->xorInt64($x)->mulInt($m),

   319             $b->xorInt64($x)->mulInt($m)

   320         );

   321     }

   322 

   323     /**

   324      * @param array<int, int> $a

   325      * @param array<int, int> $b

   326      * @param int $baseLog2

   327      * @return array<int, int>

   328      */

   329     public function multiplyLong(array $a, array $b, $baseLog2 = 16)

   330     {

   331         $a_l = count($a);

   332         $b_l = count($b);

   333         /** @var array<int, int> $r */

   334         $r = array_fill(0, $a_l + $b_l + 1, 0);

   335         $base = 1 << $baseLog2;

   336         for ($i = 0; $i < $a_l; ++$i) {

   337             $a_i = $a[$i];

   338             for ($j = 0; $j < $a_l; ++$j) {

   339                 $b_j = $b[$j];

   340                 $product = ($a_i * $b_j) + $r[$i + $j];

   341                 $carry = ($product >> $baseLog2 & 0xffff);

   342                 $r[$i + $j] = ($product - (int) ($carry * $base)) & 0xffff;

   343                 $r[$i + $j + 1] += $carry;

   344             }

   345         }

   346         return array_slice($r, 0, 5);

   347     }

   348 

   349     /**

   350      * @param int $int

   351      * @return ParagonIE_Sodium_Core32_Int64

   352      */

   353     public function mulIntFast($int)

   354     {

   355         // Handle negative numbers

   356         $aNeg = ($this->limbs[0] >> 15) & 1;

   357         $bNeg = ($int >> 31) & 1;

   358         $a = array_reverse($this->limbs);

   359         $b = array(

   360             $int & 0xffff,

   361             ($int >> 16) & 0xffff,

   362             -$bNeg & 0xffff,

   363             -$bNeg & 0xffff

   364         );

   365         if ($aNeg) {

   366             for ($i = 0; $i < 4; ++$i) {

   367                 $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;

   368             }

   369             ++$a[0];

   370         }

   371         if ($bNeg) {

   372             for ($i = 0; $i < 4; ++$i) {

   373                 $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;

   374             }

   375             ++$b[0];

   376         }

   377         // Multiply

   378         $res = $this->multiplyLong($a, $b);

   379 

   380         // Re-apply negation to results

   381         if ($aNeg !== $bNeg) {

   382             for ($i = 0; $i < 4; ++$i) {

   383                 $res[$i] = (0xffff ^ $res[$i]) & 0xffff;

   384             }

   385             // Handle integer overflow

   386             $c = 1;

   387             for ($i = 0; $i < 4; ++$i) {

   388                 $res[$i] += $c;

   389                 $c = $res[$i] >> 16;

   390                 $res[$i] &= 0xffff;

   391             }

   392         }

   393 

   394         // Return our values

   395         $return = new ParagonIE_Sodium_Core32_Int64();

   396         $return->limbs = array(

   397             $res[3] & 0xffff,

   398             $res[2] & 0xffff,

   399             $res[1] & 0xffff,

   400             $res[0] & 0xffff

   401         );

   402         if (count($res) > 4) {

   403             $return->overflow = $res[4] & 0xffff;

   404         }

   405         $return->unsignedInt = $this->unsignedInt;

   406         return $return;

   407     }

   408 

   409     /**

   410      * @param ParagonIE_Sodium_Core32_Int64 $right

   411      * @return ParagonIE_Sodium_Core32_Int64

   412      */

   413     public function mulInt64Fast(ParagonIE_Sodium_Core32_Int64 $right)

   414     {

   415         $aNeg = ($this->limbs[0] >> 15) & 1;

   416         $bNeg = ($right->limbs[0] >> 15) & 1;

   417 

   418         $a = array_reverse($this->limbs);

   419         $b = array_reverse($right->limbs);

   420         if ($aNeg) {

   421             for ($i = 0; $i < 4; ++$i) {

   422                 $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;

   423             }

   424             ++$a[0];

   425         }

   426         if ($bNeg) {

   427             for ($i = 0; $i < 4; ++$i) {

   428                 $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;

   429             }

   430             ++$b[0];

   431         }

   432         $res = $this->multiplyLong($a, $b);

   433         if ($aNeg !== $bNeg) {

   434             if ($aNeg !== $bNeg) {

   435                 for ($i = 0; $i < 4; ++$i) {

   436                     $res[$i] = ($res[$i] ^ 0xffff) & 0xffff;

   437                 }

   438                 $c = 1;

   439                 for ($i = 0; $i < 4; ++$i) {

   440                     $res[$i] += $c;

   441                     $c = $res[$i] >> 16;

   442                     $res[$i] &= 0xffff;

   443                 }

   444             }

   445         }

   446         $return = new ParagonIE_Sodium_Core32_Int64();

   447         $return->limbs = array(

   448             $res[3] & 0xffff,

   449             $res[2] & 0xffff,

   450             $res[1] & 0xffff,

   451             $res[0] & 0xffff

   452         );

   453         if (count($res) > 4) {

   454             $return->overflow = $res[4];

   455         }

   456         return $return;

   457     }

   458 

   459     /**

   460      * @param ParagonIE_Sodium_Core32_Int64 $int

   461      * @param int $size

   462      * @return ParagonIE_Sodium_Core32_Int64

   463      * @throws SodiumException

   464      * @throws TypeError

   465      * @psalm-suppress MixedAssignment

   466      */

   467     public function mulInt64(ParagonIE_Sodium_Core32_Int64 $int, $size = 0)

   468     {

   469         if (ParagonIE_Sodium_Compat::$fastMult) {

   470             return $this->mulInt64Fast($int);

   471         }

   472         ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);

   473         if (!$size) {

   474             $size = 63;

   475         }

   476         list($a, $b) = self::ctSelect($this, $int);

   477 

   478         $return = new ParagonIE_Sodium_Core32_Int64();

   479         $return->unsignedInt = $this->unsignedInt;

   480 

   481         // Initialize:

   482         $ret0 = 0;

   483         $ret1 = 0;

   484         $ret2 = 0;

   485         $ret3 = 0;

   486         $a0 = $a->limbs[0];

   487         $a1 = $a->limbs[1];

   488         $a2 = $a->limbs[2];

   489         $a3 = $a->limbs[3];

   490         $b0 = $b->limbs[0];

   491         $b1 = $b->limbs[1];

   492         $b2 = $b->limbs[2];

   493         $b3 = $b->limbs[3];

   494 

   495         /** @var int $size */

   496         /** @var int $i */

   497         for ($i = (int) $size; $i >= 0; --$i) {

   498             $mask = -($b3 & 1);

   499             $x0 = $a0 & $mask;

   500             $x1 = $a1 & $mask;

   501             $x2 = $a2 & $mask;

   502             $x3 = $a3 & $mask;

   503 

   504             $ret3 += $x3;

   505             $c = $ret3 >> 16;

   506 

   507             $ret2 += $x2 + $c;

   508             $c = $ret2 >> 16;

   509 

   510             $ret1 += $x1 + $c;

   511             $c = $ret1 >> 16;

   512 

   513             $ret0 += $x0 + $c;

   514 

   515             $ret0 &= 0xffff;

   516             $ret1 &= 0xffff;

   517             $ret2 &= 0xffff;

   518             $ret3 &= 0xffff;

   519 

   520             $a3 = $a3 << 1;

   521             $x3 = $a3 >> 16;

   522             $a2 = ($a2 << 1) | $x3;

   523             $x2 = $a2 >> 16;

   524             $a1 = ($a1 << 1) | $x2;

   525             $x1 = $a1 >> 16;

   526             $a0 = ($a0 << 1) | $x1;

   527             $a0 &= 0xffff;

   528             $a1 &= 0xffff;

   529             $a2 &= 0xffff;

   530             $a3 &= 0xffff;

   531 

   532             $x0 = ($b0 & 1) << 16;

   533             $x1 = ($b1 & 1) << 16;

   534             $x2 = ($b2 & 1) << 16;

   535 

   536             $b0 = ($b0 >> 1);

   537             $b1 = (($b1 | $x0) >> 1);

   538             $b2 = (($b2 | $x1) >> 1);

   539             $b3 = (($b3 | $x2) >> 1);

   540 

   541             $b0 &= 0xffff;

   542             $b1 &= 0xffff;

   543             $b2 &= 0xffff;

   544             $b3 &= 0xffff;

   545 

   546         }

   547         $return->limbs[0] = $ret0;

   548         $return->limbs[1] = $ret1;

   549         $return->limbs[2] = $ret2;

   550         $return->limbs[3] = $ret3;

   551 

   552         return $return;

   553     }

   554 

   555     /**

   556      * OR this 64-bit integer with another.

   557      *

   558      * @param ParagonIE_Sodium_Core32_Int64 $b

   559      * @return ParagonIE_Sodium_Core32_Int64

   560      */

   561     public function orInt64(ParagonIE_Sodium_Core32_Int64 $b)

   562     {

   563         $return = new ParagonIE_Sodium_Core32_Int64();

   564         $return->unsignedInt = $this->unsignedInt;

   565         $return->limbs = array(

   566             (int) ($this->limbs[0] | $b->limbs[0]),

   567             (int) ($this->limbs[1] | $b->limbs[1]),

   568             (int) ($this->limbs[2] | $b->limbs[2]),

   569             (int) ($this->limbs[3] | $b->limbs[3])

   570         );

   571         return $return;

   572     }

   573 

   574     /**

   575      * @param int $c

   576      * @return ParagonIE_Sodium_Core32_Int64

   577      * @throws SodiumException

   578      * @throws TypeError

   579      * @psalm-suppress MixedArrayAccess

   580      */

   581     public function rotateLeft($c = 0)

   582     {

   583         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);

   584         /** @var int $c */

   585         $c = (int) $c;

   586 

   587         $return = new ParagonIE_Sodium_Core32_Int64();

   588         $return->unsignedInt = $this->unsignedInt;

   589         $c &= 63;

   590         if ($c === 0) {

   591             // NOP, but we want a copy.

   592             $return->limbs = $this->limbs;

   593         } else {

   594             /** @var array<int, int> $limbs */

   595             $limbs =& $return->limbs;

   596 

   597             /** @var array<int, int> $myLimbs */

   598             $myLimbs =& $this->limbs;

   599 

   600             /** @var int $idx_shift */

   601             $idx_shift = ($c >> 4) & 3;

   602             /** @var int $sub_shift */

   603             $sub_shift = $c & 15;

   604 

   605             for ($i = 3; $i >= 0; --$i) {

   606                 /** @var int $j */

   607                 $j = ($i + $idx_shift) & 3;

   608                 /** @var int $k */

   609                 $k = ($i + $idx_shift + 1) & 3;

   610                 $limbs[$i] = (int) (

   611                     (

   612                         ((int) ($myLimbs[$j]) << $sub_shift)

   613                             |

   614                         ((int) ($myLimbs[$k]) >> (16 - $sub_shift))

   615                     ) & 0xffff

   616                 );

   617             }

   618         }

   619         return $return;

   620     }

   621 

   622     /**

   623      * Rotate to the right

   624      *

   625      * @param int $c

   626      * @return ParagonIE_Sodium_Core32_Int64

   627      * @throws SodiumException

   628      * @throws TypeError

   629      * @psalm-suppress MixedArrayAccess

   630      */

   631     public function rotateRight($c = 0)

   632     {

   633         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);

   634         /** @var int $c */

   635         $c = (int) $c;

   636 

   637         /** @var ParagonIE_Sodium_Core32_Int64 $return */

   638         $return = new ParagonIE_Sodium_Core32_Int64();

   639         $return->unsignedInt = $this->unsignedInt;

   640         $c &= 63;

   641         /** @var int $c */

   642         if ($c === 0) {

   643             // NOP, but we want a copy.

   644             $return->limbs = $this->limbs;

   645         } else {

   646             /** @var array<int, int> $limbs */

   647             $limbs =& $return->limbs;

   648 

   649             /** @var array<int, int> $myLimbs */

   650             $myLimbs =& $this->limbs;

   651 

   652             /** @var int $idx_shift */

   653             $idx_shift = ($c >> 4) & 3;

   654             /** @var int $sub_shift */

   655             $sub_shift = $c & 15;

   656 

   657             for ($i = 3; $i >= 0; --$i) {

   658                 /** @var int $j */

   659                 $j = ($i - $idx_shift) & 3;

   660                 /** @var int $k */

   661                 $k = ($i - $idx_shift - 1) & 3;

   662                 $limbs[$i] = (int) (

   663                     (

   664                         ((int) ($myLimbs[$j]) >> (int) ($sub_shift))

   665                             |

   666                         ((int) ($myLimbs[$k]) << (16 - (int) ($sub_shift)))

   667                     ) & 0xffff

   668                 );

   669             }

   670         }

   671         return $return;

   672     }

   673     /**

   674      * @param int $c

   675      * @return ParagonIE_Sodium_Core32_Int64

   676      * @throws SodiumException

   677      * @throws TypeError

   678      */

   679     public function shiftLeft($c = 0)

   680     {

   681         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);

   682         /** @var int $c */

   683         $c = (int) $c;

   684 

   685         $return = new ParagonIE_Sodium_Core32_Int64();

   686         $return->unsignedInt = $this->unsignedInt;

   687         $c &= 63;

   688 

   689         if ($c >= 16) {

   690             if ($c >= 48) {

   691                 $return->limbs = array(

   692                     $this->limbs[3], 0, 0, 0

   693                 );

   694             } elseif ($c >= 32) {

   695                 $return->limbs = array(

   696                     $this->limbs[2], $this->limbs[3], 0, 0

   697                 );

   698             } else {

   699                 $return->limbs = array(

   700                     $this->limbs[1], $this->limbs[2], $this->limbs[3], 0

   701                 );

   702             }

   703             return $return->shiftLeft($c & 15);

   704         }

   705         if ($c === 0) {

   706             $return->limbs = $this->limbs;

   707         } elseif ($c < 0) {

   708             /** @var int $c */

   709             return $this->shiftRight(-$c);

   710         } else {

   711             if (!is_int($c)) {

   712                 throw new TypeError();

   713             }

   714             /** @var int $carry */

   715             $carry = 0;

   716             for ($i = 3; $i >= 0; --$i) {

   717                 /** @var int $tmp */

   718                 $tmp = ($this->limbs[$i] << $c) | ($carry & 0xffff);

   719                 $return->limbs[$i] = (int) ($tmp & 0xffff);

   720                 /** @var int $carry */

   721                 $carry = $tmp >> 16;

   722             }

   723         }

   724         return $return;

   725     }

   726 

   727     /**

   728      * @param int $c

   729      * @return ParagonIE_Sodium_Core32_Int64

   730      * @throws SodiumException

   731      * @throws TypeError

   732      */

   733     public function shiftRight($c = 0)

   734     {

   735         ParagonIE_Sodium_Core32_Util::declareScalarType($c, 'int', 1);

   736         $c = (int) $c;

   737         /** @var int $c */

   738         $return = new ParagonIE_Sodium_Core32_Int64();

   739         $return->unsignedInt = $this->unsignedInt;

   740         $c &= 63;

   741 

   742         $negative = -(($this->limbs[0] >> 15) & 1);

   743         if ($c >= 16) {

   744             if ($c >= 48) {

   745                 $return->limbs = array(

   746                     (int) ($negative & 0xffff),

   747                     (int) ($negative & 0xffff),

   748                     (int) ($negative & 0xffff),

   749                     (int) $this->limbs[0]

   750                 );

   751             } elseif ($c >= 32) {

   752                 $return->limbs = array(

   753                     (int) ($negative & 0xffff),

   754                     (int) ($negative & 0xffff),

   755                     (int) $this->limbs[0],

   756                     (int) $this->limbs[1]

   757                 );

   758             } else {

   759                 $return->limbs = array(

   760                     (int) ($negative & 0xffff),

   761                     (int) $this->limbs[0],

   762                     (int) $this->limbs[1],

   763                     (int) $this->limbs[2]

   764                 );

   765             }

   766             return $return->shiftRight($c & 15);

   767         }

   768 

   769         if ($c === 0) {

   770             $return->limbs = $this->limbs;

   771         } elseif ($c < 0) {

   772             return $this->shiftLeft(-$c);

   773         } else {

   774             if (!is_int($c)) {

   775                 throw new TypeError();

   776             }

   777             /** @var int $carryRight */

   778             $carryRight = ($negative & 0xffff);

   779             $mask = (int) (((1 << ($c + 1)) - 1) & 0xffff);

   780             for ($i = 0; $i < 4; ++$i) {

   781                 $return->limbs[$i] = (int) (

   782                     (($this->limbs[$i] >> $c) | ($carryRight << (16 - $c))) & 0xffff

   783                 );

   784                 $carryRight = (int) ($this->limbs[$i] & $mask);

   785             }

   786         }

   787         return $return;

   788     }

   789 

   790 

   791     /**

   792      * Subtract a normal integer from an int64 object.

   793      *

   794      * @param int $int

   795      * @return ParagonIE_Sodium_Core32_Int64

   796      * @throws SodiumException

   797      * @throws TypeError

   798      */

   799     public function subInt($int)

   800     {

   801         ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);

   802         $int = (int) $int;

   803 

   804         $return = new ParagonIE_Sodium_Core32_Int64();

   805         $return->unsignedInt = $this->unsignedInt;

   806 

   807         /** @var int $carry */

   808         $carry = 0;

   809         for ($i = 3; $i >= 0; --$i) {

   810             /** @var int $tmp */

   811             $tmp = $this->limbs[$i] - (($int >> 16) & 0xffff) + $carry;

   812             /** @var int $carry */

   813             $carry = $tmp >> 16;

   814             $return->limbs[$i] = (int) ($tmp & 0xffff);

   815         }

   816         return $return;

   817     }

   818 

   819     /**

   820      * The difference between two Int64 objects.

   821      *

   822      * @param ParagonIE_Sodium_Core32_Int64 $b

   823      * @return ParagonIE_Sodium_Core32_Int64

   824      */

   825     public function subInt64(ParagonIE_Sodium_Core32_Int64 $b)

   826     {

   827         $return = new ParagonIE_Sodium_Core32_Int64();

   828         $return->unsignedInt = $this->unsignedInt;

   829         /** @var int $carry */

   830         $carry = 0;

   831         for ($i = 3; $i >= 0; --$i) {

   832             /** @var int $tmp */

   833             $tmp = $this->limbs[$i] - $b->limbs[$i] + $carry;

   834             /** @var int $carry */

   835             $carry = ($tmp >> 16);

   836             $return->limbs[$i] = (int) ($tmp & 0xffff);

   837         }

   838         return $return;

   839     }

   840 

   841     /**

   842      * XOR this 64-bit integer with another.

   843      *

   844      * @param ParagonIE_Sodium_Core32_Int64 $b

   845      * @return ParagonIE_Sodium_Core32_Int64

   846      */

   847     public function xorInt64(ParagonIE_Sodium_Core32_Int64 $b)

   848     {

   849         $return = new ParagonIE_Sodium_Core32_Int64();

   850         $return->unsignedInt = $this->unsignedInt;

   851         $return->limbs = array(

   852             (int) ($this->limbs[0] ^ $b->limbs[0]),

   853             (int) ($this->limbs[1] ^ $b->limbs[1]),

   854             (int) ($this->limbs[2] ^ $b->limbs[2]),

   855             (int) ($this->limbs[3] ^ $b->limbs[3])

   856         );

   857         return $return;

   858     }

   859 

   860     /**

   861      * @param int $low

   862      * @param int $high

   863      * @return self

   864      * @throws SodiumException

   865      * @throws TypeError

   866      */

   867     public static function fromInts($low, $high)

   868     {

   869         ParagonIE_Sodium_Core32_Util::declareScalarType($low, 'int', 1);

   870         ParagonIE_Sodium_Core32_Util::declareScalarType($high, 'int', 2);

   871 

   872         $high = (int) $high;

   873         $low = (int) $low;

   874         return new ParagonIE_Sodium_Core32_Int64(

   875             array(

   876                 (int) (($high >> 16) & 0xffff),

   877                 (int) ($high & 0xffff),

   878                 (int) (($low >> 16) & 0xffff),

   879                 (int) ($low & 0xffff)

   880             )

   881         );

   882     }

   883 

   884     /**

   885      * @param int $low

   886      * @return self

   887      * @throws SodiumException

   888      * @throws TypeError

   889      */

   890     public static function fromInt($low)

   891     {

   892         ParagonIE_Sodium_Core32_Util::declareScalarType($low, 'int', 1);

   893         $low = (int) $low;

   894 

   895         return new ParagonIE_Sodium_Core32_Int64(

   896             array(

   897                 0,

   898                 0,

   899                 (int) (($low >> 16) & 0xffff),

   900                 (int) ($low & 0xffff)

   901             )

   902         );

   903     }

   904 

   905     /**

   906      * @return int

   907      */

   908     public function toInt()

   909     {

   910         return (int) (

   911             (($this->limbs[2] & 0xffff) << 16)

   912                 |

   913             ($this->limbs[3] & 0xffff)

   914         );

   915     }

   916 

   917     /**

   918      * @param string $string

   919      * @return self

   920      * @throws SodiumException

   921      * @throws TypeError

   922      */

   923     public static function fromString($string)

   924     {

   925         ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);

   926         $string = (string) $string;

   927         if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 8) {

   928             throw new RangeException(

   929                 'String must be 8 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'

   930             );

   931         }

   932         $return = new ParagonIE_Sodium_Core32_Int64();

   933 

   934         $return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff) << 8);

   935         $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff);

   936         $return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff) << 8);

   937         $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff);

   938         $return->limbs[2]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[4]) & 0xff) << 8);

   939         $return->limbs[2] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[5]) & 0xff);

   940         $return->limbs[3]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[6]) & 0xff) << 8);

   941         $return->limbs[3] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[7]) & 0xff);

   942         return $return;

   943     }

   944 

   945     /**

   946      * @param string $string

   947      * @return self

   948      * @throws SodiumException

   949      * @throws TypeError

   950      */

   951     public static function fromReverseString($string)

   952     {

   953         ParagonIE_Sodium_Core32_Util::declareScalarType($string, 'string', 1);

   954         $string = (string) $string;

   955         if (ParagonIE_Sodium_Core32_Util::strlen($string) !== 8) {

   956             throw new RangeException(

   957                 'String must be 8 bytes; ' . ParagonIE_Sodium_Core32_Util::strlen($string) . ' given.'

   958             );

   959         }

   960         $return = new ParagonIE_Sodium_Core32_Int64();

   961 

   962         $return->limbs[0]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[7]) & 0xff) << 8);

   963         $return->limbs[0] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[6]) & 0xff);

   964         $return->limbs[1]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[5]) & 0xff) << 8);

   965         $return->limbs[1] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[4]) & 0xff);

   966         $return->limbs[2]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[3]) & 0xff) << 8);

   967         $return->limbs[2] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[2]) & 0xff);

   968         $return->limbs[3]  = (int) ((ParagonIE_Sodium_Core32_Util::chrToInt($string[1]) & 0xff) << 8);

   969         $return->limbs[3] |= (ParagonIE_Sodium_Core32_Util::chrToInt($string[0]) & 0xff);

   970         return $return;

   971     }

   972 

   973     /**

   974      * @return array<int, int>

   975      */

   976     public function toArray()

   977     {

   978         return array(

   979             (int) ((($this->limbs[0] & 0xffff) << 16) | ($this->limbs[1] & 0xffff)),

   980             (int) ((($this->limbs[2] & 0xffff) << 16) | ($this->limbs[3] & 0xffff))

   981         );

   982     }

   983 

   984     /**

   985      * @return ParagonIE_Sodium_Core32_Int32

   986      */

   987     public function toInt32()

   988     {

   989         $return = new ParagonIE_Sodium_Core32_Int32();

   990         $return->limbs[0] = (int) ($this->limbs[2]);

   991         $return->limbs[1] = (int) ($this->limbs[3]);

   992         $return->unsignedInt = $this->unsignedInt;

   993         $return->overflow = (int) (ParagonIE_Sodium_Core32_Util::abs($this->limbs[1], 16) & 0xffff);

   994         return $return;

   995     }

   996 

   997     /**

   998      * @return ParagonIE_Sodium_Core32_Int64

   999      */

  1000     public function toInt64()

  1001     {

  1002         $return = new ParagonIE_Sodium_Core32_Int64();

  1003         $return->limbs[0] = (int) ($this->limbs[0]);

  1004         $return->limbs[1] = (int) ($this->limbs[1]);

  1005         $return->limbs[2] = (int) ($this->limbs[2]);

  1006         $return->limbs[3] = (int) ($this->limbs[3]);

  1007         $return->unsignedInt = $this->unsignedInt;

  1008         $return->overflow = ParagonIE_Sodium_Core32_Util::abs($this->overflow);

  1009         return $return;

  1010     }

  1011 

  1012     /**

  1013      * @param bool $bool

  1014      * @return self

  1015      */

  1016     public function setUnsignedInt($bool = false)

  1017     {

  1018         $this->unsignedInt = !empty($bool);

  1019         return $this;

  1020     }

  1021 

  1022     /**

  1023      * @return string

  1024      * @throws TypeError

  1025      */

  1026     public function toString()

  1027     {

  1028         return ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff) .

  1029             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .

  1030             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .

  1031             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .

  1032             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[2] >> 8) & 0xff) .

  1033             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[2] & 0xff) .

  1034             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[3] >> 8) & 0xff) .

  1035             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[3] & 0xff);

  1036     }

  1037 

  1038     /**

  1039      * @return string

  1040      * @throws TypeError

  1041      */

  1042     public function toReverseString()

  1043     {

  1044         return ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[3] & 0xff) .

  1045             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[3] >> 8) & 0xff) .

  1046             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[2] & 0xff) .

  1047             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[2] >> 8) & 0xff) .

  1048             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[1] & 0xff) .

  1049             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[1] >> 8) & 0xff) .

  1050             ParagonIE_Sodium_Core32_Util::intToChr($this->limbs[0] & 0xff) .

  1051             ParagonIE_Sodium_Core32_Util::intToChr(($this->limbs[0] >> 8) & 0xff);

  1052     }

  1053 

  1054     /**

  1055      * @return string

  1056      */

  1057     public function __toString()

  1058     {

  1059         try {

  1060             return $this->toString();

  1061         } catch (TypeError $ex) {

  1062             // PHP engine can't handle exceptions from __toString()

  1063             return '';

  1064         }

  1065     }

  1066 }