{"version":3,"sources":["webpack:///./node_modules/ethereumjs-util/dist.browser/bytes.js","webpack:///./node_modules/ethereum-bloom-filters/dist/index.js","webpack:///./node_modules/ethereum-cryptography/secp256k1.js","webpack:///./node_modules/ethereum-cryptography/random.js","webpack:///./node_modules/ethereumjs-util/dist.browser/helpers.js","webpack:///./node_modules/ethereum-bloom-filters/dist/utils.js","webpack:///./node_modules/ethereumjs-util/dist.browser/constants.js","webpack:///./node_modules/ethereumjs-util/dist.browser/index.js","webpack:///./node_modules/ethereumjs-util/dist.browser/types.js","webpack:///./node_modules/ethereumjs-util/dist.browser/hash.js","webpack:///./node_modules/ethereum-cryptography/hash-utils.js","webpack:///./node_modules/ethereumjs-util/node_modules/bn.js/lib/bn.js","webpack:///./node_modules/ethereumjs-util/dist.browser/account.js","webpack:///./node_modules/ethereumjs-util/dist.browser/signature.js","webpack:///./node_modules/ethereumjs-util/dist.browser/internal.js","webpack:///./node_modules/ethereum-cryptography/keccak.js","webpack:///./node_modules/ethereumjs-util/dist.browser/externals.js","webpack:///./node_modules/ethereumjs-util/dist.browser/address.js","webpack:///./node_modules/ethereumjs-util/dist.browser/object.js"],"names":["__values","this","o","s","Symbol","iterator","m","i","call","length","next","value","done","TypeError","__read","n","r","e","ar","push","error","Object","defineProperty","exports","bufArrToArr","arrToBufArr","validateNoLeadingZeroes","baToJSON","toUtf8","addHexPrefix","toUnsigned","fromSigned","bufferToHex","bufferToInt","toBuffer","unpadHexString","unpadArray","unpadBuffer","setLengthRight","setLengthLeft","zeros","intToBuffer","intToHex","externals_1","internal_1","helpers_1","Number","isSafeInteger","Error","concat","toString","hex","Buffer","from","padToEven","slice","bytes","allocUnsafe","fill","setLength","msg","right","buf","copy","assertIsBuffer","stripZeros","a","first","assertIsArray","assertIsHexString","stripHexPrefix","v","isBuffer","Array","isArray","Uint8Array","isHexString","BN","isBN","isNeg","toArrayLike","toArray","toNumber","num","fromTwos","toTwos","str","isHexPrefixed","replace","ba","array","values","e_1","_a","_b","entries","_c","_d","k","e_1_1","return","arr","map","utils_1","isBloom","bloom","test","isInBloom","constructor","bytesToHex","hash","keccak256","bitpos","parseInt","substr","offset","codePointToInt","charCodeAt","Math","floor","codePoint","isTopic","topic","isAddress","address","match","isUserEthereumAddressInBloom","ethereumAddress","padLeft","isContractAddressInBloom","contractAddress","isTopicInBloom","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","rejected","result","then","apply","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","op","pop","secp256k1_1","random_1","createPrivateKey","pk","getRandomBytes","privateKeyVerify","createPrivateKeySync","getRandomBytesSync","p","hasOwnProperty","__export","randombytes","err","resp","assertIsString","input","sha3","toByteArray","substring","addSlice","String","isByteArray","args","prototype","arguments","data","keccak_256","chars","hasPrefix","padding","join","KECCAK256_RLP","KECCAK256_RLP_S","KECCAK256_RLP_ARRAY","KECCAK256_RLP_ARRAY_S","KECCAK256_NULL","KECCAK256_NULL_S","TWO_POW256","MAX_INTEGER","MAX_UINT64","buffer_1","__createBinding","create","k2","enumerable","get","__exportStar","getKeys","fromAscii","fromUtf8","toAscii","arrayContainsArray","getBinarySize","toType","TypeOutput","bnToRlp","bnToUnpaddedBuffer","bnToHex","bytes_1","outputType","output","bn","max","MAX_SAFE_INTEGER","gt","rlphash","ripemd160FromArray","ripemd160FromString","ripemd160","sha256FromArray","sha256FromString","sha256","keccakFromArray","keccakFromHexString","keccakFromString","keccak","keccak_1","createHash","bits","keccak224","keccak384","keccak512","_sha256","update","digest","_ripemd160","padded","rlp","encode","createHashFunction","hashConstructor","assert","val","inherits","ctor","superCtor","super_","TempCtor","number","base","endian","negative","words","red","_init","module","wordSize","window","parseHex4Bits","string","index","c","parseHexByte","lowerBound","parseBase","start","end","mul","b","len","min","move","dest","src","left","cmp","_initNumber","_initArray","_parseHex","_parseBase","ceil","j","w","off","_strip","limbLen","limbPow","total","mod","word","imuln","_iaddn","pow","_move","clone","_expand","size","_normSign","for","inspect","groupSizes","groupBases","out","carry","groupSize","groupBase","isZero","modrn","idivn","ret","toJSON","smallMulTo","self","lo","ncarry","rword","maxJ","ArrayType","byteLength","reqLength","res","allocate","_toArrayLikeLE","position","shift","_toArrayLikeBE","clz32","_countBits","_zeroBits","bitLength","hi","zeroBits","width","abs","inotn","iaddn","testn","notn","ineg","neg","iuor","ior","or","uor","iuand","iand","and","uand","iuxor","ixor","xor","uxor","bytesNeeded","bitsLeft","setn","bit","wbit","iadd","isub","add","sub","comb10MulTo","mid","a0","al0","ah0","a1","al1","ah1","a2","al2","ah2","a3","al3","ah3","a4","al4","ah4","a5","al5","ah5","a6","al6","ah6","a7","al7","ah7","a8","al8","ah8","a9","al9","ah9","b0","bl0","bh0","b1","bl1","bh1","b2","bl2","bh2","b3","bl3","bh3","b4","bl4","bh4","b5","bl5","bh5","b6","bl6","bh6","b7","bl7","bh7","b8","bl8","bh8","b9","bl9","bh9","w0","imul","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","bigMulTo","hncarry","jumboMulTo","FFTM","x","mulTo","makeRBT","N","l","revBin","rb","permute","rbt","rws","iws","rtws","itws","transform","rtwdf","cos","PI","itwdf","sin","rtwdf_","itwdf_","re","ie","ro","io","rx","guessLen13b","odd","conjugate","normalize13b","ws","round","convert13b","stub","ph","mulp","rwst","iwst","nrws","nrwst","niwst","rmws","mulf","isNegNum","muln","sqr","isqr","toBitArray","q","iushln","carryMask","newCarry","ishln","iushrn","hint","extended","h","mask","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","isubn","addn","subn","iabs","_ishlnsubmul","_wordDiv","mode","bhi","diff","qj","div","divmod","positive","divn","umod","divRound","dm","half","r2","andln","acc","modn","egcd","A","B","C","D","isEven","yp","xp","im","isOdd","jm","gcd","_invmp","x1","x2","delta","cmpn","invm","bincn","ucmp","gtn","gten","gte","ltn","lt","lten","lte","eqn","eq","Red","toRed","ctx","convertTo","_forceRed","fromRed","convertFrom","forceRed","redAdd","redIAdd","redSub","redISub","redShl","shl","redMul","_verify2","redIMul","redSqr","_verify1","redISqr","redSqrt","sqrt","redInvm","redNeg","redPow","primes","k256","p224","p192","p25519","MPrime","name","tmp","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","split","imulK","strip","outLen","prev","mod3","one","nOne","lpow","z","inv","wnd","current","currentLen","mont","u","__importDefault","__esModule","isZeroAddress","zeroAddress","importPublic","privateToAddress","privateToPublic","publicToAddress","pubToAddress","isValidPublic","isValidPrivate","generateAddress2","generateAddress","isValidChecksumAddress","toChecksumAddress","isValidAddress","Account","assert_1","constants_1","hash_1","types_1","nonce","balance","stateRoot","codeHash","_validate","fromAccountData","accountData","fromRlpSerializedAccount","serialized","decode","fromValuesArray","raw","serialize","isContract","equals","isEmpty","hexAddress","eip1191ChainId","toLowerCase","prefix","chainId","toUpperCase","nonceBN","salt","initCode","default","privateKey","publicKey","sanitize","publicKeyVerify","pubKey","publicKeyConvert","publicKeyCreate","addr","zeroAddr","hashPersonalMessage","isValidSignature","fromRpcSig","toCompactSig","toRpcSig","ecrecover","ecsign","calculateSigRecovery","vBN","chainIdBN","isValidSigRecovery","recovery","rec","msgHash","ecdsaSign","signature","recid","senderPubKey","ecdsaRecover","vn","ss","sig","homesteadOrLater","SECP256K1_N_DIV_2","SECP256K1_N","rBN","sBN","message","superset","subset","some","indexOf","code","fromCharCode","stringValue","params","key","allowEmpty","hash_utils_1","createKeccakHash","__setModuleDefault","__importStar","bn_js_1","Address","account_1","zero","fromString","fromPublicKey","fromPrivateKey","generate","generate2","isPrecompileOrSystemAddress","addressBN","rangeMin","rangeMax","defineProperties","fields","_fields","obj_1","forEach","field","getter","setter","allowZero","allowLess","configurable","set","alias","d","keys_1","keys"],"mappings":"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","file":"js/chunk-vendors~836717c0.2366b7e9.js","sourcesContent":["\"use strict\";\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.bufArrToArr = exports.arrToBufArr = exports.validateNoLeadingZeroes = exports.baToJSON = exports.toUtf8 = exports.addHexPrefix = exports.toUnsigned = exports.fromSigned = exports.bufferToHex = exports.bufferToInt = exports.toBuffer = exports.unpadHexString = exports.unpadArray = exports.unpadBuffer = exports.setLengthRight = exports.setLengthLeft = exports.zeros = exports.intToBuffer = exports.intToHex = void 0;\nvar externals_1 = require(\"./externals\");\nvar internal_1 = require(\"./internal\");\nvar helpers_1 = require(\"./helpers\");\n/**\n * Converts a `Number` into a hex `String`\n * @param {Number} i\n * @return {String}\n */\nvar intToHex = function (i) {\n    if (!Number.isSafeInteger(i) || i < 0) {\n        throw new Error(\"Received an invalid integer type: \".concat(i));\n    }\n    return \"0x\".concat(i.toString(16));\n};\nexports.intToHex = intToHex;\n/**\n * Converts an `Number` to a `Buffer`\n * @param {Number} i\n * @return {Buffer}\n */\nvar intToBuffer = function (i) {\n    var hex = (0, exports.intToHex)(i);\n    return Buffer.from((0, internal_1.padToEven)(hex.slice(2)), 'hex');\n};\nexports.intToBuffer = intToBuffer;\n/**\n * Returns a buffer filled with 0s.\n * @param bytes the number of bytes the buffer should be\n */\nvar zeros = function (bytes) {\n    return Buffer.allocUnsafe(bytes).fill(0);\n};\nexports.zeros = zeros;\n/**\n * Pads a `Buffer` with zeros till it has `length` bytes.\n * Truncates the beginning or end of input if its length exceeds `length`.\n * @param msg the value to pad (Buffer)\n * @param length the number of bytes the output should be\n * @param right whether to start padding form the left or right\n * @return (Buffer)\n */\nvar setLength = function (msg, length, right) {\n    var buf = (0, exports.zeros)(length);\n    if (right) {\n        if (msg.length < length) {\n            msg.copy(buf);\n            return buf;\n        }\n        return msg.slice(0, length);\n    }\n    else {\n        if (msg.length < length) {\n            msg.copy(buf, length - msg.length);\n            return buf;\n        }\n        return msg.slice(-length);\n    }\n};\n/**\n * Left Pads a `Buffer` with leading zeros till it has `length` bytes.\n * Or it truncates the beginning if it exceeds.\n * @param msg the value to pad (Buffer)\n * @param length the number of bytes the output should be\n * @return (Buffer)\n */\nvar setLengthLeft = function (msg, length) {\n    (0, helpers_1.assertIsBuffer)(msg);\n    return setLength(msg, length, false);\n};\nexports.setLengthLeft = setLengthLeft;\n/**\n * Right Pads a `Buffer` with trailing zeros till it has `length` bytes.\n * it truncates the end if it exceeds.\n * @param msg the value to pad (Buffer)\n * @param length the number of bytes the output should be\n * @return (Buffer)\n */\nvar setLengthRight = function (msg, length) {\n    (0, helpers_1.assertIsBuffer)(msg);\n    return setLength(msg, length, true);\n};\nexports.setLengthRight = setLengthRight;\n/**\n * Trims leading zeros from a `Buffer`, `String` or `Number[]`.\n * @param a (Buffer|Array|String)\n * @return (Buffer|Array|String)\n */\nvar stripZeros = function (a) {\n    var first = a[0];\n    while (a.length > 0 && first.toString() === '0') {\n        a = a.slice(1);\n        first = a[0];\n    }\n    return a;\n};\n/**\n * Trims leading zeros from a `Buffer`.\n * @param a (Buffer)\n * @return (Buffer)\n */\nvar unpadBuffer = function (a) {\n    (0, helpers_1.assertIsBuffer)(a);\n    return stripZeros(a);\n};\nexports.unpadBuffer = unpadBuffer;\n/**\n * Trims leading zeros from an `Array` (of numbers).\n * @param a (number[])\n * @return (number[])\n */\nvar unpadArray = function (a) {\n    (0, helpers_1.assertIsArray)(a);\n    return stripZeros(a);\n};\nexports.unpadArray = unpadArray;\n/**\n * Trims leading zeros from a hex-prefixed `String`.\n * @param a (String)\n * @return (String)\n */\nvar unpadHexString = function (a) {\n    (0, helpers_1.assertIsHexString)(a);\n    a = (0, internal_1.stripHexPrefix)(a);\n    return stripZeros(a);\n};\nexports.unpadHexString = unpadHexString;\n/**\n * Attempts to turn a value into a `Buffer`.\n * Inputs supported: `Buffer`, `String` (hex-prefixed), `Number`, null/undefined, `BN` and other objects\n * with a `toArray()` or `toBuffer()` method.\n * @param v the value\n */\nvar toBuffer = function (v) {\n    if (v === null || v === undefined) {\n        return Buffer.allocUnsafe(0);\n    }\n    if (Buffer.isBuffer(v)) {\n        return Buffer.from(v);\n    }\n    if (Array.isArray(v) || v instanceof Uint8Array) {\n        return Buffer.from(v);\n    }\n    if (typeof v === 'string') {\n        if (!(0, internal_1.isHexString)(v)) {\n            throw new Error(\"Cannot convert string to buffer. toBuffer only supports 0x-prefixed hex strings and this string was given: \".concat(v));\n        }\n        return Buffer.from((0, internal_1.padToEven)((0, internal_1.stripHexPrefix)(v)), 'hex');\n    }\n    if (typeof v === 'number') {\n        return (0, exports.intToBuffer)(v);\n    }\n    if (externals_1.BN.isBN(v)) {\n        if (v.isNeg()) {\n            throw new Error(\"Cannot convert negative BN to buffer. Given: \".concat(v));\n        }\n        return v.toArrayLike(Buffer);\n    }\n    if (v.toArray) {\n        // converts a BN to a Buffer\n        return Buffer.from(v.toArray());\n    }\n    if (v.toBuffer) {\n        return Buffer.from(v.toBuffer());\n    }\n    throw new Error('invalid type');\n};\nexports.toBuffer = toBuffer;\n/**\n * Converts a `Buffer` to a `Number`.\n * @param buf `Buffer` object to convert\n * @throws If the input number exceeds 53 bits.\n */\nvar bufferToInt = function (buf) {\n    return new externals_1.BN((0, exports.toBuffer)(buf)).toNumber();\n};\nexports.bufferToInt = bufferToInt;\n/**\n * Converts a `Buffer` into a `0x`-prefixed hex `String`.\n * @param buf `Buffer` object to convert\n */\nvar bufferToHex = function (buf) {\n    buf = (0, exports.toBuffer)(buf);\n    return '0x' + buf.toString('hex');\n};\nexports.bufferToHex = bufferToHex;\n/**\n * Interprets a `Buffer` as a signed integer and returns a `BN`. Assumes 256-bit numbers.\n * @param num Signed integer value\n */\nvar fromSigned = function (num) {\n    return new externals_1.BN(num).fromTwos(256);\n};\nexports.fromSigned = fromSigned;\n/**\n * Converts a `BN` to an unsigned integer and returns it as a `Buffer`. Assumes 256-bit numbers.\n * @param num\n */\nvar toUnsigned = function (num) {\n    return Buffer.from(num.toTwos(256).toArray());\n};\nexports.toUnsigned = toUnsigned;\n/**\n * Adds \"0x\" to a given `String` if it does not already start with \"0x\".\n */\nvar addHexPrefix = function (str) {\n    if (typeof str !== 'string') {\n        return str;\n    }\n    return (0, internal_1.isHexPrefixed)(str) ? str : '0x' + str;\n};\nexports.addHexPrefix = addHexPrefix;\n/**\n * Returns the utf8 string representation from a hex string.\n *\n * Examples:\n *\n * Input 1: '657468657265756d000000000000000000000000000000000000000000000000'\n * Input 2: '657468657265756d'\n * Input 3: '000000000000000000000000000000000000000000000000657468657265756d'\n *\n * Output (all 3 input variants): 'ethereum'\n *\n * Note that this method is not intended to be used with hex strings\n * representing quantities in both big endian or little endian notation.\n *\n * @param string Hex string, should be `0x` prefixed\n * @return Utf8 string\n */\nvar toUtf8 = function (hex) {\n    var zerosRegexp = /^(00)+|(00)+$/g;\n    hex = (0, internal_1.stripHexPrefix)(hex);\n    if (hex.length % 2 !== 0) {\n        throw new Error('Invalid non-even hex string input for toUtf8() provided');\n    }\n    var bufferVal = Buffer.from(hex.replace(zerosRegexp, ''), 'hex');\n    return bufferVal.toString('utf8');\n};\nexports.toUtf8 = toUtf8;\n/**\n * Converts a `Buffer` or `Array` to JSON.\n * @param ba (Buffer|Array)\n * @return (Array|String|null)\n */\nvar baToJSON = function (ba) {\n    if (Buffer.isBuffer(ba)) {\n        return \"0x\".concat(ba.toString('hex'));\n    }\n    else if (ba instanceof Array) {\n        var array = [];\n        for (var i = 0; i < ba.length; i++) {\n            array.push((0, exports.baToJSON)(ba[i]));\n        }\n        return array;\n    }\n};\nexports.baToJSON = baToJSON;\n/**\n * Checks provided Buffers for leading zeroes and throws if found.\n *\n * Examples:\n *\n * Valid values: 0x1, 0x, 0x01, 0x1234\n * Invalid values: 0x0, 0x00, 0x001, 0x0001\n *\n * Note: This method is useful for validating that RLP encoded integers comply with the rule that all\n * integer values encoded to RLP must be in the most compact form and contain no leading zero bytes\n * @param values An object containing string keys and Buffer values\n * @throws if any provided value is found to have leading zero bytes\n */\nvar validateNoLeadingZeroes = function (values) {\n    var e_1, _a;\n    try {\n        for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var _d = __read(_c.value, 2), k = _d[0], v = _d[1];\n            if (v !== undefined && v.length > 0 && v[0] === 0) {\n                throw new Error(\"\".concat(k, \" cannot have leading zeroes, received: \").concat(v.toString('hex')));\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n};\nexports.validateNoLeadingZeroes = validateNoLeadingZeroes;\nfunction arrToBufArr(arr) {\n    if (!Array.isArray(arr)) {\n        return Buffer.from(arr);\n    }\n    return arr.map(function (a) { return arrToBufArr(a); });\n}\nexports.arrToBufArr = arrToBufArr;\nfunction bufArrToArr(arr) {\n    if (!Array.isArray(arr)) {\n        return Uint8Array.from(arr !== null && arr !== void 0 ? arr : []);\n    }\n    return arr.map(function (a) { return bufArrToArr(a); });\n}\nexports.bufArrToArr = bufArrToArr;\n//# sourceMappingURL=bytes.js.map","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils_1 = require(\"./utils\");\r\n/**\r\n * Returns true if the bloom is a valid bloom\r\n * @param bloom The bloom\r\n */\r\nfunction isBloom(bloom) {\r\n    if (typeof bloom !== 'string') {\r\n        return false;\r\n    }\r\n    if (!/^(0x)?[0-9a-f]{512}$/i.test(bloom)) {\r\n        return false;\r\n    }\r\n    if (/^(0x)?[0-9a-f]{512}$/.test(bloom) ||\r\n        /^(0x)?[0-9A-F]{512}$/.test(bloom)) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\nexports.isBloom = isBloom;\r\n/**\r\n * Returns true if the value is part of the given bloom\r\n * note: false positives are possible.\r\n * @param bloom encoded bloom\r\n * @param value The value\r\n */\r\nfunction isInBloom(bloom, value) {\r\n    if (typeof value === 'object' && value.constructor === Uint8Array) {\r\n        value = utils_1.bytesToHex(value);\r\n    }\r\n    const hash = utils_1.keccak256(value).replace('0x', '');\r\n    for (let i = 0; i < 12; i += 4) {\r\n        // calculate bit position in bloom filter that must be active\r\n        const bitpos = ((parseInt(hash.substr(i, 2), 16) << 8) +\r\n            parseInt(hash.substr(i + 2, 2), 16)) &\r\n            2047;\r\n        // test if bitpos in bloom is active\r\n        const code = codePointToInt(bloom.charCodeAt(bloom.length - 1 - Math.floor(bitpos / 4)));\r\n        const offset = 1 << bitpos % 4;\r\n        if ((code & offset) !== offset) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\nexports.isInBloom = isInBloom;\r\n/**\r\n * Code points to int\r\n * @param codePoint The code point\r\n */\r\nfunction codePointToInt(codePoint) {\r\n    if (codePoint >= 48 && codePoint <= 57) {\r\n        /* ['0'..'9'] -> [0..9] */\r\n        return codePoint - 48;\r\n    }\r\n    if (codePoint >= 65 && codePoint <= 70) {\r\n        /* ['A'..'F'] -> [10..15] */\r\n        return codePoint - 55;\r\n    }\r\n    if (codePoint >= 97 && codePoint <= 102) {\r\n        /* ['a'..'f'] -> [10..15] */\r\n        return codePoint - 87;\r\n    }\r\n    throw new Error('invalid bloom');\r\n}\r\n/**\r\n * Returns true if the ethereum users address is part of the given bloom.\r\n * note: false positives are possible.\r\n * @param bloom encoded bloom\r\n * @param address the address to test\r\n */\r\nfunction isUserEthereumAddressInBloom(bloom, ethereumAddress) {\r\n    if (!isBloom(bloom)) {\r\n        throw new Error('Invalid bloom given');\r\n    }\r\n    if (!isAddress(ethereumAddress)) {\r\n        throw new Error(`Invalid ethereum address given: \"${ethereumAddress}\"`);\r\n    }\r\n    // you have to pad the ethereum address to 32 bytes\r\n    // else the bloom filter does not work\r\n    // this is only if your matching the USERS\r\n    // ethereum address. Contract address do not need this\r\n    // hence why we have 2 methods\r\n    // (0x is not in the 2nd parameter of padleft so 64 chars is fine)\r\n    const address = utils_1.padLeft(ethereumAddress, 64);\r\n    return isInBloom(bloom, address);\r\n}\r\nexports.isUserEthereumAddressInBloom = isUserEthereumAddressInBloom;\r\n/**\r\n * Returns true if the contract address is part of the given bloom.\r\n * note: false positives are possible.\r\n * @param bloom encoded bloom\r\n * @param contractAddress the contract address to test\r\n */\r\nfunction isContractAddressInBloom(bloom, contractAddress) {\r\n    if (!isBloom(bloom)) {\r\n        throw new Error('Invalid bloom given');\r\n    }\r\n    if (!isAddress(contractAddress)) {\r\n        throw new Error(`Invalid contract address given: \"${contractAddress}\"`);\r\n    }\r\n    return isInBloom(bloom, contractAddress);\r\n}\r\nexports.isContractAddressInBloom = isContractAddressInBloom;\r\n/**\r\n * Returns true if the topic is part of the given bloom.\r\n * note: false positives are possible.\r\n * @param bloom encoded bloom\r\n * @param topic the topic encoded hex\r\n */\r\nfunction isTopicInBloom(bloom, topic) {\r\n    if (!isBloom(bloom)) {\r\n        throw new Error('Invalid bloom given');\r\n    }\r\n    if (!isTopic(topic)) {\r\n        throw new Error('Invalid topic');\r\n    }\r\n    return isInBloom(bloom, topic);\r\n}\r\nexports.isTopicInBloom = isTopicInBloom;\r\n/**\r\n * Checks if its a valid topic\r\n * @param topic encoded hex topic\r\n */\r\nfunction isTopic(topic) {\r\n    if (typeof topic !== 'string') {\r\n        return false;\r\n    }\r\n    if (!/^(0x)?[0-9a-f]{64}$/i.test(topic)) {\r\n        return false;\r\n    }\r\n    else if (/^(0x)?[0-9a-f]{64}$/.test(topic) ||\r\n        /^(0x)?[0-9A-F]{64}$/.test(topic)) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\nexports.isTopic = isTopic;\r\n/**\r\n * Is valid address\r\n * @param address The address\r\n */\r\nfunction isAddress(address) {\r\n    if (typeof address !== 'string') {\r\n        return false;\r\n    }\r\n    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {\r\n        return true;\r\n    }\r\n    if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\nexports.isAddress = isAddress;\r\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar secp256k1_1 = require(\"secp256k1\");\nvar random_1 = require(\"./random\");\nvar SECP256K1_PRIVATE_KEY_SIZE = 32;\nfunction createPrivateKey() {\n    return __awaiter(this, void 0, void 0, function () {\n        var pk;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    if (!true) return [3 /*break*/, 2];\n                    return [4 /*yield*/, random_1.getRandomBytes(SECP256K1_PRIVATE_KEY_SIZE)];\n                case 1:\n                    pk = _a.sent();\n                    if (secp256k1_1.privateKeyVerify(pk)) {\n                        return [2 /*return*/, pk];\n                    }\n                    return [3 /*break*/, 0];\n                case 2: return [2 /*return*/];\n            }\n        });\n    });\n}\nexports.createPrivateKey = createPrivateKey;\nfunction createPrivateKeySync() {\n    while (true) {\n        var pk = random_1.getRandomBytesSync(SECP256K1_PRIVATE_KEY_SIZE);\n        if (secp256k1_1.privateKeyVerify(pk)) {\n            return pk;\n        }\n    }\n}\nexports.createPrivateKeySync = createPrivateKeySync;\n__export(require(\"secp256k1\"));\n//# sourceMappingURL=secp256k1.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar randombytes = require(\"randombytes\");\nfunction getRandomBytes(bytes) {\n    return new Promise(function (resolve, reject) {\n        randombytes(bytes, function (err, resp) {\n            if (err) {\n                reject(err);\n                return;\n            }\n            resolve(resp);\n        });\n    });\n}\nexports.getRandomBytes = getRandomBytes;\nfunction getRandomBytesSync(bytes) {\n    return randombytes(bytes);\n}\nexports.getRandomBytesSync = getRandomBytesSync;\n//# sourceMappingURL=random.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assertIsString = exports.assertIsArray = exports.assertIsBuffer = exports.assertIsHexString = void 0;\nvar internal_1 = require(\"./internal\");\n/**\n * Throws if a string is not hex prefixed\n * @param {string} input string to check hex prefix of\n */\nvar assertIsHexString = function (input) {\n    if (!(0, internal_1.isHexString)(input)) {\n        var msg = \"This method only supports 0x-prefixed hex strings but input was: \".concat(input);\n        throw new Error(msg);\n    }\n};\nexports.assertIsHexString = assertIsHexString;\n/**\n * Throws if input is not a buffer\n * @param {Buffer} input value to check\n */\nvar assertIsBuffer = function (input) {\n    if (!Buffer.isBuffer(input)) {\n        var msg = \"This method only supports Buffer but input was: \".concat(input);\n        throw new Error(msg);\n    }\n};\nexports.assertIsBuffer = assertIsBuffer;\n/**\n * Throws if input is not an array\n * @param {number[]} input value to check\n */\nvar assertIsArray = function (input) {\n    if (!Array.isArray(input)) {\n        var msg = \"This method only supports number arrays but input was: \".concat(input);\n        throw new Error(msg);\n    }\n};\nexports.assertIsArray = assertIsArray;\n/**\n * Throws if input is not a string\n * @param {string} input value to check\n */\nvar assertIsString = function (input) {\n    if (typeof input !== 'string') {\n        var msg = \"This method only supports strings but input was: \".concat(input);\n        throw new Error(msg);\n    }\n};\nexports.assertIsString = assertIsString;\n//# sourceMappingURL=helpers.js.map","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst sha3 = require(\"js-sha3\");\r\n/**\r\n * Keccak256 hash\r\n * @param data The data\r\n */\r\nfunction keccak256(data) {\r\n    return '0x' + sha3.keccak_256(toByteArray(data));\r\n}\r\nexports.keccak256 = keccak256;\r\n/**\r\n * Adding padding to string on the left\r\n * @param value The value\r\n * @param chars The chars\r\n */\r\nexports.padLeft = (value, chars) => {\r\n    const hasPrefix = /^0x/i.test(value) || typeof value === 'number';\r\n    value = value.toString().replace(/^0x/i, '');\r\n    const padding = chars - value.length + 1 >= 0 ? chars - value.length + 1 : 0;\r\n    return (hasPrefix ? '0x' : '') + new Array(padding).join('0') + value;\r\n};\r\n/**\r\n * Convert bytes to hex\r\n * @param bytes The bytes\r\n */\r\nfunction bytesToHex(bytes) {\r\n    const hex = [];\r\n    for (let i = 0; i < bytes.length; i++) {\r\n        hex.push((bytes[i] >>> 4).toString(16));\r\n        hex.push((bytes[i] & 0xf).toString(16));\r\n    }\r\n    return `0x${hex.join('').replace(/^0+/, '')}`;\r\n}\r\nexports.bytesToHex = bytesToHex;\r\n/**\r\n * To byte array\r\n * @param value The value\r\n */\r\nfunction toByteArray(value) {\r\n    if (value == null) {\r\n        throw new Error('cannot convert null value to array');\r\n    }\r\n    if (typeof value === 'string') {\r\n        const match = value.match(/^(0x)?[0-9a-fA-F]*$/);\r\n        if (!match) {\r\n            throw new Error('invalid hexidecimal string');\r\n        }\r\n        if (match[1] !== '0x') {\r\n            throw new Error('hex string must have 0x prefix');\r\n        }\r\n        value = value.substring(2);\r\n        if (value.length % 2) {\r\n            value = '0' + value;\r\n        }\r\n        const result = [];\r\n        for (let i = 0; i < value.length; i += 2) {\r\n            result.push(parseInt(value.substr(i, 2), 16));\r\n        }\r\n        return addSlice(new Uint8Array(result));\r\n    }\r\n    if (isByteArray(value)) {\r\n        return addSlice(new Uint8Array(value));\r\n    }\r\n    throw new Error('invalid arrayify value');\r\n}\r\nexports.toByteArray = toByteArray;\r\n/**\r\n * Is byte array\r\n * @param value The value\r\n */\r\nfunction isByteArray(value) {\r\n    if (!value ||\r\n        // tslint:disable-next-line: radix\r\n        parseInt(String(value.length)) != value.length ||\r\n        typeof value === 'string') {\r\n        return false;\r\n    }\r\n    for (let i = 0; i < value.length; i++) {\r\n        const v = value[i];\r\n        // tslint:disable-next-line: radix\r\n        if (v < 0 || v >= 256 || parseInt(String(v)) != v) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n/**\r\n * Add slice to array\r\n * @param array The array\r\n */\r\nfunction addSlice(array) {\r\n    if (array.slice !== undefined) {\r\n        return array;\r\n    }\r\n    array.slice = () => {\r\n        const args = Array.prototype.slice.call(arguments);\r\n        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));\r\n    };\r\n    return array;\r\n}\r\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.KECCAK256_RLP = exports.KECCAK256_RLP_S = exports.KECCAK256_RLP_ARRAY = exports.KECCAK256_RLP_ARRAY_S = exports.KECCAK256_NULL = exports.KECCAK256_NULL_S = exports.TWO_POW256 = exports.MAX_INTEGER = exports.MAX_UINT64 = void 0;\nvar buffer_1 = require(\"buffer\");\nvar externals_1 = require(\"./externals\");\n/**\n * 2^64-1\n */\nexports.MAX_UINT64 = new externals_1.BN('ffffffffffffffff', 16);\n/**\n * The max integer that the evm can handle (2^256-1)\n */\nexports.MAX_INTEGER = new externals_1.BN('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16);\n/**\n * 2^256\n */\nexports.TWO_POW256 = new externals_1.BN('10000000000000000000000000000000000000000000000000000000000000000', 16);\n/**\n * Keccak-256 hash of null\n */\nexports.KECCAK256_NULL_S = 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470';\n/**\n * Keccak-256 hash of null\n */\nexports.KECCAK256_NULL = buffer_1.Buffer.from(exports.KECCAK256_NULL_S, 'hex');\n/**\n * Keccak-256 of an RLP of an empty array\n */\nexports.KECCAK256_RLP_ARRAY_S = '1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347';\n/**\n * Keccak-256 of an RLP of an empty array\n */\nexports.KECCAK256_RLP_ARRAY = buffer_1.Buffer.from(exports.KECCAK256_RLP_ARRAY_S, 'hex');\n/**\n * Keccak-256 hash of the RLP of null\n */\nexports.KECCAK256_RLP_S = '56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421';\n/**\n * Keccak-256 hash of the RLP of null\n */\nexports.KECCAK256_RLP = buffer_1.Buffer.from(exports.KECCAK256_RLP_S, 'hex');\n//# sourceMappingURL=constants.js.map","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isHexString = exports.getKeys = exports.fromAscii = exports.fromUtf8 = exports.toAscii = exports.arrayContainsArray = exports.getBinarySize = exports.padToEven = exports.stripHexPrefix = exports.isHexPrefixed = void 0;\n/**\n * Constants\n */\n__exportStar(require(\"./constants\"), exports);\n/**\n * Account class and helper functions\n */\n__exportStar(require(\"./account\"), exports);\n/**\n * Address type\n */\n__exportStar(require(\"./address\"), exports);\n/**\n * Hash functions\n */\n__exportStar(require(\"./hash\"), exports);\n/**\n * ECDSA signature\n */\n__exportStar(require(\"./signature\"), exports);\n/**\n * Utilities for manipulating Buffers, byte arrays, etc.\n */\n__exportStar(require(\"./bytes\"), exports);\n/**\n * Function for definining properties on an object\n */\n__exportStar(require(\"./object\"), exports);\n/**\n * External exports (BN, rlp)\n */\n__exportStar(require(\"./externals\"), exports);\n/**\n * Helpful TypeScript types\n */\n__exportStar(require(\"./types\"), exports);\n/**\n * Export ethjs-util methods\n */\nvar internal_1 = require(\"./internal\");\nObject.defineProperty(exports, \"isHexPrefixed\", { enumerable: true, get: function () { return internal_1.isHexPrefixed; } });\nObject.defineProperty(exports, \"stripHexPrefix\", { enumerable: true, get: function () { return internal_1.stripHexPrefix; } });\nObject.defineProperty(exports, \"padToEven\", { enumerable: true, get: function () { return internal_1.padToEven; } });\nObject.defineProperty(exports, \"getBinarySize\", { enumerable: true, get: function () { return internal_1.getBinarySize; } });\nObject.defineProperty(exports, \"arrayContainsArray\", { enumerable: true, get: function () { return internal_1.arrayContainsArray; } });\nObject.defineProperty(exports, \"toAscii\", { enumerable: true, get: function () { return internal_1.toAscii; } });\nObject.defineProperty(exports, \"fromUtf8\", { enumerable: true, get: function () { return internal_1.fromUtf8; } });\nObject.defineProperty(exports, \"fromAscii\", { enumerable: true, get: function () { return internal_1.fromAscii; } });\nObject.defineProperty(exports, \"getKeys\", { enumerable: true, get: function () { return internal_1.getKeys; } });\nObject.defineProperty(exports, \"isHexString\", { enumerable: true, get: function () { return internal_1.isHexString; } });\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.toType = exports.TypeOutput = exports.bnToRlp = exports.bnToUnpaddedBuffer = exports.bnToHex = void 0;\nvar externals_1 = require(\"./externals\");\nvar internal_1 = require(\"./internal\");\nvar bytes_1 = require(\"./bytes\");\n/**\n * Convert BN to 0x-prefixed hex string.\n */\nfunction bnToHex(value) {\n    return \"0x\".concat(value.toString(16));\n}\nexports.bnToHex = bnToHex;\n/**\n * Convert value from BN to an unpadded Buffer\n * (useful for RLP transport)\n * @param value value to convert\n */\nfunction bnToUnpaddedBuffer(value) {\n    // Using `bn.toArrayLike(Buffer)` instead of `bn.toBuffer()`\n    // for compatibility with browserify and similar tools\n    return (0, bytes_1.unpadBuffer)(value.toArrayLike(Buffer));\n}\nexports.bnToUnpaddedBuffer = bnToUnpaddedBuffer;\n/**\n * Deprecated alias for {@link bnToUnpaddedBuffer}\n * @deprecated\n */\nfunction bnToRlp(value) {\n    return bnToUnpaddedBuffer(value);\n}\nexports.bnToRlp = bnToRlp;\n/**\n * Type output options\n */\nvar TypeOutput;\n(function (TypeOutput) {\n    TypeOutput[TypeOutput[\"Number\"] = 0] = \"Number\";\n    TypeOutput[TypeOutput[\"BN\"] = 1] = \"BN\";\n    TypeOutput[TypeOutput[\"Buffer\"] = 2] = \"Buffer\";\n    TypeOutput[TypeOutput[\"PrefixedHexString\"] = 3] = \"PrefixedHexString\";\n})(TypeOutput = exports.TypeOutput || (exports.TypeOutput = {}));\nfunction toType(input, outputType) {\n    if (input === null) {\n        return null;\n    }\n    if (input === undefined) {\n        return undefined;\n    }\n    if (typeof input === 'string' && !(0, internal_1.isHexString)(input)) {\n        throw new Error(\"A string must be provided with a 0x-prefix, given: \".concat(input));\n    }\n    else if (typeof input === 'number' && !Number.isSafeInteger(input)) {\n        throw new Error('The provided number is greater than MAX_SAFE_INTEGER (please use an alternative input type)');\n    }\n    var output = (0, bytes_1.toBuffer)(input);\n    if (outputType === TypeOutput.Buffer) {\n        return output;\n    }\n    else if (outputType === TypeOutput.BN) {\n        return new externals_1.BN(output);\n    }\n    else if (outputType === TypeOutput.Number) {\n        var bn = new externals_1.BN(output);\n        var max = new externals_1.BN(Number.MAX_SAFE_INTEGER.toString());\n        if (bn.gt(max)) {\n            throw new Error('The provided number is greater than MAX_SAFE_INTEGER (please use an alternative output type)');\n        }\n        return bn.toNumber();\n    }\n    else {\n        // outputType === TypeOutput.PrefixedHexString\n        return \"0x\".concat(output.toString('hex'));\n    }\n}\nexports.toType = toType;\n//# sourceMappingURL=types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.rlphash = exports.ripemd160FromArray = exports.ripemd160FromString = exports.ripemd160 = exports.sha256FromArray = exports.sha256FromString = exports.sha256 = exports.keccakFromArray = exports.keccakFromHexString = exports.keccakFromString = exports.keccak256 = exports.keccak = void 0;\nvar keccak_1 = require(\"ethereum-cryptography/keccak\");\nvar createHash = require('create-hash');\nvar externals_1 = require(\"./externals\");\nvar bytes_1 = require(\"./bytes\");\nvar helpers_1 = require(\"./helpers\");\n/**\n * Creates Keccak hash of a Buffer input\n * @param a The input data (Buffer)\n * @param bits (number = 256) The Keccak width\n */\nvar keccak = function (a, bits) {\n    if (bits === void 0) { bits = 256; }\n    (0, helpers_1.assertIsBuffer)(a);\n    switch (bits) {\n        case 224: {\n            return (0, keccak_1.keccak224)(a);\n        }\n        case 256: {\n            return (0, keccak_1.keccak256)(a);\n        }\n        case 384: {\n            return (0, keccak_1.keccak384)(a);\n        }\n        case 512: {\n            return (0, keccak_1.keccak512)(a);\n        }\n        default: {\n            throw new Error(\"Invald algorithm: keccak\".concat(bits));\n        }\n    }\n};\nexports.keccak = keccak;\n/**\n * Creates Keccak-256 hash of the input, alias for keccak(a, 256).\n * @param a The input data (Buffer)\n */\nvar keccak256 = function (a) {\n    return (0, exports.keccak)(a);\n};\nexports.keccak256 = keccak256;\n/**\n * Creates Keccak hash of a utf-8 string input\n * @param a The input data (String)\n * @param bits (number = 256) The Keccak width\n */\nvar keccakFromString = function (a, bits) {\n    if (bits === void 0) { bits = 256; }\n    (0, helpers_1.assertIsString)(a);\n    var buf = Buffer.from(a, 'utf8');\n    return (0, exports.keccak)(buf, bits);\n};\nexports.keccakFromString = keccakFromString;\n/**\n * Creates Keccak hash of an 0x-prefixed string input\n * @param a The input data (String)\n * @param bits (number = 256) The Keccak width\n */\nvar keccakFromHexString = function (a, bits) {\n    if (bits === void 0) { bits = 256; }\n    (0, helpers_1.assertIsHexString)(a);\n    return (0, exports.keccak)((0, bytes_1.toBuffer)(a), bits);\n};\nexports.keccakFromHexString = keccakFromHexString;\n/**\n * Creates Keccak hash of a number array input\n * @param a The input data (number[])\n * @param bits (number = 256) The Keccak width\n */\nvar keccakFromArray = function (a, bits) {\n    if (bits === void 0) { bits = 256; }\n    (0, helpers_1.assertIsArray)(a);\n    return (0, exports.keccak)((0, bytes_1.toBuffer)(a), bits);\n};\nexports.keccakFromArray = keccakFromArray;\n/**\n * Creates SHA256 hash of an input.\n * @param  a The input data (Buffer|Array|String)\n */\nvar _sha256 = function (a) {\n    a = (0, bytes_1.toBuffer)(a);\n    return createHash('sha256').update(a).digest();\n};\n/**\n * Creates SHA256 hash of a Buffer input.\n * @param a The input data (Buffer)\n */\nvar sha256 = function (a) {\n    (0, helpers_1.assertIsBuffer)(a);\n    return _sha256(a);\n};\nexports.sha256 = sha256;\n/**\n * Creates SHA256 hash of a string input.\n * @param a The input data (string)\n */\nvar sha256FromString = function (a) {\n    (0, helpers_1.assertIsString)(a);\n    return _sha256(a);\n};\nexports.sha256FromString = sha256FromString;\n/**\n * Creates SHA256 hash of a number[] input.\n * @param a The input data (number[])\n */\nvar sha256FromArray = function (a) {\n    (0, helpers_1.assertIsArray)(a);\n    return _sha256(a);\n};\nexports.sha256FromArray = sha256FromArray;\n/**\n * Creates RIPEMD160 hash of the input.\n * @param a The input data (Buffer|Array|String|Number)\n * @param padded Whether it should be padded to 256 bits or not\n */\nvar _ripemd160 = function (a, padded) {\n    a = (0, bytes_1.toBuffer)(a);\n    var hash = createHash('rmd160').update(a).digest();\n    if (padded === true) {\n        return (0, bytes_1.setLengthLeft)(hash, 32);\n    }\n    else {\n        return hash;\n    }\n};\n/**\n * Creates RIPEMD160 hash of a Buffer input.\n * @param a The input data (Buffer)\n * @param padded Whether it should be padded to 256 bits or not\n */\nvar ripemd160 = function (a, padded) {\n    (0, helpers_1.assertIsBuffer)(a);\n    return _ripemd160(a, padded);\n};\nexports.ripemd160 = ripemd160;\n/**\n * Creates RIPEMD160 hash of a string input.\n * @param a The input data (String)\n * @param padded Whether it should be padded to 256 bits or not\n */\nvar ripemd160FromString = function (a, padded) {\n    (0, helpers_1.assertIsString)(a);\n    return _ripemd160(a, padded);\n};\nexports.ripemd160FromString = ripemd160FromString;\n/**\n * Creates RIPEMD160 hash of a number[] input.\n * @param a The input data (number[])\n * @param padded Whether it should be padded to 256 bits or not\n */\nvar ripemd160FromArray = function (a, padded) {\n    (0, helpers_1.assertIsArray)(a);\n    return _ripemd160(a, padded);\n};\nexports.ripemd160FromArray = ripemd160FromArray;\n/**\n * Creates SHA-3 hash of the RLP encoded version of the input.\n * @param a The input data\n */\nvar rlphash = function (a) {\n    return (0, exports.keccak)(externals_1.rlp.encode(a));\n};\nexports.rlphash = rlphash;\n//# sourceMappingURL=hash.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction createHashFunction(hashConstructor) {\n    return function (msg) {\n        var hash = hashConstructor();\n        hash.update(msg);\n        return Buffer.from(hash.digest());\n    };\n}\nexports.createHashFunction = createHashFunction;\n//# sourceMappingURL=hash-utils.js.map","(function (module, exports) {\n  'use strict';\n\n  // Utils\n  function assert (val, msg) {\n    if (!val) throw new Error(msg || 'Assertion failed');\n  }\n\n  // Could use `inherits` module, but don't want to move from single file\n  // architecture yet.\n  function inherits (ctor, superCtor) {\n    ctor.super_ = superCtor;\n    var TempCtor = function () {};\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  }\n\n  // BN\n\n  function BN (number, base, endian) {\n    if (BN.isBN(number)) {\n      return number;\n    }\n\n    this.negative = 0;\n    this.words = null;\n    this.length = 0;\n\n    // Reduction context\n    this.red = null;\n\n    if (number !== null) {\n      if (base === 'le' || base === 'be') {\n        endian = base;\n        base = 10;\n      }\n\n      this._init(number || 0, base || 10, endian || 'be');\n    }\n  }\n  if (typeof module === 'object') {\n    module.exports = BN;\n  } else {\n    exports.BN = BN;\n  }\n\n  BN.BN = BN;\n  BN.wordSize = 26;\n\n  var Buffer;\n  try {\n    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\n      Buffer = window.Buffer;\n    } else {\n      Buffer = require('buffer').Buffer;\n    }\n  } catch (e) {\n  }\n\n  BN.isBN = function isBN (num) {\n    if (num instanceof BN) {\n      return true;\n    }\n\n    return num !== null && typeof num === 'object' &&\n      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\n  };\n\n  BN.max = function max (left, right) {\n    if (left.cmp(right) > 0) return left;\n    return right;\n  };\n\n  BN.min = function min (left, right) {\n    if (left.cmp(right) < 0) return left;\n    return right;\n  };\n\n  BN.prototype._init = function init (number, base, endian) {\n    if (typeof number === 'number') {\n      return this._initNumber(number, base, endian);\n    }\n\n    if (typeof number === 'object') {\n      return this._initArray(number, base, endian);\n    }\n\n    if (base === 'hex') {\n      base = 16;\n    }\n    assert(base === (base | 0) && base >= 2 && base <= 36);\n\n    number = number.toString().replace(/\\s+/g, '');\n    var start = 0;\n    if (number[0] === '-') {\n      start++;\n      this.negative = 1;\n    }\n\n    if (start < number.length) {\n      if (base === 16) {\n        this._parseHex(number, start, endian);\n      } else {\n        this._parseBase(number, base, start);\n        if (endian === 'le') {\n          this._initArray(this.toArray(), base, endian);\n        }\n      }\n    }\n  };\n\n  BN.prototype._initNumber = function _initNumber (number, base, endian) {\n    if (number < 0) {\n      this.negative = 1;\n      number = -number;\n    }\n    if (number < 0x4000000) {\n      this.words = [number & 0x3ffffff];\n      this.length = 1;\n    } else if (number < 0x10000000000000) {\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff\n      ];\n      this.length = 2;\n    } else {\n      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff,\n        1\n      ];\n      this.length = 3;\n    }\n\n    if (endian !== 'le') return;\n\n    // Reverse the bytes\n    this._initArray(this.toArray(), base, endian);\n  };\n\n  BN.prototype._initArray = function _initArray (number, base, endian) {\n    // Perhaps a Uint8Array\n    assert(typeof number.length === 'number');\n    if (number.length <= 0) {\n      this.words = [0];\n      this.length = 1;\n      return this;\n    }\n\n    this.length = Math.ceil(number.length / 3);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    var j, w;\n    var off = 0;\n    if (endian === 'be') {\n      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\n        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    } else if (endian === 'le') {\n      for (i = 0, j = 0; i < number.length; i += 3) {\n        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    }\n    return this._strip();\n  };\n\n  function parseHex4Bits (string, index) {\n    var c = string.charCodeAt(index);\n    // '0' - '9'\n    if (c >= 48 && c <= 57) {\n      return c - 48;\n    // 'A' - 'F'\n    } else if (c >= 65 && c <= 70) {\n      return c - 55;\n    // 'a' - 'f'\n    } else if (c >= 97 && c <= 102) {\n      return c - 87;\n    } else {\n      assert(false, 'Invalid character in ' + string);\n    }\n  }\n\n  function parseHexByte (string, lowerBound, index) {\n    var r = parseHex4Bits(string, index);\n    if (index - 1 >= lowerBound) {\n      r |= parseHex4Bits(string, index - 1) << 4;\n    }\n    return r;\n  }\n\n  BN.prototype._parseHex = function _parseHex (number, start, endian) {\n    // Create possibly bigger array to ensure that it fits the number\n    this.length = Math.ceil((number.length - start) / 6);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    // 24-bits chunks\n    var off = 0;\n    var j = 0;\n\n    var w;\n    if (endian === 'be') {\n      for (i = number.length - 1; i >= start; i -= 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    } else {\n      var parseLength = number.length - start;\n      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    }\n\n    this._strip();\n  };\n\n  function parseBase (str, start, end, mul) {\n    var r = 0;\n    var b = 0;\n    var len = Math.min(str.length, end);\n    for (var i = start; i < len; i++) {\n      var c = str.charCodeAt(i) - 48;\n\n      r *= mul;\n\n      // 'a'\n      if (c >= 49) {\n        b = c - 49 + 0xa;\n\n      // 'A'\n      } else if (c >= 17) {\n        b = c - 17 + 0xa;\n\n      // '0' - '9'\n      } else {\n        b = c;\n      }\n      assert(c >= 0 && b < mul, 'Invalid character');\n      r += b;\n    }\n    return r;\n  }\n\n  BN.prototype._parseBase = function _parseBase (number, base, start) {\n    // Initialize as zero\n    this.words = [0];\n    this.length = 1;\n\n    // Find length of limb in base\n    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\n      limbLen++;\n    }\n    limbLen--;\n    limbPow = (limbPow / base) | 0;\n\n    var total = number.length - start;\n    var mod = total % limbLen;\n    var end = Math.min(total, total - mod) + start;\n\n    var word = 0;\n    for (var i = start; i < end; i += limbLen) {\n      word = parseBase(number, i, i + limbLen, base);\n\n      this.imuln(limbPow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    if (mod !== 0) {\n      var pow = 1;\n      word = parseBase(number, i, number.length, base);\n\n      for (i = 0; i < mod; i++) {\n        pow *= base;\n      }\n\n      this.imuln(pow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    this._strip();\n  };\n\n  BN.prototype.copy = function copy (dest) {\n    dest.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      dest.words[i] = this.words[i];\n    }\n    dest.length = this.length;\n    dest.negative = this.negative;\n    dest.red = this.red;\n  };\n\n  function move (dest, src) {\n    dest.words = src.words;\n    dest.length = src.length;\n    dest.negative = src.negative;\n    dest.red = src.red;\n  }\n\n  BN.prototype._move = function _move (dest) {\n    move(dest, this);\n  };\n\n  BN.prototype.clone = function clone () {\n    var r = new BN(null);\n    this.copy(r);\n    return r;\n  };\n\n  BN.prototype._expand = function _expand (size) {\n    while (this.length < size) {\n      this.words[this.length++] = 0;\n    }\n    return this;\n  };\n\n  // Remove leading `0` from `this`\n  BN.prototype._strip = function strip () {\n    while (this.length > 1 && this.words[this.length - 1] === 0) {\n      this.length--;\n    }\n    return this._normSign();\n  };\n\n  BN.prototype._normSign = function _normSign () {\n    // -0 = 0\n    if (this.length === 1 && this.words[0] === 0) {\n      this.negative = 0;\n    }\n    return this;\n  };\n\n  // Check Symbol.for because not everywhere where Symbol defined\n  // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#Browser_compatibility\n  if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {\n    try {\n      BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;\n    } catch (e) {\n      BN.prototype.inspect = inspect;\n    }\n  } else {\n    BN.prototype.inspect = inspect;\n  }\n\n  function inspect () {\n    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\n  }\n\n  /*\n\n  var zeros = [];\n  var groupSizes = [];\n  var groupBases = [];\n\n  var s = '';\n  var i = -1;\n  while (++i < BN.wordSize) {\n    zeros[i] = s;\n    s += '0';\n  }\n  groupSizes[0] = 0;\n  groupSizes[1] = 0;\n  groupBases[0] = 0;\n  groupBases[1] = 0;\n  var base = 2 - 1;\n  while (++base < 36 + 1) {\n    var groupSize = 0;\n    var groupBase = 1;\n    while (groupBase < (1 << BN.wordSize) / base) {\n      groupBase *= base;\n      groupSize += 1;\n    }\n    groupSizes[base] = groupSize;\n    groupBases[base] = groupBase;\n  }\n\n  */\n\n  var zeros = [\n    '',\n    '0',\n    '00',\n    '000',\n    '0000',\n    '00000',\n    '000000',\n    '0000000',\n    '00000000',\n    '000000000',\n    '0000000000',\n    '00000000000',\n    '000000000000',\n    '0000000000000',\n    '00000000000000',\n    '000000000000000',\n    '0000000000000000',\n    '00000000000000000',\n    '000000000000000000',\n    '0000000000000000000',\n    '00000000000000000000',\n    '000000000000000000000',\n    '0000000000000000000000',\n    '00000000000000000000000',\n    '000000000000000000000000',\n    '0000000000000000000000000'\n  ];\n\n  var groupSizes = [\n    0, 0,\n    25, 16, 12, 11, 10, 9, 8,\n    8, 7, 7, 7, 7, 6, 6,\n    6, 6, 6, 6, 6, 5, 5,\n    5, 5, 5, 5, 5, 5, 5,\n    5, 5, 5, 5, 5, 5, 5\n  ];\n\n  var groupBases = [\n    0, 0,\n    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\n    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\n    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\n    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\n    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\n  ];\n\n  BN.prototype.toString = function toString (base, padding) {\n    base = base || 10;\n    padding = padding | 0 || 1;\n\n    var out;\n    if (base === 16 || base === 'hex') {\n      out = '';\n      var off = 0;\n      var carry = 0;\n      for (var i = 0; i < this.length; i++) {\n        var w = this.words[i];\n        var word = (((w << off) | carry) & 0xffffff).toString(16);\n        carry = (w >>> (24 - off)) & 0xffffff;\n        if (carry !== 0 || i !== this.length - 1) {\n          out = zeros[6 - word.length] + word + out;\n        } else {\n          out = word + out;\n        }\n        off += 2;\n        if (off >= 26) {\n          off -= 26;\n          i--;\n        }\n      }\n      if (carry !== 0) {\n        out = carry.toString(16) + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    if (base === (base | 0) && base >= 2 && base <= 36) {\n      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\n      var groupSize = groupSizes[base];\n      // var groupBase = Math.pow(base, groupSize);\n      var groupBase = groupBases[base];\n      out = '';\n      var c = this.clone();\n      c.negative = 0;\n      while (!c.isZero()) {\n        var r = c.modrn(groupBase).toString(base);\n        c = c.idivn(groupBase);\n\n        if (!c.isZero()) {\n          out = zeros[groupSize - r.length] + r + out;\n        } else {\n          out = r + out;\n        }\n      }\n      if (this.isZero()) {\n        out = '0' + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    assert(false, 'Base should be between 2 and 36');\n  };\n\n  BN.prototype.toNumber = function toNumber () {\n    var ret = this.words[0];\n    if (this.length === 2) {\n      ret += this.words[1] * 0x4000000;\n    } else if (this.length === 3 && this.words[2] === 0x01) {\n      // NOTE: at this stage it is known that the top bit is set\n      ret += 0x10000000000000 + (this.words[1] * 0x4000000);\n    } else if (this.length > 2) {\n      assert(false, 'Number can only safely store up to 53 bits');\n    }\n    return (this.negative !== 0) ? -ret : ret;\n  };\n\n  BN.prototype.toJSON = function toJSON () {\n    return this.toString(16, 2);\n  };\n\n  if (Buffer) {\n    BN.prototype.toBuffer = function toBuffer (endian, length) {\n      return this.toArrayLike(Buffer, endian, length);\n    };\n  }\n\n  BN.prototype.toArray = function toArray (endian, length) {\n    return this.toArrayLike(Array, endian, length);\n  };\n\n  var allocate = function allocate (ArrayType, size) {\n    if (ArrayType.allocUnsafe) {\n      return ArrayType.allocUnsafe(size);\n    }\n    return new ArrayType(size);\n  };\n\n  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\n    this._strip();\n\n    var byteLength = this.byteLength();\n    var reqLength = length || Math.max(1, byteLength);\n    assert(byteLength <= reqLength, 'byte array longer than desired length');\n    assert(reqLength > 0, 'Requested array length <= 0');\n\n    var res = allocate(ArrayType, reqLength);\n    var postfix = endian === 'le' ? 'LE' : 'BE';\n    this['_toArrayLike' + postfix](res, byteLength);\n    return res;\n  };\n\n  BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {\n    var position = 0;\n    var carry = 0;\n\n    for (var i = 0, shift = 0; i < this.length; i++) {\n      var word = (this.words[i] << shift) | carry;\n\n      res[position++] = word & 0xff;\n      if (position < res.length) {\n        res[position++] = (word >> 8) & 0xff;\n      }\n      if (position < res.length) {\n        res[position++] = (word >> 16) & 0xff;\n      }\n\n      if (shift === 6) {\n        if (position < res.length) {\n          res[position++] = (word >> 24) & 0xff;\n        }\n        carry = 0;\n        shift = 0;\n      } else {\n        carry = word >>> 24;\n        shift += 2;\n      }\n    }\n\n    if (position < res.length) {\n      res[position++] = carry;\n\n      while (position < res.length) {\n        res[position++] = 0;\n      }\n    }\n  };\n\n  BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {\n    var position = res.length - 1;\n    var carry = 0;\n\n    for (var i = 0, shift = 0; i < this.length; i++) {\n      var word = (this.words[i] << shift) | carry;\n\n      res[position--] = word & 0xff;\n      if (position >= 0) {\n        res[position--] = (word >> 8) & 0xff;\n      }\n      if (position >= 0) {\n        res[position--] = (word >> 16) & 0xff;\n      }\n\n      if (shift === 6) {\n        if (position >= 0) {\n          res[position--] = (word >> 24) & 0xff;\n        }\n        carry = 0;\n        shift = 0;\n      } else {\n        carry = word >>> 24;\n        shift += 2;\n      }\n    }\n\n    if (position >= 0) {\n      res[position--] = carry;\n\n      while (position >= 0) {\n        res[position--] = 0;\n      }\n    }\n  };\n\n  if (Math.clz32) {\n    BN.prototype._countBits = function _countBits (w) {\n      return 32 - Math.clz32(w);\n    };\n  } else {\n    BN.prototype._countBits = function _countBits (w) {\n      var t = w;\n      var r = 0;\n      if (t >= 0x1000) {\n        r += 13;\n        t >>>= 13;\n      }\n      if (t >= 0x40) {\n        r += 7;\n        t >>>= 7;\n      }\n      if (t >= 0x8) {\n        r += 4;\n        t >>>= 4;\n      }\n      if (t >= 0x02) {\n        r += 2;\n        t >>>= 2;\n      }\n      return r + t;\n    };\n  }\n\n  BN.prototype._zeroBits = function _zeroBits (w) {\n    // Short-cut\n    if (w === 0) return 26;\n\n    var t = w;\n    var r = 0;\n    if ((t & 0x1fff) === 0) {\n      r += 13;\n      t >>>= 13;\n    }\n    if ((t & 0x7f) === 0) {\n      r += 7;\n      t >>>= 7;\n    }\n    if ((t & 0xf) === 0) {\n      r += 4;\n      t >>>= 4;\n    }\n    if ((t & 0x3) === 0) {\n      r += 2;\n      t >>>= 2;\n    }\n    if ((t & 0x1) === 0) {\n      r++;\n    }\n    return r;\n  };\n\n  // Return number of used bits in a BN\n  BN.prototype.bitLength = function bitLength () {\n    var w = this.words[this.length - 1];\n    var hi = this._countBits(w);\n    return (this.length - 1) * 26 + hi;\n  };\n\n  function toBitArray (num) {\n    var w = new Array(num.bitLength());\n\n    for (var bit = 0; bit < w.length; bit++) {\n      var off = (bit / 26) | 0;\n      var wbit = bit % 26;\n\n      w[bit] = (num.words[off] >>> wbit) & 0x01;\n    }\n\n    return w;\n  }\n\n  // Number of trailing zero bits\n  BN.prototype.zeroBits = function zeroBits () {\n    if (this.isZero()) return 0;\n\n    var r = 0;\n    for (var i = 0; i < this.length; i++) {\n      var b = this._zeroBits(this.words[i]);\n      r += b;\n      if (b !== 26) break;\n    }\n    return r;\n  };\n\n  BN.prototype.byteLength = function byteLength () {\n    return Math.ceil(this.bitLength() / 8);\n  };\n\n  BN.prototype.toTwos = function toTwos (width) {\n    if (this.negative !== 0) {\n      return this.abs().inotn(width).iaddn(1);\n    }\n    return this.clone();\n  };\n\n  BN.prototype.fromTwos = function fromTwos (width) {\n    if (this.testn(width - 1)) {\n      return this.notn(width).iaddn(1).ineg();\n    }\n    return this.clone();\n  };\n\n  BN.prototype.isNeg = function isNeg () {\n    return this.negative !== 0;\n  };\n\n  // Return negative clone of `this`\n  BN.prototype.neg = function neg () {\n    return this.clone().ineg();\n  };\n\n  BN.prototype.ineg = function ineg () {\n    if (!this.isZero()) {\n      this.negative ^= 1;\n    }\n\n    return this;\n  };\n\n  // Or `num` with `this` in-place\n  BN.prototype.iuor = function iuor (num) {\n    while (this.length < num.length) {\n      this.words[this.length++] = 0;\n    }\n\n    for (var i = 0; i < num.length; i++) {\n      this.words[i] = this.words[i] | num.words[i];\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.ior = function ior (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuor(num);\n  };\n\n  // Or `num` with `this`\n  BN.prototype.or = function or (num) {\n    if (this.length > num.length) return this.clone().ior(num);\n    return num.clone().ior(this);\n  };\n\n  BN.prototype.uor = function uor (num) {\n    if (this.length > num.length) return this.clone().iuor(num);\n    return num.clone().iuor(this);\n  };\n\n  // And `num` with `this` in-place\n  BN.prototype.iuand = function iuand (num) {\n    // b = min-length(num, this)\n    var b;\n    if (this.length > num.length) {\n      b = num;\n    } else {\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = this.words[i] & num.words[i];\n    }\n\n    this.length = b.length;\n\n    return this._strip();\n  };\n\n  BN.prototype.iand = function iand (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuand(num);\n  };\n\n  // And `num` with `this`\n  BN.prototype.and = function and (num) {\n    if (this.length > num.length) return this.clone().iand(num);\n    return num.clone().iand(this);\n  };\n\n  BN.prototype.uand = function uand (num) {\n    if (this.length > num.length) return this.clone().iuand(num);\n    return num.clone().iuand(this);\n  };\n\n  // Xor `num` with `this` in-place\n  BN.prototype.iuxor = function iuxor (num) {\n    // a.length > b.length\n    var a;\n    var b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = a.words[i] ^ b.words[i];\n    }\n\n    if (this !== a) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = a.length;\n\n    return this._strip();\n  };\n\n  BN.prototype.ixor = function ixor (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuxor(num);\n  };\n\n  // Xor `num` with `this`\n  BN.prototype.xor = function xor (num) {\n    if (this.length > num.length) return this.clone().ixor(num);\n    return num.clone().ixor(this);\n  };\n\n  BN.prototype.uxor = function uxor (num) {\n    if (this.length > num.length) return this.clone().iuxor(num);\n    return num.clone().iuxor(this);\n  };\n\n  // Not ``this`` with ``width`` bitwidth\n  BN.prototype.inotn = function inotn (width) {\n    assert(typeof width === 'number' && width >= 0);\n\n    var bytesNeeded = Math.ceil(width / 26) | 0;\n    var bitsLeft = width % 26;\n\n    // Extend the buffer with leading zeroes\n    this._expand(bytesNeeded);\n\n    if (bitsLeft > 0) {\n      bytesNeeded--;\n    }\n\n    // Handle complete words\n    for (var i = 0; i < bytesNeeded; i++) {\n      this.words[i] = ~this.words[i] & 0x3ffffff;\n    }\n\n    // Handle the residue\n    if (bitsLeft > 0) {\n      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\n    }\n\n    // And remove leading zeroes\n    return this._strip();\n  };\n\n  BN.prototype.notn = function notn (width) {\n    return this.clone().inotn(width);\n  };\n\n  // Set `bit` of `this`\n  BN.prototype.setn = function setn (bit, val) {\n    assert(typeof bit === 'number' && bit >= 0);\n\n    var off = (bit / 26) | 0;\n    var wbit = bit % 26;\n\n    this._expand(off + 1);\n\n    if (val) {\n      this.words[off] = this.words[off] | (1 << wbit);\n    } else {\n      this.words[off] = this.words[off] & ~(1 << wbit);\n    }\n\n    return this._strip();\n  };\n\n  // Add `num` to `this` in-place\n  BN.prototype.iadd = function iadd (num) {\n    var r;\n\n    // negative + positive\n    if (this.negative !== 0 && num.negative === 0) {\n      this.negative = 0;\n      r = this.isub(num);\n      this.negative ^= 1;\n      return this._normSign();\n\n    // positive + negative\n    } else if (this.negative === 0 && num.negative !== 0) {\n      num.negative = 0;\n      r = this.isub(num);\n      num.negative = 1;\n      return r._normSign();\n    }\n\n    // a.length > b.length\n    var a, b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n\n    this.length = a.length;\n    if (carry !== 0) {\n      this.words[this.length] = carry;\n      this.length++;\n    // Copy the rest of the words\n    } else if (a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    return this;\n  };\n\n  // Add `num` to `this`\n  BN.prototype.add = function add (num) {\n    var res;\n    if (num.negative !== 0 && this.negative === 0) {\n      num.negative = 0;\n      res = this.sub(num);\n      num.negative ^= 1;\n      return res;\n    } else if (num.negative === 0 && this.negative !== 0) {\n      this.negative = 0;\n      res = num.sub(this);\n      this.negative = 1;\n      return res;\n    }\n\n    if (this.length > num.length) return this.clone().iadd(num);\n\n    return num.clone().iadd(this);\n  };\n\n  // Subtract `num` from `this` in-place\n  BN.prototype.isub = function isub (num) {\n    // this - (-num) = this + num\n    if (num.negative !== 0) {\n      num.negative = 0;\n      var r = this.iadd(num);\n      num.negative = 1;\n      return r._normSign();\n\n    // -this - num = -(this + num)\n    } else if (this.negative !== 0) {\n      this.negative = 0;\n      this.iadd(num);\n      this.negative = 1;\n      return this._normSign();\n    }\n\n    // At this point both numbers are positive\n    var cmp = this.cmp(num);\n\n    // Optimization - zeroify\n    if (cmp === 0) {\n      this.negative = 0;\n      this.length = 1;\n      this.words[0] = 0;\n      return this;\n    }\n\n    // a > b\n    var a, b;\n    if (cmp > 0) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n\n    // Copy rest of the words\n    if (carry === 0 && i < a.length && a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = Math.max(this.length, i);\n\n    if (a !== this) {\n      this.negative = 1;\n    }\n\n    return this._strip();\n  };\n\n  // Subtract `num` from `this`\n  BN.prototype.sub = function sub (num) {\n    return this.clone().isub(num);\n  };\n\n  function smallMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    var len = (self.length + num.length) | 0;\n    out.length = len;\n    len = (len - 1) | 0;\n\n    // Peel one iteration (compiler can't do it, because of code complexity)\n    var a = self.words[0] | 0;\n    var b = num.words[0] | 0;\n    var r = a * b;\n\n    var lo = r & 0x3ffffff;\n    var carry = (r / 0x4000000) | 0;\n    out.words[0] = lo;\n\n    for (var k = 1; k < len; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = carry >>> 26;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = (k - j) | 0;\n        a = self.words[i] | 0;\n        b = num.words[j] | 0;\n        r = a * b + rword;\n        ncarry += (r / 0x4000000) | 0;\n        rword = r & 0x3ffffff;\n      }\n      out.words[k] = rword | 0;\n      carry = ncarry | 0;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry | 0;\n    } else {\n      out.length--;\n    }\n\n    return out._strip();\n  }\n\n  // TODO(indutny): it may be reasonable to omit it for users who don't need\n  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\n  // multiplication (like elliptic secp256k1).\n  var comb10MulTo = function comb10MulTo (self, num, out) {\n    var a = self.words;\n    var b = num.words;\n    var o = out.words;\n    var c = 0;\n    var lo;\n    var mid;\n    var hi;\n    var a0 = a[0] | 0;\n    var al0 = a0 & 0x1fff;\n    var ah0 = a0 >>> 13;\n    var a1 = a[1] | 0;\n    var al1 = a1 & 0x1fff;\n    var ah1 = a1 >>> 13;\n    var a2 = a[2] | 0;\n    var al2 = a2 & 0x1fff;\n    var ah2 = a2 >>> 13;\n    var a3 = a[3] | 0;\n    var al3 = a3 & 0x1fff;\n    var ah3 = a3 >>> 13;\n    var a4 = a[4] | 0;\n    var al4 = a4 & 0x1fff;\n    var ah4 = a4 >>> 13;\n    var a5 = a[5] | 0;\n    var al5 = a5 & 0x1fff;\n    var ah5 = a5 >>> 13;\n    var a6 = a[6] | 0;\n    var al6 = a6 & 0x1fff;\n    var ah6 = a6 >>> 13;\n    var a7 = a[7] | 0;\n    var al7 = a7 & 0x1fff;\n    var ah7 = a7 >>> 13;\n    var a8 = a[8] | 0;\n    var al8 = a8 & 0x1fff;\n    var ah8 = a8 >>> 13;\n    var a9 = a[9] | 0;\n    var al9 = a9 & 0x1fff;\n    var ah9 = a9 >>> 13;\n    var b0 = b[0] | 0;\n    var bl0 = b0 & 0x1fff;\n    var bh0 = b0 >>> 13;\n    var b1 = b[1] | 0;\n    var bl1 = b1 & 0x1fff;\n    var bh1 = b1 >>> 13;\n    var b2 = b[2] | 0;\n    var bl2 = b2 & 0x1fff;\n    var bh2 = b2 >>> 13;\n    var b3 = b[3] | 0;\n    var bl3 = b3 & 0x1fff;\n    var bh3 = b3 >>> 13;\n    var b4 = b[4] | 0;\n    var bl4 = b4 & 0x1fff;\n    var bh4 = b4 >>> 13;\n    var b5 = b[5] | 0;\n    var bl5 = b5 & 0x1fff;\n    var bh5 = b5 >>> 13;\n    var b6 = b[6] | 0;\n    var bl6 = b6 & 0x1fff;\n    var bh6 = b6 >>> 13;\n    var b7 = b[7] | 0;\n    var bl7 = b7 & 0x1fff;\n    var bh7 = b7 >>> 13;\n    var b8 = b[8] | 0;\n    var bl8 = b8 & 0x1fff;\n    var bh8 = b8 >>> 13;\n    var b9 = b[9] | 0;\n    var bl9 = b9 & 0x1fff;\n    var bh9 = b9 >>> 13;\n\n    out.negative = self.negative ^ num.negative;\n    out.length = 19;\n    /* k = 0 */\n    lo = Math.imul(al0, bl0);\n    mid = Math.imul(al0, bh0);\n    mid = (mid + Math.imul(ah0, bl0)) | 0;\n    hi = Math.imul(ah0, bh0);\n    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\n    w0 &= 0x3ffffff;\n    /* k = 1 */\n    lo = Math.imul(al1, bl0);\n    mid = Math.imul(al1, bh0);\n    mid = (mid + Math.imul(ah1, bl0)) | 0;\n    hi = Math.imul(ah1, bh0);\n    lo = (lo + Math.imul(al0, bl1)) | 0;\n    mid = (mid + Math.imul(al0, bh1)) | 0;\n    mid = (mid + Math.imul(ah0, bl1)) | 0;\n    hi = (hi + Math.imul(ah0, bh1)) | 0;\n    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\n    w1 &= 0x3ffffff;\n    /* k = 2 */\n    lo = Math.imul(al2, bl0);\n    mid = Math.imul(al2, bh0);\n    mid = (mid + Math.imul(ah2, bl0)) | 0;\n    hi = Math.imul(ah2, bh0);\n    lo = (lo + Math.imul(al1, bl1)) | 0;\n    mid = (mid + Math.imul(al1, bh1)) | 0;\n    mid = (mid + Math.imul(ah1, bl1)) | 0;\n    hi = (hi + Math.imul(ah1, bh1)) | 0;\n    lo = (lo + Math.imul(al0, bl2)) | 0;\n    mid = (mid + Math.imul(al0, bh2)) | 0;\n    mid = (mid + Math.imul(ah0, bl2)) | 0;\n    hi = (hi + Math.imul(ah0, bh2)) | 0;\n    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\n    w2 &= 0x3ffffff;\n    /* k = 3 */\n    lo = Math.imul(al3, bl0);\n    mid = Math.imul(al3, bh0);\n    mid = (mid + Math.imul(ah3, bl0)) | 0;\n    hi = Math.imul(ah3, bh0);\n    lo = (lo + Math.imul(al2, bl1)) | 0;\n    mid = (mid + Math.imul(al2, bh1)) | 0;\n    mid = (mid + Math.imul(ah2, bl1)) | 0;\n    hi = (hi + Math.imul(ah2, bh1)) | 0;\n    lo = (lo + Math.imul(al1, bl2)) | 0;\n    mid = (mid + Math.imul(al1, bh2)) | 0;\n    mid = (mid + Math.imul(ah1, bl2)) | 0;\n    hi = (hi + Math.imul(ah1, bh2)) | 0;\n    lo = (lo + Math.imul(al0, bl3)) | 0;\n    mid = (mid + Math.imul(al0, bh3)) | 0;\n    mid = (mid + Math.imul(ah0, bl3)) | 0;\n    hi = (hi + Math.imul(ah0, bh3)) | 0;\n    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\n    w3 &= 0x3ffffff;\n    /* k = 4 */\n    lo = Math.imul(al4, bl0);\n    mid = Math.imul(al4, bh0);\n    mid = (mid + Math.imul(ah4, bl0)) | 0;\n    hi = Math.imul(ah4, bh0);\n    lo = (lo + Math.imul(al3, bl1)) | 0;\n    mid = (mid + Math.imul(al3, bh1)) | 0;\n    mid = (mid + Math.imul(ah3, bl1)) | 0;\n    hi = (hi + Math.imul(ah3, bh1)) | 0;\n    lo = (lo + Math.imul(al2, bl2)) | 0;\n    mid = (mid + Math.imul(al2, bh2)) | 0;\n    mid = (mid + Math.imul(ah2, bl2)) | 0;\n    hi = (hi + Math.imul(ah2, bh2)) | 0;\n    lo = (lo + Math.imul(al1, bl3)) | 0;\n    mid = (mid + Math.imul(al1, bh3)) | 0;\n    mid = (mid + Math.imul(ah1, bl3)) | 0;\n    hi = (hi + Math.imul(ah1, bh3)) | 0;\n    lo = (lo + Math.imul(al0, bl4)) | 0;\n    mid = (mid + Math.imul(al0, bh4)) | 0;\n    mid = (mid + Math.imul(ah0, bl4)) | 0;\n    hi = (hi + Math.imul(ah0, bh4)) | 0;\n    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\n    w4 &= 0x3ffffff;\n    /* k = 5 */\n    lo = Math.imul(al5, bl0);\n    mid = Math.imul(al5, bh0);\n    mid = (mid + Math.imul(ah5, bl0)) | 0;\n    hi = Math.imul(ah5, bh0);\n    lo = (lo + Math.imul(al4, bl1)) | 0;\n    mid = (mid + Math.imul(al4, bh1)) | 0;\n    mid = (mid + Math.imul(ah4, bl1)) | 0;\n    hi = (hi + Math.imul(ah4, bh1)) | 0;\n    lo = (lo + Math.imul(al3, bl2)) | 0;\n    mid = (mid + Math.imul(al3, bh2)) | 0;\n    mid = (mid + Math.imul(ah3, bl2)) | 0;\n    hi = (hi + Math.imul(ah3, bh2)) | 0;\n    lo = (lo + Math.imul(al2, bl3)) | 0;\n    mid = (mid + Math.imul(al2, bh3)) | 0;\n    mid = (mid + Math.imul(ah2, bl3)) | 0;\n    hi = (hi + Math.imul(ah2, bh3)) | 0;\n    lo = (lo + Math.imul(al1, bl4)) | 0;\n    mid = (mid + Math.imul(al1, bh4)) | 0;\n    mid = (mid + Math.imul(ah1, bl4)) | 0;\n    hi = (hi + Math.imul(ah1, bh4)) | 0;\n    lo = (lo + Math.imul(al0, bl5)) | 0;\n    mid = (mid + Math.imul(al0, bh5)) | 0;\n    mid = (mid + Math.imul(ah0, bl5)) | 0;\n    hi = (hi + Math.imul(ah0, bh5)) | 0;\n    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\n    w5 &= 0x3ffffff;\n    /* k = 6 */\n    lo = Math.imul(al6, bl0);\n    mid = Math.imul(al6, bh0);\n    mid = (mid + Math.imul(ah6, bl0)) | 0;\n    hi = Math.imul(ah6, bh0);\n    lo = (lo + Math.imul(al5, bl1)) | 0;\n    mid = (mid + Math.imul(al5, bh1)) | 0;\n    mid = (mid + Math.imul(ah5, bl1)) | 0;\n    hi = (hi + Math.imul(ah5, bh1)) | 0;\n    lo = (lo + Math.imul(al4, bl2)) | 0;\n    mid = (mid + Math.imul(al4, bh2)) | 0;\n    mid = (mid + Math.imul(ah4, bl2)) | 0;\n    hi = (hi + Math.imul(ah4, bh2)) | 0;\n    lo = (lo + Math.imul(al3, bl3)) | 0;\n    mid = (mid + Math.imul(al3, bh3)) | 0;\n    mid = (mid + Math.imul(ah3, bl3)) | 0;\n    hi = (hi + Math.imul(ah3, bh3)) | 0;\n    lo = (lo + Math.imul(al2, bl4)) | 0;\n    mid = (mid + Math.imul(al2, bh4)) | 0;\n    mid = (mid + Math.imul(ah2, bl4)) | 0;\n    hi = (hi + Math.imul(ah2, bh4)) | 0;\n    lo = (lo + Math.imul(al1, bl5)) | 0;\n    mid = (mid + Math.imul(al1, bh5)) | 0;\n    mid = (mid + Math.imul(ah1, bl5)) | 0;\n    hi = (hi + Math.imul(ah1, bh5)) | 0;\n    lo = (lo + Math.imul(al0, bl6)) | 0;\n    mid = (mid + Math.imul(al0, bh6)) | 0;\n    mid = (mid + Math.imul(ah0, bl6)) | 0;\n    hi = (hi + Math.imul(ah0, bh6)) | 0;\n    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\n    w6 &= 0x3ffffff;\n    /* k = 7 */\n    lo = Math.imul(al7, bl0);\n    mid = Math.imul(al7, bh0);\n    mid = (mid + Math.imul(ah7, bl0)) | 0;\n    hi = Math.imul(ah7, bh0);\n    lo = (lo + Math.imul(al6, bl1)) | 0;\n    mid = (mid + Math.imul(al6, bh1)) | 0;\n    mid = (mid + Math.imul(ah6, bl1)) | 0;\n    hi = (hi + Math.imul(ah6, bh1)) | 0;\n    lo = (lo + Math.imul(al5, bl2)) | 0;\n    mid = (mid + Math.imul(al5, bh2)) | 0;\n    mid = (mid + Math.imul(ah5, bl2)) | 0;\n    hi = (hi + Math.imul(ah5, bh2)) | 0;\n    lo = (lo + Math.imul(al4, bl3)) | 0;\n    mid = (mid + Math.imul(al4, bh3)) | 0;\n    mid = (mid + Math.imul(ah4, bl3)) | 0;\n    hi = (hi + Math.imul(ah4, bh3)) | 0;\n    lo = (lo + Math.imul(al3, bl4)) | 0;\n    mid = (mid + Math.imul(al3, bh4)) | 0;\n    mid = (mid + Math.imul(ah3, bl4)) | 0;\n    hi = (hi + Math.imul(ah3, bh4)) | 0;\n    lo = (lo + Math.imul(al2, bl5)) | 0;\n    mid = (mid + Math.imul(al2, bh5)) | 0;\n    mid = (mid + Math.imul(ah2, bl5)) | 0;\n    hi = (hi + Math.imul(ah2, bh5)) | 0;\n    lo = (lo + Math.imul(al1, bl6)) | 0;\n    mid = (mid + Math.imul(al1, bh6)) | 0;\n    mid = (mid + Math.imul(ah1, bl6)) | 0;\n    hi = (hi + Math.imul(ah1, bh6)) | 0;\n    lo = (lo + Math.imul(al0, bl7)) | 0;\n    mid = (mid + Math.imul(al0, bh7)) | 0;\n    mid = (mid + Math.imul(ah0, bl7)) | 0;\n    hi = (hi + Math.imul(ah0, bh7)) | 0;\n    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\n    w7 &= 0x3ffffff;\n    /* k = 8 */\n    lo = Math.imul(al8, bl0);\n    mid = Math.imul(al8, bh0);\n    mid = (mid + Math.imul(ah8, bl0)) | 0;\n    hi = Math.imul(ah8, bh0);\n    lo = (lo + Math.imul(al7, bl1)) | 0;\n    mid = (mid + Math.imul(al7, bh1)) | 0;\n    mid = (mid + Math.imul(ah7, bl1)) | 0;\n    hi = (hi + Math.imul(ah7, bh1)) | 0;\n    lo = (lo + Math.imul(al6, bl2)) | 0;\n    mid = (mid + Math.imul(al6, bh2)) | 0;\n    mid = (mid + Math.imul(ah6, bl2)) | 0;\n    hi = (hi + Math.imul(ah6, bh2)) | 0;\n    lo = (lo + Math.imul(al5, bl3)) | 0;\n    mid = (mid + Math.imul(al5, bh3)) | 0;\n    mid = (mid + Math.imul(ah5, bl3)) | 0;\n    hi = (hi + Math.imul(ah5, bh3)) | 0;\n    lo = (lo + Math.imul(al4, bl4)) | 0;\n    mid = (mid + Math.imul(al4, bh4)) | 0;\n    mid = (mid + Math.imul(ah4, bl4)) | 0;\n    hi = (hi + Math.imul(ah4, bh4)) | 0;\n    lo = (lo + Math.imul(al3, bl5)) | 0;\n    mid = (mid + Math.imul(al3, bh5)) | 0;\n    mid = (mid + Math.imul(ah3, bl5)) | 0;\n    hi = (hi + Math.imul(ah3, bh5)) | 0;\n    lo = (lo + Math.imul(al2, bl6)) | 0;\n    mid = (mid + Math.imul(al2, bh6)) | 0;\n    mid = (mid + Math.imul(ah2, bl6)) | 0;\n    hi = (hi + Math.imul(ah2, bh6)) | 0;\n    lo = (lo + Math.imul(al1, bl7)) | 0;\n    mid = (mid + Math.imul(al1, bh7)) | 0;\n    mid = (mid + Math.imul(ah1, bl7)) | 0;\n    hi = (hi + Math.imul(ah1, bh7)) | 0;\n    lo = (lo + Math.imul(al0, bl8)) | 0;\n    mid = (mid + Math.imul(al0, bh8)) | 0;\n    mid = (mid + Math.imul(ah0, bl8)) | 0;\n    hi = (hi + Math.imul(ah0, bh8)) | 0;\n    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\n    w8 &= 0x3ffffff;\n    /* k = 9 */\n    lo = Math.imul(al9, bl0);\n    mid = Math.imul(al9, bh0);\n    mid = (mid + Math.imul(ah9, bl0)) | 0;\n    hi = Math.imul(ah9, bh0);\n    lo = (lo + Math.imul(al8, bl1)) | 0;\n    mid = (mid + Math.imul(al8, bh1)) | 0;\n    mid = (mid + Math.imul(ah8, bl1)) | 0;\n    hi = (hi + Math.imul(ah8, bh1)) | 0;\n    lo = (lo + Math.imul(al7, bl2)) | 0;\n    mid = (mid + Math.imul(al7, bh2)) | 0;\n    mid = (mid + Math.imul(ah7, bl2)) | 0;\n    hi = (hi + Math.imul(ah7, bh2)) | 0;\n    lo = (lo + Math.imul(al6, bl3)) | 0;\n    mid = (mid + Math.imul(al6, bh3)) | 0;\n    mid = (mid + Math.imul(ah6, bl3)) | 0;\n    hi = (hi + Math.imul(ah6, bh3)) | 0;\n    lo = (lo + Math.imul(al5, bl4)) | 0;\n    mid = (mid + Math.imul(al5, bh4)) | 0;\n    mid = (mid + Math.imul(ah5, bl4)) | 0;\n    hi = (hi + Math.imul(ah5, bh4)) | 0;\n    lo = (lo + Math.imul(al4, bl5)) | 0;\n    mid = (mid + Math.imul(al4, bh5)) | 0;\n    mid = (mid + Math.imul(ah4, bl5)) | 0;\n    hi = (hi + Math.imul(ah4, bh5)) | 0;\n    lo = (lo + Math.imul(al3, bl6)) | 0;\n    mid = (mid + Math.imul(al3, bh6)) | 0;\n    mid = (mid + Math.imul(ah3, bl6)) | 0;\n    hi = (hi + Math.imul(ah3, bh6)) | 0;\n    lo = (lo + Math.imul(al2, bl7)) | 0;\n    mid = (mid + Math.imul(al2, bh7)) | 0;\n    mid = (mid + Math.imul(ah2, bl7)) | 0;\n    hi = (hi + Math.imul(ah2, bh7)) | 0;\n    lo = (lo + Math.imul(al1, bl8)) | 0;\n    mid = (mid + Math.imul(al1, bh8)) | 0;\n    mid = (mid + Math.imul(ah1, bl8)) | 0;\n    hi = (hi + Math.imul(ah1, bh8)) | 0;\n    lo = (lo + Math.imul(al0, bl9)) | 0;\n    mid = (mid + Math.imul(al0, bh9)) | 0;\n    mid = (mid + Math.imul(ah0, bl9)) | 0;\n    hi = (hi + Math.imul(ah0, bh9)) | 0;\n    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\n    w9 &= 0x3ffffff;\n    /* k = 10 */\n    lo = Math.imul(al9, bl1);\n    mid = Math.imul(al9, bh1);\n    mid = (mid + Math.imul(ah9, bl1)) | 0;\n    hi = Math.imul(ah9, bh1);\n    lo = (lo + Math.imul(al8, bl2)) | 0;\n    mid = (mid + Math.imul(al8, bh2)) | 0;\n    mid = (mid + Math.imul(ah8, bl2)) | 0;\n    hi = (hi + Math.imul(ah8, bh2)) | 0;\n    lo = (lo + Math.imul(al7, bl3)) | 0;\n    mid = (mid + Math.imul(al7, bh3)) | 0;\n    mid = (mid + Math.imul(ah7, bl3)) | 0;\n    hi = (hi + Math.imul(ah7, bh3)) | 0;\n    lo = (lo + Math.imul(al6, bl4)) | 0;\n    mid = (mid + Math.imul(al6, bh4)) | 0;\n    mid = (mid + Math.imul(ah6, bl4)) | 0;\n    hi = (hi + Math.imul(ah6, bh4)) | 0;\n    lo = (lo + Math.imul(al5, bl5)) | 0;\n    mid = (mid + Math.imul(al5, bh5)) | 0;\n    mid = (mid + Math.imul(ah5, bl5)) | 0;\n    hi = (hi + Math.imul(ah5, bh5)) | 0;\n    lo = (lo + Math.imul(al4, bl6)) | 0;\n    mid = (mid + Math.imul(al4, bh6)) | 0;\n    mid = (mid + Math.imul(ah4, bl6)) | 0;\n    hi = (hi + Math.imul(ah4, bh6)) | 0;\n    lo = (lo + Math.imul(al3, bl7)) | 0;\n    mid = (mid + Math.imul(al3, bh7)) | 0;\n    mid = (mid + Math.imul(ah3, bl7)) | 0;\n    hi = (hi + Math.imul(ah3, bh7)) | 0;\n    lo = (lo + Math.imul(al2, bl8)) | 0;\n    mid = (mid + Math.imul(al2, bh8)) | 0;\n    mid = (mid + Math.imul(ah2, bl8)) | 0;\n    hi = (hi + Math.imul(ah2, bh8)) | 0;\n    lo = (lo + Math.imul(al1, bl9)) | 0;\n    mid = (mid + Math.imul(al1, bh9)) | 0;\n    mid = (mid + Math.imul(ah1, bl9)) | 0;\n    hi = (hi + Math.imul(ah1, bh9)) | 0;\n    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\n    w10 &= 0x3ffffff;\n    /* k = 11 */\n    lo = Math.imul(al9, bl2);\n    mid = Math.imul(al9, bh2);\n    mid = (mid + Math.imul(ah9, bl2)) | 0;\n    hi = Math.imul(ah9, bh2);\n    lo = (lo + Math.imul(al8, bl3)) | 0;\n    mid = (mid + Math.imul(al8, bh3)) | 0;\n    mid = (mid + Math.imul(ah8, bl3)) | 0;\n    hi = (hi + Math.imul(ah8, bh3)) | 0;\n    lo = (lo + Math.imul(al7, bl4)) | 0;\n    mid = (mid + Math.imul(al7, bh4)) | 0;\n    mid = (mid + Math.imul(ah7, bl4)) | 0;\n    hi = (hi + Math.imul(ah7, bh4)) | 0;\n    lo = (lo + Math.imul(al6, bl5)) | 0;\n    mid = (mid + Math.imul(al6, bh5)) | 0;\n    mid = (mid + Math.imul(ah6, bl5)) | 0;\n    hi = (hi + Math.imul(ah6, bh5)) | 0;\n    lo = (lo + Math.imul(al5, bl6)) | 0;\n    mid = (mid + Math.imul(al5, bh6)) | 0;\n    mid = (mid + Math.imul(ah5, bl6)) | 0;\n    hi = (hi + Math.imul(ah5, bh6)) | 0;\n    lo = (lo + Math.imul(al4, bl7)) | 0;\n    mid = (mid + Math.imul(al4, bh7)) | 0;\n    mid = (mid + Math.imul(ah4, bl7)) | 0;\n    hi = (hi + Math.imul(ah4, bh7)) | 0;\n    lo = (lo + Math.imul(al3, bl8)) | 0;\n    mid = (mid + Math.imul(al3, bh8)) | 0;\n    mid = (mid + Math.imul(ah3, bl8)) | 0;\n    hi = (hi + Math.imul(ah3, bh8)) | 0;\n    lo = (lo + Math.imul(al2, bl9)) | 0;\n    mid = (mid + Math.imul(al2, bh9)) | 0;\n    mid = (mid + Math.imul(ah2, bl9)) | 0;\n    hi = (hi + Math.imul(ah2, bh9)) | 0;\n    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\n    w11 &= 0x3ffffff;\n    /* k = 12 */\n    lo = Math.imul(al9, bl3);\n    mid = Math.imul(al9, bh3);\n    mid = (mid + Math.imul(ah9, bl3)) | 0;\n    hi = Math.imul(ah9, bh3);\n    lo = (lo + Math.imul(al8, bl4)) | 0;\n    mid = (mid + Math.imul(al8, bh4)) | 0;\n    mid = (mid + Math.imul(ah8, bl4)) | 0;\n    hi = (hi + Math.imul(ah8, bh4)) | 0;\n    lo = (lo + Math.imul(al7, bl5)) | 0;\n    mid = (mid + Math.imul(al7, bh5)) | 0;\n    mid = (mid + Math.imul(ah7, bl5)) | 0;\n    hi = (hi + Math.imul(ah7, bh5)) | 0;\n    lo = (lo + Math.imul(al6, bl6)) | 0;\n    mid = (mid + Math.imul(al6, bh6)) | 0;\n    mid = (mid + Math.imul(ah6, bl6)) | 0;\n    hi = (hi + Math.imul(ah6, bh6)) | 0;\n    lo = (lo + Math.imul(al5, bl7)) | 0;\n    mid = (mid + Math.imul(al5, bh7)) | 0;\n    mid = (mid + Math.imul(ah5, bl7)) | 0;\n    hi = (hi + Math.imul(ah5, bh7)) | 0;\n    lo = (lo + Math.imul(al4, bl8)) | 0;\n    mid = (mid + Math.imul(al4, bh8)) | 0;\n    mid = (mid + Math.imul(ah4, bl8)) | 0;\n    hi = (hi + Math.imul(ah4, bh8)) | 0;\n    lo = (lo + Math.imul(al3, bl9)) | 0;\n    mid = (mid + Math.imul(al3, bh9)) | 0;\n    mid = (mid + Math.imul(ah3, bl9)) | 0;\n    hi = (hi + Math.imul(ah3, bh9)) | 0;\n    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\n    w12 &= 0x3ffffff;\n    /* k = 13 */\n    lo = Math.imul(al9, bl4);\n    mid = Math.imul(al9, bh4);\n    mid = (mid + Math.imul(ah9, bl4)) | 0;\n    hi = Math.imul(ah9, bh4);\n    lo = (lo + Math.imul(al8, bl5)) | 0;\n    mid = (mid + Math.imul(al8, bh5)) | 0;\n    mid = (mid + Math.imul(ah8, bl5)) | 0;\n    hi = (hi + Math.imul(ah8, bh5)) | 0;\n    lo = (lo + Math.imul(al7, bl6)) | 0;\n    mid = (mid + Math.imul(al7, bh6)) | 0;\n    mid = (mid + Math.imul(ah7, bl6)) | 0;\n    hi = (hi + Math.imul(ah7, bh6)) | 0;\n    lo = (lo + Math.imul(al6, bl7)) | 0;\n    mid = (mid + Math.imul(al6, bh7)) | 0;\n    mid = (mid + Math.imul(ah6, bl7)) | 0;\n    hi = (hi + Math.imul(ah6, bh7)) | 0;\n    lo = (lo + Math.imul(al5, bl8)) | 0;\n    mid = (mid + Math.imul(al5, bh8)) | 0;\n    mid = (mid + Math.imul(ah5, bl8)) | 0;\n    hi = (hi + Math.imul(ah5, bh8)) | 0;\n    lo = (lo + Math.imul(al4, bl9)) | 0;\n    mid = (mid + Math.imul(al4, bh9)) | 0;\n    mid = (mid + Math.imul(ah4, bl9)) | 0;\n    hi = (hi + Math.imul(ah4, bh9)) | 0;\n    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\n    w13 &= 0x3ffffff;\n    /* k = 14 */\n    lo = Math.imul(al9, bl5);\n    mid = Math.imul(al9, bh5);\n    mid = (mid + Math.imul(ah9, bl5)) | 0;\n    hi = Math.imul(ah9, bh5);\n    lo = (lo + Math.imul(al8, bl6)) | 0;\n    mid = (mid + Math.imul(al8, bh6)) | 0;\n    mid = (mid + Math.imul(ah8, bl6)) | 0;\n    hi = (hi + Math.imul(ah8, bh6)) | 0;\n    lo = (lo + Math.imul(al7, bl7)) | 0;\n    mid = (mid + Math.imul(al7, bh7)) | 0;\n    mid = (mid + Math.imul(ah7, bl7)) | 0;\n    hi = (hi + Math.imul(ah7, bh7)) | 0;\n    lo = (lo + Math.imul(al6, bl8)) | 0;\n    mid = (mid + Math.imul(al6, bh8)) | 0;\n    mid = (mid + Math.imul(ah6, bl8)) | 0;\n    hi = (hi + Math.imul(ah6, bh8)) | 0;\n    lo = (lo + Math.imul(al5, bl9)) | 0;\n    mid = (mid + Math.imul(al5, bh9)) | 0;\n    mid = (mid + Math.imul(ah5, bl9)) | 0;\n    hi = (hi + Math.imul(ah5, bh9)) | 0;\n    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\n    w14 &= 0x3ffffff;\n    /* k = 15 */\n    lo = Math.imul(al9, bl6);\n    mid = Math.imul(al9, bh6);\n    mid = (mid + Math.imul(ah9, bl6)) | 0;\n    hi = Math.imul(ah9, bh6);\n    lo = (lo + Math.imul(al8, bl7)) | 0;\n    mid = (mid + Math.imul(al8, bh7)) | 0;\n    mid = (mid + Math.imul(ah8, bl7)) | 0;\n    hi = (hi + Math.imul(ah8, bh7)) | 0;\n    lo = (lo + Math.imul(al7, bl8)) | 0;\n    mid = (mid + Math.imul(al7, bh8)) | 0;\n    mid = (mid + Math.imul(ah7, bl8)) | 0;\n    hi = (hi + Math.imul(ah7, bh8)) | 0;\n    lo = (lo + Math.imul(al6, bl9)) | 0;\n    mid = (mid + Math.imul(al6, bh9)) | 0;\n    mid = (mid + Math.imul(ah6, bl9)) | 0;\n    hi = (hi + Math.imul(ah6, bh9)) | 0;\n    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\n    w15 &= 0x3ffffff;\n    /* k = 16 */\n    lo = Math.imul(al9, bl7);\n    mid = Math.imul(al9, bh7);\n    mid = (mid + Math.imul(ah9, bl7)) | 0;\n    hi = Math.imul(ah9, bh7);\n    lo = (lo + Math.imul(al8, bl8)) | 0;\n    mid = (mid + Math.imul(al8, bh8)) | 0;\n    mid = (mid + Math.imul(ah8, bl8)) | 0;\n    hi = (hi + Math.imul(ah8, bh8)) | 0;\n    lo = (lo + Math.imul(al7, bl9)) | 0;\n    mid = (mid + Math.imul(al7, bh9)) | 0;\n    mid = (mid + Math.imul(ah7, bl9)) | 0;\n    hi = (hi + Math.imul(ah7, bh9)) | 0;\n    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\n    w16 &= 0x3ffffff;\n    /* k = 17 */\n    lo = Math.imul(al9, bl8);\n    mid = Math.imul(al9, bh8);\n    mid = (mid + Math.imul(ah9, bl8)) | 0;\n    hi = Math.imul(ah9, bh8);\n    lo = (lo + Math.imul(al8, bl9)) | 0;\n    mid = (mid + Math.imul(al8, bh9)) | 0;\n    mid = (mid + Math.imul(ah8, bl9)) | 0;\n    hi = (hi + Math.imul(ah8, bh9)) | 0;\n    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\n    w17 &= 0x3ffffff;\n    /* k = 18 */\n    lo = Math.imul(al9, bl9);\n    mid = Math.imul(al9, bh9);\n    mid = (mid + Math.imul(ah9, bl9)) | 0;\n    hi = Math.imul(ah9, bh9);\n    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\n    w18 &= 0x3ffffff;\n    o[0] = w0;\n    o[1] = w1;\n    o[2] = w2;\n    o[3] = w3;\n    o[4] = w4;\n    o[5] = w5;\n    o[6] = w6;\n    o[7] = w7;\n    o[8] = w8;\n    o[9] = w9;\n    o[10] = w10;\n    o[11] = w11;\n    o[12] = w12;\n    o[13] = w13;\n    o[14] = w14;\n    o[15] = w15;\n    o[16] = w16;\n    o[17] = w17;\n    o[18] = w18;\n    if (c !== 0) {\n      o[19] = c;\n      out.length++;\n    }\n    return out;\n  };\n\n  // Polyfill comb\n  if (!Math.imul) {\n    comb10MulTo = smallMulTo;\n  }\n\n  function bigMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    out.length = self.length + num.length;\n\n    var carry = 0;\n    var hncarry = 0;\n    for (var k = 0; k < out.length - 1; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = hncarry;\n      hncarry = 0;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = k - j;\n        var a = self.words[i] | 0;\n        var b = num.words[j] | 0;\n        var r = a * b;\n\n        var lo = r & 0x3ffffff;\n        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\n        lo = (lo + rword) | 0;\n        rword = lo & 0x3ffffff;\n        ncarry = (ncarry + (lo >>> 26)) | 0;\n\n        hncarry += ncarry >>> 26;\n        ncarry &= 0x3ffffff;\n      }\n      out.words[k] = rword;\n      carry = ncarry;\n      ncarry = hncarry;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry;\n    } else {\n      out.length--;\n    }\n\n    return out._strip();\n  }\n\n  function jumboMulTo (self, num, out) {\n    // Temporary disable, see https://github.com/indutny/bn.js/issues/211\n    // var fftm = new FFTM();\n    // return fftm.mulp(self, num, out);\n    return bigMulTo(self, num, out);\n  }\n\n  BN.prototype.mulTo = function mulTo (num, out) {\n    var res;\n    var len = this.length + num.length;\n    if (this.length === 10 && num.length === 10) {\n      res = comb10MulTo(this, num, out);\n    } else if (len < 63) {\n      res = smallMulTo(this, num, out);\n    } else if (len < 1024) {\n      res = bigMulTo(this, num, out);\n    } else {\n      res = jumboMulTo(this, num, out);\n    }\n\n    return res;\n  };\n\n  // Cooley-Tukey algorithm for FFT\n  // slightly revisited to rely on looping instead of recursion\n\n  function FFTM (x, y) {\n    this.x = x;\n    this.y = y;\n  }\n\n  FFTM.prototype.makeRBT = function makeRBT (N) {\n    var t = new Array(N);\n    var l = BN.prototype._countBits(N) - 1;\n    for (var i = 0; i < N; i++) {\n      t[i] = this.revBin(i, l, N);\n    }\n\n    return t;\n  };\n\n  // Returns binary-reversed representation of `x`\n  FFTM.prototype.revBin = function revBin (x, l, N) {\n    if (x === 0 || x === N - 1) return x;\n\n    var rb = 0;\n    for (var i = 0; i < l; i++) {\n      rb |= (x & 1) << (l - i - 1);\n      x >>= 1;\n    }\n\n    return rb;\n  };\n\n  // Performs \"tweedling\" phase, therefore 'emulating'\n  // behaviour of the recursive algorithm\n  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\n    for (var i = 0; i < N; i++) {\n      rtws[i] = rws[rbt[i]];\n      itws[i] = iws[rbt[i]];\n    }\n  };\n\n  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\n    this.permute(rbt, rws, iws, rtws, itws, N);\n\n    for (var s = 1; s < N; s <<= 1) {\n      var l = s << 1;\n\n      var rtwdf = Math.cos(2 * Math.PI / l);\n      var itwdf = Math.sin(2 * Math.PI / l);\n\n      for (var p = 0; p < N; p += l) {\n        var rtwdf_ = rtwdf;\n        var itwdf_ = itwdf;\n\n        for (var j = 0; j < s; j++) {\n          var re = rtws[p + j];\n          var ie = itws[p + j];\n\n          var ro = rtws[p + j + s];\n          var io = itws[p + j + s];\n\n          var rx = rtwdf_ * ro - itwdf_ * io;\n\n          io = rtwdf_ * io + itwdf_ * ro;\n          ro = rx;\n\n          rtws[p + j] = re + ro;\n          itws[p + j] = ie + io;\n\n          rtws[p + j + s] = re - ro;\n          itws[p + j + s] = ie - io;\n\n          /* jshint maxdepth : false */\n          if (j !== l) {\n            rx = rtwdf * rtwdf_ - itwdf * itwdf_;\n\n            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\n            rtwdf_ = rx;\n          }\n        }\n      }\n    }\n  };\n\n  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\n    var N = Math.max(m, n) | 1;\n    var odd = N & 1;\n    var i = 0;\n    for (N = N / 2 | 0; N; N = N >>> 1) {\n      i++;\n    }\n\n    return 1 << i + 1 + odd;\n  };\n\n  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\n    if (N <= 1) return;\n\n    for (var i = 0; i < N / 2; i++) {\n      var t = rws[i];\n\n      rws[i] = rws[N - i - 1];\n      rws[N - i - 1] = t;\n\n      t = iws[i];\n\n      iws[i] = -iws[N - i - 1];\n      iws[N - i - 1] = -t;\n    }\n  };\n\n  FFTM.prototype.normalize13b = function normalize13b (ws, N) {\n    var carry = 0;\n    for (var i = 0; i < N / 2; i++) {\n      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\n        Math.round(ws[2 * i] / N) +\n        carry;\n\n      ws[i] = w & 0x3ffffff;\n\n      if (w < 0x4000000) {\n        carry = 0;\n      } else {\n        carry = w / 0x4000000 | 0;\n      }\n    }\n\n    return ws;\n  };\n\n  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\n    var carry = 0;\n    for (var i = 0; i < len; i++) {\n      carry = carry + (ws[i] | 0);\n\n      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\n      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\n    }\n\n    // Pad with zeroes\n    for (i = 2 * len; i < N; ++i) {\n      rws[i] = 0;\n    }\n\n    assert(carry === 0);\n    assert((carry & ~0x1fff) === 0);\n  };\n\n  FFTM.prototype.stub = function stub (N) {\n    var ph = new Array(N);\n    for (var i = 0; i < N; i++) {\n      ph[i] = 0;\n    }\n\n    return ph;\n  };\n\n  FFTM.prototype.mulp = function mulp (x, y, out) {\n    var N = 2 * this.guessLen13b(x.length, y.length);\n\n    var rbt = this.makeRBT(N);\n\n    var _ = this.stub(N);\n\n    var rws = new Array(N);\n    var rwst = new Array(N);\n    var iwst = new Array(N);\n\n    var nrws = new Array(N);\n    var nrwst = new Array(N);\n    var niwst = new Array(N);\n\n    var rmws = out.words;\n    rmws.length = N;\n\n    this.convert13b(x.words, x.length, rws, N);\n    this.convert13b(y.words, y.length, nrws, N);\n\n    this.transform(rws, _, rwst, iwst, N, rbt);\n    this.transform(nrws, _, nrwst, niwst, N, rbt);\n\n    for (var i = 0; i < N; i++) {\n      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\n      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\n      rwst[i] = rx;\n    }\n\n    this.conjugate(rwst, iwst, N);\n    this.transform(rwst, iwst, rmws, _, N, rbt);\n    this.conjugate(rmws, _, N);\n    this.normalize13b(rmws, N);\n\n    out.negative = x.negative ^ y.negative;\n    out.length = x.length + y.length;\n    return out._strip();\n  };\n\n  // Multiply `this` by `num`\n  BN.prototype.mul = function mul (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return this.mulTo(num, out);\n  };\n\n  // Multiply employing FFT\n  BN.prototype.mulf = function mulf (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return jumboMulTo(this, num, out);\n  };\n\n  // In-place Multiplication\n  BN.prototype.imul = function imul (num) {\n    return this.clone().mulTo(num, this);\n  };\n\n  BN.prototype.imuln = function imuln (num) {\n    var isNegNum = num < 0;\n    if (isNegNum) num = -num;\n\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n\n    // Carry\n    var carry = 0;\n    for (var i = 0; i < this.length; i++) {\n      var w = (this.words[i] | 0) * num;\n      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\n      carry >>= 26;\n      carry += (w / 0x4000000) | 0;\n      // NOTE: lo is 27bit maximum\n      carry += lo >>> 26;\n      this.words[i] = lo & 0x3ffffff;\n    }\n\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n\n    return isNegNum ? this.ineg() : this;\n  };\n\n  BN.prototype.muln = function muln (num) {\n    return this.clone().imuln(num);\n  };\n\n  // `this` * `this`\n  BN.prototype.sqr = function sqr () {\n    return this.mul(this);\n  };\n\n  // `this` * `this` in-place\n  BN.prototype.isqr = function isqr () {\n    return this.imul(this.clone());\n  };\n\n  // Math.pow(`this`, `num`)\n  BN.prototype.pow = function pow (num) {\n    var w = toBitArray(num);\n    if (w.length === 0) return new BN(1);\n\n    // Skip leading zeroes\n    var res = this;\n    for (var i = 0; i < w.length; i++, res = res.sqr()) {\n      if (w[i] !== 0) break;\n    }\n\n    if (++i < w.length) {\n      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\n        if (w[i] === 0) continue;\n\n        res = res.mul(q);\n      }\n    }\n\n    return res;\n  };\n\n  // Shift-left in-place\n  BN.prototype.iushln = function iushln (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\n    var i;\n\n    if (r !== 0) {\n      var carry = 0;\n\n      for (i = 0; i < this.length; i++) {\n        var newCarry = this.words[i] & carryMask;\n        var c = ((this.words[i] | 0) - newCarry) << r;\n        this.words[i] = c | carry;\n        carry = newCarry >>> (26 - r);\n      }\n\n      if (carry) {\n        this.words[i] = carry;\n        this.length++;\n      }\n    }\n\n    if (s !== 0) {\n      for (i = this.length - 1; i >= 0; i--) {\n        this.words[i + s] = this.words[i];\n      }\n\n      for (i = 0; i < s; i++) {\n        this.words[i] = 0;\n      }\n\n      this.length += s;\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.ishln = function ishln (bits) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushln(bits);\n  };\n\n  // Shift-right in-place\n  // NOTE: `hint` is a lowest bit before trailing zeroes\n  // NOTE: if `extended` is present - it will be filled with destroyed bits\n  BN.prototype.iushrn = function iushrn (bits, hint, extended) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var h;\n    if (hint) {\n      h = (hint - (hint % 26)) / 26;\n    } else {\n      h = 0;\n    }\n\n    var r = bits % 26;\n    var s = Math.min((bits - r) / 26, this.length);\n    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n    var maskedWords = extended;\n\n    h -= s;\n    h = Math.max(0, h);\n\n    // Extended mode, copy masked part\n    if (maskedWords) {\n      for (var i = 0; i < s; i++) {\n        maskedWords.words[i] = this.words[i];\n      }\n      maskedWords.length = s;\n    }\n\n    if (s === 0) {\n      // No-op, we should not move anything at all\n    } else if (this.length > s) {\n      this.length -= s;\n      for (i = 0; i < this.length; i++) {\n        this.words[i] = this.words[i + s];\n      }\n    } else {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    var carry = 0;\n    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\n      var word = this.words[i] | 0;\n      this.words[i] = (carry << (26 - r)) | (word >>> r);\n      carry = word & mask;\n    }\n\n    // Push carried bits as a mask\n    if (maskedWords && carry !== 0) {\n      maskedWords.words[maskedWords.length++] = carry;\n    }\n\n    if (this.length === 0) {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.ishrn = function ishrn (bits, hint, extended) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushrn(bits, hint, extended);\n  };\n\n  // Shift-left\n  BN.prototype.shln = function shln (bits) {\n    return this.clone().ishln(bits);\n  };\n\n  BN.prototype.ushln = function ushln (bits) {\n    return this.clone().iushln(bits);\n  };\n\n  // Shift-right\n  BN.prototype.shrn = function shrn (bits) {\n    return this.clone().ishrn(bits);\n  };\n\n  BN.prototype.ushrn = function ushrn (bits) {\n    return this.clone().iushrn(bits);\n  };\n\n  // Test if n bit is set\n  BN.prototype.testn = function testn (bit) {\n    assert(typeof bit === 'number' && bit >= 0);\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) return false;\n\n    // Check bit and return\n    var w = this.words[s];\n\n    return !!(w & q);\n  };\n\n  // Return only lowers bits of number (in-place)\n  BN.prototype.imaskn = function imaskn (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n\n    assert(this.negative === 0, 'imaskn works only with positive numbers');\n\n    if (this.length <= s) {\n      return this;\n    }\n\n    if (r !== 0) {\n      s++;\n    }\n    this.length = Math.min(s, this.length);\n\n    if (r !== 0) {\n      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n      this.words[this.length - 1] &= mask;\n    }\n\n    return this._strip();\n  };\n\n  // Return only lowers bits of number\n  BN.prototype.maskn = function maskn (bits) {\n    return this.clone().imaskn(bits);\n  };\n\n  // Add plain number `num` to `this`\n  BN.prototype.iaddn = function iaddn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.isubn(-num);\n\n    // Possible sign change\n    if (this.negative !== 0) {\n      if (this.length === 1 && (this.words[0] | 0) <= num) {\n        this.words[0] = num - (this.words[0] | 0);\n        this.negative = 0;\n        return this;\n      }\n\n      this.negative = 0;\n      this.isubn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    // Add without checks\n    return this._iaddn(num);\n  };\n\n  BN.prototype._iaddn = function _iaddn (num) {\n    this.words[0] += num;\n\n    // Carry\n    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\n      this.words[i] -= 0x4000000;\n      if (i === this.length - 1) {\n        this.words[i + 1] = 1;\n      } else {\n        this.words[i + 1]++;\n      }\n    }\n    this.length = Math.max(this.length, i + 1);\n\n    return this;\n  };\n\n  // Subtract plain number `num` from `this`\n  BN.prototype.isubn = function isubn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.iaddn(-num);\n\n    if (this.negative !== 0) {\n      this.negative = 0;\n      this.iaddn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    this.words[0] -= num;\n\n    if (this.length === 1 && this.words[0] < 0) {\n      this.words[0] = -this.words[0];\n      this.negative = 1;\n    } else {\n      // Carry\n      for (var i = 0; i < this.length && this.words[i] < 0; i++) {\n        this.words[i] += 0x4000000;\n        this.words[i + 1] -= 1;\n      }\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.addn = function addn (num) {\n    return this.clone().iaddn(num);\n  };\n\n  BN.prototype.subn = function subn (num) {\n    return this.clone().isubn(num);\n  };\n\n  BN.prototype.iabs = function iabs () {\n    this.negative = 0;\n\n    return this;\n  };\n\n  BN.prototype.abs = function abs () {\n    return this.clone().iabs();\n  };\n\n  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\n    var len = num.length + shift;\n    var i;\n\n    this._expand(len);\n\n    var w;\n    var carry = 0;\n    for (i = 0; i < num.length; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      var right = (num.words[i] | 0) * mul;\n      w -= right & 0x3ffffff;\n      carry = (w >> 26) - ((right / 0x4000000) | 0);\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n    for (; i < this.length - shift; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      carry = w >> 26;\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n\n    if (carry === 0) return this._strip();\n\n    // Subtraction overflow\n    assert(carry === -1);\n    carry = 0;\n    for (i = 0; i < this.length; i++) {\n      w = -(this.words[i] | 0) + carry;\n      carry = w >> 26;\n      this.words[i] = w & 0x3ffffff;\n    }\n    this.negative = 1;\n\n    return this._strip();\n  };\n\n  BN.prototype._wordDiv = function _wordDiv (num, mode) {\n    var shift = this.length - num.length;\n\n    var a = this.clone();\n    var b = num;\n\n    // Normalize\n    var bhi = b.words[b.length - 1] | 0;\n    var bhiBits = this._countBits(bhi);\n    shift = 26 - bhiBits;\n    if (shift !== 0) {\n      b = b.ushln(shift);\n      a.iushln(shift);\n      bhi = b.words[b.length - 1] | 0;\n    }\n\n    // Initialize quotient\n    var m = a.length - b.length;\n    var q;\n\n    if (mode !== 'mod') {\n      q = new BN(null);\n      q.length = m + 1;\n      q.words = new Array(q.length);\n      for (var i = 0; i < q.length; i++) {\n        q.words[i] = 0;\n      }\n    }\n\n    var diff = a.clone()._ishlnsubmul(b, 1, m);\n    if (diff.negative === 0) {\n      a = diff;\n      if (q) {\n        q.words[m] = 1;\n      }\n    }\n\n    for (var j = m - 1; j >= 0; j--) {\n      var qj = (a.words[b.length + j] | 0) * 0x4000000 +\n        (a.words[b.length + j - 1] | 0);\n\n      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\n      // (0x7ffffff)\n      qj = Math.min((qj / bhi) | 0, 0x3ffffff);\n\n      a._ishlnsubmul(b, qj, j);\n      while (a.negative !== 0) {\n        qj--;\n        a.negative = 0;\n        a._ishlnsubmul(b, 1, j);\n        if (!a.isZero()) {\n          a.negative ^= 1;\n        }\n      }\n      if (q) {\n        q.words[j] = qj;\n      }\n    }\n    if (q) {\n      q._strip();\n    }\n    a._strip();\n\n    // Denormalize\n    if (mode !== 'div' && shift !== 0) {\n      a.iushrn(shift);\n    }\n\n    return {\n      div: q || null,\n      mod: a\n    };\n  };\n\n  // NOTE: 1) `mode` can be set to `mod` to request mod only,\n  //       to `div` to request div only, or be absent to\n  //       request both div & mod\n  //       2) `positive` is true if unsigned mod is requested\n  BN.prototype.divmod = function divmod (num, mode, positive) {\n    assert(!num.isZero());\n\n    if (this.isZero()) {\n      return {\n        div: new BN(0),\n        mod: new BN(0)\n      };\n    }\n\n    var div, mod, res;\n    if (this.negative !== 0 && num.negative === 0) {\n      res = this.neg().divmod(num, mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.iadd(num);\n        }\n      }\n\n      return {\n        div: div,\n        mod: mod\n      };\n    }\n\n    if (this.negative === 0 && num.negative !== 0) {\n      res = this.divmod(num.neg(), mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      return {\n        div: div,\n        mod: res.mod\n      };\n    }\n\n    if ((this.negative & num.negative) !== 0) {\n      res = this.neg().divmod(num.neg(), mode);\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.isub(num);\n        }\n      }\n\n      return {\n        div: res.div,\n        mod: mod\n      };\n    }\n\n    // Both numbers are positive at this point\n\n    // Strip both numbers to approximate shift value\n    if (num.length > this.length || this.cmp(num) < 0) {\n      return {\n        div: new BN(0),\n        mod: this\n      };\n    }\n\n    // Very short reduction\n    if (num.length === 1) {\n      if (mode === 'div') {\n        return {\n          div: this.divn(num.words[0]),\n          mod: null\n        };\n      }\n\n      if (mode === 'mod') {\n        return {\n          div: null,\n          mod: new BN(this.modrn(num.words[0]))\n        };\n      }\n\n      return {\n        div: this.divn(num.words[0]),\n        mod: new BN(this.modrn(num.words[0]))\n      };\n    }\n\n    return this._wordDiv(num, mode);\n  };\n\n  // Find `this` / `num`\n  BN.prototype.div = function div (num) {\n    return this.divmod(num, 'div', false).div;\n  };\n\n  // Find `this` % `num`\n  BN.prototype.mod = function mod (num) {\n    return this.divmod(num, 'mod', false).mod;\n  };\n\n  BN.prototype.umod = function umod (num) {\n    return this.divmod(num, 'mod', true).mod;\n  };\n\n  // Find Round(`this` / `num`)\n  BN.prototype.divRound = function divRound (num) {\n    var dm = this.divmod(num);\n\n    // Fast case - exact division\n    if (dm.mod.isZero()) return dm.div;\n\n    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\n\n    var half = num.ushrn(1);\n    var r2 = num.andln(1);\n    var cmp = mod.cmp(half);\n\n    // Round down\n    if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;\n\n    // Round up\n    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\n  };\n\n  BN.prototype.modrn = function modrn (num) {\n    var isNegNum = num < 0;\n    if (isNegNum) num = -num;\n\n    assert(num <= 0x3ffffff);\n    var p = (1 << 26) % num;\n\n    var acc = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      acc = (p * acc + (this.words[i] | 0)) % num;\n    }\n\n    return isNegNum ? -acc : acc;\n  };\n\n  // WARNING: DEPRECATED\n  BN.prototype.modn = function modn (num) {\n    return this.modrn(num);\n  };\n\n  // In-place division by number\n  BN.prototype.idivn = function idivn (num) {\n    var isNegNum = num < 0;\n    if (isNegNum) num = -num;\n\n    assert(num <= 0x3ffffff);\n\n    var carry = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var w = (this.words[i] | 0) + carry * 0x4000000;\n      this.words[i] = (w / num) | 0;\n      carry = w % num;\n    }\n\n    this._strip();\n    return isNegNum ? this.ineg() : this;\n  };\n\n  BN.prototype.divn = function divn (num) {\n    return this.clone().idivn(num);\n  };\n\n  BN.prototype.egcd = function egcd (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var x = this;\n    var y = p.clone();\n\n    if (x.negative !== 0) {\n      x = x.umod(p);\n    } else {\n      x = x.clone();\n    }\n\n    // A * x + B * y = x\n    var A = new BN(1);\n    var B = new BN(0);\n\n    // C * x + D * y = y\n    var C = new BN(0);\n    var D = new BN(1);\n\n    var g = 0;\n\n    while (x.isEven() && y.isEven()) {\n      x.iushrn(1);\n      y.iushrn(1);\n      ++g;\n    }\n\n    var yp = y.clone();\n    var xp = x.clone();\n\n    while (!x.isZero()) {\n      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        x.iushrn(i);\n        while (i-- > 0) {\n          if (A.isOdd() || B.isOdd()) {\n            A.iadd(yp);\n            B.isub(xp);\n          }\n\n          A.iushrn(1);\n          B.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        y.iushrn(j);\n        while (j-- > 0) {\n          if (C.isOdd() || D.isOdd()) {\n            C.iadd(yp);\n            D.isub(xp);\n          }\n\n          C.iushrn(1);\n          D.iushrn(1);\n        }\n      }\n\n      if (x.cmp(y) >= 0) {\n        x.isub(y);\n        A.isub(C);\n        B.isub(D);\n      } else {\n        y.isub(x);\n        C.isub(A);\n        D.isub(B);\n      }\n    }\n\n    return {\n      a: C,\n      b: D,\n      gcd: y.iushln(g)\n    };\n  };\n\n  // This is reduced incarnation of the binary EEA\n  // above, designated to invert members of the\n  // _prime_ fields F(p) at a maximal speed\n  BN.prototype._invmp = function _invmp (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var a = this;\n    var b = p.clone();\n\n    if (a.negative !== 0) {\n      a = a.umod(p);\n    } else {\n      a = a.clone();\n    }\n\n    var x1 = new BN(1);\n    var x2 = new BN(0);\n\n    var delta = b.clone();\n\n    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\n      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        a.iushrn(i);\n        while (i-- > 0) {\n          if (x1.isOdd()) {\n            x1.iadd(delta);\n          }\n\n          x1.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        b.iushrn(j);\n        while (j-- > 0) {\n          if (x2.isOdd()) {\n            x2.iadd(delta);\n          }\n\n          x2.iushrn(1);\n        }\n      }\n\n      if (a.cmp(b) >= 0) {\n        a.isub(b);\n        x1.isub(x2);\n      } else {\n        b.isub(a);\n        x2.isub(x1);\n      }\n    }\n\n    var res;\n    if (a.cmpn(1) === 0) {\n      res = x1;\n    } else {\n      res = x2;\n    }\n\n    if (res.cmpn(0) < 0) {\n      res.iadd(p);\n    }\n\n    return res;\n  };\n\n  BN.prototype.gcd = function gcd (num) {\n    if (this.isZero()) return num.abs();\n    if (num.isZero()) return this.abs();\n\n    var a = this.clone();\n    var b = num.clone();\n    a.negative = 0;\n    b.negative = 0;\n\n    // Remove common factor of two\n    for (var shift = 0; a.isEven() && b.isEven(); shift++) {\n      a.iushrn(1);\n      b.iushrn(1);\n    }\n\n    do {\n      while (a.isEven()) {\n        a.iushrn(1);\n      }\n      while (b.isEven()) {\n        b.iushrn(1);\n      }\n\n      var r = a.cmp(b);\n      if (r < 0) {\n        // Swap `a` and `b` to make `a` always bigger than `b`\n        var t = a;\n        a = b;\n        b = t;\n      } else if (r === 0 || b.cmpn(1) === 0) {\n        break;\n      }\n\n      a.isub(b);\n    } while (true);\n\n    return b.iushln(shift);\n  };\n\n  // Invert number in the field F(num)\n  BN.prototype.invm = function invm (num) {\n    return this.egcd(num).a.umod(num);\n  };\n\n  BN.prototype.isEven = function isEven () {\n    return (this.words[0] & 1) === 0;\n  };\n\n  BN.prototype.isOdd = function isOdd () {\n    return (this.words[0] & 1) === 1;\n  };\n\n  // And first word and num\n  BN.prototype.andln = function andln (num) {\n    return this.words[0] & num;\n  };\n\n  // Increment at the bit position in-line\n  BN.prototype.bincn = function bincn (bit) {\n    assert(typeof bit === 'number');\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) {\n      this._expand(s + 1);\n      this.words[s] |= q;\n      return this;\n    }\n\n    // Add bit and propagate, if needed\n    var carry = q;\n    for (var i = s; carry !== 0 && i < this.length; i++) {\n      var w = this.words[i] | 0;\n      w += carry;\n      carry = w >>> 26;\n      w &= 0x3ffffff;\n      this.words[i] = w;\n    }\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n    return this;\n  };\n\n  BN.prototype.isZero = function isZero () {\n    return this.length === 1 && this.words[0] === 0;\n  };\n\n  BN.prototype.cmpn = function cmpn (num) {\n    var negative = num < 0;\n\n    if (this.negative !== 0 && !negative) return -1;\n    if (this.negative === 0 && negative) return 1;\n\n    this._strip();\n\n    var res;\n    if (this.length > 1) {\n      res = 1;\n    } else {\n      if (negative) {\n        num = -num;\n      }\n\n      assert(num <= 0x3ffffff, 'Number is too big');\n\n      var w = this.words[0] | 0;\n      res = w === num ? 0 : w < num ? -1 : 1;\n    }\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Compare two numbers and return:\n  // 1 - if `this` > `num`\n  // 0 - if `this` == `num`\n  // -1 - if `this` < `num`\n  BN.prototype.cmp = function cmp (num) {\n    if (this.negative !== 0 && num.negative === 0) return -1;\n    if (this.negative === 0 && num.negative !== 0) return 1;\n\n    var res = this.ucmp(num);\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Unsigned comparison\n  BN.prototype.ucmp = function ucmp (num) {\n    // At this point both numbers have the same sign\n    if (this.length > num.length) return 1;\n    if (this.length < num.length) return -1;\n\n    var res = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var a = this.words[i] | 0;\n      var b = num.words[i] | 0;\n\n      if (a === b) continue;\n      if (a < b) {\n        res = -1;\n      } else if (a > b) {\n        res = 1;\n      }\n      break;\n    }\n    return res;\n  };\n\n  BN.prototype.gtn = function gtn (num) {\n    return this.cmpn(num) === 1;\n  };\n\n  BN.prototype.gt = function gt (num) {\n    return this.cmp(num) === 1;\n  };\n\n  BN.prototype.gten = function gten (num) {\n    return this.cmpn(num) >= 0;\n  };\n\n  BN.prototype.gte = function gte (num) {\n    return this.cmp(num) >= 0;\n  };\n\n  BN.prototype.ltn = function ltn (num) {\n    return this.cmpn(num) === -1;\n  };\n\n  BN.prototype.lt = function lt (num) {\n    return this.cmp(num) === -1;\n  };\n\n  BN.prototype.lten = function lten (num) {\n    return this.cmpn(num) <= 0;\n  };\n\n  BN.prototype.lte = function lte (num) {\n    return this.cmp(num) <= 0;\n  };\n\n  BN.prototype.eqn = function eqn (num) {\n    return this.cmpn(num) === 0;\n  };\n\n  BN.prototype.eq = function eq (num) {\n    return this.cmp(num) === 0;\n  };\n\n  //\n  // A reduce context, could be using montgomery or something better, depending\n  // on the `m` itself.\n  //\n  BN.red = function red (num) {\n    return new Red(num);\n  };\n\n  BN.prototype.toRed = function toRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    assert(this.negative === 0, 'red works only with positives');\n    return ctx.convertTo(this)._forceRed(ctx);\n  };\n\n  BN.prototype.fromRed = function fromRed () {\n    assert(this.red, 'fromRed works only with numbers in reduction context');\n    return this.red.convertFrom(this);\n  };\n\n  BN.prototype._forceRed = function _forceRed (ctx) {\n    this.red = ctx;\n    return this;\n  };\n\n  BN.prototype.forceRed = function forceRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    return this._forceRed(ctx);\n  };\n\n  BN.prototype.redAdd = function redAdd (num) {\n    assert(this.red, 'redAdd works only with red numbers');\n    return this.red.add(this, num);\n  };\n\n  BN.prototype.redIAdd = function redIAdd (num) {\n    assert(this.red, 'redIAdd works only with red numbers');\n    return this.red.iadd(this, num);\n  };\n\n  BN.prototype.redSub = function redSub (num) {\n    assert(this.red, 'redSub works only with red numbers');\n    return this.red.sub(this, num);\n  };\n\n  BN.prototype.redISub = function redISub (num) {\n    assert(this.red, 'redISub works only with red numbers');\n    return this.red.isub(this, num);\n  };\n\n  BN.prototype.redShl = function redShl (num) {\n    assert(this.red, 'redShl works only with red numbers');\n    return this.red.shl(this, num);\n  };\n\n  BN.prototype.redMul = function redMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.mul(this, num);\n  };\n\n  BN.prototype.redIMul = function redIMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.imul(this, num);\n  };\n\n  BN.prototype.redSqr = function redSqr () {\n    assert(this.red, 'redSqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqr(this);\n  };\n\n  BN.prototype.redISqr = function redISqr () {\n    assert(this.red, 'redISqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.isqr(this);\n  };\n\n  // Square root over p\n  BN.prototype.redSqrt = function redSqrt () {\n    assert(this.red, 'redSqrt works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqrt(this);\n  };\n\n  BN.prototype.redInvm = function redInvm () {\n    assert(this.red, 'redInvm works only with red numbers');\n    this.red._verify1(this);\n    return this.red.invm(this);\n  };\n\n  // Return negative clone of `this` % `red modulo`\n  BN.prototype.redNeg = function redNeg () {\n    assert(this.red, 'redNeg works only with red numbers');\n    this.red._verify1(this);\n    return this.red.neg(this);\n  };\n\n  BN.prototype.redPow = function redPow (num) {\n    assert(this.red && !num.red, 'redPow(normalNum)');\n    this.red._verify1(this);\n    return this.red.pow(this, num);\n  };\n\n  // Prime numbers with efficient reduction\n  var primes = {\n    k256: null,\n    p224: null,\n    p192: null,\n    p25519: null\n  };\n\n  // Pseudo-Mersenne prime\n  function MPrime (name, p) {\n    // P = 2 ^ N - K\n    this.name = name;\n    this.p = new BN(p, 16);\n    this.n = this.p.bitLength();\n    this.k = new BN(1).iushln(this.n).isub(this.p);\n\n    this.tmp = this._tmp();\n  }\n\n  MPrime.prototype._tmp = function _tmp () {\n    var tmp = new BN(null);\n    tmp.words = new Array(Math.ceil(this.n / 13));\n    return tmp;\n  };\n\n  MPrime.prototype.ireduce = function ireduce (num) {\n    // Assumes that `num` is less than `P^2`\n    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\n    var r = num;\n    var rlen;\n\n    do {\n      this.split(r, this.tmp);\n      r = this.imulK(r);\n      r = r.iadd(this.tmp);\n      rlen = r.bitLength();\n    } while (rlen > this.n);\n\n    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\n    if (cmp === 0) {\n      r.words[0] = 0;\n      r.length = 1;\n    } else if (cmp > 0) {\n      r.isub(this.p);\n    } else {\n      if (r.strip !== undefined) {\n        // r is a BN v4 instance\n        r.strip();\n      } else {\n        // r is a BN v5 instance\n        r._strip();\n      }\n    }\n\n    return r;\n  };\n\n  MPrime.prototype.split = function split (input, out) {\n    input.iushrn(this.n, 0, out);\n  };\n\n  MPrime.prototype.imulK = function imulK (num) {\n    return num.imul(this.k);\n  };\n\n  function K256 () {\n    MPrime.call(\n      this,\n      'k256',\n      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\n  }\n  inherits(K256, MPrime);\n\n  K256.prototype.split = function split (input, output) {\n    // 256 = 9 * 26 + 22\n    var mask = 0x3fffff;\n\n    var outLen = Math.min(input.length, 9);\n    for (var i = 0; i < outLen; i++) {\n      output.words[i] = input.words[i];\n    }\n    output.length = outLen;\n\n    if (input.length <= 9) {\n      input.words[0] = 0;\n      input.length = 1;\n      return;\n    }\n\n    // Shift by 9 limbs\n    var prev = input.words[9];\n    output.words[output.length++] = prev & mask;\n\n    for (i = 10; i < input.length; i++) {\n      var next = input.words[i] | 0;\n      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\n      prev = next;\n    }\n    prev >>>= 22;\n    input.words[i - 10] = prev;\n    if (prev === 0 && input.length > 10) {\n      input.length -= 10;\n    } else {\n      input.length -= 9;\n    }\n  };\n\n  K256.prototype.imulK = function imulK (num) {\n    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\n    num.words[num.length] = 0;\n    num.words[num.length + 1] = 0;\n    num.length += 2;\n\n    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\n    var lo = 0;\n    for (var i = 0; i < num.length; i++) {\n      var w = num.words[i] | 0;\n      lo += w * 0x3d1;\n      num.words[i] = lo & 0x3ffffff;\n      lo = w * 0x40 + ((lo / 0x4000000) | 0);\n    }\n\n    // Fast length reduction\n    if (num.words[num.length - 1] === 0) {\n      num.length--;\n      if (num.words[num.length - 1] === 0) {\n        num.length--;\n      }\n    }\n    return num;\n  };\n\n  function P224 () {\n    MPrime.call(\n      this,\n      'p224',\n      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n  }\n  inherits(P224, MPrime);\n\n  function P192 () {\n    MPrime.call(\n      this,\n      'p192',\n      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n  }\n  inherits(P192, MPrime);\n\n  function P25519 () {\n    // 2 ^ 255 - 19\n    MPrime.call(\n      this,\n      '25519',\n      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\n  }\n  inherits(P25519, MPrime);\n\n  P25519.prototype.imulK = function imulK (num) {\n    // K = 0x13\n    var carry = 0;\n    for (var i = 0; i < num.length; i++) {\n      var hi = (num.words[i] | 0) * 0x13 + carry;\n      var lo = hi & 0x3ffffff;\n      hi >>>= 26;\n\n      num.words[i] = lo;\n      carry = hi;\n    }\n    if (carry !== 0) {\n      num.words[num.length++] = carry;\n    }\n    return num;\n  };\n\n  // Exported mostly for testing purposes, use plain name instead\n  BN._prime = function prime (name) {\n    // Cached version of prime\n    if (primes[name]) return primes[name];\n\n    var prime;\n    if (name === 'k256') {\n      prime = new K256();\n    } else if (name === 'p224') {\n      prime = new P224();\n    } else if (name === 'p192') {\n      prime = new P192();\n    } else if (name === 'p25519') {\n      prime = new P25519();\n    } else {\n      throw new Error('Unknown prime ' + name);\n    }\n    primes[name] = prime;\n\n    return prime;\n  };\n\n  //\n  // Base reduction engine\n  //\n  function Red (m) {\n    if (typeof m === 'string') {\n      var prime = BN._prime(m);\n      this.m = prime.p;\n      this.prime = prime;\n    } else {\n      assert(m.gtn(1), 'modulus must be greater than 1');\n      this.m = m;\n      this.prime = null;\n    }\n  }\n\n  Red.prototype._verify1 = function _verify1 (a) {\n    assert(a.negative === 0, 'red works only with positives');\n    assert(a.red, 'red works only with red numbers');\n  };\n\n  Red.prototype._verify2 = function _verify2 (a, b) {\n    assert((a.negative | b.negative) === 0, 'red works only with positives');\n    assert(a.red && a.red === b.red,\n      'red works only with red numbers');\n  };\n\n  Red.prototype.imod = function imod (a) {\n    if (this.prime) return this.prime.ireduce(a)._forceRed(this);\n\n    move(a, a.umod(this.m)._forceRed(this));\n    return a;\n  };\n\n  Red.prototype.neg = function neg (a) {\n    if (a.isZero()) {\n      return a.clone();\n    }\n\n    return this.m.sub(a)._forceRed(this);\n  };\n\n  Red.prototype.add = function add (a, b) {\n    this._verify2(a, b);\n\n    var res = a.add(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.iadd = function iadd (a, b) {\n    this._verify2(a, b);\n\n    var res = a.iadd(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.sub = function sub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.sub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.isub = function isub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.isub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.shl = function shl (a, num) {\n    this._verify1(a);\n    return this.imod(a.ushln(num));\n  };\n\n  Red.prototype.imul = function imul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.imul(b));\n  };\n\n  Red.prototype.mul = function mul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.mul(b));\n  };\n\n  Red.prototype.isqr = function isqr (a) {\n    return this.imul(a, a.clone());\n  };\n\n  Red.prototype.sqr = function sqr (a) {\n    return this.mul(a, a);\n  };\n\n  Red.prototype.sqrt = function sqrt (a) {\n    if (a.isZero()) return a.clone();\n\n    var mod3 = this.m.andln(3);\n    assert(mod3 % 2 === 1);\n\n    // Fast case\n    if (mod3 === 3) {\n      var pow = this.m.add(new BN(1)).iushrn(2);\n      return this.pow(a, pow);\n    }\n\n    // Tonelli-Shanks algorithm (Totally unoptimized and slow)\n    //\n    // Find Q and S, that Q * 2 ^ S = (P - 1)\n    var q = this.m.subn(1);\n    var s = 0;\n    while (!q.isZero() && q.andln(1) === 0) {\n      s++;\n      q.iushrn(1);\n    }\n    assert(!q.isZero());\n\n    var one = new BN(1).toRed(this);\n    var nOne = one.redNeg();\n\n    // Find quadratic non-residue\n    // NOTE: Max is such because of generalized Riemann hypothesis.\n    var lpow = this.m.subn(1).iushrn(1);\n    var z = this.m.bitLength();\n    z = new BN(2 * z * z).toRed(this);\n\n    while (this.pow(z, lpow).cmp(nOne) !== 0) {\n      z.redIAdd(nOne);\n    }\n\n    var c = this.pow(z, q);\n    var r = this.pow(a, q.addn(1).iushrn(1));\n    var t = this.pow(a, q);\n    var m = s;\n    while (t.cmp(one) !== 0) {\n      var tmp = t;\n      for (var i = 0; tmp.cmp(one) !== 0; i++) {\n        tmp = tmp.redSqr();\n      }\n      assert(i < m);\n      var b = this.pow(c, new BN(1).iushln(m - i - 1));\n\n      r = r.redMul(b);\n      c = b.redSqr();\n      t = t.redMul(c);\n      m = i;\n    }\n\n    return r;\n  };\n\n  Red.prototype.invm = function invm (a) {\n    var inv = a._invmp(this.m);\n    if (inv.negative !== 0) {\n      inv.negative = 0;\n      return this.imod(inv).redNeg();\n    } else {\n      return this.imod(inv);\n    }\n  };\n\n  Red.prototype.pow = function pow (a, num) {\n    if (num.isZero()) return new BN(1).toRed(this);\n    if (num.cmpn(1) === 0) return a.clone();\n\n    var windowSize = 4;\n    var wnd = new Array(1 << windowSize);\n    wnd[0] = new BN(1).toRed(this);\n    wnd[1] = a;\n    for (var i = 2; i < wnd.length; i++) {\n      wnd[i] = this.mul(wnd[i - 1], a);\n    }\n\n    var res = wnd[0];\n    var current = 0;\n    var currentLen = 0;\n    var start = num.bitLength() % 26;\n    if (start === 0) {\n      start = 26;\n    }\n\n    for (i = num.length - 1; i >= 0; i--) {\n      var word = num.words[i];\n      for (var j = start - 1; j >= 0; j--) {\n        var bit = (word >> j) & 1;\n        if (res !== wnd[0]) {\n          res = this.sqr(res);\n        }\n\n        if (bit === 0 && current === 0) {\n          currentLen = 0;\n          continue;\n        }\n\n        current <<= 1;\n        current |= bit;\n        currentLen++;\n        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\n\n        res = this.mul(res, wnd[current]);\n        currentLen = 0;\n        current = 0;\n      }\n      start = 26;\n    }\n\n    return res;\n  };\n\n  Red.prototype.convertTo = function convertTo (num) {\n    var r = num.umod(this.m);\n\n    return r === num ? r.clone() : r;\n  };\n\n  Red.prototype.convertFrom = function convertFrom (num) {\n    var res = num.clone();\n    res.red = null;\n    return res;\n  };\n\n  //\n  // Montgomery method engine\n  //\n\n  BN.mont = function mont (num) {\n    return new Mont(num);\n  };\n\n  function Mont (m) {\n    Red.call(this, m);\n\n    this.shift = this.m.bitLength();\n    if (this.shift % 26 !== 0) {\n      this.shift += 26 - (this.shift % 26);\n    }\n\n    this.r = new BN(1).iushln(this.shift);\n    this.r2 = this.imod(this.r.sqr());\n    this.rinv = this.r._invmp(this.m);\n\n    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\n    this.minv = this.minv.umod(this.r);\n    this.minv = this.r.sub(this.minv);\n  }\n  inherits(Mont, Red);\n\n  Mont.prototype.convertTo = function convertTo (num) {\n    return this.imod(num.ushln(this.shift));\n  };\n\n  Mont.prototype.convertFrom = function convertFrom (num) {\n    var r = this.imod(num.mul(this.rinv));\n    r.red = null;\n    return r;\n  };\n\n  Mont.prototype.imul = function imul (a, b) {\n    if (a.isZero() || b.isZero()) {\n      a.words[0] = 0;\n      a.length = 1;\n      return a;\n    }\n\n    var t = a.imul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.mul = function mul (a, b) {\n    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\n\n    var t = a.mul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.invm = function invm (a) {\n    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\n    var res = this.imod(a._invmp(this.m).mul(this.r2));\n    return res._forceRed(this);\n  };\n})(typeof module === 'undefined' || module, this);\n","\"use strict\";\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isZeroAddress = exports.zeroAddress = exports.importPublic = exports.privateToAddress = exports.privateToPublic = exports.publicToAddress = exports.pubToAddress = exports.isValidPublic = exports.isValidPrivate = exports.generateAddress2 = exports.generateAddress = exports.isValidChecksumAddress = exports.toChecksumAddress = exports.isValidAddress = exports.Account = void 0;\nvar assert_1 = __importDefault(require(\"assert\"));\nvar externals_1 = require(\"./externals\");\nvar secp256k1_1 = require(\"ethereum-cryptography/secp256k1\");\nvar internal_1 = require(\"./internal\");\nvar constants_1 = require(\"./constants\");\nvar bytes_1 = require(\"./bytes\");\nvar hash_1 = require(\"./hash\");\nvar helpers_1 = require(\"./helpers\");\nvar types_1 = require(\"./types\");\nvar Account = /** @class */ (function () {\n    /**\n     * This constructor assigns and validates the values.\n     * Use the static factory methods to assist in creating an Account from varying data types.\n     */\n    function Account(nonce, balance, stateRoot, codeHash) {\n        if (nonce === void 0) { nonce = new externals_1.BN(0); }\n        if (balance === void 0) { balance = new externals_1.BN(0); }\n        if (stateRoot === void 0) { stateRoot = constants_1.KECCAK256_RLP; }\n        if (codeHash === void 0) { codeHash = constants_1.KECCAK256_NULL; }\n        this.nonce = nonce;\n        this.balance = balance;\n        this.stateRoot = stateRoot;\n        this.codeHash = codeHash;\n        this._validate();\n    }\n    Account.fromAccountData = function (accountData) {\n        var nonce = accountData.nonce, balance = accountData.balance, stateRoot = accountData.stateRoot, codeHash = accountData.codeHash;\n        return new Account(nonce ? new externals_1.BN((0, bytes_1.toBuffer)(nonce)) : undefined, balance ? new externals_1.BN((0, bytes_1.toBuffer)(balance)) : undefined, stateRoot ? (0, bytes_1.toBuffer)(stateRoot) : undefined, codeHash ? (0, bytes_1.toBuffer)(codeHash) : undefined);\n    };\n    Account.fromRlpSerializedAccount = function (serialized) {\n        var values = externals_1.rlp.decode(serialized);\n        if (!Array.isArray(values)) {\n            throw new Error('Invalid serialized account input. Must be array');\n        }\n        return this.fromValuesArray(values);\n    };\n    Account.fromValuesArray = function (values) {\n        var _a = __read(values, 4), nonce = _a[0], balance = _a[1], stateRoot = _a[2], codeHash = _a[3];\n        return new Account(new externals_1.BN(nonce), new externals_1.BN(balance), stateRoot, codeHash);\n    };\n    Account.prototype._validate = function () {\n        if (this.nonce.lt(new externals_1.BN(0))) {\n            throw new Error('nonce must be greater than zero');\n        }\n        if (this.balance.lt(new externals_1.BN(0))) {\n            throw new Error('balance must be greater than zero');\n        }\n        if (this.stateRoot.length !== 32) {\n            throw new Error('stateRoot must have a length of 32');\n        }\n        if (this.codeHash.length !== 32) {\n            throw new Error('codeHash must have a length of 32');\n        }\n    };\n    /**\n     * Returns a Buffer Array of the raw Buffers for the account, in order.\n     */\n    Account.prototype.raw = function () {\n        return [\n            (0, types_1.bnToUnpaddedBuffer)(this.nonce),\n            (0, types_1.bnToUnpaddedBuffer)(this.balance),\n            this.stateRoot,\n            this.codeHash,\n        ];\n    };\n    /**\n     * Returns the RLP serialization of the account as a `Buffer`.\n     */\n    Account.prototype.serialize = function () {\n        return externals_1.rlp.encode(this.raw());\n    };\n    /**\n     * Returns a `Boolean` determining if the account is a contract.\n     */\n    Account.prototype.isContract = function () {\n        return !this.codeHash.equals(constants_1.KECCAK256_NULL);\n    };\n    /**\n     * Returns a `Boolean` determining if the account is empty complying to the definition of\n     * account emptiness in [EIP-161](https://eips.ethereum.org/EIPS/eip-161):\n     * \"An account is considered empty when it has no code and zero nonce and zero balance.\"\n     */\n    Account.prototype.isEmpty = function () {\n        return this.balance.isZero() && this.nonce.isZero() && this.codeHash.equals(constants_1.KECCAK256_NULL);\n    };\n    return Account;\n}());\nexports.Account = Account;\n/**\n * Checks if the address is a valid. Accepts checksummed addresses too.\n */\nvar isValidAddress = function (hexAddress) {\n    try {\n        (0, helpers_1.assertIsString)(hexAddress);\n    }\n    catch (e) {\n        return false;\n    }\n    return /^0x[0-9a-fA-F]{40}$/.test(hexAddress);\n};\nexports.isValidAddress = isValidAddress;\n/**\n * Returns a checksummed address.\n *\n * If an eip1191ChainId is provided, the chainId will be included in the checksum calculation. This\n * has the effect of checksummed addresses for one chain having invalid checksums for others.\n * For more details see [EIP-1191](https://eips.ethereum.org/EIPS/eip-1191).\n *\n * WARNING: Checksums with and without the chainId will differ and the EIP-1191 checksum is not\n * backwards compatible to the original widely adopted checksum format standard introduced in\n * [EIP-55](https://eips.ethereum.org/EIPS/eip-55), so this will break in existing applications.\n * Usage of this EIP is therefore discouraged unless you have a very targeted use case.\n */\nvar toChecksumAddress = function (hexAddress, eip1191ChainId) {\n    (0, helpers_1.assertIsHexString)(hexAddress);\n    var address = (0, internal_1.stripHexPrefix)(hexAddress).toLowerCase();\n    var prefix = '';\n    if (eip1191ChainId) {\n        var chainId = (0, types_1.toType)(eip1191ChainId, types_1.TypeOutput.BN);\n        prefix = chainId.toString() + '0x';\n    }\n    var hash = (0, hash_1.keccakFromString)(prefix + address).toString('hex');\n    var ret = '0x';\n    for (var i = 0; i < address.length; i++) {\n        if (parseInt(hash[i], 16) >= 8) {\n            ret += address[i].toUpperCase();\n        }\n        else {\n            ret += address[i];\n        }\n    }\n    return ret;\n};\nexports.toChecksumAddress = toChecksumAddress;\n/**\n * Checks if the address is a valid checksummed address.\n *\n * See toChecksumAddress' documentation for details about the eip1191ChainId parameter.\n */\nvar isValidChecksumAddress = function (hexAddress, eip1191ChainId) {\n    return (0, exports.isValidAddress)(hexAddress) && (0, exports.toChecksumAddress)(hexAddress, eip1191ChainId) === hexAddress;\n};\nexports.isValidChecksumAddress = isValidChecksumAddress;\n/**\n * Generates an address of a newly created contract.\n * @param from The address which is creating this new address\n * @param nonce The nonce of the from account\n */\nvar generateAddress = function (from, nonce) {\n    (0, helpers_1.assertIsBuffer)(from);\n    (0, helpers_1.assertIsBuffer)(nonce);\n    var nonceBN = new externals_1.BN(nonce);\n    if (nonceBN.isZero()) {\n        // in RLP we want to encode null in the case of zero nonce\n        // read the RLP documentation for an answer if you dare\n        return (0, hash_1.rlphash)([from, null]).slice(-20);\n    }\n    // Only take the lower 160bits of the hash\n    return (0, hash_1.rlphash)([from, Buffer.from(nonceBN.toArray())]).slice(-20);\n};\nexports.generateAddress = generateAddress;\n/**\n * Generates an address for a contract created using CREATE2.\n * @param from The address which is creating this new address\n * @param salt A salt\n * @param initCode The init code of the contract being created\n */\nvar generateAddress2 = function (from, salt, initCode) {\n    (0, helpers_1.assertIsBuffer)(from);\n    (0, helpers_1.assertIsBuffer)(salt);\n    (0, helpers_1.assertIsBuffer)(initCode);\n    (0, assert_1.default)(from.length === 20);\n    (0, assert_1.default)(salt.length === 32);\n    var address = (0, hash_1.keccak256)(Buffer.concat([Buffer.from('ff', 'hex'), from, salt, (0, hash_1.keccak256)(initCode)]));\n    return address.slice(-20);\n};\nexports.generateAddress2 = generateAddress2;\n/**\n * Checks if the private key satisfies the rules of the curve secp256k1.\n */\nvar isValidPrivate = function (privateKey) {\n    return (0, secp256k1_1.privateKeyVerify)(privateKey);\n};\nexports.isValidPrivate = isValidPrivate;\n/**\n * Checks if the public key satisfies the rules of the curve secp256k1\n * and the requirements of Ethereum.\n * @param publicKey The two points of an uncompressed key, unless sanitize is enabled\n * @param sanitize Accept public keys in other formats\n */\nvar isValidPublic = function (publicKey, sanitize) {\n    if (sanitize === void 0) { sanitize = false; }\n    (0, helpers_1.assertIsBuffer)(publicKey);\n    if (publicKey.length === 64) {\n        // Convert to SEC1 for secp256k1\n        return (0, secp256k1_1.publicKeyVerify)(Buffer.concat([Buffer.from([4]), publicKey]));\n    }\n    if (!sanitize) {\n        return false;\n    }\n    return (0, secp256k1_1.publicKeyVerify)(publicKey);\n};\nexports.isValidPublic = isValidPublic;\n/**\n * Returns the ethereum address of a given public key.\n * Accepts \"Ethereum public keys\" and SEC1 encoded keys.\n * @param pubKey The two points of an uncompressed key, unless sanitize is enabled\n * @param sanitize Accept public keys in other formats\n */\nvar pubToAddress = function (pubKey, sanitize) {\n    if (sanitize === void 0) { sanitize = false; }\n    (0, helpers_1.assertIsBuffer)(pubKey);\n    if (sanitize && pubKey.length !== 64) {\n        pubKey = Buffer.from((0, secp256k1_1.publicKeyConvert)(pubKey, false).slice(1));\n    }\n    (0, assert_1.default)(pubKey.length === 64);\n    // Only take the lower 160bits of the hash\n    return (0, hash_1.keccak)(pubKey).slice(-20);\n};\nexports.pubToAddress = pubToAddress;\nexports.publicToAddress = exports.pubToAddress;\n/**\n * Returns the ethereum public key of a given private key.\n * @param privateKey A private key must be 256 bits wide\n */\nvar privateToPublic = function (privateKey) {\n    (0, helpers_1.assertIsBuffer)(privateKey);\n    // skip the type flag and use the X, Y points\n    return Buffer.from((0, secp256k1_1.publicKeyCreate)(privateKey, false)).slice(1);\n};\nexports.privateToPublic = privateToPublic;\n/**\n * Returns the ethereum address of a given private key.\n * @param privateKey A private key must be 256 bits wide\n */\nvar privateToAddress = function (privateKey) {\n    return (0, exports.publicToAddress)((0, exports.privateToPublic)(privateKey));\n};\nexports.privateToAddress = privateToAddress;\n/**\n * Converts a public key to the Ethereum format.\n */\nvar importPublic = function (publicKey) {\n    (0, helpers_1.assertIsBuffer)(publicKey);\n    if (publicKey.length !== 64) {\n        publicKey = Buffer.from((0, secp256k1_1.publicKeyConvert)(publicKey, false).slice(1));\n    }\n    return publicKey;\n};\nexports.importPublic = importPublic;\n/**\n * Returns the zero address.\n */\nvar zeroAddress = function () {\n    var addressLength = 20;\n    var addr = (0, bytes_1.zeros)(addressLength);\n    return (0, bytes_1.bufferToHex)(addr);\n};\nexports.zeroAddress = zeroAddress;\n/**\n * Checks if a given address is the zero address.\n */\nvar isZeroAddress = function (hexAddress) {\n    try {\n        (0, helpers_1.assertIsString)(hexAddress);\n    }\n    catch (e) {\n        return false;\n    }\n    var zeroAddr = (0, exports.zeroAddress)();\n    return zeroAddr === hexAddress;\n};\nexports.isZeroAddress = isZeroAddress;\n//# sourceMappingURL=account.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hashPersonalMessage = exports.isValidSignature = exports.fromRpcSig = exports.toCompactSig = exports.toRpcSig = exports.ecrecover = exports.ecsign = void 0;\nvar secp256k1_1 = require(\"ethereum-cryptography/secp256k1\");\nvar externals_1 = require(\"./externals\");\nvar bytes_1 = require(\"./bytes\");\nvar hash_1 = require(\"./hash\");\nvar helpers_1 = require(\"./helpers\");\nvar types_1 = require(\"./types\");\nfunction ecsign(msgHash, privateKey, chainId) {\n    var _a = (0, secp256k1_1.ecdsaSign)(msgHash, privateKey), signature = _a.signature, recovery = _a.recid;\n    var r = Buffer.from(signature.slice(0, 32));\n    var s = Buffer.from(signature.slice(32, 64));\n    if (!chainId || typeof chainId === 'number') {\n        // return legacy type ECDSASignature (deprecated in favor of ECDSASignatureBuffer to handle large chainIds)\n        if (chainId && !Number.isSafeInteger(chainId)) {\n            throw new Error('The provided number is greater than MAX_SAFE_INTEGER (please use an alternative input type)');\n        }\n        var v_1 = chainId ? recovery + (chainId * 2 + 35) : recovery + 27;\n        return { r: r, s: s, v: v_1 };\n    }\n    var chainIdBN = (0, types_1.toType)(chainId, types_1.TypeOutput.BN);\n    var v = chainIdBN.muln(2).addn(35).addn(recovery).toArrayLike(Buffer);\n    return { r: r, s: s, v: v };\n}\nexports.ecsign = ecsign;\nfunction calculateSigRecovery(v, chainId) {\n    var vBN = (0, types_1.toType)(v, types_1.TypeOutput.BN);\n    if (!chainId) {\n        return vBN.subn(27);\n    }\n    var chainIdBN = (0, types_1.toType)(chainId, types_1.TypeOutput.BN);\n    return vBN.sub(chainIdBN.muln(2).addn(35));\n}\nfunction isValidSigRecovery(recovery) {\n    var rec = new externals_1.BN(recovery);\n    return rec.eqn(0) || rec.eqn(1);\n}\n/**\n * ECDSA public key recovery from signature.\n * @returns Recovered public key\n */\nvar ecrecover = function (msgHash, v, r, s, chainId) {\n    var signature = Buffer.concat([(0, bytes_1.setLengthLeft)(r, 32), (0, bytes_1.setLengthLeft)(s, 32)], 64);\n    var recovery = calculateSigRecovery(v, chainId);\n    if (!isValidSigRecovery(recovery)) {\n        throw new Error('Invalid signature v value');\n    }\n    var senderPubKey = (0, secp256k1_1.ecdsaRecover)(signature, recovery.toNumber(), msgHash);\n    return Buffer.from((0, secp256k1_1.publicKeyConvert)(senderPubKey, false).slice(1));\n};\nexports.ecrecover = ecrecover;\n/**\n * Convert signature parameters into the format of `eth_sign` RPC method.\n * @returns Signature\n */\nvar toRpcSig = function (v, r, s, chainId) {\n    var recovery = calculateSigRecovery(v, chainId);\n    if (!isValidSigRecovery(recovery)) {\n        throw new Error('Invalid signature v value');\n    }\n    // geth (and the RPC eth_sign method) uses the 65 byte format used by Bitcoin\n    return (0, bytes_1.bufferToHex)(Buffer.concat([(0, bytes_1.setLengthLeft)(r, 32), (0, bytes_1.setLengthLeft)(s, 32), (0, bytes_1.toBuffer)(v)]));\n};\nexports.toRpcSig = toRpcSig;\n/**\n * Convert signature parameters into the format of Compact Signature Representation (EIP-2098).\n * @returns Signature\n */\nvar toCompactSig = function (v, r, s, chainId) {\n    var recovery = calculateSigRecovery(v, chainId);\n    if (!isValidSigRecovery(recovery)) {\n        throw new Error('Invalid signature v value');\n    }\n    var vn = (0, types_1.toType)(v, types_1.TypeOutput.Number);\n    var ss = s;\n    if ((vn > 28 && vn % 2 === 1) || vn === 1 || vn === 28) {\n        ss = Buffer.from(s);\n        ss[0] |= 0x80;\n    }\n    return (0, bytes_1.bufferToHex)(Buffer.concat([(0, bytes_1.setLengthLeft)(r, 32), (0, bytes_1.setLengthLeft)(ss, 32)]));\n};\nexports.toCompactSig = toCompactSig;\n/**\n * Convert signature format of the `eth_sign` RPC method to signature parameters\n * NOTE: all because of a bug in geth: https://github.com/ethereum/go-ethereum/issues/2053\n */\nvar fromRpcSig = function (sig) {\n    var buf = (0, bytes_1.toBuffer)(sig);\n    var r;\n    var s;\n    var v;\n    if (buf.length >= 65) {\n        r = buf.slice(0, 32);\n        s = buf.slice(32, 64);\n        v = (0, bytes_1.bufferToInt)(buf.slice(64));\n    }\n    else if (buf.length === 64) {\n        // Compact Signature Representation (https://eips.ethereum.org/EIPS/eip-2098)\n        r = buf.slice(0, 32);\n        s = buf.slice(32, 64);\n        v = (0, bytes_1.bufferToInt)(buf.slice(32, 33)) >> 7;\n        s[0] &= 0x7f;\n    }\n    else {\n        throw new Error('Invalid signature length');\n    }\n    // support both versions of `eth_sign` responses\n    if (v < 27) {\n        v += 27;\n    }\n    return {\n        v: v,\n        r: r,\n        s: s,\n    };\n};\nexports.fromRpcSig = fromRpcSig;\n/**\n * Validate a ECDSA signature.\n * @param homesteadOrLater Indicates whether this is being used on either the homestead hardfork or a later one\n */\nvar isValidSignature = function (v, r, s, homesteadOrLater, chainId) {\n    if (homesteadOrLater === void 0) { homesteadOrLater = true; }\n    var SECP256K1_N_DIV_2 = new externals_1.BN('7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0', 16);\n    var SECP256K1_N = new externals_1.BN('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 16);\n    if (r.length !== 32 || s.length !== 32) {\n        return false;\n    }\n    if (!isValidSigRecovery(calculateSigRecovery(v, chainId))) {\n        return false;\n    }\n    var rBN = new externals_1.BN(r);\n    var sBN = new externals_1.BN(s);\n    if (rBN.isZero() || rBN.gt(SECP256K1_N) || sBN.isZero() || sBN.gt(SECP256K1_N)) {\n        return false;\n    }\n    if (homesteadOrLater && sBN.cmp(SECP256K1_N_DIV_2) === 1) {\n        return false;\n    }\n    return true;\n};\nexports.isValidSignature = isValidSignature;\n/**\n * Returns the keccak-256 hash of `message`, prefixed with the header used by the `eth_sign` RPC call.\n * The output of this function can be fed into `ecsign` to produce the same signature as the `eth_sign`\n * call for a given `message`, or fed to `ecrecover` along with a signature to recover the public key\n * used to produce the signature.\n */\nvar hashPersonalMessage = function (message) {\n    (0, helpers_1.assertIsBuffer)(message);\n    var prefix = Buffer.from(\"\\u0019Ethereum Signed Message:\\n\".concat(message.length), 'utf-8');\n    return (0, hash_1.keccak)(Buffer.concat([prefix, message]));\n};\nexports.hashPersonalMessage = hashPersonalMessage;\n//# sourceMappingURL=signature.js.map","\"use strict\";\n/*\nThe MIT License\n\nCopyright (c) 2016 Nick Dodson. nickdodson.com\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isHexString = exports.getKeys = exports.fromAscii = exports.fromUtf8 = exports.toAscii = exports.arrayContainsArray = exports.getBinarySize = exports.padToEven = exports.stripHexPrefix = exports.isHexPrefixed = void 0;\n/**\n * Returns a `Boolean` on whether or not the a `String` starts with '0x'\n * @param str the string input value\n * @return a boolean if it is or is not hex prefixed\n * @throws if the str input is not a string\n */\nfunction isHexPrefixed(str) {\n    if (typeof str !== 'string') {\n        throw new Error(\"[isHexPrefixed] input must be type 'string', received type \".concat(typeof str));\n    }\n    return str[0] === '0' && str[1] === 'x';\n}\nexports.isHexPrefixed = isHexPrefixed;\n/**\n * Removes '0x' from a given `String` if present\n * @param str the string value\n * @returns the string without 0x prefix\n */\nvar stripHexPrefix = function (str) {\n    if (typeof str !== 'string')\n        throw new Error(\"[stripHexPrefix] input must be type 'string', received \".concat(typeof str));\n    return isHexPrefixed(str) ? str.slice(2) : str;\n};\nexports.stripHexPrefix = stripHexPrefix;\n/**\n * Pads a `String` to have an even length\n * @param value\n * @return output\n */\nfunction padToEven(value) {\n    var a = value;\n    if (typeof a !== 'string') {\n        throw new Error(\"[padToEven] value must be type 'string', received \".concat(typeof a));\n    }\n    if (a.length % 2)\n        a = \"0\".concat(a);\n    return a;\n}\nexports.padToEven = padToEven;\n/**\n * Get the binary size of a string\n * @param str\n * @returns the number of bytes contained within the string\n */\nfunction getBinarySize(str) {\n    if (typeof str !== 'string') {\n        throw new Error(\"[getBinarySize] method requires input type 'string', recieved \".concat(typeof str));\n    }\n    return Buffer.byteLength(str, 'utf8');\n}\nexports.getBinarySize = getBinarySize;\n/**\n * Returns TRUE if the first specified array contains all elements\n * from the second one. FALSE otherwise.\n *\n * @param superset\n * @param subset\n *\n */\nfunction arrayContainsArray(superset, subset, some) {\n    if (Array.isArray(superset) !== true) {\n        throw new Error(\"[arrayContainsArray] method requires input 'superset' to be an array, got type '\".concat(typeof superset, \"'\"));\n    }\n    if (Array.isArray(subset) !== true) {\n        throw new Error(\"[arrayContainsArray] method requires input 'subset' to be an array, got type '\".concat(typeof subset, \"'\"));\n    }\n    return subset[some ? 'some' : 'every'](function (value) { return superset.indexOf(value) >= 0; });\n}\nexports.arrayContainsArray = arrayContainsArray;\n/**\n * Should be called to get ascii from its hex representation\n *\n * @param string in hex\n * @returns ascii string representation of hex value\n */\nfunction toAscii(hex) {\n    var str = '';\n    var i = 0;\n    var l = hex.length;\n    if (hex.substring(0, 2) === '0x')\n        i = 2;\n    for (; i < l; i += 2) {\n        var code = parseInt(hex.substr(i, 2), 16);\n        str += String.fromCharCode(code);\n    }\n    return str;\n}\nexports.toAscii = toAscii;\n/**\n * Should be called to get hex representation (prefixed by 0x) of utf8 string\n *\n * @param string\n * @param optional padding\n * @returns hex representation of input string\n */\nfunction fromUtf8(stringValue) {\n    var str = Buffer.from(stringValue, 'utf8');\n    return \"0x\".concat(padToEven(str.toString('hex')).replace(/^0+|0+$/g, ''));\n}\nexports.fromUtf8 = fromUtf8;\n/**\n * Should be called to get hex representation (prefixed by 0x) of ascii string\n *\n * @param  string\n * @param  optional padding\n * @returns  hex representation of input string\n */\nfunction fromAscii(stringValue) {\n    var hex = '';\n    for (var i = 0; i < stringValue.length; i++) {\n        var code = stringValue.charCodeAt(i);\n        var n = code.toString(16);\n        hex += n.length < 2 ? \"0\".concat(n) : n;\n    }\n    return \"0x\".concat(hex);\n}\nexports.fromAscii = fromAscii;\n/**\n * Returns the keys from an array of objects.\n * @example\n * ```js\n * getKeys([{a: '1', b: '2'}, {a: '3', b: '4'}], 'a') => ['1', '3']\n *````\n * @param  params\n * @param  key\n * @param  allowEmpty\n * @returns output just a simple array of output keys\n */\nfunction getKeys(params, key, allowEmpty) {\n    if (!Array.isArray(params)) {\n        throw new Error(\"[getKeys] method expects input 'params' to be an array, got \".concat(typeof params));\n    }\n    if (typeof key !== 'string') {\n        throw new Error(\"[getKeys] method expects input 'key' to be type 'string', got \".concat(typeof params));\n    }\n    var result = [];\n    for (var i = 0; i < params.length; i++) {\n        var value = params[i][key];\n        if (allowEmpty && !value) {\n            value = '';\n        }\n        else if (typeof value !== 'string') {\n            throw new Error(\"invalid abi - expected type 'string', received \".concat(typeof value));\n        }\n        result.push(value);\n    }\n    return result;\n}\nexports.getKeys = getKeys;\n/**\n * Is the string a hex string.\n *\n * @param  value\n * @param  length\n * @returns  output the string is a hex string\n */\nfunction isHexString(value, length) {\n    if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/))\n        return false;\n    if (length && value.length !== 2 + 2 * length)\n        return false;\n    return true;\n}\nexports.isHexString = isHexString;\n//# sourceMappingURL=internal.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar hash_utils_1 = require(\"./hash-utils\");\nvar createKeccakHash = require(\"keccak\");\nexports.keccak224 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak224\");\n});\nexports.keccak256 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak256\");\n});\nexports.keccak384 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak384\");\n});\nexports.keccak512 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak512\");\n});\n//# sourceMappingURL=keccak.js.map","\"use strict\";\n/**\n * Re-exports commonly used modules:\n * * Exports [`BN`](https://github.com/indutny/bn.js), [`rlp`](https://github.com/ethereumjs/rlp).\n * @packageDocumentation\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.rlp = exports.BN = void 0;\nvar bn_js_1 = __importDefault(require(\"bn.js\"));\nexports.BN = bn_js_1.default;\nvar rlp = __importStar(require(\"rlp\"));\nexports.rlp = rlp;\n//# sourceMappingURL=externals.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Address = void 0;\nvar assert_1 = __importDefault(require(\"assert\"));\nvar externals_1 = require(\"./externals\");\nvar bytes_1 = require(\"./bytes\");\nvar account_1 = require(\"./account\");\nvar Address = /** @class */ (function () {\n    function Address(buf) {\n        (0, assert_1.default)(buf.length === 20, 'Invalid address length');\n        this.buf = buf;\n    }\n    /**\n     * Returns the zero address.\n     */\n    Address.zero = function () {\n        return new Address((0, bytes_1.zeros)(20));\n    };\n    /**\n     * Returns an Address object from a hex-encoded string.\n     * @param str - Hex-encoded address\n     */\n    Address.fromString = function (str) {\n        (0, assert_1.default)((0, account_1.isValidAddress)(str), 'Invalid address');\n        return new Address((0, bytes_1.toBuffer)(str));\n    };\n    /**\n     * Returns an address for a given public key.\n     * @param pubKey The two points of an uncompressed key\n     */\n    Address.fromPublicKey = function (pubKey) {\n        (0, assert_1.default)(Buffer.isBuffer(pubKey), 'Public key should be Buffer');\n        var buf = (0, account_1.pubToAddress)(pubKey);\n        return new Address(buf);\n    };\n    /**\n     * Returns an address for a given private key.\n     * @param privateKey A private key must be 256 bits wide\n     */\n    Address.fromPrivateKey = function (privateKey) {\n        (0, assert_1.default)(Buffer.isBuffer(privateKey), 'Private key should be Buffer');\n        var buf = (0, account_1.privateToAddress)(privateKey);\n        return new Address(buf);\n    };\n    /**\n     * Generates an address for a newly created contract.\n     * @param from The address which is creating this new address\n     * @param nonce The nonce of the from account\n     */\n    Address.generate = function (from, nonce) {\n        (0, assert_1.default)(externals_1.BN.isBN(nonce));\n        return new Address((0, account_1.generateAddress)(from.buf, nonce.toArrayLike(Buffer)));\n    };\n    /**\n     * Generates an address for a contract created using CREATE2.\n     * @param from The address which is creating this new address\n     * @param salt A salt\n     * @param initCode The init code of the contract being created\n     */\n    Address.generate2 = function (from, salt, initCode) {\n        (0, assert_1.default)(Buffer.isBuffer(salt));\n        (0, assert_1.default)(Buffer.isBuffer(initCode));\n        return new Address((0, account_1.generateAddress2)(from.buf, salt, initCode));\n    };\n    /**\n     * Is address equal to another.\n     */\n    Address.prototype.equals = function (address) {\n        return this.buf.equals(address.buf);\n    };\n    /**\n     * Is address zero.\n     */\n    Address.prototype.isZero = function () {\n        return this.equals(Address.zero());\n    };\n    /**\n     * True if address is in the address range defined\n     * by EIP-1352\n     */\n    Address.prototype.isPrecompileOrSystemAddress = function () {\n        var addressBN = new externals_1.BN(this.buf);\n        var rangeMin = new externals_1.BN(0);\n        var rangeMax = new externals_1.BN('ffff', 'hex');\n        return addressBN.gte(rangeMin) && addressBN.lte(rangeMax);\n    };\n    /**\n     * Returns hex encoding of address.\n     */\n    Address.prototype.toString = function () {\n        return '0x' + this.buf.toString('hex');\n    };\n    /**\n     * Returns Buffer representation of address.\n     */\n    Address.prototype.toBuffer = function () {\n        return Buffer.from(this.buf);\n    };\n    return Address;\n}());\nexports.Address = Address;\n//# sourceMappingURL=address.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.defineProperties = void 0;\nvar assert_1 = __importDefault(require(\"assert\"));\nvar internal_1 = require(\"./internal\");\nvar externals_1 = require(\"./externals\");\nvar bytes_1 = require(\"./bytes\");\n/**\n * Defines properties on a `Object`. It make the assumption that underlying data is binary.\n * @param self the `Object` to define properties on\n * @param fields an array fields to define. Fields can contain:\n * * `name` - the name of the properties\n * * `length` - the number of bytes the field can have\n * * `allowLess` - if the field can be less than the length\n * * `allowEmpty`\n * @param data data to be validated against the definitions\n * @deprecated\n */\nvar defineProperties = function (self, fields, data) {\n    self.raw = [];\n    self._fields = [];\n    // attach the `toJSON`\n    self.toJSON = function (label) {\n        if (label === void 0) { label = false; }\n        if (label) {\n            var obj_1 = {};\n            self._fields.forEach(function (field) {\n                obj_1[field] = \"0x\".concat(self[field].toString('hex'));\n            });\n            return obj_1;\n        }\n        return (0, bytes_1.baToJSON)(self.raw);\n    };\n    self.serialize = function serialize() {\n        return externals_1.rlp.encode(self.raw);\n    };\n    fields.forEach(function (field, i) {\n        self._fields.push(field.name);\n        function getter() {\n            return self.raw[i];\n        }\n        function setter(v) {\n            v = (0, bytes_1.toBuffer)(v);\n            if (v.toString('hex') === '00' && !field.allowZero) {\n                v = Buffer.allocUnsafe(0);\n            }\n            if (field.allowLess && field.length) {\n                v = (0, bytes_1.unpadBuffer)(v);\n                (0, assert_1.default)(field.length >= v.length, \"The field \".concat(field.name, \" must not have more \").concat(field.length, \" bytes\"));\n            }\n            else if (!(field.allowZero && v.length === 0) && field.length) {\n                (0, assert_1.default)(field.length === v.length, \"The field \".concat(field.name, \" must have byte length of \").concat(field.length));\n            }\n            self.raw[i] = v;\n        }\n        Object.defineProperty(self, field.name, {\n            enumerable: true,\n            configurable: true,\n            get: getter,\n            set: setter,\n        });\n        if (field.default) {\n            self[field.name] = field.default;\n        }\n        // attach alias\n        if (field.alias) {\n            Object.defineProperty(self, field.alias, {\n                enumerable: false,\n                configurable: true,\n                set: setter,\n                get: getter,\n            });\n        }\n    });\n    // if the constuctor is passed data\n    if (data) {\n        if (typeof data === 'string') {\n            data = Buffer.from((0, internal_1.stripHexPrefix)(data), 'hex');\n        }\n        if (Buffer.isBuffer(data)) {\n            data = externals_1.rlp.decode(data);\n        }\n        if (Array.isArray(data)) {\n            if (data.length > self._fields.length) {\n                throw new Error('wrong number of fields in data');\n            }\n            // make sure all the items are buffers\n            data.forEach(function (d, i) {\n                self[self._fields[i]] = (0, bytes_1.toBuffer)(d);\n            });\n        }\n        else if (typeof data === 'object') {\n            var keys_1 = Object.keys(data);\n            fields.forEach(function (field) {\n                if (keys_1.indexOf(field.name) !== -1)\n                    self[field.name] = data[field.name];\n                if (keys_1.indexOf(field.alias) !== -1)\n                    self[field.alias] = data[field.alias];\n            });\n        }\n        else {\n            throw new Error('invalid data');\n        }\n    }\n};\nexports.defineProperties = defineProperties;\n//# sourceMappingURL=object.js.map"],"sourceRoot":""}