Files
burrow-server/tools/decompiled/old-builds/b1375/com/hurlant/math/BigInteger.as
T

1790 lines
50 KiB
ActionScript

package com.hurlant.math
{
import com.hurlant.crypto.prng.Random;
import com.hurlant.util.Hex;
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
use namespace bi_internal;
public class BigInteger
{
public static const DB:int = 30;
public static const DV:int = 1073741824;
public static const DM:int = 1073741823;
public static const BI_FP:int = 52;
public static const F1:int = 22;
public static const F2:int = 8;
public static const FV:Number = Math.pow(2,52);
public static const ZERO:BigInteger = nbv(0);
public static const ONE:BigInteger = nbv(1);
public static const lowprimes:Array = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509];
public static const lplim:int = 67108864 / lowprimes[lowprimes.length - 1];
public var t:int;
bi_internal var s:int;
bi_internal var a:Array;
public function BigInteger(param1:* = null, param2:int = 0)
{
var _loc4_:ByteArray = null;
var _loc3_:int = 0;
super();
bi_internal::a = [];
if(param1 is String)
{
param1 = Hex.toArray(param1);
param2 = 0;
}
if(param1 is ByteArray)
{
_loc4_ = param1 as ByteArray;
_loc3_ = int(param2 || _loc4_.length - _loc4_.position);
bi_internal::fromArray(_loc4_,_loc3_);
}
}
public static function nbv(param1:int) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
_loc2_.fromInt(param1);
return _loc2_;
}
public function dispose() : void
{
var _loc2_:* = 0;
var _loc1_:Random = new Random();
_loc2_ = 0;
while(_loc2_ < a.length)
{
a[_loc2_] = _loc1_.nextByte();
delete a[_loc2_];
_loc2_++;
}
a = null;
t = 0;
s = 0;
Memory.gc();
}
public function toString(param1:Number = 16) : String
{
var _loc6_:int = 0;
if(s < 0)
{
return "-" + negate().toString(param1);
}
switch(param1)
{
case 2:
_loc6_ = 1;
break;
case 4:
_loc6_ = 2;
break;
case 8:
_loc6_ = 3;
break;
case 16:
_loc6_ = 4;
break;
case 32:
_loc6_ = 5;
}
var _loc7_:int = (1 << _loc6_) - 1;
var _loc2_:int = 0;
var _loc5_:Boolean = false;
var _loc3_:String = "";
var _loc8_:int = t;
var _loc4_:int = 30 - _loc8_ * 30 % _loc6_;
if(_loc8_-- > 0)
{
if(_loc4_ < 30 && (_loc2_ = a[_loc8_] >> _loc4_) > 0)
{
_loc5_ = true;
_loc3_ = _loc2_.toString(36);
}
while(_loc8_ >= 0)
{
if(_loc4_ < _loc6_)
{
_loc2_ = (a[_loc8_] & (1 << _loc4_) - 1) << _loc6_ - _loc4_;
_loc2_ |= a[--_loc8_] >> (_loc4_ += 30 - _loc6_);
}
else
{
_loc2_ = a[_loc8_] >> (_loc4_ -= _loc6_) & _loc7_;
if(_loc4_ <= 0)
{
_loc4_ += 30;
_loc8_--;
}
}
if(_loc2_ > 0)
{
_loc5_ = true;
}
if(_loc5_)
{
_loc3_ += _loc2_.toString(36);
}
}
}
return _loc5_ ? _loc3_ : "0";
}
public function toArray(param1:ByteArray) : uint
{
var _loc6_:int = 0;
_loc6_ = 8;
var _loc7_:int = 0;
_loc7_ = 255;
var _loc2_:int = 0;
var _loc8_:int = t;
var _loc4_:int = 30 - _loc8_ * 30 % 8;
var _loc5_:Boolean = false;
var _loc3_:int = 0;
if(_loc8_-- > 0)
{
if(_loc4_ < 30 && (_loc2_ = a[_loc8_] >> _loc4_) > 0)
{
_loc5_ = true;
param1.writeByte(_loc2_);
_loc3_++;
}
while(_loc8_ >= 0)
{
if(_loc4_ < 8)
{
_loc2_ = (a[_loc8_] & (1 << _loc4_) - 1) << 8 - _loc4_;
_loc2_ |= a[--_loc8_] >> (_loc4_ += 30 - 8);
}
else
{
_loc2_ = a[_loc8_] >> (_loc4_ -= 8) & 0xFF;
if(_loc4_ <= 0)
{
_loc4_ += 30;
_loc8_--;
}
}
if(_loc2_ > 0)
{
_loc5_ = true;
}
if(_loc5_)
{
param1.writeByte(_loc2_);
_loc3_++;
}
}
}
return _loc3_;
}
public function valueOf() : Number
{
var _loc3_:* = 0;
var _loc1_:Number = 1;
var _loc2_:Number = 0;
_loc3_ = 0;
while(_loc3_ < t)
{
_loc2_ += a[_loc3_] * _loc1_;
_loc1_ *= 1073741824;
_loc3_++;
}
return _loc2_;
}
public function negate() : BigInteger
{
var _loc1_:BigInteger = nbi();
ZERO.subTo(this,_loc1_);
return _loc1_;
}
public function abs() : BigInteger
{
return s < 0 ? negate() : this;
}
public function compareTo(param1:BigInteger) : int
{
var _loc2_:int = s - param1.s;
if(_loc2_ != 0)
{
return _loc2_;
}
var _loc3_:int = t;
_loc2_ = _loc3_ - param1.t;
if(_loc2_ != 0)
{
return _loc2_;
}
while(--_loc3_ >= 0)
{
_loc2_ = a[_loc3_] - param1.a[_loc3_];
if(_loc2_ != 0)
{
return _loc2_;
}
}
return 0;
}
bi_internal function nbits(param1:int) : int
{
var _loc2_:int = 0;
var _loc3_:int = 1;
_loc2_ = param1 >>> 16;
if(_loc2_ != 0)
{
param1 = _loc2_;
_loc3_ += 16;
}
_loc2_ = param1 >> 8;
if(_loc2_ != 0)
{
param1 = _loc2_;
_loc3_ += 8;
}
_loc2_ = param1 >> 4;
if(_loc2_ != 0)
{
param1 = _loc2_;
_loc3_ += 4;
}
_loc2_ = param1 >> 2;
if(_loc2_ != 0)
{
param1 = _loc2_;
_loc3_ += 2;
}
_loc2_ = param1 >> 1;
if(_loc2_ != 0)
{
param1 = _loc2_;
_loc3_ += 1;
}
return _loc3_;
}
public function bitLength() : int
{
if(t <= 0)
{
return 0;
}
return 30 * (t - 1) + nbits(a[t - 1] ^ s & 0x3FFFFFFF);
}
public function mod(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = nbi();
abs().divRemTo(param1,null,_loc2_);
if(s < 0 && _loc2_.compareTo(ZERO) > 0)
{
param1.subTo(_loc2_,_loc2_);
}
return _loc2_;
}
public function modPowInt(param1:int, param2:BigInteger) : BigInteger
{
var _loc3_:IReduction = null;
if(param1 < 256 || param2.isEven())
{
_loc3_ = new ClassicReduction(param2);
}
else
{
_loc3_ = new MontgomeryReduction(param2);
}
return exp(param1,_loc3_);
}
bi_internal function copyTo(param1:BigInteger) : void
{
var _loc2_:int = 0;
_loc2_ = t - 1;
while(_loc2_ >= 0)
{
param1.a[_loc2_] = a[_loc2_];
_loc2_--;
}
param1.t = t;
param1.s = s;
}
bi_internal function fromInt(param1:int) : void
{
t = 1;
s = param1 < 0 ? -1 : 0;
if(param1 > 0)
{
a[0] = param1;
}
else if(param1 < -1)
{
a[0] = param1 + 1073741824;
}
else
{
t = 0;
}
}
bi_internal function fromArray(param1:ByteArray, param2:int) : void
{
var _loc5_:int = 0;
_loc5_ = 8;
var _loc6_:int = 0;
var _loc3_:int = int(param1.position);
var _loc7_:int = _loc3_ + param2;
var _loc4_:int = 0;
t = 0;
s = 0;
while(--_loc7_ >= _loc3_)
{
_loc6_ = int(_loc7_ < param1.length ? param1[_loc7_] : 0);
if(_loc4_ == 0)
{
a[t++] = _loc6_;
}
else if(_loc4_ + 8 > 30)
{
var _loc8_:* = t - 1;
var _loc9_:* = a[_loc8_] | (_loc6_ & (1 << 30 - _loc4_) - 1) << _loc4_;
a[_loc8_] = _loc9_;
a[t++] = _loc6_ >> 30 - _loc4_;
}
else
{
_loc9_ = t - 1;
_loc8_ = a[_loc9_] | _loc6_ << _loc4_;
a[_loc9_] = _loc8_;
}
_loc4_ += 8;
if(_loc4_ >= 30)
{
_loc4_ -= 30;
}
}
clamp();
param1.position = Math.min(_loc3_ + param2,param1.length);
}
bi_internal function clamp() : void
{
var _loc1_:int = s & 0x3FFFFFFF;
while(t > 0 && a[t - 1] == _loc1_)
{
t = t - 1;
}
}
bi_internal function dlShiftTo(param1:int, param2:BigInteger) : void
{
var _loc3_:int = 0;
_loc3_ = t - 1;
while(_loc3_ >= 0)
{
param2.a[_loc3_ + param1] = a[_loc3_];
_loc3_--;
}
_loc3_ = param1 - 1;
while(_loc3_ >= 0)
{
param2.a[_loc3_] = 0;
_loc3_--;
}
param2.t = t + param1;
param2.s = s;
}
bi_internal function drShiftTo(param1:int, param2:BigInteger) : void
{
var _loc3_:int = 0;
_loc3_ = param1;
while(_loc3_ < t)
{
param2.a[_loc3_ - param1] = a[_loc3_];
_loc3_++;
}
param2.t = Math.max(t - param1,0);
param2.s = s;
}
bi_internal function lShiftTo(param1:int, param2:BigInteger) : void
{
var _loc8_:int = 0;
var _loc6_:int = param1 % 30;
var _loc3_:int = 30 - _loc6_;
var _loc5_:int = (1 << _loc3_) - 1;
var _loc7_:int = param1 / 30;
var _loc4_:int = s << _loc6_ & 0x3FFFFFFF;
_loc8_ = t - 1;
while(_loc8_ >= 0)
{
param2.a[_loc8_ + _loc7_ + 1] = a[_loc8_] >> _loc3_ | _loc4_;
_loc4_ = (a[_loc8_] & _loc5_) << _loc6_;
_loc8_--;
}
_loc8_ = _loc7_ - 1;
while(_loc8_ >= 0)
{
param2.a[_loc8_] = 0;
_loc8_--;
}
param2.a[_loc7_] = _loc4_;
param2.t = t + _loc7_ + 1;
param2.s = s;
param2.clamp();
}
bi_internal function rShiftTo(param1:int, param2:BigInteger) : void
{
var _loc7_:int = 0;
param2.s = s;
var _loc6_:int = param1 / 30;
if(_loc6_ >= t)
{
param2.t = 0;
return;
}
var _loc5_:int = param1 % 30;
var _loc3_:int = 30 - _loc5_;
var _loc4_:int = (1 << _loc5_) - 1;
param2.a[0] = a[_loc6_] >> _loc5_;
_loc7_ = _loc6_ + 1;
while(_loc7_ < t)
{
var _loc8_:* = _loc7_ - _loc6_ - 1;
var _loc9_:* = param2.a[_loc8_] | (a[_loc7_] & _loc4_) << _loc3_;
param2.a[_loc8_] = _loc9_;
param2.a[_loc7_ - _loc6_] = a[_loc7_] >> _loc5_;
_loc7_++;
}
if(_loc5_ > 0)
{
_loc9_ = t - _loc6_ - 1;
_loc8_ = param2.a[_loc9_] | (s & _loc4_) << _loc3_;
param2.a[_loc9_] = _loc8_;
}
param2.t = t - _loc6_;
param2.clamp();
}
bi_internal function subTo(param1:BigInteger, param2:BigInteger) : void
{
var _loc5_:int = 0;
var _loc3_:int = 0;
var _loc4_:int = Math.min(param1.t,t);
while(_loc5_ < _loc4_)
{
_loc3_ += a[_loc5_] - param1.a[_loc5_];
param2.a[_loc5_++] = _loc3_ & 0x3FFFFFFF;
_loc3_ >>= 30;
}
if(param1.t < t)
{
_loc3_ -= param1.s;
while(_loc5_ < t)
{
_loc3_ += a[_loc5_];
param2.a[_loc5_++] = _loc3_ & 0x3FFFFFFF;
_loc3_ >>= 30;
}
_loc3_ += s;
}
else
{
_loc3_ += s;
while(_loc5_ < param1.t)
{
_loc3_ -= param1.a[_loc5_];
param2.a[_loc5_++] = _loc3_ & 0x3FFFFFFF;
_loc3_ >>= 30;
}
_loc3_ -= param1.s;
}
param2.s = _loc3_ < 0 ? -1 : 0;
if(_loc3_ < -1)
{
param2.a[_loc5_++] = 1073741824 + _loc3_;
}
else if(_loc3_ > 0)
{
param2.a[_loc5_++] = _loc3_;
}
param2.t = _loc5_;
param2.clamp();
}
bi_internal function am(param1:int, param2:int, param3:BigInteger, param4:int, param5:int, param6:int) : int
{
var _loc9_:int = 0;
var _loc11_:int = 0;
var _loc10_:int = 0;
var _loc8_:int = param2 & 0x7FFF;
var _loc7_:int = param2 >> 15;
while(--param6 >= 0)
{
_loc9_ = a[param1] & 0x7FFF;
_loc11_ = a[param1++] >> 15;
_loc10_ = _loc7_ * _loc9_ + _loc11_ * _loc8_;
_loc9_ = _loc8_ * _loc9_ + ((_loc10_ & 0x7FFF) << 15) + param3.a[param4] + (param5 & 0x3FFFFFFF);
param5 = (_loc9_ >>> 30) + (_loc10_ >>> 15) + _loc7_ * _loc11_ + (param5 >>> 30);
param3.a[param4++] = _loc9_ & 0x3FFFFFFF;
}
return param5;
}
bi_internal function multiplyTo(param1:BigInteger, param2:BigInteger) : void
{
var _loc5_:BigInteger = abs();
var _loc3_:BigInteger = param1.abs();
var _loc4_:int = _loc5_.t;
param2.t = _loc4_ + _loc3_.t;
while(--_loc4_ >= 0)
{
param2.a[_loc4_] = 0;
}
_loc4_ = 0;
while(_loc4_ < _loc3_.t)
{
param2.a[_loc4_ + _loc5_.t] = _loc5_.am(0,_loc3_.a[_loc4_],param2,_loc4_,0,_loc5_.t);
_loc4_++;
}
param2.s = 0;
param2.clamp();
if(s != param1.s)
{
ZERO.subTo(param2,param2);
}
}
bi_internal function squareTo(param1:BigInteger) : void
{
var _loc2_:int = 0;
var _loc4_:BigInteger = abs();
var _loc3_:int = param1.t = 2 * _loc4_.t;
while(--_loc3_ >= 0)
{
param1.a[_loc3_] = 0;
}
_loc3_ = 0;
while(_loc3_ < _loc4_.t - 1)
{
_loc2_ = _loc4_.am(_loc3_,_loc4_.a[_loc3_],param1,2 * _loc3_,0,1);
param1.a[_loc3_ + _loc4_.t] += _loc4_.am(_loc3_ + 1,2 * _loc4_.a[_loc3_],param1,2 * _loc3_ + 1,_loc2_,_loc4_.t - _loc3_ - 1);
if(_loc6_ >= 1073741824)
{
var _loc6_:Number = _loc3_ + _loc4_.t;
var _loc5_:Number = param1.a[_loc6_] - 1073741824;
param1.a[_loc6_] = _loc5_;
param1.a[_loc3_ + _loc4_.t + 1] = 1;
}
_loc3_++;
}
if(param1.t > 0)
{
_loc5_ = param1.t - 1;
_loc6_ = param1.a[_loc5_] + _loc4_.am(_loc3_,_loc4_.a[_loc3_],param1,2 * _loc3_,0,1);
param1.a[_loc5_] = _loc6_;
}
param1.s = 0;
param1.clamp();
}
bi_internal function divRemTo(param1:BigInteger, param2:BigInteger = null, param3:BigInteger = null) : void
{
var _loc9_:int = 0;
var _loc17_:BigInteger = param1.abs();
if(_loc17_.t <= 0)
{
return;
}
var _loc16_:BigInteger = abs();
if(_loc16_.t < _loc17_.t)
{
if(param2 != null)
{
param2.fromInt(0);
}
if(param3 != null)
{
copyTo(param3);
}
return;
}
if(param3 == null)
{
param3 = nbi();
}
var _loc19_:BigInteger = nbi();
var _loc5_:int = s;
var _loc6_:int = param1.s;
var _loc18_:int = 30 - nbits(_loc17_.a[_loc17_.t - 1]);
if(_loc18_ > 0)
{
_loc17_.lShiftTo(_loc18_,_loc19_);
_loc16_.lShiftTo(_loc18_,param3);
}
else
{
_loc17_.copyTo(_loc19_);
_loc16_.copyTo(param3);
}
var _loc15_:int = _loc19_.t;
var _loc7_:int = int(_loc19_.a[_loc15_ - 1]);
if(_loc7_ == 0)
{
return;
}
var _loc14_:Number = _loc7_ * (1 << 22) + (_loc15_ > 1 ? _loc19_.a[_loc15_ - 2] >> 8 : 0);
var _loc11_:Number = FV / _loc14_;
var _loc12_:Number = (1 << 22) / _loc14_;
var _loc4_:Number = 256;
var _loc10_:int = param3.t;
var _loc8_:int = _loc10_ - _loc15_;
var _loc13_:BigInteger = param2 == null ? nbi() : param2;
_loc19_.dlShiftTo(_loc8_,_loc13_);
if(param3.compareTo(_loc13_) >= 0)
{
param3.a[param3.t++] = 1;
param3.subTo(_loc13_,param3);
}
ONE.dlShiftTo(_loc15_,_loc13_);
_loc13_.subTo(_loc19_,_loc19_);
while(_loc19_.t < _loc15_)
{
_loc19_.(_loc19_.t++,false);
}
while(--_loc8_ >= 0)
{
_loc9_ = int(param3.a[--_loc10_] == _loc7_ ? 1073741823 : Number(param3.a[_loc10_]) * _loc11_ + (Number(param3.a[_loc10_ - 1]) + _loc4_) * _loc12_);
param3.a[_loc10_] += _loc19_.am(0,_loc9_,param3,_loc8_,0,_loc15_);
if(_loc21_ < _loc9_)
{
_loc19_.dlShiftTo(_loc8_,_loc13_);
param3.subTo(_loc13_,param3);
while(param3.a[_loc10_] < --_loc9_)
{
param3.subTo(_loc13_,param3);
}
}
}
if(param2 != null)
{
param3.drShiftTo(_loc15_,param2);
if(_loc5_ != _loc6_)
{
ZERO.subTo(param2,param2);
}
}
param3.t = _loc15_;
param3.clamp();
if(_loc18_ > 0)
{
param3.rShiftTo(_loc18_,param3);
}
if(_loc5_ < 0)
{
ZERO.subTo(param3,param3);
}
}
bi_internal function invDigit() : int
{
if(t < 1)
{
return 0;
}
var _loc2_:int = int(a[0]);
if((_loc2_ & 1) == 0)
{
return 0;
}
var _loc1_:int = _loc2_ & 3;
_loc1_ = _loc1_ * (2 - (_loc2_ & 0x0F) * _loc1_) & 0x0F;
_loc1_ = _loc1_ * (2 - (_loc2_ & 0xFF) * _loc1_) & 0xFF;
_loc1_ = _loc1_ * (2 - ((_loc2_ & 0xFFFF) * _loc1_ & 0xFFFF)) & 0xFFFF;
_loc1_ = _loc1_ * (2 - _loc2_ * _loc1_ % 1073741824) % 1073741824;
return _loc1_ > 0 ? 1073741824 - _loc1_ : -_loc1_;
}
bi_internal function isEven() : Boolean
{
return (t > 0 ? a[0] & 1 : s) == 0;
}
bi_internal function exp(param1:int, param2:IReduction) : BigInteger
{
var _loc4_:BigInteger = null;
if(param1 > 4294967295 || param1 < 1)
{
return ONE;
}
var _loc5_:BigInteger = nbi();
var _loc6_:BigInteger = nbi();
var _loc3_:BigInteger = param2.convert(this);
var _loc7_:int = nbits(param1) - 1;
_loc3_.copyTo(_loc5_);
while(--_loc7_ >= 0)
{
param2.sqrTo(_loc5_,_loc6_);
if((param1 & 1 << _loc7_) > 0)
{
param2.mulTo(_loc6_,_loc3_,_loc5_);
}
else
{
_loc4_ = _loc5_;
_loc5_ = _loc6_;
_loc6_ = _loc4_;
}
}
return param2.revert(_loc5_);
}
bi_internal function intAt(param1:String, param2:int) : int
{
return parseInt(param1.charAt(param2),36);
}
protected function nbi() : *
{
return new BigInteger();
}
public function clone() : BigInteger
{
var _loc1_:BigInteger = new BigInteger();
this.copyTo(_loc1_);
return _loc1_;
}
public function intValue() : int
{
if(s < 0)
{
if(t == 1)
{
return a[0] - 1073741824;
}
if(t == 0)
{
return -1;
}
}
else
{
if(t == 1)
{
return a[0];
}
if(t == 0)
{
return 0;
}
}
return (a[1] & 3) << 30 | a[0];
}
public function byteValue() : int
{
return t == 0 ? s : a[0] << 24 >> 24;
}
public function shortValue() : int
{
return t == 0 ? s : a[0] << 16 >> 16;
}
protected function chunkSize(param1:Number) : int
{
return Math.floor(0.6931471805599453 * 30 / Math.log(param1));
}
public function sigNum() : int
{
if(s < 0)
{
return -1;
}
if(t <= 0 || t == 1 && a[0] <= 0)
{
return 0;
}
return 1;
}
protected function toRadix(param1:uint = 10) : String
{
if(sigNum() == 0 || param1 < 2 || param1 > 32)
{
return "0";
}
var _loc7_:int = chunkSize(param1);
var _loc4_:Number = Math.pow(param1,_loc7_);
var _loc2_:BigInteger = nbv(_loc4_);
var _loc6_:BigInteger = nbi();
var _loc5_:BigInteger = nbi();
var _loc3_:String = "";
divRemTo(_loc2_,_loc6_,_loc5_);
while(_loc6_.sigNum() > 0)
{
_loc3_ = (_loc4_ + _loc5_.intValue()).toString(param1).substr(1) + _loc3_;
_loc6_.divRemTo(_loc2_,_loc6_,_loc5_);
}
return _loc5_.intValue().toString(param1) + _loc3_;
}
protected function fromRadix(param1:String, param2:int = 10) : void
{
var _loc8_:int = 0;
var _loc7_:int = 0;
fromInt(0);
var _loc9_:int = chunkSize(param2);
var _loc4_:Number = Math.pow(param2,_loc9_);
var _loc6_:Boolean = false;
var _loc5_:int = 0;
var _loc3_:int = 0;
_loc8_ = 0;
while(_loc8_ < param1.length)
{
_loc7_ = intAt(param1,_loc8_);
if(_loc7_ < 0)
{
if(param1.charAt(_loc8_) == "-" && sigNum() == 0)
{
_loc6_ = true;
}
}
else
{
_loc3_ = param2 * _loc3_ + _loc7_;
if(++_loc5_ >= _loc9_)
{
dMultiply(_loc4_);
dAddOffset(_loc3_,0);
_loc5_ = 0;
_loc3_ = 0;
}
}
_loc8_++;
}
if(_loc5_ > 0)
{
dMultiply(Math.pow(param2,_loc5_));
dAddOffset(_loc3_,0);
}
if(_loc6_)
{
BigInteger.ZERO.subTo(this,this);
}
}
public function toByteArray() : ByteArray
{
var _loc1_:int = 0;
var _loc5_:int = t;
var _loc2_:ByteArray = new ByteArray();
_loc2_[0] = s;
var _loc3_:int = 30 - _loc5_ * 30 % 8;
var _loc4_:int = 0;
if(_loc5_-- > 0)
{
if(_loc3_ < 30 && (_loc1_ = a[_loc5_] >> _loc3_) != (s & 0x3FFFFFFF) >> _loc3_)
{
_loc2_[_loc4_++] = _loc1_ | s << 30 - _loc3_;
}
while(_loc5_ >= 0)
{
if(_loc3_ < 8)
{
_loc1_ = (a[_loc5_] & (1 << _loc3_) - 1) << 8 - _loc3_;
_loc1_ |= a[--_loc5_] >> (_loc3_ += 30 - 8);
}
else
{
_loc1_ = a[_loc5_] >> (_loc3_ -= 8) & 0xFF;
if(_loc3_ <= 0)
{
_loc3_ += 30;
_loc5_--;
}
}
if((_loc1_ & 0x80) != 0)
{
_loc1_ |= -256;
}
if(_loc4_ == 0 && (s & 0x80) != (_loc1_ & 0x80))
{
_loc4_++;
}
if(_loc4_ > 0 || _loc1_ != s)
{
_loc2_[_loc4_++] = _loc1_;
}
}
}
return _loc2_;
}
public function equals(param1:BigInteger) : Boolean
{
return compareTo(param1) == 0;
}
public function min(param1:BigInteger) : BigInteger
{
return compareTo(param1) < 0 ? this : param1;
}
public function max(param1:BigInteger) : BigInteger
{
return compareTo(param1) > 0 ? this : param1;
}
protected function bitwiseTo(param1:BigInteger, param2:Function, param3:BigInteger) : void
{
var _loc6_:int = 0;
var _loc4_:int = 0;
var _loc5_:int = Math.min(param1.t,t);
_loc6_ = 0;
while(_loc6_ < _loc5_)
{
param3.a[_loc6_] = param2(this.a[_loc6_],param1.a[_loc6_]);
_loc6_++;
}
if(param1.t < t)
{
_loc4_ = param1.s & 0x3FFFFFFF;
_loc6_ = _loc5_;
while(_loc6_ < t)
{
param3.a[_loc6_] = param2(this.a[_loc6_],_loc4_);
_loc6_++;
}
param3.t = t;
}
else
{
_loc4_ = s & 0x3FFFFFFF;
_loc6_ = _loc5_;
while(_loc6_ < param1.t)
{
param3.a[_loc6_] = param2(_loc4_,param1.a[_loc6_]);
_loc6_++;
}
param3.t = param1.t;
}
param3.s = param2(s,param1.s);
param3.clamp();
}
private function op_and(param1:int, param2:int) : int
{
return param1 & param2;
}
public function and(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
bitwiseTo(param1,op_and,_loc2_);
return _loc2_;
}
private function op_or(param1:int, param2:int) : int
{
return param1 | param2;
}
public function or(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
bitwiseTo(param1,op_or,_loc2_);
return _loc2_;
}
private function op_xor(param1:int, param2:int) : int
{
return param1 ^ param2;
}
public function xor(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
bitwiseTo(param1,op_xor,_loc2_);
return _loc2_;
}
private function op_andnot(param1:int, param2:int) : int
{
return param1 & ~param2;
}
public function andNot(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
bitwiseTo(param1,op_andnot,_loc2_);
return _loc2_;
}
public function not() : BigInteger
{
var _loc2_:int = 0;
var _loc1_:BigInteger = new BigInteger();
_loc2_ = 0;
while(_loc2_ < t)
{
_loc1_[_loc2_] = 0x3FFFFFFF & ~a[_loc2_];
_loc2_++;
}
_loc1_.t = t;
_loc1_.s = ~s;
return _loc1_;
}
public function shiftLeft(param1:int) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
if(param1 < 0)
{
rShiftTo(-param1,_loc2_);
}
else
{
lShiftTo(param1,_loc2_);
}
return _loc2_;
}
public function shiftRight(param1:int) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
if(param1 < 0)
{
lShiftTo(-param1,_loc2_);
}
else
{
rShiftTo(param1,_loc2_);
}
return _loc2_;
}
private function lbit(param1:int) : int
{
if(param1 == 0)
{
return -1;
}
var _loc2_:int = 0;
if((param1 & 0xFFFF) == 0)
{
param1 >>= 16;
_loc2_ += 16;
}
if((param1 & 0xFF) == 0)
{
param1 >>= 8;
_loc2_ += 8;
}
if((param1 & 0x0F) == 0)
{
param1 >>= 4;
_loc2_ += 4;
}
if((param1 & 3) == 0)
{
param1 >>= 2;
_loc2_ += 2;
}
if((param1 & 1) == 0)
{
_loc2_++;
}
return _loc2_;
}
public function getLowestSetBit() : int
{
var _loc1_:int = 0;
_loc1_ = 0;
while(_loc1_ < t)
{
if(a[_loc1_] != 0)
{
return _loc1_ * 30 + lbit(a[_loc1_]);
}
_loc1_++;
}
if(s < 0)
{
return t * 30;
}
return -1;
}
private function cbit(param1:int) : int
{
var _loc2_:uint = 0;
while(param1 != 0)
{
param1 &= param1 - 1;
_loc2_++;
}
return _loc2_;
}
public function bitCount() : int
{
var _loc2_:int = 0;
var _loc1_:int = 0;
var _loc3_:int = s & 0x3FFFFFFF;
_loc2_ = 0;
while(_loc2_ < t)
{
_loc1_ += cbit(a[_loc2_] ^ _loc3_);
_loc2_++;
}
return _loc1_;
}
public function testBit(param1:int) : Boolean
{
var _loc2_:int = Math.floor(param1 / 30);
if(_loc2_ >= t)
{
return s != 0;
}
return (a[_loc2_] & 1 << param1 % 30) != 0;
}
protected function changeBit(param1:int, param2:Function) : BigInteger
{
var _loc3_:BigInteger = BigInteger.ONE.shiftLeft(param1);
bitwiseTo(_loc3_,param2,_loc3_);
return _loc3_;
}
public function setBit(param1:int) : BigInteger
{
return changeBit(param1,op_or);
}
public function clearBit(param1:int) : BigInteger
{
return changeBit(param1,op_andnot);
}
public function flipBit(param1:int) : BigInteger
{
return changeBit(param1,op_xor);
}
protected function addTo(param1:BigInteger, param2:BigInteger) : void
{
var _loc5_:int = 0;
var _loc3_:int = 0;
var _loc4_:int = Math.min(param1.t,t);
while(_loc5_ < _loc4_)
{
_loc3_ += this.a[_loc5_] + param1.a[_loc5_];
param2.a[_loc5_++] = _loc3_ & 0x3FFFFFFF;
_loc3_ >>= 30;
}
if(param1.t < t)
{
_loc3_ += param1.s;
while(_loc5_ < t)
{
_loc3_ += this.a[_loc5_];
param2.a[_loc5_++] = _loc3_ & 0x3FFFFFFF;
_loc3_ >>= 30;
}
_loc3_ += s;
}
else
{
_loc3_ += s;
while(_loc5_ < param1.t)
{
_loc3_ += param1.a[_loc5_];
param2.a[_loc5_++] = _loc3_ & 0x3FFFFFFF;
_loc3_ >>= 30;
}
_loc3_ += param1.s;
}
param2.s = _loc3_ < 0 ? -1 : 0;
if(_loc3_ > 0)
{
param2.a[_loc5_++] = _loc3_;
}
else if(_loc3_ < -1)
{
param2.a[_loc5_++] = 1073741824 + _loc3_;
}
param2.t = _loc5_;
param2.clamp();
}
public function add(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
addTo(param1,_loc2_);
return _loc2_;
}
public function subtract(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
subTo(param1,_loc2_);
return _loc2_;
}
public function multiply(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
multiplyTo(param1,_loc2_);
return _loc2_;
}
public function divide(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
divRemTo(param1,_loc2_,null);
return _loc2_;
}
public function remainder(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
divRemTo(param1,null,_loc2_);
return _loc2_;
}
public function divideAndRemainder(param1:BigInteger) : Array
{
var _loc3_:BigInteger = new BigInteger();
var _loc2_:BigInteger = new BigInteger();
divRemTo(param1,_loc3_,_loc2_);
return [_loc3_,_loc2_];
}
bi_internal function dMultiply(param1:int) : void
{
a[t] = am(0,param1 - 1,this,0,0,t);
t = t + 1;
clamp();
}
bi_internal function dAddOffset(param1:int, param2:int) : void
{
while(t <= param2)
{
a[t++] = 0;
}
var _loc3_:* = param2;
var _loc4_:* = a[_loc3_] + param1;
a[_loc3_] = _loc4_;
while(a[param2] >= 1073741824)
{
_loc4_ = param2;
_loc3_ = a[_loc4_] - 1073741824;
a[_loc4_] = _loc3_;
if(++param2 >= t)
{
a[t++] = 0;
}
++a[param2];
}
}
public function pow(param1:int) : BigInteger
{
return exp(param1,new NullReduction());
}
bi_internal function multiplyLowerTo(param1:BigInteger, param2:int, param3:BigInteger) : void
{
var _loc4_:int = 0;
var _loc5_:int = Math.min(t + param1.t,param2);
param3.s = 0;
param3.t = _loc5_;
while(_loc5_ > 0)
{
param3.a[--_loc5_] = 0;
}
_loc4_ = param3.t - t;
while(_loc5_ < _loc4_)
{
param3.a[_loc5_ + t] = am(0,param1.a[_loc5_],param3,_loc5_,0,t);
_loc5_++;
}
_loc4_ = Math.min(param1.t,param2);
while(_loc5_ < _loc4_)
{
am(0,param1.a[_loc5_],param3,_loc5_,0,param2 - _loc5_);
_loc5_++;
}
param3.clamp();
}
bi_internal function multiplyUpperTo(param1:BigInteger, param2:int, param3:BigInteger) : void
{
param2--;
var _loc4_:int = param3.t = t + param1.t - param2;
param3.s = 0;
while(--_loc4_ >= 0)
{
param3.a[_loc4_] = 0;
}
_loc4_ = Math.max(param2 - t,0);
while(_loc4_ < param1.t)
{
param3.a[t + _loc4_ - param2] = am(param2 - _loc4_,param1.a[_loc4_],param3,0,0,t + _loc4_ - param2);
_loc4_++;
}
param3.clamp();
param3.drShiftTo(1,param3);
}
public function modPow(param1:BigInteger, param2:BigInteger) : BigInteger
{
var _loc7_:int = 0;
var _loc16_:IReduction = null;
var _loc14_:BigInteger = null;
var _loc11_:int = 0;
var _loc12_:BigInteger = null;
var _loc10_:int = param1.bitLength();
var _loc13_:BigInteger = nbv(1);
if(_loc10_ <= 0)
{
return _loc13_;
}
if(_loc10_ < 18)
{
_loc7_ = 1;
}
else if(_loc10_ < 48)
{
_loc7_ = 3;
}
else if(_loc10_ < 144)
{
_loc7_ = 4;
}
else if(_loc10_ < 768)
{
_loc7_ = 5;
}
else
{
_loc7_ = 6;
}
if(_loc10_ < 8)
{
_loc16_ = new ClassicReduction(param2);
}
else if(param2.isEven())
{
_loc16_ = new BarrettReduction(param2);
}
else
{
_loc16_ = new MontgomeryReduction(param2);
}
var _loc3_:Array = [];
var _loc4_:int = 3;
var _loc8_:int = _loc7_ - 1;
var _loc9_:int = (1 << _loc7_) - 1;
_loc3_[1] = _loc16_.convert(this);
if(_loc7_ > 1)
{
_loc14_ = new BigInteger();
_loc16_.sqrTo(_loc3_[1],_loc14_);
while(_loc4_ <= _loc9_)
{
_loc3_[_loc4_] = new BigInteger();
_loc16_.mulTo(_loc14_,_loc3_[_loc4_ - 2],_loc3_[_loc4_]);
_loc4_ += 2;
}
}
var _loc6_:int = param1.t - 1;
var _loc5_:Boolean = true;
var _loc15_:BigInteger = new BigInteger();
_loc10_ = nbits(param1.a[_loc6_]) - 1;
while(_loc6_ >= 0)
{
if(_loc10_ >= _loc8_)
{
_loc11_ = param1.a[_loc6_] >> _loc10_ - _loc8_ & _loc9_;
}
else
{
_loc11_ = (param1.a[_loc6_] & (1 << _loc10_ + 1) - 1) << _loc8_ - _loc10_;
if(_loc6_ > 0)
{
_loc11_ |= param1.a[_loc6_ - 1] >> 30 + _loc10_ - _loc8_;
}
}
_loc4_ = _loc7_;
while((_loc11_ & 1) == 0)
{
_loc11_ >>= 1;
_loc4_--;
}
_loc10_ -= _loc4_;
if(_loc10_ < 0)
{
_loc10_ += 30;
_loc6_--;
}
if(_loc5_)
{
_loc3_[_loc11_].copyTo(_loc13_);
_loc5_ = false;
}
else
{
while(_loc4_ > 1)
{
_loc16_.sqrTo(_loc13_,_loc15_);
_loc16_.sqrTo(_loc15_,_loc13_);
_loc4_ -= 2;
}
if(_loc4_ > 0)
{
_loc16_.sqrTo(_loc13_,_loc15_);
}
else
{
_loc12_ = _loc13_;
_loc13_ = _loc15_;
_loc15_ = _loc12_;
}
_loc16_.mulTo(_loc15_,_loc3_[_loc11_],_loc13_);
}
while(_loc6_ >= 0 && (param1.a[_loc6_] & 1 << _loc10_) == 0)
{
_loc16_.sqrTo(_loc13_,_loc15_);
_loc12_ = _loc13_;
_loc13_ = _loc15_;
_loc15_ = _loc12_;
if(--_loc10_ < 0)
{
_loc10_ = 30 - 1;
_loc6_--;
}
}
}
return _loc16_.revert(_loc13_);
}
public function gcd(param1:BigInteger) : BigInteger
{
var _loc3_:BigInteger = null;
var _loc6_:BigInteger = s < 0 ? negate() : clone();
var _loc4_:BigInteger = param1.s < 0 ? param1.negate() : param1.clone();
if(_loc6_.compareTo(_loc4_) < 0)
{
_loc3_ = _loc6_;
_loc6_ = _loc4_;
_loc4_ = _loc3_;
}
var _loc5_:int = _loc6_.getLowestSetBit();
var _loc2_:int = _loc4_.getLowestSetBit();
if(_loc2_ < 0)
{
return _loc6_;
}
if(_loc5_ < _loc2_)
{
_loc2_ = _loc5_;
}
if(_loc2_ > 0)
{
_loc6_.rShiftTo(_loc2_,_loc6_);
_loc4_.rShiftTo(_loc2_,_loc4_);
}
while(_loc6_.sigNum() > 0)
{
_loc5_ = _loc6_.getLowestSetBit();
if(_loc5_ > 0)
{
_loc6_.rShiftTo(_loc5_,_loc6_);
}
_loc5_ = _loc4_.getLowestSetBit();
if(_loc5_ > 0)
{
_loc4_.rShiftTo(_loc5_,_loc4_);
}
if(_loc6_.compareTo(_loc4_) >= 0)
{
_loc6_.subTo(_loc4_,_loc6_);
_loc6_.rShiftTo(1,_loc6_);
}
else
{
_loc4_.subTo(_loc6_,_loc4_);
_loc4_.rShiftTo(1,_loc4_);
}
}
if(_loc2_ > 0)
{
_loc4_.lShiftTo(_loc2_,_loc4_);
}
return _loc4_;
}
protected function modInt(param1:int) : int
{
var _loc4_:int = 0;
if(param1 <= 0)
{
return 0;
}
var _loc2_:int = 1073741824 % param1;
var _loc3_:int = s < 0 ? param1 - 1 : 0;
if(t > 0)
{
if(_loc2_ == 0)
{
_loc3_ = a[0] % param1;
}
else
{
_loc4_ = t - 1;
while(_loc4_ >= 0)
{
_loc3_ = (_loc2_ * _loc3_ + a[_loc4_]) % param1;
_loc4_--;
}
}
}
return _loc3_;
}
public function modInverse(param1:BigInteger) : BigInteger
{
var _loc8_:Boolean = param1.isEven();
if(isEven() && _loc8_ || param1.sigNum() == 0)
{
return BigInteger.ZERO;
}
var _loc4_:BigInteger = param1.clone();
var _loc2_:BigInteger = clone();
var _loc7_:BigInteger = nbv(1);
var _loc5_:BigInteger = nbv(0);
var _loc6_:BigInteger = nbv(0);
var _loc3_:BigInteger = nbv(1);
while(_loc4_.sigNum() != 0)
{
while(_loc4_.isEven())
{
_loc4_.rShiftTo(1,_loc4_);
if(_loc8_)
{
if(!_loc7_.isEven() || !_loc5_.isEven())
{
_loc7_.addTo(this,_loc7_);
_loc5_.subTo(param1,_loc5_);
}
_loc7_.rShiftTo(1,_loc7_);
}
else if(!_loc5_.isEven())
{
_loc5_.subTo(param1,_loc5_);
}
_loc5_.rShiftTo(1,_loc5_);
}
while(_loc2_.isEven())
{
_loc2_.rShiftTo(1,_loc2_);
if(_loc8_)
{
if(!_loc6_.isEven() || !_loc3_.isEven())
{
_loc6_.addTo(this,_loc6_);
_loc3_.subTo(param1,_loc3_);
}
_loc6_.rShiftTo(1,_loc6_);
}
else if(!_loc3_.isEven())
{
_loc3_.subTo(param1,_loc3_);
}
_loc3_.rShiftTo(1,_loc3_);
}
if(_loc4_.compareTo(_loc2_) >= 0)
{
_loc4_.subTo(_loc2_,_loc4_);
if(_loc8_)
{
_loc7_.subTo(_loc6_,_loc7_);
}
_loc5_.subTo(_loc3_,_loc5_);
}
else
{
_loc2_.subTo(_loc4_,_loc2_);
if(_loc8_)
{
_loc6_.subTo(_loc7_,_loc6_);
}
_loc3_.subTo(_loc5_,_loc3_);
}
}
if(_loc2_.compareTo(BigInteger.ONE) != 0)
{
return BigInteger.ZERO;
}
if(_loc3_.compareTo(param1) >= 0)
{
return _loc3_.subtract(param1);
}
if(_loc3_.sigNum() < 0)
{
_loc3_.addTo(param1,_loc3_);
if(_loc3_.sigNum() < 0)
{
return _loc3_.add(param1);
}
return _loc3_;
}
return _loc3_;
}
public function isProbablePrime(param1:int) : Boolean
{
var _loc5_:int = 0;
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc4_:BigInteger = abs();
if(_loc4_.t == 1 && _loc4_.a[0] <= lowprimes[lowprimes.length - 1])
{
_loc5_ = 0;
while(_loc5_ < lowprimes.length)
{
if(_loc4_[0] == lowprimes[_loc5_])
{
return true;
}
_loc5_++;
}
return false;
}
if(_loc4_.isEven())
{
return false;
}
_loc5_ = 1;
loop1:
while(_loc5_ < lowprimes.length)
{
_loc2_ = int(lowprimes[_loc5_]);
_loc3_ = _loc5_ + 1;
while(_loc3_ < lowprimes.length && _loc2_ < lplim)
{
_loc2_ *= lowprimes[_loc3_++];
}
_loc2_ = _loc4_.modInt(_loc2_);
do
{
if(_loc5_ >= _loc3_)
{
continue loop1;
}
}
while(_loc2_ % lowprimes[_loc5_++] != 0);
return false;
}
return _loc4_.millerRabin(param1);
}
protected function millerRabin(param1:int) : Boolean
{
var _loc8_:int = 0;
var _loc7_:BigInteger = null;
var _loc5_:int = 0;
var _loc2_:BigInteger = subtract(BigInteger.ONE);
var _loc6_:int = _loc2_.getLowestSetBit();
if(_loc6_ <= 0)
{
return false;
}
var _loc3_:BigInteger = _loc2_.shiftRight(_loc6_);
param1 = param1 + 1 >> 1;
if(param1 > lowprimes.length)
{
param1 = int(lowprimes.length);
}
var _loc4_:BigInteger = new BigInteger();
_loc8_ = 0;
while(_loc8_ < param1)
{
_loc4_.fromInt(lowprimes[_loc8_]);
_loc7_ = _loc4_.modPow(_loc3_,this);
if(_loc7_.compareTo(BigInteger.ONE) != 0 && _loc7_.compareTo(_loc2_) != 0)
{
_loc5_ = 1;
while(_loc5_++ < _loc6_ && _loc7_.compareTo(_loc2_) != 0)
{
_loc7_ = _loc7_.modPowInt(2,this);
if(_loc7_.compareTo(BigInteger.ONE) == 0)
{
return false;
}
}
if(_loc7_.compareTo(_loc2_) != 0)
{
return false;
}
}
_loc8_++;
}
return true;
}
public function primify(param1:int, param2:int) : void
{
if(!testBit(param1 - 1))
{
bitwiseTo(BigInteger.ONE.shiftLeft(param1 - 1),op_or,this);
}
if(isEven())
{
dAddOffset(1,0);
}
while(!isProbablePrime(param2))
{
dAddOffset(2,0);
while(bitLength() > param1)
{
subTo(BigInteger.ONE.shiftLeft(param1 - 1),this);
}
}
}
}
}