package com.hurlant.math
{
    import _-0zz.*;
    import _-1qK.*;
    import _-2Lw.*;
    import _-Hv.*;
    import _-Ih.*;
    import flash.utils.*;

    public class BigInteger extends Object
    {
        var a:Array;
        var s:int;
        public var t:int;
        public static const _-0hK:BigInteger = _-1-f(1);
        public static const _-1y5:BigInteger = _-1-f(0);
        public static const _-1HA:int = _-27c - 1;
        public static const F1:int = 22;
        public static const F2:int = 8;
        public static const _-0rE:int = (1 << 26) / _-1y-[(_-1y-.length - 1)];
        public static const _-1y-: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 _-113:Number = Math.pow(2, _-2F);
        public static const _-2F:int = 52;
        public static const _-27c:int = 1 << _-11j;
        public static const _-11j:int = 30;

        public function BigInteger(param1 = null, param2:int = 0)
        {
            var _loc_3:ByteArray = null;
            var _loc_4:int = 0;
            a = new Array();
            if (param1 is String)
            {
                param1 = Hex._-td(param1);
                param2 = 0;
            }
            if (param1 is ByteArray)
            {
                _loc_3 = param1 as ByteArray;
                _loc_4 = param2 || _loc_3.length - _loc_3.position;
                _-7S(_loc_3, _loc_4);
            }
            return;
        }

        public function _-SP(param1:int) : BigInteger
        {
            return _-S2(param1, _-0CO);
        }

        private function _-5-(param1:int, param2:int) : int
        {
            return param1 | param2;
        }

        public function _-0KD() : BigInteger
        {
            var _loc_1:* = _-0mG();
            _-1y5._-11m(this, _loc_1);
            return _loc_1;
        }

        public function _-0mP(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-2Cx(param1, _-0CO, _loc_2);
            return _loc_2;
        }

        public function _-1nq(param1:BigInteger, param2:BigInteger) : BigInteger
        {
            var _loc_4:int = 0;
            var _loc_6:_-0Rn = null;
            var _loc_12:int = 0;
            var _loc_15:BigInteger = null;
            var _loc_16:BigInteger = null;
            var _loc_3:* = param1._-1g6();
            var _loc_5:* = _-1-f(1);
            if (_loc_3 <= 0)
            {
                return _loc_5;
            }
            if (_loc_3 < 18)
            {
                _loc_4 = 1;
            }
            else if (_loc_3 < 48)
            {
                _loc_4 = 3;
            }
            else if (_loc_3 < 144)
            {
                _loc_4 = 4;
            }
            else if (_loc_3 < 768)
            {
                _loc_4 = 5;
            }
            else
            {
                _loc_4 = 6;
            }
            if (_loc_3 < 8)
            {
                _loc_6 = new _-002(param2);
            }
            else if (param2._-0n7())
            {
                _loc_6 = new _-2BM(param2);
            }
            else
            {
                _loc_6 = new _-26X(param2);
            }
            var _loc_7:Array = [];
            var _loc_8:int = 3;
            var _loc_9:* = _loc_4 - 1;
            var _loc_10:* = (1 << _loc_4) - 1;
            _loc_7[1] = _loc_6._-23a(this);
            if (_loc_4 > 1)
            {
                _loc_16 = new BigInteger();
                _loc_6._-ou(_loc_7[1], _loc_16);
                while (_loc_8 <= _loc_10)
                {

                    _loc_7[_loc_8] = new BigInteger();
                    _loc_6._-0ch(_loc_16, _loc_7[_loc_8 - 2], _loc_7[_loc_8]);
                    _loc_8 = _loc_8 + 2;
                }
            }
            var _loc_11:* = param1.t - 1;
            var _loc_13:Boolean = true;
            var _loc_14:* = new BigInteger();
            _loc_3 = _-2K1(param1.a[_loc_11]) - 1;
            while (_loc_11 >= 0)
            {

                if (_loc_3 >= _loc_9)
                {
                    _loc_12 = param1.a[_loc_11] >> _loc_3 - _loc_9 & _loc_10;
                }
                else
                {
                    _loc_12 = (param1.a[_loc_11] & (1 << (_loc_3 + 1)) - 1) << _loc_9 - _loc_3;
                    if (_loc_11 > 0)
                    {
                        _loc_12 = _loc_12 | param1.a[(_loc_11 - 1)] >> _-11j + _loc_3 - _loc_9;
                    }
                }
                _loc_8 = _loc_4;
                while ((_loc_12 & 1) == 0)
                {

                    _loc_12 = _loc_12 >> 1;
                    _loc_8 = _loc_8 - 1;
                }
                var _loc_17:* = _loc_3 - _loc_8;
                _loc_3 = _loc_3 - _loc_8;
                if (_loc_17 < 0)
                {
                    _loc_3 = _loc_3 + _-11j;
                    _loc_11 = _loc_11 - 1;
                }
                if (_loc_13)
                {
                    _loc_7[_loc_12].copyTo(_loc_5);
                    _loc_13 = false;
                }
                else
                {
                    while (_loc_8 > 1)
                    {

                        _loc_6._-ou(_loc_5, _loc_14);
                        _loc_6._-ou(_loc_14, _loc_5);
                        _loc_8 = _loc_8 - 2;
                    }
                    if (_loc_8 > 0)
                    {
                        _loc_6._-ou(_loc_5, _loc_14);
                    }
                    else
                    {
                        _loc_15 = _loc_5;
                        _loc_5 = _loc_14;
                        _loc_14 = _loc_15;
                    }
                    _loc_6._-0ch(_loc_14, _loc_7[_loc_12], _loc_5);
                }
                while (_loc_11 >= 0 && (param1.a[_loc_11] & 1 << --_loc_3) == 0)
                {

                    _loc_6._-ou(_loc_5, _loc_14);
                    _loc_15 = _loc_5;
                    _loc_5 = _loc_14;
                    _loc_14 = _loc_15;
                    if (--_loc_3 < 0)
                    {
                        --_loc_3 = _-11j - 1;
                        _loc_11 = _loc_11 - 1;
                    }
                }
            }
            return _loc_6._-0o-(_loc_5);
        }

        public function _-F(param1:int) : Boolean
        {
            var _loc_2:int = 0;
            var _loc_4:int = 0;
            var _loc_5:int = 0;
            var _loc_3:* = abs();
            if (_loc_3.t == 1 && _loc_3.a[0] <= _-1y-[(_-1y-.length - 1)])
            {
                _loc_2 = 0;
                while (_loc_2 < _-1y-.length)
                {

                    if (_loc_3[0] == _-1y-[_loc_2])
                    {
                        return true;
                    }
                    _loc_2++;
                }
                return false;
            }
            if (_loc_3._-0n7())
            {
                return false;
            }
            _loc_2 = 1;
            while (_loc_2 < _-1y-.length)
            {

                _loc_4 = _-1y-[_loc_2];
                _loc_5 = _loc_2 + 1;
                while (_loc_5 < _-1y-.length && _loc_4 < _-0rE)
                {

                    _loc_4 = _loc_4 * _-1y-[_loc_5++];
                }
                _loc_4 = _loc_3._-2E1(_loc_4);
                while (_loc_2 < _loc_5)
                {

                    if (_loc_4 % _-1y-[_loc_2++] == 0)
                    {
                        return false;
                    }
                }
            }
            return _loc_3._-xk(param1);
        }

        public function _-0EK(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-1Eh(param1, _loc_2, null);
            return _loc_2;
        }

        public function mod(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = _-0mG();
            abs()._-1Eh(param1, null, _loc_2);
            if (s < 0 && _loc_2.compareTo(_-1y5) > 0)
            {
                param1._-11m(_loc_2, _loc_2);
            }
            return _loc_2;
        }

        public function _-Ad(param1:BigInteger, param2:BigInteger) : void
        {
            var _loc_3:int = 0;
            var _loc_4:int = 0;
            var _loc_5:* = Math.min(param1.t, t);
            while (_loc_3 < _loc_5)
            {

                _loc_4 = _loc_4 + (this.a[_loc_3] + param1.a[_loc_3]);
                param2.a[++_loc_3] = _loc_4 & _-1HA;
                _loc_4 = _loc_4 >> _-11j;
            }
            if (param1.t < t)
            {
                _loc_4 = _loc_4 + param1.s;
                while (_loc_3 < t)
                {

                    _loc_4 = _loc_4 + this.a[_loc_3];
                    param2.a[++_loc_3] = _loc_4 & _-1HA;
                    _loc_4 = _loc_4 >> _-11j;
                }
                _loc_4 = _loc_4 + s;
            }
            else
            {
                _loc_4 = _loc_4 + s;
                while (_loc_3 < param1.t)
                {

                    _loc_4 = _loc_4 + param1.a[_loc_3];
                    param2.a[++_loc_3] = _loc_4 & _-1HA;
                    _loc_4 = _loc_4 >> _-11j;
                }
                _loc_4 = _loc_4 + param1.s;
            }
            param2.s = _loc_4 < 0 ? (-1) : (0);
            if (_loc_4 > 0)
            {
                param2.a[++_loc_3] = _loc_4;
            }
            else if (_loc_4 < -1)
            {
                param2.a[++_loc_3] = _-27c + _loc_4;
            }
            param2.t = _loc_3;
            param2._-0x5();
            return;
        }

        public function _-2Cx(param1:BigInteger, param2:Function, param3:BigInteger) : void
        {
            var _loc_4:int = 0;
            var _loc_5:int = 0;
            var _loc_6:* = Math.min(param1.t, t);
            _loc_4 = 0;
            while (_loc_4 < _loc_6)
            {

                param3.a[_loc_4] = this.param2(this.a[_loc_4], param1.a[_loc_4]);
                _loc_4++;
            }
            if (param1.t < t)
            {
                _loc_5 = param1.s & _-1HA;
                _loc_4 = _loc_6;
                while (_loc_4 < t)
                {

                    param3.a[_loc_4] = this.param2(this.a[_loc_4], _loc_5);
                    _loc_4++;
                }
                param3.t = t;
            }
            else
            {
                _loc_5 = s & _-1HA;
                _loc_4 = _loc_6;
                while (_loc_4 < param1.t)
                {

                    param3.a[_loc_4] = this.param2(_loc_5, param1.a[_loc_4]);
                    _loc_4++;
                }
                param3.t = param1.t;
            }
            param3.s = this.param2(s, param1.s);
            param3._-0x5();
            return;
        }

        public function _-2E1(param1:int) : int
        {
            var _loc_4:int = 0;
            if (param1 <= 0)
            {
                return 0;
            }
            var _loc_2:* = _-27c % param1;
            var _loc_3:* = s < 0 ? ((param1 - 1)) : (0);
            if (t > 0)
            {
                if (_loc_2 == 0)
                {
                    _loc_3 = a[0] % param1;
                }
                else
                {
                    _loc_4 = t - 1;
                    while (_loc_4 >= 0)
                    {

                        _loc_3 = (_loc_2 * _loc_3 + a[_loc_4]) % param1;
                        _loc_4 = _loc_4 - 1;
                    }
                }
            }
            return _loc_3;
        }

        public function _-0ww(param1:Number) : int
        {
            return Math.floor(Math.LN2 * _-11j / Math.log(param1));
        }

        public function _-0Kt(param1:BigInteger) : BigInteger
        {
            var _loc_6:BigInteger = null;
            var _loc_2:* = s < 0 ? (_-0KD()) : (clone());
            var _loc_3:* = param1.s < 0 ? (param1._-0KD()) : (param1.clone());
            if (_loc_2.compareTo(_loc_3) < 0)
            {
                _loc_6 = _loc_2;
                _loc_2 = _loc_3;
                _loc_3 = _loc_6;
            }
            var _loc_4:* = _loc_2._-0S6();
            var _loc_5:* = _loc_3._-0S6();
            if (_loc_5 < 0)
            {
                return _loc_2;
            }
            if (_loc_4 < _loc_5)
            {
                _loc_5 = _loc_4;
            }
            if (_loc_5 > 0)
            {
                _loc_2._-5x(_loc_5, _loc_2);
                _loc_3._-5x(_loc_5, _loc_3);
            }
            while (_loc_2._-08u() > 0)
            {

                var _loc_7:* = _loc_2._-0S6();
                _loc_4 = _loc_2._-0S6();
                if (_loc_7 > 0)
                {
                    _loc_2._-5x(_loc_4, _loc_2);
                }
                var _loc_7:* = _loc_3._-0S6();
                _loc_4 = _loc_3._-0S6();
                if (_loc_7 > 0)
                {
                    _loc_3._-5x(_loc_4, _loc_3);
                }
                if (_loc_2.compareTo(_loc_3) >= 0)
                {
                    _loc_2._-11m(_loc_3, _loc_2);
                    _loc_2._-5x(1, _loc_2);
                    continue;
                }
                _loc_3._-11m(_loc_2, _loc_3);
                _loc_3._-5x(1, _loc_3);
            }
            if (_loc_5 > 0)
            {
                _loc_3._-1CD(_loc_5, _loc_3);
            }
            return _loc_3;
        }

        function _-2FR(param1:int, param2:int) : void
        {
            while (t <= param2)
            {

                var _loc_3:* = t + 1;
                a[_loc_3] = 0;
            }
            a[param2] = a[param2] + param1;
            while (a[_loc_2] >= _-27c)
            {

                a[param2] = a[param2] - _-27c;
                if (++param2 >= t)
                {
                    var _loc_3:* = t + 1;
                    a[_loc_3] = 0;
                }
                var _loc_3:* = a;
                var _loc_5:* = a[++param2] + 1;
                _loc_3[++param2] = _loc_5;
            }
            return;
        }

        function _-1CD(param1:int, param2:BigInteger) : void
        {
            var _loc_8:int = 0;
            var _loc_3:* = param1 % _-11j;
            var _loc_4:* = _-11j - _loc_3;
            var _loc_5:* = (1 << _loc_4) - 1;
            var _loc_6:* = param1 / _-11j;
            var _loc_7:* = s << _loc_3 & _-1HA;
            _loc_8 = t - 1;
            while (_loc_8 >= 0)
            {

                param2.a[_loc_8 + _loc_6 + 1] = a[_loc_8] >> _loc_4 | _loc_7;
                _loc_7 = (a[_loc_8] & _loc_5) << _loc_3;
                _loc_8 = _loc_8 - 1;
            }
            _loc_8 = _loc_6 - 1;
            while (_loc_8 >= 0)
            {

                param2.a[_loc_8] = 0;
                _loc_8 = _loc_8 - 1;
            }
            param2.a[_loc_6] = _loc_7;
            param2.t = t + _loc_6 + 1;
            param2.s = s;
            param2._-0x5();
            return;
        }

        public function _-0S6() : int
        {
            var _loc_1:int = 0;
            while (_loc_1 < t)
            {

                if (a[_loc_1] != 0)
                {
                    return _loc_1 * _-11j + _-2Aw(a[_loc_1]);
                }
                _loc_1++;
            }
            if (s < 0)
            {
                return t * _-11j;
            }
            return -1;
        }

        public function subtract(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-11m(param1, _loc_2);
            return _loc_2;
        }

        public function _-0oP(param1:int, param2:int) : void
        {
            if (!_-ym((param1 - 1)))
            {
                _-2Cx(BigInteger._-0hK._-20b((param1 - 1)), _-5-, this);
            }
            if (_-0n7())
            {
                _-2FR(1, 0);
            }
            while (!_-F(param2))
            {

                _-2FR(2, 0);
                while (_-1g6() > param1)
                {

                    _-11m(BigInteger._-0hK._-20b((param1 - 1)), this);
                }
            }
            return;
        }

        function _-0id(param1:BigInteger, param2:int, param3:BigInteger) : void
        {
            var _loc_5:int = 0;
            var _loc_4:* = Math.min(t + param1.t, param2);
            param3.s = 0;
            param3.t = _loc_4;
            while (--_loc_4 > 0)
            {

                param3.a[--_loc_4] = 0;
            }
            _loc_5 = param3.t - t;
            while (_loc_4 < _loc_5)
            {

                param3.a[_loc_4 + t] = _-7i(0, param1.a[_loc_4], param3, _loc_4, 0, t);
                _loc_4++;
            }
            _loc_5 = Math.min(param1.t, param2);
            while (_loc_4 < _loc_5)
            {

                _-7i(0, param1.a[_loc_4], param3, _loc_4, 0, param2 - _loc_4);
                _loc_4++;
            }
            param3._-0x5();
            return;
        }

        public function _-0uK(param1:int, param2:BigInteger) : BigInteger
        {
            var _loc_3:_-0Rn = null;
            if (param1 < 256 || param2._-0n7())
            {
                _loc_3 = new _-002(param2);
            }
            else
            {
                _loc_3 = new _-26X(param2);
            }
            return _-fl(param1, _loc_3);
        }

        function _-lk(param1:String, param2:int) : int
        {
            return parseInt(param1.charAt(param2), 36);
        }

        public function _-ym(param1:int) : Boolean
        {
            var _loc_2:* = Math.floor(param1 / _-11j);
            if (_loc_2 >= t)
            {
                return s != 0;
            }
            return (a[_loc_2] & 1 << param1 % _-11j) != 0;
        }

        function _-fl(param1:int, param2:_-0Rn) : BigInteger
        {
            var _loc_7:BigInteger = null;
            if (param1 > 4294967295 || param1 < 1)
            {
                return _-0hK;
            }
            var _loc_3:* = _-0mG();
            var _loc_4:* = _-0mG();
            var _loc_5:* = param2._-23a(this);
            var _loc_6:* = _-2K1(param1) - 1;
            _loc_5.copyTo(_loc_3);
            while (--_loc_6 >= 0)
            {

                param2._-ou(_loc_3, _loc_4);
                if ((param1 & 1 << _loc_6) > 0)
                {
                    param2._-0ch(_loc_4, _loc_5, _loc_3);
                    continue;
                }
                _loc_7 = _loc_3;
                _loc_3 = _loc_4;
                _loc_4 = _loc_7;
            }
            return param2._-0o-(_loc_3);
        }

        public function _-td(param1:ByteArray) : uint
        {
            var _loc_2:int = 8;
            var _loc_3:* = (1 << 8) - 1;
            var _loc_4:int = 0;
            var _loc_5:* = t;
            var _loc_6:* = _-11j - _loc_5 * _-11j % _loc_2;
            var _loc_7:Boolean = false;
            var _loc_8:int = 0;
            if (_loc_5-- > 0)
            {
                var _loc_9:* = a[_loc_5] >> _loc_6;
                _loc_4 = a[_loc_5] >> _loc_6;
                if (_loc_6 < _-11j && _loc_9 > 0)
                {
                    _loc_7 = true;
                    param1.writeByte(_loc_4);
                    _loc_8++;
                }
                while (_loc_5 >= 0)
                {

                    if (_loc_6 < _loc_2)
                    {
                        _loc_4 = (a[_loc_5] & (1 << _loc_6) - 1) << _loc_2 - _loc_6;
                        var _loc_9:* = _loc_6 + (_-11j - _loc_2);
                        _loc_6 = _loc_6 + (_-11j - _loc_2);
                        _loc_4 = _loc_4 | a[--_loc_5] >> _loc_9;
                    }
                    else
                    {
                        var _loc_9:* = _loc_6 - _loc_2;
                        _loc_6 = _loc_6 - _loc_2;
                        _loc_4 = a[--_loc_5] >> _loc_9 & _loc_3;
                        if (_loc_6 <= 0)
                        {
                            _loc_6 = _loc_6 + _-11j;
                            _loc_5 = _loc_5 - 1;
                        }
                    }
                    if (_loc_4 > 0)
                    {
                        _loc_7 = true;
                    }
                    if (_loc_7)
                    {
                        param1.writeByte(_loc_4);
                        _loc_8++;
                    }
                }
            }
            return _loc_8;
        }

        public function dispose() : void
        {
            var _loc_1:* = new _-1fe();
            var _loc_2:uint = 0;
            while (_loc_2 < a.length)
            {

                a[_loc_2] = _loc_1._-0mm();
                delete a[_loc_2];
                _loc_2 = _loc_2 + 1;
            }
            a = null;
            t = 0;
            s = 0;
            _-wA._-1Gn();
            return;
        }

        private function _-2Aw(param1:int) : int
        {
            if (param1 == 0)
            {
                return -1;
            }
            var _loc_2:int = 0;
            if ((param1 & 65535) == 0)
            {
                param1 = param1 >> 16;
                _loc_2 = _loc_2 + 16;
            }
            if ((param1 & 255) == 0)
            {
                param1 = param1 >> 8;
                _loc_2 = _loc_2 + 8;
            }
            if ((param1 & 15) == 0)
            {
                param1 = param1 >> 4;
                _loc_2 = _loc_2 + 4;
            }
            if ((param1 & 3) == 0)
            {
                param1 = param1 >> 2;
                _loc_2 = _loc_2 + 2;
            }
            if ((param1 & 1) == 0)
            {
                _loc_2++;
            }
            return _loc_2;
        }

        function _-1Eh(param1:BigInteger, param2:BigInteger = null, param3:BigInteger = null) : void
        {
            var qd:int;
            var m:* = param1;
            var q:* = param2;
            var r:* = param3;
            var pm:* = m.abs();
            if (pm.t <= 0)
            {
                return;
            }
            var pt:* = abs();
            if (pt.t < pm.t)
            {
                if (q != null)
                {
                    q._-16t(0);
                }
                if (r != null)
                {
                    copyTo(r);
                }
                return;
            }
            if (r == null)
            {
                r = _-0mG();
            }
            var y:* = _-0mG();
            var ts:* = s;
            var ms:* = m.s;
            var nsh:* = _-11j - _-2K1(pm.a[(pm.t - 1)]);
            if (nsh > 0)
            {
                pm._-1CD(nsh, y);
                pt._-1CD(nsh, r);
            }
            else
            {
                pm.copyTo(y);
                pt.copyTo(r);
            }
            var ys:* = y.t;
            var y0:* = y.a[(ys - 1)];
            if (y0 == 0)
            {
                return;
            }
            var yt:* = y0 * (1 << F1) + (ys > 1 ? (y.a[ys - 2] >> F2) : (0));
            var d1:* = _-113 / yt;
            var d2:* = (1 << F1) / yt;
            var e:* = 1 << F2;
            var i:* = r.t;
            var j:* = i - ys;
            var t:* = q == null ? (_-0mG()) : (q);
            y._-uZ(j, t);
            if (r.compareTo(t) >= 0)
            {
                var _loc_6:* = r;
                _loc_6.t = r.t + 1;
                r.a[++r.t] = 1;
                r._-11m(t, r);
            }
            _-0hK._-uZ(ys, t);
            t._-11m(y, y);
            while (y.t < ys)
            {

                var _loc_6:int = 0;
                var _loc_7:* = y;
                var _loc_5:* = new XMLList("");
                for each (_loc_8 in _loc_7)
                {

                    var _loc_9:* = _loc_7[_loc_6];
                    with (_loc_7[_loc_6])
                    {
                        var _loc_10:* = y;
                        var _loc_11:* = y.t + 1;
                        _loc_10.t = _loc_11;
                        if (0)
                        {
                            _loc_5[_loc_6] = _loc_8;
                        }
                    }
                }
            }
            do
            {

                i = (i - 1);
                qd = r.a[(i - 1)] == y0 ? (_-1HA) : (Number(r.a[i]) * d1 + (Number(r.a[(i - 1)]) + e) * d2);
                var _loc_5:* = r.a[i] + y._-7i(0, qd, r, j, 0, ys);
                r.a[i] = r.a[i] + y._-7i(0, qd, r, j, 0, ys);
                if (_loc_5 < qd)
                {
                    y._-uZ(j, t);
                    r._-11m(t, r);
                    do
                    {

                        r._-11m(t, r);
                        qd = (qd - 1);
                    }while (r.a[i] < (qd - 1))
                }
                j = (j - 1);
            }while ((j - 1) >= 0)
            if (q != null)
            {
                r._-0IF(ys, q);
                if (ts != ms)
                {
                    _-1y5._-11m(q, q);
                }
            }
            r.t = ys;
            r._-0x5();
            if (nsh > 0)
            {
                r._-5x(nsh, r);
            }
            if (ts < 0)
            {
                _-1y5._-11m(r, r);
            }
            return;
        }

        public function _-2IY(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-1Eh(param1, null, _loc_2);
            return _loc_2;
        }

        function _-1IU(param1:BigInteger, param2:int, param3:BigInteger) : void
        {
            param2 = param2 - 1;
            var _loc_5:* = t + param1.t - param2;
            param3.t = t + param1.t - param2;
            var _loc_4:* = _loc_5;
            param3.s = 0;
            while (--_loc_4 >= 0)
            {

                param3.a[_loc_4] = 0;
            }
            --_loc_4 = Math.max(param2 - t, 0);
            while (_loc_4 < param1.t)
            {

                param3.a[t + --_loc_4 - param2] = _-7i(param2 - _loc_4, param1.a[_loc_4], param3, 0, 0, t + _loc_4 - param2);
                _loc_4++;
            }
            param3._-0x5();
            param3._-0IF(1, param3);
            return;
        }

        public function _-1Nb(param1:BigInteger) : Array
        {
            var _loc_2:* = new BigInteger();
            var _loc_3:* = new BigInteger();
            _-1Eh(param1, _loc_2, _loc_3);
            return [_loc_2, _loc_3];
        }

        public function valueOf() : Number
        {
            var _loc_1:Number = 1;
            var _loc_2:Number = 0;
            var _loc_3:uint = 0;
            while (_loc_3 < t)
            {

                _loc_2 = _loc_2 + a[_loc_3] * _loc_1;
                _loc_1 = _loc_1 * _-27c;
                _loc_3 = _loc_3 + 1;
            }
            return _loc_2;
        }

        public function _-20b(param1:int) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            if (param1 < 0)
            {
                _-5x(-param1, _loc_2);
            }
            else
            {
                _-1CD(param1, _loc_2);
            }
            return _loc_2;
        }

        public function _-ac(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-AS(param1, _loc_2);
            return _loc_2;
        }

        function _-7i(param1:int, param2:int, param3:BigInteger, param4:int, param5:int, param6:int) : int
        {
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_7:* = param2 & 32767;
            var _loc_8:* = param2 >> 15;
            while (--param6 >= 0)
            {

                _loc_9 = a[param1] & 32767;
                _loc_10 = a[param1++] >> 15;
                _loc_11 = _loc_8 * _loc_9 + _loc_10 * _loc_7;
                _loc_9 = _loc_7 * _loc_9 + ((_loc_11 & 32767) << 15) + param3.a[param4] + (param5 & 1073741823);
                param5 = (_loc_9 >>> 30) + (_loc_11 >>> 15) + _loc_8 * _loc_10 + (param5 >>> 30);
                param3.a[++param4] = _loc_9 & 1073741823;
            }
            return param5;
        }

        function _-0IF(param1:int, param2:BigInteger) : void
        {
            var _loc_3:int = 0;
            _loc_3 = param1;
            while (_loc_3 < t)
            {

                param2.a[_loc_3 - param1] = a[_loc_3];
                _loc_3++;
            }
            param2.t = Math.max(t - param1, 0);
            param2.s = s;
            return;
        }

        public function add(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-Ad(param1, _loc_2);
            return _loc_2;
        }

        public function _-0mG()
        {
            return new BigInteger();
        }

        public function _-xk(param1:int) : Boolean
        {
            var _loc_7:BigInteger = null;
            var _loc_8:int = 0;
            var _loc_2:* = subtract(BigInteger._-0hK);
            var _loc_3:* = _loc_2._-0S6();
            if (_loc_3 <= 0)
            {
                return false;
            }
            var _loc_4:* = _loc_2._-0Ao(_loc_3);
            param1 = (param1 + 1) >> 1;
            if (param1 > _-1y-.length)
            {
                param1 = _-1y-.length;
            }
            var _loc_5:* = new BigInteger();
            var _loc_6:int = 0;
            while (_loc_6 < param1)
            {

                _loc_5._-16t(_-1y-[_loc_6]);
                _loc_7 = _loc_5._-1nq(_loc_4, this);
                if (_loc_7.compareTo(BigInteger._-0hK) != 0 && _loc_7.compareTo(_loc_2) != 0)
                {
                    _loc_8 = 1;
                    while (_loc_8++ < _loc_3 && _loc_7.compareTo(_loc_2) != 0)
                    {

                        _loc_7 = _loc_7._-0uK(2, this);
                        if (_loc_7.compareTo(BigInteger._-0hK) == 0)
                        {
                            return false;
                        }
                    }
                    if (_loc_7.compareTo(_loc_2) != 0)
                    {
                        return false;
                    }
                }
                _loc_6++;
            }
            return true;
        }

        function _-DR(param1:int) : void
        {
            a[t] = _-7i(0, (param1 - 1), this, 0, 0, t);
            var _loc_3:* = t + 1;
            t = _loc_3;
            _-0x5();
            return;
        }

        private function _-0CO(param1:int, param2:int) : int
        {
            return param1 & ~param2;
        }

        function _-0x5() : void
        {
            var _loc_1:* = s & _-1HA;
            while (t > 0 && a[(t - 1)] == _loc_1)
            {

                var _loc_3:* = t - 1;
                t = _loc_3;
            }
            return;
        }

        function _-1qc() : int
        {
            if (t < 1)
            {
                return 0;
            }
            var _loc_1:* = a[0];
            if ((_loc_1 & 1) == 0)
            {
                return 0;
            }
            var _loc_2:* = _loc_1 & 3;
            _loc_2 = _loc_2 * (2 - (_loc_1 & 15) * _loc_2) & 15;
            _loc_2 = _loc_2 * (2 - (_loc_1 & 255) * _loc_2) & 255;
            _loc_2 = _loc_2 * (2 - ((_loc_1 & 65535) * _loc_2 & 65535)) & 65535;
            _loc_2 = _loc_2 * (2 - _loc_1 * _loc_2 % _-27c) % _-27c;
            return _loc_2 > 0 ? (_-27c - _loc_2) : (-_loc_2);
        }

        public function _-S2(param1:int, param2:Function) : BigInteger
        {
            var _loc_3:* = BigInteger._-0hK._-20b(param1);
            _-2Cx(_loc_3, param2, _loc_3);
            return _loc_3;
        }

        public function equals(param1:BigInteger) : Boolean
        {
            return compareTo(param1) == 0;
        }

        public function compareTo(param1:BigInteger) : int
        {
            var _loc_2:* = s - param1.s;
            if (_loc_2 != 0)
            {
                return _loc_2;
            }
            var _loc_3:* = t;
            _loc_2 = _loc_3 - param1.t;
            if (_loc_2 != 0)
            {
                return _loc_2;
            }
            while (--_loc_3 >= 0)
            {

                _loc_2 = a[_loc_3] - param1.a[_loc_3];
                if (_loc_2 != 0)
                {
                    return _loc_2;
                }
            }
            return 0;
        }

        public function _-0Ao(param1:int) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            if (param1 < 0)
            {
                _-1CD(-param1, _loc_2);
            }
            else
            {
                _-5x(param1, _loc_2);
            }
            return _loc_2;
        }

        function _-AS(param1:BigInteger, param2:BigInteger) : void
        {
            var _loc_3:* = abs();
            var _loc_4:* = param1.abs();
            var _loc_5:* = _loc_3.t;
            param2.t = _loc_5 + _loc_4.t;
            while (--_loc_5 >= 0)
            {

                param2.a[_loc_5] = 0;
            }
            --_loc_5 = 0;
            while (_loc_5 < _loc_4.t)
            {

                param2.a[--_loc_5 + _loc_3.t] = _loc_3._-7i(0, _loc_4.a[_loc_5], param2, _loc_5, 0, _loc_3.t);
                _loc_5++;
            }
            param2.s = 0;
            param2._-0x5();
            if (s != param1.s)
            {
                _-1y5._-11m(param2, param2);
            }
            return;
        }

        public function _-1zS() : int
        {
            var _loc_1:int = 0;
            var _loc_2:* = s & _-1HA;
            var _loc_3:int = 0;
            while (_loc_3 < t)
            {

                _loc_1 = _loc_1 + _-0gM(a[_loc_3] ^ _loc_2);
                _loc_3++;
            }
            return _loc_1;
        }

        public function _-jz(param1:uint = 10) : String
        {
            if (_-08u() == 0 || param1 < 2 || param1 > 32)
            {
                return "0";
            }
            var _loc_2:* = _-0ww(param1);
            var _loc_3:* = Math.pow(param1, _loc_2);
            var _loc_4:* = _-1-f(_loc_3);
            var _loc_5:* = _-0mG();
            var _loc_6:* = _-0mG();
            var _loc_7:String = "";
            _-1Eh(_loc_4, _loc_5, _loc_6);
            while (_loc_5._-08u() > 0)
            {

                _loc_7 = (_loc_3 + _loc_6._-iO()).toString(param1).substr(1) + _loc_7;
                _loc_5._-1Eh(_loc_4, _loc_5, _loc_6);
            }
            return _loc_6._-iO().toString(param1) + _loc_7;
        }

        private function _-0gM(param1:int) : int
        {
            var _loc_2:uint = 0;
            while (param1 != 0)
            {

                param1 = param1 & (param1 - 1);
                _loc_2 = _loc_2 + 1;
            }
            return _loc_2;
        }

        function _-5x(param1:int, param2:BigInteger) : void
        {
            var _loc_7:int = 0;
            param2.s = s;
            var _loc_3:* = param1 / _-11j;
            if (_loc_3 >= t)
            {
                param2.t = 0;
                return;
            }
            var _loc_4:* = param1 % _-11j;
            var _loc_5:* = _-11j - _loc_4;
            var _loc_6:* = (1 << _loc_4) - 1;
            param2.a[0] = a[_loc_3] >> _loc_4;
            _loc_7 = _loc_3 + 1;
            while (_loc_7 < t)
            {

                param2.a[_loc_7 - _loc_3 - 1] = param2.a[_loc_7 - _loc_3 - 1] | (a[_loc_7] & _loc_6) << _loc_5;
                param2.a[_loc_7 - _loc_3] = a[_loc_7] >> _loc_4;
                _loc_7++;
            }
            if (_loc_4 > 0)
            {
                param2.a[t - _loc_3 - 1] = param2.a[t - _loc_3 - 1] | (s & _loc_6) << _loc_5;
            }
            param2.t = t - _loc_3;
            param2._-0x5();
            return;
        }

        public function _-10t(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = param1._-0n7();
            if (_-0n7() && _loc_2 || param1._-08u() == 0)
            {
                return BigInteger._-1y5;
            }
            var _loc_3:* = param1.clone();
            var _loc_4:* = clone();
            var _loc_5:* = _-1-f(1);
            var _loc_6:* = _-1-f(0);
            var _loc_7:* = _-1-f(0);
            var _loc_8:* = _-1-f(1);
            while (_loc_3._-08u() != 0)
            {

                while (_loc_3._-0n7())
                {

                    _loc_3._-5x(1, _loc_3);
                    if (_loc_2)
                    {
                        if (!_loc_5._-0n7() || !_loc_6._-0n7())
                        {
                            _loc_5._-Ad(this, _loc_5);
                            _loc_6._-11m(param1, _loc_6);
                        }
                        _loc_5._-5x(1, _loc_5);
                    }
                    else if (!_loc_6._-0n7())
                    {
                        _loc_6._-11m(param1, _loc_6);
                    }
                    _loc_6._-5x(1, _loc_6);
                }
                while (_loc_4._-0n7())
                {

                    _loc_4._-5x(1, _loc_4);
                    if (_loc_2)
                    {
                        if (!_loc_7._-0n7() || !_loc_8._-0n7())
                        {
                            _loc_7._-Ad(this, _loc_7);
                            _loc_8._-11m(param1, _loc_8);
                        }
                        _loc_7._-5x(1, _loc_7);
                    }
                    else if (!_loc_8._-0n7())
                    {
                        _loc_8._-11m(param1, _loc_8);
                    }
                    _loc_8._-5x(1, _loc_8);
                }
                if (_loc_3.compareTo(_loc_4) >= 0)
                {
                    _loc_3._-11m(_loc_4, _loc_3);
                    if (_loc_2)
                    {
                        _loc_5._-11m(_loc_7, _loc_5);
                    }
                    _loc_6._-11m(_loc_8, _loc_6);
                    continue;
                }
                _loc_4._-11m(_loc_3, _loc_4);
                if (_loc_2)
                {
                    _loc_7._-11m(_loc_5, _loc_7);
                }
                _loc_8._-11m(_loc_6, _loc_8);
            }
            if (_loc_4.compareTo(BigInteger._-0hK) != 0)
            {
                return BigInteger._-1y5;
            }
            if (_loc_8.compareTo(param1) >= 0)
            {
                return _loc_8.subtract(param1);
            }
            if (_loc_8._-08u() < 0)
            {
                _loc_8._-Ad(param1, _loc_8);
                ;
            }
            return _loc_8;
        }

        function _-7S(param1:ByteArray, param2:int) : void
        {
            var _loc_7:int = 0;
            var _loc_3:* = param1.position;
            var _loc_4:* = _loc_3 + param2;
            var _loc_5:int = 0;
            var _loc_6:int = 8;
            t = 0;
            s = 0;
            while (--_loc_4 >= _loc_3)
            {

                _loc_7 = _loc_4 < param1.length ? (param1[_loc_4]) : (0);
                if (_loc_5 == 0)
                {
                    a[++t] = _loc_7;
                }
                else if (_loc_5 + _loc_6 > _-11j)
                {
                    a[(t - 1)] = a[(t - 1)] | (_loc_7 & (1 << _-11j - _loc_5) - 1) << _loc_5;
                    a[++t] = _loc_7 >> _-11j - _loc_5;
                }
                else
                {
                    a[(t - 1)] = a[(t - 1)] | _loc_7 << _loc_5;
                }
                _loc_5 = _loc_5 + _loc_6;
                if (_loc_5 >= _-11j)
                {
                    _loc_5 = _loc_5 - _-11j;
                }
            }
            _-0x5();
            param1.position = Math.min(_loc_3 + param2, param1.length);
            return;
        }

        function copyTo(param1:BigInteger) : void
        {
            var _loc_2:* = t - 1;
            while (_loc_2 >= 0)
            {

                param1.a[_loc_2] = a[_loc_2];
                _loc_2 = _loc_2 - 1;
            }
            param1.t = t;
            param1.s = s;
            return;
        }

        public function _-iO() : int
        {
            if (s < 0)
            {
                if (t == 1)
                {
                    return a[0] - _-27c;
                }
                if (t == 0)
                {
                    return -1;
                }
            }
            else
            {
                if (t == 1)
                {
                    return a[0];
                }
                if (t == 0)
                {
                    return 0;
                }
            }
            return (a[1] & (1 << 32 - _-11j) - 1) << _-11j | a[0];
        }

        public function min(param1:BigInteger) : BigInteger
        {
            return compareTo(param1) < 0 ? (this) : (param1);
        }

        public function _-1g6() : int
        {
            if (t <= 0)
            {
                return 0;
            }
            return _-11j * (t - 1) + _-2K1(a[(t - 1)] ^ s & _-1HA);
        }

        public function _-1Qs() : int
        {
            return t == 0 ? (s) : (a[0] << 16 >> 16);
        }

        public function _-d6(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-2Cx(param1, _-0YN, _loc_2);
            return _loc_2;
        }

        public function _-1s() : int
        {
            return t == 0 ? (s) : (a[0] << 24 >> 24);
        }

        public function _-NU() : BigInteger
        {
            var _loc_1:* = new BigInteger();
            var _loc_2:int = 0;
            while (_loc_2 < t)
            {

                _loc_1[_loc_2] = _-1HA & ~a[_loc_2];
                _loc_2++;
            }
            _loc_1.t = t;
            _loc_1.s = ~s;
            return _loc_1;
        }

        function _-11m(param1:BigInteger, param2:BigInteger) : void
        {
            var _loc_3:int = 0;
            var _loc_4:int = 0;
            var _loc_5:* = Math.min(param1.t, t);
            while (_loc_3 < _loc_5)
            {

                _loc_4 = _loc_4 + (a[_loc_3] - param1.a[_loc_3]);
                param2.a[++_loc_3] = _loc_4 & _-1HA;
                _loc_4 = _loc_4 >> _-11j;
            }
            if (param1.t < t)
            {
                _loc_4 = _loc_4 - param1.s;
                while (_loc_3 < t)
                {

                    _loc_4 = _loc_4 + a[_loc_3];
                    param2.a[++_loc_3] = _loc_4 & _-1HA;
                    _loc_4 = _loc_4 >> _-11j;
                }
                _loc_4 = _loc_4 + s;
            }
            else
            {
                _loc_4 = _loc_4 + s;
                while (_loc_3 < param1.t)
                {

                    _loc_4 = _loc_4 - param1.a[_loc_3];
                    param2.a[++_loc_3] = _loc_4 & _-1HA;
                    _loc_4 = _loc_4 >> _-11j;
                }
                _loc_4 = _loc_4 - param1.s;
            }
            param2.s = _loc_4 < 0 ? (-1) : (0);
            if (_loc_4 < -1)
            {
                param2.a[++_loc_3] = _-27c + _loc_4;
            }
            else if (_loc_4 > 0)
            {
                param2.a[++_loc_3] = _loc_4;
            }
            param2.t = _loc_3;
            param2._-0x5();
            return;
        }

        public function clone() : BigInteger
        {
            var _loc_1:* = new BigInteger();
            this.copyTo(_loc_1);
            return _loc_1;
        }

        public function pow(param1:int) : BigInteger
        {
            return _-fl(param1, new _-y8());
        }

        public function _-00v(param1:int) : BigInteger
        {
            return _-S2(param1, _-0xF);
        }

        public function _-UE(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-2Cx(param1, _-0xF, _loc_2);
            return _loc_2;
        }

        public function _-0Pu(param1:BigInteger) : BigInteger
        {
            var _loc_2:* = new BigInteger();
            _-2Cx(param1, _-5-, _loc_2);
            return _loc_2;
        }

        public function max(param1:BigInteger) : BigInteger
        {
            return compareTo(param1) > 0 ? (this) : (param1);
        }

        function _-16t(param1:int) : void
        {
            t = 1;
            s = param1 < 0 ? (-1) : (0);
            if (param1 > 0)
            {
                a[0] = param1;
            }
            else if (param1 < -1)
            {
                a[0] = param1 + _-27c;
            }
            else
            {
                t = 0;
            }
            return;
        }

        function _-0n7() : Boolean
        {
            return (t > 0 ? (a[0] & 1) : (s)) == 0;
        }

        public function toString(param1:Number = 16) : String
        {
            var _loc_2:int = 0;
            if (s < 0)
            {
                return "-" + _-0KD().toString(param1);
            }
            switch(param1)
            {
                case 2:
                {
                    _loc_2 = 1;
                    break;
                }
                case 4:
                {
                    _loc_2 = 2;
                    break;
                }
                case 8:
                {
                    _loc_2 = 3;
                    break;
                }
                case 16:
                {
                    _loc_2 = 4;
                    break;
                }
                case 32:
                {
                    _loc_2 = 5;
                    break;
                }
                default:
                {
                    _loc_2 = 4;
                    break;
                }
            }
            var _loc_3:* = (1 << _loc_2) - 1;
            var _loc_4:int = 0;
            var _loc_5:Boolean = false;
            var _loc_6:String = "";
            var _loc_7:* = t;
            var _loc_8:* = _-11j - _loc_7 * _-11j % _loc_2;
            if (_loc_7-- > 0)
            {
                var _loc_9:* = a[_loc_7] >> _loc_8;
                _loc_4 = a[_loc_7] >> _loc_8;
                if (_loc_8 < _-11j && _loc_9 > 0)
                {
                    _loc_5 = true;
                    _loc_6 = _loc_4.toString(36);
                }
                while (_loc_7 >= 0)
                {

                    if (_loc_8 < _loc_2)
                    {
                        _loc_4 = (a[_loc_7] & (1 << _loc_8) - 1) << _loc_2 - _loc_8;
                        var _loc_9:* = _loc_8 + (_-11j - _loc_2);
                        _loc_8 = _loc_8 + (_-11j - _loc_2);
                        _loc_4 = _loc_4 | a[--_loc_7] >> _loc_9;
                    }
                    else
                    {
                        var _loc_9:* = _loc_8 - _loc_2;
                        _loc_8 = _loc_8 - _loc_2;
                        _loc_4 = a[--_loc_7] >> _loc_9 & _loc_3;
                        if (_loc_8 <= 0)
                        {
                            _loc_8 = _loc_8 + _-11j;
                            _loc_7 = _loc_7 - 1;
                        }
                    }
                    if (_loc_4 > 0)
                    {
                        _loc_5 = true;
                    }
                    if (_loc_5)
                    {
                        _loc_6 = _loc_6 + _loc_4.toString(36);
                    }
                }
            }
            return _loc_5 ? (_loc_6) : ("0");
        }

        public function _-kj(param1:int) : BigInteger
        {
            return _-S2(param1, _-5-);
        }

        public function abs() : BigInteger
        {
            return s < 0 ? (_-0KD()) : (this);
        }

        function _-2K1(param1:int) : int
        {
            var _loc_3:int = 0;
            var _loc_2:int = 1;
            var _loc_4:* = param1 >>> 16;
            _loc_3 = param1 >>> 16;
            if (_loc_4 != 0)
            {
                param1 = _loc_3;
                _loc_2 = _loc_2 + 16;
            }
            var _loc_4:* = param1 >> 8;
            _loc_3 = param1 >> 8;
            if (_loc_4 != 0)
            {
                param1 = _loc_3;
                _loc_2 = _loc_2 + 8;
            }
            var _loc_4:* = param1 >> 4;
            _loc_3 = param1 >> 4;
            if (_loc_4 != 0)
            {
                param1 = _loc_3;
                _loc_2 = _loc_2 + 4;
            }
            var _loc_4:* = param1 >> 2;
            _loc_3 = param1 >> 2;
            if (_loc_4 != 0)
            {
                param1 = _loc_3;
                _loc_2 = _loc_2 + 2;
            }
            var _loc_4:* = param1 >> 1;
            _loc_3 = param1 >> 1;
            if (_loc_4 != 0)
            {
                param1 = _loc_3;
                _loc_2 = _loc_2 + 1;
            }
            return _loc_2;
        }

        public function _-08u() : int
        {
            if (s < 0)
            {
                return -1;
            }
            if (t <= 0 || t == 1 && a[0] <= 0)
            {
                return 0;
            }
            return 1;
        }

        public function _-0-6() : ByteArray
        {
            var _loc_4:int = 0;
            var _loc_1:* = t;
            var _loc_2:* = new ByteArray();
            _loc_2[0] = s;
            var _loc_3:* = _-11j - _loc_1 * _-11j % 8;
            var _loc_5:int = 0;
            if (_loc_1-- > 0)
            {
                var _loc_6:* = a[_loc_1] >> _loc_3;
                _loc_4 = a[_loc_1] >> _loc_3;
                if (_loc_3 < _-11j && _loc_6 != (s & _-1HA) >> _loc_3)
                {
                    _loc_2[++_loc_5] = _loc_4 | s << _-11j - _loc_3;
                }
                while (_loc_1 >= 0)
                {

                    if (_loc_3 < 8)
                    {
                        _loc_4 = (a[_loc_1] & (1 << _loc_3) - 1) << 8 - _loc_3;
                        var _loc_6:* = _loc_3 + (_-11j - 8);
                        _loc_3 = _loc_3 + (_-11j - 8);
                        _loc_4 = _loc_4 | a[--_loc_1] >> _loc_6;
                    }
                    else
                    {
                        var _loc_6:* = _loc_3 - 8;
                        _loc_3 = _loc_3 - 8;
                        _loc_4 = a[--_loc_1] >> _loc_6 & 255;
                        if (_loc_3 <= 0)
                        {
                            _loc_3 = _loc_3 + _-11j;
                            _loc_1 = _loc_1 - 1;
                        }
                    }
                    if ((_loc_4 & 128) != 0)
                    {
                        _loc_4 = _loc_4 | -256;
                    }
                    if (_loc_5 == 0 && (s & 128) != (_loc_4 & 128))
                    {
                        _loc_5++;
                    }
                    if (_loc_5 > 0 || _loc_4 != s)
                    {
                        _loc_2[++_loc_5] = _loc_4;
                    }
                }
            }
            return _loc_2;
        }

        function _-1H4(param1:BigInteger) : void
        {
            var _loc_4:int = 0;
            var _loc_2:* = abs();
            var _loc_5:* = 2 * _loc_2.t;
            param1.t = 2 * _loc_2.t;
            var _loc_3:* = _loc_5;
            while (--_loc_3 >= 0)
            {

                param1.a[_loc_3] = 0;
            }
            --_loc_3 = 0;
            while (_loc_3 < (_loc_2.t - 1))
            {

                _loc_4 = _loc_2._-7i(--_loc_3, _loc_2.a[--_loc_3], param1, 2 * _loc_3, 0, 1);
                var _loc_5:* = param1.a[_loc_3 + _loc_2.t] + _loc_2._-7i((_loc_3 + 1), 2 * _loc_2.a[_loc_3], param1, 2 * _loc_3 + 1, _loc_4, _loc_2.t - _loc_3 - 1);
                param1.a[_loc_3 + _loc_2.t] = param1.a[_loc_3 + _loc_2.t] + _loc_2._-7i((_loc_3 + 1), 2 * _loc_2.a[_loc_3], param1, 2 * _loc_3 + 1, _loc_4, _loc_2.t - _loc_3 - 1);
                if (_loc_5 >= _-27c)
                {
                    param1.a[_loc_3 + _loc_2.t] = param1.a[_loc_3 + _loc_2.t] - _-27c;
                    param1.a[_loc_3 + _loc_2.t + 1] = 1;
                }
                _loc_3++;
            }
            if (param1.t > 0)
            {
                param1.a[(param1.t - 1)] = param1.a[(param1.t - 1)] + _loc_2._-7i(_loc_3, _loc_2.a[_loc_3], param1, 2 * _loc_3, 0, 1);
            }
            param1.s = 0;
            param1._-0x5();
            return;
        }

        private function _-0YN(param1:int, param2:int) : int
        {
            return param1 & param2;
        }

        public function _-2FW(param1:String, param2:int = 10) : void
        {
            var _loc_9:int = 0;
            _-16t(0);
            var _loc_3:* = _-0ww(param2);
            var _loc_4:* = Math.pow(param2, _loc_3);
            var _loc_5:Boolean = false;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            while (_loc_8 < param1.length)
            {

                _loc_9 = _-lk(param1, _loc_8);
                if (_loc_9 < 0)
                {
                    if (param1.charAt(_loc_8) == "-" && _-08u() == 0)
                    {
                        _loc_5 = true;
                    }
                }
                else
                {
                    _loc_7 = param2 * _loc_7 + _loc_9;
                    if (++_loc_6 >= _loc_3)
                    {
                        _-DR(_loc_4);
                        _-2FR(_loc_7, 0);
                        ++_loc_6 = 0;
                        _loc_7 = 0;
                    }
                }
                _loc_8++;
            }
            if (++_loc_6 > 0)
            {
                _-DR(Math.pow(param2, _loc_6));
                _-2FR(_loc_7, 0);
            }
            if (_loc_5)
            {
                BigInteger._-1y5._-11m(this, this);
            }
            return;
        }

        function _-uZ(param1:int, param2:BigInteger) : void
        {
            var _loc_3:int = 0;
            _loc_3 = t - 1;
            while (_loc_3 >= 0)
            {

                param2.a[_loc_3 + param1] = a[_loc_3];
                _loc_3 = _loc_3 - 1;
            }
            _loc_3 = param1 - 1;
            while (_loc_3 >= 0)
            {

                param2.a[_loc_3] = 0;
                _loc_3 = _loc_3 - 1;
            }
            param2.t = t + param1;
            param2.s = s;
            return;
        }

        private function _-0xF(param1:int, param2:int) : int
        {
            return param1 ^ param2;
        }

        public static function _-1-f(param1:int) : BigInteger
        {
            var _loc_2:* = new BigInteger;
            _loc_2._-16t(param1);
            return _loc_2;
        }

    }
}