https://thoppe.github.io/Landmark/bower_components/truffle-contract/dist/truffle-contract.js

333	                        subtype.$super.init.apply(this, arguments);
334	                    };
335	                }
336
337	                // Initializer's prototype is the subtype object
338	                subtype.init.prototype = subtype;
339
340	                // Reference supertype
341	                subtype.$super = this;
342
343	                return subtype;
344	            },
345
346	            /**
347	             * Extends this object and runs the init method.
348	             * Arguments to create() will be passed to init().
349	             *
350	             * @return {Object} The new object.
351	             *
352	             * @static
353	             *
354	             * @example
355	             *
356	             *     var instance = MyType.create();
357	             */
358	            create: function () {
359	                var instance = this.extend();
360	                instance.init.apply(instance, arguments);
361
362	                return instance;
363	            },
364
365	            /**
366	             * Initializes a newly created object.
367	             * Override this method to add some logic when your objects are created.
368	             *
369	             * @example
370	             *
371	             *     var MyType = CryptoJS.lib.Base.extend({
372	             *         init: function () {
373	             *             // ...
374	             *         }
375	             *     });
376	             */
377	            init: function () {
378	            },
379
380	            /**
381	             * Copies properties into this object.
382	             *
383	             * @param {Object} properties The properties to mix in.
384	             *
385	             * @example
386	             *
387	             *     MyType.mixIn({
388	             *         field: 'value'
389	             *     });
390	             */
391	            mixIn: function (properties) {
392	                for (var propertyName in properties) {
393	                    if (properties.hasOwnProperty(propertyName)) {
394	                        this[propertyName] = properties[propertyName];
395	                    }
396	                }
397
398	                // IE won't copy toString using the loop above
399	                if (properties.hasOwnProperty('toString')) {
400	                    this.toString = properties.toString;
401	                }
402	            },
403
404	            /**
405	             * Creates a copy of this object.
406	             *
407	             * @return {Object} The clone.
408	             *
409	             * @example
410	             *
411	             *     var clone = instance.clone();
412	             */
413	            clone: function () {
414	                return this.init.prototype.extend(this);
415	            }
416	        };
417	    }());
418
419	    /**
420	     * An array of 32-bit words.
421	     *
422	     * @property {Array} words The array of 32-bit words.
423	     * @property {number} sigBytes The number of significant bytes in this word array.
424	     */
425	    var WordArray = C_lib.WordArray = Base.extend({
426	        /**
427	         * Initializes a newly created word array.
428	         *
429	         * @param {Array} words (Optional) An array of 32-bit words.
430	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
431	         *
432	         * @example
433	         *
434	         *     var wordArray = CryptoJS.lib.WordArray.create();
435	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
436	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
437	         */
438	        init: function (words, sigBytes) {
439	            words = this.words = words || [];
440
441	            if (sigBytes != undefined) {
442	                this.sigBytes = sigBytes;
443	            } else {
444	                this.sigBytes = words.length * 4;
445	            }
446	        },
447
448	        /**
449	         * Converts this word array to a string.
450	         *
451	         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
452	         *
453	         * @return {string} The stringified word array.
454	         *
455	         * @example
456	         *
457	         *     var string = wordArray + '';
458	         *     var string = wordArray.toString();
459	         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
460	         */
461	        toString: function (encoder) {
462	            return (encoder || Hex).stringify(this);
463	        },
464
465	        /**
466	         * Concatenates a word array to this word array.

467	         *
468	         * @param {WordArray} wordArray The word array to append.
469	         *
470	         * @return {WordArray} This word array.
471	         *
472	         * @example
473	         *
474	         *     wordArray1.concat(wordArray2);
475	         */
476	        concat: function (wordArray) {
477	            // Shortcuts
478	            var thisWords = this.words;
479	            var thatWords = wordArray.words;
480	            var thisSigBytes = this.sigBytes;
481	            var thatSigBytes = wordArray.sigBytes;
482
483	            // Clamp excess bits
484	            this.clamp();
485
486	            // Concat
487	            if (thisSigBytes % 4) {
488	                // Copy one byte at a time
489	                for (var i = 0; i < thatSigBytes; i++) {
490	                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
491	                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
492	                }
493	            } else {
494	                // Copy one word at a time
495	                for (var i = 0; i < thatSigBytes; i += 4) {
496	                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
497	                }
498	            }
499	            this.sigBytes += thatSigBytes;
500
501	            // Chainable
502	            return this;
503	        },
504
505	        /**
506	         * Removes insignificant bits.
507	         *
508	         * @example
509	         *
510	         *     wordArray.clamp();
511	         */
512	        clamp: function () {
513	            // Shortcuts
514	            var words = this.words;
515	            var sigBytes = this.sigBytes;
516
517	            // Clamp
518	            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
519	            words.length = Math.ceil(sigBytes / 4);
520	        },
521
522	        /**
523	         * Creates a copy of this word array.
524	         *
525	         * @return {WordArray} The clone.
526	         *
527	         * @example
528	         *
529	         *     var clone = wordArray.clone();
530	         */
531	        clone: function () {
532	            var clone = Base.clone.call(this);
533	            clone.words = this.words.slice(0);
534
535	            return clone;
536	        },
537
538	        /**
539	         * Creates a word array filled with random bytes.
540	         *
541	         * @param {number} nBytes The number of random bytes to generate.
542	         *
543	         * @return {WordArray} The random word array.
544	         *
545	         * @static
546	         *
547	         * @example
548	         *
549	         *     var wordArray = CryptoJS.lib.WordArray.random(16);
550	         */
551	        random: function (nBytes) {
552	            var words = [];
553
554	            var r = (function (m_w) {
555	                var m_w = m_w;
556	                var m_z = 0x3ade68b1;
557	                var mask = 0xffffffff;
558
559	                return function () {
560	                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
561	                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
562	                    var result = ((m_z << 0x10) + m_w) & mask;
563	                    result /= 0x100000000;
564	                    result += 0.5;
565	                    return result * (Math.random() > .5 ? 1 : -1);
566	                }
567	            });
568
569	            for (var i = 0, rcache; i < nBytes; i += 4) {
570	                var _r = r((rcache || Math.random()) * 0x100000000);
571
572	                rcache = _r() * 0x3ade67b7;
573	                words.push((_r() * 0x100000000) | 0);
574	            }
575
576	            return new WordArray.init(words, nBytes);
577	        }
578	    });
579
580	    /**
581	     * Encoder namespace.
582	     */
583	    var C_enc = C.enc = {};
584
585	    /**
586	     * Hex encoding strategy.
587	     */
588	    var Hex = C_enc.Hex = {
589	        /**
590	         * Converts a word array to a hex string.
591	         *
592	         * @param {WordArray} wordArray The word array.
593	         *
594	         * @return {string} The hex string.
595	         *
596	         * @static
597	         *
598	         * @example
599	         *
600	         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
601	         */
602	        stringify: function (wordArray) {
603	            // Shortcuts
604	            var words = wordArray.words;
605	            var sigBytes = wordArray.sigBytes;
606
607	            // Convert
608	            var hexChars = [];
609	            for (var i = 0; i < sigBytes; i++) {
610	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;

611	                hexChars.push((bite >>> 4).toString(16));
612	                hexChars.push((bite & 0x0f).toString(16));
613	            }
614
615	            return hexChars.join('');
616	        },
617
618	        /**
619	         * Converts a hex string to a word array.
620	         *
621	         * @param {string} hexStr The hex string.
622	         *
623	         * @return {WordArray} The word array.
624	         *
625	         * @static
626	         *
627	         * @example
628	         *
629	         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
630	         */
631	        parse: function (hexStr) {
632	            // Shortcut
633	            var hexStrLength = hexStr.length;
634
635	            // Convert
636	            var words = [];
637	            for (var i = 0; i < hexStrLength; i += 2) {
638	                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
639	            }
640
641	            return new WordArray.init(words, hexStrLength / 2);
642	        }
643	    };
644
645	    /**
646	     * Latin1 encoding strategy.
647	     */
648	    var Latin1 = C_enc.Latin1 = {
649	        /**
650	         * Converts a word array to a Latin1 string.
651	         *
652	         * @param {WordArray} wordArray The word array.
653	         *
654	         * @return {string} The Latin1 string.
655	         *
656	         * @static
657	         *
658	         * @example
659	         *
660	         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
661	         */
662	        stringify: function (wordArray) {
663	            // Shortcuts
664	            var words = wordArray.words;
665	            var sigBytes = wordArray.sigBytes;
666
667	            // Convert
668	            var latin1Chars = [];
669	            for (var i = 0; i < sigBytes; i++) {
670	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
671	                latin1Chars.push(String.fromCharCode(bite));
672	            }
673
674	            return latin1Chars.join('');
675	        },
676
677	        /**
678	         * Converts a Latin1 string to a word array.
679	         *
680	         * @param {string} latin1Str The Latin1 string.
681	         *
682	         * @return {WordArray} The word array.
683	         *
684	         * @static
685	         *
686	         * @example
687	         *
688	         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
689	         */
690	        parse: function (latin1Str) {
691	            // Shortcut
692	            var latin1StrLength = latin1Str.length;
693
694	            // Convert
695	            var words = [];
696	            for (var i = 0; i < latin1StrLength; i++) {
697	                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
698	            }
699
700	            return new WordArray.init(words, latin1StrLength);
701	        }
702	    };
703
704	    /**
705	     * UTF-8 encoding strategy.
706	     */
707	    var Utf8 = C_enc.Utf8 = {
708	        /**
709	         * Converts a word array to a UTF-8 string.
710	         *
711	         * @param {WordArray} wordArray The word array.
712	         *
713	         * @return {string} The UTF-8 string.
714	         *
715	         * @static
716	         *
717	         * @example
718	         *
719	         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
720	         */
721	        stringify: function (wordArray) {
722	            try {
723	                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
724	            } catch (e) {
725	                throw new Error('Malformed UTF-8 data');
726	            }
727	        },
728
729	        /**
730	         * Converts a UTF-8 string to a word array.
731	         *
732	         * @param {string} utf8Str The UTF-8 string.
733	         *
734	         * @return {WordArray} The word array.
735	         *
736	         * @static
737	         *
738	         * @example
739	         *

740	         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
741	         */
742	        parse: function (utf8Str) {
743	            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
744	        }
745	    };
746
747	    /**
748	     * Abstract buffered block algorithm template.
749	     *
750	     * The property blockSize must be implemented in a concrete subtype.
751	     *
752	     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
753	     */
754	    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
755	        /**
756	         * Resets this block algorithm's data buffer to its initial state.
757	         *
758	         * @example
759	         *
760	         *     bufferedBlockAlgorithm.reset();
761	         */
762	        reset: function () {
763	            // Initial values
764	            this._data = new WordArray.init();
765	            this._nDataBytes = 0;
766	        },
767
768	        /**
769	         * Adds new data to this block algorithm's buffer.
770	         *
771	         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
772	         *
773	         * @example
774	         *
775	         *     bufferedBlockAlgorithm._append('data');
776	         *     bufferedBlockAlgorithm._append(wordArray);
777	         */
778	        _append: function (data) {
779	            // Convert string to WordArray, else assume WordArray already
780	            if (typeof data == 'string') {
781	                data = Utf8.parse(data);
782	            }
783
784	            // Append
785	            this._data.concat(data);
786	            this._nDataBytes += data.sigBytes;
787	        },
788
789	        /**
790	         * Processes available data blocks.
791	         *
792	         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
793	         *
794	         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
795	         *
796	         * @return {WordArray} The processed data.
797	         *
798	         * @example
799	         *
800	         *     var processedData = bufferedBlockAlgorithm._process();
801	         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
802	         */
803	        _process: function (doFlush) {
804	            // Shortcuts
805	            var data = this._data;
806	            var dataWords = data.words;
807	            var dataSigBytes = data.sigBytes;
808	            var blockSize = this.blockSize;
809	            var blockSizeBytes = blockSize * 4;
810
811	            // Count blocks ready
812	            var nBlocksReady = dataSigBytes / blockSizeBytes;
813	            if (doFlush) {
814	                // Round up to include partial blocks
815	                nBlocksReady = Math.ceil(nBlocksReady);
816	            } else {
817	                // Round down to include only full blocks,
818	                // less the number of blocks that must remain in the buffer
819	                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
820	            }
821
822	            // Count words ready
823	            var nWordsReady = nBlocksReady * blockSize;
824
825	            // Count bytes ready
826	            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
827
828	            // Process blocks
829	            if (nWordsReady) {
830	                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
831	                    // Perform concrete-algorithm logic
832	                    this._doProcessBlock(dataWords, offset);
833	                }
834
835	                // Remove processed words
836	                var processedWords = dataWords.splice(0, nWordsReady);
837	                data.sigBytes -= nBytesReady;
838	            }
839
840	            // Return processed words
841	            return new WordArray.init(processedWords, nBytesReady);
842	        },
843
844	        /**
845	         * Creates a copy of this object.
846	         *
847	         * @return {Object} The clone.
848	         *
849	         * @example
850	         *
851	         *     var clone = bufferedBlockAlgorithm.clone();
852	         */
853	        clone: function () {
854	            var clone = Base.clone.call(this);
855	            clone._data = this._data.clone();
856
857	            return clone;
858	        },
859
860	        _minBufferSize: 0
861	    });
862
863	    /**
864	     * Abstract hasher template.
865	     *
866	     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
867	     */
868	    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
869	        /**
870	         * Configuration options.
871	         */
872	        cfg: Base.extend(),
873
874	        /**
875	         * Initializes a newly created hasher.
876	         *
877	         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
878	         *
879	         * @example
880	         *
881	         *     var hasher = CryptoJS.algo.SHA256.create();
882	         */
883	        init: function (cfg) {
884	            // Apply config defaults
885	            this.cfg = this.cfg.extend(cfg);
886
887	            // Set initial values
888	            this.reset();
889	        },
890
891	        /**
892	         * Resets this hasher to its initial state.
893	         *
894	         * @example
895	         *
896	         *     hasher.reset();
897	         */
898	        reset: function () {
899	            // Reset data buffer
900	            BufferedBlockAlgorithm.reset.call(this);
901
902	            // Perform concrete-hasher logic
903	            this._doReset();
904	        },
905
906	        /**
907	         * Updates this hasher with a message.
908	         *
909	         * @param {WordArray|string} messageUpdate The message to append.
910	         *
911	         * @return {Hasher} This hasher.
912	         *
913	         * @example
914	         *
915	         *     hasher.update('message');
916	         *     hasher.update(wordArray);
917	         */
918	        update: function (messageUpdate) {
919	            // Append
920	            this._append(messageUpdate);
921
922	            // Update the hash
923	            this._process();
924
925	            // Chainable
926	            return this;
927	        },
928
929	        /**
930	         * Finalizes the hash computation.
931	         * Note that the finalize operation is effectively a destructive, read-once operation.
932	         *
933	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
934	         *
935	         * @return {WordArray} The hash.
936	         *
937	         * @example
938	         *
939	         *     var hash = hasher.finalize();
940	         *     var hash = hasher.finalize('message');
941	         *     var hash = hasher.finalize(wordArray);
942	         */
943	        finalize: function (messageUpdate) {
944	            // Final message update
945	            if (messageUpdate) {
946	                this._append(messageUpdate);
947	            }
948
949	            // Perform concrete-hasher logic
950	            var hash = this._doFinalize();
951
952	            return hash;
953	        },
954
955	        blockSize: 512/32,
956
957	        /**
958	         * Creates a shortcut function to a hasher's object interface.
959	         *
960	         * @param {Hasher} hasher The hasher to create a helper for.
961	         *
962	         * @return {Function} The shortcut function.
963	         *
964	         * @static
965	         *
966	         * @example
967	         *
968	         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
969	         */
970	        _createHelper: function (hasher) {
971	            return function (message, cfg) {
972	                return new hasher.init(cfg).finalize(message);
973	            };
974	        },
975
976	        /**
977	         * Creates a shortcut function to the HMAC's object interface.
978	         *
979	         * @param {Hasher} hasher The hasher to use in this HMAC helper.
980	         *
981	         * @return {Function} The shortcut function.
982	         *
983	         * @static
984	         *
985	         * @example
986	         *
987	         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
988	         */
989	        _createHmacHelper: function (hasher) {
990	            return function (message, key) {
991	                return new C_algo.HMAC.init(hasher, key).finalize(message);
992	            };
993	        }
994	    });
995
996	    /**
997	     * Algorithm namespace.
998	     */
999	    var C_algo = C.algo = {};
1000
1001	    return C;
1002	}(Math));
1003
1004
1005	return CryptoJS;
1006
1007}));
1008},{}],4:[function(require,module,exports){
1009;(function (root, factory, undef) {
1010	if (typeof exports === "object") {
1011		// CommonJS
1012		module.exports = exports = factory(require("./core"), require("./x64-core"));
1013	}
1014	else if (typeof define === "function" && define.amd) {
1015		// AMD
1016		define(["./core", "./x64-core"], factory);
1017	}
1018	else {
1019		// Global (browser)
1020		factory(root.CryptoJS);
1021	}
1022}(this, function (CryptoJS) {
1023
1024	(function (Math) {
1025	    // Shortcuts
1026	    var C = CryptoJS;
1027	    var C_lib = C.lib;
1028	    var WordArray = C_lib.WordArray;
1029	    var Hasher = C_lib.Hasher;
1030	    var C_x64 = C.x64;
1031	    var X64Word = C_x64.Word;
1032	    var C_algo = C.algo;
1033
1034	    // Constants tables
1035	    var RHO_OFFSETS = [];
1036	    var PI_INDEXES  = [];
1037	    var ROUND_CONSTANTS = [];
1038
1039	    // Compute Constants
1040	    (function () {
1041	        // Compute rho offset constants
1042	        var x = 1, y = 0;
1043	        for (var t = 0; t < 24; t++) {
1044	            RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64;
1045
1046	            var newX = y % 5;
1047	            var newY = (2 * x + 3 * y) % 5;
1048	            x = newX;
1049	            y = newY;
1050	        }
1051
1052	        // Compute pi index constants
1053	        for (var x = 0; x < 5; x++) {
1054	            for (var y = 0; y < 5; y++) {
1055	                PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;
1056	            }
1057	        }
1058

1059	        // Compute round constants
1060	        var LFSR = 0x01;
1061	        for (var i = 0; i < 24; i++) {
1062	            var roundConstantMsw = 0;
1063	            var roundConstantLsw = 0;
1064
1065	            for (var j = 0; j < 7; j++) {
1066	                if (LFSR & 0x01) {
1067	                    var bitPosition = (1 << j) - 1;
1068	                    if (bitPosition < 32) {
1069	                        roundConstantLsw ^= 1 << bitPosition;
1070	                    } else /* if (bitPosition >= 32) */ {
1071	                        roundConstantMsw ^= 1 << (bitPosition - 32);
1072	                    }
1073	                }
1074
1075	                // Compute next LFSR
1076	                if (LFSR & 0x80) {
1077	                    // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
1078	                    LFSR = (LFSR << 1) ^ 0x71;
1079	                } else {
1080	                    LFSR <<= 1;
1081	                }
1082	            }
1083
1084	            ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
1085	        }
1086	    }());
1087
1088	    // Reusable objects for temporary values
1089	    var T = [];
1090	    (function () {
1091	        for (var i = 0; i < 25; i++) {
1092	            T[i] = X64Word.create();
1093	        }
1094	    }());
1095
1096	    /**
1097	     * SHA-3 hash algorithm.
1098	     */
1099	    var SHA3 = C_algo.SHA3 = Hasher.extend({
1100	        /**
1101	         * Configuration options.
1102	         *
1103	         * @property {number} outputLength
1104	         *   The desired number of bits in the output hash.
1105	         *   Only values permitted are: 224, 256, 384, 512.
1106	         *   Default: 512
1107	         */
1108	        cfg: Hasher.cfg.extend({
1109	            outputLength: 512
1110	        }),
1111
1112	        _doReset: function () {
1113	            var state = this._state = []
1114	            for (var i = 0; i < 25; i++) {
1115	                state[i] = new X64Word.init();
1116	            }
1117
1118	            this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
1119	        },
1120
1121	        _doProcessBlock: function (M, offset) {
1122	            // Shortcuts
1123	            var state = this._state;
1124	            var nBlockSizeLanes = this.blockSize / 2;
1125
1126	            // Absorb
1127	            for (var i = 0; i < nBlockSizeLanes; i++) {
1128	                // Shortcuts
1129	                var M2i  = M[offset + 2 * i];
1130	                var M2i1 = M[offset + 2 * i + 1];
1131
1132	                // Swap endian
1133	                M2i = (
1134	                    (((M2i << 8)  | (M2i >>> 24)) & 0x00ff00ff) |
1135	                    (((M2i << 24) | (M2i >>> 8))  & 0xff00ff00)
1136	                );
1137	                M2i1 = (
1138	                    (((M2i1 << 8)  | (M2i1 >>> 24)) & 0x00ff00ff) |
1139	                    (((M2i1 << 24) | (M2i1 >>> 8))  & 0xff00ff00)
1140	                );
1141
1142	                // Absorb message into state
1143	                var lane = state[i];
1144	                lane.high ^= M2i1;
1145	                lane.low  ^= M2i;
1146	            }
1147
1148	            // Rounds
1149	            for (var round = 0; round < 24; round++) {
1150	                // Theta
1151	                for (var x = 0; x < 5; x++) {
1152	                    // Mix column lanes
1153	                    var tMsw = 0, tLsw = 0;
1154	                    for (var y = 0; y < 5; y++) {
1155	                        var lane = state[x + 5 * y];
1156	                        tMsw ^= lane.high;
1157	                        tLsw ^= lane.low;
1158	                    }
1159
1160	                    // Temporary values
1161	                    var Tx = T[x];
1162	                    Tx.high = tMsw;
1163	                    Tx.low  = tLsw;
1164	                }
1165	                for (var x = 0; x < 5; x++) {
1166	                    // Shortcuts
1167	                    var Tx4 = T[(x + 4) % 5];
1168	                    var Tx1 = T[(x + 1) % 5];
1169	                    var Tx1Msw = Tx1.high;
1170	                    var Tx1Lsw = Tx1.low;
1171
1172	                    // Mix surrounding columns
1173	                    var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));
1174	                    var tLsw = Tx4.low  ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));
1175	                    for (var y = 0; y < 5; y++) {
1176	                        var lane = state[x + 5 * y];
1177	                        lane.high ^= tMsw;
1178	                        lane.low  ^= tLsw;
1179	                    }
1180	                }
1181
1182	                // Rho Pi
1183	                for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
1184	                    // Shortcuts
1185	                    var lane = state[laneIndex];
1186	                    var laneMsw = lane.high;
1187	                    var laneLsw = lane.low;
1188	                    var rhoOffset = RHO_OFFSETS[laneIndex];
1189
1190	                    // Rotate lanes
1191	                    if (rhoOffset < 32) {
1192	                        var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));
1193	                        var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));
1194	                    } else /* if (rhoOffset >= 32) */ {
1195	                        var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));
1196	                        var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));
1197	                    }
1198
1199	                    // Transpose lanes
1200	                    var TPiLane = T[PI_INDEXES[laneIndex]];
1201	                    TPiLane.high = tMsw;
1202	                    TPiLane.low  = tLsw;
1203	                }
1204
1205	                // Rho pi at x = y = 0
1206	                var T0 = T[0];
1207	                var state0 = state[0];
1208	                T0.high = state0.high;
1209	                T0.low  = state0.low;
1210
1211	                // Chi
1212	                for (var x = 0; x < 5; x++) {
1213	                    for (var y = 0; y < 5; y++) {
1214	                        // Shortcuts
1215	                        var laneIndex = x + 5 * y;
1216	                        var lane = state[laneIndex];
1217	                        var TLane = T[laneIndex];
1218	                        var Tx1Lane = T[((x + 1) % 5) + 5 * y];
1219	                        var Tx2Lane = T[((x + 2) % 5) + 5 * y];
1220
1221	                        // Mix rows
1222	                        lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);
1223	                        lane.low  = TLane.low  ^ (~Tx1Lane.low  & Tx2Lane.low);
1224	                    }
1225	                }
1226
1227	                // Iota
1228	                var lane = state[0];
1229	                var roundConstant = ROUND_CONSTANTS[round];
1230	                lane.high ^= roundConstant.high;
1231	                lane.low  ^= roundConstant.low;;
1232	            }
1233	        },
1234
1235	        _doFinalize: function () {
1236	            // Shortcuts
1237	            var data = this._data;
1238	            var dataWords = data.words;
1239	            var nBitsTotal = this._nDataBytes * 8;
1240	            var nBitsLeft = data.sigBytes * 8;
1241	            var blockSizeBits = this.blockSize * 32;
1242
1243	            // Add padding
1244	            dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);
1245	            dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;
1246	            data.sigBytes = dataWords.length * 4;
1247
1248	            // Hash final blocks
1249	            this._process();
1250
1251	            // Shortcuts
1252	            var state = this._state;
1253	            var outputLengthBytes = this.cfg.outputLength / 8;
1254	            var outputLengthLanes = outputLengthBytes / 8;
1255
1256	            // Squeeze
1257	            var hashWords = [];
1258	            for (var i = 0; i < outputLengthLanes; i++) {
1259	                // Shortcuts
1260	                var lane = state[i];
1261	                var laneMsw = lane.high;
1262	                var laneLsw = lane.low;
1263
1264	                // Swap endian
1265	                laneMsw = (
1266	                    (((laneMsw << 8)  | (laneMsw >>> 24)) & 0x00ff00ff) |
1267	                    (((laneMsw << 24) | (laneMsw >>> 8))  & 0xff00ff00)
1268	                );
1269	                laneLsw = (
1270	                    (((laneLsw << 8)  | (laneLsw >>> 24)) & 0x00ff00ff) |
1271	                    (((laneLsw << 24) | (laneLsw >>> 8))  & 0xff00ff00)
1272	                );
1273
1274	                // Squeeze state to retrieve hash
1275	                hashWords.push(laneLsw);
1276	                hashWords.push(laneMsw);
1277	            }
1278
1279	            // Return final computed hash
1280	            return new WordArray.init(hashWords, outputLengthBytes);
1281	        },
1282
1283	        clone: function () {
1284	            var clone = Hasher.clone.call(this);
1285
1286	            var state = clone._state = this._state.slice(0);
1287	            for (var i = 0; i < 25; i++) {
1288	                state[i] = state[i].clone();
1289	            }
1290
1291	            return clone;
1292	        }
1293	    });
1294
1295	    /**
1296	     * Shortcut function to the hasher's object interface.
1297	     *
1298	     * @param {WordArray|string} message The message to hash.
1299	     *
1300	     * @return {WordArray} The hash.
1301	     *
1302	     * @static
1303	     *
1304	     * @example
1305	     *
1306	     *     var hash = CryptoJS.SHA3('message');
1307	     *     var hash = CryptoJS.SHA3(wordArray);
1308	     */
1309	    C.SHA3 = Hasher._createHelper(SHA3);
1310
1311	    /**
1312	     * Shortcut function to the HMAC's object interface.
1313	     *
1314	     * @param {WordArray|string} message The message to hash.
1315	     * @param {WordArray|string} key The secret key.
1316	     *
1317	     * @return {WordArray} The HMAC.
1318	     *
1319	     * @static
1320	     *
1321	     * @example
1322	     *
1323	     *     var hmac = CryptoJS.HmacSHA3(message, key);
1324	     */
1325	    C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
1326	}(Math));
1327
1328
1329	return CryptoJS.SHA3;
1330
1331}));
1332},{"./core":3,"./x64-core":5}],5:[function(require,module,exports){
1333;(function (root, factory) {
1334	if (typeof exports === "object") {
1335		// CommonJS
1336		module.exports = exports = factory(require("./core"));
1337	}
1338	else if (typeof define === "function" && define.amd) {
1339		// AMD
1340		define(["./core"], factory);
1341	}
1342	else {
1343		// Global (browser)
1344		factory(root.CryptoJS);
1345	}
1346}(this, function (CryptoJS) {
1347
1348	(function (undefined) {
1349	    // Shortcuts
1350	    var C = CryptoJS;
1351	    var C_lib = C.lib;
1352	    var Base = C_lib.Base;
1353	    var X32WordArray = C_lib.WordArray;
1354
1355	    /**
1356	     * x64 namespace.
1357	     */
1358	    var C_x64 = C.x64 = {};
1359
1360	    /**
1361	     * A 64-bit word.
1362	     */
1363	    var X64Word = C_x64.Word = Base.extend({
1364	        /**
1365	         * Initializes a newly created 64-bit word.
1366	         *
1367	         * @param {number} high The high 32 bits.
1368	         * @param {number} low The low 32 bits.
1369	         *
1370	         * @example
1371	         *
1372	         *     var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
1373	         */
1374	        init: function (high, low) {
1375	            this.high = high;
1376	            this.low = low;
1377	        }
1378
1379	        /**
1380	         * Bitwise NOTs this word.
1381	         *
1382	         * @return {X64Word} A new x64-Word object after negating.
1383	         *
1384	         * @example
1385	         *
1386	         *     var negated = x64Word.not();
1387	         */
1388	        // not: function () {
1389	            // var high = ~this.high;
1390	            // var low = ~this.low;
1391
1392	            // return X64Word.create(high, low);
1393	        // },
1394
1395	        /**
1396	         * Bitwise ANDs this word with the passed word.
1397	         *
1398	         * @param {X64Word} word The x64-Word to AND with this word.
1399	         *
1400	         * @return {X64Word} A new x64-Word object after ANDing.
1401	         *
1402	         * @example
1403	         *
1404	         *     var anded = x64Word.and(anotherX64Word);
1405	         */
1406	        // and: function (word) {
1407	            // var high = this.high & word.high;
1408	            // var low = this.low & word.low;
1409
1410	            // return X64Word.create(high, low);
1411	        // },
1412
1413	        /**
1414	         * Bitwise ORs this word with the passed word.
1415	         *
1416	         * @param {X64Word} word The x64-Word to OR with this word.
1417	         *
1418	         * @return {X64Word} A new x64-Word object after ORing.
1419	         *
1420	         * @example
1421	         *
1422	         *     var ored = x64Word.or(anotherX64Word);
1423	         */
1424	        // or: function (word) {
1425	            // var high = this.high | word.high;
1426	            // var low = this.low | word.low;
1427
1428	            // return X64Word.create(high, low);
1429	        // },
1430
1431	        /**
1432	         * Bitwise XORs this word with the passed word.
1433	         *
1434	         * @param {X64Word} word The x64-Word to XOR with this word.
1435	         *
1436	         * @return {X64Word} A new x64-Word object after XORing.
1437	         *
1438	         * @example
1439	         *
1440	         *     var xored = x64Word.xor(anotherX64Word);
1441	         */
1442	        // xor: function (word) {
1443	            // var high = this.high ^ word.high;
1444	            // var low = this.low ^ word.low;
1445
1446	            // return X64Word.create(high, low);
1447	        // },
1448
1449	        /**
1450	         * Shifts this word n bits to the left.
1451	         *
1452	         * @param {number} n The number of bits to shift.
1453	         *
1454	         * @return {X64Word} A new x64-Word object after shifting.
1455	         *
1456	         * @example
1457	         *
1458	         *     var shifted = x64Word.shiftL(25);
1459	         */
1460	        // shiftL: function (n) {
1461	            // if (n < 32) {
1462	                // var high = (this.high << n) | (this.low >>> (32 - n));
1463	                // var low = this.low << n;
1464	            // } else {
1465	                // var high = this.low << (n - 32);
1466	                // var low = 0;
1467	            // }
1468
1469	            // return X64Word.create(high, low);
1470	        // },
1471
1472	        /**
1473	         * Shifts this word n bits to the right.
1474	         *
1475	         * @param {number} n The number of bits to shift.
1476	         *
1477	         * @return {X64Word} A new x64-Word object after shifting.
1478	         *
1479	         * @example
1480	         *
1481	         *     var shifted = x64Word.shiftR(7);
1482	         */
1483	        // shiftR: function (n) {
1484	            // if (n < 32) {
1485	                // var low = (this.low >>> n) | (this.high << (32 - n));
1486	                // var high = this.high >>> n;
1487	            // } else {
1488	                // var low = this.high >>> (n - 32);
1489	                // var high = 0;
1490	            // }
1491
1492	            // return X64Word.create(high, low);
1493	        // },
1494
1495	        /**
1496	         * Rotates this word n bits to the left.
1497	         *
1498	         * @param {number} n The number of bits to rotate.
1499	         *
1500	         * @return {X64Word} A new x64-Word object after rotating.
1501	         *
1502	         * @example
1503	         *
1504	         *     var rotated = x64Word.rotL(25);
1505	         */
1506	        // rotL: function (n) {
1507	            // return this.shiftL(n).or(this.shiftR(64 - n));
1508	        // },
1509
1510	        /**
1511	         * Rotates this word n bits to the right.
1512	         *
1513	         * @param {number} n The number of bits to rotate.
1514	         *
1515	         * @return {X64Word} A new x64-Word object after rotating.
1516	         *
1517	         * @example
1518	         *
1519	         *     var rotated = x64Word.rotR(7);
1520	         */
1521	        // rotR: function (n) {
1522	            // return this.shiftR(n).or(this.shiftL(64 - n));
1523	        // },
1524
1525	        /**
1526	         * Adds this word with the passed word.
1527	         *
1528	         * @param {X64Word} word The x64-Word to add with this word.
1529	         *
1530	         * @return {X64Word} A new x64-Word object after adding.
1531	         *
1532	         * @example
1533	         *
1534	         *     var added = x64Word.add(anotherX64Word);
1535	         */
1536	        // add: function (word) {
1537	            // var low = (this.low + word.low) | 0;
1538	            // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
1539	            // var high = (this.high + word.high + carry) | 0;
1540
1541	            // return X64Word.create(high, low);
1542	        // }
1543	    });
1544
1545	    /**
1546	     * An array of 64-bit words.
1547	     *
1548	     * @property {Array} words The array of CryptoJS.x64.Word objects.
1549	     * @property {number} sigBytes The number of significant bytes in this word array.

2547+/'
2548for (var i = 0, len = code.length; i < len; ++i) {
2549  lookup[i] = code[i]
2550  revLookup[code.charCodeAt(i)] = i
2551}
2552
2553revLookup['-'.charCodeAt(0)] = 62
2554revLookup['_'.charCodeAt(0)] = 63
2555
2556function placeHoldersCount (b64) {
2557  var len = b64.length
2558  if (len % 4 > 0) {
2559    throw new Error('Invalid string. Length must be a multiple of 4')
2560  }
2561
2562  // the number of equal signs (place holders)
2563  // if there are two placeholders, than the two characters before it
2564  // represent one byte
2565  // if there is only one, then the three characters before it represent 2 bytes
2566  // this is just a cheap hack to not do indexOf twice
2567  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
2568}
2569
2570function byteLength (b64) {
2571  // base64 is 4/3 + up to two characters of the original data
2572  return (b64.length * 3 / 4) - placeHoldersCount(b64)
2573}
2574
2575function toByteArray (b64) {
2576  var i, l, tmp, placeHolders, arr
2577  var len = b64.length
2578  placeHolders = placeHoldersCount(b64)
2579
2580  arr = new Arr((len * 3 / 4) - placeHolders)
2581
2582  // if there are placeholders, only get up to the last complete 4 chars
2583  l = placeHolders > 0 ? len - 4 : len
2584
2585  var L = 0
2586
2587  for (i = 0; i < l; i += 4) {
2588    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
2589    arr[L++] = (tmp >> 16) & 0xFF
2590    arr[L++] = (tmp >> 8) & 0xFF
2591    arr[L++] = tmp & 0xFF
2592  }
2593
2594  if (placeHolders === 2) {
2595    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
2596    arr[L++] = tmp & 0xFF
2597  } else if (placeHolders === 1) {
2598    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
2599    arr[L++] = (tmp >> 8) & 0xFF
2600    arr[L++] = tmp & 0xFF
2601  }
2602
2603  return arr
2604}
2605
2606function tripletToBase64 (num) {
2607  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
2608}
2609
2610function encodeChunk (uint8, start, end) {
2611  var tmp
2612  var output = []
2613  for (var i = start; i < end; i += 3) {
2614    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
2615    output.push(tripletToBase64(tmp))
2616  }
2617  return output.join('')
2618}
2619
2620function fromByteArray (uint8) {
2621  var tmp
2622  var len = uint8.length
2623  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
2624  var output = ''
2625  var parts = []
2626  var maxChunkLength = 16383 // must be multiple of 3
2627
2628  // go through the array every three bytes, we'll deal with trailing stuff later
2629  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
2630    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
2631  }
2632
2633  // pad the end with zeros, but make sure to not forget the extra bytes
2634  if (extraBytes === 1) {
2635    tmp = uint8[len - 1]
2636    output += lookup[tmp >> 2]
2637    output += lookup[(tmp << 4) & 0x3F]
2638    output += '=='
2639  } else if (extraBytes === 2) {
2640    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
2641    output += lookup[tmp >> 10]
2642    output += lookup[(tmp >> 4) & 0x3F]
2643    output += lookup[(tmp << 2) & 0x3F]
2644    output += '='
2645  }
2646
2647  parts.push(output)
2648
2649  return parts.join('')
2650}
2651
2652},{}],10:[function(require,module,exports){
2653(function (module, exports) {
2654  'use strict';
2655
2656  // Utils
2657  function assert (val, msg) {
2658    if (!val) throw new Error(msg || 'Assertion failed');
2659  }
2660
2661  // Could use `inherits` module, but don't want to move from single file
2662  // architecture yet.
2663  function inherits (ctor, superCtor) {
2664    ctor.super_ = superCtor;
2665    var TempCtor = function () {};
2666    TempCtor.prototype = superCtor.prototype;
2667    ctor.prototype = new TempCtor();
2668    ctor.prototype.constructor = ctor;
2669  }
2670
2671  // BN
2672
2673  function BN (number, base, endian) {
2674    if (BN.isBN(number)) {
2675      return number;
2676    }
2677
2678    this.negative = 0;
2679    this.words = null;
2680    this.length = 0;
2681
2682    // Reduction context
2683    this.red = null;
2684
2685    if (number !== null) {
2686      if (base === 'le' || base === 'be') {
2687        endian = base;
2688        base = 10;
2689      }
2690
2691      this._init(number || 0, base || 10, endian || 'be');
2692    }
2693  }
2694  if (typeof module === 'object') {
2695    module.exports = BN;
2696  } else {
2697    exports.BN = BN;
2698  }
2699
2700  BN.BN = BN;
2701  BN.wordSize = 26;
2702
2703  var Buffer;
2704  try {
2705    Buffer = require('buf' + 'fer').Buffer;
2706  } catch (e) {
2707  }
2708
2709  BN.isBN = function isBN (num) {
2710    if (num instanceof BN) {
2711      return true;
2712    }
2713
2714    return num !== null && typeof num === 'object' &&
2715      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
2716  };
2717
2718  BN.max = function max (left, right) {
2719    if (left.cmp(right) > 0) return left;
2720    return right;
2721  };
2722
2723  BN.min = function min (left, right) {
2724    if (left.cmp(right) < 0) return left;
2725    return right;
2726  };
2727
2728  BN.prototype._init = function init (number, base, endian) {
2729    if (typeof number === 'number') {
2730      return this._initNumber(number, base, endian);
2731    }
2732
2733    if (typeof number === 'object') {
2734      return this._initArray(number, base, endian);
2735    }
2736
2737    if (base === 'hex') {
2738      base = 16;
2739    }
2740    assert(base === (base | 0) && base >= 2 && base <= 36);
2741
2742    number = number.toString().replace(/\s+/g, '');
2743    var start = 0;
2744    if (number[0] === '-') {
2745      start++;
2746    }
2747
2748    if (base === 16) {
2749      this._parseHex(number, start);
2750    } else {
2751      this._parseBase(number, base, start);
2752    }
2753
2754    if (number[0] === '-') {
2755      this.negative = 1;
2756    }
2757
2758    this.strip();
2759
2760    if (endian !== 'le') return;
2761
2762    this._initArray(this.toArray(), base, endian);
2763  };
2764
2765  BN.prototype._initNumber = function _initNumber (number, base, endian) {
2766    if (number < 0) {
2767      this.negative = 1;
2768      number = -number;
2769    }
2770    if (number < 0x4000000) {
2771      this.words = [ number & 0x3ffffff ];
2772      this.length = 1;
2773    } else if (number < 0x10000000000000) {
2774      this.words = [
2775        number & 0x3ffffff,
2776        (number / 0x4000000) & 0x3ffffff
2777      ];
2778      this.length = 2;
2779    } else {
2780      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
2781      this.words = [
2782        number & 0x3ffffff,
2783        (number / 0x4000000) & 0x3ffffff,
2784        1
2785      ];
2786      this.length = 3;
2787    }
2788
2789    if (endian !== 'le') return;
2790
2791    // Reverse the bytes
2792    this._initArray(this.toArray(), base, endian);
2793  };
2794
2795  BN.prototype._initArray = function _initArray (number, base, endian) {
2796    // Perhaps a Uint8Array
2797    assert(typeof number.length === 'number');
2798    if (number.length <= 0) {
2799      this.words = [ 0 ];
2800      this.length = 1;
2801      return this;
2802    }
2803
2804    this.length = Math.ceil(number.length / 3);
2805    this.words = new Array(this.length);
2806    for (var i = 0; i < this.length; i++) {
2807      this.words[i] = 0;
2808    }
2809
2810    var j, w;
2811    var off = 0;
2812    if (endian === 'be') {
2813      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
2814        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
2815        this.words[j] |= (w << off) & 0x3ffffff;
2816        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
2817        off += 24;
2818        if (off >= 26) {
2819          off -= 26;
2820          j++;
2821        }
2822      }
2823    } else if (endian === 'le') {
2824      for (i = 0, j = 0; i < number.length; i += 3) {
2825        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
2826        this.words[j] |= (w << off) & 0x3ffffff;
2827        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
2828        off += 24;
2829        if (off >= 26) {
2830          off -= 26;
2831          j++;
2832        }
2833      }
2834    }
2835    return this.strip();
2836  };
2837
2838  function parseHex (str, start, end) {
2839    var r = 0;
2840    var len = Math.min(str.length, end);
2841    for (var i = start; i < len; i++) {
2842      var c = str.charCodeAt(i) - 48;
2843
2844      r <<= 4;
2845
2846      // 'a' - 'f'
2847      if (c >= 49 && c <= 54) {
2848        r |= c - 49 + 0xa;
2849
2850      // 'A' - 'F'
2851      } else if (c >= 17 && c <= 22) {
2852        r |= c - 17 + 0xa;
2853
2854      // '0' - '9'
2855      } else {
2856        r |= c & 0xf;
2857      }
2858    }
2859    return r;
2860  }
2861
2862  BN.prototype._parseHex = function _parseHex (number, start) {
2863    // Create possibly bigger array to ensure that it fits the number
2864    this.length = Math.ceil((number.length - start) / 6);
2865    this.words = new Array(this.length);
2866    for (var i = 0; i < this.length; i++) {
2867      this.words[i] = 0;
2868    }
2869
2870    var j, w;
2871    // Scan 24-bit chunks and add them to the number
2872    var off = 0;
2873    for (i = number.length - 6, j = 0; i >= start; i -= 6) {
2874      w = parseHex(number, i, i + 6);
2875      this.words[j] |= (w << off) & 0x3ffffff;
2876      // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
2877      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
2878      off += 24;
2879      if (off >= 26) {
2880        off -= 26;
2881        j++;
2882      }
2883    }
2884    if (i + 6 !== start) {
2885      w = parseHex(number, start, i + 6);
2886      this.words[j] |= (w << off) & 0x3ffffff;
2887      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
2888    }
2889    this.strip();
2890  };
2891
2892  function parseBase (str, start, end, mul) {
2893    var r = 0;
2894    var len = Math.min(str.length, end);
2895    for (var i = start; i < len; i++) {
2896      var c = str.charCodeAt(i) - 48;
2897
2898      r *= mul;
2899
2900      // 'a'
2901      if (c >= 49) {
2902        r += c - 49 + 0xa;
2903
2904      // 'A'
2905      } else if (c >= 17) {
2906        r += c - 17 + 0xa;
2907
2908      // '0' - '9'
2909      } else {
2910        r += c;
2911      }
2912    }
2913    return r;
2914  }
2915
2916  BN.prototype._parseBase = function _parseBase (number, base, start) {
2917    // Initialize as zero
2918    this.words = [ 0 ];
2919    this.length = 1;
2920
2921    // Find length of limb in base
2922    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
2923      limbLen++;
2924    }
2925    limbLen--;
2926    limbPow = (limbPow / base) | 0;
2927
2928    var total = number.length - start;
2929    var mod = total % limbLen;
2930    var end = Math.min(total, total - mod) + start;
2931
2932    var word = 0;
2933    for (var i = start; i < end; i += limbLen) {
2934      word = parseBase(number, i, i + limbLen, base);
2935
2936      this.imuln(limbPow);
2937      if (this.words[0] + word < 0x4000000) {
2938        this.words[0] += word;
2939      } else {
2940        this._iaddn(word);
2941      }
2942    }
2943
2944    if (mod !== 0) {
2945      var pow = 1;
2946      word = parseBase(number, i, number.length, base);
2947
2948      for (i = 0; i < mod; i++) {
2949        pow *= base;
2950      }
2951
2952      this.imuln(pow);
2953      if (this.words[0] + word < 0x4000000) {
2954        this.words[0] += word;
2955      } else {
2956        this._iaddn(word);
2957      }
2958    }