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); } } } } }