neox-tpke
Version:
NeoX TPKE utilities
1,808 lines • 218 kB
JavaScript
(function(global, factory) {
typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["neox-tpke"] = {}));
})(this, function(exports2) {
"use strict";
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var hash$1 = {};
var utils = {};
var minimalisticAssert;
var hasRequiredMinimalisticAssert;
function requireMinimalisticAssert() {
if (hasRequiredMinimalisticAssert) return minimalisticAssert;
hasRequiredMinimalisticAssert = 1;
minimalisticAssert = assert;
function assert(val, msg) {
if (!val)
throw new Error(msg || "Assertion failed");
}
assert.equal = function assertEqual(l2, r, msg) {
if (l2 != r)
throw new Error(msg || "Assertion failed: " + l2 + " != " + r);
};
return minimalisticAssert;
}
var inherits_browser = { exports: {} };
var hasRequiredInherits_browser;
function requireInherits_browser() {
if (hasRequiredInherits_browser) return inherits_browser.exports;
hasRequiredInherits_browser = 1;
if (typeof Object.create === "function") {
inherits_browser.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
};
} else {
inherits_browser.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
};
}
return inherits_browser.exports;
}
var hasRequiredUtils;
function requireUtils() {
if (hasRequiredUtils) return utils;
hasRequiredUtils = 1;
var assert = requireMinimalisticAssert();
var inherits = requireInherits_browser();
utils.inherits = inherits;
function isSurrogatePair(msg, i) {
if ((msg.charCodeAt(i) & 64512) !== 55296) {
return false;
}
if (i < 0 || i + 1 >= msg.length) {
return false;
}
return (msg.charCodeAt(i + 1) & 64512) === 56320;
}
function toArray(msg, enc) {
if (Array.isArray(msg))
return msg.slice();
if (!msg)
return [];
var res = [];
if (typeof msg === "string") {
if (!enc) {
var p2 = 0;
for (var i = 0; i < msg.length; i++) {
var c = msg.charCodeAt(i);
if (c < 128) {
res[p2++] = c;
} else if (c < 2048) {
res[p2++] = c >> 6 | 192;
res[p2++] = c & 63 | 128;
} else if (isSurrogatePair(msg, i)) {
c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
res[p2++] = c >> 18 | 240;
res[p2++] = c >> 12 & 63 | 128;
res[p2++] = c >> 6 & 63 | 128;
res[p2++] = c & 63 | 128;
} else {
res[p2++] = c >> 12 | 224;
res[p2++] = c >> 6 & 63 | 128;
res[p2++] = c & 63 | 128;
}
}
} else if (enc === "hex") {
msg = msg.replace(/[^a-z0-9]+/ig, "");
if (msg.length % 2 !== 0)
msg = "0" + msg;
for (i = 0; i < msg.length; i += 2)
res.push(parseInt(msg[i] + msg[i + 1], 16));
}
} else {
for (i = 0; i < msg.length; i++)
res[i] = msg[i] | 0;
}
return res;
}
utils.toArray = toArray;
function toHex(msg) {
var res = "";
for (var i = 0; i < msg.length; i++)
res += zero2(msg[i].toString(16));
return res;
}
utils.toHex = toHex;
function htonl(w) {
var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
return res >>> 0;
}
utils.htonl = htonl;
function toHex32(msg, endian) {
var res = "";
for (var i = 0; i < msg.length; i++) {
var w = msg[i];
if (endian === "little")
w = htonl(w);
res += zero8(w.toString(16));
}
return res;
}
utils.toHex32 = toHex32;
function zero2(word) {
if (word.length === 1)
return "0" + word;
else
return word;
}
utils.zero2 = zero2;
function zero8(word) {
if (word.length === 7)
return "0" + word;
else if (word.length === 6)
return "00" + word;
else if (word.length === 5)
return "000" + word;
else if (word.length === 4)
return "0000" + word;
else if (word.length === 3)
return "00000" + word;
else if (word.length === 2)
return "000000" + word;
else if (word.length === 1)
return "0000000" + word;
else
return word;
}
utils.zero8 = zero8;
function join32(msg, start, end, endian) {
var len = end - start;
assert(len % 4 === 0);
var res = new Array(len / 4);
for (var i = 0, k = start; i < res.length; i++, k += 4) {
var w;
if (endian === "big")
w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
else
w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
res[i] = w >>> 0;
}
return res;
}
utils.join32 = join32;
function split32(msg, endian) {
var res = new Array(msg.length * 4);
for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
var m = msg[i];
if (endian === "big") {
res[k] = m >>> 24;
res[k + 1] = m >>> 16 & 255;
res[k + 2] = m >>> 8 & 255;
res[k + 3] = m & 255;
} else {
res[k + 3] = m >>> 24;
res[k + 2] = m >>> 16 & 255;
res[k + 1] = m >>> 8 & 255;
res[k] = m & 255;
}
}
return res;
}
utils.split32 = split32;
function rotr32(w, b) {
return w >>> b | w << 32 - b;
}
utils.rotr32 = rotr32;
function rotl32(w, b) {
return w << b | w >>> 32 - b;
}
utils.rotl32 = rotl32;
function sum32(a, b) {
return a + b >>> 0;
}
utils.sum32 = sum32;
function sum32_3(a, b, c) {
return a + b + c >>> 0;
}
utils.sum32_3 = sum32_3;
function sum32_4(a, b, c, d) {
return a + b + c + d >>> 0;
}
utils.sum32_4 = sum32_4;
function sum32_5(a, b, c, d, e) {
return a + b + c + d + e >>> 0;
}
utils.sum32_5 = sum32_5;
function sum64(buf, pos, ah, al) {
var bh = buf[pos];
var bl = buf[pos + 1];
var lo = al + bl >>> 0;
var hi = (lo < al ? 1 : 0) + ah + bh;
buf[pos] = hi >>> 0;
buf[pos + 1] = lo;
}
utils.sum64 = sum64;
function sum64_hi(ah, al, bh, bl) {
var lo = al + bl >>> 0;
var hi = (lo < al ? 1 : 0) + ah + bh;
return hi >>> 0;
}
utils.sum64_hi = sum64_hi;
function sum64_lo(ah, al, bh, bl) {
var lo = al + bl;
return lo >>> 0;
}
utils.sum64_lo = sum64_lo;
function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
var carry = 0;
var lo = al;
lo = lo + bl >>> 0;
carry += lo < al ? 1 : 0;
lo = lo + cl >>> 0;
carry += lo < cl ? 1 : 0;
lo = lo + dl >>> 0;
carry += lo < dl ? 1 : 0;
var hi = ah + bh + ch + dh + carry;
return hi >>> 0;
}
utils.sum64_4_hi = sum64_4_hi;
function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
var lo = al + bl + cl + dl;
return lo >>> 0;
}
utils.sum64_4_lo = sum64_4_lo;
function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
var carry = 0;
var lo = al;
lo = lo + bl >>> 0;
carry += lo < al ? 1 : 0;
lo = lo + cl >>> 0;
carry += lo < cl ? 1 : 0;
lo = lo + dl >>> 0;
carry += lo < dl ? 1 : 0;
lo = lo + el >>> 0;
carry += lo < el ? 1 : 0;
var hi = ah + bh + ch + dh + eh + carry;
return hi >>> 0;
}
utils.sum64_5_hi = sum64_5_hi;
function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
var lo = al + bl + cl + dl + el;
return lo >>> 0;
}
utils.sum64_5_lo = sum64_5_lo;
function rotr64_hi(ah, al, num) {
var r = al << 32 - num | ah >>> num;
return r >>> 0;
}
utils.rotr64_hi = rotr64_hi;
function rotr64_lo(ah, al, num) {
var r = ah << 32 - num | al >>> num;
return r >>> 0;
}
utils.rotr64_lo = rotr64_lo;
function shr64_hi(ah, al, num) {
return ah >>> num;
}
utils.shr64_hi = shr64_hi;
function shr64_lo(ah, al, num) {
var r = ah << 32 - num | al >>> num;
return r >>> 0;
}
utils.shr64_lo = shr64_lo;
return utils;
}
var common$1 = {};
var hasRequiredCommon$1;
function requireCommon$1() {
if (hasRequiredCommon$1) return common$1;
hasRequiredCommon$1 = 1;
var utils2 = requireUtils();
var assert = requireMinimalisticAssert();
function BlockHash() {
this.pending = null;
this.pendingTotal = 0;
this.blockSize = this.constructor.blockSize;
this.outSize = this.constructor.outSize;
this.hmacStrength = this.constructor.hmacStrength;
this.padLength = this.constructor.padLength / 8;
this.endian = "big";
this._delta8 = this.blockSize / 8;
this._delta32 = this.blockSize / 32;
}
common$1.BlockHash = BlockHash;
BlockHash.prototype.update = function update(msg, enc) {
msg = utils2.toArray(msg, enc);
if (!this.pending)
this.pending = msg;
else
this.pending = this.pending.concat(msg);
this.pendingTotal += msg.length;
if (this.pending.length >= this._delta8) {
msg = this.pending;
var r = msg.length % this._delta8;
this.pending = msg.slice(msg.length - r, msg.length);
if (this.pending.length === 0)
this.pending = null;
msg = utils2.join32(msg, 0, msg.length - r, this.endian);
for (var i = 0; i < msg.length; i += this._delta32)
this._update(msg, i, i + this._delta32);
}
return this;
};
BlockHash.prototype.digest = function digest(enc) {
this.update(this._pad());
assert(this.pending === null);
return this._digest(enc);
};
BlockHash.prototype._pad = function pad() {
var len = this.pendingTotal;
var bytes = this._delta8;
var k = bytes - (len + this.padLength) % bytes;
var res = new Array(k + this.padLength);
res[0] = 128;
for (var i = 1; i < k; i++)
res[i] = 0;
len <<= 3;
if (this.endian === "big") {
for (var t2 = 8; t2 < this.padLength; t2++)
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = len >>> 24 & 255;
res[i++] = len >>> 16 & 255;
res[i++] = len >>> 8 & 255;
res[i++] = len & 255;
} else {
res[i++] = len & 255;
res[i++] = len >>> 8 & 255;
res[i++] = len >>> 16 & 255;
res[i++] = len >>> 24 & 255;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
for (t2 = 8; t2 < this.padLength; t2++)
res[i++] = 0;
}
return res;
};
return common$1;
}
var sha = {};
var common = {};
var hasRequiredCommon;
function requireCommon() {
if (hasRequiredCommon) return common;
hasRequiredCommon = 1;
var utils2 = requireUtils();
var rotr32 = utils2.rotr32;
function ft_1(s2, x, y2, z) {
if (s2 === 0)
return ch32(x, y2, z);
if (s2 === 1 || s2 === 3)
return p32(x, y2, z);
if (s2 === 2)
return maj32(x, y2, z);
}
common.ft_1 = ft_1;
function ch32(x, y2, z) {
return x & y2 ^ ~x & z;
}
common.ch32 = ch32;
function maj32(x, y2, z) {
return x & y2 ^ x & z ^ y2 & z;
}
common.maj32 = maj32;
function p32(x, y2, z) {
return x ^ y2 ^ z;
}
common.p32 = p32;
function s0_256(x) {
return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
}
common.s0_256 = s0_256;
function s1_256(x) {
return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
}
common.s1_256 = s1_256;
function g0_256(x) {
return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
}
common.g0_256 = g0_256;
function g1_256(x) {
return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
}
common.g1_256 = g1_256;
return common;
}
var _1;
var hasRequired_1;
function require_1() {
if (hasRequired_1) return _1;
hasRequired_1 = 1;
var utils2 = requireUtils();
var common2 = requireCommon$1();
var shaCommon = requireCommon();
var rotl32 = utils2.rotl32;
var sum32 = utils2.sum32;
var sum32_5 = utils2.sum32_5;
var ft_1 = shaCommon.ft_1;
var BlockHash = common2.BlockHash;
var sha1_K = [
1518500249,
1859775393,
2400959708,
3395469782
];
function SHA1() {
if (!(this instanceof SHA1))
return new SHA1();
BlockHash.call(this);
this.h = [
1732584193,
4023233417,
2562383102,
271733878,
3285377520
];
this.W = new Array(80);
}
utils2.inherits(SHA1, BlockHash);
_1 = SHA1;
SHA1.blockSize = 512;
SHA1.outSize = 160;
SHA1.hmacStrength = 80;
SHA1.padLength = 64;
SHA1.prototype._update = function _update(msg, start) {
var W = this.W;
for (var i = 0; i < 16; i++)
W[i] = msg[start + i];
for (; i < W.length; i++)
W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
var a = this.h[0];
var b = this.h[1];
var c = this.h[2];
var d = this.h[3];
var e = this.h[4];
for (i = 0; i < W.length; i++) {
var s2 = ~~(i / 20);
var t2 = sum32_5(rotl32(a, 5), ft_1(s2, b, c, d), e, W[i], sha1_K[s2]);
e = d;
d = c;
c = rotl32(b, 30);
b = a;
a = t2;
}
this.h[0] = sum32(this.h[0], a);
this.h[1] = sum32(this.h[1], b);
this.h[2] = sum32(this.h[2], c);
this.h[3] = sum32(this.h[3], d);
this.h[4] = sum32(this.h[4], e);
};
SHA1.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils2.toHex32(this.h, "big");
else
return utils2.split32(this.h, "big");
};
return _1;
}
var _256;
var hasRequired_256;
function require_256() {
if (hasRequired_256) return _256;
hasRequired_256 = 1;
var utils2 = requireUtils();
var common2 = requireCommon$1();
var shaCommon = requireCommon();
var assert = requireMinimalisticAssert();
var sum32 = utils2.sum32;
var sum32_4 = utils2.sum32_4;
var sum32_5 = utils2.sum32_5;
var ch32 = shaCommon.ch32;
var maj32 = shaCommon.maj32;
var s0_256 = shaCommon.s0_256;
var s1_256 = shaCommon.s1_256;
var g0_256 = shaCommon.g0_256;
var g1_256 = shaCommon.g1_256;
var BlockHash = common2.BlockHash;
var sha256_K = [
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
];
function SHA2562() {
if (!(this instanceof SHA2562))
return new SHA2562();
BlockHash.call(this);
this.h = [
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
];
this.k = sha256_K;
this.W = new Array(64);
}
utils2.inherits(SHA2562, BlockHash);
_256 = SHA2562;
SHA2562.blockSize = 512;
SHA2562.outSize = 256;
SHA2562.hmacStrength = 192;
SHA2562.padLength = 64;
SHA2562.prototype._update = function _update(msg, start) {
var W = this.W;
for (var i = 0; i < 16; i++)
W[i] = msg[start + i];
for (; i < W.length; i++)
W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
var a = this.h[0];
var b = this.h[1];
var c = this.h[2];
var d = this.h[3];
var e = this.h[4];
var f = this.h[5];
var g = this.h[6];
var h2 = this.h[7];
assert(this.k.length === W.length);
for (i = 0; i < W.length; i++) {
var T1 = sum32_5(h2, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
var T2 = sum32(s0_256(a), maj32(a, b, c));
h2 = g;
g = f;
f = e;
e = sum32(d, T1);
d = c;
c = b;
b = a;
a = sum32(T1, T2);
}
this.h[0] = sum32(this.h[0], a);
this.h[1] = sum32(this.h[1], b);
this.h[2] = sum32(this.h[2], c);
this.h[3] = sum32(this.h[3], d);
this.h[4] = sum32(this.h[4], e);
this.h[5] = sum32(this.h[5], f);
this.h[6] = sum32(this.h[6], g);
this.h[7] = sum32(this.h[7], h2);
};
SHA2562.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils2.toHex32(this.h, "big");
else
return utils2.split32(this.h, "big");
};
return _256;
}
var _224;
var hasRequired_224;
function require_224() {
if (hasRequired_224) return _224;
hasRequired_224 = 1;
var utils2 = requireUtils();
var SHA2562 = require_256();
function SHA224() {
if (!(this instanceof SHA224))
return new SHA224();
SHA2562.call(this);
this.h = [
3238371032,
914150663,
812702999,
4144912697,
4290775857,
1750603025,
1694076839,
3204075428
];
}
utils2.inherits(SHA224, SHA2562);
_224 = SHA224;
SHA224.blockSize = 512;
SHA224.outSize = 224;
SHA224.hmacStrength = 192;
SHA224.padLength = 64;
SHA224.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils2.toHex32(this.h.slice(0, 7), "big");
else
return utils2.split32(this.h.slice(0, 7), "big");
};
return _224;
}
var _512;
var hasRequired_512;
function require_512() {
if (hasRequired_512) return _512;
hasRequired_512 = 1;
var utils2 = requireUtils();
var common2 = requireCommon$1();
var assert = requireMinimalisticAssert();
var rotr64_hi = utils2.rotr64_hi;
var rotr64_lo = utils2.rotr64_lo;
var shr64_hi = utils2.shr64_hi;
var shr64_lo = utils2.shr64_lo;
var sum64 = utils2.sum64;
var sum64_hi = utils2.sum64_hi;
var sum64_lo = utils2.sum64_lo;
var sum64_4_hi = utils2.sum64_4_hi;
var sum64_4_lo = utils2.sum64_4_lo;
var sum64_5_hi = utils2.sum64_5_hi;
var sum64_5_lo = utils2.sum64_5_lo;
var BlockHash = common2.BlockHash;
var sha512_K = [
1116352408,
3609767458,
1899447441,
602891725,
3049323471,
3964484399,
3921009573,
2173295548,
961987163,
4081628472,
1508970993,
3053834265,
2453635748,
2937671579,
2870763221,
3664609560,
3624381080,
2734883394,
310598401,
1164996542,
607225278,
1323610764,
1426881987,
3590304994,
1925078388,
4068182383,
2162078206,
991336113,
2614888103,
633803317,
3248222580,
3479774868,
3835390401,
2666613458,
4022224774,
944711139,
264347078,
2341262773,
604807628,
2007800933,
770255983,
1495990901,
1249150122,
1856431235,
1555081692,
3175218132,
1996064986,
2198950837,
2554220882,
3999719339,
2821834349,
766784016,
2952996808,
2566594879,
3210313671,
3203337956,
3336571891,
1034457026,
3584528711,
2466948901,
113926993,
3758326383,
338241895,
168717936,
666307205,
1188179964,
773529912,
1546045734,
1294757372,
1522805485,
1396182291,
2643833823,
1695183700,
2343527390,
1986661051,
1014477480,
2177026350,
1206759142,
2456956037,
344077627,
2730485921,
1290863460,
2820302411,
3158454273,
3259730800,
3505952657,
3345764771,
106217008,
3516065817,
3606008344,
3600352804,
1432725776,
4094571909,
1467031594,
275423344,
851169720,
430227734,
3100823752,
506948616,
1363258195,
659060556,
3750685593,
883997877,
3785050280,
958139571,
3318307427,
1322822218,
3812723403,
1537002063,
2003034995,
1747873779,
3602036899,
1955562222,
1575990012,
2024104815,
1125592928,
2227730452,
2716904306,
2361852424,
442776044,
2428436474,
593698344,
2756734187,
3733110249,
3204031479,
2999351573,
3329325298,
3815920427,
3391569614,
3928383900,
3515267271,
566280711,
3940187606,
3454069534,
4118630271,
4000239992,
116418474,
1914138554,
174292421,
2731055270,
289380356,
3203993006,
460393269,
320620315,
685471733,
587496836,
852142971,
1086792851,
1017036298,
365543100,
1126000580,
2618297676,
1288033470,
3409855158,
1501505948,
4234509866,
1607167915,
987167468,
1816402316,
1246189591
];
function SHA512() {
if (!(this instanceof SHA512))
return new SHA512();
BlockHash.call(this);
this.h = [
1779033703,
4089235720,
3144134277,
2227873595,
1013904242,
4271175723,
2773480762,
1595750129,
1359893119,
2917565137,
2600822924,
725511199,
528734635,
4215389547,
1541459225,
327033209
];
this.k = sha512_K;
this.W = new Array(160);
}
utils2.inherits(SHA512, BlockHash);
_512 = SHA512;
SHA512.blockSize = 1024;
SHA512.outSize = 512;
SHA512.hmacStrength = 192;
SHA512.padLength = 128;
SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
var W = this.W;
for (var i = 0; i < 32; i++)
W[i] = msg[start + i];
for (; i < W.length; i += 2) {
var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
var c1_hi = W[i - 14];
var c1_lo = W[i - 13];
var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
var c3_hi = W[i - 32];
var c3_lo = W[i - 31];
W[i] = sum64_4_hi(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo
);
W[i + 1] = sum64_4_lo(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo
);
}
};
SHA512.prototype._update = function _update(msg, start) {
this._prepareBlock(msg, start);
var W = this.W;
var ah = this.h[0];
var al = this.h[1];
var bh = this.h[2];
var bl = this.h[3];
var ch = this.h[4];
var cl = this.h[5];
var dh = this.h[6];
var dl = this.h[7];
var eh = this.h[8];
var el = this.h[9];
var fh = this.h[10];
var fl = this.h[11];
var gh = this.h[12];
var gl = this.h[13];
var hh = this.h[14];
var hl = this.h[15];
assert(this.k.length === W.length);
for (var i = 0; i < W.length; i += 2) {
var c0_hi = hh;
var c0_lo = hl;
var c1_hi = s1_512_hi(eh, el);
var c1_lo = s1_512_lo(eh, el);
var c2_hi = ch64_hi(eh, el, fh, fl, gh);
var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
var c3_hi = this.k[i];
var c3_lo = this.k[i + 1];
var c4_hi = W[i];
var c4_lo = W[i + 1];
var T1_hi = sum64_5_hi(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo,
c4_hi,
c4_lo
);
var T1_lo = sum64_5_lo(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo,
c4_hi,
c4_lo
);
c0_hi = s0_512_hi(ah, al);
c0_lo = s0_512_lo(ah, al);
c1_hi = maj64_hi(ah, al, bh, bl, ch);
c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
eh = sum64_hi(dh, dl, T1_hi, T1_lo);
el = sum64_lo(dl, dl, T1_hi, T1_lo);
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
}
sum64(this.h, 0, ah, al);
sum64(this.h, 2, bh, bl);
sum64(this.h, 4, ch, cl);
sum64(this.h, 6, dh, dl);
sum64(this.h, 8, eh, el);
sum64(this.h, 10, fh, fl);
sum64(this.h, 12, gh, gl);
sum64(this.h, 14, hh, hl);
};
SHA512.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils2.toHex32(this.h, "big");
else
return utils2.split32(this.h, "big");
};
function ch64_hi(xh, xl, yh, yl, zh) {
var r = xh & yh ^ ~xh & zh;
if (r < 0)
r += 4294967296;
return r;
}
function ch64_lo(xh, xl, yh, yl, zh, zl) {
var r = xl & yl ^ ~xl & zl;
if (r < 0)
r += 4294967296;
return r;
}
function maj64_hi(xh, xl, yh, yl, zh) {
var r = xh & yh ^ xh & zh ^ yh & zh;
if (r < 0)
r += 4294967296;
return r;
}
function maj64_lo(xh, xl, yh, yl, zh, zl) {
var r = xl & yl ^ xl & zl ^ yl & zl;
if (r < 0)
r += 4294967296;
return r;
}
function s0_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 28);
var c1_hi = rotr64_hi(xl, xh, 2);
var c2_hi = rotr64_hi(xl, xh, 7);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function s0_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 28);
var c1_lo = rotr64_lo(xl, xh, 2);
var c2_lo = rotr64_lo(xl, xh, 7);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
function s1_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 14);
var c1_hi = rotr64_hi(xh, xl, 18);
var c2_hi = rotr64_hi(xl, xh, 9);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function s1_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 14);
var c1_lo = rotr64_lo(xh, xl, 18);
var c2_lo = rotr64_lo(xl, xh, 9);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
function g0_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 1);
var c1_hi = rotr64_hi(xh, xl, 8);
var c2_hi = shr64_hi(xh, xl, 7);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function g0_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 1);
var c1_lo = rotr64_lo(xh, xl, 8);
var c2_lo = shr64_lo(xh, xl, 7);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
function g1_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 19);
var c1_hi = rotr64_hi(xl, xh, 29);
var c2_hi = shr64_hi(xh, xl, 6);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function g1_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 19);
var c1_lo = rotr64_lo(xl, xh, 29);
var c2_lo = shr64_lo(xh, xl, 6);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
return _512;
}
var _384;
var hasRequired_384;
function require_384() {
if (hasRequired_384) return _384;
hasRequired_384 = 1;
var utils2 = requireUtils();
var SHA512 = require_512();
function SHA384() {
if (!(this instanceof SHA384))
return new SHA384();
SHA512.call(this);
this.h = [
3418070365,
3238371032,
1654270250,
914150663,
2438529370,
812702999,
355462360,
4144912697,
1731405415,
4290775857,
2394180231,
1750603025,
3675008525,
1694076839,
1203062813,
3204075428
];
}
utils2.inherits(SHA384, SHA512);
_384 = SHA384;
SHA384.blockSize = 1024;
SHA384.outSize = 384;
SHA384.hmacStrength = 192;
SHA384.padLength = 128;
SHA384.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils2.toHex32(this.h.slice(0, 12), "big");
else
return utils2.split32(this.h.slice(0, 12), "big");
};
return _384;
}
var hasRequiredSha;
function requireSha() {
if (hasRequiredSha) return sha;
hasRequiredSha = 1;
sha.sha1 = require_1();
sha.sha224 = require_224();
sha.sha256 = require_256();
sha.sha384 = require_384();
sha.sha512 = require_512();
return sha;
}
var ripemd = {};
var hasRequiredRipemd;
function requireRipemd() {
if (hasRequiredRipemd) return ripemd;
hasRequiredRipemd = 1;
var utils2 = requireUtils();
var common2 = requireCommon$1();
var rotl32 = utils2.rotl32;
var sum32 = utils2.sum32;
var sum32_3 = utils2.sum32_3;
var sum32_4 = utils2.sum32_4;
var BlockHash = common2.BlockHash;
function RIPEMD160() {
if (!(this instanceof RIPEMD160))
return new RIPEMD160();
BlockHash.call(this);
this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
this.endian = "little";
}
utils2.inherits(RIPEMD160, BlockHash);
ripemd.ripemd160 = RIPEMD160;
RIPEMD160.blockSize = 512;
RIPEMD160.outSize = 160;
RIPEMD160.hmacStrength = 192;
RIPEMD160.padLength = 64;
RIPEMD160.prototype._update = function update(msg, start) {
var A = this.h[0];
var B = this.h[1];
var C = this.h[2];
var D = this.h[3];
var E = this.h[4];
var Ah = A;
var Bh = B;
var Ch = C;
var Dh = D;
var Eh = E;
for (var j = 0; j < 80; j++) {
var T = sum32(
rotl32(
sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
s2[j]
),
E
);
A = E;
E = D;
D = rotl32(C, 10);
C = B;
B = T;
T = sum32(
rotl32(
sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
sh[j]
),
Eh
);
Ah = Eh;
Eh = Dh;
Dh = rotl32(Ch, 10);
Ch = Bh;
Bh = T;
}
T = sum32_3(this.h[1], C, Dh);
this.h[1] = sum32_3(this.h[2], D, Eh);
this.h[2] = sum32_3(this.h[3], E, Ah);
this.h[3] = sum32_3(this.h[4], A, Bh);
this.h[4] = sum32_3(this.h[0], B, Ch);
this.h[0] = T;
};
RIPEMD160.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils2.toHex32(this.h, "little");
else
return utils2.split32(this.h, "little");
};
function f(j, x, y2, z) {
if (j <= 15)
return x ^ y2 ^ z;
else if (j <= 31)
return x & y2 | ~x & z;
else if (j <= 47)
return (x | ~y2) ^ z;
else if (j <= 63)
return x & z | y2 & ~z;
else
return x ^ (y2 | ~z);
}
function K(j) {
if (j <= 15)
return 0;
else if (j <= 31)
return 1518500249;
else if (j <= 47)
return 1859775393;
else if (j <= 63)
return 2400959708;
else
return 2840853838;
}
function Kh(j) {
if (j <= 15)
return 1352829926;
else if (j <= 31)
return 1548603684;
else if (j <= 47)
return 1836072691;
else if (j <= 63)
return 2053994217;
else
return 0;
}
var r = [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
7,
4,
13,
1,
10,
6,
15,
3,
12,
0,
9,
5,
2,
14,
11,
8,
3,
10,
14,
4,
9,
15,
8,
1,
2,
7,
0,
6,
13,
11,
5,
12,
1,
9,
11,
10,
0,
8,
12,
4,
13,
3,
7,
15,
14,
5,
6,
2,
4,
0,
5,
9,
7,
12,
2,
10,
14,
1,
3,
8,
11,
6,
15,
13
];
var rh = [
5,
14,
7,
0,
9,
2,
11,
4,
13,
6,
15,
8,
1,
10,
3,
12,
6,
11,
3,
7,
0,
13,
5,
10,
14,
15,
8,
12,
4,
9,
1,
2,
15,
5,
1,
3,
7,
14,
6,
9,
11,
8,
12,
2,
10,
0,
4,
13,
8,
6,
4,
1,
3,
11,
15,
0,
5,
12,
2,
13,
9,
7,
10,
14,
12,
15,
10,
4,
1,
5,
8,
7,
6,
2,
13,
14,
0,
3,
9,
11
];
var s2 = [
11,
14,
15,
12,
5,
8,
7,
9,
11,
13,
14,
15,
6,
7,
9,
8,
7,
6,
8,
13,
11,
9,
7,
15,
7,
12,
15,
9,
11,
7,
13,
12,
11,
13,
6,
7,
14,
9,
13,
15,
14,
8,
13,
6,
5,
12,
7,
5,
11,
12,
14,
15,
14,
15,
9,
8,
9,
14,
5,
6,
8,
6,
5,
12,
9,
15,
5,
11,
6,
8,
13,
12,
5,
12,
13,
14,
11,
8,
5,
6
];
var sh = [
8,
9,
9,
11,
13,
15,
15,
5,
7,
7,
8,
11,
14,
14,
12,
6,
9,
13,
15,
7,
12,
8,
9,
11,
7,
7,
12,
7,
6,
15,
13,
11,
9,
7,
15,
11,
8,
6,
6,
14,
12,
13,
5,
14,
13,
13,
7,
5,
15,
5,
8,
11,
14,
14,
6,
14,
6,
9,
12,
9,
12,
5,
15,
8,
8,
5,
12,
9,
12,
5,
14,
6,
8,
13,
6,
5,
15,
13,
11,
11
];
return ripemd;
}
var hmac;
var hasRequiredHmac;
function requireHmac() {
if (hasRequiredHmac) return hmac;
hasRequiredHmac = 1;
var utils2 = requireUtils();
var assert = requireMinimalisticAssert();
function Hmac(hash2, key, enc) {
if (!(this instanceof Hmac))
return new Hmac(hash2, key, enc);
this.Hash = hash2;
this.blockSize = hash2.blockSize / 8;
this.outSize = hash2.outSize / 8;
this.inner = null;
this.outer = null;
this._init(utils2.toArray(key, enc));
}
hmac = Hmac;
Hmac.prototype._init = function init(key) {
if (key.length > this.blockSize)
key = new this.Hash().update(key).digest();
assert(key.length <= this.blockSize);
for (var i = key.length; i < this.blockSize; i++)
key.push(0);
for (i = 0; i < key.length; i++)
key[i] ^= 54;
this.inner = new this.Hash().update(key);
for (i = 0; i < key.length; i++)
key[i] ^= 106;
this.outer = new this.Hash().update(key);
};
Hmac.prototype.update = function update(msg, enc) {
this.inner.update(msg, enc);
return this;
};
Hmac.prototype.digest = function digest(enc) {
this.outer.update(this.inner.digest());
return this.outer.digest(enc);
};
return hmac;
}
var hasRequiredHash;
function requireHash() {
if (hasRequiredHash) return hash$1;
hasRequiredHash = 1;
(function(exports3) {
var hash2 = exports3;
hash2.utils = requireUtils();
hash2.common = requireCommon$1();
hash2.sha = requireSha();
hash2.ripemd = requireRipemd();
hash2.hmac = requireHmac();
hash2.sha1 = hash2.sha.sha1;
hash2.sha256 = hash2.sha.sha256;
hash2.sha224 = hash2.sha.sha224;
hash2.sha384 = hash2.sha.sha384;
hash2.sha512 = hash2.sha.sha512;
hash2.ripemd160 = hash2.ripemd.ripemd160;
})(hash$1);
return hash$1;
}
var hashExports = requireHash();
const hash = /* @__PURE__ */ getDefaultExportFromCjs(hashExports);
var aesJs = { exports: {} };
/*! MIT License. Copyright 2015-2018 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */
var hasRequiredAesJs;
function requireAesJs() {
if (hasRequiredAesJs) return aesJs.exports;
hasRequiredAesJs = 1;
(function(module2, exports3) {
(function(root) {
function checkInt(value) {
return parseInt(value) === value;
}
function checkInts(arrayish) {
if (!checkInt(arrayish.length)) {
return false;
}
for (var i = 0; i < arrayish.length; i++) {
if (!checkInt(arrayish[i]) || arrayish[i] < 0 || arrayish[i] > 255) {
return false;
}
}
return true;
}
function coerceArray(arg, copy) {
if (arg.buffer && arg.name === "Uint8Array") {
if (copy) {
if (arg.slice) {
arg = arg.slice();
} else {
arg = Array.prototype.slice.call(arg);
}
}
return arg;
}
if (Array.isArray(arg)) {
if (!checkInts(arg)) {
throw new Error("Array contains invalid value: " + arg);
}
return new Uint8Array(arg);
}
if (checkInt(arg.length) && checkInts(arg)) {
return new Uint8Array(arg);
}
throw new Error("unsupported array-like object");
}
function createArray(length) {
return new Uint8Array(length);
}
function copyArray(sourceArray, targetArray, targetStart, sourceStart, sourceEnd) {
if (sourceStart != null || sourceEnd != null) {
if (sourceArray.slice) {
sourceArray = sourceArray.slice(sourceStart, sourceEnd);
} else {
sourceArray = Array.prototype.slice.call(sourceArray, sourceStart, sourceEnd);
}
}
targetArray.set(sourceArray, targetStart);
}
var convertUtf8 = /* @__PURE__ */ function() {
function toBytes2(text) {
var result = [], i = 0;
text = encodeURI(text);
while (i < text.length) {
var c = text.charCodeAt(i++);
if (c === 37) {
result.push(parseInt(text.substr(i, 2), 16));
i += 2;
} else {
result.push(c);
}
}
return coerceArray(result);
}
function fromBytes(bytes) {
var result = [], i = 0;
while (i < bytes.length) {
var c = bytes[i];
if (c < 128) {
result.push(String.fromCharCode(c));
i++;
} else if (c > 191 && c < 224) {
result.push(String.fromCharCode((c & 31) << 6 | bytes[i + 1] & 63));
i += 2;
} else {
result.push(String.fromCharCode((c & 15) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63));
i += 3;
}
}
return result.join("");
}
return {
toBytes: toBytes2,
fromBytes
};
}();
var convertHex = /* @__PURE__ */ function() {
function toBytes2(text) {
var result = [];
for (var i = 0; i < text.length; i += 2) {
result.push(parseInt(text.substr(i, 2), 16));
}
return result;
}
var Hex = "0123456789abcdef";
function fromBytes(bytes) {
var result = [];
for (var i = 0; i < bytes.length; i++) {
var v = bytes[i];
result.push(Hex[(v & 240) >> 4] + Hex[v & 15]);
}
return result.join("");
}
return {
toBytes: toBytes2,
fromBytes
};
}();
var numberOfRounds = { 16: 10, 24: 12, 32: 14 };
var rcon = [1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145];
var S = [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, 255, 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];
var Si = [82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 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];
var T1 = [3328402341, 4168907908, 4000806809, 4135287693, 4294111757, 3597364157, 3731845041, 2445657428, 1613770832, 33620227, 3462883241, 1445669757, 3892248089, 3050821474, 1303096294, 3967186586, 2412431941, 528646813, 2311702848, 4202528135, 4026202645, 2992200171, 2387036105, 4226871307, 1101901292, 3017069671, 1604494077, 1169141738, 597466303, 1403299063, 3832705686, 2613100635, 1974974402, 3791519004, 1033081774, 1277568618, 1815492186, 2118074177, 4126668546, 2211236943, 1748251740, 1369810420, 3521504564, 4193382664, 3799085459, 2883115123, 1647391059, 706024767, 134480908, 2512897874, 1176707941, 2646852446, 806885416, 932615841, 168101135, 798661301, 235341577, 605164086, 461406363, 3756188221, 3454790438, 1311188841, 2142417613, 3933566367, 302582043, 495158174, 1479289972, 874125870, 907746093, 3698224818, 3025820398, 1537253627, 2756858614, 1983593293, 3084310113, 2108928974, 1378429307, 3722699582, 1580150641, 327451799, 2790478837, 3117535592, 0, 3253595436, 1075847264, 3825007647, 2041688520, 3059440621, 3563743934, 2378943302, 1740553945, 1916352843, 2487896798, 2555137236, 2958579944, 2244988746, 3151024235, 3320835882, 1336584933, 3992714006, 2252555205, 2588757463, 1714631509, 293963156, 2319795663, 3925473552, 67240454, 4269768577, 2689618160, 2017213508, 631218106, 1269344483, 2723238387, 1571005438, 2151694528, 93294474, 1066570413, 563977660, 1882732616, 4059428100, 1673313503, 2008463041, 2950355573, 1109467491, 537923632, 3858759450, 4260623118, 3218264685, 2177748300, 403442708, 638784309, 3287084079, 3193921505, 899127202, 2286175436, 773265209, 2479146071, 1437050866, 4236148354, 2050833735, 3362022572, 3126681063, 840505643, 3866325909, 3227541664, 427917720, 2655997905, 2749160575, 1143087718, 1412049534, 999329963, 193497219, 2353415882, 3354324521, 1807268051, 672404540, 2816401017, 3160301282, 369822493, 2916866934, 3688947771, 1681011286, 1949973070, 336202270, 2454276571, 201721354, 1210328172, 3093060836, 2680341085, 3184776046, 1135389935, 3294782118, 965841320, 831886756, 3554993207, 4068047243, 3588745010, 2345191491, 1849112409, 3664604599, 26054028, 2983581028, 2622377682, 1235855840, 3630984372, 2891339514, 4092916743, 3488279077, 3395642799, 4101667470, 1202630377, 268961816, 1874508501, 4034427016, 1243948399, 1546530418, 941366308, 1470539505, 1941222599, 2546386513, 3421038627, 2715671932, 3899946140, 1042226977, 2521517021, 1639824860, 227249030, 260737669, 3765465232, 2084453954, 1907733956, 3429263018, 2420656344, 100860677, 4160157185, 470683154, 3261161891, 1781871967, 2924959737, 1773779408, 394692241, 2579611992, 974986535, 664706745, 3655459128, 3958962195, 731420851, 571543859, 3530123707, 2849626480, 126783113, 865375399, 765172662, 1008606754, 361203602, 3387549984, 2278477385, 2857719295, 1344809080, 2782912378, 59542671, 1503764984, 160008576, 437062935, 1707065306, 3622233649, 2218934982, 3496503480, 2185314755, 697932208, 1512910199, 504303377, 2075177163, 2824099068, 1841019862, 739644986];
var T2 = [2781242211, 2230877308, 2582542199, 2381740923, 234877682, 3184946027, 2984144751, 1418839493, 1348481072, 50462977, 2848876391, 2102799147, 434634494, 1656084439, 3863849899, 2599188086, 1167051466, 2636087938, 1082771913, 2281340285, 368048890, 3954334041, 3381544775, 201060592, 3963727277, 1739838676, 4250903202, 3930435503, 3206782108, 4149453988, 2531553906, 1536934080, 3262494647, 484572669, 2923271059, 1783375398, 1517041206, 1098792767, 49674231, 1334037708, 1550332980, 4098991525, 886171109, 150598129, 2481090929, 1940642008, 1398944049, 1059722517, 201851908, 1385547719, 1699095331, 1587397571, 674240536, 2704774806, 252314885, 3039795866, 151914247, 908333586, 2602270848, 1038082786, 651029483, 1766729511, 3447698098, 2682942837, 454166793, 2652734339, 1951935532, 775166490, 758520603, 3000790638, 4004797018, 4217086112, 4137964114, 1299594043, 1639438038, 3464344499, 2068982057, 1054729187, 1901997871, 2534638724, 4121318227, 1757008337, 0, 750906861, 1614815264, 535035132, 3363418545, 3988151131, 3201591914, 1183697867, 3647454910, 1265776953, 3734260298, 3566750796, 3903871064, 1250283471, 1807470800, 717615087, 3847203498, 384695291, 3313910595, 36172137