{"version":3,"file":"neox-tpke.mjs","sources":["../../../node_modules/.pnpm/minimalistic-assert@1.0.1/node_modules/minimalistic-assert/index.js","../../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/utils.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/common.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/common.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/1.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/256.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/224.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/512.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/384.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/ripemd.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/hmac.js","../../../node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash.js","../../../node_modules/.pnpm/aes-js@3.1.2/node_modules/aes-js/index.js","../../../node_modules/.pnpm/@noble+hashes@1.7.1/node_modules/@noble/hashes/esm/_assert.js","../../../node_modules/.pnpm/@noble+hashes@1.7.1/node_modules/@noble/hashes/esm/crypto.js","../../../node_modules/.pnpm/@noble+hashes@1.7.1/node_modules/@noble/hashes/esm/utils.js","../../../node_modules/.pnpm/@noble+hashes@1.7.1/node_modules/@noble/hashes/esm/_md.js","../../../node_modules/.pnpm/@noble+hashes@1.7.1/node_modules/@noble/hashes/esm/sha256.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/utils.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/modular.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/hash-to-curve.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/curve.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/weierstrass.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/bls.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/abstract/tower.js","../../../node_modules/.pnpm/@noble+curves@1.8.1/node_modules/@noble/curves/esm/bls12-381.js","../../../node_modules/.pnpm/bigint-crypto-utils@3.3.0/node_modules/bigint-crypto-utils/dist/index.browser.esm.js","../../../node_modules/.pnpm/viem@2.23.9_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.2/node_modules/viem/_esm/utils/data/concat.js","../src/index.ts"],"sourcesContent":["module.exports = assert;\n\nfunction assert(val, msg) {\n  if (!val)\n    throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n  if (l != r)\n    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));\n};\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (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}\n","'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nexports.inherits = inherits;\n\nfunction isSurrogatePair(msg, i) {\n  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {\n    return false;\n  }\n  if (i < 0 || i + 1 >= msg.length) {\n    return false;\n  }\n  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;\n}\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg === 'string') {\n    if (!enc) {\n      // Inspired by stringToUtf8ByteArray() in closure-library by Google\n      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143\n      // Apache License 2.0\n      // https://github.com/google/closure-library/blob/master/LICENSE\n      var p = 0;\n      for (var i = 0; i < msg.length; i++) {\n        var c = msg.charCodeAt(i);\n        if (c < 128) {\n          res[p++] = c;\n        } else if (c < 2048) {\n          res[p++] = (c >> 6) | 192;\n          res[p++] = (c & 63) | 128;\n        } else if (isSurrogatePair(msg, i)) {\n          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);\n          res[p++] = (c >> 18) | 240;\n          res[p++] = ((c >> 12) & 63) | 128;\n          res[p++] = ((c >> 6) & 63) | 128;\n          res[p++] = (c & 63) | 128;\n        } else {\n          res[p++] = (c >> 12) | 224;\n          res[p++] = ((c >> 6) & 63) | 128;\n          res[p++] = (c & 63) | 128;\n        }\n      }\n    } else if (enc === 'hex') {\n      msg = msg.replace(/[^a-z0-9]+/ig, '');\n      if (msg.length % 2 !== 0)\n        msg = '0' + msg;\n      for (i = 0; i < msg.length; i += 2)\n        res.push(parseInt(msg[i] + msg[i + 1], 16));\n    }\n  } else {\n    for (i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n  }\n  return res;\n}\nexports.toArray = toArray;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nexports.toHex = toHex;\n\nfunction htonl(w) {\n  var res = (w >>> 24) |\n            ((w >>> 8) & 0xff00) |\n            ((w << 8) & 0xff0000) |\n            ((w & 0xff) << 24);\n  return res >>> 0;\n}\nexports.htonl = htonl;\n\nfunction toHex32(msg, endian) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++) {\n    var w = msg[i];\n    if (endian === 'little')\n      w = htonl(w);\n    res += zero8(w.toString(16));\n  }\n  return res;\n}\nexports.toHex32 = toHex32;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nexports.zero2 = zero2;\n\nfunction zero8(word) {\n  if (word.length === 7)\n    return '0' + word;\n  else if (word.length === 6)\n    return '00' + word;\n  else if (word.length === 5)\n    return '000' + word;\n  else if (word.length === 4)\n    return '0000' + word;\n  else if (word.length === 3)\n    return '00000' + word;\n  else if (word.length === 2)\n    return '000000' + word;\n  else if (word.length === 1)\n    return '0000000' + word;\n  else\n    return word;\n}\nexports.zero8 = zero8;\n\nfunction join32(msg, start, end, endian) {\n  var len = end - start;\n  assert(len % 4 === 0);\n  var res = new Array(len / 4);\n  for (var i = 0, k = start; i < res.length; i++, k += 4) {\n    var w;\n    if (endian === 'big')\n      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];\n    else\n      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];\n    res[i] = w >>> 0;\n  }\n  return res;\n}\nexports.join32 = join32;\n\nfunction split32(msg, endian) {\n  var res = new Array(msg.length * 4);\n  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {\n    var m = msg[i];\n    if (endian === 'big') {\n      res[k] = m >>> 24;\n      res[k + 1] = (m >>> 16) & 0xff;\n      res[k + 2] = (m >>> 8) & 0xff;\n      res[k + 3] = m & 0xff;\n    } else {\n      res[k + 3] = m >>> 24;\n      res[k + 2] = (m >>> 16) & 0xff;\n      res[k + 1] = (m >>> 8) & 0xff;\n      res[k] = m & 0xff;\n    }\n  }\n  return res;\n}\nexports.split32 = split32;\n\nfunction rotr32(w, b) {\n  return (w >>> b) | (w << (32 - b));\n}\nexports.rotr32 = rotr32;\n\nfunction rotl32(w, b) {\n  return (w << b) | (w >>> (32 - b));\n}\nexports.rotl32 = rotl32;\n\nfunction sum32(a, b) {\n  return (a + b) >>> 0;\n}\nexports.sum32 = sum32;\n\nfunction sum32_3(a, b, c) {\n  return (a + b + c) >>> 0;\n}\nexports.sum32_3 = sum32_3;\n\nfunction sum32_4(a, b, c, d) {\n  return (a + b + c + d) >>> 0;\n}\nexports.sum32_4 = sum32_4;\n\nfunction sum32_5(a, b, c, d, e) {\n  return (a + b + c + d + e) >>> 0;\n}\nexports.sum32_5 = sum32_5;\n\nfunction sum64(buf, pos, ah, al) {\n  var bh = buf[pos];\n  var bl = buf[pos + 1];\n\n  var lo = (al + bl) >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  buf[pos] = hi >>> 0;\n  buf[pos + 1] = lo;\n}\nexports.sum64 = sum64;\n\nfunction sum64_hi(ah, al, bh, bl) {\n  var lo = (al + bl) >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  return hi >>> 0;\n}\nexports.sum64_hi = sum64_hi;\n\nfunction sum64_lo(ah, al, bh, bl) {\n  var lo = al + bl;\n  return lo >>> 0;\n}\nexports.sum64_lo = sum64_lo;\n\nfunction sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {\n  var carry = 0;\n  var lo = al;\n  lo = (lo + bl) >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = (lo + cl) >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = (lo + dl) >>> 0;\n  carry += lo < dl ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + carry;\n  return hi >>> 0;\n}\nexports.sum64_4_hi = sum64_4_hi;\n\nfunction sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {\n  var lo = al + bl + cl + dl;\n  return lo >>> 0;\n}\nexports.sum64_4_lo = sum64_4_lo;\n\nfunction sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var carry = 0;\n  var lo = al;\n  lo = (lo + bl) >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = (lo + cl) >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = (lo + dl) >>> 0;\n  carry += lo < dl ? 1 : 0;\n  lo = (lo + el) >>> 0;\n  carry += lo < el ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + eh + carry;\n  return hi >>> 0;\n}\nexports.sum64_5_hi = sum64_5_hi;\n\nfunction sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var lo = al + bl + cl + dl + el;\n\n  return lo >>> 0;\n}\nexports.sum64_5_lo = sum64_5_lo;\n\nfunction rotr64_hi(ah, al, num) {\n  var r = (al << (32 - num)) | (ah >>> num);\n  return r >>> 0;\n}\nexports.rotr64_hi = rotr64_hi;\n\nfunction rotr64_lo(ah, al, num) {\n  var r = (ah << (32 - num)) | (al >>> num);\n  return r >>> 0;\n}\nexports.rotr64_lo = rotr64_lo;\n\nfunction shr64_hi(ah, al, num) {\n  return ah >>> num;\n}\nexports.shr64_hi = shr64_hi;\n\nfunction shr64_lo(ah, al, num) {\n  var r = (ah << (32 - num)) | (al >>> num);\n  return r >>> 0;\n}\nexports.shr64_lo = shr64_lo;\n","'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction BlockHash() {\n  this.pending = null;\n  this.pendingTotal = 0;\n  this.blockSize = this.constructor.blockSize;\n  this.outSize = this.constructor.outSize;\n  this.hmacStrength = this.constructor.hmacStrength;\n  this.padLength = this.constructor.padLength / 8;\n  this.endian = 'big';\n\n  this._delta8 = this.blockSize / 8;\n  this._delta32 = this.blockSize / 32;\n}\nexports.BlockHash = BlockHash;\n\nBlockHash.prototype.update = function update(msg, enc) {\n  // Convert message to array, pad it, and join into 32bit blocks\n  msg = utils.toArray(msg, enc);\n  if (!this.pending)\n    this.pending = msg;\n  else\n    this.pending = this.pending.concat(msg);\n  this.pendingTotal += msg.length;\n\n  // Enough data, try updating\n  if (this.pending.length >= this._delta8) {\n    msg = this.pending;\n\n    // Process pending data in blocks\n    var r = msg.length % this._delta8;\n    this.pending = msg.slice(msg.length - r, msg.length);\n    if (this.pending.length === 0)\n      this.pending = null;\n\n    msg = utils.join32(msg, 0, msg.length - r, this.endian);\n    for (var i = 0; i < msg.length; i += this._delta32)\n      this._update(msg, i, i + this._delta32);\n  }\n\n  return this;\n};\n\nBlockHash.prototype.digest = function digest(enc) {\n  this.update(this._pad());\n  assert(this.pending === null);\n\n  return this._digest(enc);\n};\n\nBlockHash.prototype._pad = function pad() {\n  var len = this.pendingTotal;\n  var bytes = this._delta8;\n  var k = bytes - ((len + this.padLength) % bytes);\n  var res = new Array(k + this.padLength);\n  res[0] = 0x80;\n  for (var i = 1; i < k; i++)\n    res[i] = 0;\n\n  // Append length\n  len <<= 3;\n  if (this.endian === 'big') {\n    for (var t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = len & 0xff;\n  } else {\n    res[i++] = len & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n\n    for (t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n  }\n\n  return res;\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar rotr32 = utils.rotr32;\n\nfunction ft_1(s, x, y, z) {\n  if (s === 0)\n    return ch32(x, y, z);\n  if (s === 1 || s === 3)\n    return p32(x, y, z);\n  if (s === 2)\n    return maj32(x, y, z);\n}\nexports.ft_1 = ft_1;\n\nfunction ch32(x, y, z) {\n  return (x & y) ^ ((~x) & z);\n}\nexports.ch32 = ch32;\n\nfunction maj32(x, y, z) {\n  return (x & y) ^ (x & z) ^ (y & z);\n}\nexports.maj32 = maj32;\n\nfunction p32(x, y, z) {\n  return x ^ y ^ z;\n}\nexports.p32 = p32;\n\nfunction s0_256(x) {\n  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);\n}\nexports.s0_256 = s0_256;\n\nfunction s1_256(x) {\n  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);\n}\nexports.s1_256 = s1_256;\n\nfunction g0_256(x) {\n  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);\n}\nexports.g0_256 = g0_256;\n\nfunction g1_256(x) {\n  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);\n}\nexports.g1_256 = g1_256;\n","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_5 = utils.sum32_5;\nvar ft_1 = shaCommon.ft_1;\nvar BlockHash = common.BlockHash;\n\nvar sha1_K = [\n  0x5A827999, 0x6ED9EBA1,\n  0x8F1BBCDC, 0xCA62C1D6\n];\n\nfunction SHA1() {\n  if (!(this instanceof SHA1))\n    return new SHA1();\n\n  BlockHash.call(this);\n  this.h = [\n    0x67452301, 0xefcdab89, 0x98badcfe,\n    0x10325476, 0xc3d2e1f0 ];\n  this.W = new Array(80);\n}\n\nutils.inherits(SHA1, BlockHash);\nmodule.exports = SHA1;\n\nSHA1.blockSize = 512;\nSHA1.outSize = 160;\nSHA1.hmacStrength = 80;\nSHA1.padLength = 64;\n\nSHA1.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++)\n    W[i] = msg[start + i];\n\n  for(; i < W.length; i++)\n    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);\n\n  var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n\n  for (i = 0; i < W.length; i++) {\n    var s = ~~(i / 20);\n    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);\n    e = d;\n    d = c;\n    c = rotl32(b, 30);\n    b = a;\n    a = t;\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n};\n\nSHA1.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\nvar assert = require('minimalistic-assert');\n\nvar sum32 = utils.sum32;\nvar sum32_4 = utils.sum32_4;\nvar sum32_5 = utils.sum32_5;\nvar ch32 = shaCommon.ch32;\nvar maj32 = shaCommon.maj32;\nvar s0_256 = shaCommon.s0_256;\nvar s1_256 = shaCommon.s1_256;\nvar g0_256 = shaCommon.g0_256;\nvar g1_256 = shaCommon.g1_256;\n\nvar BlockHash = common.BlockHash;\n\nvar sha256_K = [\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\n  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\n  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\n  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\n  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\n  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\n  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n];\n\nfunction SHA256() {\n  if (!(this instanceof SHA256))\n    return new SHA256();\n\n  BlockHash.call(this);\n  this.h = [\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\n    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n  ];\n  this.k = sha256_K;\n  this.W = new Array(64);\n}\nutils.inherits(SHA256, BlockHash);\nmodule.exports = SHA256;\n\nSHA256.blockSize = 512;\nSHA256.outSize = 256;\nSHA256.hmacStrength = 192;\nSHA256.padLength = 64;\n\nSHA256.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++)\n    W[i] = msg[start + i];\n  for (; i < W.length; i++)\n    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);\n\n  var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n  var f = this.h[5];\n  var g = this.h[6];\n  var h = this.h[7];\n\n  assert(this.k.length === W.length);\n  for (i = 0; i < W.length; i++) {\n    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);\n    var T2 = sum32(s0_256(a), maj32(a, b, c));\n    h = g;\n    g = f;\n    f = e;\n    e = sum32(d, T1);\n    d = c;\n    c = b;\n    b = a;\n    a = sum32(T1, T2);\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n  this.h[5] = sum32(this.h[5], f);\n  this.h[6] = sum32(this.h[6], g);\n  this.h[7] = sum32(this.h[7], h);\n};\n\nSHA256.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar SHA256 = require('./256');\n\nfunction SHA224() {\n  if (!(this instanceof SHA224))\n    return new SHA224();\n\n  SHA256.call(this);\n  this.h = [\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,\n    0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];\n}\nutils.inherits(SHA224, SHA256);\nmodule.exports = SHA224;\n\nSHA224.blockSize = 512;\nSHA224.outSize = 224;\nSHA224.hmacStrength = 192;\nSHA224.padLength = 64;\n\nSHA224.prototype._digest = function digest(enc) {\n  // Just truncate output\n  if (enc === 'hex')\n    return utils.toHex32(this.h.slice(0, 7), 'big');\n  else\n    return utils.split32(this.h.slice(0, 7), 'big');\n};\n\n","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar assert = require('minimalistic-assert');\n\nvar rotr64_hi = utils.rotr64_hi;\nvar rotr64_lo = utils.rotr64_lo;\nvar shr64_hi = utils.shr64_hi;\nvar shr64_lo = utils.shr64_lo;\nvar sum64 = utils.sum64;\nvar sum64_hi = utils.sum64_hi;\nvar sum64_lo = utils.sum64_lo;\nvar sum64_4_hi = utils.sum64_4_hi;\nvar sum64_4_lo = utils.sum64_4_lo;\nvar sum64_5_hi = utils.sum64_5_hi;\nvar sum64_5_lo = utils.sum64_5_lo;\n\nvar BlockHash = common.BlockHash;\n\nvar sha512_K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n];\n\nfunction SHA512() {\n  if (!(this instanceof SHA512))\n    return new SHA512();\n\n  BlockHash.call(this);\n  this.h = [\n    0x6a09e667, 0xf3bcc908,\n    0xbb67ae85, 0x84caa73b,\n    0x3c6ef372, 0xfe94f82b,\n    0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1,\n    0x9b05688c, 0x2b3e6c1f,\n    0x1f83d9ab, 0xfb41bd6b,\n    0x5be0cd19, 0x137e2179 ];\n  this.k = sha512_K;\n  this.W = new Array(160);\n}\nutils.inherits(SHA512, BlockHash);\nmodule.exports = SHA512;\n\nSHA512.blockSize = 1024;\nSHA512.outSize = 512;\nSHA512.hmacStrength = 192;\nSHA512.padLength = 128;\n\nSHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {\n  var W = this.W;\n\n  // 32 x 32bit words\n  for (var i = 0; i < 32; i++)\n    W[i] = msg[start + i];\n  for (; i < W.length; i += 2) {\n    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);  // i - 2\n    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);\n    var c1_hi = W[i - 14];  // i - 7\n    var c1_lo = W[i - 13];\n    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);  // i - 15\n    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);\n    var c3_hi = W[i - 32];  // i - 16\n    var c3_lo = W[i - 31];\n\n    W[i] = sum64_4_hi(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo);\n    W[i + 1] = sum64_4_lo(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo);\n  }\n};\n\nSHA512.prototype._update = function _update(msg, start) {\n  this._prepareBlock(msg, start);\n\n  var W = this.W;\n\n  var ah = this.h[0];\n  var al = this.h[1];\n  var bh = this.h[2];\n  var bl = this.h[3];\n  var ch = this.h[4];\n  var cl = this.h[5];\n  var dh = this.h[6];\n  var dl = this.h[7];\n  var eh = this.h[8];\n  var el = this.h[9];\n  var fh = this.h[10];\n  var fl = this.h[11];\n  var gh = this.h[12];\n  var gl = this.h[13];\n  var hh = this.h[14];\n  var hl = this.h[15];\n\n  assert(this.k.length === W.length);\n  for (var i = 0; i < W.length; i += 2) {\n    var c0_hi = hh;\n    var c0_lo = hl;\n    var c1_hi = s1_512_hi(eh, el);\n    var c1_lo = s1_512_lo(eh, el);\n    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);\n    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);\n    var c3_hi = this.k[i];\n    var c3_lo = this.k[i + 1];\n    var c4_hi = W[i];\n    var c4_lo = W[i + 1];\n\n    var T1_hi = sum64_5_hi(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo,\n      c4_hi, c4_lo);\n    var T1_lo = sum64_5_lo(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo,\n      c4_hi, c4_lo);\n\n    c0_hi = s0_512_hi(ah, al);\n    c0_lo = s0_512_lo(ah, al);\n    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);\n    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);\n\n    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);\n    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);\n\n    hh = gh;\n    hl = gl;\n\n    gh = fh;\n    gl = fl;\n\n    fh = eh;\n    fl = el;\n\n    eh = sum64_hi(dh, dl, T1_hi, T1_lo);\n    el = sum64_lo(dl, dl, T1_hi, T1_lo);\n\n    dh = ch;\n    dl = cl;\n\n    ch = bh;\n    cl = bl;\n\n    bh = ah;\n    bl = al;\n\n    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);\n    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);\n  }\n\n  sum64(this.h, 0, ah, al);\n  sum64(this.h, 2, bh, bl);\n  sum64(this.h, 4, ch, cl);\n  sum64(this.h, 6, dh, dl);\n  sum64(this.h, 8, eh, el);\n  sum64(this.h, 10, fh, fl);\n  sum64(this.h, 12, gh, gl);\n  sum64(this.h, 14, hh, hl);\n};\n\nSHA512.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n\nfunction ch64_hi(xh, xl, yh, yl, zh) {\n  var r = (xh & yh) ^ ((~xh) & zh);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction ch64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = (xl & yl) ^ ((~xl) & zl);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction maj64_hi(xh, xl, yh, yl, zh) {\n  var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction maj64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 28);\n  var c1_hi = rotr64_hi(xl, xh, 2);  // 34\n  var c2_hi = rotr64_hi(xl, xh, 7);  // 39\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 28);\n  var c1_lo = rotr64_lo(xl, xh, 2);  // 34\n  var c2_lo = rotr64_lo(xl, xh, 7);  // 39\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 14);\n  var c1_hi = rotr64_hi(xh, xl, 18);\n  var c2_hi = rotr64_hi(xl, xh, 9);  // 41\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 14);\n  var c1_lo = rotr64_lo(xh, xl, 18);\n  var c2_lo = rotr64_lo(xl, xh, 9);  // 41\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 1);\n  var c1_hi = rotr64_hi(xh, xl, 8);\n  var c2_hi = shr64_hi(xh, xl, 7);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 1);\n  var c1_lo = rotr64_lo(xh, xl, 8);\n  var c2_lo = shr64_lo(xh, xl, 7);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 19);\n  var c1_hi = rotr64_hi(xl, xh, 29);  // 61\n  var c2_hi = shr64_hi(xh, xl, 6);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 19);\n  var c1_lo = rotr64_lo(xl, xh, 29);  // 61\n  var c2_lo = shr64_lo(xh, xl, 6);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n","'use strict';\n\nvar utils = require('../utils');\n\nvar SHA512 = require('./512');\n\nfunction SHA384() {\n  if (!(this instanceof SHA384))\n    return new SHA384();\n\n  SHA512.call(this);\n  this.h = [\n    0xcbbb9d5d, 0xc1059ed8,\n    0x629a292a, 0x367cd507,\n    0x9159015a, 0x3070dd17,\n    0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31,\n    0x8eb44a87, 0x68581511,\n    0xdb0c2e0d, 0x64f98fa7,\n    0x47b5481d, 0xbefa4fa4 ];\n}\nutils.inherits(SHA384, SHA512);\nmodule.exports = SHA384;\n\nSHA384.blockSize = 1024;\nSHA384.outSize = 384;\nSHA384.hmacStrength = 192;\nSHA384.padLength = 128;\n\nSHA384.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h.slice(0, 12), 'big');\n  else\n    return utils.split32(this.h.slice(0, 12), 'big');\n};\n","'use strict';\n\nexports.sha1 = require('./sha/1');\nexports.sha224 = require('./sha/224');\nexports.sha256 = require('./sha/256');\nexports.sha384 = require('./sha/384');\nexports.sha512 = require('./sha/512');\n","'use strict';\n\nvar utils = require('./utils');\nvar common = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_3 = utils.sum32_3;\nvar sum32_4 = utils.sum32_4;\nvar BlockHash = common.BlockHash;\n\nfunction RIPEMD160() {\n  if (!(this instanceof RIPEMD160))\n    return new RIPEMD160();\n\n  BlockHash.call(this);\n\n  this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];\n  this.endian = 'little';\n}\nutils.inherits(RIPEMD160, BlockHash);\nexports.ripemd160 = RIPEMD160;\n\nRIPEMD160.blockSize = 512;\nRIPEMD160.outSize = 160;\nRIPEMD160.hmacStrength = 192;\nRIPEMD160.padLength = 64;\n\nRIPEMD160.prototype._update = function update(msg, start) {\n  var A = this.h[0];\n  var B = this.h[1];\n  var C = this.h[2];\n  var D = this.h[3];\n  var E = this.h[4];\n  var Ah = A;\n  var Bh = B;\n  var Ch = C;\n  var Dh = D;\n  var Eh = E;\n  for (var j = 0; j < 80; j++) {\n    var T = sum32(\n      rotl32(\n        sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),\n        s[j]),\n      E);\n    A = E;\n    E = D;\n    D = rotl32(C, 10);\n    C = B;\n    B = T;\n    T = sum32(\n      rotl32(\n        sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),\n        sh[j]),\n      Eh);\n    Ah = Eh;\n    Eh = Dh;\n    Dh = rotl32(Ch, 10);\n    Ch = Bh;\n    Bh = T;\n  }\n  T = sum32_3(this.h[1], C, Dh);\n  this.h[1] = sum32_3(this.h[2], D, Eh);\n  this.h[2] = sum32_3(this.h[3], E, Ah);\n  this.h[3] = sum32_3(this.h[4], A, Bh);\n  this.h[4] = sum32_3(this.h[0], B, Ch);\n  this.h[0] = T;\n};\n\nRIPEMD160.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'little');\n  else\n    return utils.split32(this.h, 'little');\n};\n\nfunction f(j, x, y, z) {\n  if (j <= 15)\n    return x ^ y ^ z;\n  else if (j <= 31)\n    return (x & y) | ((~x) & z);\n  else if (j <= 47)\n    return (x | (~y)) ^ z;\n  else if (j <= 63)\n    return (x & z) | (y & (~z));\n  else\n    return x ^ (y | (~z));\n}\n\nfunction K(j) {\n  if (j <= 15)\n    return 0x00000000;\n  else if (j <= 31)\n    return 0x5a827999;\n  else if (j <= 47)\n    return 0x6ed9eba1;\n  else if (j <= 63)\n    return 0x8f1bbcdc;\n  else\n    return 0xa953fd4e;\n}\n\nfunction Kh(j) {\n  if (j <= 15)\n    return 0x50a28be6;\n  else if (j <= 31)\n    return 0x5c4dd124;\n  else if (j <= 47)\n    return 0x6d703ef3;\n  else if (j <= 63)\n    return 0x7a6d76e9;\n  else\n    return 0x00000000;\n}\n\nvar r = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n];\n\nvar rh = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n];\n\nvar s = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n];\n\nvar sh = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n];\n","'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction Hmac(hash, key, enc) {\n  if (!(this instanceof Hmac))\n    return new Hmac(hash, key, enc);\n  this.Hash = hash;\n  this.blockSize = hash.blockSize / 8;\n  this.outSize = hash.outSize / 8;\n  this.inner = null;\n  this.outer = null;\n\n  this._init(utils.toArray(key, enc));\n}\nmodule.exports = Hmac;\n\nHmac.prototype._init = function init(key) {\n  // Shorten key, if needed\n  if (key.length > this.blockSize)\n    key = new this.Hash().update(key).digest();\n  assert(key.length <= this.blockSize);\n\n  // Add padding to key\n  for (var i = key.length; i < this.blockSize; i++)\n    key.push(0);\n\n  for (i = 0; i < key.length; i++)\n    key[i] ^= 0x36;\n  this.inner = new this.Hash().update(key);\n\n  // 0x36 ^ 0x5c = 0x6a\n  for (i = 0; i < key.length; i++)\n    key[i] ^= 0x6a;\n  this.outer = new this.Hash().update(key);\n};\n\nHmac.prototype.update = function update(msg, enc) {\n  this.inner.update(msg, enc);\n  return this;\n};\n\nHmac.prototype.digest = function digest(enc) {\n  this.outer.update(this.inner.digest());\n  return this.outer.digest(enc);\n};\n","var hash = exports;\n\nhash.utils = require('./hash/utils');\nhash.common = require('./hash/common');\nhash.sha = require('./hash/sha');\nhash.ripemd = require('./hash/ripemd');\nhash.hmac = require('./hash/hmac');\n\n// Proxy hash functions to the main object\nhash.sha1 = hash.sha.sha1;\nhash.sha256 = hash.sha.sha256;\nhash.sha224 = hash.sha.sha224;\nhash.sha384 = hash.sha.sha384;\nhash.sha512 = hash.sha.sha512;\nhash.ripemd160 = hash.ripemd.ripemd160;\n","/*! MIT License. Copyright 2015-2018 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */\n(function(root) {\n    \"use strict\";\n\n    function checkInt(value) {\n        return (parseInt(value) === value);\n    }\n\n    function checkInts(arrayish) {\n        if (!checkInt(arrayish.length)) { return false; }\n\n        for (var i = 0; i < arrayish.length; i++) {\n            if (!checkInt(arrayish[i]) || arrayish[i] < 0 || arrayish[i] > 255) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    function coerceArray(arg, copy) {\n\n        // ArrayBuffer view\n        if (arg.buffer && arg.name === 'Uint8Array') {\n\n            if (copy) {\n                if (arg.slice) {\n                    arg = arg.slice();\n                } else {\n                    arg = Array.prototype.slice.call(arg);\n                }\n            }\n\n            return arg;\n        }\n\n        // It's an array; check it is a valid representation of a byte\n        if (Array.isArray(arg)) {\n            if (!checkInts(arg)) {\n                throw new Error('Array contains invalid value: ' + arg);\n            }\n\n            return new Uint8Array(arg);\n        }\n\n        // Something else, but behaves like an array (maybe a Buffer? Arguments?)\n        if (checkInt(arg.length) && checkInts(arg)) {\n            return new Uint8Array(arg);\n        }\n\n        throw new Error('unsupported array-like object');\n    }\n\n    function createArray(length) {\n        return new Uint8Array(length);\n    }\n\n    function copyArray(sourceArray, targetArray, targetStart, sourceStart, sourceEnd) {\n        if (sourceStart != null || sourceEnd != null) {\n            if (sourceArray.slice) {\n                sourceArray = sourceArray.slice(sourceStart, sourceEnd);\n            } else {\n                sourceArray = Array.prototype.slice.call(sourceArray, sourceStart, sourceEnd);\n            }\n        }\n        targetArray.set(sourceArray, targetStart);\n    }\n\n\n\n    var convertUtf8 = (function() {\n        function toBytes(text) {\n            var result = [], i = 0;\n            text = encodeURI(text);\n            while (i < text.length) {\n                var c = text.charCodeAt(i++);\n\n                // if it is a % sign, encode the following 2 bytes as a hex value\n                if (c === 37) {\n                    result.push(parseInt(text.substr(i, 2), 16))\n                    i += 2;\n\n                // otherwise, just the actual byte\n                } else {\n                    result.push(c)\n                }\n            }\n\n            return coerceArray(result);\n        }\n\n        function fromBytes(bytes) {\n            var result = [], i = 0;\n\n            while (i < bytes.length) {\n                var c = bytes[i];\n\n                if (c < 128) {\n                    result.push(String.fromCharCode(c));\n                    i++;\n                } else if (c > 191 && c < 224) {\n                    result.push(String.fromCharCode(((c & 0x1f) << 6) | (bytes[i + 1] & 0x3f)));\n                    i += 2;\n                } else {\n                    result.push(String.fromCharCode(((c & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f)));\n                    i += 3;\n                }\n            }\n\n            return result.join('');\n        }\n\n        return {\n            toBytes: toBytes,\n            fromBytes: fromBytes,\n        }\n    })();\n\n    var convertHex = (function() {\n        function toBytes(text) {\n            var result = [];\n            for (var i = 0; i < text.length; i += 2) {\n                result.push(parseInt(text.substr(i, 2), 16));\n            }\n\n            return result;\n        }\n\n        // http://ixti.net/development/javascript/2011/11/11/base64-encodedecode-of-utf8-in-browser-with-js.html\n        var Hex = '0123456789abcdef';\n\n        function fromBytes(bytes) {\n                var result = [];\n                for (var i = 0; i < bytes.length; i++) {\n                    var v = bytes[i];\n                    result.push(Hex[(v & 0xf0) >> 4] + Hex[v & 0x0f]);\n                }\n                return result.join('');\n        }\n\n        return {\n            toBytes: toBytes,\n            fromBytes: fromBytes,\n        }\n    })();\n\n\n    // Number of rounds by keysize\n    var numberOfRounds = {16: 10, 24: 12, 32: 14}\n\n    // Round constant words\n    var rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91];\n\n    // S-box and Inverse S-box (S is for Substitution)\n    var S = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16];\n    var Si =[0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d];\n\n    // Transformations for encryption\n    var T1 = [0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a];\n    var T2 = [0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0xec41adad, 0x67b3d4d4, 0xfd5fa2a2, 0xea45afaf, 0xbf239c9c, 0xf753a4a4, 0x96e47272, 0x5b9bc0c0, 0xc275b7b7, 0x1ce1fdfd, 0xae3d9393, 0x6a4c2626, 0x5a6c3636, 0x417e3f3f, 0x02f5f7f7, 0x4f83cccc, 0x5c683434, 0xf451a5a5, 0x34d1e5e5, 0x08f9f1f1, 0x93e27171, 0x73abd8d8, 0x53623131, 0x3f2a1515, 0x0c080404, 0x5295c7c7, 0x65462323, 0x5e9dc3c3, 0x28301818, 0xa1379696, 0x0f0a0505, 0xb52f9a9a, 0x090e0707, 0x36241212, 0x9b1b8080, 0x3ddfe2e2, 0x26cdebeb, 0x694e2727, 0xcd7fb2b2, 0x9fea7575, 0x1b120909, 0x9e1d8383, 0x74582c2c, 0x2e341a1a, 0x2d361b1b, 0xb2dc6e6e, 0xeeb45a5a, 0xfb5ba0a0, 0xf6a45252, 0x4d763b3b, 0x61b7d6d6, 0xce7db3b3, 0x7b522929, 0x3edde3e3, 0x715e2f2f, 0x97138484, 0xf5a65353, 0x68b9d1d1, 0x00000000, 0x2cc1eded, 0x60402020, 0x1fe3fcfc, 0xc879b1b1, 0xedb65b5b, 0xbed46a6a, 0x468dcbcb, 0xd967bebe, 0x4b723939, 0xde944a4a, 0xd4984c4c, 0xe8b05858, 0x4a85cfcf, 0x6bbbd0d0, 0x2ac5efef, 0xe54faaaa, 0x16edfbfb, 0xc5864343, 0xd79a4d4d, 0x55663333, 0x94118585, 0xcf8a4545, 0x10e9f9f9, 0x06040202, 0x81fe7f7f, 0xf0a05050, 0x44783c3c, 0xba259f9f, 0xe34ba8a8, 0xf3a25151, 0xfe5da3a3, 0xc0804040, 0x8a058f8f, 0xad3f9292, 0xbc219d9d, 0x48703838, 0x04f1f5f5, 0xdf63bcbc, 0xc177b6b6, 0x75afdada, 0x63422121, 0x30201010, 0x1ae5ffff, 0x0efdf3f3, 0x6dbfd2d2, 0x4c81cdcd, 0x14180c0c, 0x35261313, 0x2fc3ecec, 0xe1be5f5f, 0xa2359797, 0xcc884444, 0x392e1717, 0x5793c4c4, 0xf255a7a7, 0x82fc7e7e, 0x477a3d3d, 0xacc86464, 0xe7ba5d5d, 0x2b321919, 0x95e67373, 0xa0c06060, 0x98198181, 0xd19e4f4f, 0x7fa3dcdc, 0x66442222, 0x7e542a2a, 0xab3b9090, 0x830b8888, 0xca8c4646, 0x29c7eeee, 0xd36bb8b8, 0x3c281414, 0x79a7dede, 0xe2bc5e5e, 0x1d160b0b, 0x76addbdb, 0x3bdbe0e0, 0x56643232, 0x4e743a3a, 0x1e140a0a, 0xdb924949, 0x0a0c0606, 0x6c482424, 0xe4b85c5c, 0x5d9fc2c2, 0x6ebdd3d3, 0xef43acac, 0xa6c46262, 0xa8399191, 0xa4319595, 0x37d3e4e4, 0x8bf27979, 0x32d5e7e7, 0x438bc8c8, 0x596e3737, 0xb7da6d6d, 0x8c018d8d, 0x64b1d5d5, 0xd29c4e4e, 0xe049a9a9, 0xb4d86c6c, 0xfaac5656, 0x07f3f4f4, 0x25cfeaea, 0xafca6565, 0x8ef47a7a, 0xe947aeae, 0x18100808, 0xd56fbaba, 0x88f07878, 0x6f4a2525, 0x725c2e2e, 0x24381c1c, 0xf157a6a6, 0xc773b4b4, 0x5197c6c6, 0x23cbe8e8, 0x7ca1dddd, 0x9ce87474, 0x213e1f1f, 0xdd964b4b, 0xdc61bdbd, 0x860d8b8b, 0x850f8a8a, 0x90e07070, 0x427c3e3e, 0xc471b5b5, 0xaacc6666, 0xd8904848, 0x05060303, 0x01f7f6f6, 0x121c0e0e, 0xa3c26161, 0x5f6a3535, 0xf9ae5757, 0xd069b9b9, 0x91178686, 0x5899c1c1, 0x273a1d1d, 0xb9279e9e, 0x38d9e1e1, 0x13ebf8f8, 0xb32b9898, 0x33221111, 0xbbd26969, 0x70a9d9d9, 0x89078e8e, 0xa7339494, 0xb62d9b9b, 0x223c1e1e, 0x92158787, 0x20c9e9e9, 0x4987cece, 0xffaa5555, 0x78502828, 0x7aa5dfdf, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616];\n    var T3 = [0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xadec41ad, 0xd467b3d4, 0xa2fd5fa2, 0xafea45af, 0x9cbf239c, 0xa4f753a4, 0x7296e472, 0xc05b9bc0, 0xb7c275b7, 0xfd1ce1fd, 0x93ae3d93, 0x266a4c26, 0x365a6c36, 0x3f417e3f, 0xf702f5f7, 0xcc4f83cc, 0x345c6834, 0xa5f451a5, 0xe534d1e5, 0xf108f9f1, 0x7193e271, 0xd873abd8, 0x31536231, 0x153f2a15, 0x040c0804, 0xc75295c7, 0x23654623, 0xc35e9dc3, 0x18283018, 0x96a13796, 0x050f0a05, 0x9ab52f9a, 0x07090e07, 0x12362412, 0x809b1b80, 0xe23ddfe2, 0xeb26cdeb, 0x27694e27, 0xb2cd7fb2, 0x759fea75, 0x091b1209, 0x839e1d83, 0x2c74582c, 0x1a2e341a, 0x1b2d361b, 0x6eb2dc6e, 0x5aeeb45a, 0xa0fb5ba0, 0x52f6a452, 0x3b4d763b, 0xd661b7d6, 0xb3ce7db3, 0x297b5229, 0xe33edde3, 0x2f715e2f, 0x84971384, 0x53f5a653, 0xd168b9d1, 0x00000000, 0xed2cc1ed, 0x20604020, 0xfc1fe3fc, 0xb1c879b1, 0x5bedb65b, 0x6abed46a, 0xcb468dcb, 0xbed967be, 0x394b7239, 0x4ade944a, 0x4cd4984c, 0x58e8b058, 0xcf4a85cf, 0xd06bbbd0, 0xef2ac5ef, 0xaae54faa, 0xfb16edfb, 0x43c58643, 0x4dd79a4d, 0x33556633, 0x85941185, 0x45cf8a45, 0xf910e9f9, 0x02060402, 0x7f81fe7f, 0x50f0a050, 0x3c44783c, 0x9fba259f, 0xa8e34ba8, 0x51f3a251, 0xa3fe5da3, 0x40c08040, 0x8f8a058f, 0x92ad3f92, 0x9dbc219d, 0x38487038, 0xf504f1f5, 0xbcdf63bc, 0xb6c177b6, 0xda75afda, 0x21634221, 0x10302010, 0xff1ae5ff, 0xf30efdf3, 0xd26dbfd2, 0xcd4c81cd, 0x0c14180c, 0x13352613, 0xec2fc3ec, 0x5fe1be5f, 0x97a23597, 0x44cc8844, 0x17392e17, 0xc45793c4, 0xa7f255a7, 0x7e82fc7e, 0x3d477a3d, 0x64acc864, 0x5de7ba5d, 0x192b3219, 0x7395e673, 0x60a0c060, 0x81981981, 0x4fd19e4f, 0xdc7fa3dc, 0x22664422, 0x2a7e542a, 0x90ab3b90, 0x88830b88, 0x46ca8c46, 0xee29c7ee, 0xb8d36bb8, 0x143c2814, 0xde79a7de, 0x5ee2bc5e, 0x0b1d160b, 0xdb76addb, 0xe03bdbe0, 0x32566432, 0x3a4e743a, 0x0a1e140a, 0x49db9249, 0x060a0c06, 0x246c4824, 0x5ce4b85c, 0xc25d9fc2, 0xd36ebdd3, 0xacef43ac, 0x62a6c462, 0x91a83991, 0x95a43195, 0xe437d3e4, 0x798bf279, 0xe732d5e7, 0xc8438bc8, 0x37596e37, 0x6db7da6d, 0x8d8c018d, 0xd564b1d5, 0x4ed29c4e, 0xa9e049a9, 0x6cb4d86c, 0x56faac56, 0xf407f3f4, 0xea25cfea, 0x65afca65, 0x7a8ef47a, 0xaee947ae, 0x08181008, 0xbad56fba, 0x7888f078, 0x256f4a25, 0x2e725c2e, 0x1c24381c, 0xa6f157a6, 0xb4c773b4, 0xc65197c6, 0xe823cbe8, 0xdd7ca1dd, 0x749ce874, 0x1f213e1f, 0x4bdd964b, 0xbddc61bd, 0x8b860d8b, 0x8a850f8a, 0x7090e070, 0x3e427c3e, 0xb5c471b5, 0x66aacc66, 0x48d89048, 0x03050603, 0xf601f7f6, 0x0e121c0e, 0x61a3c261, 0x355f6a35, 0x57f9ae57, 0xb9d069b9, 0x86911786, 0xc15899c1, 0x1d273a1d, 0x9eb9279e, 0xe138d9e1, 0xf813ebf8, 0x98b32b98, 0x11332211, 0x69bbd269, 0xd970a9d9, 0x8e89078e, 0x94a73394, 0x9bb62d9b, 0x1e223c1e, 0x87921587, 0xe920c9e9, 0xce4987ce, 0x55ffaa55, 0x28785028, 0xdf7aa5df, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16];\n    var T4 = [0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xadadec41, 0xd4d467b3, 0xa2a2fd5f, 0xafafea45, 0x9c9cbf23, 0xa4a4f753, 0x727296e4, 0xc0c05b9b, 0xb7b7c275, 0xfdfd1ce1, 0x9393ae3d, 0x26266a4c, 0x36365a6c, 0x3f3f417e, 0xf7f702f5, 0xcccc4f83, 0x34345c68, 0xa5a5f451, 0xe5e534d1, 0xf1f108f9, 0x717193e2, 0xd8d873ab, 0x31315362, 0x15153f2a, 0x04040c08, 0xc7c75295, 0x23236546, 0xc3c35e9d, 0x18182830, 0x9696a137, 0x05050f0a, 0x9a9ab52f, 0x0707090e, 0x12123624, 0x80809b1b, 0xe2e23ddf, 0xebeb26cd, 0x2727694e, 0xb2b2cd7f, 0x75759fea, 0x09091b12, 0x83839e1d, 0x2c2c7458, 0x1a1a2e34, 0x1b1b2d36, 0x6e6eb2dc, 0x5a5aeeb4, 0xa0a0fb5b, 0x5252f6a4, 0x3b3b4d76, 0xd6d661b7, 0xb3b3ce7d, 0x29297b52, 0xe3e33edd, 0x2f2f715e, 0x84849713, 0x5353f5a6, 0xd1d168b9, 0x00000000, 0xeded2cc1, 0x20206040, 0xfcfc1fe3, 0xb1b1c879, 0x5b5bedb6, 0x6a6abed4, 0xcbcb468d, 0xbebed967, 0x39394b72, 0x4a4ade94, 0x4c4cd498, 0x5858e8b0, 0xcfcf4a85, 0xd0d06bbb, 0xefef2ac5, 0xaaaae54f, 0xfbfb16ed, 0x4343c586, 0x4d4dd79a, 0x33335566, 0x85859411, 0x4545cf8a, 0xf9f910e9, 0x02020604, 0x7f7f81fe, 0x5050f0a0, 0x3c3c4478, 0x9f9fba25, 0xa8a8e34b, 0x5151f3a2, 0xa3a3fe5d, 0x4040c080, 0x8f8f8a05, 0x9292ad3f, 0x9d9dbc21, 0x38384870, 0xf5f504f1, 0xbcbcdf63, 0xb6b6c177, 0xdada75af, 0x21216342, 0x10103020, 0xffff1ae5, 0xf3f30efd, 0xd2d26dbf, 0xcdcd4c81, 0x0c0c1418, 0x13133526, 0xecec2fc3, 0x5f5fe1be, 0x9797a235, 0x4444cc88, 0x1717392e, 0xc4c45793, 0xa7a7f255, 0x7e7e82fc, 0x3d3d477a, 0x6464acc8, 0x5d5de7ba, 0x19192b32, 0x737395e6, 0x6060a0c0, 0x81819819, 0x4f4fd19e, 0xdcdc7fa3, 0x22226644, 0x2a2a7e54, 0x9090ab3b, 0x8888830b, 0x4646ca8c, 0xeeee29c7, 0xb8b8d36b, 0x14143c28, 0xdede79a7, 0x5e5ee2bc, 0x0b0b1d16, 0xdbdb76ad, 0xe0e03bdb, 0x32325664, 0x3a3a4e74, 0x0a0a1e14, 0x4949db92, 0x06060a0c, 0x24246c48, 0x5c5ce4b8, 0xc2c25d9f, 0xd3d36ebd, 0xacacef43, 0x6262a6c4, 0x9191a839, 0x9595a431, 0xe4e437d3, 0x79798bf2, 0xe7e732d5, 0xc8c8438b, 0x3737596e, 0x6d6db7da, 0x8d8d8c01, 0xd5d564b1, 0x4e4ed29c, 0xa9a9e049, 0x6c6cb4d8, 0x5656faac, 0xf4f407f3, 0xeaea25cf, 0x6565afca, 0x7a7a8ef4, 0xaeaee947, 0x08081810, 0xbabad56f, 0x787888f0, 0x25256f4a, 0x2e2e725c, 0x1c1c2438, 0xa6a6f157, 0xb4b4c773, 0xc6c65197, 0xe8e823cb, 0xdddd7ca1, 0x74749ce8, 0x1f1f213e, 0x4b4bdd96, 0xbdbddc61, 0x8b8b860d, 0x8a8a850f, 0x707090e0, 0x3e3e427c, 0xb5b5c471, 0x6666aacc, 0x4848d890, 0x03030506, 0xf6f601f7, 0x0e0e121c, 0x6161a3c2, 0x35355f6a, 0x5757f9ae, 0xb9b9d069, 0x86869117, 0xc1c15899, 0x1d1d273a, 0x9e9eb927, 0xe1e138d9, 0xf8f813eb, 0x9898b32b, 0x11113322, 0x6969bbd2, 0xd9d970a9, 0x8e8e8907, 0x9494a733, 0x9b9bb62d, 0x1e1e223c, 0x87879215, 0xe9e920c9, 0xcece4987, 0x5555ffaa, 0x28287850, 0xdfdf7aa5, 0x8c8c8f03, 0xa1a1f859, 0x89898009, 0x0d0d171a, 0xbfbfda65, 0xe6e631d7, 0x4242c684, 0x6868b8d0, 0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e, 0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c];\n\n    // Transformations for decryption\n    var T5 = [0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742];\n    var T6 = [0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0xe7038f5f, 0x9515929c, 0xebbf6d7a, 0xda955259, 0x2dd4be83, 0xd3587421, 0x2949e069, 0x448ec9c8, 0x6a75c289, 0x78f48e79, 0x6b99583e, 0xdd27b971, 0xb6bee14f, 0x17f088ad, 0x66c920ac, 0xb47dce3a, 0x1863df4a, 0x82e51a31, 0x60975133, 0x4562537f, 0xe0b16477, 0x84bb6bae, 0x1cfe81a0, 0x94f9082b, 0x58704868, 0x198f45fd, 0x8794de6c, 0xb7527bf8, 0x23ab73d3, 0xe2724b02, 0x57e31f8f, 0x2a6655ab, 0x07b2eb28, 0x032fb5c2, 0x9a86c57b, 0xa5d33708, 0xf2302887, 0xb223bfa5, 0xba02036a, 0x5ced1682, 0x2b8acf1c, 0x92a779b4, 0xf0f307f2, 0xa14e69e2, 0xcd65daf4, 0xd50605be, 0x1fd13462, 0x8ac4a6fe, 0x9d342e53, 0xa0a2f355, 0x32058ae1, 0x75a4f6eb, 0x390b83ec, 0xaa4060ef, 0x065e719f, 0x51bd6e10, 0xf93e218a, 0x3d96dd06, 0xaedd3e05, 0x464de6bd, 0xb591548d, 0x0571c45d, 0x6f0406d4, 0xff605015, 0x241998fb, 0x97d6bde9, 0xcc894043, 0x7767d99e, 0xbdb0e842, 0x8807898b, 0x38e7195b, 0xdb79c8ee, 0x47a17c0a, 0xe97c420f, 0xc9f8841e, 0x00000000, 0x83098086, 0x48322bed, 0xac1e1170, 0x4e6c5a72, 0xfbfd0eff, 0x560f8538, 0x1e3daed5, 0x27362d39, 0x640a0fd9, 0x21685ca6, 0xd19b5b54, 0x3a24362e, 0xb10c0a67, 0x0f9357e7, 0xd2b4ee96, 0x9e1b9b91, 0x4f80c0c5, 0xa261dc20, 0x695a774b, 0x161c121a, 0x0ae293ba, 0xe5c0a02a, 0x433c22e0, 0x1d121b17, 0x0b0e090d, 0xadf28bc7, 0xb92db6a8, 0xc8141ea9, 0x8557f119, 0x4caf7507, 0xbbee99dd, 0xfda37f60, 0x9ff70126, 0xbc5c72f5, 0xc544663b, 0x345bfb7e, 0x768b4329, 0xdccb23c6, 0x68b6edfc, 0x63b8e4f1, 0xcad731dc, 0x10426385, 0x40139722, 0x2084c611, 0x7d854a24, 0xf8d2bb3d, 0x11aef932, 0x6dc729a1, 0x4b1d9e2f, 0xf3dcb230, 0xec0d8652, 0xd077c1e3, 0x6c2bb316, 0x99a970b9, 0xfa119448, 0x2247e964, 0xc4a8fc8c, 0x1aa0f03f, 0xd8567d2c, 0xef223390, 0xc787494e, 0xc1d938d1, 0xfe8ccaa2, 0x3698d40b, 0xcfa6f581, 0x28a57ade, 0x26dab78e, 0xa43fadbf, 0xe42c3a9d, 0x0d507892, 0x9b6a5fcc, 0x62547e46, 0xc2f68d13, 0xe890d8b8, 0x5e2e39f7, 0xf582c3af, 0xbe9f5d80, 0x7c69d093, 0xa96fd52d, 0xb3cf2512, 0x3bc8ac99, 0xa710187d, 0x6ee89c63, 0x7bdb3bbb, 0x09cd2678, 0xf46e5918, 0x01ec9ab7, 0xa8834f9a, 0x65e6956e, 0x7eaaffe6, 0x0821bccf, 0xe6ef15e8, 0xd9bae79b, 0xce4a6f36, 0xd4ea9f09, 0xd629b07c, 0xaf31a4b2, 0x312a3f23, 0x30c6a594, 0xc035a266, 0x37744ebc, 0xa6fc82ca, 0xb0e090d0, 0x1533a7d8, 0x4af10498, 0xf741ecda, 0x0e7fcd50, 0x2f1791f6, 0x8d764dd6, 0x4d43efb0, 0x54ccaa4d, 0xdfe49604, 0xe39ed1b5, 0x1b4c6a88, 0xb8c12c1f, 0x7f466551, 0x049d5eea, 0x5d018c35, 0x73fa8774, 0x2efb0b41, 0x5ab3671d, 0x5292dbd2, 0x33e91056, 0x136dd647, 0x8c9ad761, 0x7a37a10c, 0x8e59f814, 0x89eb133c, 0xeecea927, 0x35b761c9, 0xede11ce5, 0x3c7a47b1, 0x599cd2df, 0x3f55f273, 0x791814ce, 0xbf73c737, 0xea53f7cd, 0x5b5ffdaa, 0x14df3d6f, 0x867844db, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857];\n    var T7 = [0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5fe7038f, 0x9c951592, 0x7aebbf6d, 0x59da9552, 0x832dd4be, 0x21d35874, 0x692949e0, 0xc8448ec9, 0x896a75c2, 0x7978f48e, 0x3e6b9958, 0x71dd27b9, 0x4fb6bee1, 0xad17f088, 0xac66c920, 0x3ab47dce, 0x4a1863df, 0x3182e51a, 0x33609751, 0x7f456253, 0x77e0b164, 0xae84bb6b, 0xa01cfe81, 0x2b94f908, 0x68587048, 0xfd198f45, 0x6c8794de, 0xf8b7527b, 0xd323ab73, 0x02e2724b, 0x8f57e31f, 0xab2a6655, 0x2807b2eb, 0xc2032fb5, 0x7b9a86c5, 0x08a5d337, 0x87f23028, 0xa5b223bf, 0x6aba0203, 0x825ced16, 0x1c2b8acf, 0xb492a779, 0xf2f0f307, 0xe2a14e69, 0xf4cd65da, 0xbed50605, 0x621fd134, 0xfe8ac4a6, 0x539d342e, 0x55a0a2f3, 0xe132058a, 0xeb75a4f6, 0xec390b83, 0xefaa4060, 0x9f065e71, 0x1051bd6e, 0x8af93e21, 0x063d96dd, 0x05aedd3e, 0xbd464de6, 0x8db59154, 0x5d0571c4, 0xd46f0406, 0x15ff6050, 0xfb241998, 0xe997d6bd, 0x43cc8940, 0x9e7767d9, 0x42bdb0e8, 0x8b880789, 0x5b38e719, 0xeedb79c8, 0x0a47a17c, 0x0fe97c42, 0x1ec9f884, 0x00000000, 0x86830980, 0xed48322b, 0x70ac1e11, 0x724e6c5a, 0xfffbfd0e, 0x38560f85, 0xd51e3dae, 0x3927362d, 0xd9640a0f, 0xa621685c, 0x54d19b5b, 0x2e3a2436, 0x67b10c0a, 0xe70f9357, 0x96d2b4ee, 0x919e1b9b, 0xc54f80c0, 0x20a261dc, 0x4b695a77, 0x1a161c12, 0xba0ae293, 0x2ae5c0a0, 0xe0433c22, 0x171d121b, 0x0d0b0e09, 0xc7adf28b, 0xa8b92db6, 0xa9c8141e, 0x198557f1, 0x074caf75, 0xddbbee99, 0x60fda37f, 0x269ff701, 0xf5bc5c72, 0x3bc54466, 0x7e345bfb, 0x29768b43, 0xc6dccb23, 0xfc68b6ed, 0xf163b8e4, 0xdccad731, 0x85104263, 0x22401397, 0x112084c6, 0x247d854a, 0x3df8d2bb, 0x3211aef9, 0xa16dc729, 0x2f4b1d9e, 0x30f3dcb2, 0x52ec0d86, 0xe3d077c1, 0x166c2bb3, 0xb999a970, 0x48fa1194, 0x642247e9, 0x8cc4a8fc, 0x3f1aa0f0, 0x2cd8567d, 0x90ef2233, 0x4ec78749, 0xd1c1d938, 0xa2fe8cca, 0x0b3698d4, 0x81cfa6f5, 0xde28a57a, 0x8e26dab7, 0xbfa43fad, 0x9de42c3a, 0x920d5078, 0xcc9b6a5f, 0x4662547e, 0x13c2f68d, 0xb8e890d8, 0xf75e2e39, 0xaff582c3, 0x80be9f5d, 0x937c69d0, 0x2da96fd5, 0x12b3cf25, 0x993bc8ac, 0x7da71018, 0x636ee89c, 0xbb7bdb3b, 0x7809cd26, 0x18f46e59, 0xb701ec9a, 0x9aa8834f, 0x6e65e695, 0xe67eaaff, 0xcf0821bc, 0xe8e6ef15, 0x9bd9bae7, 0x36ce4a6f, 0x09d4ea9f, 0x7cd629b0, 0xb2af31a4, 0x23312a3f, 0x9430c6a5, 0x66c035a2, 0xbc37744e, 0xcaa6fc82, 0xd0b0e090, 0xd81533a7, 0x984af104, 0xdaf741ec, 0x500e7fcd, 0xf62f1791, 0xd68d764d, 0xb04d43ef, 0x4d54ccaa, 0x04dfe496, 0xb5e39ed1, 0x881b4c6a, 0x1fb8c12c, 0x517f4665, 0xea049d5e, 0x355d018c, 0x7473fa87, 0x412efb0b, 0x1d5ab367, 0xd25292db, 0x5633e910, 0x47136dd6, 0x618c9ad7, 0x0c7a37a1, 0x148e59f8, 0x3c89eb13, 0x27eecea9, 0xc935b761, 0xe5ede11c, 0xb13c7a47, 0xdf599cd2, 0x733f55f2, 0xce791814, 0x37bf73c7, 0xcdea53f7, 0xaa5b5ffd, 0x6f14df3d, 0xdb867844, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8];\n    var T8 = [0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0x8f5fe703, 0x929c9515, 0x6d7aebbf, 0x5259da95, 0xbe832dd4, 0x7421d358, 0xe0692949, 0xc9c8448e, 0xc2896a75, 0x8e7978f4, 0x583e6b99, 0xb971dd27, 0xe14fb6be, 0x88ad17f0, 0x20ac66c9, 0xce3ab47d, 0xdf4a1863, 0x1a3182e5, 0x51336097, 0x537f4562, 0x6477e0b1, 0x6bae84bb, 0x81a01cfe, 0x082b94f9, 0x48685870, 0x45fd198f, 0xde6c8794, 0x7bf8b752, 0x73d323ab, 0x4b02e272, 0x1f8f57e3, 0x55ab2a66, 0xeb2807b2, 0xb5c2032f, 0xc57b9a86, 0x3708a5d3, 0x2887f230, 0xbfa5b223, 0x036aba02, 0x16825ced, 0xcf1c2b8a, 0x79b492a7, 0x07f2f0f3, 0x69e2a14e, 0xdaf4cd65, 0x05bed506, 0x34621fd1, 0xa6fe8ac4, 0x2e539d34, 0xf355a0a2, 0x8ae13205, 0xf6eb75a4, 0x83ec390b, 0x60efaa40, 0x719f065e, 0x6e1051bd, 0x218af93e, 0xdd063d96, 0x3e05aedd, 0xe6bd464d, 0x548db591, 0xc45d0571, 0x06d46f04, 0x5015ff60, 0x98fb2419, 0xbde997d6, 0x4043cc89, 0xd99e7767, 0xe842bdb0, 0x898b8807, 0x195b38e7, 0xc8eedb79, 0x7c0a47a1, 0x420fe97c, 0x841ec9f8, 0x00000000, 0x80868309, 0x2bed4832, 0x1170ac1e, 0x5a724e6c, 0x0efffbfd, 0x8538560f, 0xaed51e3d, 0x2d392736, 0x0fd9640a, 0x5ca62168, 0x5b54d19b, 0x362e3a24, 0x0a67b10c, 0x57e70f93, 0xee96d2b4, 0x9b919e1b, 0xc0c54f80, 0xdc20a261, 0x774b695a, 0x121a161c, 0x93ba0ae2, 0xa02ae5c0, 0x22e0433c, 0x1b171d12, 0x090d0b0e, 0x8bc7adf2, 0xb6a8b92d, 0x1ea9c814, 0xf1198557, 0x75074caf, 0x99ddbbee, 0x7f60fda3, 0x01269ff7, 0x72f5bc5c, 0x663bc544, 0xfb7e345b, 0x4329768b, 0x23c6dccb, 0xedfc68b6, 0xe4f163b8, 0x31dccad7, 0x63851042, 0x97224013, 0xc6112084, 0x4a247d85, 0xbb3df8d2, 0xf93211ae, 0x29a16dc7, 0x9e2f4b1d, 0xb230f3dc, 0x8652ec0d, 0xc1e3d077, 0xb3166c2b, 0x70b999a9, 0x9448fa11, 0xe9642247, 0xfc8cc4a8, 0xf03f1aa0, 0x7d2cd856, 0x3390ef22, 0x494ec787, 0x38d1c1d9, 0xcaa2fe8c, 0xd40b3698, 0xf581cfa6, 0x7ade28a5, 0xb78e26da, 0xadbfa43f, 0x3a9de42c, 0x78920d50, 0x5fcc9b6a, 0x7e466254, 0x8d13c2f6, 0xd8b8e890, 0x39f75e2e, 0xc3aff582, 0x5d80be9f, 0xd0937c69, 0xd52da96f, 0x2512b3cf, 0xac993bc8, 0x187da710, 0x9c636ee8, 0x3bbb7bdb, 0x267809cd, 0x5918f46e, 0x9ab701ec, 0x4f9aa883, 0x956e65e6, 0xffe67eaa, 0xbccf0821, 0x15e8e6ef, 0xe79bd9ba, 0x6f36ce4a, 0x9f09d4ea, 0xb07cd629, 0xa4b2af31, 0x3f23312a, 0xa59430c6, 0xa266c035, 0x4ebc3774, 0x82caa6fc, 0x90d0b0e0, 0xa7d81533, 0x04984af1, 0xecdaf741, 0xcd500e7f, 0x91f62f17, 0x4dd68d76, 0xefb04d43, 0xaa4d54cc, 0x9604dfe4, 0xd1b5e39e, 0x6a881b4c, 0x2c1fb8c1, 0x65517f46, 0x5eea049d, 0x8c355d01, 0x877473fa, 0x0b412efb, 0x671d5ab3, 0xdbd25292, 0x105633e9, 0xd647136d, 0xd7618c9a, 0xa10c7a37, 0xf8148e59, 0x133c89eb, 0xa927eece, 0x61c935b7, 0x1ce5ede1, 0x47b13c7a, 0xd2df599c, 0xf2733f55, 0x14ce7918, 0xc737bf73, 0xf7cdea53, 0xfdaa5b5f, 0x3d6f14df, 0x44db8678, 0xaff381ca, 0x68c43eb9, 0x24342c38, 0xa3405fc2, 0x1dc37216, 0xe2250cbc, 0x3c498b28, 0x0d9541ff, 0xa8017139, 0x0cb3de08, 0xb4e49cd8, 0x56c19064, 0xcb84617b, 0x32b670d5, 0x6c5c7448, 0xb85742d0];\n\n    // Transformations for decryption key expansion\n    var U1 = [0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3];\n    var U2 = [0x00000000, 0x0b0e090d, 0x161c121a, 0x1d121b17, 0x2c382434, 0x27362d39, 0x3a24362e, 0x312a3f23, 0x58704868, 0x537e4165, 0x4e6c5a72, 0x4562537f, 0x74486c5c, 0x7f466551, 0x62547e46, 0x695a774b, 0xb0e090d0, 0xbbee99dd, 0xa6fc82ca, 0xadf28bc7, 0x9cd8b4e4, 0x97d6bde9, 0x8ac4a6fe, 0x81caaff3, 0xe890d8b8, 0xe39ed1b5, 0xfe8ccaa2, 0xf582c3af, 0xc4a8fc8c, 0xcfa6f581, 0xd2b4ee96, 0xd9bae79b, 0x7bdb3bbb, 0x70d532b6, 0x6dc729a1, 0x66c920ac, 0x57e31f8f, 0x5ced1682, 0x41ff0d95, 0x4af10498, 0x23ab73d3, 0x28a57ade, 0x35b761c9, 0x3eb968c4, 0x0f9357e7, 0x049d5eea, 0x198f45fd, 0x12814cf0, 0xcb3bab6b, 0xc035a266, 0xdd27b971, 0xd629b07c, 0xe7038f5f, 0xec0d8652, 0xf11f9d45, 0xfa119448, 0x934be303, 0x9845ea0e, 0x8557f119, 0x8e59f814, 0xbf73c737, 0xb47dce3a, 0xa96fd52d, 0xa261dc20, 0xf6ad766d, 0xfda37f60, 0xe0b16477, 0xebbf6d7a, 0xda955259, 0xd19b5b54, 0xcc894043, 0xc787494e, 0xaedd3e05, 0xa5d33708, 0xb8c12c1f, 0xb3cf2512, 0x82e51a31, 0x89eb133c, 0x94f9082b, 0x9ff70126, 0x464de6bd, 0x4d43efb0, 0x5051f4a7, 0x5b5ffdaa, 0x6a75c289, 0x617bcb84, 0x7c69d093, 0x7767d99e, 0x1e3daed5, 0x1533a7d8, 0x0821bccf, 0x032fb5c2, 0x32058ae1, 0x390b83ec, 0x241998fb, 0x2f1791f6, 0x8d764dd6, 0x867844db, 0x9b6a5fcc, 0x906456c1, 0xa14e69e2, 0xaa4060ef, 0xb7527bf8, 0xbc5c72f5, 0xd50605be, 0xde080cb3, 0xc31a17a4, 0xc8141ea9, 0xf93e218a, 0xf2302887, 0xef223390, 0xe42c3a9d, 0x3d96dd06, 0x3698d40b, 0x2b8acf1c, 0x2084c611, 0x11aef932, 0x1aa0f03f, 0x07b2eb28, 0x0cbce225, 0x65e6956e, 0x6ee89c63, 0x73fa8774, 0x78f48e79, 0x49deb15a, 0x42d0b857, 0x5fc2a340, 0x54ccaa4d, 0xf741ecda, 0xfc4fe5d7, 0xe15dfec0, 0xea53f7cd, 0xdb79c8ee, 0xd077c1e3, 0xcd65daf4, 0xc66bd3f9, 0xaf31a4b2, 0xa43fadbf, 0xb92db6a8, 0xb223bfa5, 0x83098086, 0x8807898b, 0x9515929c, 0x9e1b9b91, 0x47a17c0a, 0x4caf7507, 0x51bd6e10, 0x5ab3671d, 0x6b99583e, 0x60975133, 0x7d854a24, 0x768b4329, 0x1fd13462, 0x14df3d6f, 0x09cd2678, 0x02c32f75, 0x33e91056, 0x38e7195b, 0x25f5024c, 0x2efb0b41, 0x8c9ad761, 0x8794de6c, 0x9a86c57b, 0x9188cc76, 0xa0a2f355, 0xabacfa58, 0xb6bee14f, 0xbdb0e842, 0xd4ea9f09, 0xdfe49604, 0xc2f68d13, 0xc9f8841e, 0xf8d2bb3d, 0xf3dcb230, 0xeecea927, 0xe5c0a02a, 0x3c7a47b1, 0x37744ebc, 0x2a6655ab, 0x21685ca6, 0x10426385, 0x1b4c6a88, 0x065e719f, 0x0d507892, 0x640a0fd9, 0x6f0406d4, 0x72161dc3, 0x791814ce, 0x48322bed, 0x433c22e0, 0x5e2e39f7, 0x552030fa, 0x01ec9ab7, 0x0ae293ba, 0x17f088ad, 0x1cfe81a0, 0x2dd4be83, 0x26dab78e, 0x3bc8ac99, 0x30c6a594, 0x599cd2df, 0x5292dbd2, 0x4f80c0c5, 0x448ec9c8, 0x75a4f6eb, 0x7eaaffe6, 0x63b8e4f1, 0x68b6edfc, 0xb10c0a67, 0xba02036a, 0xa710187d, 0xac1e1170, 0x9d342e53, 0x963a275e, 0x8b283c49, 0x80263544, 0xe97c420f, 0xe2724b02, 0xff605015, 0xf46e5918, 0xc544663b, 0xce4a6f36, 0xd3587421, 0xd8567d2c, 0x7a37a10c, 0x7139a801, 0x6c2bb316, 0x6725ba1b, 0x560f8538, 0x5d018c35, 0x40139722, 0x4b1d9e2f, 0x2247e964, 0x2949e069, 0x345bfb7e, 0x3f55f273, 0x0e7fcd50, 0x0571c45d, 0x1863df4a, 0x136dd647, 0xcad731dc, 0xc1d938d1, 0xdccb23c6, 0xd7c52acb, 0xe6ef15e8, 0xede11ce5, 0xf0f307f2, 0xfbfd0eff, 0x92a779b4, 0x99a970b9, 0x84bb6bae, 0x8fb562a3, 0xbe9f5d80, 0xb591548d, 0xa8834f9a, 0xa38d4697];\n    var U3 = [0x00000000, 0x0d0b0e09, 0x1a161c12, 0x171d121b, 0x342c3824, 0x3927362d, 0x2e3a2436, 0x23312a3f, 0x68587048, 0x65537e41, 0x724e6c5a, 0x7f456253, 0x5c74486c, 0x517f4665, 0x4662547e, 0x4b695a77, 0xd0b0e090, 0xddbbee99, 0xcaa6fc82, 0xc7adf28b, 0xe49cd8b4, 0xe997d6bd, 0xfe8ac4a6, 0xf381caaf, 0xb8e890d8, 0xb5e39ed1, 0xa2fe8cca, 0xaff582c3, 0x8cc4a8fc, 0x81cfa6f5, 0x96d2b4ee, 0x9bd9bae7, 0xbb7bdb3b, 0xb670d532, 0xa16dc729, 0xac66c920, 0x8f57e31f, 0x825ced16, 0x9541ff0d, 0x984af104, 0xd323ab73, 0xde28a57a, 0xc935b761, 0xc43eb968, 0xe70f9357, 0xea049d5e, 0xfd198f45, 0xf012814c, 0x6bcb3bab, 0x66c035a2, 0x71dd27b9, 0x7cd629b0, 0x5fe7038f, 0x52ec0d86, 0x45f11f9d, 0x48fa1194, 0x03934be3, 0x0e9845ea, 0x198557f1, 0x148e59f8, 0x37bf73c7, 0x3ab47dce, 0x2da96fd5, 0x20a261dc, 0x6df6ad76, 0x60fda37f, 0x77e0b164, 0x7aebbf6d, 0x59da9552, 0x54d19b5b, 0x43cc8940, 0x4ec78749, 0x05aedd3e, 0x08a5d337, 0x1fb8c12c, 0x12b3cf25, 0x3182e51a, 0x3c89eb13, 0x2b94f908, 0x269ff701, 0xbd464de6, 0xb04d43ef, 0xa75051f4, 0xaa5b5ffd, 0x896a75c2, 0x84617bcb, 0x937c69d0, 0x9e7767d9, 0xd51e3dae, 0xd81533a7, 0xcf0821bc, 0xc2032fb5, 0xe132058a, 0xec390b83, 0xfb241998, 0xf62f1791, 0xd68d764d, 0xdb867844, 0xcc9b6a5f, 0xc1906456, 0xe2a14e69, 0xefaa4060, 0xf8b7527b, 0xf5bc5c72, 0xbed50605, 0xb3de080c, 0xa4c31a17, 0xa9c8141e, 0x8af93e21, 0x87f23028, 0x90ef2233, 0x9de42c3a, 0x063d96dd, 0x0b3698d4, 0x1c2b8acf, 0x112084c6, 0x3211aef9, 0x3f1aa0f0, 0x2807b2eb, 0x250cbce2, 0x6e65e695, 0x636ee89c, 0x7473fa87, 0x7978f48e, 0x5a49deb1, 0x5742d0b8, 0x405fc2a3, 0x4d54ccaa, 0xdaf741ec, 0xd7fc4fe5, 0xc0e15dfe, 0xcdea53f7, 0xeedb79c8, 0xe3d077c1, 0xf4cd65da, 0xf9c66bd3, 0xb2af31a4, 0xbfa43fad, 0xa8b92db6, 0xa5b223bf, 0x86830980, 0x8b880789, 0x9c951592, 0x919e1b9b, 0x0a47a17c, 0x074caf75, 0x1051bd6e, 0x1d5ab367, 0x3e6b9958, 0x33609751, 0x247d854a, 0x29768b43, 0x621fd134, 0x6f14df3d, 0x7809cd26, 0x7502c32f, 0x5633e910, 0x5b38e719, 0x4c25f502, 0x412efb0b, 0x618c9ad7, 0x6c8794de, 0x7b9a86c5, 0x769188cc, 0x55a0a2f3, 0x58abacfa, 0x4fb6bee1, 0x42bdb0e8, 0x09d4ea9f, 0x04dfe496, 0x13c2f68d, 0x1ec9f884, 0x3df8d2bb, 0x30f3dcb2, 0x27eecea9, 0x2ae5c0a0, 0xb13c7a47, 0xbc37744e, 0xab2a6655, 0xa621685c, 0x85104263, 0x881b4c6a, 0x9f065e71, 0x920d5078, 0xd9640a0f, 0xd46f0406, 0xc372161d, 0xce791814, 0xed48322b, 0xe0433c22, 0xf75e2e39, 0xfa552030, 0xb701ec9a, 0xba0ae293, 0xad17f088, 0xa01cfe81, 0x832dd4be, 0x8e26dab7, 0x993bc8ac, 0x9430c6a5, 0xdf599cd2, 0xd25292db, 0xc54f80c0, 0xc8448ec9, 0xeb75a4f6, 0xe67eaaff, 0xf163b8e4, 0xfc68b6ed, 0x67b10c0a, 0x6aba0203, 0x7da71018, 0x70ac1e11, 0x539d342e, 0x5e963a27, 0x498b283c, 0x44802635, 0x0fe97c42, 0x02e2724b, 0x15ff6050, 0x18f46e59, 0x3bc54466, 0x36ce4a6f, 0x21d35874, 0x2cd8567d, 0x0c7a37a1, 0x017139a8, 0x166c2bb3, 0x1b6725ba, 0x38560f85, 0x355d018c, 0x22401397, 0x2f4b1d9e, 0x642247e9, 0x692949e0, 0x7e345bfb, 0x733f55f2, 0x500e7fcd, 0x5d0571c4, 0x4a1863df, 0x47136dd6, 0xdccad731, 0xd1c1d938, 0xc6dccb23, 0xcbd7c52a, 0xe8e6ef15, 0xe5ede11c, 0xf2f0f307, 0xfffbfd0e, 0xb492a779, 0xb999a970, 0xae84bb6b, 0xa38fb562, 0x80be9f5d, 0x8db59154, 0x9aa8834f, 0x97a38d46];\n    var U4 = [0x00000000, 0x090d0b0e, 0x121a161c, 0x1b171d12, 0x24342c38, 0x2d392736, 0x362e3a24, 0x3f23312a, 0x48685870, 0x4165537e, 0x5a724e6c, 0x537f4562, 0x6c5c7448, 0x65517f46, 0x7e466254, 0x774b695a, 0x90d0b0e0, 0x99ddbbee, 0x82caa6fc, 0x8bc7adf2, 0xb4e49cd8, 0xbde997d6, 0xa6fe8ac4, 0xaff381ca, 0xd8b8e890, 0xd1b5e39e, 0xcaa2fe8c, 0xc3aff582, 0xfc8cc4a8, 0xf581cfa6, 0xee96d2b4, 0xe79bd9ba, 0x3bbb7bdb, 0x32b670d5, 0x29a16dc7, 0x20ac66c9, 0x1f8f57e3, 0x16825ced, 0x0d9541ff, 0x04984af1, 0x73d323ab, 0x7ade28a5, 0x61c935b7, 0x68c43eb9, 0x57e70f93, 0x5eea049d, 0x45fd198f, 0x4cf01281, 0xab6bcb3b, 0xa266c035, 0xb971dd27, 0xb07cd629, 0x8f5fe703, 0x8652ec0d, 0x9d45f11f, 0x9448fa11, 0xe303934b, 0xea0e9845, 0xf1198557, 0xf8148e59, 0xc737bf73, 0xce3ab47d, 0xd52da96f, 0xdc20a261, 0x766df6ad, 0x7f60fda3, 0x6477e0b1, 0x6d7aebbf, 0x5259da95, 0x5b54d19b, 0x4043cc89, 0x494ec787, 0x3e05aedd, 0x3708a5d3, 0x2c1fb8c1, 0x2512b3cf, 0x1a3182e5, 0x133c89eb, 0x082b94f9, 0x01269ff7, 0xe6bd464d, 0xefb04d43, 0xf4a75051, 0xfdaa5b5f, 0xc2896a75, 0xcb84617b, 0xd0937c69, 0xd99e7767, 0xaed51e3d, 0xa7d81533, 0xbccf0821, 0xb5c2032f, 0x8ae13205, 0x83ec390b, 0x98fb2419, 0x91f62f17, 0x4dd68d76, 0x44db8678, 0x5fcc9b6a, 0x56c19064, 0x69e2a14e, 0x60efaa40, 0x7bf8b752, 0x72f5bc5c, 0x05bed506, 0x0cb3de08, 0x17a4c31a, 0x1ea9c814, 0x218af93e, 0x2887f230, 0x3390ef22, 0x3a9de42c, 0xdd063d96, 0xd40b3698, 0xcf1c2b8a, 0xc6112084, 0xf93211ae, 0xf03f1aa0, 0xeb2807b2, 0xe2250cbc, 0x956e65e6, 0x9c636ee8, 0x877473fa, 0x8e7978f4, 0xb15a49de, 0xb85742d0, 0xa3405fc2, 0xaa4d54cc, 0xecdaf741, 0xe5d7fc4f, 0xfec0e15d, 0xf7cdea53, 0xc8eedb79, 0xc1e3d077, 0xdaf4cd65, 0xd3f9c66b, 0xa4b2af31, 0xadbfa43f, 0xb6a8b92d, 0xbfa5b223, 0x80868309, 0x898b8807, 0x929c9515, 0x9b919e1b, 0x7c0a47a1, 0x75074caf, 0x6e1051bd, 0x671d5ab3, 0x583e6b99, 0x51336097, 0x4a247d85, 0x4329768b, 0x34621fd1, 0x3d6f14df, 0x267809cd, 0x2f7502c3, 0x105633e9, 0x195b38e7, 0x024c25f5, 0x0b412efb, 0xd7618c9a, 0xde6c8794, 0xc57b9a86, 0xcc769188, 0xf355a0a2, 0xfa58abac, 0xe14fb6be, 0xe842bdb0, 0x9f09d4ea, 0x9604dfe4, 0x8d13c2f6, 0x841ec9f8, 0xbb3df8d2, 0xb230f3dc, 0xa927eece, 0xa02ae5c0, 0x47b13c7a, 0x4ebc3774, 0x55ab2a66, 0x5ca62168, 0x63851042, 0x6a881b4c, 0x719f065e, 0x78920d50, 0x0fd9640a, 0x06d46f04, 0x1dc37216, 0x14ce7918, 0x2bed4832, 0x22e0433c, 0x39f75e2e, 0x30fa5520, 0x9ab701ec, 0x93ba0ae2, 0x88ad17f0, 0x81a01cfe, 0xbe832dd4, 0xb78e26da, 0xac993bc8, 0xa59430c6, 0xd2df599c, 0xdbd25292, 0xc0c54f80, 0xc9c8448e, 0xf6eb75a4, 0xffe67eaa, 0xe4f163b8, 0xedfc68b6, 0x0a67b10c, 0x036aba02, 0x187da710, 0x1170ac1e, 0x2e539d34, 0x275e963a, 0x3c498b28, 0x35448026, 0x420fe97c, 0x4b02e272, 0x5015ff60, 0x5918f46e, 0x663bc544, 0x6f36ce4a, 0x7421d358, 0x7d2cd856, 0xa10c7a37, 0xa8017139, 0xb3166c2b, 0xba1b6725, 0x8538560f, 0x8c355d01, 0x97224013, 0x9e2f4b1d, 0xe9642247, 0xe0692949, 0xfb7e345b, 0xf2733f55, 0xcd500e7f, 0xc45d0571, 0xdf4a1863, 0xd647136d, 0x31dccad7, 0x38d1c1d9, 0x23c6dccb, 0x2acbd7c5, 0x15e8e6ef, 0x1ce5ede1, 0x07f2f0f3, 0x0efffbfd, 0x79b492a7, 0x70b999a9, 0x6bae84bb, 0x62a38fb5, 0x5d80be9f, 0x548db591, 0x4f9aa883, 0x4697a38d];\n\n    function convertToInt32(bytes) {\n        var result = [];\n        for (var i = 0; i < bytes.length; i += 4) {\n            result.push(\n                (bytes[i    ] << 24) |\n                (bytes[i + 1] << 16) |\n                (bytes[i + 2] <<  8) |\n                 bytes[i + 3]\n            );\n        }\n        return result;\n    }\n\n    var AES = function(key) {\n        if (!(this instanceof AES)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n\n        Object.defineProperty(this, 'key', {\n            value: coerceArray(key, true)\n        });\n\n        this._prepare();\n    }\n\n\n    AES.prototype._prepare = function() {\n\n        var rounds = numberOfRounds[this.key.length];\n        if (rounds == null) {\n            throw new Error('invalid key size (must be 16, 24 or 32 bytes)');\n        }\n\n        // encryption round keys\n        this._Ke = [];\n\n        // decryption round keys\n        this._Kd = [];\n\n        for (var i = 0; i <= rounds; i++) {\n            this._Ke.push([0, 0, 0, 0]);\n            this._Kd.push([0, 0, 0, 0]);\n        }\n\n        var roundKeyCount = (rounds + 1) * 4;\n        var KC = this.key.length / 4;\n\n        // convert the key into ints\n        var tk = convertToInt32(this.key);\n\n        // copy values into round key arrays\n        var index;\n        for (var i = 0; i < KC; i++) {\n            index = i >> 2;\n            this._Ke[index][i % 4] = tk[i];\n            this._Kd[rounds - index][i % 4] = tk[i];\n        }\n\n        // key expansion (fips-197 section 5.2)\n        var rconpointer = 0;\n        var t = KC, tt;\n        while (t < roundKeyCount) {\n            tt = tk[KC - 1];\n            tk[0] ^= ((S[(tt >> 16) & 0xFF] << 24) ^\n                      (S[(tt >>  8) & 0xFF] << 16) ^\n                      (S[ tt        & 0xFF] <<  8) ^\n                       S[(tt >> 24) & 0xFF]        ^\n                      (rcon[rconpointer] << 24));\n            rconpointer += 1;\n\n            // key expansion (for non-256 bit)\n            if (KC != 8) {\n                for (var i = 1; i < KC; i++) {\n                    tk[i] ^= tk[i - 1];\n                }\n\n            // key expansion for 256-bit keys is \"slightly different\" (fips-197)\n            } else {\n                for (var i = 1; i < (KC / 2); i++) {\n                    tk[i] ^= tk[i - 1];\n                }\n                tt = tk[(KC / 2) - 1];\n\n                tk[KC / 2] ^= (S[ tt        & 0xFF]        ^\n                              (S[(tt >>  8) & 0xFF] <<  8) ^\n                              (S[(tt >> 16) & 0xFF] << 16) ^\n                              (S[(tt >> 24) & 0xFF] << 24));\n\n                for (var i = (KC / 2) + 1; i < KC; i++) {\n                    tk[i] ^= tk[i - 1];\n                }\n            }\n\n            // copy values into round key arrays\n            var i = 0, r, c;\n            while (i < KC && t < roundKeyCount) {\n                r = t >> 2;\n                c = t % 4;\n                this._Ke[r][c] = tk[i];\n                this._Kd[rounds - r][c] = tk[i++];\n                t++;\n            }\n        }\n\n        // inverse-cipher-ify the decryption round key (fips-197 section 5.3)\n        for (var r = 1; r < rounds; r++) {\n            for (var c = 0; c < 4; c++) {\n                tt = this._Kd[r][c];\n                this._Kd[r][c] = (U1[(tt >> 24) & 0xFF] ^\n                                  U2[(tt >> 16) & 0xFF] ^\n                                  U3[(tt >>  8) & 0xFF] ^\n                                  U4[ tt        & 0xFF]);\n            }\n        }\n    }\n\n    AES.prototype.encrypt = function(plaintext) {\n        if (plaintext.length != 16) {\n            throw new Error('invalid plaintext size (must be 16 bytes)');\n        }\n\n        var rounds = this._Ke.length - 1;\n        var a = [0, 0, 0, 0];\n\n        // convert plaintext to (ints ^ key)\n        var t = convertToInt32(plaintext);\n        for (var i = 0; i < 4; i++) {\n            t[i] ^= this._Ke[0][i];\n        }\n\n        // apply round transforms\n        for (var r = 1; r < rounds; r++) {\n            for (var i = 0; i < 4; i++) {\n                a[i] = (T1[(t[ i         ] >> 24) & 0xff] ^\n                        T2[(t[(i + 1) % 4] >> 16) & 0xff] ^\n                        T3[(t[(i + 2) % 4] >>  8) & 0xff] ^\n                        T4[ t[(i + 3) % 4]        & 0xff] ^\n                        this._Ke[r][i]);\n            }\n            t = a.slice();\n        }\n\n        // the last round is special\n        var result = createArray(16), tt;\n        for (var i = 0; i < 4; i++) {\n            tt = this._Ke[rounds][i];\n            result[4 * i    ] = (S[(t[ i         ] >> 24) & 0xff] ^ (tt >> 24)) & 0xff;\n            result[4 * i + 1] = (S[(t[(i + 1) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff;\n            result[4 * i + 2] = (S[(t[(i + 2) % 4] >>  8) & 0xff] ^ (tt >>  8)) & 0xff;\n            result[4 * i + 3] = (S[ t[(i + 3) % 4]        & 0xff] ^  tt       ) & 0xff;\n        }\n\n        return result;\n    }\n\n    AES.prototype.decrypt = function(ciphertext) {\n        if (ciphertext.length != 16) {\n            throw new Error('invalid ciphertext size (must be 16 bytes)');\n        }\n\n        var rounds = this._Kd.length - 1;\n        var a = [0, 0, 0, 0];\n\n        // convert plaintext to (ints ^ key)\n        var t = convertToInt32(ciphertext);\n        for (var i = 0; i < 4; i++) {\n            t[i] ^= this._Kd[0][i];\n        }\n\n        // apply round transforms\n        for (var r = 1; r < rounds; r++) {\n            for (var i = 0; i < 4; i++) {\n                a[i] = (T5[(t[ i          ] >> 24) & 0xff] ^\n                        T6[(t[(i + 3) % 4] >> 16) & 0xff] ^\n                        T7[(t[(i + 2) % 4] >>  8) & 0xff] ^\n                        T8[ t[(i + 1) % 4]        & 0xff] ^\n                        this._Kd[r][i]);\n            }\n            t = a.slice();\n        }\n\n        // the last round is special\n        var result = createArray(16), tt;\n        for (var i = 0; i < 4; i++) {\n            tt = this._Kd[rounds][i];\n            result[4 * i    ] = (Si[(t[ i         ] >> 24) & 0xff] ^ (tt >> 24)) & 0xff;\n            result[4 * i + 1] = (Si[(t[(i + 3) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff;\n            result[4 * i + 2] = (Si[(t[(i + 2) % 4] >>  8) & 0xff] ^ (tt >>  8)) & 0xff;\n            result[4 * i + 3] = (Si[ t[(i + 1) % 4]        & 0xff] ^  tt       ) & 0xff;\n        }\n\n        return result;\n    }\n\n\n    /**\n     *  Mode Of Operation - Electonic Codebook (ECB)\n     */\n    var ModeOfOperationECB = function(key) {\n        if (!(this instanceof ModeOfOperationECB)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n\n        this.description = \"Electronic Code Block\";\n        this.name = \"ecb\";\n\n        this._aes = new AES(key);\n    }\n\n    ModeOfOperationECB.prototype.encrypt = function(plaintext) {\n        plaintext = coerceArray(plaintext);\n\n        if ((plaintext.length % 16) !== 0) {\n            throw new Error('invalid plaintext size (must be multiple of 16 bytes)');\n        }\n\n        var ciphertext = createArray(plaintext.length);\n        var block = createArray(16);\n\n        for (var i = 0; i < plaintext.length; i += 16) {\n            copyArray(plaintext, block, 0, i, i + 16);\n            block = this._aes.encrypt(block);\n            copyArray(block, ciphertext, i);\n        }\n\n        return ciphertext;\n    }\n\n    ModeOfOperationECB.prototype.decrypt = function(ciphertext) {\n        ciphertext = coerceArray(ciphertext);\n\n        if ((ciphertext.length % 16) !== 0) {\n            throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');\n        }\n\n        var plaintext = createArray(ciphertext.length);\n        var block = createArray(16);\n\n        for (var i = 0; i < ciphertext.length; i += 16) {\n            copyArray(ciphertext, block, 0, i, i + 16);\n            block = this._aes.decrypt(block);\n            copyArray(block, plaintext, i);\n        }\n\n        return plaintext;\n    }\n\n\n    /**\n     *  Mode Of Operation - Cipher Block Chaining (CBC)\n     */\n    var ModeOfOperationCBC = function(key, iv) {\n        if (!(this instanceof ModeOfOperationCBC)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n\n        this.description = \"Cipher Block Chaining\";\n        this.name = \"cbc\";\n\n        if (!iv) {\n            iv = createArray(16);\n\n        } else if (iv.length != 16) {\n            throw new Error('invalid initialation vector size (must be 16 bytes)');\n        }\n\n        this._lastCipherblock = coerceArray(iv, true);\n\n        this._aes = new AES(key);\n    }\n\n    ModeOfOperationCBC.prototype.encrypt = function(plaintext) {\n        plaintext = coerceArray(plaintext);\n\n        if ((plaintext.length % 16) !== 0) {\n            throw new Error('invalid plaintext size (must be multiple of 16 bytes)');\n        }\n\n        var ciphertext = createArray(plaintext.length);\n        var block = createArray(16);\n\n        for (var i = 0; i < plaintext.length; i += 16) {\n            copyArray(plaintext, block, 0, i, i + 16);\n\n            for (var j = 0; j < 16; j++) {\n                block[j] ^= this._lastCipherblock[j];\n            }\n\n            this._lastCipherblock = this._aes.encrypt(block);\n            copyArray(this._lastCipherblock, ciphertext, i);\n        }\n\n        return ciphertext;\n    }\n\n    ModeOfOperationCBC.prototype.decrypt = function(ciphertext) {\n        ciphertext = coerceArray(ciphertext);\n\n        if ((ciphertext.length % 16) !== 0) {\n            throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');\n        }\n\n        var plaintext = createArray(ciphertext.length);\n        var block = createArray(16);\n\n        for (var i = 0; i < ciphertext.length; i += 16) {\n            copyArray(ciphertext, block, 0, i, i + 16);\n            block = this._aes.decrypt(block);\n\n            for (var j = 0; j < 16; j++) {\n                plaintext[i + j] = block[j] ^ this._lastCipherblock[j];\n            }\n\n            copyArray(ciphertext, this._lastCipherblock, 0, i, i + 16);\n        }\n\n        return plaintext;\n    }\n\n\n    /**\n     *  Mode Of Operation - Cipher Feedback (CFB)\n     */\n    var ModeOfOperationCFB = function(key, iv, segmentSize) {\n        if (!(this instanceof ModeOfOperationCFB)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n\n        this.description = \"Cipher Feedback\";\n        this.name = \"cfb\";\n\n        if (!iv) {\n            iv = createArray(16);\n\n        } else if (iv.length != 16) {\n            throw new Error('invalid initialation vector size (must be 16 size)');\n        }\n\n        if (!segmentSize) { segmentSize = 1; }\n\n        this.segmentSize = segmentSize;\n\n        this._shiftRegister = coerceArray(iv, true);\n\n        this._aes = new AES(key);\n    }\n\n    ModeOfOperationCFB.prototype.encrypt = function(plaintext) {\n        if ((plaintext.length % this.segmentSize) != 0) {\n            throw new Error('invalid plaintext size (must be segmentSize bytes)');\n        }\n\n        var encrypted = coerceArray(plaintext, true);\n\n        var xorSegment;\n        for (var i = 0; i < encrypted.length; i += this.segmentSize) {\n            xorSegment = this._aes.encrypt(this._shiftRegister);\n            for (var j = 0; j < this.segmentSize; j++) {\n                encrypted[i + j] ^= xorSegment[j];\n            }\n\n            // Shift the register\n            copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize);\n            copyArray(encrypted, this._shiftRegister, 16 - this.segmentSize, i, i + this.segmentSize);\n        }\n\n        return encrypted;\n    }\n\n    ModeOfOperationCFB.prototype.decrypt = function(ciphertext) {\n        if ((ciphertext.length % this.segmentSize) != 0) {\n            throw new Error('invalid ciphertext size (must be segmentSize bytes)');\n        }\n\n        var plaintext = coerceArray(ciphertext, true);\n\n        var xorSegment;\n        for (var i = 0; i < plaintext.length; i += this.segmentSize) {\n            xorSegment = this._aes.encrypt(this._shiftRegister);\n\n            for (var j = 0; j < this.segmentSize; j++) {\n                plaintext[i + j] ^= xorSegment[j];\n            }\n\n            // Shift the register\n            copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize);\n            copyArray(ciphertext, this._shiftRegister, 16 - this.segmentSize, i, i + this.segmentSize);\n        }\n\n        return plaintext;\n    }\n\n    /**\n     *  Mode Of Operation - Output Feedback (OFB)\n     */\n    var ModeOfOperationOFB = function(key, iv) {\n        if (!(this instanceof ModeOfOperationOFB)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n\n        this.description = \"Output Feedback\";\n        this.name = \"ofb\";\n\n        if (!iv) {\n            iv = createArray(16);\n\n        } else if (iv.length != 16) {\n            throw new Error('invalid initialation vector size (must be 16 bytes)');\n        }\n\n        this._lastPrecipher = coerceArray(iv, true);\n        this._lastPrecipherIndex = 16;\n\n        this._aes = new AES(key);\n    }\n\n    ModeOfOperationOFB.prototype.encrypt = function(plaintext) {\n        var encrypted = coerceArray(plaintext, true);\n\n        for (var i = 0; i < encrypted.length; i++) {\n            if (this._lastPrecipherIndex === 16) {\n                this._lastPrecipher = this._aes.encrypt(this._lastPrecipher);\n                this._lastPrecipherIndex = 0;\n            }\n            encrypted[i] ^= this._lastPrecipher[this._lastPrecipherIndex++];\n        }\n\n        return encrypted;\n    }\n\n    // Decryption is symetric\n    ModeOfOperationOFB.prototype.decrypt = ModeOfOperationOFB.prototype.encrypt;\n\n\n    /**\n     *  Counter object for CTR common mode of operation\n     */\n    var Counter = function(initialValue) {\n        if (!(this instanceof Counter)) {\n            throw Error('Counter must be instanitated with `new`');\n        }\n\n        // We allow 0, but anything false-ish uses the default 1\n        if (initialValue !== 0 && !initialValue) { initialValue = 1; }\n\n        if (typeof(initialValue) === 'number') {\n            this._counter = createArray(16);\n            this.setValue(initialValue);\n\n        } else {\n            this.setBytes(initialValue);\n        }\n    }\n\n    Counter.prototype.setValue = function(value) {\n        if (typeof(value) !== 'number' || parseInt(value) != value) {\n            throw new Error('invalid counter value (must be an integer)');\n        }\n\n        // We cannot safely handle numbers beyond the safe range for integers\n        if (value > Number.MAX_SAFE_INTEGER) {\n            throw new Error('integer value out of safe range');\n        }\n\n        for (var index = 15; index >= 0; --index) {\n            this._counter[index] = value % 256;\n            value = parseInt(value / 256);\n        }\n    }\n\n    Counter.prototype.setBytes = function(bytes) {\n        bytes = coerceArray(bytes, true);\n\n        if (bytes.length != 16) {\n            throw new Error('invalid counter bytes size (must be 16 bytes)');\n        }\n\n        this._counter = bytes;\n    };\n\n    Counter.prototype.increment = function() {\n        for (var i = 15; i >= 0; i--) {\n            if (this._counter[i] === 255) {\n                this._counter[i] = 0;\n            } else {\n                this._counter[i]++;\n                break;\n            }\n        }\n    }\n\n\n    /**\n     *  Mode Of Operation - Counter (CTR)\n     */\n    var ModeOfOperationCTR = function(key, counter) {\n        if (!(this instanceof ModeOfOperationCTR)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n\n        this.description = \"Counter\";\n        this.name = \"ctr\";\n\n        if (!(counter instanceof Counter)) {\n            counter = new Counter(counter)\n        }\n\n        this._counter = counter;\n\n        this._remainingCounter = null;\n        this._remainingCounterIndex = 16;\n\n        this._aes = new AES(key);\n    }\n\n    ModeOfOperationCTR.prototype.encrypt = function(plaintext) {\n        var encrypted = coerceArray(plaintext, true);\n\n        for (var i = 0; i < encrypted.length; i++) {\n            if (this._remainingCounterIndex === 16) {\n                this._remainingCounter = this._aes.encrypt(this._counter._counter);\n                this._remainingCounterIndex = 0;\n                this._counter.increment();\n            }\n            encrypted[i] ^= this._remainingCounter[this._remainingCounterIndex++];\n        }\n\n        return encrypted;\n    }\n\n    // Decryption is symetric\n    ModeOfOperationCTR.prototype.decrypt = ModeOfOperationCTR.prototype.encrypt;\n\n\n    ///////////////////////\n    // Padding\n\n    // See:https://tools.ietf.org/html/rfc2315\n    function pkcs7pad(data) {\n        data = coerceArray(data, true);\n        var padder = 16 - (data.length % 16);\n        var result = createArray(data.length + padder);\n        copyArray(data, result);\n        for (var i = data.length; i < result.length; i++) {\n            result[i] = padder;\n        }\n        return result;\n    }\n\n    function pkcs7strip(data) {\n        data = coerceArray(data, true);\n        if (data.length < 16) { throw new Error('PKCS#7 invalid length'); }\n\n        var padder = data[data.length - 1];\n        if (padder > 16) { throw new Error('PKCS#7 padding byte out of range'); }\n\n        var length = data.length - padder;\n        for (var i = 0; i < padder; i++) {\n            if (data[length + i] !== padder) {\n                throw new Error('PKCS#7 invalid padding byte');\n            }\n        }\n\n        var result = createArray(length);\n        copyArray(data, result, 0, 0, length);\n        return result;\n    }\n\n    ///////////////////////\n    // Exporting\n\n\n    // The block cipher\n    var aesjs = {\n        AES: AES,\n        Counter: Counter,\n\n        ModeOfOperation: {\n            ecb: ModeOfOperationECB,\n            cbc: ModeOfOperationCBC,\n            cfb: ModeOfOperationCFB,\n            ofb: ModeOfOperationOFB,\n            ctr: ModeOfOperationCTR\n        },\n\n        utils: {\n            hex: convertHex,\n            utf8: convertUtf8\n        },\n\n        padding: {\n            pkcs7: {\n                pad: pkcs7pad,\n                strip: pkcs7strip\n            }\n        },\n\n        _arrayTest: {\n            coerceArray: coerceArray,\n            createArray: createArray,\n            copyArray: copyArray,\n        }\n    };\n\n\n    // node.js\n    if (typeof exports !== 'undefined') {\n        module.exports = aesjs\n\n    // RequireJS/AMD\n    // http://www.requirejs.org/docs/api.html\n    // https://github.com/amdjs/amdjs-api/wiki/AMD\n    } else if (typeof(define) === 'function' && define.amd) {\n        define([], function() { return aesjs; });\n\n    // Web Browsers\n    } else {\n\n        // If there was an existing library at \"aesjs\" make sure it's still available\n        if (root.aesjs) {\n            aesjs._aesjs = root.aesjs;\n        }\n\n        root.aesjs = aesjs;\n    }\n\n\n})(this);\n","/**\n * Internal assertion helpers.\n * @module\n */\n/** Asserts something is positive integer. */\nfunction anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Is number an Uint8Array? Copied from utils for perf. */\nfunction isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is Uint8Array. */\nfunction abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n/** Asserts something is hash */\nfunction ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nfunction aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nfunction aoutput(out, instance) {\n    abytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('digestInto() expects output buffer of length at least ' + min);\n    }\n}\nexport { anumber, abytes, ahash, aexists, aoutput };\n//# sourceMappingURL=_assert.js.map","export const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nimport { abytes } from './_assert.js';\n// export { isBytes } from './_assert.js';\n// We can't reuse isBytes from _assert, because somehow this causes huge perf issues\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n// Cast array to different type\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n// Cast array to view\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n// The byte swap operation for uint32\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const byteSwapIfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n}\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * Convert JS string to byte array.\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('utf8ToBytes expected string, got ' + typeof str);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n/** For runtime check if class implements interface */\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** Wraps hash function, creating an interface on top of it */\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return crypto.randomBytes(bytesLength);\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { aexists, aoutput } from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        const { view, buffer, blockLen } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\n//# sourceMappingURL=_md.js.map","/**\n * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.\n *\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n *\n * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj } from './_md.js';\nimport { rotr, wrapConstructor } from './utils.js';\n/** Round constants: first 32 bits of fractional parts of the cube roots of the first 64 primes 2..311). */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ new Uint32Array([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Initial state: first 32 bits of fractional parts of the square roots of the first 8 primes 2..19. */\n// prettier-ignore\nconst SHA256_IV = /* @__PURE__ */ new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n/**\n * Temporary buffer, not used to store anything between runs.\n * Named this way because it matches specification.\n */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor() {\n        super(64, 32, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n/**\n * Constants taken from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf.\n */\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/** SHA2-256 hash function */\nexport const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());\n/** SHA2-224 hash function */\nexport const sha224 = /* @__PURE__ */ wrapConstructor(() => new SHA224());\n//# sourceMappingURL=sha256.js.map","/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\nexport function abytes(item) {\n    if (!isBytes(item))\n        throw new Error('Uint8Array expected');\n}\nexport function abool(title, value) {\n    if (typeof value !== 'boolean')\n        throw new Error(title + ' boolean expected, got ' + value);\n}\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? '0' + hex : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    abytes(bytes);\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n        }\n    }\n    else if (isBytes(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(title + ' must be hex string or Uint8Array');\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Is positive bigint\nconst isPosBig = (n) => typeof n === 'bigint' && _0n <= n;\nexport function inRange(n, min, max) {\n    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title, n, min, max) {\n    // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n    // consider P=256n, min=0n, max=P\n    // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n    // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n    // - our way is the cleanest:               `inRange('x', x, 0n, P)\n    if (!inRange(n, min, max))\n        throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n, pos, value) {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;\n// DRBG\nconst u8n = (data) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n()) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error('invalid validator function');\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n/**\n * throws not implemented error\n */\nexport const notImplemented = () => {\n    throw new Error('not implemented');\n};\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized(fn) {\n    const map = new WeakMap();\n    return (arg, ...args) => {\n        const val = map.get(arg);\n        if (val !== undefined)\n            return val;\n        const computed = fn(arg, ...args);\n        map.set(arg, computed);\n        return computed;\n    };\n}\n//# sourceMappingURL=utils.js.map","/**\n * Utils for modular division and finite fields.\n * A finite field over 11 is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { bitMask, bytesToNumberBE, bytesToNumberLE, ensureBytes, numberToBytesBE, numberToBytesLE, validateObject, } from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);\n// prettier-ignore\nconst _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);\n// prettier-ignore\nconst _9n = /* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @todo use field version && remove\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num, power, modulo) {\n    if (power < _0n)\n        throw new Error('invalid exponent, negatives unsupported');\n    if (modulo <= _0n)\n        throw new Error('invalid modulus');\n    if (modulo === _1n)\n        return _0n;\n    let res = _1n;\n    while (power > _0n) {\n        if (power & _1n)\n            res = (res * num) % modulo;\n        num = (num * num) % modulo;\n        power >>= _1n;\n    }\n    return res;\n}\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number, modulo) {\n    if (number === _0n)\n        throw new Error('invert: expected non-zero number');\n    if (modulo <= _0n)\n        throw new Error('invert: expected positive modulus, got ' + modulo);\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Legendre constant: used to calculate Legendre symbol (a | p),\n    // which denotes the value of a^((p-1)/2) (mod p).\n    // (a | p) ≡ 1    if a is a square (mod p)\n    // (a | p) ≡ -1   if a is not a square (mod p)\n    // (a | p) ≡ 0    if a ≡ 0 (mod p)\n    const legendreC = (P - _1n) / _2n;\n    let Q, S, Z;\n    // Step 1: By factoring out powers of 2 from p - 1,\n    // find q and s such that p - 1 = q*(2^s) with q odd\n    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)\n        ;\n    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++) {\n        // Crash instead of infinity loop, we cannot reasonable count until P.\n        if (Z > 1000)\n            throw new Error('Cannot find square root: likely non-prime P');\n    }\n    // Fast-path\n    if (S === 1) {\n        const p1div4 = (P + _1n) / _4n;\n        return function tonelliFast(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Slow-path\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))\n            throw new Error('Cannot find square root');\n        let r = S;\n        // TODO: will fail at Fp2/etc\n        let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n        let x = Fp.pow(n, Q1div2); // first guess at the square root\n        let b = Fp.pow(n, Q); // first guess at the fudge factor\n        while (!Fp.eql(b, Fp.ONE)) {\n            if (Fp.eql(b, Fp.ZERO))\n                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n            // Find m such b^(2^m)==1\n            let m = 1;\n            for (let t2 = Fp.sqr(b); m < r; m++) {\n                if (Fp.eql(t2, Fp.ONE))\n                    break;\n                t2 = Fp.sqr(t2); // t2 *= t2\n            }\n            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n            const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n            g = Fp.sqr(ge); // g = ge * ge\n            x = Fp.mul(x, ge); // x *= ge\n            b = Fp.mul(b, g); // b *= g\n            r = m;\n        }\n        return x;\n    };\n}\n/**\n * Square root for a finite field. It will try to check if optimizations are applicable and fall back to 4:\n *\n * 1. P ≡ 3 (mod 4)\n * 2. P ≡ 5 (mod 8)\n * 3. P ≡ 9 (mod 16)\n * 4. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P) {\n    // P ≡ 3 (mod 4)\n    // √n = n^((P+1)/4)\n    if (P % _4n === _3n) {\n        // Not all roots possible!\n        // const ORDER =\n        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n        // const NUM = 72057594037927816n;\n        const p1div4 = (P + _1n) / _4n;\n        return function sqrt3mod4(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            // Throw if root**2 != n\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n    if (P % _8n === _5n) {\n        const c1 = (P - _5n) / _8n;\n        return function sqrt5mod8(Fp, n) {\n            const n2 = Fp.mul(n, _2n);\n            const v = Fp.pow(n2, c1);\n            const nv = Fp.mul(n, v);\n            const i = Fp.mul(Fp.mul(nv, _2n), v);\n            const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // P ≡ 9 (mod 16)\n    if (P % _16n === _9n) {\n        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n        // Means we cannot use sqrt for constants at all!\n        //\n        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n        // sqrt = (x) => {\n        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n        // }\n    }\n    // Other cases: Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(f, num, power) {\n    // Should have same speed as pow for bigints\n    // TODO: benchmark!\n    if (power < _0n)\n        throw new Error('invalid exponent, negatives unsupported');\n    if (power === _0n)\n        return f.ONE;\n    if (power === _1n)\n        return num;\n    let p = f.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = f.mul(p, d);\n        d = f.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch(f, nums) {\n    const tmp = new Array(nums.length);\n    // Walk from first to last, multiply them by each other MOD p\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = acc;\n        return f.mul(acc, num);\n    }, f.ONE);\n    // Invert last element\n    const inverted = f.inv(lastMultiplied);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = f.mul(acc, tmp[i]);\n        return f.mul(acc, num);\n    }, inverted);\n    return tmp;\n}\nexport function FpDiv(f, lhs, rhs) {\n    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n/**\n * Legendre symbol.\n * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue\n * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue\n * * (a | p) ≡ 0    if a ≡ 0 (mod p)\n */\nexport function FpLegendre(order) {\n    const legendreConst = (order - _1n) / _2n; // Integer arithmetic\n    return (f, x) => f.pow(x, legendreConst);\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(f) {\n    const legendre = FpLegendre(f.ORDER);\n    return (x) => {\n        const p = legendre(f, x);\n        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n    };\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n    let sqrtP; // cached sqrtP\n    const f = Object.freeze({\n        ORDER,\n        isLE,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error('invalid field element: expected bigint, got ' + typeof num);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt ||\n            ((n) => {\n                if (!sqrtP)\n                    sqrtP = FpSqrt(ORDER);\n                return sqrtP(f, n);\n            }),\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // TODO: do we really need constant cmov?\n        // We don't have const-time bigints anyway, so probably will be not very useful\n        cmov: (a, b, c) => (c ? b : a),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(\"Field doesn't have isOdd\");\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use `mapKeyToField` instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error('hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n    const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","import { mod } from './modular.js';\nimport { abytes, bytesToNumberBE, concatBytes, utf8ToBytes, validateObject } from './utils.js';\n// Octet Stream to Integer. \"spec\" implementation of os2ip is 2.5x slower vs bytesToNumberBE.\nconst os2ip = bytesToNumberBE;\n// Integer to Octet Stream (numberToBytesBE)\nfunction i2osp(value, length) {\n    anum(value);\n    anum(length);\n    if (value < 0 || value >= 1 << (8 * length))\n        throw new Error('invalid I2OSP input: ' + value);\n    const res = Array.from({ length }).fill(0);\n    for (let i = length - 1; i >= 0; i--) {\n        res[i] = value & 0xff;\n        value >>>= 8;\n    }\n    return new Uint8Array(res);\n}\nfunction strxor(a, b) {\n    const arr = new Uint8Array(a.length);\n    for (let i = 0; i < a.length; i++) {\n        arr[i] = a[i] ^ b[i];\n    }\n    return arr;\n}\nfunction anum(item) {\n    if (!Number.isSafeInteger(item))\n        throw new Error('number expected');\n}\n/**\n * Produces a uniformly random byte string using a cryptographic hash function H that outputs b bits.\n * [RFC 9380 5.3.1](https://www.rfc-editor.org/rfc/rfc9380#section-5.3.1).\n */\nexport function expand_message_xmd(msg, DST, lenInBytes, H) {\n    abytes(msg);\n    abytes(DST);\n    anum(lenInBytes);\n    // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3\n    if (DST.length > 255)\n        DST = H(concatBytes(utf8ToBytes('H2C-OVERSIZE-DST-'), DST));\n    const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;\n    const ell = Math.ceil(lenInBytes / b_in_bytes);\n    if (lenInBytes > 65535 || ell > 255)\n        throw new Error('expand_message_xmd: invalid lenInBytes');\n    const DST_prime = concatBytes(DST, i2osp(DST.length, 1));\n    const Z_pad = i2osp(0, r_in_bytes);\n    const l_i_b_str = i2osp(lenInBytes, 2); // len_in_bytes_str\n    const b = new Array(ell);\n    const b_0 = H(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));\n    b[0] = H(concatBytes(b_0, i2osp(1, 1), DST_prime));\n    for (let i = 1; i <= ell; i++) {\n        const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];\n        b[i] = H(concatBytes(...args));\n    }\n    const pseudo_random_bytes = concatBytes(...b);\n    return pseudo_random_bytes.slice(0, lenInBytes);\n}\n/**\n * Produces a uniformly random byte string using an extendable-output function (XOF) H.\n * 1. The collision resistance of H MUST be at least k bits.\n * 2. H MUST be an XOF that has been proved indifferentiable from\n *    a random oracle under a reasonable cryptographic assumption.\n * [RFC 9380 5.3.2](https://www.rfc-editor.org/rfc/rfc9380#section-5.3.2).\n */\nexport function expand_message_xof(msg, DST, lenInBytes, k, H) {\n    abytes(msg);\n    abytes(DST);\n    anum(lenInBytes);\n    // https://www.rfc-editor.org/rfc/rfc9380#section-5.3.3\n    // DST = H('H2C-OVERSIZE-DST-' || a_very_long_DST, Math.ceil((lenInBytes * k) / 8));\n    if (DST.length > 255) {\n        const dkLen = Math.ceil((2 * k) / 8);\n        DST = H.create({ dkLen }).update(utf8ToBytes('H2C-OVERSIZE-DST-')).update(DST).digest();\n    }\n    if (lenInBytes > 65535 || DST.length > 255)\n        throw new Error('expand_message_xof: invalid lenInBytes');\n    return (H.create({ dkLen: lenInBytes })\n        .update(msg)\n        .update(i2osp(lenInBytes, 2))\n        // 2. DST_prime = DST || I2OSP(len(DST), 1)\n        .update(DST)\n        .update(i2osp(DST.length, 1))\n        .digest());\n}\n/**\n * Hashes arbitrary-length byte strings to a list of one or more elements of a finite field F.\n * [RFC 9380 5.2](https://www.rfc-editor.org/rfc/rfc9380#section-5.2).\n * @param msg a byte string containing the message to hash\n * @param count the number of elements of F to output\n * @param options `{DST: string, p: bigint, m: number, k: number, expand: 'xmd' | 'xof', hash: H}`, see above\n * @returns [u_0, ..., u_(count - 1)], a list of field elements.\n */\nexport function hash_to_field(msg, count, options) {\n    validateObject(options, {\n        DST: 'stringOrUint8Array',\n        p: 'bigint',\n        m: 'isSafeInteger',\n        k: 'isSafeInteger',\n        hash: 'hash',\n    });\n    const { p, k, m, hash, expand, DST: _DST } = options;\n    abytes(msg);\n    anum(count);\n    const DST = typeof _DST === 'string' ? utf8ToBytes(_DST) : _DST;\n    const log2p = p.toString(2).length;\n    const L = Math.ceil((log2p + k) / 8); // section 5.1 of ietf draft link above\n    const len_in_bytes = count * m * L;\n    let prb; // pseudo_random_bytes\n    if (expand === 'xmd') {\n        prb = expand_message_xmd(msg, DST, len_in_bytes, hash);\n    }\n    else if (expand === 'xof') {\n        prb = expand_message_xof(msg, DST, len_in_bytes, k, hash);\n    }\n    else if (expand === '_internal_pass') {\n        // for internal tests only\n        prb = msg;\n    }\n    else {\n        throw new Error('expand must be \"xmd\" or \"xof\"');\n    }\n    const u = new Array(count);\n    for (let i = 0; i < count; i++) {\n        const e = new Array(m);\n        for (let j = 0; j < m; j++) {\n            const elm_offset = L * (j + i * m);\n            const tv = prb.subarray(elm_offset, elm_offset + L);\n            e[j] = mod(os2ip(tv), p);\n        }\n        u[i] = e;\n    }\n    return u;\n}\nexport function isogenyMap(field, map) {\n    // Make same order as in spec\n    const COEFF = map.map((i) => Array.from(i).reverse());\n    return (x, y) => {\n        const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));\n        x = field.div(xNum, xDen); // xNum / xDen\n        y = field.mul(y, field.div(yNum, yDen)); // y * (yNum / yDev)\n        return { x: x, y: y };\n    };\n}\n/** Creates hash-to-curve methods from EC Point and mapToCurve function. */\nexport function createHasher(Point, mapToCurve, def) {\n    if (typeof mapToCurve !== 'function')\n        throw new Error('mapToCurve() must be defined');\n    return {\n        // Encodes byte string to elliptic curve.\n        // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3\n        hashToCurve(msg, options) {\n            const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });\n            const u0 = Point.fromAffine(mapToCurve(u[0]));\n            const u1 = Point.fromAffine(mapToCurve(u[1]));\n            const P = u0.add(u1).clearCofactor();\n            P.assertValidity();\n            return P;\n        },\n        // Encodes byte string to elliptic curve.\n        // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3\n        encodeToCurve(msg, options) {\n            const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });\n            const P = Point.fromAffine(mapToCurve(u[0])).clearCofactor();\n            P.assertValidity();\n            return P;\n        },\n        // Same as encodeToCurve, but without hash\n        mapToCurve(scalars) {\n            if (!Array.isArray(scalars))\n                throw new Error('mapToCurve: expected array of bigints');\n            for (const i of scalars)\n                if (typeof i !== 'bigint')\n                    throw new Error('mapToCurve: expected array of bigints');\n            const P = Point.fromAffine(mapToCurve(scalars)).clearCofactor();\n            P.assertValidity();\n            return P;\n        },\n    };\n}\n//# sourceMappingURL=hash-to-curve.js.map","/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { nLength, validateField } from './modular.js';\nimport { bitLen, validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nfunction constTimeNegate(condition, item) {\n    const neg = item.negate();\n    return condition ? neg : item;\n}\nfunction validateW(W, bits) {\n    if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n        throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\nfunction calcWOpts(W, bits) {\n    validateW(W, bits);\n    const windows = Math.ceil(bits / W) + 1; // +1, because\n    const windowSize = 2 ** (W - 1); // -1 because we skip zero\n    return { windows, windowSize };\n}\nfunction validateMSMPoints(points, c) {\n    if (!Array.isArray(points))\n        throw new Error('array expected');\n    points.forEach((p, i) => {\n        if (!(p instanceof c))\n            throw new Error('invalid point at index ' + i);\n    });\n}\nfunction validateMSMScalars(scalars, field) {\n    if (!Array.isArray(scalars))\n        throw new Error('array of scalars expected');\n    scalars.forEach((s, i) => {\n        if (!field.isValid(s))\n            throw new Error('invalid scalar at index ' + i);\n    });\n}\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes\nconst pointPrecomputes = new WeakMap();\nconst pointWindowSizes = new WeakMap(); // This allows use make points immutable (nothing changes inside)\nfunction getW(P) {\n    return pointWindowSizes.get(P) || 1;\n}\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport function wNAF(c, bits) {\n    return {\n        constTimeNegate,\n        hasPrecomputes(elm) {\n            return getW(elm) !== 1;\n        },\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n, p = c.ZERO) {\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @param elm Point instance\n         * @param W window size\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = calcWOpts(W, bits);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = calcWOpts(W, bits);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        /**\n         * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @param acc accumulator point to add result of multiplication\n         * @returns point\n         */\n        wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {\n            const { windows, windowSize } = calcWOpts(W, bits);\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                if (n === _0n)\n                    break; // No need to go over empty scalar\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                if (wbits === 0)\n                    continue;\n                let curr = precomputes[offset + Math.abs(wbits) - 1]; // -1 because we skip zero\n                if (wbits < 0)\n                    curr = curr.negate();\n                // NOTE: by re-using acc, we can save a lot of additions in case of MSM\n                acc = acc.add(curr);\n            }\n            return acc;\n        },\n        getPrecomputes(W, P, transform) {\n            // Calculate precomputes on a first run, reuse them after\n            let comp = pointPrecomputes.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1)\n                    pointPrecomputes.set(P, transform(comp));\n            }\n            return comp;\n        },\n        wNAFCached(P, n, transform) {\n            const W = getW(P);\n            return this.wNAF(W, this.getPrecomputes(W, P, transform), n);\n        },\n        wNAFCachedUnsafe(P, n, transform, prev) {\n            const W = getW(P);\n            if (W === 1)\n                return this.unsafeLadder(P, n, prev); // For W=1 ladder is ~x2 faster\n            return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);\n        },\n        // We calculate precomputes for elliptic curve point multiplication\n        // using windowed method. This specifies window size and\n        // stores precomputed values. Usually only base point would be precomputed.\n        setWindowSize(P, W) {\n            validateW(W, bits);\n            pointWindowSizes.set(P, W);\n            pointPrecomputes.delete(P);\n        },\n    };\n}\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster with precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka private keys / bigints)\n */\nexport function pippenger(c, fieldN, points, scalars) {\n    // If we split scalars by some window (let's say 8 bits), every chunk will only\n    // take 256 buckets even if there are 4096 scalars, also re-uses double.\n    // TODO:\n    // - https://eprint.iacr.org/2024/750.pdf\n    // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n    // 0 is accepted in scalars\n    validateMSMPoints(points, c);\n    validateMSMScalars(scalars, fieldN);\n    if (points.length !== scalars.length)\n        throw new Error('arrays of points and scalars must have equal length');\n    const zero = c.ZERO;\n    const wbits = bitLen(BigInt(points.length));\n    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1; // in bits\n    const MASK = (1 << windowSize) - 1;\n    const buckets = new Array(MASK + 1).fill(zero); // +1 for zero array\n    const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n    let sum = zero;\n    for (let i = lastBits; i >= 0; i -= windowSize) {\n        buckets.fill(zero);\n        for (let j = 0; j < scalars.length; j++) {\n            const scalar = scalars[j];\n            const wbits = Number((scalar >> BigInt(i)) & BigInt(MASK));\n            buckets[wbits] = buckets[wbits].add(points[j]);\n        }\n        let resI = zero; // not using this will do small speed-up, but will lose ct\n        // Skip first bucket, because it is zero\n        for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n            sumI = sumI.add(buckets[j]);\n            resI = resI.add(sumI);\n        }\n        sum = sum.add(resI);\n        if (i !== 0)\n            for (let j = 0; j < windowSize; j++)\n                sum = sum.double();\n    }\n    return sum;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe(c, fieldN, points, windowSize) {\n    /**\n     * Performance Analysis of Window-based Precomputation\n     *\n     * Base Case (256-bit scalar, 8-bit window):\n     * - Standard precomputation requires:\n     *   - 31 additions per scalar × 256 scalars = 7,936 ops\n     *   - Plus 255 summary additions = 8,191 total ops\n     *   Note: Summary additions can be optimized via accumulator\n     *\n     * Chunked Precomputation Analysis:\n     * - Using 32 chunks requires:\n     *   - 255 additions per chunk\n     *   - 256 doublings\n     *   - Total: (255 × 32) + 256 = 8,416 ops\n     *\n     * Memory Usage Comparison:\n     * Window Size | Standard Points | Chunked Points\n     * ------------|-----------------|---------------\n     *     4-bit   |     520         |      15\n     *     8-bit   |    4,224        |     255\n     *    10-bit   |   13,824        |   1,023\n     *    16-bit   |  557,056        |  65,535\n     *\n     * Key Advantages:\n     * 1. Enables larger window sizes due to reduced memory overhead\n     * 2. More efficient for smaller scalar counts:\n     *    - 16 chunks: (16 × 255) + 256 = 4,336 ops\n     *    - ~2x faster than standard 8,191 ops\n     *\n     * Limitations:\n     * - Not suitable for plain precomputes (requires 256 constant doublings)\n     * - Performance degrades with larger scalar counts:\n     *   - Optimal for ~256 scalars\n     *   - Less efficient for 4096+ scalars (Pippenger preferred)\n     */\n    validateW(windowSize, fieldN.BITS);\n    validateMSMPoints(points, c);\n    const zero = c.ZERO;\n    const tableSize = 2 ** windowSize - 1; // table size (without zero)\n    const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n    const MASK = BigInt((1 << windowSize) - 1);\n    const tables = points.map((p) => {\n        const res = [];\n        for (let i = 0, acc = p; i < tableSize; i++) {\n            res.push(acc);\n            acc = acc.add(p);\n        }\n        return res;\n    });\n    return (scalars) => {\n        validateMSMScalars(scalars, fieldN);\n        if (scalars.length > points.length)\n            throw new Error('array of scalars must be smaller than array of points');\n        let res = zero;\n        for (let i = 0; i < chunks; i++) {\n            // No need to double if accumulator is still zero.\n            if (res !== zero)\n                for (let j = 0; j < windowSize; j++)\n                    res = res.double();\n            const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n            for (let j = 0; j < scalars.length; j++) {\n                const n = scalars[j];\n                const curr = Number((n >> shiftBy) & MASK);\n                if (!curr)\n                    continue; // skip zero scalars chunks\n                res = res.add(tables[j][curr - 1]);\n            }\n        }\n        return res;\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map","/**\n * Short Weierstrass curve methods. The formula is: y² = x³ + ax + b.\n *\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n *   `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n *   it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance\n * of nominative types in TypeScript and interfaces only check for shape, so it's hard to create\n * unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n *     which is hard to debug.\n *     2. Params can be generic and we can't enforce them to be constant value:\n *     if somebody creates curve from non-constant params,\n *     it would be allowed to interact with other curves with non-constant params\n *\n * @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { pippenger, validateBasic, wNAF, } from './curve.js';\nimport { Field, getMinHashLength, invert, mapHashToField, mod, validateField, } from './modular.js';\nimport * as ut from './utils.js';\nimport { abool, ensureBytes, memoized } from './utils.js';\nfunction validateSigVerOpts(opts) {\n    if (opts.lowS !== undefined)\n        abool('lowS', opts.lowS);\n    if (opts.prehash !== undefined)\n        abool('prehash', opts.prehash);\n}\nfunction validatePointOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        a: 'field',\n        b: 'field',\n    }, {\n        allowedPrivateKeyLengths: 'array',\n        wrapPrivateKey: 'boolean',\n        isTorsionFree: 'function',\n        clearCofactor: 'function',\n        allowInfinityPoint: 'boolean',\n        fromBytes: 'function',\n        toBytes: 'function',\n    });\n    const { endo, Fp, a } = opts;\n    if (endo) {\n        if (!Fp.eql(a, Fp.ZERO)) {\n            throw new Error('invalid endomorphism, can only be defined for Koblitz curves that have a=0');\n        }\n        if (typeof endo !== 'object' ||\n            typeof endo.beta !== 'bigint' ||\n            typeof endo.splitScalar !== 'function') {\n            throw new Error('invalid endomorphism, expected beta: bigint and splitScalar: function');\n        }\n    }\n    return Object.freeze({ ...opts });\n}\nconst { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;\nexport class DERErr extends Error {\n    constructor(m = '') {\n        super(m);\n    }\n}\n/**\n * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:\n *\n *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]\n *\n * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html\n */\nexport const DER = {\n    // asn.1 DER encoding utils\n    Err: DERErr,\n    // Basic building block is TLV (Tag-Length-Value)\n    _tlv: {\n        encode: (tag, data) => {\n            const { Err: E } = DER;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length & 1)\n                throw new E('tlv.encode: unpadded data');\n            const dataLen = data.length / 2;\n            const len = ut.numberToHexUnpadded(dataLen);\n            if ((len.length / 2) & 128)\n                throw new E('tlv.encode: long form length too big');\n            // length of length with long form flag\n            const lenLen = dataLen > 127 ? ut.numberToHexUnpadded((len.length / 2) | 128) : '';\n            const t = ut.numberToHexUnpadded(tag);\n            return t + lenLen + len + data;\n        },\n        // v - value, l - left bytes (unparsed)\n        decode(tag, data) {\n            const { Err: E } = DER;\n            let pos = 0;\n            if (tag < 0 || tag > 256)\n                throw new E('tlv.encode: wrong tag');\n            if (data.length < 2 || data[pos++] !== tag)\n                throw new E('tlv.decode: wrong tlv');\n            const first = data[pos++];\n            const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form\n            let length = 0;\n            if (!isLong)\n                length = first;\n            else {\n                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]\n                const lenLen = first & 127;\n                if (!lenLen)\n                    throw new E('tlv.decode(long): indefinite length not supported');\n                if (lenLen > 4)\n                    throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js\n                const lengthBytes = data.subarray(pos, pos + lenLen);\n                if (lengthBytes.length !== lenLen)\n                    throw new E('tlv.decode: length bytes not complete');\n                if (lengthBytes[0] === 0)\n                    throw new E('tlv.decode(long): zero leftmost byte');\n                for (const b of lengthBytes)\n                    length = (length << 8) | b;\n                pos += lenLen;\n                if (length < 128)\n                    throw new E('tlv.decode(long): not minimal encoding');\n            }\n            const v = data.subarray(pos, pos + length);\n            if (v.length !== length)\n                throw new E('tlv.decode: wrong value length');\n            return { v, l: data.subarray(pos + length) };\n        },\n    },\n    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n    // since we always use positive integers here. It must always be empty:\n    // - add zero byte if exists\n    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n    _int: {\n        encode(num) {\n            const { Err: E } = DER;\n            if (num < _0n)\n                throw new E('integer: negative integers are not allowed');\n            let hex = ut.numberToHexUnpadded(num);\n            // Pad with zero byte if negative flag is present\n            if (Number.parseInt(hex[0], 16) & 0b1000)\n                hex = '00' + hex;\n            if (hex.length & 1)\n                throw new E('unexpected DER parsing assertion: unpadded hex');\n            return hex;\n        },\n        decode(data) {\n            const { Err: E } = DER;\n            if (data[0] & 128)\n                throw new E('invalid signature integer: negative');\n            if (data[0] === 0x00 && !(data[1] & 128))\n                throw new E('invalid signature integer: unnecessary leading zero');\n            return b2n(data);\n        },\n    },\n    toSig(hex) {\n        // parse DER signature\n        const { Err: E, _int: int, _tlv: tlv } = DER;\n        const data = typeof hex === 'string' ? h2b(hex) : hex;\n        ut.abytes(data);\n        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);\n        if (seqLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);\n        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);\n        if (sLeftBytes.length)\n            throw new E('invalid signature: left bytes after parsing');\n        return { r: int.decode(rBytes), s: int.decode(sBytes) };\n    },\n    hexFromSig(sig) {\n        const { _tlv: tlv, _int: int } = DER;\n        const rs = tlv.encode(0x02, int.encode(sig.r));\n        const ss = tlv.encode(0x02, int.encode(sig.s));\n        const seq = rs + ss;\n        return tlv.encode(0x30, seq);\n    },\n};\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\nexport function weierstrassPoints(opts) {\n    const CURVE = validatePointOpts(opts);\n    const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ\n    const Fn = Field(CURVE.n, CURVE.nBitLength);\n    const toBytes = CURVE.toBytes ||\n        ((_c, point, _isCompressed) => {\n            const a = point.toAffine();\n            return ut.concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));\n        });\n    const fromBytes = CURVE.fromBytes ||\n        ((bytes) => {\n            // const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');\n            const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n            const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n            return { x, y };\n        });\n    /**\n     * y² = x³ + ax + b: Short weierstrass curve formula\n     * @returns y²\n     */\n    function weierstrassEquation(x) {\n        const { a, b } = CURVE;\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x2 * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x3 + a * x + b\n    }\n    // Validate whether the passed curve params are valid.\n    // We check if curve equation works for generator point.\n    // `assertValidity()` won't work: `isTorsionFree()` is not available at this point in bls12-381.\n    // ProjectivePoint class has not been initialized yet.\n    if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))\n        throw new Error('bad generator point: equation left != right');\n    // Valid group elements reside in range 1..n-1\n    function isWithinCurveOrder(num) {\n        return ut.inRange(num, _1n, CURVE.n);\n    }\n    // Validates if priv key is valid and converts it to bigint.\n    // Supports options allowedPrivateKeyLengths and wrapPrivateKey.\n    function normPrivateKeyToScalar(key) {\n        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;\n        if (lengths && typeof key !== 'bigint') {\n            if (ut.isBytes(key))\n                key = ut.bytesToHex(key);\n            // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes\n            if (typeof key !== 'string' || !lengths.includes(key.length))\n                throw new Error('invalid private key');\n            key = key.padStart(nByteLength * 2, '0');\n        }\n        let num;\n        try {\n            num =\n                typeof key === 'bigint'\n                    ? key\n                    : ut.bytesToNumberBE(ensureBytes('private key', key, nByteLength));\n        }\n        catch (error) {\n            throw new Error('invalid private key, expected hex or ' + nByteLength + ' bytes, got ' + typeof key);\n        }\n        if (wrapPrivateKey)\n            num = mod(num, N); // disabled by default, enabled for BLS\n        ut.aInRange('private key', num, _1n, N); // num in range [1..N-1]\n        return num;\n    }\n    function assertPrjPoint(other) {\n        if (!(other instanceof Point))\n            throw new Error('ProjectivePoint expected');\n    }\n    // Memoized toAffine / validity check. They are heavy. Points are immutable.\n    // Converts Projective point to affine (x, y) coordinates.\n    // Can accept precomputed Z^-1 - for example, from invertBatch.\n    // (x, y, z) ∋ (x=x/z, y=y/z)\n    const toAffineMemo = memoized((p, iz) => {\n        const { px: x, py: y, pz: z } = p;\n        // Fast-path for normalized points\n        if (Fp.eql(z, Fp.ONE))\n            return { x, y };\n        const is0 = p.is0();\n        // If invZ was 0, we return zero point. However we still want to execute\n        // all operations, so we replace invZ with a random number, 1.\n        if (iz == null)\n            iz = is0 ? Fp.ONE : Fp.inv(z);\n        const ax = Fp.mul(x, iz);\n        const ay = Fp.mul(y, iz);\n        const zz = Fp.mul(z, iz);\n        if (is0)\n            return { x: Fp.ZERO, y: Fp.ZERO };\n        if (!Fp.eql(zz, Fp.ONE))\n            throw new Error('invZ was invalid');\n        return { x: ax, y: ay };\n    });\n    // NOTE: on exception this will crash 'cached' and no value will be set.\n    // Otherwise true will be return\n    const assertValidMemo = memoized((p) => {\n        if (p.is0()) {\n            // (0, 1, 0) aka ZERO is invalid in most contexts.\n            // In BLS, ZERO can be serialized, so we allow it.\n            // (0, 0, 0) is invalid representation of ZERO.\n            if (CURVE.allowInfinityPoint && !Fp.is0(p.py))\n                return;\n            throw new Error('bad point: ZERO');\n        }\n        // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n        const { x, y } = p.toAffine();\n        // Check if x, y are valid field elements\n        if (!Fp.isValid(x) || !Fp.isValid(y))\n            throw new Error('bad point: x or y not FE');\n        const left = Fp.sqr(y); // y²\n        const right = weierstrassEquation(x); // x³ + ax + b\n        if (!Fp.eql(left, right))\n            throw new Error('bad point: equation left != right');\n        if (!p.isTorsionFree())\n            throw new Error('bad point: not in prime-order subgroup');\n        return true;\n    });\n    /**\n     * Projective Point works in 3d / projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)\n     * Default Point works in 2d / affine coordinates: (x, y)\n     * We're doing calculations in projective, because its operations don't require costly inversion.\n     */\n    class Point {\n        constructor(px, py, pz) {\n            this.px = px;\n            this.py = py;\n            this.pz = pz;\n            if (px == null || !Fp.isValid(px))\n                throw new Error('x required');\n            if (py == null || !Fp.isValid(py))\n                throw new Error('y required');\n            if (pz == null || !Fp.isValid(pz))\n                throw new Error('z required');\n            Object.freeze(this);\n        }\n        // Does not validate if the point is on-curve.\n        // Use fromHex instead, or call assertValidity() later.\n        static fromAffine(p) {\n            const { x, y } = p || {};\n            if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('invalid affine point');\n            if (p instanceof Point)\n                throw new Error('projective point not allowed');\n            const is0 = (i) => Fp.eql(i, Fp.ZERO);\n            // fromAffine(x:0, y:0) would produce (x:0, y:0, z:1), but we need (x:0, y:1, z:0)\n            if (is0(x) && is0(y))\n                return Point.ZERO;\n            return new Point(x, y, Fp.ONE);\n        }\n        get x() {\n            return this.toAffine().x;\n        }\n        get y() {\n            return this.toAffine().y;\n        }\n        /**\n         * Takes a bunch of Projective Points but executes only one\n         * inversion on all of them. Inversion is very slow operation,\n         * so this improves performance massively.\n         * Optimization: converts a list of projective points to a list of identical points with Z=1.\n         */\n        static normalizeZ(points) {\n            const toInv = Fp.invertBatch(points.map((p) => p.pz));\n            return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n        }\n        /**\n         * Converts hash string or Uint8Array to Point.\n         * @param hex short/long ECDSA hex\n         */\n        static fromHex(hex) {\n            const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));\n            P.assertValidity();\n            return P;\n        }\n        // Multiplies generator point by privateKey.\n        static fromPrivateKey(privateKey) {\n            return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));\n        }\n        // Multiscalar Multiplication\n        static msm(points, scalars) {\n            return pippenger(Point, Fn, points, scalars);\n        }\n        // \"Private method\", don't use it directly\n        _setWindowSize(windowSize) {\n            wnaf.setWindowSize(this, windowSize);\n        }\n        // A point on curve is valid if it conforms to equation.\n        assertValidity() {\n            assertValidMemo(this);\n        }\n        hasEvenY() {\n            const { y } = this.toAffine();\n            if (Fp.isOdd)\n                return !Fp.isOdd(y);\n            throw new Error(\"Field doesn't support isOdd\");\n        }\n        /**\n         * Compare one point to another.\n         */\n        equals(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n            const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n            return U1 && U2;\n        }\n        /**\n         * Flips point to one corresponding to (x, -y) in Affine coordinates.\n         */\n        negate() {\n            return new Point(this.px, Fp.neg(this.py), this.pz);\n        }\n        // Renes-Costello-Batina exception-free doubling formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 3\n        // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n        double() {\n            const { a, b } = CURVE;\n            const b3 = Fp.mul(b, _3n);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            let t0 = Fp.mul(X1, X1); // step 1\n            let t1 = Fp.mul(Y1, Y1);\n            let t2 = Fp.mul(Z1, Z1);\n            let t3 = Fp.mul(X1, Y1);\n            t3 = Fp.add(t3, t3); // step 5\n            Z3 = Fp.mul(X1, Z1);\n            Z3 = Fp.add(Z3, Z3);\n            X3 = Fp.mul(a, Z3);\n            Y3 = Fp.mul(b3, t2);\n            Y3 = Fp.add(X3, Y3); // step 10\n            X3 = Fp.sub(t1, Y3);\n            Y3 = Fp.add(t1, Y3);\n            Y3 = Fp.mul(X3, Y3);\n            X3 = Fp.mul(t3, X3);\n            Z3 = Fp.mul(b3, Z3); // step 15\n            t2 = Fp.mul(a, t2);\n            t3 = Fp.sub(t0, t2);\n            t3 = Fp.mul(a, t3);\n            t3 = Fp.add(t3, Z3);\n            Z3 = Fp.add(t0, t0); // step 20\n            t0 = Fp.add(Z3, t0);\n            t0 = Fp.add(t0, t2);\n            t0 = Fp.mul(t0, t3);\n            Y3 = Fp.add(Y3, t0);\n            t2 = Fp.mul(Y1, Z1); // step 25\n            t2 = Fp.add(t2, t2);\n            t0 = Fp.mul(t2, t3);\n            X3 = Fp.sub(X3, t0);\n            Z3 = Fp.mul(t2, t1);\n            Z3 = Fp.add(Z3, Z3); // step 30\n            Z3 = Fp.add(Z3, Z3);\n            return new Point(X3, Y3, Z3);\n        }\n        // Renes-Costello-Batina exception-free addition formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 1\n        // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n        add(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            const a = CURVE.a;\n            const b3 = Fp.mul(CURVE.b, _3n);\n            let t0 = Fp.mul(X1, X2); // step 1\n            let t1 = Fp.mul(Y1, Y2);\n            let t2 = Fp.mul(Z1, Z2);\n            let t3 = Fp.add(X1, Y1);\n            let t4 = Fp.add(X2, Y2); // step 5\n            t3 = Fp.mul(t3, t4);\n            t4 = Fp.add(t0, t1);\n            t3 = Fp.sub(t3, t4);\n            t4 = Fp.add(X1, Z1);\n            let t5 = Fp.add(X2, Z2); // step 10\n            t4 = Fp.mul(t4, t5);\n            t5 = Fp.add(t0, t2);\n            t4 = Fp.sub(t4, t5);\n            t5 = Fp.add(Y1, Z1);\n            X3 = Fp.add(Y2, Z2); // step 15\n            t5 = Fp.mul(t5, X3);\n            X3 = Fp.add(t1, t2);\n            t5 = Fp.sub(t5, X3);\n            Z3 = Fp.mul(a, t4);\n            X3 = Fp.mul(b3, t2); // step 20\n            Z3 = Fp.add(X3, Z3);\n            X3 = Fp.sub(t1, Z3);\n            Z3 = Fp.add(t1, Z3);\n            Y3 = Fp.mul(X3, Z3);\n            t1 = Fp.add(t0, t0); // step 25\n            t1 = Fp.add(t1, t0);\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.mul(b3, t4);\n            t1 = Fp.add(t1, t2);\n            t2 = Fp.sub(t0, t2); // step 30\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.add(t4, t2);\n            t0 = Fp.mul(t1, t4);\n            Y3 = Fp.add(Y3, t0);\n            t0 = Fp.mul(t5, t4); // step 35\n            X3 = Fp.mul(t3, X3);\n            X3 = Fp.sub(X3, t0);\n            t0 = Fp.mul(t3, t1);\n            Z3 = Fp.mul(t5, Z3);\n            Z3 = Fp.add(Z3, t0); // step 40\n            return new Point(X3, Y3, Z3);\n        }\n        subtract(other) {\n            return this.add(other.negate());\n        }\n        is0() {\n            return this.equals(Point.ZERO);\n        }\n        wNAF(n) {\n            return wnaf.wNAFCached(this, n, Point.normalizeZ);\n        }\n        /**\n         * Non-constant-time multiplication. Uses double-and-add algorithm.\n         * It's faster, but should only be used when you don't care about\n         * an exposed private key e.g. sig verification, which works over *public* keys.\n         */\n        multiplyUnsafe(sc) {\n            const { endo, n: N } = CURVE;\n            ut.aInRange('scalar', sc, _0n, N);\n            const I = Point.ZERO;\n            if (sc === _0n)\n                return I;\n            if (this.is0() || sc === _1n)\n                return this;\n            // Case a: no endomorphism. Case b: has precomputes.\n            if (!endo || wnaf.hasPrecomputes(this))\n                return wnaf.wNAFCachedUnsafe(this, sc, Point.normalizeZ);\n            // Case c: endomorphism\n            let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);\n            let k1p = I;\n            let k2p = I;\n            let d = this;\n            while (k1 > _0n || k2 > _0n) {\n                if (k1 & _1n)\n                    k1p = k1p.add(d);\n                if (k2 & _1n)\n                    k2p = k2p.add(d);\n                d = d.double();\n                k1 >>= _1n;\n                k2 >>= _1n;\n            }\n            if (k1neg)\n                k1p = k1p.negate();\n            if (k2neg)\n                k2p = k2p.negate();\n            k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n            return k1p.add(k2p);\n        }\n        /**\n         * Constant time multiplication.\n         * Uses wNAF method. Windowed method may be 10% faster,\n         * but takes 2x longer to generate and consumes 2x memory.\n         * Uses precomputes when available.\n         * Uses endomorphism for Koblitz curves.\n         * @param scalar by which the point would be multiplied\n         * @returns New point\n         */\n        multiply(scalar) {\n            const { endo, n: N } = CURVE;\n            ut.aInRange('scalar', scalar, _1n, N);\n            let point, fake; // Fake point is used to const-time mult\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);\n                let { p: k1p, f: f1p } = this.wNAF(k1);\n                let { p: k2p, f: f2p } = this.wNAF(k2);\n                k1p = wnaf.constTimeNegate(k1neg, k1p);\n                k2p = wnaf.constTimeNegate(k2neg, k2p);\n                k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n                point = k1p.add(k2p);\n                fake = f1p.add(f2p);\n            }\n            else {\n                const { p, f } = this.wNAF(scalar);\n                point = p;\n                fake = f;\n            }\n            // Normalize `z` for both points, but return only real one\n            return Point.normalizeZ([point, fake])[0];\n        }\n        /**\n         * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.\n         * Not using Strauss-Shamir trick: precomputation tables are faster.\n         * The trick could be useful if both P and Q are not G (not in our case).\n         * @returns non-zero affine point\n         */\n        multiplyAndAddUnsafe(Q, a, b) {\n            const G = Point.BASE; // No Strauss-Shamir trick: we have 10% faster G precomputes\n            const mul = (P, a // Select faster multiply() method\n            ) => (a === _0n || a === _1n || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));\n            const sum = mul(this, a).add(mul(Q, b));\n            return sum.is0() ? undefined : sum;\n        }\n        // Converts Projective point to affine (x, y) coordinates.\n        // Can accept precomputed Z^-1 - for example, from invertBatch.\n        // (x, y, z) ∋ (x=x/z, y=y/z)\n        toAffine(iz) {\n            return toAffineMemo(this, iz);\n        }\n        isTorsionFree() {\n            const { h: cofactor, isTorsionFree } = CURVE;\n            if (cofactor === _1n)\n                return true; // No subgroups, always torsion-free\n            if (isTorsionFree)\n                return isTorsionFree(Point, this);\n            throw new Error('isTorsionFree() has not been declared for the elliptic curve');\n        }\n        clearCofactor() {\n            const { h: cofactor, clearCofactor } = CURVE;\n            if (cofactor === _1n)\n                return this; // Fast-path\n            if (clearCofactor)\n                return clearCofactor(Point, this);\n            return this.multiplyUnsafe(CURVE.h);\n        }\n        toRawBytes(isCompressed = true) {\n            abool('isCompressed', isCompressed);\n            this.assertValidity();\n            return toBytes(Point, this, isCompressed);\n        }\n        toHex(isCompressed = true) {\n            abool('isCompressed', isCompressed);\n            return ut.bytesToHex(this.toRawBytes(isCompressed));\n        }\n    }\n    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);\n    const _bits = CURVE.nBitLength;\n    const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);\n    // Validate if generator point is on curve\n    return {\n        CURVE,\n        ProjectivePoint: Point,\n        normPrivateKeyToScalar,\n        weierstrassEquation,\n        isWithinCurveOrder,\n    };\n}\nfunction validateOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        hash: 'hash',\n        hmac: 'function',\n        randomBytes: 'function',\n    }, {\n        bits2int: 'function',\n        bits2int_modN: 'function',\n        lowS: 'boolean',\n    });\n    return Object.freeze({ lowS: true, ...opts });\n}\n/**\n * Creates short weierstrass curve and ECDSA signature methods for it.\n * @example\n * import { Field } from '@noble/curves/abstract/modular';\n * // Before that, define BigInt-s: a, b, p, n, Gx, Gy\n * const curve = weierstrass({ a, b, Fp: Field(p), n, Gx, Gy, h: 1n })\n */\nexport function weierstrass(curveDef) {\n    const CURVE = validateOpts(curveDef);\n    const { Fp, n: CURVE_ORDER } = CURVE;\n    const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32\n    const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32\n    function modN(a) {\n        return mod(a, CURVE_ORDER);\n    }\n    function invN(a) {\n        return invert(a, CURVE_ORDER);\n    }\n    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder, } = weierstrassPoints({\n        ...CURVE,\n        toBytes(_c, point, isCompressed) {\n            const a = point.toAffine();\n            const x = Fp.toBytes(a.x);\n            const cat = ut.concatBytes;\n            abool('isCompressed', isCompressed);\n            if (isCompressed) {\n                return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);\n            }\n            else {\n                return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));\n            }\n        },\n        fromBytes(bytes) {\n            const len = bytes.length;\n            const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // this.assertValidity() is done inside of fromHex\n            if (len === compressedLen && (head === 0x02 || head === 0x03)) {\n                const x = ut.bytesToNumberBE(tail);\n                if (!ut.inRange(x, _1n, Fp.ORDER))\n                    throw new Error('Point is not on curve');\n                const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n                let y;\n                try {\n                    y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n                }\n                catch (sqrtError) {\n                    const suffix = sqrtError instanceof Error ? ': ' + sqrtError.message : '';\n                    throw new Error('Point is not on curve' + suffix);\n                }\n                const isYOdd = (y & _1n) === _1n;\n                // ECDSA\n                const isHeadOdd = (head & 1) === 1;\n                if (isHeadOdd !== isYOdd)\n                    y = Fp.neg(y);\n                return { x, y };\n            }\n            else if (len === uncompressedLen && head === 0x04) {\n                const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n                const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n                return { x, y };\n            }\n            else {\n                const cl = compressedLen;\n                const ul = uncompressedLen;\n                throw new Error('invalid Point, expected length of ' + cl + ', or uncompressed ' + ul + ', got ' + len);\n            }\n        },\n    });\n    const numToNByteStr = (num) => ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));\n    function isBiggerThanHalfOrder(number) {\n        const HALF = CURVE_ORDER >> _1n;\n        return number > HALF;\n    }\n    function normalizeS(s) {\n        return isBiggerThanHalfOrder(s) ? modN(-s) : s;\n    }\n    // slice bytes num\n    const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));\n    /**\n     * ECDSA signature with its (r, s) properties. Supports DER & compact representations.\n     */\n    class Signature {\n        constructor(r, s, recovery) {\n            this.r = r;\n            this.s = s;\n            this.recovery = recovery;\n            this.assertValidity();\n        }\n        // pair (bytes of r, bytes of s)\n        static fromCompact(hex) {\n            const l = CURVE.nByteLength;\n            hex = ensureBytes('compactSignature', hex, l * 2);\n            return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));\n        }\n        // DER encoded ECDSA signature\n        // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script\n        static fromDER(hex) {\n            const { r, s } = DER.toSig(ensureBytes('DER', hex));\n            return new Signature(r, s);\n        }\n        assertValidity() {\n            ut.aInRange('r', this.r, _1n, CURVE_ORDER); // r in [1..N]\n            ut.aInRange('s', this.s, _1n, CURVE_ORDER); // s in [1..N]\n        }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(msgHash) {\n            const { r, s, recovery: rec } = this;\n            const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash\n            if (rec == null || ![0, 1, 2, 3].includes(rec))\n                throw new Error('recovery id invalid');\n            const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;\n            if (radj >= Fp.ORDER)\n                throw new Error('recovery id 2 or 3 invalid');\n            const prefix = (rec & 1) === 0 ? '02' : '03';\n            const R = Point.fromHex(prefix + numToNByteStr(radj));\n            const ir = invN(radj); // r^-1\n            const u1 = modN(-h * ir); // -hr^-1\n            const u2 = modN(s * ir); // sr^-1\n            const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)\n            if (!Q)\n                throw new Error('point at infinify'); // unsafe is fine: no priv data leaked\n            Q.assertValidity();\n            return Q;\n        }\n        // Signatures should be low-s, to prevent malleability.\n        hasHighS() {\n            return isBiggerThanHalfOrder(this.s);\n        }\n        normalizeS() {\n            return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;\n        }\n        // DER-encoded\n        toDERRawBytes() {\n            return ut.hexToBytes(this.toDERHex());\n        }\n        toDERHex() {\n            return DER.hexFromSig({ r: this.r, s: this.s });\n        }\n        // padded bytes of r, then padded bytes of s\n        toCompactRawBytes() {\n            return ut.hexToBytes(this.toCompactHex());\n        }\n        toCompactHex() {\n            return numToNByteStr(this.r) + numToNByteStr(this.s);\n        }\n    }\n    const utils = {\n        isValidPrivateKey(privateKey) {\n            try {\n                normPrivateKeyToScalar(privateKey);\n                return true;\n            }\n            catch (error) {\n                return false;\n            }\n        },\n        normPrivateKeyToScalar: normPrivateKeyToScalar,\n        /**\n         * Produces cryptographically secure private key from random of size\n         * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n         */\n        randomPrivateKey: () => {\n            const length = getMinHashLength(CURVE.n);\n            return mapHashToField(CURVE.randomBytes(length), CURVE.n);\n        },\n        /**\n         * Creates precompute table for an arbitrary EC point. Makes point \"cached\".\n         * Allows to massively speed-up `point.multiply(scalar)`.\n         * @returns cached point\n         * @example\n         * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));\n         * fast.multiply(privKey); // much faster ECDH now\n         */\n        precompute(windowSize = 8, point = Point.BASE) {\n            point._setWindowSize(windowSize);\n            point.multiply(BigInt(3)); // 3 is arbitrary, just need any number here\n            return point;\n        },\n    };\n    /**\n     * Computes public key for a private key. Checks for validity of the private key.\n     * @param privateKey private key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns Public key, full when isCompressed=false; short when isCompressed=true\n     */\n    function getPublicKey(privateKey, isCompressed = true) {\n        return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        const arr = ut.isBytes(item);\n        const str = typeof item === 'string';\n        const len = (arr || str) && item.length;\n        if (arr)\n            return len === compressedLen || len === uncompressedLen;\n        if (str)\n            return len === 2 * compressedLen || len === 2 * uncompressedLen;\n        if (item instanceof Point)\n            return true;\n        return false;\n    }\n    /**\n     * ECDH (Elliptic Curve Diffie Hellman).\n     * Computes shared public key from private key and public key.\n     * Checks: 1) private key validity 2) shared key is on-curve.\n     * Does NOT hash the result.\n     * @param privateA private key\n     * @param publicB different public key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns shared public key\n     */\n    function getSharedSecret(privateA, publicB, isCompressed = true) {\n        if (isProbPub(privateA))\n            throw new Error('first arg must be private key');\n        if (!isProbPub(publicB))\n            throw new Error('second arg must be public key');\n        const b = Point.fromHex(publicB); // check for being on-curve\n        return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);\n    }\n    // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n    // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n    // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n    // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n    const bits2int = CURVE.bits2int ||\n        function (bytes) {\n            // Our custom check \"just in case\"\n            if (bytes.length > 8192)\n                throw new Error('input is too large');\n            // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n            // for some cases, since bytes.length * 8 is not actual bitLength.\n            const num = ut.bytesToNumberBE(bytes); // check for == u8 done here\n            const delta = bytes.length * 8 - CURVE.nBitLength; // truncate to nBitLength leftmost bits\n            return delta > 0 ? num >> BigInt(delta) : num;\n        };\n    const bits2int_modN = CURVE.bits2int_modN ||\n        function (bytes) {\n            return modN(bits2int(bytes)); // can't use bytesToNumberBE here\n        };\n    // NOTE: pads output with zero as per spec\n    const ORDER_MASK = ut.bitMask(CURVE.nBitLength);\n    /**\n     * Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.\n     */\n    function int2octets(num) {\n        ut.aInRange('num < 2^' + CURVE.nBitLength, num, _0n, ORDER_MASK);\n        // works with order, can have different size than numToField!\n        return ut.numberToBytesBE(num, CURVE.nByteLength);\n    }\n    // Steps A, D of RFC6979 3.2\n    // Creates RFC6979 seed; converts msg/privKey to numbers.\n    // Used only in sign, not in verify.\n    // NOTE: we cannot assume here that msgHash has same amount of bytes as curve order,\n    // this will be invalid at least for P521. Also it can be bigger for P224 + SHA256\n    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {\n        if (['recovered', 'canonical'].some((k) => k in opts))\n            throw new Error('sign() legacy options not supported');\n        const { hash, randomBytes } = CURVE;\n        let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default\n        if (lowS == null)\n            lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash\n        msgHash = ensureBytes('msgHash', msgHash);\n        validateSigVerOpts(opts);\n        if (prehash)\n            msgHash = ensureBytes('prehashed msgHash', hash(msgHash));\n        // We can't later call bits2octets, since nested bits2int is broken for curves\n        // with nBitLength % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n        // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n        const h1int = bits2int_modN(msgHash);\n        const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint\n        const seedArgs = [int2octets(d), int2octets(h1int)];\n        // extraEntropy. RFC6979 3.6: additional k' (optional).\n        if (ent != null && ent !== false) {\n            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n            const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is\n            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes\n        }\n        const seed = ut.concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n        // Converts signature params into point w r/s, checks result for validity.\n        function k2sig(kBytes) {\n            // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n            const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n            if (!isWithinCurveOrder(k))\n                return; // Important: all mod() calls here must be done over N\n            const ik = invN(k); // k^-1 mod n\n            const q = Point.BASE.multiply(k).toAffine(); // q = Gk\n            const r = modN(q.x); // r = q.x mod n\n            if (r === _0n)\n                return;\n            // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n            // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n            // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n            const s = modN(ik * modN(m + r * d)); // Not using blinding here\n            if (s === _0n)\n                return;\n            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n            let normS = s;\n            if (lowS && isBiggerThanHalfOrder(s)) {\n                normS = normalizeS(s); // if lowS was passed, ensure s is always\n                recovery ^= 1; // // in the bottom half of N\n            }\n            return new Signature(r, normS, recovery); // use normS, not s\n        }\n        return { seed, k2sig };\n    }\n    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };\n    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };\n    /**\n     * Signs message hash with a private key.\n     * ```\n     * sign(m, d, k) where\n     *   (x, y) = G × k\n     *   r = x mod n\n     *   s = (m + dr)/k mod n\n     * ```\n     * @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.\n     * @param privKey private key\n     * @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.\n     * @returns signature with recovery param\n     */\n    function sign(msgHash, privKey, opts = defaultSigOpts) {\n        const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.\n        const C = CURVE;\n        const drbg = ut.createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);\n        return drbg(seed, k2sig); // Steps B, C, D, E, F, G\n    }\n    // Enable precomputes. Slows down first publicKey computation by 20ms.\n    Point.BASE._setWindowSize(8);\n    // utils.precompute(8, ProjectivePoint.BASE)\n    /**\n     * Verifies a signature against message hash and public key.\n     * Rejects lowS signatures by default: to override,\n     * specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n     *\n     * ```\n     * verify(r, s, h, P) where\n     *   U1 = hs^-1 mod n\n     *   U2 = rs^-1 mod n\n     *   R = U1⋅G - U2⋅P\n     *   mod(R.x, n) == r\n     * ```\n     */\n    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {\n        const sg = signature;\n        msgHash = ensureBytes('msgHash', msgHash);\n        publicKey = ensureBytes('publicKey', publicKey);\n        const { lowS, prehash, format } = opts;\n        // Verify opts, deduce signature format\n        validateSigVerOpts(opts);\n        if ('strict' in opts)\n            throw new Error('options.strict was renamed to lowS');\n        if (format !== undefined && format !== 'compact' && format !== 'der')\n            throw new Error('format must be compact or der');\n        const isHex = typeof sg === 'string' || ut.isBytes(sg);\n        const isObj = !isHex &&\n            !format &&\n            typeof sg === 'object' &&\n            sg !== null &&\n            typeof sg.r === 'bigint' &&\n            typeof sg.s === 'bigint';\n        if (!isHex && !isObj)\n            throw new Error('invalid signature, expected Uint8Array, hex string or Signature instance');\n        let _sig = undefined;\n        let P;\n        try {\n            if (isObj)\n                _sig = new Signature(sg.r, sg.s);\n            if (isHex) {\n                // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).\n                // Since DER can also be 2*nByteLength bytes, we check for it first.\n                try {\n                    if (format !== 'compact')\n                        _sig = Signature.fromDER(sg);\n                }\n                catch (derError) {\n                    if (!(derError instanceof DER.Err))\n                        throw derError;\n                }\n                if (!_sig && format !== 'der')\n                    _sig = Signature.fromCompact(sg);\n            }\n            P = Point.fromHex(publicKey);\n        }\n        catch (error) {\n            return false;\n        }\n        if (!_sig)\n            return false;\n        if (lowS && _sig.hasHighS())\n            return false;\n        if (prehash)\n            msgHash = CURVE.hash(msgHash);\n        const { r, s } = _sig;\n        const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element\n        const is = invN(s); // s^-1\n        const u1 = modN(h * is); // u1 = hs^-1 mod n\n        const u2 = modN(r * is); // u2 = rs^-1 mod n\n        const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); // R = u1⋅G + u2⋅P\n        if (!R)\n            return false;\n        const v = modN(R.x);\n        return v === r;\n    }\n    return {\n        CURVE,\n        getPublicKey,\n        getSharedSecret,\n        sign,\n        verify,\n        ProjectivePoint: Point,\n        Signature,\n        utils,\n    };\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n    // Generic implementation\n    const q = Fp.ORDER;\n    let l = _0n;\n    for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n        l += _1n;\n    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n    // 2n ** c1 == 2n << (c1-1)\n    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n    const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n    const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n    let sqrtRatio = (u, v) => {\n        let tv1 = c6; // 1. tv1 = c6\n        let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n        let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n        tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n        let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n        tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n        tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n        tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n        tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n        let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n        tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n        let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n        tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n        tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n        tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n        tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n        // 17. for i in (c1, c1 - 1, ..., 2):\n        for (let i = c1; i > _1n; i--) {\n            let tv5 = i - _2n; // 18.    tv5 = i - 2\n            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n            let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n            const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n            tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n            tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n            tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n            tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n            tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n        }\n        return { isValid: isQR, value: tv3 };\n    };\n    if (Fp.ORDER % _4n === _3n) {\n        // sqrt_ratio_3mod4(u, v)\n        const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n        const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n        sqrtRatio = (u, v) => {\n            let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n    validateField(Fp);\n    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n    if (!Fp.isOdd)\n        throw new Error('Fp.isOdd is not implemented!');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n        tv5 = Fp.mul(tv6, opts.A); // 11. tv5 = A * tv6\n        tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n        tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n        tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n        tv5 = Fp.mul(tv6, opts.B); // 15. tv5 = B * tv6\n        tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n        x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n        y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n        y = Fp.mul(y, value); // 20.   y = y * y1\n        x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n        y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n        const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)\n        y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n        x = Fp.div(x, tv4); // 25.   x = x / tv4\n        return { x, y };\n    };\n}\n//# sourceMappingURL=weierstrass.js.map","/**\n * BLS (Barreto-Lynn-Scott) family of pairing-friendly curves.\n * BLS != BLS.\n * The file implements BLS (Boneh-Lynn-Shacham) signatures.\n * Used in both BLS (Barreto-Lynn-Scott) and BN (Barreto-Naehrig)\n * families of pairing-friendly curves.\n * Consists of two curves: G1 and G2:\n * - G1 is a subgroup of (x, y) E(Fq) over y² = x³ + 4.\n * - G2 is a subgroup of ((x₁, x₂+i), (y₁, y₂+i)) E(Fq²) over y² = x³ + 4(1 + i) where i is √-1\n * - Gt, created by bilinear (ate) pairing e(G1, G2), consists of p-th roots of unity in\n *   Fq^k where k is embedding degree. Only degree 12 is currently supported, 24 is not.\n * Pairing is used to aggregate and verify signatures.\n * There are two main ways to use it:\n * 1. Fp for short private keys, Fp₂ for signatures\n * 2. Fp for short signatures, Fp₂ for private keys\n * @module\n **/\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// TODO: import { AffinePoint } from './curve.js';\nimport { getMinHashLength, mapHashToField } from './modular.js';\nimport { ensureBytes, memoized } from './utils.js';\n// prettier-ignore\nimport { createHasher } from './hash-to-curve.js';\nimport { weierstrassPoints, } from './weierstrass.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// Not used with BLS12-381 (no sequential `11` in X). Useful for other curves.\nfunction NAfDecomposition(a) {\n    const res = [];\n    // a>1 because of marker bit\n    for (; a > _1n; a >>= _1n) {\n        if ((a & _1n) === _0n)\n            res.unshift(0);\n        else if ((a & _3n) === _3n) {\n            res.unshift(-1);\n            a += _1n;\n        }\n        else\n            res.unshift(1);\n    }\n    return res;\n}\nexport function bls(CURVE) {\n    // Fields are specific for curve, so for now we'll need to pass them with opts\n    const { Fp, Fr, Fp2, Fp6, Fp12 } = CURVE.fields;\n    const BLS_X_IS_NEGATIVE = CURVE.params.xNegative;\n    const TWIST = CURVE.params.twistType;\n    // Point on G1 curve: (x, y)\n    const G1_ = weierstrassPoints({ n: Fr.ORDER, ...CURVE.G1 });\n    const G1 = Object.assign(G1_, createHasher(G1_.ProjectivePoint, CURVE.G1.mapToCurve, {\n        ...CURVE.htfDefaults,\n        ...CURVE.G1.htfDefaults,\n    }));\n    // Point on G2 curve (complex numbers): (x₁, x₂+i), (y₁, y₂+i)\n    const G2_ = weierstrassPoints({ n: Fr.ORDER, ...CURVE.G2 });\n    const G2 = Object.assign(G2_, createHasher(G2_.ProjectivePoint, CURVE.G2.mapToCurve, {\n        ...CURVE.htfDefaults,\n        ...CURVE.G2.htfDefaults,\n    }));\n    // Applies sparse multiplication as line function\n    let lineFunction;\n    if (TWIST === 'multiplicative') {\n        lineFunction = (c0, c1, c2, f, Px, Py) => Fp12.mul014(f, c0, Fp2.mul(c1, Px), Fp2.mul(c2, Py));\n    }\n    else if (TWIST === 'divisive') {\n        // NOTE: it should be [c0, c1, c2], but we use different order here to reduce complexity of\n        // precompute calculations.\n        lineFunction = (c0, c1, c2, f, Px, Py) => Fp12.mul034(f, Fp2.mul(c2, Py), Fp2.mul(c1, Px), c0);\n    }\n    else\n        throw new Error('bls: unknown twist type');\n    const Fp2div2 = Fp2.div(Fp2.ONE, Fp2.mul(Fp2.ONE, _2n));\n    function pointDouble(ell, Rx, Ry, Rz) {\n        const t0 = Fp2.sqr(Ry); // Ry²\n        const t1 = Fp2.sqr(Rz); // Rz²\n        const t2 = Fp2.mulByB(Fp2.mul(t1, _3n)); // 3 * T1 * B\n        const t3 = Fp2.mul(t2, _3n); // 3 * T2\n        const t4 = Fp2.sub(Fp2.sub(Fp2.sqr(Fp2.add(Ry, Rz)), t1), t0); // (Ry + Rz)² - T1 - T0\n        const c0 = Fp2.sub(t2, t0); // T2 - T0 (i)\n        const c1 = Fp2.mul(Fp2.sqr(Rx), _3n); // 3 * Rx²\n        const c2 = Fp2.neg(t4); // -T4 (-h)\n        ell.push([c0, c1, c2]);\n        Rx = Fp2.mul(Fp2.mul(Fp2.mul(Fp2.sub(t0, t3), Rx), Ry), Fp2div2); // ((T0 - T3) * Rx * Ry) / 2\n        Ry = Fp2.sub(Fp2.sqr(Fp2.mul(Fp2.add(t0, t3), Fp2div2)), Fp2.mul(Fp2.sqr(t2), _3n)); // ((T0 + T3) / 2)² - 3 * T2²\n        Rz = Fp2.mul(t0, t4); // T0 * T4\n        return { Rx, Ry, Rz };\n    }\n    function pointAdd(ell, Rx, Ry, Rz, Qx, Qy) {\n        // Addition\n        const t0 = Fp2.sub(Ry, Fp2.mul(Qy, Rz)); // Ry - Qy * Rz\n        const t1 = Fp2.sub(Rx, Fp2.mul(Qx, Rz)); // Rx - Qx * Rz\n        const c0 = Fp2.sub(Fp2.mul(t0, Qx), Fp2.mul(t1, Qy)); // T0 * Qx - T1 * Qy == Ry * Qx  - Rx * Qy\n        const c1 = Fp2.neg(t0); // -T0 == Qy * Rz - Ry\n        const c2 = t1; // == Rx - Qx * Rz\n        ell.push([c0, c1, c2]);\n        const t2 = Fp2.sqr(t1); // T1²\n        const t3 = Fp2.mul(t2, t1); // T2 * T1\n        const t4 = Fp2.mul(t2, Rx); // T2 * Rx\n        const t5 = Fp2.add(Fp2.sub(t3, Fp2.mul(t4, _2n)), Fp2.mul(Fp2.sqr(t0), Rz)); // T3 - 2 * T4 + T0² * Rz\n        Rx = Fp2.mul(t1, t5); // T1 * T5\n        Ry = Fp2.sub(Fp2.mul(Fp2.sub(t4, t5), t0), Fp2.mul(t3, Ry)); // (T4 - T5) * T0 - T3 * Ry\n        Rz = Fp2.mul(Rz, t3); // Rz * T3\n        return { Rx, Ry, Rz };\n    }\n    // Pre-compute coefficients for sparse multiplication\n    // Point addition and point double calculations is reused for coefficients\n    // pointAdd happens only if bit set, so wNAF is reasonable. Unfortunately we cannot combine\n    // add + double in windowed precomputes here, otherwise it would be single op (since X is static)\n    const ATE_NAF = NAfDecomposition(CURVE.params.ateLoopSize);\n    const calcPairingPrecomputes = memoized((point) => {\n        const p = point;\n        const { x, y } = p.toAffine();\n        // prettier-ignore\n        const Qx = x, Qy = y, negQy = Fp2.neg(y);\n        // prettier-ignore\n        let Rx = Qx, Ry = Qy, Rz = Fp2.ONE;\n        const ell = [];\n        for (const bit of ATE_NAF) {\n            const cur = [];\n            ({ Rx, Ry, Rz } = pointDouble(cur, Rx, Ry, Rz));\n            if (bit)\n                ({ Rx, Ry, Rz } = pointAdd(cur, Rx, Ry, Rz, Qx, bit === -1 ? negQy : Qy));\n            ell.push(cur);\n        }\n        if (CURVE.postPrecompute) {\n            const last = ell[ell.length - 1];\n            CURVE.postPrecompute(Rx, Ry, Rz, Qx, Qy, pointAdd.bind(null, last));\n        }\n        return ell;\n    });\n    function millerLoopBatch(pairs, withFinalExponent = false) {\n        let f12 = Fp12.ONE;\n        if (pairs.length) {\n            const ellLen = pairs[0][0].length;\n            for (let i = 0; i < ellLen; i++) {\n                f12 = Fp12.sqr(f12); // This allows us to do sqr only one time for all pairings\n                // NOTE: we apply multiple pairings in parallel here\n                for (const [ell, Px, Py] of pairs) {\n                    for (const [c0, c1, c2] of ell[i])\n                        f12 = lineFunction(c0, c1, c2, f12, Px, Py);\n                }\n            }\n        }\n        if (BLS_X_IS_NEGATIVE)\n            f12 = Fp12.conjugate(f12);\n        return withFinalExponent ? Fp12.finalExponentiate(f12) : f12;\n    }\n    // Calculates product of multiple pairings\n    // This up to x2 faster than just `map(({g1, g2})=>pairing({g1,g2}))`\n    function pairingBatch(pairs, withFinalExponent = true) {\n        const res = [];\n        // This cache precomputed toAffine for all points\n        G1.ProjectivePoint.normalizeZ(pairs.map(({ g1 }) => g1));\n        G2.ProjectivePoint.normalizeZ(pairs.map(({ g2 }) => g2));\n        for (const { g1, g2 } of pairs) {\n            if (g1.equals(G1.ProjectivePoint.ZERO) || g2.equals(G2.ProjectivePoint.ZERO))\n                throw new Error('pairing is not available for ZERO point');\n            // This uses toAffine inside\n            g1.assertValidity();\n            g2.assertValidity();\n            const Qa = g1.toAffine();\n            res.push([calcPairingPrecomputes(g2), Qa.x, Qa.y]);\n        }\n        return millerLoopBatch(res, withFinalExponent);\n    }\n    // Calculates bilinear pairing\n    function pairing(Q, P, withFinalExponent = true) {\n        return pairingBatch([{ g1: Q, g2: P }], withFinalExponent);\n    }\n    const utils = {\n        randomPrivateKey: () => {\n            const length = getMinHashLength(Fr.ORDER);\n            return mapHashToField(CURVE.randomBytes(length), Fr.ORDER);\n        },\n        calcPairingPrecomputes,\n    };\n    const { ShortSignature } = CURVE.G1;\n    const { Signature } = CURVE.G2;\n    function normP1(point) {\n        return point instanceof G1.ProjectivePoint ? point : G1.ProjectivePoint.fromHex(point);\n    }\n    function normP1Hash(point, htfOpts) {\n        return point instanceof G1.ProjectivePoint\n            ? point\n            : G1.hashToCurve(ensureBytes('point', point), htfOpts);\n    }\n    function normP2(point) {\n        return point instanceof G2.ProjectivePoint ? point : Signature.fromHex(point);\n    }\n    function normP2Hash(point, htfOpts) {\n        return point instanceof G2.ProjectivePoint\n            ? point\n            : G2.hashToCurve(ensureBytes('point', point), htfOpts);\n    }\n    // Multiplies generator (G1) by private key.\n    // P = pk x G\n    function getPublicKey(privateKey) {\n        return G1.ProjectivePoint.fromPrivateKey(privateKey).toRawBytes(true);\n    }\n    // Multiplies generator (G2) by private key.\n    // P = pk x G\n    function getPublicKeyForShortSignatures(privateKey) {\n        return G2.ProjectivePoint.fromPrivateKey(privateKey).toRawBytes(true);\n    }\n    function sign(message, privateKey, htfOpts) {\n        const msgPoint = normP2Hash(message, htfOpts);\n        msgPoint.assertValidity();\n        const sigPoint = msgPoint.multiply(G1.normPrivateKeyToScalar(privateKey));\n        if (message instanceof G2.ProjectivePoint)\n            return sigPoint;\n        return Signature.toRawBytes(sigPoint);\n    }\n    function signShortSignature(message, privateKey, htfOpts) {\n        const msgPoint = normP1Hash(message, htfOpts);\n        msgPoint.assertValidity();\n        const sigPoint = msgPoint.multiply(G1.normPrivateKeyToScalar(privateKey));\n        if (message instanceof G1.ProjectivePoint)\n            return sigPoint;\n        return ShortSignature.toRawBytes(sigPoint);\n    }\n    // Checks if pairing of public key & hash is equal to pairing of generator & signature.\n    // e(P, H(m)) == e(G, S)\n    function verify(signature, message, publicKey, htfOpts) {\n        const P = normP1(publicKey);\n        const Hm = normP2Hash(message, htfOpts);\n        const G = G1.ProjectivePoint.BASE;\n        const S = normP2(signature);\n        const exp = pairingBatch([\n            { g1: P.negate(), g2: Hm }, // ePHM = pairing(P.negate(), Hm, false);\n            { g1: G, g2: S }, // eGS = pairing(G, S, false);\n        ]);\n        return Fp12.eql(exp, Fp12.ONE);\n    }\n    // Checks if pairing of public key & hash is equal to pairing of generator & signature.\n    // e(S, G) == e(H(m), P)\n    function verifyShortSignature(signature, message, publicKey, htfOpts) {\n        const P = normP2(publicKey);\n        const Hm = normP1Hash(message, htfOpts);\n        const G = G2.ProjectivePoint.BASE;\n        const S = normP1(signature);\n        const exp = pairingBatch([\n            { g1: Hm, g2: P }, // eHmP = pairing(Hm, P, false);\n            { g1: S, g2: G.negate() }, // eSG = pairing(S, G.negate(), false);\n        ]);\n        return Fp12.eql(exp, Fp12.ONE);\n    }\n    function aNonEmpty(arr) {\n        if (!Array.isArray(arr) || arr.length === 0)\n            throw new Error('expected non-empty array');\n    }\n    function aggregatePublicKeys(publicKeys) {\n        aNonEmpty(publicKeys);\n        const agg = publicKeys.map(normP1).reduce((sum, p) => sum.add(p), G1.ProjectivePoint.ZERO);\n        const aggAffine = agg; //.toAffine();\n        if (publicKeys[0] instanceof G1.ProjectivePoint) {\n            aggAffine.assertValidity();\n            return aggAffine;\n        }\n        // toRawBytes ensures point validity\n        return aggAffine.toRawBytes(true);\n    }\n    function aggregateSignatures(signatures) {\n        aNonEmpty(signatures);\n        const agg = signatures.map(normP2).reduce((sum, s) => sum.add(s), G2.ProjectivePoint.ZERO);\n        const aggAffine = agg; //.toAffine();\n        if (signatures[0] instanceof G2.ProjectivePoint) {\n            aggAffine.assertValidity();\n            return aggAffine;\n        }\n        return Signature.toRawBytes(aggAffine);\n    }\n    function aggregateShortSignatures(signatures) {\n        aNonEmpty(signatures);\n        const agg = signatures.map(normP1).reduce((sum, s) => sum.add(s), G1.ProjectivePoint.ZERO);\n        const aggAffine = agg; //.toAffine();\n        if (signatures[0] instanceof G1.ProjectivePoint) {\n            aggAffine.assertValidity();\n            return aggAffine;\n        }\n        return ShortSignature.toRawBytes(aggAffine);\n    }\n    // https://ethresear.ch/t/fast-verification-of-multiple-bls-signatures/5407\n    // e(G, S) = e(G, SUM(n)(Si)) = MUL(n)(e(G, Si))\n    function verifyBatch(signature, \n    // TODO: maybe `{message: G2Hex, publicKey: G1Hex}[]` instead?\n    messages, publicKeys, htfOpts) {\n        aNonEmpty(messages);\n        if (publicKeys.length !== messages.length)\n            throw new Error('amount of public keys and messages should be equal');\n        const sig = normP2(signature);\n        const nMessages = messages.map((i) => normP2Hash(i, htfOpts));\n        const nPublicKeys = publicKeys.map(normP1);\n        // NOTE: this works only for exact same object\n        const messagePubKeyMap = new Map();\n        for (let i = 0; i < nPublicKeys.length; i++) {\n            const pub = nPublicKeys[i];\n            const msg = nMessages[i];\n            let keys = messagePubKeyMap.get(msg);\n            if (keys === undefined) {\n                keys = [];\n                messagePubKeyMap.set(msg, keys);\n            }\n            keys.push(pub);\n        }\n        const paired = [];\n        try {\n            for (const [msg, keys] of messagePubKeyMap) {\n                const groupPublicKey = keys.reduce((acc, msg) => acc.add(msg));\n                paired.push({ g1: groupPublicKey, g2: msg });\n            }\n            paired.push({ g1: G1.ProjectivePoint.BASE.negate(), g2: sig });\n            return Fp12.eql(pairingBatch(paired), Fp12.ONE);\n        }\n        catch {\n            return false;\n        }\n    }\n    G1.ProjectivePoint.BASE._setWindowSize(4);\n    return {\n        getPublicKey,\n        getPublicKeyForShortSignatures,\n        sign,\n        signShortSignature,\n        verify,\n        verifyBatch,\n        verifyShortSignature,\n        aggregatePublicKeys,\n        aggregateSignatures,\n        aggregateShortSignatures,\n        millerLoopBatch,\n        pairing,\n        pairingBatch,\n        G1,\n        G2,\n        Signature,\n        ShortSignature,\n        fields: {\n            Fr,\n            Fp,\n            Fp2,\n            Fp6,\n            Fp12,\n        },\n        params: {\n            ateLoopSize: CURVE.params.ateLoopSize,\n            r: CURVE.params.r,\n            G1b: CURVE.G1.b,\n            G2b: CURVE.G2.b,\n        },\n        utils,\n    };\n}\n//# sourceMappingURL=bls.js.map","/**\n * Towered extension fields.\n * Rather than implementing a massive 12th-degree extension directly, it is more efficient\n * to build it up from smaller extensions: a tower of extensions.\n *\n * For BLS12-381, the Fp12 field is implemented as a quadratic (degree two) extension,\n * on top of a cubic (degree three) extension, on top of a quadratic extension of Fp.\n *\n * For more info: \"Pairings for beginners\" by Costello, section 7.3.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport * as mod from './modular.js';\nimport { bitLen, bitMask, concatBytes, notImplemented } from './utils.js';\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\nfunction calcFrobeniusCoefficients(Fp, nonResidue, modulus, degree, num = 1, divisor) {\n    const _divisor = BigInt(divisor === undefined ? degree : divisor);\n    const towerModulus = modulus ** BigInt(degree);\n    const res = [];\n    for (let i = 0; i < num; i++) {\n        const a = BigInt(i + 1);\n        const powers = [];\n        for (let j = 0, qPower = _1n; j < degree; j++) {\n            const power = ((a * qPower - a) / _divisor) % towerModulus;\n            powers.push(Fp.pow(nonResidue, power));\n            qPower *= modulus;\n        }\n        res.push(powers);\n    }\n    return res;\n}\n// This works same at least for bls12-381, bn254 and bls12-377\nexport function psiFrobenius(Fp, Fp2, base) {\n    // Ψ endomorphism\n    const PSI_X = Fp2.pow(base, (Fp.ORDER - _1n) / _3n); // u^((p-1)/3)\n    const PSI_Y = Fp2.pow(base, (Fp.ORDER - _1n) / _2n); // u^((p-1)/2)\n    function psi(x, y) {\n        // This x10 faster than previous version in bls12-381\n        const x2 = Fp2.mul(Fp2.frobeniusMap(x, 1), PSI_X);\n        const y2 = Fp2.mul(Fp2.frobeniusMap(y, 1), PSI_Y);\n        return [x2, y2];\n    }\n    // Ψ²(P) endomorphism (psi2(x) = psi(psi(x)))\n    const PSI2_X = Fp2.pow(base, (Fp.ORDER ** _2n - _1n) / _3n); // u^((p^2 - 1)/3)\n    // This equals -1, which causes y to be Fp2.neg(y).\n    // But not sure if there are case when this is not true?\n    const PSI2_Y = Fp2.pow(base, (Fp.ORDER ** _2n - _1n) / _2n); // u^((p^2 - 1)/3)\n    if (!Fp2.eql(PSI2_Y, Fp2.neg(Fp2.ONE)))\n        throw new Error('psiFrobenius: PSI2_Y!==-1');\n    function psi2(x, y) {\n        return [Fp2.mul(x, PSI2_X), Fp2.neg(y)];\n    }\n    // Map points\n    const mapAffine = (fn) => (c, P) => {\n        const affine = P.toAffine();\n        const p = fn(affine.x, affine.y);\n        return c.fromAffine({ x: p[0], y: p[1] });\n    };\n    const G2psi = mapAffine(psi);\n    const G2psi2 = mapAffine(psi2);\n    return { psi, psi2, G2psi, G2psi2, PSI_X, PSI_Y, PSI2_X, PSI2_Y };\n}\nexport function tower12(opts) {\n    const { ORDER } = opts;\n    // Fp\n    const Fp = mod.Field(ORDER);\n    const FpNONRESIDUE = Fp.create(opts.NONRESIDUE || BigInt(-1));\n    const FpLegendre = mod.FpLegendre(ORDER);\n    const Fpdiv2 = Fp.div(Fp.ONE, _2n); // 1/2\n    // Fp2\n    const FP2_FROBENIUS_COEFFICIENTS = calcFrobeniusCoefficients(Fp, FpNONRESIDUE, Fp.ORDER, 2)[0];\n    const Fp2Add = ({ c0, c1 }, { c0: r0, c1: r1 }) => ({\n        c0: Fp.add(c0, r0),\n        c1: Fp.add(c1, r1),\n    });\n    const Fp2Subtract = ({ c0, c1 }, { c0: r0, c1: r1 }) => ({\n        c0: Fp.sub(c0, r0),\n        c1: Fp.sub(c1, r1),\n    });\n    const Fp2Multiply = ({ c0, c1 }, rhs) => {\n        if (typeof rhs === 'bigint')\n            return { c0: Fp.mul(c0, rhs), c1: Fp.mul(c1, rhs) };\n        // (a+bi)(c+di) = (ac−bd) + (ad+bc)i\n        const { c0: r0, c1: r1 } = rhs;\n        let t1 = Fp.mul(c0, r0); // c0 * o0\n        let t2 = Fp.mul(c1, r1); // c1 * o1\n        // (T1 - T2) + ((c0 + c1) * (r0 + r1) - (T1 + T2))*i\n        const o0 = Fp.sub(t1, t2);\n        const o1 = Fp.sub(Fp.mul(Fp.add(c0, c1), Fp.add(r0, r1)), Fp.add(t1, t2));\n        return { c0: o0, c1: o1 };\n    };\n    const Fp2Square = ({ c0, c1 }) => {\n        const a = Fp.add(c0, c1);\n        const b = Fp.sub(c0, c1);\n        const c = Fp.add(c0, c0);\n        return { c0: Fp.mul(a, b), c1: Fp.mul(c, c1) };\n    };\n    const Fp2fromBigTuple = (tuple) => {\n        if (tuple.length !== 2)\n            throw new Error('invalid tuple');\n        const fps = tuple.map((n) => Fp.create(n));\n        return { c0: fps[0], c1: fps[1] };\n    };\n    const FP2_ORDER = ORDER * ORDER;\n    const Fp2Nonresidue = Fp2fromBigTuple(opts.FP2_NONRESIDUE);\n    const Fp2 = {\n        ORDER: FP2_ORDER,\n        isLE: Fp.isLE,\n        NONRESIDUE: Fp2Nonresidue,\n        BITS: bitLen(FP2_ORDER),\n        BYTES: Math.ceil(bitLen(FP2_ORDER) / 8),\n        MASK: bitMask(bitLen(FP2_ORDER)),\n        ZERO: { c0: Fp.ZERO, c1: Fp.ZERO },\n        ONE: { c0: Fp.ONE, c1: Fp.ZERO },\n        create: (num) => num,\n        isValid: ({ c0, c1 }) => typeof c0 === 'bigint' && typeof c1 === 'bigint',\n        is0: ({ c0, c1 }) => Fp.is0(c0) && Fp.is0(c1),\n        eql: ({ c0, c1 }, { c0: r0, c1: r1 }) => Fp.eql(c0, r0) && Fp.eql(c1, r1),\n        neg: ({ c0, c1 }) => ({ c0: Fp.neg(c0), c1: Fp.neg(c1) }),\n        pow: (num, power) => mod.FpPow(Fp2, num, power),\n        invertBatch: (nums) => mod.FpInvertBatch(Fp2, nums),\n        // Normalized\n        add: Fp2Add,\n        sub: Fp2Subtract,\n        mul: Fp2Multiply,\n        sqr: Fp2Square,\n        // NonNormalized stuff\n        addN: Fp2Add,\n        subN: Fp2Subtract,\n        mulN: Fp2Multiply,\n        sqrN: Fp2Square,\n        // Why inversion for bigint inside Fp instead of Fp2? it is even used in that context?\n        div: (lhs, rhs) => Fp2.mul(lhs, typeof rhs === 'bigint' ? Fp.inv(Fp.create(rhs)) : Fp2.inv(rhs)),\n        inv: ({ c0: a, c1: b }) => {\n            // We wish to find the multiplicative inverse of a nonzero\n            // element a + bu in Fp2. We leverage an identity\n            //\n            // (a + bu)(a - bu) = a² + b²\n            //\n            // which holds because u² = -1. This can be rewritten as\n            //\n            // (a + bu)(a - bu)/(a² + b²) = 1\n            //\n            // because a² + b² = 0 has no nonzero solutions for (a, b).\n            // This gives that (a - bu)/(a² + b²) is the inverse\n            // of (a + bu). Importantly, this can be computing using\n            // only a single inversion in Fp.\n            const factor = Fp.inv(Fp.create(a * a + b * b));\n            return { c0: Fp.mul(factor, Fp.create(a)), c1: Fp.mul(factor, Fp.create(-b)) };\n        },\n        sqrt: (num) => {\n            if (opts.Fp2sqrt)\n                return opts.Fp2sqrt(num);\n            // This is generic for all quadratic extensions (Fp2)\n            const { c0, c1 } = num;\n            if (Fp.is0(c1)) {\n                // if c0 is quadratic residue\n                if (Fp.eql(FpLegendre(Fp, c0), Fp.ONE))\n                    return Fp2.create({ c0: Fp.sqrt(c0), c1: Fp.ZERO });\n                else\n                    return Fp2.create({ c0: Fp.ZERO, c1: Fp.sqrt(Fp.div(c0, FpNONRESIDUE)) });\n            }\n            const a = Fp.sqrt(Fp.sub(Fp.sqr(c0), Fp.mul(Fp.sqr(c1), FpNONRESIDUE)));\n            let d = Fp.mul(Fp.add(a, c0), Fpdiv2);\n            const legendre = FpLegendre(Fp, d);\n            // -1, Quadratic non residue\n            if (!Fp.is0(legendre) && !Fp.eql(legendre, Fp.ONE))\n                d = Fp.sub(d, a);\n            const a0 = Fp.sqrt(d);\n            const candidateSqrt = Fp2.create({ c0: a0, c1: Fp.div(Fp.mul(c1, Fpdiv2), a0) });\n            if (!Fp2.eql(Fp2.sqr(candidateSqrt), num))\n                throw new Error('Cannot find square root');\n            // Normalize root: at this point candidateSqrt ** 2 = num, but also -candidateSqrt ** 2 = num\n            const x1 = candidateSqrt;\n            const x2 = Fp2.neg(x1);\n            const { re: re1, im: im1 } = Fp2.reim(x1);\n            const { re: re2, im: im2 } = Fp2.reim(x2);\n            if (im1 > im2 || (im1 === im2 && re1 > re2))\n                return x1;\n            return x2;\n        },\n        // Same as sgn0_m_eq_2 in RFC 9380\n        isOdd: (x) => {\n            const { re: x0, im: x1 } = Fp2.reim(x);\n            const sign_0 = x0 % _2n;\n            const zero_0 = x0 === _0n;\n            const sign_1 = x1 % _2n;\n            return BigInt(sign_0 || (zero_0 && sign_1)) == _1n;\n        },\n        // Bytes util\n        fromBytes(b) {\n            if (b.length !== Fp2.BYTES)\n                throw new Error('fromBytes invalid length=' + b.length);\n            return { c0: Fp.fromBytes(b.subarray(0, Fp.BYTES)), c1: Fp.fromBytes(b.subarray(Fp.BYTES)) };\n        },\n        toBytes: ({ c0, c1 }) => concatBytes(Fp.toBytes(c0), Fp.toBytes(c1)),\n        cmov: ({ c0, c1 }, { c0: r0, c1: r1 }, c) => ({\n            c0: Fp.cmov(c0, r0, c),\n            c1: Fp.cmov(c1, r1, c),\n        }),\n        reim: ({ c0, c1 }) => ({ re: c0, im: c1 }),\n        // multiply by u + 1\n        mulByNonresidue: ({ c0, c1 }) => Fp2.mul({ c0, c1 }, Fp2Nonresidue),\n        mulByB: opts.Fp2mulByB,\n        fromBigTuple: Fp2fromBigTuple,\n        frobeniusMap: ({ c0, c1 }, power) => ({\n            c0,\n            c1: Fp.mul(c1, FP2_FROBENIUS_COEFFICIENTS[power % 2]),\n        }),\n    };\n    // Fp6\n    const Fp6Add = ({ c0, c1, c2 }, { c0: r0, c1: r1, c2: r2 }) => ({\n        c0: Fp2.add(c0, r0),\n        c1: Fp2.add(c1, r1),\n        c2: Fp2.add(c2, r2),\n    });\n    const Fp6Subtract = ({ c0, c1, c2 }, { c0: r0, c1: r1, c2: r2 }) => ({\n        c0: Fp2.sub(c0, r0),\n        c1: Fp2.sub(c1, r1),\n        c2: Fp2.sub(c2, r2),\n    });\n    const Fp6Multiply = ({ c0, c1, c2 }, rhs) => {\n        if (typeof rhs === 'bigint') {\n            return {\n                c0: Fp2.mul(c0, rhs),\n                c1: Fp2.mul(c1, rhs),\n                c2: Fp2.mul(c2, rhs),\n            };\n        }\n        const { c0: r0, c1: r1, c2: r2 } = rhs;\n        const t0 = Fp2.mul(c0, r0); // c0 * o0\n        const t1 = Fp2.mul(c1, r1); // c1 * o1\n        const t2 = Fp2.mul(c2, r2); // c2 * o2\n        return {\n            // t0 + (c1 + c2) * (r1 * r2) - (T1 + T2) * (u + 1)\n            c0: Fp2.add(t0, Fp2.mulByNonresidue(Fp2.sub(Fp2.mul(Fp2.add(c1, c2), Fp2.add(r1, r2)), Fp2.add(t1, t2)))),\n            // (c0 + c1) * (r0 + r1) - (T0 + T1) + T2 * (u + 1)\n            c1: Fp2.add(Fp2.sub(Fp2.mul(Fp2.add(c0, c1), Fp2.add(r0, r1)), Fp2.add(t0, t1)), Fp2.mulByNonresidue(t2)),\n            // T1 + (c0 + c2) * (r0 + r2) - T0 + T2\n            c2: Fp2.sub(Fp2.add(t1, Fp2.mul(Fp2.add(c0, c2), Fp2.add(r0, r2))), Fp2.add(t0, t2)),\n        };\n    };\n    const Fp6Square = ({ c0, c1, c2 }) => {\n        let t0 = Fp2.sqr(c0); // c0²\n        let t1 = Fp2.mul(Fp2.mul(c0, c1), _2n); // 2 * c0 * c1\n        let t3 = Fp2.mul(Fp2.mul(c1, c2), _2n); // 2 * c1 * c2\n        let t4 = Fp2.sqr(c2); // c2²\n        return {\n            c0: Fp2.add(Fp2.mulByNonresidue(t3), t0), // T3 * (u + 1) + T0\n            c1: Fp2.add(Fp2.mulByNonresidue(t4), t1), // T4 * (u + 1) + T1\n            // T1 + (c0 - c1 + c2)² + T3 - T0 - T4\n            c2: Fp2.sub(Fp2.sub(Fp2.add(Fp2.add(t1, Fp2.sqr(Fp2.add(Fp2.sub(c0, c1), c2))), t3), t0), t4),\n        };\n    };\n    const [FP6_FROBENIUS_COEFFICIENTS_1, FP6_FROBENIUS_COEFFICIENTS_2] = calcFrobeniusCoefficients(Fp2, Fp2Nonresidue, Fp.ORDER, 6, 2, 3);\n    const Fp6 = {\n        ORDER: Fp2.ORDER, // TODO: unused, but need to verify\n        isLE: Fp2.isLE,\n        BITS: 3 * Fp2.BITS,\n        BYTES: 3 * Fp2.BYTES,\n        MASK: bitMask(3 * Fp2.BITS),\n        ZERO: { c0: Fp2.ZERO, c1: Fp2.ZERO, c2: Fp2.ZERO },\n        ONE: { c0: Fp2.ONE, c1: Fp2.ZERO, c2: Fp2.ZERO },\n        create: (num) => num,\n        isValid: ({ c0, c1, c2 }) => Fp2.isValid(c0) && Fp2.isValid(c1) && Fp2.isValid(c2),\n        is0: ({ c0, c1, c2 }) => Fp2.is0(c0) && Fp2.is0(c1) && Fp2.is0(c2),\n        neg: ({ c0, c1, c2 }) => ({ c0: Fp2.neg(c0), c1: Fp2.neg(c1), c2: Fp2.neg(c2) }),\n        eql: ({ c0, c1, c2 }, { c0: r0, c1: r1, c2: r2 }) => Fp2.eql(c0, r0) && Fp2.eql(c1, r1) && Fp2.eql(c2, r2),\n        sqrt: notImplemented,\n        // Do we need division by bigint at all? Should be done via order:\n        div: (lhs, rhs) => Fp6.mul(lhs, typeof rhs === 'bigint' ? Fp.inv(Fp.create(rhs)) : Fp6.inv(rhs)),\n        pow: (num, power) => mod.FpPow(Fp6, num, power),\n        invertBatch: (nums) => mod.FpInvertBatch(Fp6, nums),\n        // Normalized\n        add: Fp6Add,\n        sub: Fp6Subtract,\n        mul: Fp6Multiply,\n        sqr: Fp6Square,\n        // NonNormalized stuff\n        addN: Fp6Add,\n        subN: Fp6Subtract,\n        mulN: Fp6Multiply,\n        sqrN: Fp6Square,\n        inv: ({ c0, c1, c2 }) => {\n            let t0 = Fp2.sub(Fp2.sqr(c0), Fp2.mulByNonresidue(Fp2.mul(c2, c1))); // c0² - c2 * c1 * (u + 1)\n            let t1 = Fp2.sub(Fp2.mulByNonresidue(Fp2.sqr(c2)), Fp2.mul(c0, c1)); // c2² * (u + 1) - c0 * c1\n            let t2 = Fp2.sub(Fp2.sqr(c1), Fp2.mul(c0, c2)); // c1² - c0 * c2\n            // 1/(((c2 * T1 + c1 * T2) * v) + c0 * T0)\n            let t4 = Fp2.inv(Fp2.add(Fp2.mulByNonresidue(Fp2.add(Fp2.mul(c2, t1), Fp2.mul(c1, t2))), Fp2.mul(c0, t0)));\n            return { c0: Fp2.mul(t4, t0), c1: Fp2.mul(t4, t1), c2: Fp2.mul(t4, t2) };\n        },\n        // Bytes utils\n        fromBytes: (b) => {\n            if (b.length !== Fp6.BYTES)\n                throw new Error('fromBytes invalid length=' + b.length);\n            return {\n                c0: Fp2.fromBytes(b.subarray(0, Fp2.BYTES)),\n                c1: Fp2.fromBytes(b.subarray(Fp2.BYTES, 2 * Fp2.BYTES)),\n                c2: Fp2.fromBytes(b.subarray(2 * Fp2.BYTES)),\n            };\n        },\n        toBytes: ({ c0, c1, c2 }) => concatBytes(Fp2.toBytes(c0), Fp2.toBytes(c1), Fp2.toBytes(c2)),\n        cmov: ({ c0, c1, c2 }, { c0: r0, c1: r1, c2: r2 }, c) => ({\n            c0: Fp2.cmov(c0, r0, c),\n            c1: Fp2.cmov(c1, r1, c),\n            c2: Fp2.cmov(c2, r2, c),\n        }),\n        fromBigSix: (t) => {\n            if (!Array.isArray(t) || t.length !== 6)\n                throw new Error('invalid Fp6 usage');\n            return {\n                c0: Fp2.fromBigTuple(t.slice(0, 2)),\n                c1: Fp2.fromBigTuple(t.slice(2, 4)),\n                c2: Fp2.fromBigTuple(t.slice(4, 6)),\n            };\n        },\n        frobeniusMap: ({ c0, c1, c2 }, power) => ({\n            c0: Fp2.frobeniusMap(c0, power),\n            c1: Fp2.mul(Fp2.frobeniusMap(c1, power), FP6_FROBENIUS_COEFFICIENTS_1[power % 6]),\n            c2: Fp2.mul(Fp2.frobeniusMap(c2, power), FP6_FROBENIUS_COEFFICIENTS_2[power % 6]),\n        }),\n        mulByFp2: ({ c0, c1, c2 }, rhs) => ({\n            c0: Fp2.mul(c0, rhs),\n            c1: Fp2.mul(c1, rhs),\n            c2: Fp2.mul(c2, rhs),\n        }),\n        mulByNonresidue: ({ c0, c1, c2 }) => ({ c0: Fp2.mulByNonresidue(c2), c1: c0, c2: c1 }),\n        // Sparse multiplication\n        mul1: ({ c0, c1, c2 }, b1) => ({\n            c0: Fp2.mulByNonresidue(Fp2.mul(c2, b1)),\n            c1: Fp2.mul(c0, b1),\n            c2: Fp2.mul(c1, b1),\n        }),\n        // Sparse multiplication\n        mul01({ c0, c1, c2 }, b0, b1) {\n            let t0 = Fp2.mul(c0, b0); // c0 * b0\n            let t1 = Fp2.mul(c1, b1); // c1 * b1\n            return {\n                // ((c1 + c2) * b1 - T1) * (u + 1) + T0\n                c0: Fp2.add(Fp2.mulByNonresidue(Fp2.sub(Fp2.mul(Fp2.add(c1, c2), b1), t1)), t0),\n                // (b0 + b1) * (c0 + c1) - T0 - T1\n                c1: Fp2.sub(Fp2.sub(Fp2.mul(Fp2.add(b0, b1), Fp2.add(c0, c1)), t0), t1),\n                // (c0 + c2) * b0 - T0 + T1\n                c2: Fp2.add(Fp2.sub(Fp2.mul(Fp2.add(c0, c2), b0), t0), t1),\n            };\n        },\n    };\n    // Fp12\n    const FP12_FROBENIUS_COEFFICIENTS = calcFrobeniusCoefficients(Fp2, Fp2Nonresidue, Fp.ORDER, 12, 1, 6)[0];\n    const Fp12Add = ({ c0, c1 }, { c0: r0, c1: r1 }) => ({\n        c0: Fp6.add(c0, r0),\n        c1: Fp6.add(c1, r1),\n    });\n    const Fp12Subtract = ({ c0, c1 }, { c0: r0, c1: r1 }) => ({\n        c0: Fp6.sub(c0, r0),\n        c1: Fp6.sub(c1, r1),\n    });\n    const Fp12Multiply = ({ c0, c1 }, rhs) => {\n        if (typeof rhs === 'bigint')\n            return { c0: Fp6.mul(c0, rhs), c1: Fp6.mul(c1, rhs) };\n        let { c0: r0, c1: r1 } = rhs;\n        let t1 = Fp6.mul(c0, r0); // c0 * r0\n        let t2 = Fp6.mul(c1, r1); // c1 * r1\n        return {\n            c0: Fp6.add(t1, Fp6.mulByNonresidue(t2)), // T1 + T2 * v\n            // (c0 + c1) * (r0 + r1) - (T1 + T2)\n            c1: Fp6.sub(Fp6.mul(Fp6.add(c0, c1), Fp6.add(r0, r1)), Fp6.add(t1, t2)),\n        };\n    };\n    const Fp12Square = ({ c0, c1 }) => {\n        let ab = Fp6.mul(c0, c1); // c0 * c1\n        return {\n            // (c1 * v + c0) * (c0 + c1) - AB - AB * v\n            c0: Fp6.sub(Fp6.sub(Fp6.mul(Fp6.add(Fp6.mulByNonresidue(c1), c0), Fp6.add(c0, c1)), ab), Fp6.mulByNonresidue(ab)),\n            c1: Fp6.add(ab, ab),\n        }; // AB + AB\n    };\n    function Fp4Square(a, b) {\n        const a2 = Fp2.sqr(a);\n        const b2 = Fp2.sqr(b);\n        return {\n            first: Fp2.add(Fp2.mulByNonresidue(b2), a2), // b² * Nonresidue + a²\n            second: Fp2.sub(Fp2.sub(Fp2.sqr(Fp2.add(a, b)), a2), b2), // (a + b)² - a² - b²\n        };\n    }\n    const Fp12 = {\n        ORDER: Fp2.ORDER, // TODO: unused, but need to verify\n        isLE: Fp6.isLE,\n        BITS: 2 * Fp2.BITS,\n        BYTES: 2 * Fp2.BYTES,\n        MASK: bitMask(2 * Fp2.BITS),\n        ZERO: { c0: Fp6.ZERO, c1: Fp6.ZERO },\n        ONE: { c0: Fp6.ONE, c1: Fp6.ZERO },\n        create: (num) => num,\n        isValid: ({ c0, c1 }) => Fp6.isValid(c0) && Fp6.isValid(c1),\n        is0: ({ c0, c1 }) => Fp6.is0(c0) && Fp6.is0(c1),\n        neg: ({ c0, c1 }) => ({ c0: Fp6.neg(c0), c1: Fp6.neg(c1) }),\n        eql: ({ c0, c1 }, { c0: r0, c1: r1 }) => Fp6.eql(c0, r0) && Fp6.eql(c1, r1),\n        sqrt: notImplemented,\n        inv: ({ c0, c1 }) => {\n            let t = Fp6.inv(Fp6.sub(Fp6.sqr(c0), Fp6.mulByNonresidue(Fp6.sqr(c1)))); // 1 / (c0² - c1² * v)\n            return { c0: Fp6.mul(c0, t), c1: Fp6.neg(Fp6.mul(c1, t)) }; // ((C0 * T) * T) + (-C1 * T) * w\n        },\n        div: (lhs, rhs) => Fp12.mul(lhs, typeof rhs === 'bigint' ? Fp.inv(Fp.create(rhs)) : Fp12.inv(rhs)),\n        pow: (num, power) => mod.FpPow(Fp12, num, power),\n        invertBatch: (nums) => mod.FpInvertBatch(Fp12, nums),\n        // Normalized\n        add: Fp12Add,\n        sub: Fp12Subtract,\n        mul: Fp12Multiply,\n        sqr: Fp12Square,\n        // NonNormalized stuff\n        addN: Fp12Add,\n        subN: Fp12Subtract,\n        mulN: Fp12Multiply,\n        sqrN: Fp12Square,\n        // Bytes utils\n        fromBytes: (b) => {\n            if (b.length !== Fp12.BYTES)\n                throw new Error('fromBytes invalid length=' + b.length);\n            return {\n                c0: Fp6.fromBytes(b.subarray(0, Fp6.BYTES)),\n                c1: Fp6.fromBytes(b.subarray(Fp6.BYTES)),\n            };\n        },\n        toBytes: ({ c0, c1 }) => concatBytes(Fp6.toBytes(c0), Fp6.toBytes(c1)),\n        cmov: ({ c0, c1 }, { c0: r0, c1: r1 }, c) => ({\n            c0: Fp6.cmov(c0, r0, c),\n            c1: Fp6.cmov(c1, r1, c),\n        }),\n        // Utils\n        // toString() {\n        //   return '' + 'Fp12(' + this.c0 + this.c1 + '* w');\n        // },\n        // fromTuple(c: [Fp6, Fp6]) {\n        //   return new Fp12(...c);\n        // }\n        fromBigTwelve: (t) => ({\n            c0: Fp6.fromBigSix(t.slice(0, 6)),\n            c1: Fp6.fromBigSix(t.slice(6, 12)),\n        }),\n        // Raises to q**i -th power\n        frobeniusMap(lhs, power) {\n            const { c0, c1, c2 } = Fp6.frobeniusMap(lhs.c1, power);\n            const coeff = FP12_FROBENIUS_COEFFICIENTS[power % 12];\n            return {\n                c0: Fp6.frobeniusMap(lhs.c0, power),\n                c1: Fp6.create({\n                    c0: Fp2.mul(c0, coeff),\n                    c1: Fp2.mul(c1, coeff),\n                    c2: Fp2.mul(c2, coeff),\n                }),\n            };\n        },\n        mulByFp2: ({ c0, c1 }, rhs) => ({\n            c0: Fp6.mulByFp2(c0, rhs),\n            c1: Fp6.mulByFp2(c1, rhs),\n        }),\n        conjugate: ({ c0, c1 }) => ({ c0, c1: Fp6.neg(c1) }),\n        // Sparse multiplication\n        mul014: ({ c0, c1 }, o0, o1, o4) => {\n            let t0 = Fp6.mul01(c0, o0, o1);\n            let t1 = Fp6.mul1(c1, o4);\n            return {\n                c0: Fp6.add(Fp6.mulByNonresidue(t1), t0), // T1 * v + T0\n                // (c1 + c0) * [o0, o1+o4] - T0 - T1\n                c1: Fp6.sub(Fp6.sub(Fp6.mul01(Fp6.add(c1, c0), o0, Fp2.add(o1, o4)), t0), t1),\n            };\n        },\n        mul034: ({ c0, c1 }, o0, o3, o4) => {\n            const a = Fp6.create({\n                c0: Fp2.mul(c0.c0, o0),\n                c1: Fp2.mul(c0.c1, o0),\n                c2: Fp2.mul(c0.c2, o0),\n            });\n            const b = Fp6.mul01(c1, o3, o4);\n            const e = Fp6.mul01(Fp6.add(c0, c1), Fp2.add(o0, o3), o4);\n            return {\n                c0: Fp6.add(Fp6.mulByNonresidue(b), a),\n                c1: Fp6.sub(e, Fp6.add(a, b)),\n            };\n        },\n        // A cyclotomic group is a subgroup of Fp^n defined by\n        //   GΦₙ(p) = {α ∈ Fpⁿ : α^Φₙ(p) = 1}\n        // The result of any pairing is in a cyclotomic subgroup\n        // https://eprint.iacr.org/2009/565.pdf\n        _cyclotomicSquare: opts.Fp12cyclotomicSquare,\n        _cyclotomicExp: opts.Fp12cyclotomicExp,\n        // https://eprint.iacr.org/2010/354.pdf\n        // https://eprint.iacr.org/2009/565.pdf\n        finalExponentiate: opts.Fp12finalExponentiate,\n    };\n    return { Fp, Fp2, Fp6, Fp4Square, Fp12 };\n}\n//# sourceMappingURL=tower.js.map","/**\n * bls12-381 is pairing-friendly Barreto-Lynn-Scott elliptic curve construction allowing to:\n * * Construct zk-SNARKs at the ~120-bit security\n * * Efficiently verify N aggregate signatures with 1 pairing and N ec additions:\n *   the Boneh-Lynn-Shacham signature scheme is orders of magnitude more efficient than Schnorr\n *\n * ### Summary\n * 1. BLS Relies on Bilinear Pairing (expensive)\n * 2. Private Keys: 32 bytes\n * 3. Public Keys: 48 bytes: 381 bit affine x coordinate, encoded into 48 big-endian bytes.\n * 4. Signatures: 96 bytes: two 381 bit integers (affine x coordinate), encoded into two 48 big-endian byte arrays.\n *     - The signature is a point on the G2 subgroup, which is defined over a finite field\n *       with elements twice as big as the G1 curve (G2 is over Fp2 rather than Fp. Fp2 is analogous to the\n *       complex numbers).\n *     - We also support reversed 96-byte pubkeys & 48-byte short signatures.\n * 5. The 12 stands for the Embedding degree.\n *\n * ### Formulas\n * - `P = pk x G` - public keys\n * - `S = pk x H(m)` - signing\n * - `e(P, H(m)) == e(G, S)` - verification using pairings\n * - `e(G, S) = e(G, SUM(n)(Si)) = MUL(n)(e(G, Si))` - signature aggregation\n *\n * ### Compatibility and notes\n * 1. It is compatible with Algorand, Chia, Dfinity, Ethereum, Filecoin, ZEC.\n * Filecoin uses little endian byte arrays for private keys - make sure to reverse byte order.\n * 2. Some projects use G2 for public keys and G1 for signatures. It's called \"short signature\".\n * 3. Curve security level is about 120 bits as per [Barbulescu-Duquesne 2017](https://hal.science/hal-01534101/file/main.pdf)\n * 4. Compatible with specs:\n *    [cfrg-pairing-friendly-curves-11](https://tools.ietf.org/html/draft-irtf-cfrg-pairing-friendly-curves-11),\n *    [cfrg-bls-signature-05](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature-05),\n *    [RFC 9380](https://www.rfc-editor.org/rfc/rfc9380).\n *\n * ### Params\n * To verify curve parameters, see\n * [pairing-friendly-curves spec](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-pairing-friendly-curves-11).\n * Basic math is done over finite fields over p.\n * More complicated math is done over polynominal extension fields.\n * To simplify calculations in Fp12, we construct extension tower:\n *\n * Embedding degree (k): 12\n * Seed (X): -15132376222941642752\n * Fr:  (x⁴-x²+1)\n * Fp: ((x-1)² ⋅ r(x)/3+x)\n * (E/Fp): Y²=X³+4\n * (Eₜ/Fp²): Y² = X³+4(u+1) (M-type twist)\n * Ate loop size: X\n *\n * ### Towers\n * - Fp₁₂ = Fp₆² => Fp₂³\n * - Fp(u) / (u² - β) where β = -1\n * - Fp₂(v) / (v³ - ξ) where ξ = u + 1\n * - Fp₆(w) / (w² - γ) where γ = v\n * - Fp²[u] = Fp/u²+1\n * - Fp⁶[v] = Fp²/v³-1-u\n * - Fp¹²[w] = Fp⁶/w²-v\n *\n * @todo construct bls & bn fp/fr from seed.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha256';\nimport { randomBytes } from '@noble/hashes/utils';\nimport { bls } from './abstract/bls.js';\nimport * as mod from './abstract/modular.js';\nimport { bitGet, bitLen, bytesToHex, bytesToNumberBE, concatBytes as concatB, ensureBytes, numberToBytesBE, } from './abstract/utils.js';\n// Types\nimport { isogenyMap } from './abstract/hash-to-curve.js';\nimport { psiFrobenius, tower12 } from './abstract/tower.js';\nimport { mapToCurveSimpleSWU, } from './abstract/weierstrass.js';\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\n// The BLS parameter x (seed) for BLS12-381. NOTE: it is negative!\nconst BLS_X = BigInt('0xd201000000010000');\nconst BLS_X_LEN = bitLen(BLS_X);\n// CURVE FIELDS\nconst { Fp, Fp2, Fp6, Fp4Square, Fp12 } = tower12({\n    // Order of Fp\n    ORDER: BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'),\n    // Finite extension field over irreducible polynominal.\n    // Fp(u) / (u² - β) where β = -1\n    FP2_NONRESIDUE: [_1n, _1n],\n    Fp2mulByB: ({ c0, c1 }) => {\n        const t0 = Fp.mul(c0, _4n); // 4 * c0\n        const t1 = Fp.mul(c1, _4n); // 4 * c1\n        // (T0-T1) + (T0+T1)*i\n        return { c0: Fp.sub(t0, t1), c1: Fp.add(t0, t1) };\n    },\n    // Fp12\n    // A cyclotomic group is a subgroup of Fp^n defined by\n    //   GΦₙ(p) = {α ∈ Fpⁿ : α^Φₙ(p) = 1}\n    // The result of any pairing is in a cyclotomic subgroup\n    // https://eprint.iacr.org/2009/565.pdf\n    Fp12cyclotomicSquare: ({ c0, c1 }) => {\n        const { c0: c0c0, c1: c0c1, c2: c0c2 } = c0;\n        const { c0: c1c0, c1: c1c1, c2: c1c2 } = c1;\n        const { first: t3, second: t4 } = Fp4Square(c0c0, c1c1);\n        const { first: t5, second: t6 } = Fp4Square(c1c0, c0c2);\n        const { first: t7, second: t8 } = Fp4Square(c0c1, c1c2);\n        const t9 = Fp2.mulByNonresidue(t8); // T8 * (u + 1)\n        return {\n            c0: Fp6.create({\n                c0: Fp2.add(Fp2.mul(Fp2.sub(t3, c0c0), _2n), t3), // 2 * (T3 - c0c0)  + T3\n                c1: Fp2.add(Fp2.mul(Fp2.sub(t5, c0c1), _2n), t5), // 2 * (T5 - c0c1)  + T5\n                c2: Fp2.add(Fp2.mul(Fp2.sub(t7, c0c2), _2n), t7),\n            }), // 2 * (T7 - c0c2)  + T7\n            c1: Fp6.create({\n                c0: Fp2.add(Fp2.mul(Fp2.add(t9, c1c0), _2n), t9), // 2 * (T9 + c1c0) + T9\n                c1: Fp2.add(Fp2.mul(Fp2.add(t4, c1c1), _2n), t4), // 2 * (T4 + c1c1) + T4\n                c2: Fp2.add(Fp2.mul(Fp2.add(t6, c1c2), _2n), t6),\n            }),\n        }; // 2 * (T6 + c1c2) + T6\n    },\n    Fp12cyclotomicExp(num, n) {\n        let z = Fp12.ONE;\n        for (let i = BLS_X_LEN - 1; i >= 0; i--) {\n            z = Fp12._cyclotomicSquare(z);\n            if (bitGet(n, i))\n                z = Fp12.mul(z, num);\n        }\n        return z;\n    },\n    // https://eprint.iacr.org/2010/354.pdf\n    // https://eprint.iacr.org/2009/565.pdf\n    Fp12finalExponentiate: (num) => {\n        const x = BLS_X;\n        // this^(q⁶) / this\n        const t0 = Fp12.div(Fp12.frobeniusMap(num, 6), num);\n        // t0^(q²) * t0\n        const t1 = Fp12.mul(Fp12.frobeniusMap(t0, 2), t0);\n        const t2 = Fp12.conjugate(Fp12._cyclotomicExp(t1, x));\n        const t3 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicSquare(t1)), t2);\n        const t4 = Fp12.conjugate(Fp12._cyclotomicExp(t3, x));\n        const t5 = Fp12.conjugate(Fp12._cyclotomicExp(t4, x));\n        const t6 = Fp12.mul(Fp12.conjugate(Fp12._cyclotomicExp(t5, x)), Fp12._cyclotomicSquare(t2));\n        const t7 = Fp12.conjugate(Fp12._cyclotomicExp(t6, x));\n        const t2_t5_pow_q2 = Fp12.frobeniusMap(Fp12.mul(t2, t5), 2);\n        const t4_t1_pow_q3 = Fp12.frobeniusMap(Fp12.mul(t4, t1), 3);\n        const t6_t1c_pow_q1 = Fp12.frobeniusMap(Fp12.mul(t6, Fp12.conjugate(t1)), 1);\n        const t7_t3c_t1 = Fp12.mul(Fp12.mul(t7, Fp12.conjugate(t3)), t1);\n        // (t2 * t5)^(q²) * (t4 * t1)^(q³) * (t6 * t1.conj)^(q^1) * t7 * t3.conj * t1\n        return Fp12.mul(Fp12.mul(Fp12.mul(t2_t5_pow_q2, t4_t1_pow_q3), t6_t1c_pow_q1), t7_t3c_t1);\n    },\n});\n// Finite field over r.\n// This particular field is not used anywhere in bls12-381, but it is still useful.\nconst Fr = mod.Field(BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001'));\n// END OF CURVE FIELDS\n// HashToCurve\n// 3-isogeny map from E' to E https://www.rfc-editor.org/rfc/rfc9380#appendix-E.3\nconst isogenyMapG2 = isogenyMap(Fp2, [\n    // xNum\n    [\n        [\n            '0x5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97d6',\n            '0x5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97d6',\n        ],\n        [\n            '0x0',\n            '0x11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71a',\n        ],\n        [\n            '0x11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71e',\n            '0x8ab05f8bdd54cde190937e76bc3e447cc27c3d6fbd7063fcd104635a790520c0a395554e5c6aaaa9354ffffffffe38d',\n        ],\n        [\n            '0x171d6541fa38ccfaed6dea691f5fb614cb14b4e7f4e810aa22d6108f142b85757098e38d0f671c7188e2aaaaaaaa5ed1',\n            '0x0',\n        ],\n    ],\n    // xDen\n    [\n        [\n            '0x0',\n            '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa63',\n        ],\n        [\n            '0xc',\n            '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa9f',\n        ],\n        ['0x1', '0x0'], // LAST 1\n    ],\n    // yNum\n    [\n        [\n            '0x1530477c7ab4113b59a4c18b076d11930f7da5d4a07f649bf54439d87d27e500fc8c25ebf8c92f6812cfc71c71c6d706',\n            '0x1530477c7ab4113b59a4c18b076d11930f7da5d4a07f649bf54439d87d27e500fc8c25ebf8c92f6812cfc71c71c6d706',\n        ],\n        [\n            '0x0',\n            '0x5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97be',\n        ],\n        [\n            '0x11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71c',\n            '0x8ab05f8bdd54cde190937e76bc3e447cc27c3d6fbd7063fcd104635a790520c0a395554e5c6aaaa9354ffffffffe38f',\n        ],\n        [\n            '0x124c9ad43b6cf79bfbf7043de3811ad0761b0f37a1e26286b0e977c69aa274524e79097a56dc4bd9e1b371c71c718b10',\n            '0x0',\n        ],\n    ],\n    // yDen\n    [\n        [\n            '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa8fb',\n            '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa8fb',\n        ],\n        [\n            '0x0',\n            '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa9d3',\n        ],\n        [\n            '0x12',\n            '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa99',\n        ],\n        ['0x1', '0x0'], // LAST 1\n    ],\n].map((i) => i.map((pair) => Fp2.fromBigTuple(pair.map(BigInt)))));\n// 11-isogeny map from E' to E\nconst isogenyMapG1 = isogenyMap(Fp, [\n    // xNum\n    [\n        '0x11a05f2b1e833340b809101dd99815856b303e88a2d7005ff2627b56cdb4e2c85610c2d5f2e62d6eaeac1662734649b7',\n        '0x17294ed3e943ab2f0588bab22147a81c7c17e75b2f6a8417f565e33c70d1e86b4838f2a6f318c356e834eef1b3cb83bb',\n        '0xd54005db97678ec1d1048c5d10a9a1bce032473295983e56878e501ec68e25c958c3e3d2a09729fe0179f9dac9edcb0',\n        '0x1778e7166fcc6db74e0609d307e55412d7f5e4656a8dbf25f1b33289f1b330835336e25ce3107193c5b388641d9b6861',\n        '0xe99726a3199f4436642b4b3e4118e5499db995a1257fb3f086eeb65982fac18985a286f301e77c451154ce9ac8895d9',\n        '0x1630c3250d7313ff01d1201bf7a74ab5db3cb17dd952799b9ed3ab9097e68f90a0870d2dcae73d19cd13c1c66f652983',\n        '0xd6ed6553fe44d296a3726c38ae652bfb11586264f0f8ce19008e218f9c86b2a8da25128c1052ecaddd7f225a139ed84',\n        '0x17b81e7701abdbe2e8743884d1117e53356de5ab275b4db1a682c62ef0f2753339b7c8f8c8f475af9ccb5618e3f0c88e',\n        '0x80d3cf1f9a78fc47b90b33563be990dc43b756ce79f5574a2c596c928c5d1de4fa295f296b74e956d71986a8497e317',\n        '0x169b1f8e1bcfa7c42e0c37515d138f22dd2ecb803a0c5c99676314baf4bb1b7fa3190b2edc0327797f241067be390c9e',\n        '0x10321da079ce07e272d8ec09d2565b0dfa7dccdde6787f96d50af36003b14866f69b771f8c285decca67df3f1605fb7b',\n        '0x6e08c248e260e70bd1e962381edee3d31d79d7e22c837bc23c0bf1bc24c6b68c24b1b80b64d391fa9c8ba2e8ba2d229',\n    ],\n    // xDen\n    [\n        '0x8ca8d548cff19ae18b2e62f4bd3fa6f01d5ef4ba35b48ba9c9588617fc8ac62b558d681be343df8993cf9fa40d21b1c',\n        '0x12561a5deb559c4348b4711298e536367041e8ca0cf0800c0126c2588c48bf5713daa8846cb026e9e5c8276ec82b3bff',\n        '0xb2962fe57a3225e8137e629bff2991f6f89416f5a718cd1fca64e00b11aceacd6a3d0967c94fedcfcc239ba5cb83e19',\n        '0x3425581a58ae2fec83aafef7c40eb545b08243f16b1655154cca8abc28d6fd04976d5243eecf5c4130de8938dc62cd8',\n        '0x13a8e162022914a80a6f1d5f43e7a07dffdfc759a12062bb8d6b44e833b306da9bd29ba81f35781d539d395b3532a21e',\n        '0xe7355f8e4e667b955390f7f0506c6e9395735e9ce9cad4d0a43bcef24b8982f7400d24bc4228f11c02df9a29f6304a5',\n        '0x772caacf16936190f3e0c63e0596721570f5799af53a1894e2e073062aede9cea73b3538f0de06cec2574496ee84a3a',\n        '0x14a7ac2a9d64a8b230b3f5b074cf01996e7f63c21bca68a81996e1cdf9822c580fa5b9489d11e2d311f7d99bbdcc5a5e',\n        '0xa10ecf6ada54f825e920b3dafc7a3cce07f8d1d7161366b74100da67f39883503826692abba43704776ec3a79a1d641',\n        '0x95fc13ab9e92ad4476d6e3eb3a56680f682b4ee96f7d03776df533978f31c1593174e4b4b7865002d6384d168ecdd0a',\n        '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n    // yNum\n    [\n        '0x90d97c81ba24ee0259d1f094980dcfa11ad138e48a869522b52af6c956543d3cd0c7aee9b3ba3c2be9845719707bb33',\n        '0x134996a104ee5811d51036d776fb46831223e96c254f383d0f906343eb67ad34d6c56711962fa8bfe097e75a2e41c696',\n        '0xcc786baa966e66f4a384c86a3b49942552e2d658a31ce2c344be4b91400da7d26d521628b00523b8dfe240c72de1f6',\n        '0x1f86376e8981c217898751ad8746757d42aa7b90eeb791c09e4a3ec03251cf9de405aba9ec61deca6355c77b0e5f4cb',\n        '0x8cc03fdefe0ff135caf4fe2a21529c4195536fbe3ce50b879833fd221351adc2ee7f8dc099040a841b6daecf2e8fedb',\n        '0x16603fca40634b6a2211e11db8f0a6a074a7d0d4afadb7bd76505c3d3ad5544e203f6326c95a807299b23ab13633a5f0',\n        '0x4ab0b9bcfac1bbcb2c977d027796b3ce75bb8ca2be184cb5231413c4d634f3747a87ac2460f415ec961f8855fe9d6f2',\n        '0x987c8d5333ab86fde9926bd2ca6c674170a05bfe3bdd81ffd038da6c26c842642f64550fedfe935a15e4ca31870fb29',\n        '0x9fc4018bd96684be88c9e221e4da1bb8f3abd16679dc26c1e8b6e6a1f20cabe69d65201c78607a360370e577bdba587',\n        '0xe1bba7a1186bdb5223abde7ada14a23c42a0ca7915af6fe06985e7ed1e4d43b9b3f7055dd4eba6f2bafaaebca731c30',\n        '0x19713e47937cd1be0dfd0b8f1d43fb93cd2fcbcb6caf493fd1183e416389e61031bf3a5cce3fbafce813711ad011c132',\n        '0x18b46a908f36f6deb918c143fed2edcc523559b8aaf0c2462e6bfe7f911f643249d9cdf41b44d606ce07c8a4d0074d8e',\n        '0xb182cac101b9399d155096004f53f447aa7b12a3426b08ec02710e807b4633f06c851c1919211f20d4c04f00b971ef8',\n        '0x245a394ad1eca9b72fc00ae7be315dc757b3b080d4c158013e6632d3c40659cc6cf90ad1c232a6442d9d3f5db980133',\n        '0x5c129645e44cf1102a159f748c4a3fc5e673d81d7e86568d9ab0f5d396a7ce46ba1049b6579afb7866b1e715475224b',\n        '0x15e6be4e990f03ce4ea50b3b42df2eb5cb181d8f84965a3957add4fa95af01b2b665027efec01c7704b456be69c8b604',\n    ],\n    // yDen\n    [\n        '0x16112c4c3a9c98b252181140fad0eae9601a6de578980be6eec3232b5be72e7a07f3688ef60c206d01479253b03663c1',\n        '0x1962d75c2381201e1a0cbd6c43c348b885c84ff731c4d59ca4a10356f453e01f78a4260763529e3532f6102c2e49a03d',\n        '0x58df3306640da276faaae7d6e8eb15778c4855551ae7f310c35a5dd279cd2eca6757cd636f96f891e2538b53dbf67f2',\n        '0x16b7d288798e5395f20d23bf89edb4d1d115c5dbddbcd30e123da489e726af41727364f2c28297ada8d26d98445f5416',\n        '0xbe0e079545f43e4b00cc912f8228ddcc6d19c9f0f69bbb0542eda0fc9dec916a20b15dc0fd2ededda39142311a5001d',\n        '0x8d9e5297186db2d9fb266eaac783182b70152c65550d881c5ecd87b6f0f5a6449f38db9dfa9cce202c6477faaf9b7ac',\n        '0x166007c08a99db2fc3ba8734ace9824b5eecfdfa8d0cf8ef5dd365bc400a0051d5fa9c01a58b1fb93d1a1399126a775c',\n        '0x16a3ef08be3ea7ea03bcddfabba6ff6ee5a4375efa1f4fd7feb34fd206357132b920f5b00801dee460ee415a15812ed9',\n        '0x1866c8ed336c61231a1be54fd1d74cc4f9fb0ce4c6af5920abc5750c4bf39b4852cfe2f7bb9248836b233d9d55535d4a',\n        '0x167a55cda70a6e1cea820597d94a84903216f763e13d87bb5308592e7ea7d4fbc7385ea3d529b35e346ef48bb8913f55',\n        '0x4d2f259eea405bd48f010a01ad2911d9c6dd039bb61a6290e591b36e636a5c871a5c29f4f83060400f8b49cba8f6aa8',\n        '0xaccbb67481d033ff5852c1e48c50c477f94ff8aefce42d28c0f9a88cea7913516f968986f7ebbea9684b529e2561092',\n        '0xad6b9514c767fe3c3613144b45f1496543346d98adf02267d5ceef9a00d9b8693000763e3b90ac11e99b138573345cc',\n        '0x2660400eb2e4f3b628bdd0d53cd76f2bf565b94e72927c1cb748df27942480e420517bd8714cc80d1fadc1326ed06f7',\n        '0xe0fa1d816ddc03e6b24255e0d7819c171c40f65e273b853324efcd6356caa205ca2f570f13497804415473a1d634b8f',\n        '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n].map((i) => i.map((j) => BigInt(j))));\n// SWU Map - Fp2 to G2': y² = x³ + 240i * x + 1012 + 1012i\nconst G2_SWU = mapToCurveSimpleSWU(Fp2, {\n    A: Fp2.create({ c0: Fp.create(_0n), c1: Fp.create(BigInt(240)) }), // A' = 240 * I\n    B: Fp2.create({ c0: Fp.create(BigInt(1012)), c1: Fp.create(BigInt(1012)) }), // B' = 1012 * (1 + I)\n    Z: Fp2.create({ c0: Fp.create(BigInt(-2)), c1: Fp.create(BigInt(-1)) }), // Z: -(2 + I)\n});\n// Optimized SWU Map - Fp to G1\nconst G1_SWU = mapToCurveSimpleSWU(Fp, {\n    A: Fp.create(BigInt('0x144698a3b8e9433d693a02c96d4982b0ea985383ee66a8d8e8981aefd881ac98936f8da0e0f97f5cf428082d584c1d')),\n    B: Fp.create(BigInt('0x12e2908d11688030018b12e8753eee3b2016c1f0f24f4070a0b9c14fcef35ef55a23215a316ceaa5d1cc48e98e172be0')),\n    Z: Fp.create(BigInt(11)),\n});\n// Endomorphisms (for fast cofactor clearing)\n// Ψ(P) endomorphism\nconst { G2psi, G2psi2 } = psiFrobenius(Fp, Fp2, Fp2.div(Fp2.ONE, Fp2.NONRESIDUE)); // 1/(u+1)\n// Default hash_to_field options are for hash to G2.\n//\n// Parameter definitions are in section 5.3 of the spec unless otherwise noted.\n// Parameter values come from section 8.8.2 of the spec.\n// https://www.rfc-editor.org/rfc/rfc9380#section-8.8.2\n//\n// Base field F is GF(p^m)\n// p = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab\n// m = 2 (or 1 for G1 see section 8.8.1)\n// k = 128\nconst htfDefaults = Object.freeze({\n    // DST: a domain separation tag\n    // defined in section 2.2.5\n    // Use utils.getDSTLabel(), utils.setDSTLabel(value)\n    DST: 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_',\n    encodeDST: 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_',\n    // p: the characteristic of F\n    //    where F is a finite field of characteristic p and order q = p^m\n    p: Fp.ORDER,\n    // m: the extension degree of F, m >= 1\n    //     where F is a finite field of characteristic p and order q = p^m\n    m: 2,\n    // k: the target security level for the suite in bits\n    // defined in section 5.1\n    k: 128,\n    // option to use a message that has already been processed by\n    // expand_message_xmd\n    expand: 'xmd',\n    // Hash functions for: expand_message_xmd is appropriate for use with a\n    // wide range of hash functions, including SHA-2, SHA-3, BLAKE2, and others.\n    // BBS+ uses blake2: https://github.com/hyperledger/aries-framework-go/issues/2247\n    hash: sha256,\n});\n// Encoding utils\n// Point on G1 curve: (x, y)\n// Compressed point of infinity\nconst COMPRESSED_ZERO = setMask(Fp.toBytes(_0n), { infinity: true, compressed: true }); // set compressed & point-at-infinity bits\nfunction parseMask(bytes) {\n    // Copy, so we can remove mask data. It will be removed also later, when Fp.create will call modulo.\n    bytes = bytes.slice();\n    const mask = bytes[0] & 224;\n    const compressed = !!((mask >> 7) & 1); // compression bit (0b1000_0000)\n    const infinity = !!((mask >> 6) & 1); // point at infinity bit (0b0100_0000)\n    const sort = !!((mask >> 5) & 1); // sort bit (0b0010_0000)\n    bytes[0] &= 31; // clear mask (zero first 3 bits)\n    return { compressed, infinity, sort, value: bytes };\n}\nfunction setMask(bytes, mask) {\n    if (bytes[0] & 224)\n        throw new Error('setMask: non-empty mask');\n    if (mask.compressed)\n        bytes[0] |= 128;\n    if (mask.infinity)\n        bytes[0] |= 64;\n    if (mask.sort)\n        bytes[0] |= 32;\n    return bytes;\n}\nfunction signatureG1ToRawBytes(point) {\n    point.assertValidity();\n    const isZero = point.equals(bls12_381.G1.ProjectivePoint.ZERO);\n    const { x, y } = point.toAffine();\n    if (isZero)\n        return COMPRESSED_ZERO.slice();\n    const P = Fp.ORDER;\n    const sort = Boolean((y * _2n) / P);\n    return setMask(numberToBytesBE(x, Fp.BYTES), { compressed: true, sort });\n}\nfunction signatureG2ToRawBytes(point) {\n    // NOTE: by some reasons it was missed in bls12-381, looks like bug\n    point.assertValidity();\n    const len = Fp.BYTES;\n    if (point.equals(bls12_381.G2.ProjectivePoint.ZERO))\n        return concatB(COMPRESSED_ZERO, numberToBytesBE(_0n, len));\n    const { x, y } = point.toAffine();\n    const { re: x0, im: x1 } = Fp2.reim(x);\n    const { re: y0, im: y1 } = Fp2.reim(y);\n    const tmp = y1 > _0n ? y1 * _2n : y0 * _2n;\n    const sort = Boolean((tmp / Fp.ORDER) & _1n);\n    const z2 = x0;\n    return concatB(setMask(numberToBytesBE(x1, len), { sort, compressed: true }), numberToBytesBE(z2, len));\n}\n/**\n * bls12-381 pairing-friendly curve.\n * @example\n * import { bls12_381 as bls } from '@noble/curves/bls12-381';\n * // G1 keys, G2 signatures\n * const privateKey = '67d53f170b908cabb9eb326c3c337762d59289a8fec79f7bc9254b584b73265c';\n * const message = '64726e3da8';\n * const publicKey = bls.getPublicKey(privateKey);\n * const signature = bls.sign(message, privateKey);\n * const isValid = bls.verify(signature, message, publicKey);\n */\nexport const bls12_381 = bls({\n    // Fields\n    fields: {\n        Fp,\n        Fp2,\n        Fp6,\n        Fp12,\n        Fr,\n    },\n    // G1 is the order-q subgroup of E1(Fp) : y² = x³ + 4, #E1(Fp) = h1q, where\n    // characteristic; z + (z⁴ - z² + 1)(z - 1)²/3\n    G1: {\n        Fp,\n        // cofactor; (z - 1)²/3\n        h: BigInt('0x396c8c005555e1568c00aaab0000aaab'),\n        // generator's coordinates\n        // x = 3685416753713387016781088315183077757961620795782546409894578378688607592378376318836054947676345821548104185464507\n        // y = 1339506544944476473020471379941921221584933875938349620426543736416511423956333506472724655353366534992391756441569\n        Gx: BigInt('0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'),\n        Gy: BigInt('0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'),\n        a: Fp.ZERO,\n        b: _4n,\n        htfDefaults: { ...htfDefaults, m: 1, DST: 'BLS_SIG_BLS12381G1_XMD:SHA-256_SSWU_RO_NUL_' },\n        wrapPrivateKey: true,\n        allowInfinityPoint: true,\n        // Checks is the point resides in prime-order subgroup.\n        // point.isTorsionFree() should return true for valid points\n        // It returns false for shitty points.\n        // https://eprint.iacr.org/2021/1130.pdf\n        isTorsionFree: (c, point) => {\n            // φ endomorphism\n            const cubicRootOfUnityModP = BigInt('0x5f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe');\n            const phi = new c(Fp.mul(point.px, cubicRootOfUnityModP), point.py, point.pz);\n            // todo: unroll\n            const xP = point.multiplyUnsafe(BLS_X).negate(); // [x]P\n            const u2P = xP.multiplyUnsafe(BLS_X); // [u2]P\n            return u2P.equals(phi);\n            // https://eprint.iacr.org/2019/814.pdf\n            // (z² − 1)/3\n            // const c1 = BigInt('0x396c8c005555e1560000000055555555');\n            // const P = this;\n            // const S = P.sigma();\n            // const Q = S.double();\n            // const S2 = S.sigma();\n            // // [(z² − 1)/3](2σ(P) − P − σ²(P)) − σ²(P) = O\n            // const left = Q.subtract(P).subtract(S2).multiplyUnsafe(c1);\n            // const C = left.subtract(S2);\n            // return C.isZero();\n        },\n        // Clear cofactor of G1\n        // https://eprint.iacr.org/2019/403\n        clearCofactor: (_c, point) => {\n            // return this.multiplyUnsafe(CURVE.h);\n            return point.multiplyUnsafe(BLS_X).add(point); // x*P + P\n        },\n        mapToCurve: (scalars) => {\n            const { x, y } = G1_SWU(Fp.create(scalars[0]));\n            return isogenyMapG1(x, y);\n        },\n        fromBytes: (bytes) => {\n            const { compressed, infinity, sort, value } = parseMask(bytes);\n            if (value.length === 48 && compressed) {\n                // TODO: Fp.bytes\n                const P = Fp.ORDER;\n                const compressedValue = bytesToNumberBE(value);\n                // Zero\n                const x = Fp.create(compressedValue & Fp.MASK);\n                if (infinity) {\n                    if (x !== _0n)\n                        throw new Error('G1: non-empty compressed point at infinity');\n                    return { x: _0n, y: _0n };\n                }\n                const right = Fp.add(Fp.pow(x, _3n), Fp.create(bls12_381.params.G1b)); // y² = x³ + b\n                let y = Fp.sqrt(right);\n                if (!y)\n                    throw new Error('invalid compressed G1 point');\n                if ((y * _2n) / P !== BigInt(sort))\n                    y = Fp.neg(y);\n                return { x: Fp.create(x), y: Fp.create(y) };\n            }\n            else if (value.length === 96 && !compressed) {\n                // Check if the infinity flag is set\n                const x = bytesToNumberBE(value.subarray(0, Fp.BYTES));\n                const y = bytesToNumberBE(value.subarray(Fp.BYTES));\n                if (infinity) {\n                    if (x !== _0n || y !== _0n)\n                        throw new Error('G1: non-empty point at infinity');\n                    return bls12_381.G1.ProjectivePoint.ZERO.toAffine();\n                }\n                return { x: Fp.create(x), y: Fp.create(y) };\n            }\n            else {\n                throw new Error('invalid point G1, expected 48/96 bytes');\n            }\n        },\n        toBytes: (c, point, isCompressed) => {\n            const isZero = point.equals(c.ZERO);\n            const { x, y } = point.toAffine();\n            if (isCompressed) {\n                if (isZero)\n                    return COMPRESSED_ZERO.slice();\n                const P = Fp.ORDER;\n                const sort = Boolean((y * _2n) / P);\n                return setMask(numberToBytesBE(x, Fp.BYTES), { compressed: true, sort });\n            }\n            else {\n                if (isZero) {\n                    // 2x PUBLIC_KEY_LENGTH\n                    const x = concatB(new Uint8Array([0x40]), new Uint8Array(2 * Fp.BYTES - 1));\n                    return x;\n                }\n                else {\n                    return concatB(numberToBytesBE(x, Fp.BYTES), numberToBytesBE(y, Fp.BYTES));\n                }\n            }\n        },\n        ShortSignature: {\n            fromHex(hex) {\n                const { infinity, sort, value } = parseMask(ensureBytes('signatureHex', hex, 48));\n                const P = Fp.ORDER;\n                const compressedValue = bytesToNumberBE(value);\n                // Zero\n                if (infinity)\n                    return bls12_381.G1.ProjectivePoint.ZERO;\n                const x = Fp.create(compressedValue & Fp.MASK);\n                const right = Fp.add(Fp.pow(x, _3n), Fp.create(bls12_381.params.G1b)); // y² = x³ + b\n                let y = Fp.sqrt(right);\n                if (!y)\n                    throw new Error('invalid compressed G1 point');\n                const aflag = BigInt(sort);\n                if ((y * _2n) / P !== aflag)\n                    y = Fp.neg(y);\n                const point = bls12_381.G1.ProjectivePoint.fromAffine({ x, y });\n                point.assertValidity();\n                return point;\n            },\n            toRawBytes(point) {\n                return signatureG1ToRawBytes(point);\n            },\n            toHex(point) {\n                return bytesToHex(signatureG1ToRawBytes(point));\n            },\n        },\n    },\n    // G2 is the order-q subgroup of E2(Fp²) : y² = x³+4(1+√−1),\n    // where Fp2 is Fp[√−1]/(x2+1). #E2(Fp2 ) = h2q, where\n    // G² - 1\n    // h2q\n    G2: {\n        Fp: Fp2,\n        // cofactor\n        h: BigInt('0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5'),\n        Gx: Fp2.fromBigTuple([\n            BigInt('0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'),\n            BigInt('0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'),\n        ]),\n        // y =\n        // 927553665492332455747201965776037880757740193453592970025027978793976877002675564980949289727957565575433344219582,\n        // 1985150602287291935568054521177171638300868978215655730859378665066344726373823718423869104263333984641494340347905\n        Gy: Fp2.fromBigTuple([\n            BigInt('0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'),\n            BigInt('0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'),\n        ]),\n        a: Fp2.ZERO,\n        b: Fp2.fromBigTuple([_4n, _4n]),\n        hEff: BigInt('0xbc69f08f2ee75b3584c6a0ea91b352888e2a8e9145ad7689986ff031508ffe1329c2f178731db956d82bf015d1212b02ec0ec69d7477c1ae954cbc06689f6a359894c0adebbf6b4e8020005aaa95551'),\n        htfDefaults: { ...htfDefaults },\n        wrapPrivateKey: true,\n        allowInfinityPoint: true,\n        mapToCurve: (scalars) => {\n            const { x, y } = G2_SWU(Fp2.fromBigTuple(scalars));\n            return isogenyMapG2(x, y);\n        },\n        // Checks is the point resides in prime-order subgroup.\n        // point.isTorsionFree() should return true for valid points\n        // It returns false for shitty points.\n        // https://eprint.iacr.org/2021/1130.pdf\n        isTorsionFree: (c, P) => {\n            return P.multiplyUnsafe(BLS_X).negate().equals(G2psi(c, P)); // ψ(P) == [u](P)\n            // Older version: https://eprint.iacr.org/2019/814.pdf\n            // Ψ²(P) => Ψ³(P) => [z]Ψ³(P) where z = -x => [z]Ψ³(P) - Ψ²(P) + P == O\n            // return P.psi2().psi().mulNegX().subtract(psi2).add(P).isZero();\n        },\n        // Maps the point into the prime-order subgroup G2.\n        // clear_cofactor_bls12381_g2 from cfrg-hash-to-curve-11\n        // https://eprint.iacr.org/2017/419.pdf\n        // prettier-ignore\n        clearCofactor: (c, P) => {\n            const x = BLS_X;\n            let t1 = P.multiplyUnsafe(x).negate(); // [-x]P\n            let t2 = G2psi(c, P); // Ψ(P)\n            let t3 = P.double(); // 2P\n            t3 = G2psi2(c, t3); // Ψ²(2P)\n            t3 = t3.subtract(t2); // Ψ²(2P) - Ψ(P)\n            t2 = t1.add(t2); // [-x]P + Ψ(P)\n            t2 = t2.multiplyUnsafe(x).negate(); // [x²]P - [x]Ψ(P)\n            t3 = t3.add(t2); // Ψ²(2P) - Ψ(P) + [x²]P - [x]Ψ(P)\n            t3 = t3.subtract(t1); // Ψ²(2P) - Ψ(P) + [x²]P - [x]Ψ(P) + [x]P\n            const Q = t3.subtract(P); // Ψ²(2P) - Ψ(P) + [x²]P - [x]Ψ(P) + [x]P - 1P\n            return Q; // [x²-x-1]P + [x-1]Ψ(P) + Ψ²(2P)\n        },\n        fromBytes: (bytes) => {\n            const { compressed, infinity, sort, value } = parseMask(bytes);\n            if ((!compressed && !infinity && sort) || // 00100000\n                (!compressed && infinity && sort) || // 01100000\n                (sort && infinity && compressed) // 11100000\n            ) {\n                throw new Error('invalid encoding flag: ' + (bytes[0] & 224));\n            }\n            const L = Fp.BYTES;\n            const slc = (b, from, to) => bytesToNumberBE(b.slice(from, to));\n            if (value.length === 96 && compressed) {\n                const b = bls12_381.params.G2b;\n                const P = Fp.ORDER;\n                if (infinity) {\n                    // check that all bytes are 0\n                    if (value.reduce((p, c) => (p !== 0 ? c + 1 : c), 0) > 0) {\n                        throw new Error('invalid compressed G2 point');\n                    }\n                    return { x: Fp2.ZERO, y: Fp2.ZERO };\n                }\n                const x_1 = slc(value, 0, L);\n                const x_0 = slc(value, L, 2 * L);\n                const x = Fp2.create({ c0: Fp.create(x_0), c1: Fp.create(x_1) });\n                const right = Fp2.add(Fp2.pow(x, _3n), b); // y² = x³ + 4 * (u+1) = x³ + b\n                let y = Fp2.sqrt(right);\n                const Y_bit = y.c1 === _0n ? (y.c0 * _2n) / P : (y.c1 * _2n) / P ? _1n : _0n;\n                y = sort && Y_bit > 0 ? y : Fp2.neg(y);\n                return { x, y };\n            }\n            else if (value.length === 192 && !compressed) {\n                if (infinity) {\n                    if (value.reduce((p, c) => (p !== 0 ? c + 1 : c), 0) > 0) {\n                        throw new Error('invalid uncompressed G2 point');\n                    }\n                    return { x: Fp2.ZERO, y: Fp2.ZERO };\n                }\n                const x1 = slc(value, 0, L);\n                const x0 = slc(value, L, 2 * L);\n                const y1 = slc(value, 2 * L, 3 * L);\n                const y0 = slc(value, 3 * L, 4 * L);\n                return { x: Fp2.fromBigTuple([x0, x1]), y: Fp2.fromBigTuple([y0, y1]) };\n            }\n            else {\n                throw new Error('invalid point G2, expected 96/192 bytes');\n            }\n        },\n        toBytes: (c, point, isCompressed) => {\n            const { BYTES: len, ORDER: P } = Fp;\n            const isZero = point.equals(c.ZERO);\n            const { x, y } = point.toAffine();\n            if (isCompressed) {\n                if (isZero)\n                    return concatB(COMPRESSED_ZERO, numberToBytesBE(_0n, len));\n                const flag = Boolean(y.c1 === _0n ? (y.c0 * _2n) / P : (y.c1 * _2n) / P);\n                return concatB(setMask(numberToBytesBE(x.c1, len), { compressed: true, sort: flag }), numberToBytesBE(x.c0, len));\n            }\n            else {\n                if (isZero)\n                    return concatB(new Uint8Array([0x40]), new Uint8Array(4 * len - 1)); // bytes[0] |= 1 << 6;\n                const { re: x0, im: x1 } = Fp2.reim(x);\n                const { re: y0, im: y1 } = Fp2.reim(y);\n                return concatB(numberToBytesBE(x1, len), numberToBytesBE(x0, len), numberToBytesBE(y1, len), numberToBytesBE(y0, len));\n            }\n        },\n        Signature: {\n            // TODO: Optimize, it's very slow because of sqrt.\n            fromHex(hex) {\n                const { infinity, sort, value } = parseMask(ensureBytes('signatureHex', hex));\n                const P = Fp.ORDER;\n                const half = value.length / 2;\n                if (half !== 48 && half !== 96)\n                    throw new Error('invalid compressed signature length, must be 96 or 192');\n                const z1 = bytesToNumberBE(value.slice(0, half));\n                const z2 = bytesToNumberBE(value.slice(half));\n                // Indicates the infinity point\n                if (infinity)\n                    return bls12_381.G2.ProjectivePoint.ZERO;\n                const x1 = Fp.create(z1 & Fp.MASK);\n                const x2 = Fp.create(z2);\n                const x = Fp2.create({ c0: x2, c1: x1 });\n                const y2 = Fp2.add(Fp2.pow(x, _3n), bls12_381.params.G2b); // y² = x³ + 4\n                // The slow part\n                let y = Fp2.sqrt(y2);\n                if (!y)\n                    throw new Error('Failed to find a square root');\n                // Choose the y whose leftmost bit of the imaginary part is equal to the a_flag1\n                // If y1 happens to be zero, then use the bit of y0\n                const { re: y0, im: y1 } = Fp2.reim(y);\n                const aflag1 = BigInt(sort);\n                const isGreater = y1 > _0n && (y1 * _2n) / P !== aflag1;\n                const isZero = y1 === _0n && (y0 * _2n) / P !== aflag1;\n                if (isGreater || isZero)\n                    y = Fp2.neg(y);\n                const point = bls12_381.G2.ProjectivePoint.fromAffine({ x, y });\n                point.assertValidity();\n                return point;\n            },\n            toRawBytes(point) {\n                return signatureG2ToRawBytes(point);\n            },\n            toHex(point) {\n                return bytesToHex(signatureG2ToRawBytes(point));\n            },\n        },\n    },\n    params: {\n        ateLoopSize: BLS_X, // The BLS parameter x for BLS12-381\n        r: Fr.ORDER, // order; z⁴ − z² + 1; CURVE.n from other curves\n        xNegative: true,\n        twistType: 'multiplicative',\n    },\n    htfDefaults,\n    hash: sha256,\n    randomBytes,\n});\n//# sourceMappingURL=bls12-381.js.map","function n(n){return n>=0?n:-n}function t(n){if(\"number\"==typeof n&&(n=BigInt(n)),1n===n)return 1;let t=1;do{t++}while((n>>=1n)>1n);return t}function e(n,t){if(\"number\"==typeof n&&(n=BigInt(n)),\"number\"==typeof t&&(t=BigInt(t)),n<=0n||t<=0n)throw new RangeError(\"a and b MUST be > 0\");let e=0n,r=1n,o=1n,i=0n;for(;0n!==n;){const s=t/n,u=t%n,a=e-o*s,c=r-i*s;t=n,n=u,e=o,r=i,o=a,i=c}return{g:t,x:e,y:r}}function r(n,t){if(\"number\"==typeof n&&(n=BigInt(n)),\"number\"==typeof t&&(t=BigInt(t)),t<=0n)throw new RangeError(\"n must be > 0\");const e=n%t;return e<0n?e+t:e}function o(n,t){const o=e(r(n,t),t);if(1n!==o.g)throw new RangeError(`${n.toString()} does not have inverse modulo ${t.toString()}`);return r(o.x,t)}function i(n,t,e){if(n.length!==t.length)throw new RangeError(\"The remainders and modulos arrays should have the same length\");const i=e??t.reduce(((n,t)=>n*t),1n);return t.reduce(((t,e,s)=>{const u=i/e;return r(t+u*o(u,e)%i*n[s]%i,i)}),0n)}function s(t,e){let r=\"number\"==typeof t?BigInt(n(t)):n(t),o=\"number\"==typeof e?BigInt(n(e)):n(e);if(0n===r)return o;if(0n===o)return r;let i=0n;for(;0n===(1n&(r|o));)r>>=1n,o>>=1n,i++;for(;0n===(1n&r);)r>>=1n;do{for(;0n===(1n&o);)o>>=1n;if(r>o){const n=r;r=o,o=n}o-=r}while(0n!==o);return r<<i}function u(t,e){return\"number\"==typeof t&&(t=BigInt(t)),\"number\"==typeof e&&(e=BigInt(e)),0n===t&&0n===e?BigInt(0):n(t/s(t,e)*e)}function a(n,t){return n>=t?n:t}function c(n,t){return n>=t?t:n}function f(n,t){const e=BigInt(t);return r(n.map((n=>BigInt(n)%e)).reduce(((n,t)=>n+t%e),0n),e)}function g(n,t){const e=BigInt(t);return r(n.map((n=>BigInt(n)%e)).reduce(((n,t)=>n*t%e),1n),e)}function m(n){return n.map((n=>n[0]**(n[1]-1n)*(n[0]-1n))).reduce(((n,t)=>t*n),1n)}function d(t,e,s,u){if(\"number\"==typeof t&&(t=BigInt(t)),\"number\"==typeof e&&(e=BigInt(e)),\"number\"==typeof s&&(s=BigInt(s)),s<=0n)throw new RangeError(\"n must be > 0\");if(1n===s)return 0n;if(t=r(t,s),e<0n)return o(d(t,n(e),s,u),s);if(void 0!==u)return function(n,t,e,r){const o=r.map((n=>n[0]**n[1])),s=r.map((n=>m([n]))),u=s.map(((e,r)=>d(n,t%e,o[r])));return i(u,o,e)}(t,e,s,function(n){const t={};return n.forEach((n=>{if(\"bigint\"==typeof n||\"number\"==typeof n){const e=String(n);void 0===t[e]?t[e]={p:BigInt(n),k:1n}:t[e].k+=1n}else{const e=String(n[0]);void 0===t[e]?t[e]={p:BigInt(n[0]),k:BigInt(n[1])}:t[e].k+=BigInt(n[1])}})),Object.values(t).map((n=>[n.p,n.k]))}(u));let a=1n;for(;e>0;)e%2n===1n&&(a=a*t%s),e/=2n,t=t**2n%s;return a}function l(n){let t=0n;for(const e of n.values()){t=(t<<8n)+BigInt(e)}return t}function b(n,t=!1){if(n<1)throw new RangeError(\"byteLength MUST be > 0\");return new Promise((function(e,r){{const r=new Uint8Array(n);if(n<=65536)self.crypto.getRandomValues(r);else for(let t=0;t<Math.ceil(n/65536);t++){const e=65536*t,o=e+65535<n?e+65535:n-1;self.crypto.getRandomValues(r.subarray(e,o))}t&&(r[0]=128|r[0]),e(r)}}))}function h(n,t=!1){if(n<1)throw new RangeError(\"byteLength MUST be > 0\");{const e=new Uint8Array(n);if(n<=65536)self.crypto.getRandomValues(e);else for(let t=0;t<Math.ceil(n/65536);t++){const r=65536*t,o=r+65535<n?r+65535:n-1;self.crypto.getRandomValues(e.subarray(r,o))}return t&&(e[0]=128|e[0]),e}}function w(n,t=!1){if(n<1)throw new RangeError(\"bitLength MUST be > 0\");const e=Math.ceil(n/8),r=n%8;return new Promise(((n,o)=>{b(e,!1).then((function(e){if(0!==r&&(e[0]=e[0]&2**r-1),t){const n=0!==r?2**(r-1):128;e[0]=e[0]|n}n(e)}))}))}function p(n,t=!1){if(n<1)throw new RangeError(\"bitLength MUST be > 0\");const e=h(Math.ceil(n/8),!1),r=n%8;if(0!==r&&(e[0]=e[0]&2**r-1),t){const n=0!==r?2**(r-1):128;e[0]=e[0]|n}return e}function y(n,e=1n){if(n<=e)throw new RangeError(\"Arguments MUST be: max > min\");const r=n-e,o=t(r);let i;do{i=l(p(o))}while(i>r);return i+e}let B=!1;function I(n,t=16,e=!1){if(\"number\"==typeof n&&(n=BigInt(n)),n<0n)throw RangeError(\"w MUST be >= 0\");return new Promise(((e,r)=>{const o=new Worker($());o.onmessage=n=>{void 0!==n?.data?._bcu?.isPrime&&(o.terminate(),e(n.data._bcu.isPrime))},o.onmessageerror=n=>{r(n)};const i={_bcu:{rnd:n,iterations:t,id:0}};o.postMessage(i)}))}function S(n,t){if(2n===n)return!0;if(0n===(1n&n)||1n===n)return!1;const e=[3n,5n,7n,11n,13n,17n,19n,23n,29n,31n,37n,41n,43n,47n,53n,59n,61n,67n,71n,73n,79n,83n,89n,97n,101n,103n,107n,109n,113n,127n,131n,137n,139n,149n,151n,157n,163n,167n,173n,179n,181n,191n,193n,197n,199n,211n,223n,227n,229n,233n,239n,241n,251n,257n,263n,269n,271n,277n,281n,283n,293n,307n,311n,313n,317n,331n,337n,347n,349n,353n,359n,367n,373n,379n,383n,389n,397n,401n,409n,419n,421n,431n,433n,439n,443n,449n,457n,461n,463n,467n,479n,487n,491n,499n,503n,509n,521n,523n,541n,547n,557n,563n,569n,571n,577n,587n,593n,599n,601n,607n,613n,617n,619n,631n,641n,643n,647n,653n,659n,661n,673n,677n,683n,691n,701n,709n,719n,727n,733n,739n,743n,751n,757n,761n,769n,773n,787n,797n,809n,811n,821n,823n,827n,829n,839n,853n,857n,859n,863n,877n,881n,883n,887n,907n,911n,919n,929n,937n,941n,947n,953n,967n,971n,977n,983n,991n,997n,1009n,1013n,1019n,1021n,1031n,1033n,1039n,1049n,1051n,1061n,1063n,1069n,1087n,1091n,1093n,1097n,1103n,1109n,1117n,1123n,1129n,1151n,1153n,1163n,1171n,1181n,1187n,1193n,1201n,1213n,1217n,1223n,1229n,1231n,1237n,1249n,1259n,1277n,1279n,1283n,1289n,1291n,1297n,1301n,1303n,1307n,1319n,1321n,1327n,1361n,1367n,1373n,1381n,1399n,1409n,1423n,1427n,1429n,1433n,1439n,1447n,1451n,1453n,1459n,1471n,1481n,1483n,1487n,1489n,1493n,1499n,1511n,1523n,1531n,1543n,1549n,1553n,1559n,1567n,1571n,1579n,1583n,1597n];for(let t=0;t<e.length&&e[t]<=n;t++){const r=e[t];if(n===r)return!0;if(n%r===0n)return!1}let r=0n;const o=n-1n;let i=o;for(;i%2n===0n;)i/=2n,++r;const s=o/2n**r;do{let t=d(y(o,2n),s,n);if(1n===t||t===o)continue;let e=1;for(;e<r&&(t=d(t,2n,n),t!==o);){if(1n===t)return!1;e++}if(t!==o)return!1}while(0!=--t);return!0}function $(){let n=`\\n  'use strict';\\n  const ${e.name} = ${e.toString()};\\n  const ${o.name} = ${o.toString()};\\n  const ${d.name} = ${d.toString()};\\n  const ${r.name} = ${r.toString()};\\n  const ${p.name} = ${p.toString()};\\n  const ${h.name} = ${h.toString()};\\n  const ${y.name} = ${y.toString()};\\n  const ${I.name} = ${S.toString()};\\n  ${t.toString()};\\n  ${l.toString()};`;return n+=`\\n  onmessage = async function(msg) {\\n    if (msg !== undefined && msg.data !== undefined && msg.data._bcu !== undefined && msg.data._bcu.id !== undefined && msg.data._bcu.iterations !== undefined && msg.data._bcu.rnd !== undefined) {\\n      const msgToParent = {\\n        _bcu: {\\n          isPrime: await ${I.name}(msg.data._bcu.rnd, msg.data._bcu.iterations),\\n          value: msg.data._bcu.rnd,\\n          id: msg.data._bcu.id\\n        }\\n      };\\n      postMessage(msgToParent);\\n    }\\n  }`,function(n){n=`(() => {${n}})()`;const t=new Blob([n],{type:\"text/javascript\"});return window.URL.createObjectURL(t)}(n)}function R(n,t=16){if(n<1)throw new RangeError(\"bitLength MUST be > 0\");if(!B){let e=0n;do{e=l(p(n,!0))}while(!S(e,t));return new Promise((n=>{n(e)}))}return new Promise(((e,r)=>{const o=[],i=(r,i)=>{if(r._bcu.isPrime){for(let n=0;n<o.length;n++)o[n].terminate();for(;o.length>0;)o.pop();e(r._bcu.value)}else{const e=l(p(n,!0));try{const n={_bcu:{rnd:e,iterations:t,id:r._bcu.id}};i.postMessage(n)}catch(n){}}};{const n=$();for(let t=0;t<self.navigator.hardwareConcurrency-1;t++){const t=new Worker(n);t.onmessage=n=>i(n.data,t),o.push(t)}}for(let e=0;e<o.length;e++)w(n,!0).then((function(n){const r=l(n);o[e].postMessage({_bcu:{rnd:r,iterations:t,id:e}})})).catch(r)}))}function M(n,t=16){if(n<1)throw new RangeError(\"bitLength MUST be > 0\");let e=0n;do{e=l(p(n,!0))}while(!S(e,t));return e}void 0!==self.Worker&&(B=!0);export{n as abs,t as bitLength,i as crt,e as eGcd,s as gcd,I as isProbablyPrime,u as lcm,a as max,c as min,f as modAdd,o as modInv,g as modMultiply,d as modPow,m as phi,R as prime,M as primeSync,y as randBetween,w as randBits,p as randBitsSync,b as randBytes,h as randBytesSync,r as toZn};\n","export function concat(values) {\n    if (typeof values[0] === 'string')\n        return concatHex(values);\n    return concatBytes(values);\n}\nexport function concatBytes(values) {\n    let length = 0;\n    for (const arr of values) {\n        length += arr.length;\n    }\n    const result = new Uint8Array(length);\n    let offset = 0;\n    for (const arr of values) {\n        result.set(arr, offset);\n        offset += arr.length;\n    }\n    return result;\n}\nexport function concatHex(values) {\n    return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;\n}\n//# sourceMappingURL=concat.js.map","import hash from 'hash.js';\nimport aes from 'aes-js';\nimport { Fp, Fp2 } from '@noble/curves/abstract/tower';\nimport { ProjPointType } from '@noble/curves/abstract/weierstrass';\nimport { bls12_381 as bls } from '@noble/curves/bls12-381';\nimport { abs, gcd, lcm, randBetween } from 'bigint-crypto-utils';\nimport { ByteArray, concat } from 'viem';\n\nfunction laplace(matrix: bigint[][], r: bigint, c: bigint, order: bigint): bigint {\n  let result = 0n;\n  const cofactor = Array.from({ length: Number(order) }).map(() =>\n    Array.from({ length: Number(order) }).map(() => 0n),\n  );\n  for (let i = 0n; i < order; i++) {\n    for (let j = 0n; j < order; j++) {\n      const tmpi = i;\n      const tmpj = j;\n      if (i !== r && j !== c) {\n        if (i > r) {\n          i--;\n        }\n        if (j > c) {\n          j--;\n        }\n        cofactor[Number(i)][Number(j)] = matrix[Number(tmpi)][Number(tmpj)];\n        i = tmpi;\n        j = tmpj;\n      }\n    }\n  }\n  if (order >= 2n) {\n    result = determinant(cofactor, order - 1n).d;\n  }\n  return result;\n}\n\nfunction determinant(matrix: bigint[][], order: bigint): { d: bigint; coeff: bigint[] } {\n  let value = 0n;\n  const coeff = Array.from({ length: Number(order) }).map(() => 0n);\n  let sign = 1n;\n  if (order === 1n) {\n    value = matrix[0][0];\n    coeff[0] = 1n;\n  } else {\n    for (let i = 0n; i < order; i++) {\n      const cofactor = laplace(matrix, i, 0n, order);\n      value += sign * matrix[Number(i)][0] * cofactor;\n      coeff[Number(i)] = sign * cofactor;\n      sign *= -1n;\n    }\n  }\n  return { d: value, coeff };\n}\n\nfunction feldman(matrix: bigint[][]): { d: bigint; coeff: bigint[] } {\n  const result = determinant(matrix, BigInt(matrix.length));\n  let d = result.d;\n  const coeff = result.coeff;\n  let g = d;\n  for (let i = 0n; i < coeff.length; i++) {\n    g = gcd(g, coeff[Number(i)]);\n  }\n  d = d / g;\n  for (let i = 0n; i < coeff.length; i++) {\n    coeff[Number(i)] = coeff[Number(i)] / g;\n  }\n  if (d < 0n) {\n    d = -d;\n    for (let i = 0n; i < coeff.length; i++) {\n      coeff[Number(i)] = -coeff[Number(i)];\n    }\n  }\n  return { d, coeff };\n}\n\nfunction searchDlcm(\n  matrix: bigint[][],\n  l: bigint,\n  pos: bigint,\n  offset: bigint,\n  size: bigint,\n  threshold: bigint,\n): bigint {\n  if (pos === threshold) {\n    const result = feldman(matrix);\n    let d = result.d;\n    const coeff = result.coeff;\n    let g = d;\n    for (let i = 0n; i < coeff.length; i++) {\n      g = gcd(g, coeff[Number(i)]);\n    }\n    d = d / g;\n    return BigInt(abs(d));\n  }\n  for (let i = pos + offset; i < size - threshold + pos + 1n; i++) {\n    const row: bigint[] = Array.from({ length: Number(threshold) }).map(() => 0n);\n    for (let j = 0n; j < threshold; j++) {\n      row[Number(j)] = (i + 1n) ** j;\n    }\n    matrix[Number(pos)] = row;\n    l = lcm(l, searchDlcm(matrix, l, pos + 1n, i - pos, size, threshold));\n  }\n  return l;\n}\n\nexport function getConsensusThreshold(consensusSize: bigint): bigint {\n  return consensusSize - (consensusSize - 1n) / 3n;\n}\n\nexport function getScaler(size: bigint, threshold: bigint): bigint {\n  const matrix: bigint[][] = Array.from({ length: Number(threshold) }).map(() => []);\n  return searchDlcm(matrix, 1n, 0n, 0n, size, threshold);\n}\n\nfunction randScalar(): bigint {\n  return randBetween(bls.G1.CURVE.n - 1n, 0n);\n}\n\nfunction randPg1(): ProjPointType<Fp> {\n  const s = randScalar();\n  // for test\n  // const s = BigInt('13142576477868579383218672883803438445527974108075655005925877124647713243145');\n  return bls.G1.ProjectivePoint.BASE.multiply(s);\n}\n\nclass BlsCipherText {\n  constructor(\n    public cMsg: ProjPointType<Fp>,\n    public bigR: ProjPointType<Fp>,\n    public commitment: ProjPointType<Fp2>,\n  ) {}\n\n  verify(): boolean {\n    throw new Error('Unimplemented');\n  }\n\n  toBytes(): ByteArray {\n    return concat([this.cMsg.toRawBytes(), this.bigR.toRawBytes(), this.commitment.toRawBytes()]);\n  }\n}\n\nfunction blsEncrypt(msg: ProjPointType<Fp>, pk: ProjPointType<Fp>): BlsCipherText {\n  const r = randScalar();\n  // for test\n  // const r = BigInt('26241604929413036610059529953849322917897934190194857549647694249968225593684');\n\n  // C=M+rpk, R1=rG1, R2=-rG2\n  const rpk = pk.multiply(r);\n  const cMsg = msg.add(rpk);\n\n  const bigR1 = bls.G1.ProjectivePoint.BASE.multiply(r);\n  const bigR2 = bls.G2.ProjectivePoint.BASE.multiply(r).negate();\n\n  return new BlsCipherText(cMsg, bigR1, bigR2);\n}\n\nfunction aesEncrypt(msg: ByteArray, seed: ByteArray): ByteArray {\n  if (msg.length < 1) {\n    throw new Error('Empty aes message');\n  }\n  const seedHash = hash.sha256().update(seed).digest();\n  const cipher = new aes.ModeOfOperation.cbc(seedHash, seedHash.slice(0, 16));\n  const encrypted = cipher.encrypt(aes.padding.pkcs7.pad(msg));\n\n  return encrypted;\n}\n\nexport class PublicKey {\n  constructor(public pg1: ProjPointType<Fp>) {}\n\n  static fromAggregatedCommitment(aggregatedCommitment: ByteArray, scaler: bigint): PublicKey {\n    if (aggregatedCommitment.length !== 128) {\n      throw new Error('Invalid aggregated commitment');\n    }\n\n    let pg1 = bls.G1.ProjectivePoint.fromHex(\n      concat([aggregatedCommitment.subarray(16, 64), aggregatedCommitment.subarray(80)]),\n    );\n\n    pg1 = pg1.multiply(scaler);\n\n    return new PublicKey(pg1);\n  }\n\n  static fromBytes(bytes: ByteArray): PublicKey {\n    const pg1 = bls.G1.ProjectivePoint.fromHex(bytes);\n    return new PublicKey(pg1);\n  }\n\n  toBytes(): ByteArray {\n    return this.pg1.toRawBytes();\n  }\n\n  encrypt(msg: ByteArray): { encryptedKey: ByteArray; encryptedMsg: ByteArray } {\n    const aesKeyPg1 = randPg1();\n\n    const encryptedKey = blsEncrypt(aesKeyPg1, this.pg1).toBytes();\n    const encryptedMsg = aesEncrypt(msg, aesKeyPg1.toRawBytes(false));\n\n    return { encryptedKey, encryptedMsg };\n  }\n}\n"],"names":["l","inherits_browserModule","require$$0","require$$1","p","utils","common","t","s","y","require$$2","require$$3","SHA256","h","require$$4","hash","toBytes","isBytes","abytes","utf8ToBytes","_0n","_1n","_2n","n","concatBytes","_3n","_4n","u","Fp","n2","bitLen","wbits","ut.validateObject","ut.concatBytes","ut.inRange","ut.isBytes","ut.bytesToHex","ut.bytesToNumberBE","ut.aInRange","a","tv5","c1","c2","Fr","Fp2","Fp6","Fp12","msg","y2","G2psi","G2psi2","mod.Field","FpLegendre","mod.FpLegendre","mod.FpPow","mod.FpInvertBatch","Fp4Square","concatB","x","gcd","abs","lcm","randBetween","bls"],"mappings":";;;;;;;;;;AAAA,uBAAiB;AAEjB,WAAS,OAAO,KAAK,KAAK;AACxB,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,OAAO,kBAAkB;AAAA,EAC7C;AAEA,SAAO,QAAQ,SAAS,YAAYA,IAAG,GAAG,KAAK;AAC7C,QAAIA,MAAK;AACP,YAAM,IAAI,MAAM,OAAQ,uBAAuBA,KAAI,SAAS,CAAE;AAAA,EACjE;;;;;;;;ACVD,MAAI,OAAO,OAAO,WAAW,YAAY;AAEvCC,qBAAA,UAAiB,SAAS,SAAS,MAAM,WAAW;AAClD,UAAI,WAAW;AACb,aAAK,SAAS;AACd,aAAK,YAAY,OAAO,OAAO,UAAU,WAAW;AAAA,UAClD,aAAa;AAAA,YACX,OAAO;AAAA,YACP,YAAY;AAAA,YACZ,UAAU;AAAA,YACV,cAAc;AAAA,UACxB;AAAA,QACO,CAAA;AAAA,MACP;AAAA,IACG;AAAA,EACH,OAAO;AAELA,qBAAA,UAAiB,SAAS,SAAS,MAAM,WAAW;AAClD,UAAI,WAAW;AACb,aAAK,SAAS;AACd,YAAI,WAAW,WAAY;AAAA,QAAA;AAC3B,iBAAS,YAAY,UAAU;AAC/B,aAAK,YAAY,IAAI,SAAQ;AAC7B,aAAK,UAAU,cAAc;AAAA,MACnC;AAAA,IACA;AAAA,EACA;;;;;;;ACxBA,MAAI,SAASC,0BAA8B;AAC3C,MAAI,WAAWC,wBAAmB;AAElC,QAAA,WAAmB;AAEnB,WAAS,gBAAgB,KAAK,GAAG;AAC/B,SAAK,IAAI,WAAW,CAAC,IAAI,WAAY,OAAQ;AAC3C,aAAO;AAAA,IACX;AACE,QAAI,IAAI,KAAK,IAAI,KAAK,IAAI,QAAQ;AAChC,aAAO;AAAA,IACX;AACE,YAAQ,IAAI,WAAW,IAAI,CAAC,IAAI,WAAY;AAAA,EAC9C;AAEA,WAAS,QAAQ,KAAK,KAAK;AACzB,QAAI,MAAM,QAAQ,GAAG;AACnB,aAAO,IAAI,MAAO;AACpB,QAAI,CAAC;AACH,aAAO,CAAE;AACX,QAAI,MAAM,CAAE;AACZ,QAAI,OAAO,QAAQ,UAAU;AAC3B,UAAI,CAAC,KAAK;AAKR,YAAIC,KAAI;AACR,iBAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,cAAI,IAAI,IAAI,WAAW,CAAC;AACxB,cAAI,IAAI,KAAK;AACX,gBAAIA,IAAG,IAAI;AAAA,UACrB,WAAmB,IAAI,MAAM;AACnB,gBAAIA,IAAG,IAAK,KAAK,IAAK;AACtB,gBAAIA,IAAG,IAAK,IAAI,KAAM;AAAA,UACvB,WAAU,gBAAgB,KAAK,CAAC,GAAG;AAClC,gBAAI,UAAY,IAAI,SAAW,OAAO,IAAI,WAAW,EAAE,CAAC,IAAI;AAC5D,gBAAIA,IAAG,IAAK,KAAK,KAAM;AACvB,gBAAIA,IAAG,IAAM,KAAK,KAAM,KAAM;AAC9B,gBAAIA,IAAG,IAAM,KAAK,IAAK,KAAM;AAC7B,gBAAIA,IAAG,IAAK,IAAI,KAAM;AAAA,UAChC,OAAe;AACL,gBAAIA,IAAG,IAAK,KAAK,KAAM;AACvB,gBAAIA,IAAG,IAAM,KAAK,IAAK,KAAM;AAC7B,gBAAIA,IAAG,IAAK,IAAI,KAAM;AAAA,UAChC;AAAA,QACA;AAAA,MACA,WAAe,QAAQ,OAAO;AACxB,cAAM,IAAI,QAAQ,gBAAgB,EAAE;AACpC,YAAI,IAAI,SAAS,MAAM;AACrB,gBAAM,MAAM;AACd,aAAK,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AAC/B,cAAI,KAAK,SAAS,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;AAAA,MAClD;AAAA,IACA,OAAS;AACL,WAAK,IAAI,GAAG,IAAI,IAAI,QAAQ;AAC1B,YAAI,CAAC,IAAI,IAAI,CAAC,IAAI;AAAA,IACxB;AACE,WAAO;AAAA,EACT;AACA,QAAA,UAAkB;AAElB,WAAS,MAAM,KAAK;AAClB,QAAI,MAAM;AACV,aAAS,IAAI,GAAG,IAAI,IAAI,QAAQ;AAC9B,aAAO,MAAM,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;AAClC,WAAO;AAAA,EACT;AACA,QAAA,QAAgB;AAEhB,WAAS,MAAM,GAAG;AAChB,QAAI,MAAO,MAAM,KACL,MAAM,IAAK,QACX,KAAK,IAAK,YACV,IAAI,QAAS;AACzB,WAAO,QAAQ;AAAA,EACjB;AACA,QAAA,QAAgB;AAEhB,WAAS,QAAQ,KAAK,QAAQ;AAC5B,QAAI,MAAM;AACV,aAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,UAAI,IAAI,IAAI,CAAC;AACb,UAAI,WAAW;AACb,YAAI,MAAM,CAAC;AACb,aAAO,MAAM,EAAE,SAAS,EAAE,CAAC;AAAA,IAC/B;AACE,WAAO;AAAA,EACT;AACA,QAAA,UAAkB;AAElB,WAAS,MAAM,MAAM;AACnB,QAAI,KAAK,WAAW;AAClB,aAAO,MAAM;AAAA;AAEb,aAAO;AAAA,EACX;AACA,QAAA,QAAgB;AAEhB,WAAS,MAAM,MAAM;AACnB,QAAI,KAAK,WAAW;AAClB,aAAO,MAAM;AAAA,aACN,KAAK,WAAW;AACvB,aAAO,OAAO;AAAA,aACP,KAAK,WAAW;AACvB,aAAO,QAAQ;AAAA,aACR,KAAK,WAAW;AACvB,aAAO,SAAS;AAAA,aACT,KAAK,WAAW;AACvB,aAAO,UAAU;AAAA,aACV,KAAK,WAAW;AACvB,aAAO,WAAW;AAAA,aACX,KAAK,WAAW;AACvB,aAAO,YAAY;AAAA;AAEnB,aAAO;AAAA,EACX;AACA,QAAA,QAAgB;AAEhB,WAAS,OAAO,KAAK,OAAO,KAAK,QAAQ;AACvC,QAAI,MAAM,MAAM;AAChB,WAAO,MAAM,MAAM,CAAC;AACpB,QAAI,MAAM,IAAI,MAAM,MAAM,CAAC;AAC3B,aAAS,IAAI,GAAG,IAAI,OAAO,IAAI,IAAI,QAAQ,KAAK,KAAK,GAAG;AACtD,UAAI;AACJ,UAAI,WAAW;AACb,YAAK,IAAI,CAAC,KAAK,KAAO,IAAI,IAAI,CAAC,KAAK,KAAO,IAAI,IAAI,CAAC,KAAK,IAAK,IAAI,IAAI,CAAC;AAAA;AAEvE,YAAK,IAAI,IAAI,CAAC,KAAK,KAAO,IAAI,IAAI,CAAC,KAAK,KAAO,IAAI,IAAI,CAAC,KAAK,IAAK,IAAI,CAAC;AACzE,UAAI,CAAC,IAAI,MAAM;AAAA,IACnB;AACE,WAAO;AAAA,EACT;AACA,QAAA,SAAiB;AAEjB,WAAS,QAAQ,KAAK,QAAQ;AAC5B,QAAI,MAAM,IAAI,MAAM,IAAI,SAAS,CAAC;AAClC,aAAS,IAAI,GAAG,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,KAAK,GAAG;AAClD,UAAI,IAAI,IAAI,CAAC;AACb,UAAI,WAAW,OAAO;AACpB,YAAI,CAAC,IAAI,MAAM;AACf,YAAI,IAAI,CAAC,IAAK,MAAM,KAAM;AAC1B,YAAI,IAAI,CAAC,IAAK,MAAM,IAAK;AACzB,YAAI,IAAI,CAAC,IAAI,IAAI;AAAA,MACvB,OAAW;AACL,YAAI,IAAI,CAAC,IAAI,MAAM;AACnB,YAAI,IAAI,CAAC,IAAK,MAAM,KAAM;AAC1B,YAAI,IAAI,CAAC,IAAK,MAAM,IAAK;AACzB,YAAI,CAAC,IAAI,IAAI;AAAA,MACnB;AAAA,IACA;AACE,WAAO;AAAA,EACT;AACA,QAAA,UAAkB;AAElB,WAAS,OAAO,GAAG,GAAG;AACpB,WAAQ,MAAM,IAAM,KAAM,KAAK;AAAA,EACjC;AACA,QAAA,SAAiB;AAEjB,WAAS,OAAO,GAAG,GAAG;AACpB,WAAQ,KAAK,IAAM,MAAO,KAAK;AAAA,EACjC;AACA,QAAA,SAAiB;AAEjB,WAAS,MAAM,GAAG,GAAG;AACnB,WAAQ,IAAI,MAAO;AAAA,EACrB;AACA,QAAA,QAAgB;AAEhB,WAAS,QAAQ,GAAG,GAAG,GAAG;AACxB,WAAQ,IAAI,IAAI,MAAO;AAAA,EACzB;AACA,QAAA,UAAkB;AAElB,WAAS,QAAQ,GAAG,GAAG,GAAG,GAAG;AAC3B,WAAQ,IAAI,IAAI,IAAI,MAAO;AAAA,EAC7B;AACA,QAAA,UAAkB;AAElB,WAAS,QAAQ,GAAG,GAAG,GAAG,GAAG,GAAG;AAC9B,WAAQ,IAAI,IAAI,IAAI,IAAI,MAAO;AAAA,EACjC;AACA,QAAA,UAAkB;AAElB,WAAS,MAAM,KAAK,KAAK,IAAI,IAAI;AAC/B,QAAI,KAAK,IAAI,GAAG;AAChB,QAAI,KAAK,IAAI,MAAM,CAAC;AAEpB,QAAI,KAAM,KAAK,OAAQ;AACvB,QAAI,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK;AAClC,QAAI,GAAG,IAAI,OAAO;AAClB,QAAI,MAAM,CAAC,IAAI;AAAA,EACjB;AACA,QAAA,QAAgB;AAEhB,WAAS,SAAS,IAAI,IAAI,IAAI,IAAI;AAChC,QAAI,KAAM,KAAK,OAAQ;AACvB,QAAI,MAAM,KAAK,KAAK,IAAI,KAAK,KAAK;AAClC,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,WAAmB;AAEnB,WAAS,SAAS,IAAI,IAAI,IAAI,IAAI;AAChC,QAAI,KAAK,KAAK;AACd,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,WAAmB;AAEnB,WAAS,WAAW,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AAClD,QAAI,QAAQ;AACZ,QAAI,KAAK;AACT,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AACvB,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AACvB,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AAEvB,QAAI,KAAK,KAAK,KAAK,KAAK,KAAK;AAC7B,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,aAAqB;AAErB,WAAS,WAAW,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AAClD,QAAI,KAAK,KAAK,KAAK,KAAK;AACxB,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,aAAqB;AAErB,WAAS,WAAW,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AAC1D,QAAI,QAAQ;AACZ,QAAI,KAAK;AACT,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AACvB,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AACvB,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AACvB,SAAM,KAAK,OAAQ;AACnB,aAAS,KAAK,KAAK,IAAI;AAEvB,QAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK;AAClC,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,aAAqB;AAErB,WAAS,WAAW,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AAC1D,QAAI,KAAK,KAAK,KAAK,KAAK,KAAK;AAE7B,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,aAAqB;AAErB,WAAS,UAAU,IAAI,IAAI,KAAK;AAC9B,QAAI,IAAK,MAAO,KAAK,MAAS,OAAO;AACrC,WAAO,MAAM;AAAA,EACf;AACA,QAAA,YAAoB;AAEpB,WAAS,UAAU,IAAI,IAAI,KAAK;AAC9B,QAAI,IAAK,MAAO,KAAK,MAAS,OAAO;AACrC,WAAO,MAAM;AAAA,EACf;AACA,QAAA,YAAoB;AAEpB,WAAS,SAAS,IAAI,IAAI,KAAK;AAC7B,WAAO,OAAO;AAAA,EAChB;AACA,QAAA,WAAmB;AAEnB,WAAS,SAAS,IAAI,IAAI,KAAK;AAC7B,QAAI,IAAK,MAAO,KAAK,MAAS,OAAO;AACrC,WAAO,MAAM;AAAA,EACf;AACA,QAAA,WAAmB;;;;;;;;ACnRnB,MAAIC,SAAQH,aAAkB;AAC9B,MAAI,SAASC,0BAA8B;AAE3C,WAAS,YAAY;AACnB,SAAK,UAAU;AACf,SAAK,eAAe;AACpB,SAAK,YAAY,KAAK,YAAY;AAClC,SAAK,UAAU,KAAK,YAAY;AAChC,SAAK,eAAe,KAAK,YAAY;AACrC,SAAK,YAAY,KAAK,YAAY,YAAY;AAC9C,SAAK,SAAS;AAEd,SAAK,UAAU,KAAK,YAAY;AAChC,SAAK,WAAW,KAAK,YAAY;AAAA,EACnC;AACAG,WAAA,YAAoB;AAEpB,YAAU,UAAU,SAAS,SAAS,OAAO,KAAK,KAAK;AAErD,UAAMD,OAAM,QAAQ,KAAK,GAAG;AAC5B,QAAI,CAAC,KAAK;AACR,WAAK,UAAU;AAAA;AAEf,WAAK,UAAU,KAAK,QAAQ,OAAO,GAAG;AACxC,SAAK,gBAAgB,IAAI;AAGzB,QAAI,KAAK,QAAQ,UAAU,KAAK,SAAS;AACvC,YAAM,KAAK;AAGX,UAAI,IAAI,IAAI,SAAS,KAAK;AAC1B,WAAK,UAAU,IAAI,MAAM,IAAI,SAAS,GAAG,IAAI,MAAM;AACnD,UAAI,KAAK,QAAQ,WAAW;AAC1B,aAAK,UAAU;AAEjB,YAAMA,OAAM,OAAO,KAAK,GAAG,IAAI,SAAS,GAAG,KAAK,MAAM;AACtD,eAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,KAAK;AACxC,aAAK,QAAQ,KAAK,GAAG,IAAI,KAAK,QAAQ;AAAA,IAC5C;AAEE,WAAO;AAAA,EACR;AAED,YAAU,UAAU,SAAS,SAAS,OAAO,KAAK;AAChD,SAAK,OAAO,KAAK,MAAM;AACvB,WAAO,KAAK,YAAY,IAAI;AAE5B,WAAO,KAAK,QAAQ,GAAG;AAAA,EACxB;AAED,YAAU,UAAU,OAAO,SAAS,MAAM;AACxC,QAAI,MAAM,KAAK;AACf,QAAI,QAAQ,KAAK;AACjB,QAAI,IAAI,SAAU,MAAM,KAAK,aAAa;AAC1C,QAAI,MAAM,IAAI,MAAM,IAAI,KAAK,SAAS;AACtC,QAAI,CAAC,IAAI;AACT,aAAS,IAAI,GAAG,IAAI,GAAG;AACrB,UAAI,CAAC,IAAI;AAGX,YAAQ;AACR,QAAI,KAAK,WAAW,OAAO;AACzB,eAASE,KAAI,GAAGA,KAAI,KAAK,WAAWA;AAClC,YAAI,GAAG,IAAI;AAEb,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAK,QAAQ,KAAM;AAC1B,UAAI,GAAG,IAAK,QAAQ,KAAM;AAC1B,UAAI,GAAG,IAAK,QAAQ,IAAK;AACzB,UAAI,GAAG,IAAI,MAAM;AAAA,IACrB,OAAS;AACL,UAAI,GAAG,IAAI,MAAM;AACjB,UAAI,GAAG,IAAK,QAAQ,IAAK;AACzB,UAAI,GAAG,IAAK,QAAQ,KAAM;AAC1B,UAAI,GAAG,IAAK,QAAQ,KAAM;AAC1B,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAI;AACX,UAAI,GAAG,IAAI;AAEX,WAAKA,KAAI,GAAGA,KAAI,KAAK,WAAWA;AAC9B,YAAI,GAAG,IAAI;AAAA,IACjB;AAEE,WAAO;AAAA,EACR;;;;;;;;;ACzFD,MAAIF,SAAQH,aAAmB;AAC/B,MAAI,SAASG,OAAM;AAEnB,WAAS,KAAKG,IAAG,GAAGC,IAAG,GAAG;AACxB,QAAID,OAAM;AACR,aAAO,KAAK,GAAGC,IAAG,CAAC;AACrB,QAAID,OAAM,KAAKA,OAAM;AACnB,aAAO,IAAI,GAAGC,IAAG,CAAC;AACpB,QAAID,OAAM;AACR,aAAO,MAAM,GAAGC,IAAG,CAAC;AAAA,EACxB;AACA,SAAA,OAAe;AAEf,WAAS,KAAK,GAAGA,IAAG,GAAG;AACrB,WAAQ,IAAIA,KAAO,CAAC,IAAK;AAAA,EAC3B;AACA,SAAA,OAAe;AAEf,WAAS,MAAM,GAAGA,IAAG,GAAG;AACtB,WAAQ,IAAIA,KAAM,IAAI,IAAMA,KAAI;AAAA,EAClC;AACA,SAAA,QAAgB;AAEhB,WAAS,IAAI,GAAGA,IAAG,GAAG;AACpB,WAAO,IAAIA,KAAI;AAAA,EACjB;AACA,SAAA,MAAc;AAEd,WAAS,OAAO,GAAG;AACjB,WAAO,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,EAAE,IAAI,OAAO,GAAG,EAAE;AAAA,EACpD;AACA,SAAA,SAAiB;AAEjB,WAAS,OAAO,GAAG;AACjB,WAAO,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,EAAE,IAAI,OAAO,GAAG,EAAE;AAAA,EACpD;AACA,SAAA,SAAiB;AAEjB,WAAS,OAAO,GAAG;AACjB,WAAO,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,EAAE,IAAK,MAAM;AAAA,EAC/C;AACA,SAAA,SAAiB;AAEjB,WAAS,OAAO,GAAG;AACjB,WAAO,OAAO,GAAG,EAAE,IAAI,OAAO,GAAG,EAAE,IAAK,MAAM;AAAA,EAChD;AACA,SAAA,SAAiB;;;;;;;;AC9CjB,MAAIJ,SAAQH,aAAmB;AAC/B,MAAII,UAASH,gBAAoB;AACjC,MAAI,YAAYO,cAAmB;AAEnC,MAAI,SAASL,OAAM;AACnB,MAAI,QAAQA,OAAM;AAClB,MAAI,UAAUA,OAAM;AACpB,MAAI,OAAO,UAAU;AACrB,MAAI,YAAYC,QAAO;AAEvB,MAAI,SAAS;AAAA,IACX;AAAA,IAAY;AAAA,IACZ;AAAA,IAAY;AAAA,EACb;AAED,WAAS,OAAO;AACd,QAAI,EAAE,gBAAgB;AACpB,aAAO,IAAI,KAAM;AAEnB,cAAU,KAAK,IAAI;AACnB,SAAK,IAAI;AAAA,MACP;AAAA,MAAY;AAAA,MAAY;AAAA,MACxB;AAAA,MAAY;AAAA,IAAY;AAC1B,SAAK,IAAI,IAAI,MAAM,EAAE;AAAA,EACvB;AAEA,EAAAD,OAAM,SAAS,MAAM,SAAS;AAC9B,OAAiB;AAEjB,OAAK,YAAY;AACjB,OAAK,UAAU;AACf,OAAK,eAAe;AACpB,OAAK,YAAY;AAEjB,OAAK,UAAU,UAAU,SAAS,QAAQ,KAAK,OAAO;AACpD,QAAI,IAAI,KAAK;AAEb,aAAS,IAAI,GAAG,IAAI,IAAI;AACtB,QAAE,CAAC,IAAI,IAAI,QAAQ,CAAC;AAEtB,WAAM,IAAI,EAAE,QAAQ;AAClB,QAAE,CAAC,IAAI,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC;AAE9D,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAEhB,SAAK,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AAC7B,UAAIG,KAAI,CAAC,EAAE,IAAI;AACf,UAAID,KAAI,QAAQ,OAAO,GAAG,CAAC,GAAG,KAAKC,IAAG,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,OAAOA,EAAC,CAAC;AAClE,UAAI;AACJ,UAAI;AACJ,UAAI,OAAO,GAAG,EAAE;AAChB,UAAI;AACJ,UAAID;AAAA,IACR;AAEE,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAAA,EAC/B;AAED,OAAK,UAAU,UAAU,SAAS,OAAO,KAAK;AAC5C,QAAI,QAAQ;AACV,aAAOF,OAAM,QAAQ,KAAK,GAAG,KAAK;AAAA;AAElC,aAAOA,OAAM,QAAQ,KAAK,GAAG,KAAK;AAAA,EACrC;;;;;;;;ACvED,MAAIA,SAAQH,aAAmB;AAC/B,MAAII,UAASH,gBAAoB;AACjC,MAAI,YAAYO,cAAmB;AACnC,MAAI,SAASC,0BAA8B;AAE3C,MAAI,QAAQN,OAAM;AAClB,MAAI,UAAUA,OAAM;AACpB,MAAI,UAAUA,OAAM;AACpB,MAAI,OAAO,UAAU;AACrB,MAAI,QAAQ,UAAU;AACtB,MAAI,SAAS,UAAU;AACvB,MAAI,SAAS,UAAU;AACvB,MAAI,SAAS,UAAU;AACvB,MAAI,SAAS,UAAU;AAEvB,MAAI,YAAYC,QAAO;AAEvB,MAAI,WAAW;AAAA,IACb;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,EACrC;AAED,WAASM,UAAS;AAChB,QAAI,EAAE,gBAAgBA;AACpB,aAAO,IAAIA,QAAQ;AAErB,cAAU,KAAK,IAAI;AACnB,SAAK,IAAI;AAAA,MACP;AAAA,MAAY;AAAA,MAAY;AAAA,MAAY;AAAA,MACpC;AAAA,MAAY;AAAA,MAAY;AAAA,MAAY;AAAA,IACrC;AACD,SAAK,IAAI;AACT,SAAK,IAAI,IAAI,MAAM,EAAE;AAAA,EACvB;AACA,EAAAP,OAAM,SAASO,SAAQ,SAAS;AAChC,SAAiBA;AAEjB,EAAAA,QAAO,YAAY;AACnB,EAAAA,QAAO,UAAU;AACjB,EAAAA,QAAO,eAAe;AACtB,EAAAA,QAAO,YAAY;AAEnB,EAAAA,QAAO,UAAU,UAAU,SAAS,QAAQ,KAAK,OAAO;AACtD,QAAI,IAAI,KAAK;AAEb,aAAS,IAAI,GAAG,IAAI,IAAI;AACtB,QAAE,CAAC,IAAI,IAAI,QAAQ,CAAC;AACtB,WAAO,IAAI,EAAE,QAAQ;AACnB,QAAE,CAAC,IAAI,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;AAEzE,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAIC,KAAI,KAAK,EAAE,CAAC;AAEhB,WAAO,KAAK,EAAE,WAAW,EAAE,MAAM;AACjC,SAAK,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AAC7B,UAAI,KAAK,QAAQA,IAAG,OAAO,CAAC,GAAG,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAC7D,UAAI,KAAK,MAAM,OAAO,CAAC,GAAG,MAAM,GAAG,GAAG,CAAC,CAAC;AACxC,MAAAA,KAAI;AACJ,UAAI;AACJ,UAAI;AACJ,UAAI,MAAM,GAAG,EAAE;AACf,UAAI;AACJ,UAAI;AACJ,UAAI;AACJ,UAAI,MAAM,IAAI,EAAE;AAAA,IACpB;AAEE,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAG,CAAC;AAC9B,SAAK,EAAE,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,GAAGA,EAAC;AAAA,EAC/B;AAED,EAAAD,QAAO,UAAU,UAAU,SAAS,OAAO,KAAK;AAC9C,QAAI,QAAQ;AACV,aAAOP,OAAM,QAAQ,KAAK,GAAG,KAAK;AAAA;AAElC,aAAOA,OAAM,QAAQ,KAAK,GAAG,KAAK;AAAA,EACrC;;;;;;;;ACtGD,MAAIA,SAAQH,aAAmB;AAC/B,MAAIU,UAAST,YAAgB;AAE7B,WAAS,SAAS;AAChB,QAAI,EAAE,gBAAgB;AACpB,aAAO,IAAI,OAAQ;AAErB,IAAAS,QAAO,KAAK,IAAI;AAChB,SAAK,IAAI;AAAA,MACP;AAAA,MAAY;AAAA,MAAY;AAAA,MAAY;AAAA,MACpC;AAAA,MAAY;AAAA,MAAY;AAAA,MAAY;AAAA,IAAY;AAAA,EACpD;AACA,EAAAP,OAAM,SAAS,QAAQO,OAAM;AAC7B,SAAiB;AAEjB,SAAO,YAAY;AACnB,SAAO,UAAU;AACjB,SAAO,eAAe;AACtB,SAAO,YAAY;AAEnB,SAAO,UAAU,UAAU,SAAS,OAAO,KAAK;AAE9C,QAAI,QAAQ;AACV,aAAOP,OAAM,QAAQ,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,KAAK;AAAA;AAE9C,aAAOA,OAAM,QAAQ,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,KAAK;AAAA,EACjD;;;;;;;;AC1BD,MAAIA,SAAQH,aAAmB;AAC/B,MAAII,UAASH,gBAAoB;AACjC,MAAI,SAASO,0BAA8B;AAE3C,MAAI,YAAYL,OAAM;AACtB,MAAI,YAAYA,OAAM;AACtB,MAAI,WAAWA,OAAM;AACrB,MAAI,WAAWA,OAAM;AACrB,MAAI,QAAQA,OAAM;AAClB,MAAI,WAAWA,OAAM;AACrB,MAAI,WAAWA,OAAM;AACrB,MAAI,aAAaA,OAAM;AACvB,MAAI,aAAaA,OAAM;AACvB,MAAI,aAAaA,OAAM;AACvB,MAAI,aAAaA,OAAM;AAEvB,MAAI,YAAYC,QAAO;AAEvB,MAAI,WAAW;AAAA,IACb;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,IACpC;AAAA,IAAY;AAAA,IAAY;AAAA,IAAY;AAAA,EACrC;AAED,WAAS,SAAS;AAChB,QAAI,EAAE,gBAAgB;AACpB,aAAO,IAAI,OAAQ;AAErB,cAAU,KAAK,IAAI;AACnB,SAAK,IAAI;AAAA,MACP;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,IAAY;AAC1B,SAAK,IAAI;AACT,SAAK,IAAI,IAAI,MAAM,GAAG;AAAA,EACxB;AACA,EAAAD,OAAM,SAAS,QAAQ,SAAS;AAChC,SAAiB;AAEjB,SAAO,YAAY;AACnB,SAAO,UAAU;AACjB,SAAO,eAAe;AACtB,SAAO,YAAY;AAEnB,SAAO,UAAU,gBAAgB,SAAS,cAAc,KAAK,OAAO;AAClE,QAAI,IAAI,KAAK;AAGb,aAAS,IAAI,GAAG,IAAI,IAAI;AACtB,QAAE,CAAC,IAAI,IAAI,QAAQ,CAAC;AACtB,WAAO,IAAI,EAAE,QAAQ,KAAK,GAAG;AAC3B,UAAI,QAAQ,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACxC,UAAI,QAAQ,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACxC,UAAI,QAAQ,EAAE,IAAI,EAAE;AACpB,UAAI,QAAQ,EAAE,IAAI,EAAE;AACpB,UAAI,QAAQ,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;AAC1C,UAAI,QAAQ,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;AAC1C,UAAI,QAAQ,EAAE,IAAI,EAAE;AACpB,UAAI,QAAQ,EAAE,IAAI,EAAE;AAEpB,QAAE,CAAC,IAAI;AAAA,QACL;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,MAAK;AACd,QAAE,IAAI,CAAC,IAAI;AAAA,QACT;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,MAAK;AAAA,IAClB;AAAA,EACC;AAED,SAAO,UAAU,UAAU,SAAS,QAAQ,KAAK,OAAO;AACtD,SAAK,cAAc,KAAK,KAAK;AAE7B,QAAI,IAAI,KAAK;AAEb,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,CAAC;AACjB,QAAI,KAAK,KAAK,EAAE,EAAE;AAClB,QAAI,KAAK,KAAK,EAAE,EAAE;AAClB,QAAI,KAAK,KAAK,EAAE,EAAE;AAClB,QAAI,KAAK,KAAK,EAAE,EAAE;AAClB,QAAI,KAAK,KAAK,EAAE,EAAE;AAClB,QAAI,KAAK,KAAK,EAAE,EAAE;AAElB,WAAO,KAAK,EAAE,WAAW,EAAE,MAAM;AACjC,aAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,GAAG;AACpC,UAAI,QAAQ;AACZ,UAAI,QAAQ;AACZ,UAAI,QAAQ,UAAU,IAAI,EAAE;AAC5B,UAAI,QAAQ,UAAU,IAAI,EAAE;AAC5B,UAAI,QAAQ,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAM;AAC1C,UAAI,QAAQ,QAAQ,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C,UAAI,QAAQ,KAAK,EAAE,CAAC;AACpB,UAAI,QAAQ,KAAK,EAAE,IAAI,CAAC;AACxB,UAAI,QAAQ,EAAE,CAAC;AACf,UAAI,QAAQ,EAAE,IAAI,CAAC;AAEnB,UAAI,QAAQ;AAAA,QACV;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,MAAK;AACd,UAAI,QAAQ;AAAA,QACV;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,QACP;AAAA,QAAO;AAAA,MAAK;AAEd,cAAQ,UAAU,IAAI,EAAE;AACxB,cAAQ,UAAU,IAAI,EAAE;AACxB,cAAQ,SAAS,IAAI,IAAI,IAAI,IAAI,EAAM;AACvC,cAAQ,SAAS,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE;AAEvC,UAAI,QAAQ,SAAS,OAAO,OAAO,OAAO,KAAK;AAC/C,UAAI,QAAQ,SAAS,OAAO,OAAO,OAAO,KAAK;AAE/C,WAAK;AACL,WAAK;AAEL,WAAK;AACL,WAAK;AAEL,WAAK;AACL,WAAK;AAEL,WAAK,SAAS,IAAI,IAAI,OAAO,KAAK;AAClC,WAAK,SAAS,IAAI,IAAI,OAAO,KAAK;AAElC,WAAK;AACL,WAAK;AAEL,WAAK;AACL,WAAK;AAEL,WAAK;AACL,WAAK;AAEL,WAAK,SAAS,OAAO,OAAO,OAAO,KAAK;AACxC,WAAK,SAAS,OAAO,OAAO,OAAO,KAAK;AAAA,IAC5C;AAEE,UAAM,KAAK,GAAG,GAAG,IAAI,EAAE;AACvB,UAAM,KAAK,GAAG,GAAG,IAAI,EAAE;AACvB,UAAM,KAAK,GAAG,GAAG,IAAI,EAAE;AACvB,UAAM,KAAK,GAAG,GAAG,IAAI,EAAE;AACvB,UAAM,KAAK,GAAG,GAAG,IAAI,EAAE;AACvB,UAAM,KAAK,GAAG,IAAI,IAAI,EAAE;AACxB,UAAM,KAAK,GAAG,IAAI,IAAI,EAAE;AACxB,UAAM,KAAK,GAAG,IAAI,IAAI,EAAE;AAAA,EACzB;AAED,SAAO,UAAU,UAAU,SAAS,OAAO,KAAK;AAC9C,QAAI,QAAQ;AACV,aAAOA,OAAM,QAAQ,KAAK,GAAG,KAAK;AAAA;AAElC,aAAOA,OAAM,QAAQ,KAAK,GAAG,KAAK;AAAA,EACrC;AAED,WAAS,QAAQ,IAAI,IAAI,IAAI,IAAI,IAAI;AACnC,QAAI,IAAK,KAAK,KAAQ,CAAC,KAAM;AAC7B,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,QAAQ,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AACvC,QAAI,IAAK,KAAK,KAAQ,CAAC,KAAM;AAC7B,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,SAAS,IAAI,IAAI,IAAI,IAAI,IAAI;AACpC,QAAI,IAAK,KAAK,KAAO,KAAK,KAAO,KAAK;AACtC,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,SAAS,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AACxC,QAAI,IAAK,KAAK,KAAO,KAAK,KAAO,KAAK;AACtC,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAC/B,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAE/B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAC/B,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAE/B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAE/B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAE/B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAC/B,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAC/B,QAAI,QAAQ,SAAS,IAAI,IAAI,CAAC;AAE9B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAC/B,QAAI,QAAQ,UAAU,IAAI,IAAI,CAAC;AAC/B,QAAI,QAAQ,SAAS,IAAI,IAAI,CAAC;AAE9B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,SAAS,IAAI,IAAI,CAAC;AAE9B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;AAEA,WAAS,UAAU,IAAI,IAAI;AACzB,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,UAAU,IAAI,IAAI,EAAE;AAChC,QAAI,QAAQ,SAAS,IAAI,IAAI,CAAC;AAE9B,QAAI,IAAI,QAAQ,QAAQ;AACxB,QAAI,IAAI;AACN,WAAK;AACP,WAAO;AAAA,EACT;;;;;;;;ACvUA,MAAIA,SAAQH,aAAmB;AAE/B,MAAI,SAASC,YAAgB;AAE7B,WAAS,SAAS;AAChB,QAAI,EAAE,gBAAgB;AACpB,aAAO,IAAI,OAAQ;AAErB,WAAO,KAAK,IAAI;AAChB,SAAK,IAAI;AAAA,MACP;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,MACZ;AAAA,MAAY;AAAA,IAAY;AAAA,EAC5B;AACA,EAAAE,OAAM,SAAS,QAAQ,MAAM;AAC7B,SAAiB;AAEjB,SAAO,YAAY;AACnB,SAAO,UAAU;AACjB,SAAO,eAAe;AACtB,SAAO,YAAY;AAEnB,SAAO,UAAU,UAAU,SAAS,OAAO,KAAK;AAC9C,QAAI,QAAQ;AACV,aAAOA,OAAM,QAAQ,KAAK,EAAE,MAAM,GAAG,EAAE,GAAG,KAAK;AAAA;AAE/C,aAAOA,OAAM,QAAQ,KAAK,EAAE,MAAM,GAAG,EAAE,GAAG,KAAK;AAAA,EAClD;;;;;;;AChCD,MAAA,OAAeH,UAAkB;AACjC,MAAA,SAAiBC,YAAoB;AACrC,MAAA,SAAiBO,YAAoB;AACrC,MAAA,SAAiBC,YAAoB;AACrC,MAAA,SAAiBG,YAAoB;;;;;;;;ACJrC,MAAIT,SAAQH,aAAkB;AAC9B,MAAII,UAASH,gBAAmB;AAEhC,MAAI,SAASE,OAAM;AACnB,MAAI,QAAQA,OAAM;AAClB,MAAI,UAAUA,OAAM;AACpB,MAAI,UAAUA,OAAM;AACpB,MAAI,YAAYC,QAAO;AAEvB,WAAS,YAAY;AACnB,QAAI,EAAE,gBAAgB;AACpB,aAAO,IAAI,UAAW;AAExB,cAAU,KAAK,IAAI;AAEnB,SAAK,IAAI,CAAE,YAAY,YAAY,YAAY,WAAY,UAAY;AACvE,SAAK,SAAS;AAAA,EAChB;AACA,EAAAD,OAAM,SAAS,WAAW,SAAS;AACnC,SAAA,YAAoB;AAEpB,YAAU,YAAY;AACtB,YAAU,UAAU;AACpB,YAAU,eAAe;AACzB,YAAU,YAAY;AAEtB,YAAU,UAAU,UAAU,SAAS,OAAO,KAAK,OAAO;AACxD,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,IAAI,KAAK,EAAE,CAAC;AAChB,QAAI,KAAK;AACT,QAAI,KAAK;AACT,QAAI,KAAK;AACT,QAAI,KAAK;AACT,QAAI,KAAK;AACT,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,UAAI,IAAI;AAAA,QACN;AAAA,UACE,QAAQ,GAAG,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC,CAAC;AAAA,UACjDG,GAAE,CAAC;AAAA,QAAC;AAAA,QACN;AAAA,MAAC;AACH,UAAI;AACJ,UAAI;AACJ,UAAI,OAAO,GAAG,EAAE;AAChB,UAAI;AACJ,UAAI;AACJ,UAAI;AAAA,QACF;AAAA,UACE,QAAQ,IAAI,EAAE,KAAK,GAAG,IAAI,IAAI,EAAE,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC;AAAA,UAC5D,GAAG,CAAC;AAAA,QAAC;AAAA,QACP;AAAA,MAAE;AACJ,WAAK;AACL,WAAK;AACL,WAAK,OAAO,IAAI,EAAE;AAClB,WAAK;AACL,WAAK;AAAA,IACT;AACE,QAAI,QAAQ,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE;AAC5B,SAAK,EAAE,CAAC,IAAI,QAAQ,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE;AACpC,SAAK,EAAE,CAAC,IAAI,QAAQ,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE;AACpC,SAAK,EAAE,CAAC,IAAI,QAAQ,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE;AACpC,SAAK,EAAE,CAAC,IAAI,QAAQ,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE;AACpC,SAAK,EAAE,CAAC,IAAI;AAAA,EACb;AAED,YAAU,UAAU,UAAU,SAAS,OAAO,KAAK;AACjD,QAAI,QAAQ;AACV,aAAOH,OAAM,QAAQ,KAAK,GAAG,QAAQ;AAAA;AAErC,aAAOA,OAAM,QAAQ,KAAK,GAAG,QAAQ;AAAA,EACxC;AAED,WAAS,EAAE,GAAG,GAAGI,IAAG,GAAG;AACrB,QAAI,KAAK;AACP,aAAO,IAAIA,KAAI;AAAA,aACR,KAAK;AACZ,aAAQ,IAAIA,KAAO,CAAC,IAAK;AAAA,aAClB,KAAK;AACZ,cAAQ,IAAK,CAACA,MAAM;AAAA,aACb,KAAK;AACZ,aAAQ,IAAI,IAAMA,KAAK,CAAC;AAAA;AAExB,aAAO,KAAKA,KAAK,CAAC;AAAA,EACtB;AAEA,WAAS,EAAE,GAAG;AACZ,QAAI,KAAK;AACP,aAAO;AAAA,aACA,KAAK;AACZ,aAAO;AAAA,aACA,KAAK;AACZ,aAAO;AAAA,aACA,KAAK;AACZ,aAAO;AAAA;AAEP,aAAO;AAAA,EACX;AAEA,WAAS,GAAG,GAAG;AACb,QAAI,KAAK;AACP,aAAO;AAAA,aACA,KAAK;AACZ,aAAO;AAAA,aACA,KAAK;AACZ,aAAO;AAAA,aACA,KAAK;AACZ,aAAO;AAAA;AAEP,aAAO;AAAA,EACX;AAEA,MAAI,IAAI;AAAA,IACN;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAClD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IACnD;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAClD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IACnD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,EACnD;AAED,MAAI,KAAK;AAAA,IACP;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAClD;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IACnD;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAClD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAClD;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,EACnD;AAED,MAAID,KAAI;AAAA,IACN;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IACrD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IACpD;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IACrD;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IACpD;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,EACtD;AAED,MAAI,KAAK;AAAA,IACP;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IACrD;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IACpD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IACrD;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IACrD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,EACrD;;;;;;;;AC/ID,MAAIH,SAAQH,aAAkB;AAC9B,MAAI,SAASC,0BAA8B;AAE3C,WAAS,KAAKY,OAAM,KAAK,KAAK;AAC5B,QAAI,EAAE,gBAAgB;AACpB,aAAO,IAAI,KAAKA,OAAM,KAAK,GAAG;AAChC,SAAK,OAAOA;AACZ,SAAK,YAAYA,MAAK,YAAY;AAClC,SAAK,UAAUA,MAAK,UAAU;AAC9B,SAAK,QAAQ;AACb,SAAK,QAAQ;AAEb,SAAK,MAAMV,OAAM,QAAQ,KAAK,GAAG,CAAC;AAAA,EACpC;AACA,SAAiB;AAEjB,OAAK,UAAU,QAAQ,SAAS,KAAK,KAAK;AAExC,QAAI,IAAI,SAAS,KAAK;AACpB,YAAM,IAAI,KAAK,KAAI,EAAG,OAAO,GAAG,EAAE,OAAQ;AAC5C,WAAO,IAAI,UAAU,KAAK,SAAS;AAGnC,aAAS,IAAI,IAAI,QAAQ,IAAI,KAAK,WAAW;AAC3C,UAAI,KAAK,CAAC;AAEZ,SAAK,IAAI,GAAG,IAAI,IAAI,QAAQ;AAC1B,UAAI,CAAC,KAAK;AACZ,SAAK,QAAQ,IAAI,KAAK,KAAM,EAAC,OAAO,GAAG;AAGvC,SAAK,IAAI,GAAG,IAAI,IAAI,QAAQ;AAC1B,UAAI,CAAC,KAAK;AACZ,SAAK,QAAQ,IAAI,KAAK,KAAM,EAAC,OAAO,GAAG;AAAA,EACxC;AAED,OAAK,UAAU,SAAS,SAAS,OAAO,KAAK,KAAK;AAChD,SAAK,MAAM,OAAO,KAAK,GAAG;AAC1B,WAAO;AAAA,EACR;AAED,OAAK,UAAU,SAAS,SAAS,OAAO,KAAK;AAC3C,SAAK,MAAM,OAAO,KAAK,MAAM,OAAM,CAAE;AACrC,WAAO,KAAK,MAAM,OAAO,GAAG;AAAA,EAC7B;;;;;;;;AC9CD,QAAIU,QAAO;AAEX,IAAAA,MAAK,QAAQb,aAAuB;AACpC,IAAAa,MAAK,SAASZ,gBAAwB;AACtC,IAAAY,MAAK,MAAML,WAAqB;AAChC,IAAAK,MAAK,SAASJ,cAAwB;AACtC,IAAAI,MAAK,OAAOD,YAAsB;AAGlC,IAAAC,MAAK,OAAOA,MAAK,IAAI;AACrB,IAAAA,MAAK,SAASA,MAAK,IAAI;AACvB,IAAAA,MAAK,SAASA,MAAK,IAAI;AACvB,IAAAA,MAAK,SAASA,MAAK,IAAI;AACvB,IAAAA,MAAK,SAASA,MAAK,IAAI;AACvB,IAAAA,MAAK,YAAYA,MAAK,OAAO;AAAA;;;;;;;;;;;;ACb7B,KAAC,SAAS,MAAM;AAGZ,eAAS,SAAS,OAAO;AACrB,eAAQ,SAAS,KAAK,MAAM;AAAA,MACpC;AAEI,eAAS,UAAU,UAAU;AACzB,YAAI,CAAC,SAAS,SAAS,MAAM,GAAG;AAAE,iBAAO;AAAA,QAAM;AAE/C,iBAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACtC,cAAI,CAAC,SAAS,SAAS,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI,KAAK;AAChE,mBAAO;AAAA,UACvB;AAAA,QACA;AAEQ,eAAO;AAAA,MACf;AAEI,eAAS,YAAY,KAAK,MAAM;AAG5B,YAAI,IAAI,UAAU,IAAI,SAAS,cAAc;AAEzC,cAAI,MAAM;AACN,gBAAI,IAAI,OAAO;AACX,oBAAM,IAAI,MAAO;AAAA,YACrC,OAAuB;AACH,oBAAM,MAAM,UAAU,MAAM,KAAK,GAAG;AAAA,YACxD;AAAA,UACA;AAEY,iBAAO;AAAA,QACnB;AAGQ,YAAI,MAAM,QAAQ,GAAG,GAAG;AACpB,cAAI,CAAC,UAAU,GAAG,GAAG;AACjB,kBAAM,IAAI,MAAM,mCAAmC,GAAG;AAAA,UACtE;AAEY,iBAAO,IAAI,WAAW,GAAG;AAAA,QACrC;AAGQ,YAAI,SAAS,IAAI,MAAM,KAAK,UAAU,GAAG,GAAG;AACxC,iBAAO,IAAI,WAAW,GAAG;AAAA,QACrC;AAEQ,cAAM,IAAI,MAAM,+BAA+B;AAAA,MACvD;AAEI,eAAS,YAAY,QAAQ;AACzB,eAAO,IAAI,WAAW,MAAM;AAAA,MACpC;AAEI,eAAS,UAAU,aAAa,aAAa,aAAa,aAAa,WAAW;AAC9E,YAAI,eAAe,QAAQ,aAAa,MAAM;AAC1C,cAAI,YAAY,OAAO;AACnB,0BAAc,YAAY,MAAM,aAAa,SAAS;AAAA,UACtE,OAAmB;AACH,0BAAc,MAAM,UAAU,MAAM,KAAK,aAAa,aAAa,SAAS;AAAA,UAC5F;AAAA,QACA;AACQ,oBAAY,IAAI,aAAa,WAAW;AAAA,MAChD;AAII,UAAI,cAAe,2BAAW;AAC1B,iBAASC,SAAQ,MAAM;AACnB,cAAI,SAAS,IAAI,IAAI;AACrB,iBAAO,UAAU,IAAI;AACrB,iBAAO,IAAI,KAAK,QAAQ;AACpB,gBAAI,IAAI,KAAK,WAAW,GAAG;AAG3B,gBAAI,MAAM,IAAI;AACV,qBAAO,KAAK,SAAS,KAAK,OAAO,GAAG,CAAC,GAAG,EAAE,CAAC;AAC3C,mBAAK;AAAA,YAGzB,OAAuB;AACH,qBAAO,KAAK,CAAC;AAAA,YACjC;AAAA,UACA;AAEY,iBAAO,YAAY,MAAM;AAAA,QACrC;AAEQ,iBAAS,UAAU,OAAO;AACtB,cAAI,SAAS,IAAI,IAAI;AAErB,iBAAO,IAAI,MAAM,QAAQ;AACrB,gBAAI,IAAI,MAAM,CAAC;AAEf,gBAAI,IAAI,KAAK;AACT,qBAAO,KAAK,OAAO,aAAa,CAAC,CAAC;AAClC;AAAA,YACH,WAAU,IAAI,OAAO,IAAI,KAAK;AAC3B,qBAAO,KAAK,OAAO,cAAe,IAAI,OAAS,IAAM,MAAM,IAAI,CAAC,IAAI,EAAK,CAAC;AAC1E,mBAAK;AAAA,YACzB,OAAuB;AACH,qBAAO,KAAK,OAAO,cAAe,IAAI,OAAS,MAAQ,MAAM,IAAI,CAAC,IAAI,OAAS,IAAM,MAAM,IAAI,CAAC,IAAI,EAAK,CAAC;AAC1G,mBAAK;AAAA,YACzB;AAAA,UACA;AAEY,iBAAO,OAAO,KAAK,EAAE;AAAA,QACjC;AAEQ,eAAO;AAAA,UACH,SAASA;AAAA,UACT;AAAA,QACZ;AAAA,MACA,EAAQ;AAEJ,UAAI,aAAc,2BAAW;AACzB,iBAASA,SAAQ,MAAM;AACnB,cAAI,SAAS,CAAE;AACf,mBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GAAG;AACrC,mBAAO,KAAK,SAAS,KAAK,OAAO,GAAG,CAAC,GAAG,EAAE,CAAC;AAAA,UAC3D;AAEY,iBAAO;AAAA,QACnB;AAGQ,YAAI,MAAM;AAEV,iBAAS,UAAU,OAAO;AAClB,cAAI,SAAS,CAAE;AACf,mBAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,gBAAI,IAAI,MAAM,CAAC;AACf,mBAAO,KAAK,KAAK,IAAI,QAAS,CAAC,IAAI,IAAI,IAAI,EAAI,CAAC;AAAA,UACpE;AACgB,iBAAO,OAAO,KAAK,EAAE;AAAA,QACrC;AAEQ,eAAO;AAAA,UACH,SAASA;AAAA,UACT;AAAA,QACZ;AAAA,MACA,EAAQ;AAIJ,UAAI,iBAAiB,EAAC,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE;AAG5C,UAAI,OAAO,CAAC,GAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI;AAG9L,UAAI,IAAI,CAAC,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,GAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,GAAM,KAAM,IAAM,KAAM,IAAM,KAAM,GAAM,KAAM,GAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,GAAM,KAAM,IAAM,IAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,IAAM,KAAM,GAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,IAAM,KAAM,IAAM,KAAM,GAAM,KAAM,IAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAM,KAAM,KAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,GAAM,KAAM,IAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,EAAI;AACvgD,UAAI,KAAI,CAAC,IAAM,GAAM,KAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,IAAM,GAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,GAAM,KAAM,KAAM,IAAM,GAAM,KAAM,IAAM,IAAM,KAAM,KAAM,IAAM,IAAM,GAAM,KAAM,KAAM,KAAM,GAAM,GAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,KAAM,IAAM,KAAM,GAAM,KAAM,IAAM,KAAM,IAAM,IAAM,IAAM,IAAM,KAAM,KAAM,IAAM,IAAM,IAAM,KAAM,KAAM,IAAM,KAAM,IAAM,IAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,IAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,IAAM,KAAM,IAAM,IAAM,IAAM,GAAM,KAAM,KAAM,KAAM,KAAM,IAAM,KAAM,KAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAI;AAGvgD,UAAI,KAAK,CAAC,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,GAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,SAAU;AACxgG,UAAI,KAAK,CAAC,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,GAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,UAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,SAAU;AACxgG,UAAI,KAAK,CAAC,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,UAAY,YAAY,WAAY,YAAY,WAAY,YAAY,UAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,GAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,SAAU;AACxgG,UAAI,KAAK,CAAC,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,UAAY,YAAY,WAAY,YAAY,WAAY,YAAY,UAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,GAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,SAAU;AAGxgG,UAAI,KAAK,CAAC,YAAY,YAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,UAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,GAAY,WAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AACxgG,UAAI,KAAK,CAAC,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,GAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,UAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,UAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AACxgG,UAAI,KAAK,CAAC,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,UAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,GAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AACxgG,UAAI,KAAK,CAAC,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,UAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,YAAY,UAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,UAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,GAAY,YAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,WAAY,YAAY,UAAU;AAGxgG,UAAI,KAAK,CAAC,GAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,WAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AACxgG,UAAI,KAAK,CAAC,GAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,UAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,YAAY,WAAY,UAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AACxgG,UAAI,KAAK,CAAC,GAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,WAAY,WAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,WAAY,WAAY,YAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,WAAY,WAAY,YAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AACxgG,UAAI,KAAK,CAAC,GAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,YAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,YAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,YAAY,UAAU;AAExgG,eAAS,eAAe,OAAO;AAC3B,YAAI,SAAS,CAAE;AACf,iBAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACtC,iBAAO;AAAA,YACF,MAAM,CAAC,KAAS,KAChB,MAAM,IAAI,CAAC,KAAK,KAChB,MAAM,IAAI,CAAC,KAAM,IACjB,MAAM,IAAI,CAAC;AAAA,UACf;AAAA,QACb;AACQ,eAAO;AAAA,MACf;AAEI,UAAI,MAAM,SAAS,KAAK;AACpB,YAAI,EAAE,gBAAgB,MAAM;AACxB,gBAAM,MAAM,qCAAqC;AAAA,QAC7D;AAEQ,eAAO,eAAe,MAAM,OAAO;AAAA,UAC/B,OAAO,YAAY,KAAK,IAAI;AAAA,QACxC,CAAS;AAED,aAAK,SAAU;AAAA,MACvB;AAGI,UAAI,UAAU,WAAW,WAAW;AAEhC,YAAI,SAAS,eAAe,KAAK,IAAI,MAAM;AAC3C,YAAI,UAAU,MAAM;AAChB,gBAAM,IAAI,MAAM,+CAA+C;AAAA,QAC3E;AAGQ,aAAK,MAAM,CAAE;AAGb,aAAK,MAAM,CAAE;AAEb,iBAAS,IAAI,GAAG,KAAK,QAAQ,KAAK;AAC9B,eAAK,IAAI,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;AAC1B,eAAK,IAAI,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,QACtC;AAEQ,YAAI,iBAAiB,SAAS,KAAK;AACnC,YAAI,KAAK,KAAK,IAAI,SAAS;AAG3B,YAAI,KAAK,eAAe,KAAK,GAAG;AAGhC,YAAI;AACJ,iBAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,kBAAQ,KAAK;AACb,eAAK,IAAI,KAAK,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC;AAC7B,eAAK,IAAI,SAAS,KAAK,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC;AAAA,QAClD;AAGQ,YAAI,cAAc;AAClB,YAAIT,KAAI,IAAI;AACZ,eAAOA,KAAI,eAAe;AACtB,eAAK,GAAG,KAAK,CAAC;AACd,aAAG,CAAC,KAAO,EAAG,MAAM,KAAM,GAAI,KAAK,KACxB,EAAG,MAAO,IAAK,GAAI,KAAK,KACxB,EAAG,KAAY,GAAI,KAAM,IACzB,EAAG,MAAM,KAAM,GAAI,IACnB,KAAK,WAAW,KAAK;AAChC,yBAAe;AAGf,cAAI,MAAM,GAAG;AACT,qBAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,iBAAG,CAAC,KAAK,GAAG,IAAI,CAAC;AAAA,YACrC;AAAA,UAGA,OAAmB;AACH,qBAAS,IAAI,GAAG,IAAK,KAAK,GAAI,KAAK;AAC/B,iBAAG,CAAC,KAAK,GAAG,IAAI,CAAC;AAAA,YACrC;AACgB,iBAAK,GAAI,KAAK,IAAK,CAAC;AAEpB,eAAG,KAAK,CAAC,KAAM,EAAG,KAAY,GAAI,IACnB,EAAG,MAAO,IAAK,GAAI,KAAM,IACzB,EAAG,MAAM,KAAM,GAAI,KAAK,KACxB,EAAG,MAAM,KAAM,GAAI,KAAK;AAEvC,qBAAS,IAAK,KAAK,IAAK,GAAG,IAAI,IAAI,KAAK;AACpC,iBAAG,CAAC,KAAK,GAAG,IAAI,CAAC;AAAA,YACrC;AAAA,UACA;AAGY,cAAI,IAAI,GAAG,GAAG;AACd,iBAAO,IAAI,MAAMA,KAAI,eAAe;AAChC,gBAAIA,MAAK;AACT,gBAAIA,KAAI;AACR,iBAAK,IAAI,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC;AACrB,iBAAK,IAAI,SAAS,CAAC,EAAE,CAAC,IAAI,GAAG,GAAG;AAChC,YAAAA;AAAA,UAChB;AAAA,QACA;AAGQ,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,mBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,iBAAK,KAAK,IAAI,CAAC,EAAE,CAAC;AAClB,iBAAK,IAAI,CAAC,EAAE,CAAC,IAAK,GAAI,MAAM,KAAM,GAAI,IACpB,GAAI,MAAM,KAAM,GAAI,IACpB,GAAI,MAAO,IAAK,GAAI,IACpB,GAAI,KAAY,GAAI;AAAA,UACtD;AAAA,QACA;AAAA,MACA;AAEI,UAAI,UAAU,UAAU,SAAS,WAAW;AACxC,YAAI,UAAU,UAAU,IAAI;AACxB,gBAAM,IAAI,MAAM,2CAA2C;AAAA,QACvE;AAEQ,YAAI,SAAS,KAAK,IAAI,SAAS;AAC/B,YAAI,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AAGnB,YAAIA,KAAI,eAAe,SAAS;AAChC,iBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,UAAAA,GAAE,CAAC,KAAK,KAAK,IAAI,CAAC,EAAE,CAAC;AAAA,QACjC;AAGQ,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,mBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,cAAE,CAAC,IAAK,GAAIA,GAAG,CAAW,KAAI,KAAM,GAAI,IAChC,GAAIA,IAAG,IAAI,KAAK,CAAC,KAAK,KAAM,GAAI,IAChC,GAAIA,IAAG,IAAI,KAAK,CAAC,KAAM,IAAK,GAAI,IAChC,GAAIA,IAAG,IAAI,KAAK,CAAC,IAAW,GAAI,IAChC,KAAK,IAAI,CAAC,EAAE,CAAC;AAAA,UACrC;AACY,UAAAA,KAAI,EAAE,MAAO;AAAA,QACzB;AAGQ,YAAI,SAAS,YAAY,EAAE,GAAG;AAC9B,iBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,eAAK,KAAK,IAAI,MAAM,EAAE,CAAC;AACvB,iBAAO,IAAI,CAAM,KAAI,EAAGA,GAAG,CAAW,KAAI,KAAM,GAAI,IAAK,MAAM,MAAO;AACtE,iBAAO,IAAI,IAAI,CAAC,KAAK,EAAGA,IAAG,IAAI,KAAK,CAAC,KAAK,KAAM,GAAI,IAAK,MAAM,MAAO;AACtE,iBAAO,IAAI,IAAI,CAAC,KAAK,EAAGA,IAAG,IAAI,KAAK,CAAC,KAAM,IAAK,GAAI,IAAK,MAAO,KAAM;AACtE,iBAAO,IAAI,IAAI,CAAC,KAAK,EAAGA,IAAG,IAAI,KAAK,CAAC,IAAW,GAAI,IAAK,MAAa;AAAA,QAClF;AAEQ,eAAO;AAAA,MACf;AAEI,UAAI,UAAU,UAAU,SAAS,YAAY;AACzC,YAAI,WAAW,UAAU,IAAI;AACzB,gBAAM,IAAI,MAAM,4CAA4C;AAAA,QACxE;AAEQ,YAAI,SAAS,KAAK,IAAI,SAAS;AAC/B,YAAI,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AAGnB,YAAIA,KAAI,eAAe,UAAU;AACjC,iBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,UAAAA,GAAE,CAAC,KAAK,KAAK,IAAI,CAAC,EAAE,CAAC;AAAA,QACjC;AAGQ,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,mBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,cAAE,CAAC,IAAK,GAAIA,GAAG,CAAY,KAAI,KAAM,GAAI,IACjC,GAAIA,IAAG,IAAI,KAAK,CAAC,KAAK,KAAM,GAAI,IAChC,GAAIA,IAAG,IAAI,KAAK,CAAC,KAAM,IAAK,GAAI,IAChC,GAAIA,IAAG,IAAI,KAAK,CAAC,IAAW,GAAI,IAChC,KAAK,IAAI,CAAC,EAAE,CAAC;AAAA,UACrC;AACY,UAAAA,KAAI,EAAE,MAAO;AAAA,QACzB;AAGQ,YAAI,SAAS,YAAY,EAAE,GAAG;AAC9B,iBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,eAAK,KAAK,IAAI,MAAM,EAAE,CAAC;AACvB,iBAAO,IAAI,CAAM,KAAI,GAAIA,GAAG,CAAW,KAAI,KAAM,GAAI,IAAK,MAAM,MAAO;AACvE,iBAAO,IAAI,IAAI,CAAC,KAAK,GAAIA,IAAG,IAAI,KAAK,CAAC,KAAK,KAAM,GAAI,IAAK,MAAM,MAAO;AACvE,iBAAO,IAAI,IAAI,CAAC,KAAK,GAAIA,IAAG,IAAI,KAAK,CAAC,KAAM,IAAK,GAAI,IAAK,MAAO,KAAM;AACvE,iBAAO,IAAI,IAAI,CAAC,KAAK,GAAIA,IAAG,IAAI,KAAK,CAAC,IAAW,GAAI,IAAK,MAAa;AAAA,QACnF;AAEQ,eAAO;AAAA,MACf;AAMI,UAAI,qBAAqB,SAAS,KAAK;AACnC,YAAI,EAAE,gBAAgB,qBAAqB;AACvC,gBAAM,MAAM,qCAAqC;AAAA,QAC7D;AAEQ,aAAK,cAAc;AACnB,aAAK,OAAO;AAEZ,aAAK,OAAO,IAAI,IAAI,GAAG;AAAA,MAC/B;AAEI,yBAAmB,UAAU,UAAU,SAAS,WAAW;AACvD,oBAAY,YAAY,SAAS;AAEjC,YAAK,UAAU,SAAS,OAAQ,GAAG;AAC/B,gBAAM,IAAI,MAAM,uDAAuD;AAAA,QACnF;AAEQ,YAAI,aAAa,YAAY,UAAU,MAAM;AAC7C,YAAI,QAAQ,YAAY,EAAE;AAE1B,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,IAAI;AAC3C,oBAAU,WAAW,OAAO,GAAG,GAAG,IAAI,EAAE;AACxC,kBAAQ,KAAK,KAAK,QAAQ,KAAK;AAC/B,oBAAU,OAAO,YAAY,CAAC;AAAA,QAC1C;AAEQ,eAAO;AAAA,MACf;AAEI,yBAAmB,UAAU,UAAU,SAAS,YAAY;AACxD,qBAAa,YAAY,UAAU;AAEnC,YAAK,WAAW,SAAS,OAAQ,GAAG;AAChC,gBAAM,IAAI,MAAM,wDAAwD;AAAA,QACpF;AAEQ,YAAI,YAAY,YAAY,WAAW,MAAM;AAC7C,YAAI,QAAQ,YAAY,EAAE;AAE1B,iBAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK,IAAI;AAC5C,oBAAU,YAAY,OAAO,GAAG,GAAG,IAAI,EAAE;AACzC,kBAAQ,KAAK,KAAK,QAAQ,KAAK;AAC/B,oBAAU,OAAO,WAAW,CAAC;AAAA,QACzC;AAEQ,eAAO;AAAA,MACf;AAMI,UAAI,qBAAqB,SAAS,KAAK,IAAI;AACvC,YAAI,EAAE,gBAAgB,qBAAqB;AACvC,gBAAM,MAAM,qCAAqC;AAAA,QAC7D;AAEQ,aAAK,cAAc;AACnB,aAAK,OAAO;AAEZ,YAAI,CAAC,IAAI;AACL,eAAK,YAAY,EAAE;AAAA,QAE/B,WAAmB,GAAG,UAAU,IAAI;AACxB,gBAAM,IAAI,MAAM,qDAAqD;AAAA,QACjF;AAEQ,aAAK,mBAAmB,YAAY,IAAI,IAAI;AAE5C,aAAK,OAAO,IAAI,IAAI,GAAG;AAAA,MAC/B;AAEI,yBAAmB,UAAU,UAAU,SAAS,WAAW;AACvD,oBAAY,YAAY,SAAS;AAEjC,YAAK,UAAU,SAAS,OAAQ,GAAG;AAC/B,gBAAM,IAAI,MAAM,uDAAuD;AAAA,QACnF;AAEQ,YAAI,aAAa,YAAY,UAAU,MAAM;AAC7C,YAAI,QAAQ,YAAY,EAAE;AAE1B,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,IAAI;AAC3C,oBAAU,WAAW,OAAO,GAAG,GAAG,IAAI,EAAE;AAExC,mBAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,kBAAM,CAAC,KAAK,KAAK,iBAAiB,CAAC;AAAA,UACnD;AAEY,eAAK,mBAAmB,KAAK,KAAK,QAAQ,KAAK;AAC/C,oBAAU,KAAK,kBAAkB,YAAY,CAAC;AAAA,QAC1D;AAEQ,eAAO;AAAA,MACf;AAEI,yBAAmB,UAAU,UAAU,SAAS,YAAY;AACxD,qBAAa,YAAY,UAAU;AAEnC,YAAK,WAAW,SAAS,OAAQ,GAAG;AAChC,gBAAM,IAAI,MAAM,wDAAwD;AAAA,QACpF;AAEQ,YAAI,YAAY,YAAY,WAAW,MAAM;AAC7C,YAAI,QAAQ,YAAY,EAAE;AAE1B,iBAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK,IAAI;AAC5C,oBAAU,YAAY,OAAO,GAAG,GAAG,IAAI,EAAE;AACzC,kBAAQ,KAAK,KAAK,QAAQ,KAAK;AAE/B,mBAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,sBAAU,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,iBAAiB,CAAC;AAAA,UACrE;AAEY,oBAAU,YAAY,KAAK,kBAAkB,GAAG,GAAG,IAAI,EAAE;AAAA,QACrE;AAEQ,eAAO;AAAA,MACf;AAMI,UAAI,qBAAqB,SAAS,KAAK,IAAI,aAAa;AACpD,YAAI,EAAE,gBAAgB,qBAAqB;AACvC,gBAAM,MAAM,qCAAqC;AAAA,QAC7D;AAEQ,aAAK,cAAc;AACnB,aAAK,OAAO;AAEZ,YAAI,CAAC,IAAI;AACL,eAAK,YAAY,EAAE;AAAA,QAE/B,WAAmB,GAAG,UAAU,IAAI;AACxB,gBAAM,IAAI,MAAM,oDAAoD;AAAA,QAChF;AAEQ,YAAI,CAAC,aAAa;AAAE,wBAAc;AAAA,QAAE;AAEpC,aAAK,cAAc;AAEnB,aAAK,iBAAiB,YAAY,IAAI,IAAI;AAE1C,aAAK,OAAO,IAAI,IAAI,GAAG;AAAA,MAC/B;AAEI,yBAAmB,UAAU,UAAU,SAAS,WAAW;AACvD,YAAK,UAAU,SAAS,KAAK,eAAgB,GAAG;AAC5C,gBAAM,IAAI,MAAM,oDAAoD;AAAA,QAChF;AAEQ,YAAI,YAAY,YAAY,WAAW,IAAI;AAE3C,YAAI;AACJ,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,KAAK,aAAa;AACzD,uBAAa,KAAK,KAAK,QAAQ,KAAK,cAAc;AAClD,mBAAS,IAAI,GAAG,IAAI,KAAK,aAAa,KAAK;AACvC,sBAAU,IAAI,CAAC,KAAK,WAAW,CAAC;AAAA,UAChD;AAGY,oBAAU,KAAK,gBAAgB,KAAK,gBAAgB,GAAG,KAAK,WAAW;AACvE,oBAAU,WAAW,KAAK,gBAAgB,KAAK,KAAK,aAAa,GAAG,IAAI,KAAK,WAAW;AAAA,QACpG;AAEQ,eAAO;AAAA,MACf;AAEI,yBAAmB,UAAU,UAAU,SAAS,YAAY;AACxD,YAAK,WAAW,SAAS,KAAK,eAAgB,GAAG;AAC7C,gBAAM,IAAI,MAAM,qDAAqD;AAAA,QACjF;AAEQ,YAAI,YAAY,YAAY,YAAY,IAAI;AAE5C,YAAI;AACJ,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK,KAAK,aAAa;AACzD,uBAAa,KAAK,KAAK,QAAQ,KAAK,cAAc;AAElD,mBAAS,IAAI,GAAG,IAAI,KAAK,aAAa,KAAK;AACvC,sBAAU,IAAI,CAAC,KAAK,WAAW,CAAC;AAAA,UAChD;AAGY,oBAAU,KAAK,gBAAgB,KAAK,gBAAgB,GAAG,KAAK,WAAW;AACvE,oBAAU,YAAY,KAAK,gBAAgB,KAAK,KAAK,aAAa,GAAG,IAAI,KAAK,WAAW;AAAA,QACrG;AAEQ,eAAO;AAAA,MACf;AAKI,UAAI,qBAAqB,SAAS,KAAK,IAAI;AACvC,YAAI,EAAE,gBAAgB,qBAAqB;AACvC,gBAAM,MAAM,qCAAqC;AAAA,QAC7D;AAEQ,aAAK,cAAc;AACnB,aAAK,OAAO;AAEZ,YAAI,CAAC,IAAI;AACL,eAAK,YAAY,EAAE;AAAA,QAE/B,WAAmB,GAAG,UAAU,IAAI;AACxB,gBAAM,IAAI,MAAM,qDAAqD;AAAA,QACjF;AAEQ,aAAK,iBAAiB,YAAY,IAAI,IAAI;AAC1C,aAAK,sBAAsB;AAE3B,aAAK,OAAO,IAAI,IAAI,GAAG;AAAA,MAC/B;AAEI,yBAAmB,UAAU,UAAU,SAAS,WAAW;AACvD,YAAI,YAAY,YAAY,WAAW,IAAI;AAE3C,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACvC,cAAI,KAAK,wBAAwB,IAAI;AACjC,iBAAK,iBAAiB,KAAK,KAAK,QAAQ,KAAK,cAAc;AAC3D,iBAAK,sBAAsB;AAAA,UAC3C;AACY,oBAAU,CAAC,KAAK,KAAK,eAAe,KAAK,qBAAqB;AAAA,QAC1E;AAEQ,eAAO;AAAA,MACf;AAGI,yBAAmB,UAAU,UAAU,mBAAmB,UAAU;AAMpE,UAAI,UAAU,SAAS,cAAc;AACjC,YAAI,EAAE,gBAAgB,UAAU;AAC5B,gBAAM,MAAM,yCAAyC;AAAA,QACjE;AAGQ,YAAI,iBAAiB,KAAK,CAAC,cAAc;AAAE,yBAAe;AAAA,QAAE;AAE5D,YAAI,OAAO,iBAAkB,UAAU;AACnC,eAAK,WAAW,YAAY,EAAE;AAC9B,eAAK,SAAS,YAAY;AAAA,QAEtC,OAAe;AACH,eAAK,SAAS,YAAY;AAAA,QACtC;AAAA,MACA;AAEI,cAAQ,UAAU,WAAW,SAAS,OAAO;AACzC,YAAI,OAAO,UAAW,YAAY,SAAS,KAAK,KAAK,OAAO;AACxD,gBAAM,IAAI,MAAM,4CAA4C;AAAA,QACxE;AAGQ,YAAI,QAAQ,OAAO,kBAAkB;AACjC,gBAAM,IAAI,MAAM,iCAAiC;AAAA,QAC7D;AAEQ,iBAAS,QAAQ,IAAI,SAAS,GAAG,EAAE,OAAO;AACtC,eAAK,SAAS,KAAK,IAAI,QAAQ;AAC/B,kBAAQ,SAAS,QAAQ,GAAG;AAAA,QACxC;AAAA,MACA;AAEI,cAAQ,UAAU,WAAW,SAAS,OAAO;AACzC,gBAAQ,YAAY,OAAO,IAAI;AAE/B,YAAI,MAAM,UAAU,IAAI;AACpB,gBAAM,IAAI,MAAM,+CAA+C;AAAA,QAC3E;AAEQ,aAAK,WAAW;AAAA,MACnB;AAED,cAAQ,UAAU,YAAY,WAAW;AACrC,iBAAS,IAAI,IAAI,KAAK,GAAG,KAAK;AAC1B,cAAI,KAAK,SAAS,CAAC,MAAM,KAAK;AAC1B,iBAAK,SAAS,CAAC,IAAI;AAAA,UACnC,OAAmB;AACH,iBAAK,SAAS,CAAC;AACf;AAAA,UAChB;AAAA,QACA;AAAA,MACA;AAMI,UAAI,qBAAqB,SAAS,KAAK,SAAS;AAC5C,YAAI,EAAE,gBAAgB,qBAAqB;AACvC,gBAAM,MAAM,qCAAqC;AAAA,QAC7D;AAEQ,aAAK,cAAc;AACnB,aAAK,OAAO;AAEZ,YAAI,EAAE,mBAAmB,UAAU;AAC/B,oBAAU,IAAI,QAAQ,OAAO;AAAA,QACzC;AAEQ,aAAK,WAAW;AAEhB,aAAK,oBAAoB;AACzB,aAAK,yBAAyB;AAE9B,aAAK,OAAO,IAAI,IAAI,GAAG;AAAA,MAC/B;AAEI,yBAAmB,UAAU,UAAU,SAAS,WAAW;AACvD,YAAI,YAAY,YAAY,WAAW,IAAI;AAE3C,iBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACvC,cAAI,KAAK,2BAA2B,IAAI;AACpC,iBAAK,oBAAoB,KAAK,KAAK,QAAQ,KAAK,SAAS,QAAQ;AACjE,iBAAK,yBAAyB;AAC9B,iBAAK,SAAS,UAAW;AAAA,UACzC;AACY,oBAAU,CAAC,KAAK,KAAK,kBAAkB,KAAK,wBAAwB;AAAA,QAChF;AAEQ,eAAO;AAAA,MACf;AAGI,yBAAmB,UAAU,UAAU,mBAAmB,UAAU;AAOpE,eAAS,SAAS,MAAM;AACpB,eAAO,YAAY,MAAM,IAAI;AAC7B,YAAI,SAAS,KAAM,KAAK,SAAS;AACjC,YAAI,SAAS,YAAY,KAAK,SAAS,MAAM;AAC7C,kBAAU,MAAM,MAAM;AACtB,iBAAS,IAAI,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK;AAC9C,iBAAO,CAAC,IAAI;AAAA,QACxB;AACQ,eAAO;AAAA,MACf;AAEI,eAAS,WAAW,MAAM;AACtB,eAAO,YAAY,MAAM,IAAI;AAC7B,YAAI,KAAK,SAAS,IAAI;AAAE,gBAAM,IAAI,MAAM,uBAAuB;AAAA,QAAE;AAEjE,YAAI,SAAS,KAAK,KAAK,SAAS,CAAC;AACjC,YAAI,SAAS,IAAI;AAAE,gBAAM,IAAI,MAAM,kCAAkC;AAAA,QAAE;AAEvE,YAAI,SAAS,KAAK,SAAS;AAC3B,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,cAAI,KAAK,SAAS,CAAC,MAAM,QAAQ;AAC7B,kBAAM,IAAI,MAAM,6BAA6B;AAAA,UAC7D;AAAA,QACA;AAEQ,YAAI,SAAS,YAAY,MAAM;AAC/B,kBAAU,MAAM,QAAQ,GAAG,GAAG,MAAM;AACpC,eAAO;AAAA,MACf;AAOI,UAAI,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QAEA,iBAAiB;AAAA,UACb,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,QACR;AAAA,QAED,OAAO;AAAA,UACH,KAAK;AAAA,UACL,MAAM;AAAA,QACT;AAAA,QAED,SAAS;AAAA,UACL,OAAO;AAAA,YACH,KAAK;AAAA,YACL,OAAO;AAAA,UACvB;AAAA,QACS;AAAA,QAED,YAAY;AAAA,UACR;AAAA,UACA;AAAA,UACA;AAAA,QACZ;AAAA,MACK;AAImC;AAChC,eAAiB,UAAA;AAAA;IAoBxB,GAAM;AAAA;;;;;ACxxBP,SAASU,UAAQ,GAAG;AAChB,SAAO,aAAa,cAAe,YAAY,OAAO,CAAC,KAAK,EAAE,YAAY,SAAS;AACvF;AAEA,SAASC,SAAO,MAAM,SAAS;AAC3B,MAAI,CAACD,UAAQ,CAAC;AACV,UAAM,IAAI,MAAM,qBAAqB;AACzC,MAAI,QAAQ,SAAS,KAAK,CAAC,QAAQ,SAAS,EAAE,MAAM;AAChD,UAAM,IAAI,MAAM,mCAAmC,UAAU,kBAAkB,EAAE,MAAM;AAC/F;AASA,SAAS,QAAQ,UAAU,gBAAgB,MAAM;AAC7C,MAAI,SAAS;AACT,UAAM,IAAI,MAAM,kCAAkC;AACtD,MAAI,iBAAiB,SAAS;AAC1B,UAAM,IAAI,MAAM,uCAAuC;AAC/D;AAEA,SAAS,QAAQ,KAAK,UAAU;AAC5BC,WAAO,GAAG;AACV,QAAM,MAAM,SAAS;AACrB,MAAI,IAAI,SAAS,KAAK;AAClB,UAAM,IAAI,MAAM,2DAA2D,GAAG;AAAA,EACtF;AACA;ACzCO,MAAM,SAAS,OAAO,eAAe,YAAY,YAAY,aAAa,WAAW,SAAS;ACIrG;AAsBO,SAAS,WAAW,KAAK;AAC5B,SAAO,IAAI,SAAS,IAAI,QAAQ,IAAI,YAAY,IAAI,UAAU;AAClE;AAEO,SAAS,KAAK,MAAM,OAAO;AAC9B,SAAQ,QAAS,KAAK,QAAW,SAAS;AAC9C;AAgGO,SAASC,cAAY,KAAK;AAC7B,MAAI,OAAO,QAAQ;AACf,UAAM,IAAI,MAAM,sCAAsC,OAAO,GAAG;AACpE,SAAO,IAAI,WAAW,IAAI,YAAa,EAAC,OAAO,GAAG,CAAC;AACvD;AAMO,SAAS,QAAQ,MAAM;AAC1B,MAAI,OAAO,SAAS;AAChB,WAAOA,cAAY,IAAI;AAC3BD,WAAO,IAAI;AACX,SAAO;AACX;AAoBO,MAAM,KAAK;AAAA;AAAA,EAEd,QAAQ;AACJ,WAAO,KAAK,WAAY;AAAA,EAChC;AACA;AAQO,SAAS,gBAAgB,UAAU;AACtC,QAAM,QAAQ,CAAC,QAAQ,SAAU,EAAC,OAAO,QAAQ,GAAG,CAAC,EAAE,OAAQ;AAC/D,QAAM,MAAM,SAAU;AACtB,QAAM,YAAY,IAAI;AACtB,QAAM,WAAW,IAAI;AACrB,QAAM,SAAS,MAAM,SAAU;AAC/B,SAAO;AACX;AAkBO,SAAS,YAAY,cAAc,IAAI;AAC1C,MAAI,UAAU,OAAO,OAAO,oBAAoB,YAAY;AACxD,WAAO,OAAO,gBAAgB,IAAI,WAAW,WAAW,CAAC;AAAA,EACjE;AAEI,MAAI,UAAU,OAAO,OAAO,gBAAgB,YAAY;AACpD,WAAO,OAAO,YAAY,WAAW;AAAA,EAC7C;AACI,QAAM,IAAI,MAAM,wCAAwC;AAC5D;AC3MO,SAAS,aAAa,MAAM,YAAY,OAAO,MAAM;AACxD,MAAI,OAAO,KAAK,iBAAiB;AAC7B,WAAO,KAAK,aAAa,YAAY,OAAO,IAAI;AACpD,QAAM,OAAO,OAAO,EAAE;AACtB,QAAM,WAAW,OAAO,UAAU;AAClC,QAAM,KAAK,OAAQ,SAAS,OAAQ,QAAQ;AAC5C,QAAM,KAAK,OAAO,QAAQ,QAAQ;AAClC,QAAML,KAAI,OAAO,IAAI;AACrB,QAAMb,KAAI,OAAO,IAAI;AACrB,OAAK,UAAU,aAAaa,IAAG,IAAI,IAAI;AACvC,OAAK,UAAU,aAAab,IAAG,IAAI,IAAI;AAC3C;AAEO,SAAS,IAAI,GAAG,GAAG,GAAG;AACzB,SAAQ,IAAI,IAAM,CAAC,IAAI;AAC3B;AAEO,SAAS,IAAI,GAAG,GAAG,GAAG;AACzB,SAAQ,IAAI,IAAM,IAAI,IAAM,IAAI;AACpC;AAKO,MAAM,eAAe,KAAK;AAAA,EAC7B,YAAY,UAAU,WAAW,WAAW,MAAM;AAC9C,UAAO;AACP,SAAK,WAAW;AAChB,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,OAAO;AACZ,SAAK,WAAW;AAChB,SAAK,SAAS;AACd,SAAK,MAAM;AACX,SAAK,YAAY;AACjB,SAAK,SAAS,IAAI,WAAW,QAAQ;AACrC,SAAK,OAAO,WAAW,KAAK,MAAM;AAAA,EAC1C;AAAA,EACI,OAAO,MAAM;AACT,YAAQ,IAAI;AACZ,UAAM,EAAE,MAAM,QAAQ,SAAU,IAAG;AACnC,WAAO,QAAQ,IAAI;AACnB,UAAM,MAAM,KAAK;AACjB,aAAS,MAAM,GAAG,MAAM,OAAM;AAC1B,YAAM,OAAO,KAAK,IAAI,WAAW,KAAK,KAAK,MAAM,GAAG;AAEpD,UAAI,SAAS,UAAU;AACnB,cAAM,WAAW,WAAW,IAAI;AAChC,eAAO,YAAY,MAAM,KAAK,OAAO;AACjC,eAAK,QAAQ,UAAU,GAAG;AAC9B;AAAA,MAChB;AACY,aAAO,IAAI,KAAK,SAAS,KAAK,MAAM,IAAI,GAAG,KAAK,GAAG;AACnD,WAAK,OAAO;AACZ,aAAO;AACP,UAAI,KAAK,QAAQ,UAAU;AACvB,aAAK,QAAQ,MAAM,CAAC;AACpB,aAAK,MAAM;AAAA,MAC3B;AAAA,IACA;AACQ,SAAK,UAAU,KAAK;AACpB,SAAK,WAAY;AACjB,WAAO;AAAA,EACf;AAAA,EACI,WAAW,KAAK;AACZ,YAAQ,IAAI;AACZ,YAAQ,KAAK,IAAI;AACjB,SAAK,WAAW;AAIhB,UAAM,EAAE,QAAQ,MAAM,UAAU,KAAM,IAAG;AACzC,QAAI,EAAE,IAAG,IAAK;AAEd,WAAO,KAAK,IAAI;AAChB,SAAK,OAAO,SAAS,GAAG,EAAE,KAAK,CAAC;AAGhC,QAAI,KAAK,YAAY,WAAW,KAAK;AACjC,WAAK,QAAQ,MAAM,CAAC;AACpB,YAAM;AAAA,IAClB;AAEQ,aAAS,IAAI,KAAK,IAAI,UAAU;AAC5B,aAAO,CAAC,IAAI;AAIhB,iBAAa,MAAM,WAAW,GAAG,OAAO,KAAK,SAAS,CAAC,GAAG,IAAI;AAC9D,SAAK,QAAQ,MAAM,CAAC;AACpB,UAAM,QAAQ,WAAW,GAAG;AAC5B,UAAM,MAAM,KAAK;AAEjB,QAAI,MAAM;AACN,YAAM,IAAI,MAAM,6CAA6C;AACjE,UAAM,SAAS,MAAM;AACrB,UAAM,QAAQ,KAAK,IAAK;AACxB,QAAI,SAAS,MAAM;AACf,YAAM,IAAI,MAAM,oCAAoC;AACxD,aAAS,IAAI,GAAG,IAAI,QAAQ;AACxB,YAAM,UAAU,IAAI,GAAG,MAAM,CAAC,GAAG,IAAI;AAAA,EACjD;AAAA,EACI,SAAS;AACL,UAAM,EAAE,QAAQ,UAAS,IAAK;AAC9B,SAAK,WAAW,MAAM;AACtB,UAAM,MAAM,OAAO,MAAM,GAAG,SAAS;AACrC,SAAK,QAAS;AACd,WAAO;AAAA,EACf;AAAA,EACI,WAAW,IAAI;AACX,WAAO,KAAK,IAAI,KAAK,YAAW;AAChC,OAAG,IAAI,GAAG,KAAK,IAAG,CAAE;AACpB,UAAM,EAAE,UAAU,QAAQ,QAAQ,UAAU,WAAW,IAAG,IAAK;AAC/D,OAAG,SAAS;AACZ,OAAG,MAAM;AACT,OAAG,WAAW;AACd,OAAG,YAAY;AACf,QAAI,SAAS;AACT,SAAG,OAAO,IAAI,MAAM;AACxB,WAAO;AAAA,EACf;AACA;ACnHA,MAAM,WAA2B,oBAAI,YAAY;AAAA,EAC7C;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EACpF;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AACxF,CAAC;AAGD,MAAM,YAA4B,oBAAI,YAAY;AAAA,EAC9C;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AAAA,EAAY;AACxF,CAAC;AAKD,MAAM,WAA2B,oBAAI,YAAY,EAAE;AAC5C,MAAM,eAAe,OAAO;AAAA,EAC/B,cAAc;AACV,UAAM,IAAI,IAAI,GAAG,KAAK;AAGtB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AACxB,SAAK,IAAI,UAAU,CAAC,IAAI;AAAA,EAChC;AAAA,EACI,MAAM;AACF,UAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAC,IAAK;AACnC,WAAO,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAAA,EACtC;AAAA;AAAA,EAEI,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG;AACxB,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AACb,SAAK,IAAI,IAAI;AAAA,EACrB;AAAA,EACI,QAAQ,MAAM,QAAQ;AAElB,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK,UAAU;AACnC,eAAS,CAAC,IAAI,KAAK,UAAU,QAAQ,KAAK;AAC9C,aAAS,IAAI,IAAI,IAAI,IAAI,KAAK;AAC1B,YAAM,MAAM,SAAS,IAAI,EAAE;AAC3B,YAAM,KAAK,SAAS,IAAI,CAAC;AACzB,YAAM,KAAK,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,IAAK,QAAQ;AACnD,YAAM,KAAK,KAAK,IAAI,EAAE,IAAI,KAAK,IAAI,EAAE,IAAK,OAAO;AACjD,eAAS,CAAC,IAAK,KAAK,SAAS,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAK;AAAA,IAC3E;AAEQ,QAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAC,IAAK;AACjC,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,YAAM,SAAS,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,EAAE,IAAI,KAAK,GAAG,EAAE;AACpD,YAAM,KAAM,IAAI,SAAS,IAAI,GAAG,GAAG,CAAC,IAAI,SAAS,CAAC,IAAI,SAAS,CAAC,IAAK;AACrE,YAAM,SAAS,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,EAAE,IAAI,KAAK,GAAG,EAAE;AACpD,YAAM,KAAM,SAAS,IAAI,GAAG,GAAG,CAAC,IAAK;AACrC,UAAI;AACJ,UAAI;AACJ,UAAI;AACJ,UAAK,IAAI,KAAM;AACf,UAAI;AACJ,UAAI;AACJ,UAAI;AACJ,UAAK,KAAK,KAAM;AAAA,IAC5B;AAEQ,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,QAAK,IAAI,KAAK,IAAK;AACnB,SAAK,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAAA,EACvC;AAAA,EACI,aAAa;AACT,aAAS,KAAK,CAAC;AAAA,EACvB;AAAA,EACI,UAAU;AACN,SAAK,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAC/B,SAAK,OAAO,KAAK,CAAC;AAAA,EAC1B;AACA;AAmBO,MAAM,SAAyB,gCAAgB,MAAM,IAAI,QAAQ;AC1HxE;AAKA,MAAMoB,QAAsB,uBAAO,CAAC;AACpC,MAAMC,QAAsB,uBAAO,CAAC;AACpC,MAAMC,QAAsB,uBAAO,CAAC;AAC7B,SAAS,QAAQ,GAAG;AACvB,SAAO,aAAa,cAAe,YAAY,OAAO,CAAC,KAAK,EAAE,YAAY,SAAS;AACvF;AACO,SAAS,OAAO,MAAM;AACzB,MAAI,CAAC,QAAQ,IAAI;AACb,UAAM,IAAI,MAAM,qBAAqB;AAC7C;AACO,SAAS,MAAM,OAAO,OAAO;AAChC,MAAI,OAAO,UAAU;AACjB,UAAM,IAAI,MAAM,QAAQ,4BAA4B,KAAK;AACjE;AAEA,MAAM,QAAwB,sBAAM,KAAK,EAAE,QAAQ,IAAK,GAAE,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAI5F,SAAS,WAAW,OAAO;AAC9B,SAAO,KAAK;AAEZ,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,WAAO,MAAM,MAAM,CAAC,CAAC;AAAA,EAC7B;AACI,SAAO;AACX;AAKO,SAAS,YAAY,KAAK;AAC7B,MAAI,OAAO,QAAQ;AACf,UAAM,IAAI,MAAM,8BAA8B,OAAO,GAAG;AAC5D,SAAO,QAAQ,KAAKF,QAAM,OAAO,OAAO,GAAG;AAC/C;AAEA,MAAM,SAAS,EAAE,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAK;AAC9D,SAAS,cAAc,IAAI;AACvB,MAAI,MAAM,OAAO,MAAM,MAAM,OAAO;AAChC,WAAO,KAAK,OAAO;AACvB,MAAI,MAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,WAAO,MAAM,OAAO,IAAI;AAC5B,MAAI,MAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,WAAO,MAAM,OAAO,IAAI;AAC5B;AACJ;AAIO,SAAS,WAAW,KAAK;AAC5B,MAAI,OAAO,QAAQ;AACf,UAAM,IAAI,MAAM,8BAA8B,OAAO,GAAG;AAC5D,QAAM,KAAK,IAAI;AACf,QAAM,KAAK,KAAK;AAChB,MAAI,KAAK;AACL,UAAM,IAAI,MAAM,qDAAqD,EAAE;AAC3E,QAAM,QAAQ,IAAI,WAAW,EAAE;AAC/B,WAAS,KAAK,GAAG,KAAK,GAAG,KAAK,IAAI,MAAM,MAAM,GAAG;AAC7C,UAAM,KAAK,cAAc,IAAI,WAAW,EAAE,CAAC;AAC3C,UAAM,KAAK,cAAc,IAAI,WAAW,KAAK,CAAC,CAAC;AAC/C,QAAI,OAAO,UAAa,OAAO,QAAW;AACtC,YAAM,OAAO,IAAI,EAAE,IAAI,IAAI,KAAK,CAAC;AACjC,YAAM,IAAI,MAAM,iDAAiD,OAAO,gBAAgB,EAAE;AAAA,IACtG;AACQ,UAAM,EAAE,IAAI,KAAK,KAAK;AAAA,EAC9B;AACI,SAAO;AACX;AAEO,SAAS,gBAAgB,OAAO;AACnC,SAAO,YAAY,WAAW,KAAK,CAAC;AACxC;AACO,SAAS,gBAAgB,OAAO;AACnC,SAAO,KAAK;AACZ,SAAO,YAAY,WAAW,WAAW,KAAK,KAAK,EAAE,QAAO,CAAE,CAAC;AACnE;AACO,SAAS,gBAAgBG,IAAG,KAAK;AACpC,SAAO,WAAWA,GAAE,SAAS,EAAE,EAAE,SAAS,MAAM,GAAG,GAAG,CAAC;AAC3D;AACO,SAAS,gBAAgBA,IAAG,KAAK;AACpC,SAAO,gBAAgBA,IAAG,GAAG,EAAE,QAAS;AAC5C;AAcO,SAAS,YAAY,OAAO,KAAK,gBAAgB;AACpD,MAAI;AACJ,MAAI,OAAO,QAAQ,UAAU;AACzB,QAAI;AACA,YAAM,WAAW,GAAG;AAAA,IAChC,SACe,GAAG;AACN,YAAM,IAAI,MAAM,QAAQ,+CAA+C,CAAC;AAAA,IACpF;AAAA,EACA,WACa,QAAQ,GAAG,GAAG;AAGnB,UAAM,WAAW,KAAK,GAAG;AAAA,EACjC,OACS;AACD,UAAM,IAAI,MAAM,QAAQ,mCAAmC;AAAA,EACnE;AACI,QAAM,MAAM,IAAI;AAChB,MAAI,OAAO,mBAAmB,YAAY,QAAQ;AAC9C,UAAM,IAAI,MAAM,QAAQ,gBAAgB,iBAAiB,oBAAoB,GAAG;AACpF,SAAO;AACX;AAIO,SAASC,iBAAe,QAAQ;AACnC,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,UAAM,IAAI,OAAO,CAAC;AAClB,WAAO,CAAC;AACR,WAAO,EAAE;AAAA,EACjB;AACI,QAAM,MAAM,IAAI,WAAW,GAAG;AAC9B,WAAS,IAAI,GAAG,MAAM,GAAG,IAAI,OAAO,QAAQ,KAAK;AAC7C,UAAM,IAAI,OAAO,CAAC;AAClB,QAAI,IAAI,GAAG,GAAG;AACd,WAAO,EAAE;AAAA,EACjB;AACI,SAAO;AACX;AAaO,SAAS,YAAY,KAAK;AAC7B,MAAI,OAAO,QAAQ;AACf,UAAM,IAAI,MAAM,iBAAiB;AACrC,SAAO,IAAI,WAAW,IAAI,YAAa,EAAC,OAAO,GAAG,CAAC;AACvD;AAEA,MAAM,WAAW,CAACD,OAAM,OAAOA,OAAM,YAAYH,SAAOG;AACjD,SAAS,QAAQA,IAAG,KAAK,KAAK;AACjC,SAAO,SAASA,EAAC,KAAK,SAAS,GAAG,KAAK,SAAS,GAAG,KAAK,OAAOA,MAAKA,KAAI;AAC5E;AAMO,SAAS,SAAS,OAAOA,IAAG,KAAK,KAAK;AAMzC,MAAI,CAAC,QAAQA,IAAG,KAAK,GAAG;AACpB,UAAM,IAAI,MAAM,oBAAoB,QAAQ,OAAO,MAAM,aAAa,MAAM,WAAWA,EAAC;AAChG;AAMO,SAAS,OAAOA,IAAG;AACtB,MAAI;AACJ,OAAK,MAAM,GAAGA,KAAIH,OAAKG,OAAMF,OAAK,OAAO;AACrC;AACJ,SAAO;AACX;AAMO,SAAS,OAAOE,IAAG,KAAK;AAC3B,SAAQA,MAAK,OAAO,GAAG,IAAKF;AAChC;AAWO,MAAM,UAAU,CAACE,QAAOD,SAAO,OAAOC,KAAI,CAAC,KAAKF;AA+DvD,MAAM,eAAe;AAAA,EACjB,QAAQ,CAAC,QAAQ,OAAO,QAAQ;AAAA,EAChC,UAAU,CAAC,QAAQ,OAAO,QAAQ;AAAA,EAClC,SAAS,CAAC,QAAQ,OAAO,QAAQ;AAAA,EACjC,QAAQ,CAAC,QAAQ,OAAO,QAAQ;AAAA,EAChC,oBAAoB,CAAC,QAAQ,OAAO,QAAQ,YAAY,QAAQ,GAAG;AAAA,EACnE,eAAe,CAAC,QAAQ,OAAO,cAAc,GAAG;AAAA,EAChD,OAAO,CAAC,QAAQ,MAAM,QAAQ,GAAG;AAAA,EACjC,OAAO,CAAC,KAAK,WAAW,OAAO,GAAG,QAAQ,GAAG;AAAA,EAC7C,MAAM,CAAC,QAAQ,OAAO,QAAQ,cAAc,OAAO,cAAc,IAAI,SAAS;AAClF;AAEO,SAAS,eAAe,QAAQ,YAAY,gBAAgB,CAAA,GAAI;AACnE,QAAM,aAAa,CAAC,WAAW,MAAM,eAAe;AAChD,UAAM,WAAW,aAAa,IAAI;AAClC,QAAI,OAAO,aAAa;AACpB,YAAM,IAAI,MAAM,4BAA4B;AAChD,UAAM,MAAM,OAAO,SAAS;AAC5B,QAAI,cAAc,QAAQ;AACtB;AACJ,QAAI,CAAC,SAAS,KAAK,MAAM,GAAG;AACxB,YAAM,IAAI,MAAM,WAAW,OAAO,SAAS,IAAI,2BAA2B,OAAO,WAAW,GAAG;AAAA,IAC3G;AAAA,EACK;AACD,aAAW,CAAC,WAAW,IAAI,KAAK,OAAO,QAAQ,UAAU;AACrD,eAAW,WAAW,MAAM,KAAK;AACrC,aAAW,CAAC,WAAW,IAAI,KAAK,OAAO,QAAQ,aAAa;AACxD,eAAW,WAAW,MAAM,IAAI;AACpC,SAAO;AACX;AAYO,MAAM,iBAAiB,MAAM;AAChC,QAAM,IAAI,MAAM,iBAAiB;AACrC;AAKO,SAAS,SAAS,IAAI;AACzB,QAAM,MAAM,oBAAI,QAAS;AACzB,SAAO,CAAC,QAAQ,SAAS;AACrB,UAAM,MAAM,IAAI,IAAI,GAAG;AACvB,QAAI,QAAQ;AACR,aAAO;AACX,UAAM,WAAW,GAAG,KAAK,GAAG,IAAI;AAChC,QAAI,IAAI,KAAK,QAAQ;AACrB,WAAO;AAAA,EACV;AACL;ACvUA;AAGA,MAAMD,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGC,QAAsB,uBAAO,CAAC,GAAGG,QAAsB,uBAAO,CAAC;AAEvG,MAAMC,QAAsB,uBAAO,CAAC,GAAG,MAAsB,uBAAO,CAAC,GAAG,MAAsB,uBAAO,CAAC;AAI/F,SAAS,IAAI,GAAG,GAAG;AACtB,QAAM,SAAS,IAAI;AACnB,SAAO,UAAUN,QAAM,SAAS,IAAI;AACxC;AAQO,SAAS,IAAI,KAAK,OAAO,QAAQ;AACpC,MAAI,QAAQA;AACR,UAAM,IAAI,MAAM,yCAAyC;AAC7D,MAAI,UAAUA;AACV,UAAM,IAAI,MAAM,iBAAiB;AACrC,MAAI,WAAWC;AACX,WAAOD;AACX,MAAI,MAAMC;AACV,SAAO,QAAQD,OAAK;AAChB,QAAI,QAAQC;AACR,YAAO,MAAM,MAAO;AACxB,UAAO,MAAM,MAAO;AACpB,cAAUA;AAAAA,EAClB;AACI,SAAO;AACX;AAcO,SAAS,OAAO,QAAQ,QAAQ;AACnC,MAAI,WAAWD;AACX,UAAM,IAAI,MAAM,kCAAkC;AACtD,MAAI,UAAUA;AACV,UAAM,IAAI,MAAM,4CAA4C,MAAM;AAEtE,MAAI,IAAI,IAAI,QAAQ,MAAM;AAC1B,MAAI,IAAI;AAEL,MAAC,IAAIA,OAAcO,KAAIN;AAC1B,SAAO,MAAMD,OAAK;AAEd,UAAM,IAAI,IAAI;AACd,UAAM,IAAI,IAAI;AACd,UAAM,IAAI,IAAIO,KAAI;AAGlB,QAAI,GAAG,IAAI,GAAG,IAAIA,IAAUA,KAAI;AAAA,EACxC;AACI,QAAM,MAAM;AACZ,MAAI,QAAQN;AACR,UAAM,IAAI,MAAM,wBAAwB;AAC5C,SAAO,IAAI,GAAG,MAAM;AACxB;AASO,SAAS,cAAc,GAAG;AAM7B,QAAM,aAAa,IAAIA,SAAOC;AAC9B,MAAI,GAAG,GAAG;AAGV,OAAK,IAAI,IAAID,OAAK,IAAI,GAAG,IAAIC,UAAQF,OAAK,KAAKE,OAAK;AAChD;AAEJ,OAAK,IAAIA,OAAK,IAAI,KAAK,IAAI,GAAG,WAAW,CAAC,MAAM,IAAID,OAAK,KAAK;AAE1D,QAAI,IAAI;AACJ,YAAM,IAAI,MAAM,6CAA6C;AAAA,EACzE;AAEI,MAAI,MAAM,GAAG;AACT,UAAM,UAAU,IAAIA,SAAOK;AAC3B,WAAO,SAAS,YAAYE,KAAIL,IAAG;AAC/B,YAAM,OAAOK,IAAG,IAAIL,IAAG,MAAM;AAC7B,UAAI,CAACK,IAAG,IAAIA,IAAG,IAAI,IAAI,GAAGL,EAAC;AACvB,cAAM,IAAI,MAAM,yBAAyB;AAC7C,aAAO;AAAA,IACV;AAAA,EACT;AAEI,QAAM,UAAU,IAAIF,SAAOC;AAC3B,SAAO,SAAS,YAAYM,KAAIL,IAAG;AAE/B,QAAIK,IAAG,IAAIL,IAAG,SAAS,MAAMK,IAAG,IAAIA,IAAG,GAAG;AACtC,YAAM,IAAI,MAAM,yBAAyB;AAC7C,QAAI,IAAI;AAER,QAAI,IAAIA,IAAG,IAAIA,IAAG,IAAIA,IAAG,KAAK,CAAC,GAAG,CAAC;AACnC,QAAI,IAAIA,IAAG,IAAIL,IAAG,MAAM;AACxB,QAAI,IAAIK,IAAG,IAAIL,IAAG,CAAC;AACnB,WAAO,CAACK,IAAG,IAAI,GAAGA,IAAG,GAAG,GAAG;AACvB,UAAIA,IAAG,IAAI,GAAGA,IAAG,IAAI;AACjB,eAAOA,IAAG;AAEd,UAAI,IAAI;AACR,eAAS,KAAKA,IAAG,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK;AACjC,YAAIA,IAAG,IAAI,IAAIA,IAAG,GAAG;AACjB;AACJ,aAAKA,IAAG,IAAI,EAAE;AAAA,MAC9B;AAEY,YAAM,KAAKA,IAAG,IAAI,GAAGP,SAAO,OAAO,IAAI,IAAI,CAAC,CAAC;AAC7C,UAAIO,IAAG,IAAI,EAAE;AACb,UAAIA,IAAG,IAAI,GAAG,EAAE;AAChB,UAAIA,IAAG,IAAI,GAAG,CAAC;AACf,UAAI;AAAA,IAChB;AACQ,WAAO;AAAA,EACV;AACL;AAYO,SAAS,OAAO,GAAG;AAGtB,MAAI,IAAIF,UAAQD,OAAK;AAKjB,UAAM,UAAU,IAAIJ,SAAOK;AAC3B,WAAO,SAAS,UAAUE,KAAIL,IAAG;AAC7B,YAAM,OAAOK,IAAG,IAAIL,IAAG,MAAM;AAE7B,UAAI,CAACK,IAAG,IAAIA,IAAG,IAAI,IAAI,GAAGL,EAAC;AACvB,cAAM,IAAI,MAAM,yBAAyB;AAC7C,aAAO;AAAA,IACV;AAAA,EACT;AAEI,MAAI,IAAI,QAAQ,KAAK;AACjB,UAAM,MAAM,IAAI,OAAO;AACvB,WAAO,SAAS,UAAUK,KAAIL,IAAG;AAC7B,YAAMM,MAAKD,IAAG,IAAIL,IAAGD,KAAG;AACxB,YAAM,IAAIM,IAAG,IAAIC,KAAI,EAAE;AACvB,YAAM,KAAKD,IAAG,IAAIL,IAAG,CAAC;AACtB,YAAM,IAAIK,IAAG,IAAIA,IAAG,IAAI,IAAIN,KAAG,GAAG,CAAC;AACnC,YAAM,OAAOM,IAAG,IAAI,IAAIA,IAAG,IAAI,GAAGA,IAAG,GAAG,CAAC;AACzC,UAAI,CAACA,IAAG,IAAIA,IAAG,IAAI,IAAI,GAAGL,EAAC;AACvB,cAAM,IAAI,MAAM,yBAAyB;AAC7C,aAAO;AAAA,IACV;AAAA,EACT;AAwBI,SAAO,cAAc,CAAC;AAC1B;AAIA,MAAM,eAAe;AAAA,EACjB;AAAA,EAAU;AAAA,EAAW;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAQ;AAAA,EAClD;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EAAO;AAAA,EACnC;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAC5B;AACO,SAAS,cAAc,OAAO;AACjC,QAAM,UAAU;AAAA,IACZ,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO;AAAA,IACP,MAAM;AAAA,EACT;AACD,QAAM,OAAO,aAAa,OAAO,CAAC,KAAK,QAAQ;AAC3C,QAAI,GAAG,IAAI;AACX,WAAO;AAAA,EACV,GAAE,OAAO;AACV,SAAO,eAAe,OAAO,IAAI;AACrC;AAMO,SAAS,MAAM,GAAG,KAAK,OAAO;AAGjC,MAAI,QAAQH;AACR,UAAM,IAAI,MAAM,yCAAyC;AAC7D,MAAI,UAAUA;AACV,WAAO,EAAE;AACb,MAAI,UAAUC;AACV,WAAO;AACX,MAAIjB,KAAI,EAAE;AACV,MAAI,IAAI;AACR,SAAO,QAAQgB,OAAK;AAChB,QAAI,QAAQC;AACR,MAAAjB,KAAI,EAAE,IAAIA,IAAG,CAAC;AAClB,QAAI,EAAE,IAAI,CAAC;AACX,cAAUiB;AAAAA,EAClB;AACI,SAAOjB;AACX;AAKO,SAAS,cAAc,GAAG,MAAM;AACnC,QAAM,MAAM,IAAI,MAAM,KAAK,MAAM;AAEjC,QAAM,iBAAiB,KAAK,OAAO,CAAC,KAAK,KAAK,MAAM;AAChD,QAAI,EAAE,IAAI,GAAG;AACT,aAAO;AACX,QAAI,CAAC,IAAI;AACT,WAAO,EAAE,IAAI,KAAK,GAAG;AAAA,EAC7B,GAAO,EAAE,GAAG;AAER,QAAM,WAAW,EAAE,IAAI,cAAc;AAErC,OAAK,YAAY,CAAC,KAAK,KAAK,MAAM;AAC9B,QAAI,EAAE,IAAI,GAAG;AACT,aAAO;AACX,QAAI,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,CAAC;AAC1B,WAAO,EAAE,IAAI,KAAK,GAAG;AAAA,EACxB,GAAE,QAAQ;AACX,SAAO;AACX;AAUO,SAAS,WAAW,OAAO;AAC9B,QAAM,iBAAiB,QAAQiB,SAAOC;AACtC,SAAO,CAAC,GAAG,MAAM,EAAE,IAAI,GAAG,aAAa;AAC3C;AAUO,SAAS,QAAQC,IAAG,YAAY;AAEnC,QAAM,cAAc,eAAe,SAAY,aAAaA,GAAE,SAAS,CAAC,EAAE;AAC1E,QAAM,cAAc,KAAK,KAAK,cAAc,CAAC;AAC7C,SAAO,EAAE,YAAY,aAAa,YAAa;AACnD;AAgBO,SAAS,MAAM,OAAOO,SAAQ,OAAO,OAAO,QAAQ,IAAI;AAC3D,MAAI,SAASV;AACT,UAAM,IAAI,MAAM,4CAA4C,KAAK;AACrE,QAAM,EAAE,YAAY,MAAM,aAAa,MAAK,IAAK,QAAQ,OAAOU,OAAM;AACtE,MAAI,QAAQ;AACR,UAAM,IAAI,MAAM,gDAAgD;AACpE,MAAI;AACJ,QAAM,IAAI,OAAO,OAAO;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,QAAQ,IAAI;AAAA,IAClB,MAAMV;AAAAA,IACN,KAAKC;AAAAA,IACL,QAAQ,CAAC,QAAQ,IAAI,KAAK,KAAK;AAAA,IAC/B,SAAS,CAAC,QAAQ;AACd,UAAI,OAAO,QAAQ;AACf,cAAM,IAAI,MAAM,iDAAiD,OAAO,GAAG;AAC/E,aAAOD,SAAO,OAAO,MAAM;AAAA,IAC9B;AAAA,IACD,KAAK,CAAC,QAAQ,QAAQA;AAAAA,IACtB,OAAO,CAAC,SAAS,MAAMC,WAASA;AAAAA,IAChC,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,KAAK;AAAA,IAC7B,KAAK,CAAC,KAAK,QAAQ,QAAQ;AAAA,IAC3B,KAAK,CAAC,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IAClC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IACvC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IACvC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK;AAAA,IACvC,KAAK,CAAC,KAAK,UAAU,MAAM,GAAG,KAAK,KAAK;AAAA,IACxC,KAAK,CAAC,KAAK,QAAQ,IAAI,MAAM,OAAO,KAAK,KAAK,GAAG,KAAK;AAAA;AAAA,IAEtD,MAAM,CAAC,QAAQ,MAAM;AAAA,IACrB,MAAM,CAAC,KAAK,QAAQ,MAAM;AAAA,IAC1B,MAAM,CAAC,KAAK,QAAQ,MAAM;AAAA,IAC1B,MAAM,CAAC,KAAK,QAAQ,MAAM;AAAA,IAC1B,KAAK,CAAC,QAAQ,OAAO,KAAK,KAAK;AAAA,IAC/B,MAAM,MAAM,SACP,CAACE,OAAM;AACJ,UAAI,CAAC;AACD,gBAAQ,OAAO,KAAK;AACxB,aAAO,MAAM,GAAGA,EAAC;AAAA,IACjC;AAAA,IACQ,aAAa,CAAC,QAAQ,cAAc,GAAG,GAAG;AAAA;AAAA;AAAA,IAG1C,MAAM,CAAC,GAAG,GAAG,MAAO,IAAI,IAAI;AAAA,IAC5B,SAAS,CAAC,QAAS,OAAO,gBAAgB,KAAK,KAAK,IAAI,gBAAgB,KAAK,KAAK;AAAA,IAClF,WAAW,CAAC,UAAU;AAClB,UAAI,MAAM,WAAW;AACjB,cAAM,IAAI,MAAM,+BAA+B,QAAQ,iBAAiB,MAAM,MAAM;AACxF,aAAO,OAAO,gBAAgB,KAAK,IAAI,gBAAgB,KAAK;AAAA,IAC/D;AAAA,EACT,CAAK;AACD,SAAO,OAAO,OAAO,CAAC;AAC1B;AAkCO,SAAS,oBAAoB,YAAY;AAC5C,MAAI,OAAO,eAAe;AACtB,UAAM,IAAI,MAAM,4BAA4B;AAChD,QAAM,YAAY,WAAW,SAAS,CAAC,EAAE;AACzC,SAAO,KAAK,KAAK,YAAY,CAAC;AAClC;AAQO,SAAS,iBAAiB,YAAY;AACzC,QAAM,SAAS,oBAAoB,UAAU;AAC7C,SAAO,SAAS,KAAK,KAAK,SAAS,CAAC;AACxC;AAcO,SAAS,eAAe,KAAK,YAAY,OAAO,OAAO;AAC1D,QAAM,MAAM,IAAI;AAChB,QAAM,WAAW,oBAAoB,UAAU;AAC/C,QAAM,SAAS,iBAAiB,UAAU;AAE1C,MAAI,MAAM,MAAM,MAAM,UAAU,MAAM;AAClC,UAAM,IAAI,MAAM,cAAc,SAAS,+BAA+B,GAAG;AAC7E,QAAM,MAAM,OAAO,gBAAgB,GAAG,IAAI,gBAAgB,GAAG;AAE7D,QAAM,UAAU,IAAI,KAAK,aAAaF,KAAG,IAAIA;AAC7C,SAAO,OAAO,gBAAgB,SAAS,QAAQ,IAAI,gBAAgB,SAAS,QAAQ;AACxF;ACpcA,MAAM,QAAQ;AAEd,SAAS,MAAM,OAAO,QAAQ;AAC1B,OAAK,KAAK;AACV,OAAK,MAAM;AACX,MAAI,QAAQ,KAAK,SAAS,KAAM,IAAI;AAChC,UAAM,IAAI,MAAM,0BAA0B,KAAK;AACnD,QAAM,MAAM,MAAM,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC;AACzC,WAAS,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AAClC,QAAI,CAAC,IAAI,QAAQ;AACjB,eAAW;AAAA,EACnB;AACI,SAAO,IAAI,WAAW,GAAG;AAC7B;AACA,SAAS,OAAO,GAAG,GAAG;AAClB,QAAM,MAAM,IAAI,WAAW,EAAE,MAAM;AACnC,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AAC/B,QAAI,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;AAAA,EAC3B;AACI,SAAO;AACX;AACA,SAAS,KAAK,MAAM;AAChB,MAAI,CAAC,OAAO,cAAc,IAAI;AAC1B,UAAM,IAAI,MAAM,iBAAiB;AACzC;AAKO,SAAS,mBAAmB,KAAK,KAAK,YAAY,GAAG;AACxD,SAAO,GAAG;AACV,SAAO,GAAG;AACV,OAAK,UAAU;AAEf,MAAI,IAAI,SAAS;AACb,UAAM,EAAEG,cAAY,YAAY,mBAAmB,GAAG,GAAG,CAAC;AAC9D,QAAM,EAAE,WAAW,YAAY,UAAU,WAAY,IAAG;AACxD,QAAM,MAAM,KAAK,KAAK,aAAa,UAAU;AAC7C,MAAI,aAAa,SAAS,MAAM;AAC5B,UAAM,IAAI,MAAM,wCAAwC;AAC5D,QAAM,YAAYA,cAAY,KAAK,MAAM,IAAI,QAAQ,CAAC,CAAC;AACvD,QAAM,QAAQ,MAAM,GAAG,UAAU;AACjC,QAAM,YAAY,MAAM,YAAY,CAAC;AACrC,QAAM,IAAI,IAAI,MAAM,GAAG;AACvB,QAAM,MAAM,EAAEA,cAAY,OAAO,KAAK,WAAW,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;AACxE,IAAE,CAAC,IAAI,EAAEA,cAAY,KAAK,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;AACjD,WAAS,IAAI,GAAG,KAAK,KAAK,KAAK;AAC3B,UAAM,OAAO,CAAC,OAAO,KAAK,EAAE,IAAI,CAAC,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,GAAG,SAAS;AAC/D,MAAE,CAAC,IAAI,EAAEA,cAAY,GAAG,IAAI,CAAC;AAAA,EACrC;AACI,QAAM,sBAAsBA,cAAY,GAAG,CAAC;AAC5C,SAAO,oBAAoB,MAAM,GAAG,UAAU;AAClD;AAQO,SAAS,mBAAmB,KAAK,KAAK,YAAY,GAAG,GAAG;AAC3D,SAAO,GAAG;AACV,SAAO,GAAG;AACV,OAAK,UAAU;AAGf,MAAI,IAAI,SAAS,KAAK;AAClB,UAAM,QAAQ,KAAK,KAAM,IAAI,IAAK,CAAC;AACnC,UAAM,EAAE,OAAO,EAAE,MAAO,CAAA,EAAE,OAAO,YAAY,mBAAmB,CAAC,EAAE,OAAO,GAAG,EAAE,OAAQ;AAAA,EAC/F;AACI,MAAI,aAAa,SAAS,IAAI,SAAS;AACnC,UAAM,IAAI,MAAM,wCAAwC;AAC5D,SAAQ,EAAE,OAAO,EAAE,OAAO,WAAY,CAAA,EACjC,OAAO,GAAG,EACV,OAAO,MAAM,YAAY,CAAC,CAAC,EAE3B,OAAO,GAAG,EACV,OAAO,MAAM,IAAI,QAAQ,CAAC,CAAC,EAC3B,OAAQ;AACjB;AASO,SAAS,cAAc,KAAK,OAAO,SAAS;AAC/C,iBAAe,SAAS;AAAA,IACpB,KAAK;AAAA,IACL,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,MAAM;AAAA,EACd,CAAK;AACD,QAAM,EAAE,GAAApB,IAAG,GAAG,GAAG,MAAAW,OAAM,QAAQ,KAAK,KAAI,IAAK;AAC7C,SAAO,GAAG;AACV,OAAK,KAAK;AACV,QAAM,MAAM,OAAO,SAAS,WAAW,YAAY,IAAI,IAAI;AAC3D,QAAM,QAAQX,GAAE,SAAS,CAAC,EAAE;AAC5B,QAAM,IAAI,KAAK,MAAM,QAAQ,KAAK,CAAC;AACnC,QAAM,eAAe,QAAQ,IAAI;AACjC,MAAI;AACJ,MAAI,WAAW,OAAO;AAClB,UAAM,mBAAmB,KAAK,KAAK,cAAcW,KAAI;AAAA,EAC7D,WACa,WAAW,OAAO;AACvB,UAAM,mBAAmB,KAAK,KAAK,cAAc,GAAGA,KAAI;AAAA,EAChE,WACa,WAAW,kBAAkB;AAElC,UAAM;AAAA,EACd,OACS;AACD,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACvD;AACI,QAAMY,KAAI,IAAI,MAAM,KAAK;AACzB,WAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC5B,UAAM,IAAI,IAAI,MAAM,CAAC;AACrB,aAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,YAAM,aAAa,KAAK,IAAI,IAAI;AAChC,YAAM,KAAK,IAAI,SAAS,YAAY,aAAa,CAAC;AAClD,QAAE,CAAC,IAAI,IAAI,MAAM,EAAE,GAAGvB,EAAC;AAAA,IACnC;AACQ,IAAAuB,GAAE,CAAC,IAAI;AAAA,EACf;AACI,SAAOA;AACX;AACO,SAAS,WAAW,OAAO,KAAK;AAEnC,QAAM,QAAQ,IAAI,IAAI,CAAC,MAAM,MAAM,KAAK,CAAC,EAAE,SAAS;AACpD,SAAO,CAAC,GAAGlB,OAAM;AACb,UAAM,CAAC,MAAM,MAAM,MAAM,IAAI,IAAI,MAAM,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,KAAK,MAAM,MAAM,IAAI,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAC3G,QAAI,MAAM,IAAI,MAAM,IAAI;AACxB,IAAAA,KAAI,MAAM,IAAIA,IAAG,MAAM,IAAI,MAAM,IAAI,CAAC;AACtC,WAAO,EAAE,GAAM,GAAGA,GAAG;AAAA,EACxB;AACL;AAEO,SAAS,aAAa,OAAO,YAAY,KAAK;AACjD,MAAI,OAAO,eAAe;AACtB,UAAM,IAAI,MAAM,8BAA8B;AAClD,SAAO;AAAA;AAAA;AAAA,IAGH,YAAY,KAAK,SAAS;AACtB,YAAMkB,KAAI,cAAc,KAAK,GAAG,EAAE,GAAG,KAAK,KAAK,IAAI,KAAK,GAAG,QAAO,CAAE;AACpE,YAAM,KAAK,MAAM,WAAW,WAAWA,GAAE,CAAC,CAAC,CAAC;AAC5C,YAAM,KAAK,MAAM,WAAW,WAAWA,GAAE,CAAC,CAAC,CAAC;AAC5C,YAAM,IAAI,GAAG,IAAI,EAAE,EAAE,cAAe;AACpC,QAAE,eAAgB;AAClB,aAAO;AAAA,IACV;AAAA;AAAA;AAAA,IAGD,cAAc,KAAK,SAAS;AACxB,YAAMA,KAAI,cAAc,KAAK,GAAG,EAAE,GAAG,KAAK,KAAK,IAAI,WAAW,GAAG,QAAO,CAAE;AAC1E,YAAM,IAAI,MAAM,WAAW,WAAWA,GAAE,CAAC,CAAC,CAAC,EAAE,cAAe;AAC5D,QAAE,eAAgB;AAClB,aAAO;AAAA,IACV;AAAA;AAAA,IAED,WAAW,SAAS;AAChB,UAAI,CAAC,MAAM,QAAQ,OAAO;AACtB,cAAM,IAAI,MAAM,uCAAuC;AAC3D,iBAAW,KAAK;AACZ,YAAI,OAAO,MAAM;AACb,gBAAM,IAAI,MAAM,uCAAuC;AAC/D,YAAM,IAAI,MAAM,WAAW,WAAW,OAAO,CAAC,EAAE,cAAe;AAC/D,QAAE,eAAgB;AAClB,aAAO;AAAA,IACV;AAAA,EACJ;AACL;AC5KA;AAGA,MAAMP,QAAM,OAAO,CAAC;AACpB,MAAMC,QAAM,OAAO,CAAC;AACpB,SAAS,gBAAgB,WAAW,MAAM;AACtC,QAAM,MAAM,KAAK,OAAQ;AACzB,SAAO,YAAY,MAAM;AAC7B;AACA,SAAS,UAAU,GAAG,MAAM;AACxB,MAAI,CAAC,OAAO,cAAc,CAAC,KAAK,KAAK,KAAK,IAAI;AAC1C,UAAM,IAAI,MAAM,uCAAuC,OAAO,cAAc,CAAC;AACrF;AACA,SAAS,UAAU,GAAG,MAAM;AACxB,YAAU,GAAG,IAAI;AACjB,QAAM,UAAU,KAAK,KAAK,OAAO,CAAC,IAAI;AACtC,QAAM,aAAa,MAAM,IAAI;AAC7B,SAAO,EAAE,SAAS,WAAY;AAClC;AACA,SAAS,kBAAkB,QAAQ,GAAG;AAClC,MAAI,CAAC,MAAM,QAAQ,MAAM;AACrB,UAAM,IAAI,MAAM,gBAAgB;AACpC,SAAO,QAAQ,CAACjB,IAAG,MAAM;AACrB,QAAI,EAAEA,cAAa;AACf,YAAM,IAAI,MAAM,4BAA4B,CAAC;AAAA,EACzD,CAAK;AACL;AACA,SAAS,mBAAmB,SAAS,OAAO;AACxC,MAAI,CAAC,MAAM,QAAQ,OAAO;AACtB,UAAM,IAAI,MAAM,2BAA2B;AAC/C,UAAQ,QAAQ,CAACI,IAAG,MAAM;AACtB,QAAI,CAAC,MAAM,QAAQA,EAAC;AAChB,YAAM,IAAI,MAAM,6BAA6B,CAAC;AAAA,EAC1D,CAAK;AACL;AAGA,MAAM,mBAAmB,oBAAI,QAAS;AACtC,MAAM,mBAAmB,oBAAI;AAC7B,SAAS,KAAK,GAAG;AACb,SAAO,iBAAiB,IAAI,CAAC,KAAK;AACtC;AAeO,SAAS,KAAK,GAAG,MAAM;AAC1B,SAAO;AAAA,IACH;AAAA,IACA,eAAe,KAAK;AAChB,aAAO,KAAK,GAAG,MAAM;AAAA,IACxB;AAAA;AAAA,IAED,aAAa,KAAKe,IAAGnB,KAAI,EAAE,MAAM;AAC7B,UAAI,IAAI;AACR,aAAOmB,KAAIH,OAAK;AACZ,YAAIG,KAAIF;AACJ,UAAAjB,KAAIA,GAAE,IAAI,CAAC;AACf,YAAI,EAAE,OAAQ;AACd,QAAAmB,OAAMF;AAAAA,MACtB;AACY,aAAOjB;AAAA,IACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAaD,iBAAiB,KAAK,GAAG;AACrB,YAAM,EAAE,SAAS,WAAU,IAAK,UAAU,GAAG,IAAI;AACjD,YAAM,SAAS,CAAE;AACjB,UAAIA,KAAI;AACR,UAAI,OAAOA;AACX,eAAS,SAAS,GAAG,SAAS,SAAS,UAAU;AAC7C,eAAOA;AACP,eAAO,KAAK,IAAI;AAEhB,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACjC,iBAAO,KAAK,IAAIA,EAAC;AACjB,iBAAO,KAAK,IAAI;AAAA,QACpC;AACgB,QAAAA,KAAI,KAAK,OAAQ;AAAA,MACjC;AACY,aAAO;AAAA,IACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQD,KAAK,GAAG,aAAamB,IAAG;AAGpB,YAAM,EAAE,SAAS,WAAU,IAAK,UAAU,GAAG,IAAI;AACjD,UAAInB,KAAI,EAAE;AACV,UAAI,IAAI,EAAE;AACV,YAAM,OAAO,OAAO,KAAK,IAAI,CAAC;AAC9B,YAAM,YAAY,KAAK;AACvB,YAAM,UAAU,OAAO,CAAC;AACxB,eAAS,SAAS,GAAG,SAAS,SAAS,UAAU;AAC7C,cAAM,SAAS,SAAS;AAExB,YAAI,QAAQ,OAAOmB,KAAI,IAAI;AAE3B,QAAAA,OAAM;AAGN,YAAI,QAAQ,YAAY;AACpB,mBAAS;AACT,UAAAA,MAAKF;AAAAA,QACzB;AAQgB,cAAM,UAAU;AAChB,cAAM,UAAU,SAAS,KAAK,IAAI,KAAK,IAAI;AAC3C,cAAM,QAAQ,SAAS,MAAM;AAC7B,cAAM,QAAQ,QAAQ;AACtB,YAAI,UAAU,GAAG;AAEb,cAAI,EAAE,IAAI,gBAAgB,OAAO,YAAY,OAAO,CAAC,CAAC;AAAA,QAC1E,OACqB;AACD,UAAAjB,KAAIA,GAAE,IAAI,gBAAgB,OAAO,YAAY,OAAO,CAAC,CAAC;AAAA,QAC1E;AAAA,MACA;AAMY,aAAO,EAAE,GAAAA,IAAG,EAAG;AAAA,IAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASD,WAAW,GAAG,aAAamB,IAAG,MAAM,EAAE,MAAM;AACxC,YAAM,EAAE,SAAS,WAAU,IAAK,UAAU,GAAG,IAAI;AACjD,YAAM,OAAO,OAAO,KAAK,IAAI,CAAC;AAC9B,YAAM,YAAY,KAAK;AACvB,YAAM,UAAU,OAAO,CAAC;AACxB,eAAS,SAAS,GAAG,SAAS,SAAS,UAAU;AAC7C,cAAM,SAAS,SAAS;AACxB,YAAIA,OAAMH;AACN;AAEJ,YAAI,QAAQ,OAAOG,KAAI,IAAI;AAE3B,QAAAA,OAAM;AAGN,YAAI,QAAQ,YAAY;AACpB,mBAAS;AACT,UAAAA,MAAKF;AAAAA,QACzB;AACgB,YAAI,UAAU;AACV;AACJ,YAAI,OAAO,YAAY,SAAS,KAAK,IAAI,KAAK,IAAI,CAAC;AACnD,YAAI,QAAQ;AACR,iBAAO,KAAK,OAAQ;AAExB,cAAM,IAAI,IAAI,IAAI;AAAA,MAClC;AACY,aAAO;AAAA,IACV;AAAA,IACD,eAAe,GAAG,GAAG,WAAW;AAE5B,UAAI,OAAO,iBAAiB,IAAI,CAAC;AACjC,UAAI,CAAC,MAAM;AACP,eAAO,KAAK,iBAAiB,GAAG,CAAC;AACjC,YAAI,MAAM;AACN,2BAAiB,IAAI,GAAG,UAAU,IAAI,CAAC;AAAA,MAC3D;AACY,aAAO;AAAA,IACV;AAAA,IACD,WAAW,GAAGE,IAAG,WAAW;AACxB,YAAM,IAAI,KAAK,CAAC;AAChB,aAAO,KAAK,KAAK,GAAG,KAAK,eAAe,GAAG,GAAG,SAAS,GAAGA,EAAC;AAAA,IAC9D;AAAA,IACD,iBAAiB,GAAGA,IAAG,WAAW,MAAM;AACpC,YAAM,IAAI,KAAK,CAAC;AAChB,UAAI,MAAM;AACN,eAAO,KAAK,aAAa,GAAGA,IAAG,IAAI;AACvC,aAAO,KAAK,WAAW,GAAG,KAAK,eAAe,GAAG,GAAG,SAAS,GAAGA,IAAG,IAAI;AAAA,IAC1E;AAAA;AAAA;AAAA;AAAA,IAID,cAAc,GAAG,GAAG;AAChB,gBAAU,GAAG,IAAI;AACjB,uBAAiB,IAAI,GAAG,CAAC;AACzB,uBAAiB,OAAO,CAAC;AAAA,IAC5B;AAAA,EACJ;AACL;AAWO,SAAS,UAAU,GAAG,QAAQ,QAAQ,SAAS;AAOlD,oBAAkB,QAAQ,CAAC;AAC3B,qBAAmB,SAAS,MAAM;AAClC,MAAI,OAAO,WAAW,QAAQ;AAC1B,UAAM,IAAI,MAAM,qDAAqD;AACzE,QAAM,OAAO,EAAE;AACf,QAAM,QAAQ,OAAO,OAAO,OAAO,MAAM,CAAC;AAC1C,QAAM,aAAa,QAAQ,KAAK,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI;AAChF,QAAM,QAAQ,KAAK,cAAc;AACjC,QAAM,UAAU,IAAI,MAAM,OAAO,CAAC,EAAE,KAAK,IAAI;AAC7C,QAAM,WAAW,KAAK,OAAO,OAAO,OAAO,KAAK,UAAU,IAAI;AAC9D,MAAI,MAAM;AACV,WAAS,IAAI,UAAU,KAAK,GAAG,KAAK,YAAY;AAC5C,YAAQ,KAAK,IAAI;AACjB,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,YAAM,SAAS,QAAQ,CAAC;AACxB,YAAMQ,SAAQ,OAAQ,UAAU,OAAO,CAAC,IAAK,OAAO,IAAI,CAAC;AACzD,cAAQA,MAAK,IAAI,QAAQA,MAAK,EAAE,IAAI,OAAO,CAAC,CAAC;AAAA,IACzD;AACQ,QAAI,OAAO;AAEX,aAAS,IAAI,QAAQ,SAAS,GAAG,OAAO,MAAM,IAAI,GAAG,KAAK;AACtD,aAAO,KAAK,IAAI,QAAQ,CAAC,CAAC;AAC1B,aAAO,KAAK,IAAI,IAAI;AAAA,IAChC;AACQ,UAAM,IAAI,IAAI,IAAI;AAClB,QAAI,MAAM;AACN,eAAS,IAAI,GAAG,IAAI,YAAY;AAC5B,cAAM,IAAI,OAAQ;AAAA,EAClC;AACI,SAAO;AACX;AAgFO,SAAS,cAAc,OAAO;AACjC,gBAAc,MAAM,EAAE;AACtB,iBAAe,OAAO;AAAA,IAClB,GAAG;AAAA,IACH,GAAG;AAAA,IACH,IAAI;AAAA,IACJ,IAAI;AAAA,EACZ,GAAO;AAAA,IACC,YAAY;AAAA,IACZ,aAAa;AAAA,EACrB,CAAK;AAED,SAAO,OAAO,OAAO;AAAA,IACjB,GAAG,QAAQ,MAAM,GAAG,MAAM,UAAU;AAAA,IACpC,GAAG;AAAA,IACH,GAAG,EAAE,GAAG,MAAM,GAAG,MAAO;AAAA,EAChC,CAAK;AACL;AC1VA;AAWA,SAAS,kBAAkB,OAAO;AAC9B,QAAM,OAAO,cAAc,KAAK;AAChCC,iBAAkB,MAAM;AAAA,IACpB,GAAG;AAAA,IACH,GAAG;AAAA,EACX,GAAO;AAAA,IACC,0BAA0B;AAAA,IAC1B,gBAAgB;AAAA,IAChB,eAAe;AAAA,IACf,eAAe;AAAA,IACf,oBAAoB;AAAA,IACpB,WAAW;AAAA,IACX,SAAS;AAAA,EACjB,CAAK;AACD,QAAM,EAAE,MAAM,IAAAJ,KAAI,EAAG,IAAG;AACxB,MAAI,MAAM;AACN,QAAI,CAACA,IAAG,IAAI,GAAGA,IAAG,IAAI,GAAG;AACrB,YAAM,IAAI,MAAM,4EAA4E;AAAA,IACxG;AACQ,QAAI,OAAO,SAAS,YAChB,OAAO,KAAK,SAAS,YACrB,OAAO,KAAK,gBAAgB,YAAY;AACxC,YAAM,IAAI,MAAM,uEAAuE;AAAA,IACnG;AAAA,EACA;AACI,SAAO,OAAO,OAAO,EAAE,GAAG,KAAI,CAAE;AACpC;AAyHA,MAAMR,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGG,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC;AACjF,SAAS,kBAAkB,MAAM;AACpC,QAAM,QAAQ,kBAAkB,IAAI;AACpC,QAAM,EAAE,IAAAE,IAAI,IAAG;AACf,QAAM,KAAK,MAAM,MAAM,GAAG,MAAM,UAAU;AAC1C,QAAMZ,WAAU,MAAM,YACjB,CAAC,IAAI,OAAO,kBAAkB;AAC3B,UAAM,IAAI,MAAM,SAAU;AAC1B,WAAOiB,cAAe,WAAW,KAAK,CAAC,CAAI,CAAC,GAAGL,IAAG,QAAQ,EAAE,CAAC,GAAGA,IAAG,QAAQ,EAAE,CAAC,CAAC;AAAA,EAC3F;AACI,QAAM,YAAY,MAAM,cACnB,CAAC,UAAU;AAER,UAAM,OAAO,MAAM,SAAS,CAAC;AAE7B,UAAM,IAAIA,IAAG,UAAU,KAAK,SAAS,GAAGA,IAAG,KAAK,CAAC;AACjD,UAAMnB,KAAImB,IAAG,UAAU,KAAK,SAASA,IAAG,OAAO,IAAIA,IAAG,KAAK,CAAC;AAC5D,WAAO,EAAE,GAAG,GAAAnB,GAAG;AAAA,EAC3B;AAKI,WAAS,oBAAoB,GAAG;AAC5B,UAAM,EAAE,GAAG,EAAC,IAAK;AACjB,UAAM,KAAKmB,IAAG,IAAI,CAAC;AACnB,UAAM,KAAKA,IAAG,IAAI,IAAI,CAAC;AACvB,WAAOA,IAAG,IAAIA,IAAG,IAAI,IAAIA,IAAG,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC;AAAA,EACjD;AAKI,MAAI,CAACA,IAAG,IAAIA,IAAG,IAAI,MAAM,EAAE,GAAG,oBAAoB,MAAM,EAAE,CAAC;AACvD,UAAM,IAAI,MAAM,6CAA6C;AAEjE,WAAS,mBAAmB,KAAK;AAC7B,WAAOM,QAAW,KAAKb,OAAK,MAAM,CAAC;AAAA,EAC3C;AAGI,WAAS,uBAAuB,KAAK;AACjC,UAAM,EAAE,0BAA0B,SAAS,aAAa,gBAAgB,GAAG,EAAC,IAAK;AACjF,QAAI,WAAW,OAAO,QAAQ,UAAU;AACpC,UAAIc,QAAW,GAAG;AACd,cAAMC,WAAc,GAAG;AAE3B,UAAI,OAAO,QAAQ,YAAY,CAAC,QAAQ,SAAS,IAAI,MAAM;AACvD,cAAM,IAAI,MAAM,qBAAqB;AACzC,YAAM,IAAI,SAAS,cAAc,GAAG,GAAG;AAAA,IACnD;AACQ,QAAI;AACJ,QAAI;AACA,YACI,OAAO,QAAQ,WACT,MACAC,gBAAmB,YAAY,eAAe,KAAK,WAAW,CAAC;AAAA,IACrF,SACe,OAAO;AACV,YAAM,IAAI,MAAM,0CAA0C,cAAc,iBAAiB,OAAO,GAAG;AAAA,IAC/G;AACQ,QAAI;AACA,YAAM,IAAI,KAAK,CAAC;AACpBC,aAAY,eAAe,KAAKjB,OAAK,CAAC;AACtC,WAAO;AAAA,EACf;AACI,WAAS,eAAe,OAAO;AAC3B,QAAI,EAAE,iBAAiB;AACnB,YAAM,IAAI,MAAM,0BAA0B;AAAA,EACtD;AAKI,QAAM,eAAe,SAAS,CAACjB,IAAG,OAAO;AACrC,UAAM,EAAE,IAAI,GAAG,IAAIK,IAAG,IAAI,EAAC,IAAKL;AAEhC,QAAIwB,IAAG,IAAI,GAAGA,IAAG,GAAG;AAChB,aAAO,EAAE,GAAG,GAAAnB,GAAG;AACnB,UAAM,MAAML,GAAE,IAAK;AAGnB,QAAI,MAAM;AACN,WAAK,MAAMwB,IAAG,MAAMA,IAAG,IAAI,CAAC;AAChC,UAAM,KAAKA,IAAG,IAAI,GAAG,EAAE;AACvB,UAAM,KAAKA,IAAG,IAAInB,IAAG,EAAE;AACvB,UAAM,KAAKmB,IAAG,IAAI,GAAG,EAAE;AACvB,QAAI;AACA,aAAO,EAAE,GAAGA,IAAG,MAAM,GAAGA,IAAG,KAAM;AACrC,QAAI,CAACA,IAAG,IAAI,IAAIA,IAAG,GAAG;AAClB,YAAM,IAAI,MAAM,kBAAkB;AACtC,WAAO,EAAE,GAAG,IAAI,GAAG,GAAI;AAAA,EAC/B,CAAK;AAGD,QAAM,kBAAkB,SAAS,CAACxB,OAAM;AACpC,QAAIA,GAAE,OAAO;AAIT,UAAI,MAAM,sBAAsB,CAACwB,IAAG,IAAIxB,GAAE,EAAE;AACxC;AACJ,YAAM,IAAI,MAAM,iBAAiB;AAAA,IAC7C;AAEQ,UAAM,EAAE,GAAG,GAAAK,OAAML,GAAE,SAAU;AAE7B,QAAI,CAACwB,IAAG,QAAQ,CAAC,KAAK,CAACA,IAAG,QAAQnB,EAAC;AAC/B,YAAM,IAAI,MAAM,0BAA0B;AAC9C,UAAM,OAAOmB,IAAG,IAAInB,EAAC;AACrB,UAAM,QAAQ,oBAAoB,CAAC;AACnC,QAAI,CAACmB,IAAG,IAAI,MAAM,KAAK;AACnB,YAAM,IAAI,MAAM,mCAAmC;AACvD,QAAI,CAACxB,GAAE,cAAe;AAClB,YAAM,IAAI,MAAM,wCAAwC;AAC5D,WAAO;AAAA,EACf,CAAK;AAAA,EAMD,MAAM,MAAM;AAAA,IACR,YAAY,IAAI,IAAI,IAAI;AACpB,WAAK,KAAK;AACV,WAAK,KAAK;AACV,WAAK,KAAK;AACV,UAAI,MAAM,QAAQ,CAACwB,IAAG,QAAQ,EAAE;AAC5B,cAAM,IAAI,MAAM,YAAY;AAChC,UAAI,MAAM,QAAQ,CAACA,IAAG,QAAQ,EAAE;AAC5B,cAAM,IAAI,MAAM,YAAY;AAChC,UAAI,MAAM,QAAQ,CAACA,IAAG,QAAQ,EAAE;AAC5B,cAAM,IAAI,MAAM,YAAY;AAChC,aAAO,OAAO,IAAI;AAAA,IAC9B;AAAA;AAAA;AAAA,IAGQ,OAAO,WAAWxB,IAAG;AACjB,YAAM,EAAE,GAAG,GAAAK,GAAG,IAAGL,MAAK,CAAE;AACxB,UAAI,CAACA,MAAK,CAACwB,IAAG,QAAQ,CAAC,KAAK,CAACA,IAAG,QAAQnB,EAAC;AACrC,cAAM,IAAI,MAAM,sBAAsB;AAC1C,UAAIL,cAAa;AACb,cAAM,IAAI,MAAM,8BAA8B;AAClD,YAAM,MAAM,CAAC,MAAMwB,IAAG,IAAI,GAAGA,IAAG,IAAI;AAEpC,UAAI,IAAI,CAAC,KAAK,IAAInB,EAAC;AACf,eAAO,MAAM;AACjB,aAAO,IAAI,MAAM,GAAGA,IAAGmB,IAAG,GAAG;AAAA,IACzC;AAAA,IACQ,IAAI,IAAI;AACJ,aAAO,KAAK,SAAQ,EAAG;AAAA,IACnC;AAAA,IACQ,IAAI,IAAI;AACJ,aAAO,KAAK,SAAQ,EAAG;AAAA,IACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOQ,OAAO,WAAW,QAAQ;AACtB,YAAM,QAAQA,IAAG,YAAY,OAAO,IAAI,CAACxB,OAAMA,GAAE,EAAE,CAAC;AACpD,aAAO,OAAO,IAAI,CAACA,IAAG,MAAMA,GAAE,SAAS,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,MAAM,UAAU;AAAA,IAClF;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,OAAO,QAAQ,KAAK;AAChB,YAAM,IAAI,MAAM,WAAW,UAAU,YAAY,YAAY,GAAG,CAAC,CAAC;AAClE,QAAE,eAAgB;AAClB,aAAO;AAAA,IACnB;AAAA;AAAA,IAEQ,OAAO,eAAe,YAAY;AAC9B,aAAO,MAAM,KAAK,SAAS,uBAAuB,UAAU,CAAC;AAAA,IACzE;AAAA;AAAA,IAEQ,OAAO,IAAI,QAAQ,SAAS;AACxB,aAAO,UAAU,OAAO,IAAI,QAAQ,OAAO;AAAA,IACvD;AAAA;AAAA,IAEQ,eAAe,YAAY;AACvB,WAAK,cAAc,MAAM,UAAU;AAAA,IAC/C;AAAA;AAAA,IAEQ,iBAAiB;AACb,sBAAgB,IAAI;AAAA,IAChC;AAAA,IACQ,WAAW;AACP,YAAM,EAAE,GAAAK,GAAC,IAAK,KAAK,SAAU;AAC7B,UAAImB,IAAG;AACH,eAAO,CAACA,IAAG,MAAMnB,EAAC;AACtB,YAAM,IAAI,MAAM,6BAA6B;AAAA,IACzD;AAAA;AAAA;AAAA;AAAA,IAIQ,OAAO,OAAO;AACV,qBAAe,KAAK;AACpB,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,YAAM,KAAKmB,IAAG,IAAIA,IAAG,IAAI,IAAI,EAAE,GAAGA,IAAG,IAAI,IAAI,EAAE,CAAC;AAChD,YAAM,KAAKA,IAAG,IAAIA,IAAG,IAAI,IAAI,EAAE,GAAGA,IAAG,IAAI,IAAI,EAAE,CAAC;AAChD,aAAO,MAAM;AAAA,IACzB;AAAA;AAAA;AAAA;AAAA,IAIQ,SAAS;AACL,aAAO,IAAI,MAAM,KAAK,IAAIA,IAAG,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE;AAAA,IAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,SAAS;AACL,YAAM,EAAE,GAAG,EAAC,IAAK;AACjB,YAAM,KAAKA,IAAG,IAAI,GAAGH,KAAG;AACxB,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,UAAI,KAAKG,IAAG,MAAM,KAAKA,IAAG,MAAM,KAAKA,IAAG;AACxC,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,GAAG,EAAE;AACjB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,GAAG,EAAE;AACjB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,GAAG,EAAE;AACjB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,aAAO,IAAI,MAAM,IAAI,IAAI,EAAE;AAAA,IACvC;AAAA;AAAA;AAAA;AAAA;AAAA,IAKQ,IAAI,OAAO;AACP,qBAAe,KAAK;AACpB,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,YAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,UAAI,KAAKA,IAAG,MAAM,KAAKA,IAAG,MAAM,KAAKA,IAAG;AACxC,YAAM,IAAI,MAAM;AAChB,YAAM,KAAKA,IAAG,IAAI,MAAM,GAAGH,KAAG;AAC9B,UAAI,KAAKG,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,UAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,GAAG,EAAE;AACjB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,GAAG,EAAE;AACjB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,GAAG,EAAE;AACjB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,WAAKA,IAAG,IAAI,IAAI,EAAE;AAClB,aAAO,IAAI,MAAM,IAAI,IAAI,EAAE;AAAA,IACvC;AAAA,IACQ,SAAS,OAAO;AACZ,aAAO,KAAK,IAAI,MAAM,OAAM,CAAE;AAAA,IAC1C;AAAA,IACQ,MAAM;AACF,aAAO,KAAK,OAAO,MAAM,IAAI;AAAA,IACzC;AAAA,IACQ,KAAKL,IAAG;AACJ,aAAO,KAAK,WAAW,MAAMA,IAAG,MAAM,UAAU;AAAA,IAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMQ,eAAe,IAAI;AACf,YAAM,EAAE,MAAM,GAAG,EAAG,IAAG;AACvBe,eAAY,UAAU,IAAIlB,OAAK,CAAC;AAChC,YAAM,IAAI,MAAM;AAChB,UAAI,OAAOA;AACP,eAAO;AACX,UAAI,KAAK,SAAS,OAAOC;AACrB,eAAO;AAEX,UAAI,CAAC,QAAQ,KAAK,eAAe,IAAI;AACjC,eAAO,KAAK,iBAAiB,MAAM,IAAI,MAAM,UAAU;AAE3D,UAAI,EAAE,OAAO,IAAI,OAAO,GAAE,IAAK,KAAK,YAAY,EAAE;AAClD,UAAI,MAAM;AACV,UAAI,MAAM;AACV,UAAI,IAAI;AACR,aAAO,KAAKD,SAAO,KAAKA,OAAK;AACzB,YAAI,KAAKC;AACL,gBAAM,IAAI,IAAI,CAAC;AACnB,YAAI,KAAKA;AACL,gBAAM,IAAI,IAAI,CAAC;AACnB,YAAI,EAAE,OAAQ;AACd,eAAOA;AACP,eAAOA;AAAAA,MACvB;AACY,UAAI;AACA,cAAM,IAAI,OAAQ;AACtB,UAAI;AACA,cAAM,IAAI,OAAQ;AACtB,YAAM,IAAI,MAAMO,IAAG,IAAI,IAAI,IAAI,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE;AACzD,aAAO,IAAI,IAAI,GAAG;AAAA,IAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUQ,SAAS,QAAQ;AACb,YAAM,EAAE,MAAM,GAAG,EAAG,IAAG;AACvBU,eAAY,UAAU,QAAQjB,OAAK,CAAC;AACpC,UAAI,OAAO;AACX,UAAI,MAAM;AACN,cAAM,EAAE,OAAO,IAAI,OAAO,GAAE,IAAK,KAAK,YAAY,MAAM;AACxD,YAAI,EAAE,GAAG,KAAK,GAAG,IAAG,IAAK,KAAK,KAAK,EAAE;AACrC,YAAI,EAAE,GAAG,KAAK,GAAG,IAAG,IAAK,KAAK,KAAK,EAAE;AACrC,cAAM,KAAK,gBAAgB,OAAO,GAAG;AACrC,cAAM,KAAK,gBAAgB,OAAO,GAAG;AACrC,cAAM,IAAI,MAAMO,IAAG,IAAI,IAAI,IAAI,KAAK,IAAI,GAAG,IAAI,IAAI,IAAI,EAAE;AACzD,gBAAQ,IAAI,IAAI,GAAG;AACnB,eAAO,IAAI,IAAI,GAAG;AAAA,MAClC,OACiB;AACD,cAAM,EAAE,GAAAxB,IAAG,EAAC,IAAK,KAAK,KAAK,MAAM;AACjC,gBAAQA;AACR,eAAO;AAAA,MACvB;AAEY,aAAO,MAAM,WAAW,CAAC,OAAO,IAAI,CAAC,EAAE,CAAC;AAAA,IACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOQ,qBAAqB,GAAG,GAAG,GAAG;AAC1B,YAAM,IAAI,MAAM;AAChB,YAAM,MAAM,CAAC,GAAGmC,OACVA,OAAMnB,SAAOmB,OAAMlB,SAAO,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,eAAekB,EAAC,IAAI,EAAE,SAASA,EAAC;AACjF,YAAM,MAAM,IAAI,MAAM,CAAC,EAAE,IAAI,IAAI,GAAG,CAAC,CAAC;AACtC,aAAO,IAAI,QAAQ,SAAY;AAAA,IAC3C;AAAA;AAAA;AAAA;AAAA,IAIQ,SAAS,IAAI;AACT,aAAO,aAAa,MAAM,EAAE;AAAA,IACxC;AAAA,IACQ,gBAAgB;AACZ,YAAM,EAAE,GAAG,UAAU,cAAe,IAAG;AACvC,UAAI,aAAalB;AACb,eAAO;AACX,UAAI;AACA,eAAO,cAAc,OAAO,IAAI;AACpC,YAAM,IAAI,MAAM,8DAA8D;AAAA,IAC1F;AAAA,IACQ,gBAAgB;AACZ,YAAM,EAAE,GAAG,UAAU,cAAe,IAAG;AACvC,UAAI,aAAaA;AACb,eAAO;AACX,UAAI;AACA,eAAO,cAAc,OAAO,IAAI;AACpC,aAAO,KAAK,eAAe,MAAM,CAAC;AAAA,IAC9C;AAAA,IACQ,WAAW,eAAe,MAAM;AAC5B,YAAM,gBAAgB,YAAY;AAClC,WAAK,eAAgB;AACrB,aAAOL,SAAQ,OAAO,MAAM,YAAY;AAAA,IACpD;AAAA,IACQ,MAAM,eAAe,MAAM;AACvB,YAAM,gBAAgB,YAAY;AAClC,aAAOoB,WAAc,KAAK,WAAW,YAAY,CAAC;AAAA,IAC9D;AAAA,EACA;AACI,QAAM,OAAO,IAAI,MAAM,MAAM,IAAI,MAAM,IAAIR,IAAG,GAAG;AACjD,QAAM,OAAO,IAAI,MAAMA,IAAG,MAAMA,IAAG,KAAKA,IAAG,IAAI;AAC/C,QAAM,QAAQ,MAAM;AACpB,QAAM,OAAO,KAAK,OAAO,MAAM,OAAO,KAAK,KAAK,QAAQ,CAAC,IAAI,KAAK;AAElE,SAAO;AAAA,IACH;AAAA,IACA,iBAAiB;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,EACH;AACL;AA0bO,SAAS,eAAeA,KAAI,GAAG;AAElC,QAAM,IAAIA,IAAG;AACb,MAAI5B,KAAIoB;AACR,WAAS,IAAI,IAAIC,OAAK,IAAIC,UAAQF,OAAK,KAAKE;AACxC,IAAAtB,MAAKqB;AACT,QAAM,KAAKrB;AAGX,QAAM,eAAesB,SAAQ,KAAKD,QAAMA;AACxC,QAAM,aAAa,eAAeC;AAClC,QAAM,MAAM,IAAID,SAAO;AACvB,QAAM,MAAM,KAAKA,SAAOC;AACxB,QAAM,KAAK,aAAaD;AACxB,QAAM,KAAK;AACX,QAAM,KAAKO,IAAG,IAAI,GAAG,EAAE;AACvB,QAAM,KAAKA,IAAG,IAAI,IAAI,KAAKP,SAAOC,KAAG;AACrC,MAAI,YAAY,CAACK,IAAG,MAAM;AACtB,QAAI,MAAM;AACV,QAAI,MAAMC,IAAG,IAAI,GAAG,EAAE;AACtB,QAAI,MAAMA,IAAG,IAAI,GAAG;AACpB,UAAMA,IAAG,IAAI,KAAK,CAAC;AACnB,QAAI,MAAMA,IAAG,IAAID,IAAG,GAAG;AACvB,UAAMC,IAAG,IAAI,KAAK,EAAE;AACpB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,UAAMA,IAAG,IAAI,KAAK,CAAC;AACnB,UAAMA,IAAG,IAAI,KAAKD,EAAC;AACnB,QAAI,MAAMC,IAAG,IAAI,KAAK,GAAG;AACzB,UAAMA,IAAG,IAAI,KAAK,EAAE;AACpB,QAAI,OAAOA,IAAG,IAAI,KAAKA,IAAG,GAAG;AAC7B,UAAMA,IAAG,IAAI,KAAK,EAAE;AACpB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,UAAMA,IAAG,KAAK,KAAK,KAAK,IAAI;AAC5B,UAAMA,IAAG,KAAK,KAAK,KAAK,IAAI;AAE5B,aAAS,IAAI,IAAI,IAAIP,OAAK,KAAK;AAC3B,UAAImB,OAAM,IAAIlB;AACd,MAAAkB,OAAMlB,SAAQkB,OAAMnB;AACpB,UAAI,OAAOO,IAAG,IAAI,KAAKY,IAAG;AAC1B,YAAM,KAAKZ,IAAG,IAAI,MAAMA,IAAG,GAAG;AAC9B,YAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,YAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,aAAOA,IAAG,IAAI,KAAK,GAAG;AACtB,YAAMA,IAAG,KAAK,KAAK,KAAK,EAAE;AAC1B,YAAMA,IAAG,KAAK,MAAM,KAAK,EAAE;AAAA,IACvC;AACQ,WAAO,EAAE,SAAS,MAAM,OAAO,IAAK;AAAA,EACvC;AACD,MAAIA,IAAG,QAAQF,UAAQD,OAAK;AAExB,UAAMgB,OAAMb,IAAG,QAAQH,SAAOC;AAC9B,UAAMgB,MAAKd,IAAG,KAAKA,IAAG,IAAI,CAAC,CAAC;AAC5B,gBAAY,CAACD,IAAG,MAAM;AAClB,UAAI,MAAMC,IAAG,IAAI,CAAC;AAClB,YAAM,MAAMA,IAAG,IAAID,IAAG,CAAC;AACvB,YAAMC,IAAG,IAAI,KAAK,GAAG;AACrB,UAAI,KAAKA,IAAG,IAAI,KAAKa,GAAE;AACvB,WAAKb,IAAG,IAAI,IAAI,GAAG;AACnB,YAAM,KAAKA,IAAG,IAAI,IAAIc,GAAE;AACxB,YAAM,MAAMd,IAAG,IAAIA,IAAG,IAAI,EAAE,GAAG,CAAC;AAChC,YAAM,OAAOA,IAAG,IAAI,KAAKD,EAAC;AAC1B,UAAIlB,KAAImB,IAAG,KAAK,IAAI,IAAI,IAAI;AAC5B,aAAO,EAAE,SAAS,MAAM,OAAOnB,GAAC;AAAA,IACnC;AAAA,EACT;AAGI,SAAO;AACX;AAKO,SAAS,oBAAoBmB,KAAI,MAAM;AAC1C,gBAAcA,GAAE;AAChB,MAAI,CAACA,IAAG,QAAQ,KAAK,CAAC,KAAK,CAACA,IAAG,QAAQ,KAAK,CAAC,KAAK,CAACA,IAAG,QAAQ,KAAK,CAAC;AAChE,UAAM,IAAI,MAAM,mCAAmC;AACvD,QAAM,YAAY,eAAeA,KAAI,KAAK,CAAC;AAC3C,MAAI,CAACA,IAAG;AACJ,UAAM,IAAI,MAAM,8BAA8B;AAGlD,SAAO,CAACD,OAAM;AAEV,QAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAGlB;AACrC,UAAMmB,IAAG,IAAID,EAAC;AACd,UAAMC,IAAG,IAAI,KAAK,KAAK,CAAC;AACxB,UAAMA,IAAG,IAAI,GAAG;AAChB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,UAAMA,IAAG,IAAI,KAAKA,IAAG,GAAG;AACxB,UAAMA,IAAG,IAAI,KAAK,KAAK,CAAC;AACxB,UAAMA,IAAG,KAAK,KAAK,GAAGA,IAAG,IAAI,GAAG,GAAG,CAACA,IAAG,IAAI,KAAKA,IAAG,IAAI,CAAC;AACxD,UAAMA,IAAG,IAAI,KAAK,KAAK,CAAC;AACxB,UAAMA,IAAG,IAAI,GAAG;AAChB,UAAMA,IAAG,IAAI,GAAG;AAChB,UAAMA,IAAG,IAAI,KAAK,KAAK,CAAC;AACxB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,UAAMA,IAAG,IAAI,KAAK,KAAK,CAAC;AACxB,UAAMA,IAAG,IAAI,KAAK,GAAG;AACrB,QAAIA,IAAG,IAAI,KAAK,GAAG;AACnB,UAAM,EAAE,SAAS,MAAK,IAAK,UAAU,KAAK,GAAG;AAC7C,IAAAnB,KAAImB,IAAG,IAAI,KAAKD,EAAC;AACjB,IAAAlB,KAAImB,IAAG,IAAInB,IAAG,KAAK;AACnB,QAAImB,IAAG,KAAK,GAAG,KAAK,OAAO;AAC3B,IAAAnB,KAAImB,IAAG,KAAKnB,IAAG,OAAO,OAAO;AAC7B,UAAM,KAAKmB,IAAG,MAAMD,EAAC,MAAMC,IAAG,MAAMnB,EAAC;AACrC,IAAAA,KAAImB,IAAG,KAAKA,IAAG,IAAInB,EAAC,GAAGA,IAAG,EAAE;AAC5B,QAAImB,IAAG,IAAI,GAAG,GAAG;AACjB,WAAO,EAAE,GAAG,GAAAnB,GAAG;AAAA,EAClB;AACL;AC3oCA;AAQA,MAAMW,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGG,QAAM,OAAO,CAAC;AAEvE,SAAS,iBAAiB,GAAG;AACzB,QAAM,MAAM,CAAE;AAEd,SAAO,IAAIJ,OAAK,MAAMA,OAAK;AACvB,SAAK,IAAIA,WAASD;AACd,UAAI,QAAQ,CAAC;AAAA,cACP,IAAIK,WAASA,OAAK;AACxB,UAAI,QAAQ,EAAE;AACd,WAAKJ;AAAAA,IACjB;AAEY,UAAI,QAAQ,CAAC;AAAA,EACzB;AACI,SAAO;AACX;AACO,SAAS,IAAI,OAAO;AAEvB,QAAM,EAAE,IAAAO,KAAI,IAAAe,KAAI,KAAAC,MAAK,KAAAC,MAAK,MAAAC,MAAI,IAAK,MAAM;AACzC,QAAM,oBAAoB,MAAM,OAAO;AACvC,QAAM,QAAQ,MAAM,OAAO;AAE3B,QAAM,MAAM,kBAAkB,EAAE,GAAGH,IAAG,OAAO,GAAG,MAAM,IAAI;AAC1D,QAAM,KAAK,OAAO,OAAO,KAAK,aAAa,IAAI,iBAAiB,MAAM,GAAG,YAAY;AAAA,IACjF,GAAG,MAAM;AAAA,IACT,GAAG,MAAM,GAAG;AAAA,EACpB,CAAK,CAAC;AAEF,QAAM,MAAM,kBAAkB,EAAE,GAAGA,IAAG,OAAO,GAAG,MAAM,IAAI;AAC1D,QAAM,KAAK,OAAO,OAAO,KAAK,aAAa,IAAI,iBAAiB,MAAM,GAAG,YAAY;AAAA,IACjF,GAAG,MAAM;AAAA,IACT,GAAG,MAAM,GAAG;AAAA,EACpB,CAAK,CAAC;AAEF,MAAI;AACJ,MAAI,UAAU,kBAAkB;AAC5B,mBAAe,CAAC,IAAI,IAAI,IAAI,GAAG,IAAI,OAAOG,MAAK,OAAO,GAAG,IAAIF,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AAAA,EACrG,WACa,UAAU,YAAY;AAG3B,mBAAe,CAAC,IAAI,IAAI,IAAI,GAAG,IAAI,OAAOE,MAAK,OAAO,GAAGF,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE;AAAA,EACrG;AAEQ,UAAM,IAAI,MAAM,yBAAyB;AAC7C,QAAM,UAAUA,KAAI,IAAIA,KAAI,KAAKA,KAAI,IAAIA,KAAI,KAAKtB,KAAG,CAAC;AACtD,WAAS,YAAY,KAAK,IAAI,IAAI,IAAI;AAClC,UAAM,KAAKsB,KAAI,IAAI,EAAE;AACrB,UAAM,KAAKA,KAAI,IAAI,EAAE;AACrB,UAAM,KAAKA,KAAI,OAAOA,KAAI,IAAI,IAAInB,KAAG,CAAC;AACtC,UAAM,KAAKmB,KAAI,IAAI,IAAInB,KAAG;AAC1B,UAAM,KAAKmB,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE;AAC5D,UAAM,KAAKA,KAAI,IAAI,IAAI,EAAE;AACzB,UAAM,KAAKA,KAAI,IAAIA,KAAI,IAAI,EAAE,GAAGnB,KAAG;AACnC,UAAM,KAAKmB,KAAI,IAAI,EAAE;AACrB,QAAI,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;AACrB,SAAKA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,OAAO;AAC/D,SAAKA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,OAAO,CAAC,GAAGA,KAAI,IAAIA,KAAI,IAAI,EAAE,GAAGnB,KAAG,CAAC;AAClF,SAAKmB,KAAI,IAAI,IAAI,EAAE;AACnB,WAAO,EAAE,IAAI,IAAI,GAAI;AAAA,EAC7B;AACI,WAAS,SAAS,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI;AAEvC,UAAM,KAAKA,KAAI,IAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,CAAC;AACtC,UAAM,KAAKA,KAAI,IAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,CAAC;AACtC,UAAM,KAAKA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AACnD,UAAM,KAAKA,KAAI,IAAI,EAAE;AACrB,UAAM,KAAK;AACX,QAAI,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;AACrB,UAAM,KAAKA,KAAI,IAAI,EAAE;AACrB,UAAM,KAAKA,KAAI,IAAI,IAAI,EAAE;AACzB,UAAM,KAAKA,KAAI,IAAI,IAAI,EAAE;AACzB,UAAM,KAAKA,KAAI,IAAIA,KAAI,IAAI,IAAIA,KAAI,IAAI,IAAItB,KAAG,CAAC,GAAGsB,KAAI,IAAIA,KAAI,IAAI,EAAE,GAAG,EAAE,CAAC;AAC1E,SAAKA,KAAI,IAAI,IAAI,EAAE;AACnB,SAAKA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AAC1D,SAAKA,KAAI,IAAI,IAAI,EAAE;AACnB,WAAO,EAAE,IAAI,IAAI,GAAI;AAAA,EAC7B;AAKI,QAAM,UAAU,iBAAiB,MAAM,OAAO,WAAW;AACzD,QAAM,yBAAyB,SAAS,CAAC,UAAU;AAC/C,UAAMxC,KAAI;AACV,UAAM,EAAE,GAAG,GAAAK,OAAML,GAAE,SAAU;AAE7B,UAAM,KAAK,GAAG,KAAKK,IAAG,QAAQmC,KAAI,IAAInC,EAAC;AAEvC,QAAI,KAAK,IAAI,KAAK,IAAI,KAAKmC,KAAI;AAC/B,UAAM,MAAM,CAAE;AACd,eAAW,OAAO,SAAS;AACvB,YAAM,MAAM,CAAE;AACd,OAAC,EAAE,IAAI,IAAI,GAAI,IAAG,YAAY,KAAK,IAAI,IAAI,EAAE;AAC7C,UAAI;AACA,SAAC,EAAE,IAAI,IAAI,GAAE,IAAK,SAAS,KAAK,IAAI,IAAI,IAAI,IAAI,QAAQ,KAAK,QAAQ,EAAE;AAC3E,UAAI,KAAK,GAAG;AAAA,IACxB;AACQ,QAAI,MAAM,gBAAgB;AACtB,YAAM,OAAO,IAAI,IAAI,SAAS,CAAC;AAC/B,YAAM,eAAe,IAAI,IAAI,IAAI,IAAI,IAAI,SAAS,KAAK,MAAM,IAAI,CAAC;AAAA,IAC9E;AACQ,WAAO;AAAA,EACf,CAAK;AACD,WAAS,gBAAgB,OAAO,oBAAoB,OAAO;AACvD,QAAI,MAAME,MAAK;AACf,QAAI,MAAM,QAAQ;AACd,YAAM,SAAS,MAAM,CAAC,EAAE,CAAC,EAAE;AAC3B,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,cAAMA,MAAK,IAAI,GAAG;AAElB,mBAAW,CAAC,KAAK,IAAI,EAAE,KAAK,OAAO;AAC/B,qBAAW,CAAC,IAAI,IAAI,EAAE,KAAK,IAAI,CAAC;AAC5B,kBAAM,aAAa,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE;AAAA,QAClE;AAAA,MACA;AAAA,IACA;AACQ,QAAI;AACA,YAAMA,MAAK,UAAU,GAAG;AAC5B,WAAO,oBAAoBA,MAAK,kBAAkB,GAAG,IAAI;AAAA,EACjE;AAGI,WAAS,aAAa,OAAO,oBAAoB,MAAM;AACnD,UAAM,MAAM,CAAE;AAEd,OAAG,gBAAgB,WAAW,MAAM,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;AACvD,OAAG,gBAAgB,WAAW,MAAM,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;AACvD,eAAW,EAAE,IAAI,GAAE,KAAM,OAAO;AAC5B,UAAI,GAAG,OAAO,GAAG,gBAAgB,IAAI,KAAK,GAAG,OAAO,GAAG,gBAAgB,IAAI;AACvE,cAAM,IAAI,MAAM,yCAAyC;AAE7D,SAAG,eAAgB;AACnB,SAAG,eAAgB;AACnB,YAAM,KAAK,GAAG,SAAU;AACxB,UAAI,KAAK,CAAC,uBAAuB,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,IAC7D;AACQ,WAAO,gBAAgB,KAAK,iBAAiB;AAAA,EACrD;AAEI,WAAS,QAAQ,GAAG,GAAG,oBAAoB,MAAM;AAC7C,WAAO,aAAa,CAAC,EAAE,IAAI,GAAG,IAAI,EAAC,CAAE,GAAG,iBAAiB;AAAA,EACjE;AACI,QAAMzC,SAAQ;AAAA,IACV,kBAAkB,MAAM;AACpB,YAAM,SAAS,iBAAiBsC,IAAG,KAAK;AACxC,aAAO,eAAe,MAAM,YAAY,MAAM,GAAGA,IAAG,KAAK;AAAA,IAC5D;AAAA,IACD;AAAA,EACH;AACD,QAAM,EAAE,mBAAmB,MAAM;AACjC,QAAM,EAAE,cAAc,MAAM;AAC5B,WAAS,OAAO,OAAO;AACnB,WAAO,iBAAiB,GAAG,kBAAkB,QAAQ,GAAG,gBAAgB,QAAQ,KAAK;AAAA,EAC7F;AACI,WAAS,WAAW,OAAO,SAAS;AAChC,WAAO,iBAAiB,GAAG,kBACrB,QACA,GAAG,YAAY,YAAY,SAAS,KAAK,GAAG,OAAO;AAAA,EACjE;AACI,WAAS,OAAO,OAAO;AACnB,WAAO,iBAAiB,GAAG,kBAAkB,QAAQ,UAAU,QAAQ,KAAK;AAAA,EACpF;AACI,WAAS,WAAW,OAAO,SAAS;AAChC,WAAO,iBAAiB,GAAG,kBACrB,QACA,GAAG,YAAY,YAAY,SAAS,KAAK,GAAG,OAAO;AAAA,EACjE;AAGI,WAAS,aAAa,YAAY;AAC9B,WAAO,GAAG,gBAAgB,eAAe,UAAU,EAAE,WAAW,IAAI;AAAA,EAC5E;AAGI,WAAS,+BAA+B,YAAY;AAChD,WAAO,GAAG,gBAAgB,eAAe,UAAU,EAAE,WAAW,IAAI;AAAA,EAC5E;AACI,WAAS,KAAK,SAAS,YAAY,SAAS;AACxC,UAAM,WAAW,WAAW,SAAS,OAAO;AAC5C,aAAS,eAAgB;AACzB,UAAM,WAAW,SAAS,SAAS,GAAG,uBAAuB,UAAU,CAAC;AACxE,QAAI,mBAAmB,GAAG;AACtB,aAAO;AACX,WAAO,UAAU,WAAW,QAAQ;AAAA,EAC5C;AACI,WAAS,mBAAmB,SAAS,YAAY,SAAS;AACtD,UAAM,WAAW,WAAW,SAAS,OAAO;AAC5C,aAAS,eAAgB;AACzB,UAAM,WAAW,SAAS,SAAS,GAAG,uBAAuB,UAAU,CAAC;AACxE,QAAI,mBAAmB,GAAG;AACtB,aAAO;AACX,WAAO,eAAe,WAAW,QAAQ;AAAA,EACjD;AAGI,WAAS,OAAO,WAAW,SAAS,WAAW,SAAS;AACpD,UAAM,IAAI,OAAO,SAAS;AAC1B,UAAM,KAAK,WAAW,SAAS,OAAO;AACtC,UAAM,IAAI,GAAG,gBAAgB;AAC7B,UAAM,IAAI,OAAO,SAAS;AAC1B,UAAM,MAAM,aAAa;AAAA,MACrB,EAAE,IAAI,EAAE,OAAM,GAAI,IAAI,GAAI;AAAA;AAAA,MAC1B,EAAE,IAAI,GAAG,IAAI,EAAG;AAAA;AAAA,IAC5B,CAAS;AACD,WAAOG,MAAK,IAAI,KAAKA,MAAK,GAAG;AAAA,EACrC;AAGI,WAAS,qBAAqB,WAAW,SAAS,WAAW,SAAS;AAClE,UAAM,IAAI,OAAO,SAAS;AAC1B,UAAM,KAAK,WAAW,SAAS,OAAO;AACtC,UAAM,IAAI,GAAG,gBAAgB;AAC7B,UAAM,IAAI,OAAO,SAAS;AAC1B,UAAM,MAAM,aAAa;AAAA,MACrB,EAAE,IAAI,IAAI,IAAI,EAAG;AAAA;AAAA,MACjB,EAAE,IAAI,GAAG,IAAI,EAAE,OAAM,EAAI;AAAA;AAAA,IACrC,CAAS;AACD,WAAOA,MAAK,IAAI,KAAKA,MAAK,GAAG;AAAA,EACrC;AACI,WAAS,UAAU,KAAK;AACpB,QAAI,CAAC,MAAM,QAAQ,GAAG,KAAK,IAAI,WAAW;AACtC,YAAM,IAAI,MAAM,0BAA0B;AAAA,EACtD;AACI,WAAS,oBAAoB,YAAY;AACrC,cAAU,UAAU;AACpB,UAAM,MAAM,WAAW,IAAI,MAAM,EAAE,OAAO,CAAC,KAAK1C,OAAM,IAAI,IAAIA,EAAC,GAAG,GAAG,gBAAgB,IAAI;AACzF,UAAM,YAAY;AAClB,QAAI,WAAW,CAAC,aAAa,GAAG,iBAAiB;AAC7C,gBAAU,eAAgB;AAC1B,aAAO;AAAA,IACnB;AAEQ,WAAO,UAAU,WAAW,IAAI;AAAA,EACxC;AACI,WAAS,oBAAoB,YAAY;AACrC,cAAU,UAAU;AACpB,UAAM,MAAM,WAAW,IAAI,MAAM,EAAE,OAAO,CAAC,KAAKI,OAAM,IAAI,IAAIA,EAAC,GAAG,GAAG,gBAAgB,IAAI;AACzF,UAAM,YAAY;AAClB,QAAI,WAAW,CAAC,aAAa,GAAG,iBAAiB;AAC7C,gBAAU,eAAgB;AAC1B,aAAO;AAAA,IACnB;AACQ,WAAO,UAAU,WAAW,SAAS;AAAA,EAC7C;AACI,WAAS,yBAAyB,YAAY;AAC1C,cAAU,UAAU;AACpB,UAAM,MAAM,WAAW,IAAI,MAAM,EAAE,OAAO,CAAC,KAAKA,OAAM,IAAI,IAAIA,EAAC,GAAG,GAAG,gBAAgB,IAAI;AACzF,UAAM,YAAY;AAClB,QAAI,WAAW,CAAC,aAAa,GAAG,iBAAiB;AAC7C,gBAAU,eAAgB;AAC1B,aAAO;AAAA,IACnB;AACQ,WAAO,eAAe,WAAW,SAAS;AAAA,EAClD;AAGI,WAAS,YAAY,WAErB,UAAU,YAAY,SAAS;AAC3B,cAAU,QAAQ;AAClB,QAAI,WAAW,WAAW,SAAS;AAC/B,YAAM,IAAI,MAAM,oDAAoD;AACxE,UAAM,MAAM,OAAO,SAAS;AAC5B,UAAM,YAAY,SAAS,IAAI,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC;AAC5D,UAAM,cAAc,WAAW,IAAI,MAAM;AAEzC,UAAM,mBAAmB,oBAAI,IAAK;AAClC,aAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AACzC,YAAM,MAAM,YAAY,CAAC;AACzB,YAAM,MAAM,UAAU,CAAC;AACvB,UAAI,OAAO,iBAAiB,IAAI,GAAG;AACnC,UAAI,SAAS,QAAW;AACpB,eAAO,CAAE;AACT,yBAAiB,IAAI,KAAK,IAAI;AAAA,MAC9C;AACY,WAAK,KAAK,GAAG;AAAA,IACzB;AACQ,UAAM,SAAS,CAAE;AACjB,QAAI;AACA,iBAAW,CAAC,KAAK,IAAI,KAAK,kBAAkB;AACxC,cAAM,iBAAiB,KAAK,OAAO,CAAC,KAAKuC,SAAQ,IAAI,IAAIA,IAAG,CAAC;AAC7D,eAAO,KAAK,EAAE,IAAI,gBAAgB,IAAI,KAAK;AAAA,MAC3D;AACY,aAAO,KAAK,EAAE,IAAI,GAAG,gBAAgB,KAAK,OAAQ,GAAE,IAAI,KAAK;AAC7D,aAAOD,MAAK,IAAI,aAAa,MAAM,GAAGA,MAAK,GAAG;AAAA,IAC1D,QACc;AACF,aAAO;AAAA,IACnB;AAAA,EACA;AACI,KAAG,gBAAgB,KAAK,eAAe,CAAC;AACxC,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,MACJ,IAAAH;AAAA,MACA,IAAAf;AAAA,MACA,KAAAgB;AAAA,MACA,KAAAC;AAAA,MACA,MAAAC;AAAA,IACH;AAAA,IACD,QAAQ;AAAA,MACJ,aAAa,MAAM,OAAO;AAAA,MAC1B,GAAG,MAAM,OAAO;AAAA,MAChB,KAAK,MAAM,GAAG;AAAA,MACd,KAAK,MAAM,GAAG;AAAA,IACjB;AAAA,IACD,OAAAzC;AAAA,EACH;AACL;ACpVA;AAKA,MAAMe,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGC,QAAM,OAAO,CAAC,GAAGG,QAAM,OAAO,CAAC;AACvE,SAAS,0BAA0BG,KAAI,YAAY,SAAS,QAAQ,MAAM,GAAG,SAAS;AAClF,QAAM,WAAW,OAAO,YAAY,SAAY,SAAS,OAAO;AAChE,QAAM,eAAe,WAAW,OAAO,MAAM;AAC7C,QAAM,MAAM,CAAE;AACd,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC1B,UAAM,IAAI,OAAO,IAAI,CAAC;AACtB,UAAM,SAAS,CAAE;AACjB,aAAS,IAAI,GAAG,SAASP,OAAK,IAAI,QAAQ,KAAK;AAC3C,YAAM,SAAU,IAAI,SAAS,KAAK,WAAY;AAC9C,aAAO,KAAKO,IAAG,IAAI,YAAY,KAAK,CAAC;AACrC,gBAAU;AAAA,IACtB;AACQ,QAAI,KAAK,MAAM;AAAA,EACvB;AACI,SAAO;AACX;AAEO,SAAS,aAAaA,KAAIgB,MAAK,MAAM;AAExC,QAAM,QAAQA,KAAI,IAAI,OAAOhB,IAAG,QAAQP,SAAOI,KAAG;AAClD,QAAM,QAAQmB,KAAI,IAAI,OAAOhB,IAAG,QAAQP,SAAOC,KAAG;AAClD,WAAS,IAAI,GAAGb,IAAG;AAEf,UAAM,KAAKmC,KAAI,IAAIA,KAAI,aAAa,GAAG,CAAC,GAAG,KAAK;AAChD,UAAMI,MAAKJ,KAAI,IAAIA,KAAI,aAAanC,IAAG,CAAC,GAAG,KAAK;AAChD,WAAO,CAAC,IAAIuC,GAAE;AAAA,EACtB;AAEI,QAAM,SAASJ,KAAI,IAAI,OAAOhB,IAAG,SAASN,QAAMD,SAAOI,KAAG;AAG1D,QAAM,SAASmB,KAAI,IAAI,OAAOhB,IAAG,SAASN,QAAMD,SAAOC,KAAG;AAC1D,MAAI,CAACsB,KAAI,IAAI,QAAQA,KAAI,IAAIA,KAAI,GAAG,CAAC;AACjC,UAAM,IAAI,MAAM,2BAA2B;AAC/C,WAAS,KAAK,GAAGnC,IAAG;AAChB,WAAO,CAACmC,KAAI,IAAI,GAAG,MAAM,GAAGA,KAAI,IAAInC,EAAC,CAAC;AAAA,EAC9C;AAEI,QAAM,YAAY,CAAC,OAAO,CAAC,GAAG,MAAM;AAChC,UAAM,SAAS,EAAE,SAAU;AAC3B,UAAML,KAAI,GAAG,OAAO,GAAG,OAAO,CAAC;AAC/B,WAAO,EAAE,WAAW,EAAE,GAAGA,GAAE,CAAC,GAAG,GAAGA,GAAE,CAAC,GAAG;AAAA,EAC3C;AACD,QAAM6C,SAAQ,UAAU,GAAG;AAC3B,QAAMC,UAAS,UAAU,IAAI;AAC7B,SAAO,EAAE,KAAK,MAAM,OAAAD,QAAO,QAAAC,SAAQ,OAAO,OAAO,QAAQ,OAAQ;AACrE;AACO,SAAS,QAAQ,MAAM;AAC1B,QAAM,EAAE,MAAK,IAAK;AAElB,QAAMtB,MAAKuB,MAAU,KAAK;AAC1B,QAAM,eAAevB,IAAG,OAAO,KAAK,cAAc,OAAO,EAAE,CAAC;AAC5D,QAAMwB,eAAaC,WAAe,KAAK;AACvC,QAAM,SAASzB,IAAG,IAAIA,IAAG,KAAKN,KAAG;AAEjC,QAAM,6BAA6B,0BAA0BM,KAAI,cAAcA,IAAG,OAAO,CAAC,EAAE,CAAC;AAC7F,QAAM,SAAS,CAAC,EAAE,IAAI,GAAE,GAAI,EAAE,IAAI,IAAI,IAAI,UAAU;AAAA,IAChD,IAAIA,IAAG,IAAI,IAAI,EAAE;AAAA,IACjB,IAAIA,IAAG,IAAI,IAAI,EAAE;AAAA,EACzB;AACI,QAAM,cAAc,CAAC,EAAE,IAAI,GAAE,GAAI,EAAE,IAAI,IAAI,IAAI,UAAU;AAAA,IACrD,IAAIA,IAAG,IAAI,IAAI,EAAE;AAAA,IACjB,IAAIA,IAAG,IAAI,IAAI,EAAE;AAAA,EACzB;AACI,QAAM,cAAc,CAAC,EAAE,IAAI,GAAE,GAAI,QAAQ;AACrC,QAAI,OAAO,QAAQ;AACf,aAAO,EAAE,IAAIA,IAAG,IAAI,IAAI,GAAG,GAAG,IAAIA,IAAG,IAAI,IAAI,GAAG,EAAG;AAEvD,UAAM,EAAE,IAAI,IAAI,IAAI,GAAI,IAAG;AAC3B,QAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AACtB,QAAI,KAAKA,IAAG,IAAI,IAAI,EAAE;AAEtB,UAAM,KAAKA,IAAG,IAAI,IAAI,EAAE;AACxB,UAAM,KAAKA,IAAG,IAAIA,IAAG,IAAIA,IAAG,IAAI,IAAI,EAAE,GAAGA,IAAG,IAAI,IAAI,EAAE,CAAC,GAAGA,IAAG,IAAI,IAAI,EAAE,CAAC;AACxE,WAAO,EAAE,IAAI,IAAI,IAAI,GAAI;AAAA,EAC5B;AACD,QAAM,YAAY,CAAC,EAAE,IAAI,GAAE,MAAO;AAC9B,UAAM,IAAIA,IAAG,IAAI,IAAI,EAAE;AACvB,UAAM,IAAIA,IAAG,IAAI,IAAI,EAAE;AACvB,UAAM,IAAIA,IAAG,IAAI,IAAI,EAAE;AACvB,WAAO,EAAE,IAAIA,IAAG,IAAI,GAAG,CAAC,GAAG,IAAIA,IAAG,IAAI,GAAG,EAAE,EAAG;AAAA,EACjD;AACD,QAAM,kBAAkB,CAAC,UAAU;AAC/B,QAAI,MAAM,WAAW;AACjB,YAAM,IAAI,MAAM,eAAe;AACnC,UAAM,MAAM,MAAM,IAAI,CAACL,OAAMK,IAAG,OAAOL,EAAC,CAAC;AACzC,WAAO,EAAE,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,EAAG;AAAA,EACpC;AACD,QAAM,YAAY,QAAQ;AAC1B,QAAM,gBAAgB,gBAAgB,KAAK,cAAc;AACzD,QAAMqB,OAAM;AAAA,IACR,OAAO;AAAA,IACP,MAAMhB,IAAG;AAAA,IACT,YAAY;AAAA,IACZ,MAAM,OAAO,SAAS;AAAA,IACtB,OAAO,KAAK,KAAK,OAAO,SAAS,IAAI,CAAC;AAAA,IACtC,MAAM,QAAQ,OAAO,SAAS,CAAC;AAAA,IAC/B,MAAM,EAAE,IAAIA,IAAG,MAAM,IAAIA,IAAG,KAAM;AAAA,IAClC,KAAK,EAAE,IAAIA,IAAG,KAAK,IAAIA,IAAG,KAAM;AAAA,IAChC,QAAQ,CAAC,QAAQ;AAAA,IACjB,SAAS,CAAC,EAAE,IAAI,GAAE,MAAO,OAAO,OAAO,YAAY,OAAO,OAAO;AAAA,IACjE,KAAK,CAAC,EAAE,IAAI,SAASA,IAAG,IAAI,EAAE,KAAKA,IAAG,IAAI,EAAE;AAAA,IAC5C,KAAK,CAAC,EAAE,IAAI,GAAI,GAAE,EAAE,IAAI,IAAI,IAAI,GAAI,MAAKA,IAAG,IAAI,IAAI,EAAE,KAAKA,IAAG,IAAI,IAAI,EAAE;AAAA,IACxE,KAAK,CAAC,EAAE,IAAI,GAAE,OAAQ,EAAE,IAAIA,IAAG,IAAI,EAAE,GAAG,IAAIA,IAAG,IAAI,EAAE,EAAC;AAAA,IACtD,KAAK,CAAC,KAAK,UAAU0B,MAAUV,MAAK,KAAK,KAAK;AAAA,IAC9C,aAAa,CAAC,SAASW,cAAkBX,MAAK,IAAI;AAAA;AAAA,IAElD,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA;AAAA,IAEL,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA;AAAA,IAEN,KAAK,CAAC,KAAK,QAAQA,KAAI,IAAI,KAAK,OAAO,QAAQ,WAAWhB,IAAG,IAAIA,IAAG,OAAO,GAAG,CAAC,IAAIgB,KAAI,IAAI,GAAG,CAAC;AAAA,IAC/F,KAAK,CAAC,EAAE,IAAI,GAAG,IAAI,EAAC,MAAO;AAcvB,YAAM,SAAShB,IAAG,IAAIA,IAAG,OAAO,IAAI,IAAI,IAAI,CAAC,CAAC;AAC9C,aAAO,EAAE,IAAIA,IAAG,IAAI,QAAQA,IAAG,OAAO,CAAC,CAAC,GAAG,IAAIA,IAAG,IAAI,QAAQA,IAAG,OAAO,CAAC,CAAC,CAAC,EAAG;AAAA,IACjF;AAAA,IACD,MAAM,CAAC,QAAQ;AACX,UAAI,KAAK;AACL,eAAO,KAAK,QAAQ,GAAG;AAE3B,YAAM,EAAE,IAAI,GAAE,IAAK;AACnB,UAAIA,IAAG,IAAI,EAAE,GAAG;AAEZ,YAAIA,IAAG,IAAIwB,aAAWxB,KAAI,EAAE,GAAGA,IAAG,GAAG;AACjC,iBAAOgB,KAAI,OAAO,EAAE,IAAIhB,IAAG,KAAK,EAAE,GAAG,IAAIA,IAAG,KAAI,CAAE;AAAA;AAElD,iBAAOgB,KAAI,OAAO,EAAE,IAAIhB,IAAG,MAAM,IAAIA,IAAG,KAAKA,IAAG,IAAI,IAAI,YAAY,CAAC,EAAC,CAAE;AAAA,MAC5F;AACY,YAAM,IAAIA,IAAG,KAAKA,IAAG,IAAIA,IAAG,IAAI,EAAE,GAAGA,IAAG,IAAIA,IAAG,IAAI,EAAE,GAAG,YAAY,CAAC,CAAC;AACtE,UAAI,IAAIA,IAAG,IAAIA,IAAG,IAAI,GAAG,EAAE,GAAG,MAAM;AACpC,YAAM,WAAWwB,aAAWxB,KAAI,CAAC;AAEjC,UAAI,CAACA,IAAG,IAAI,QAAQ,KAAK,CAACA,IAAG,IAAI,UAAUA,IAAG,GAAG;AAC7C,YAAIA,IAAG,IAAI,GAAG,CAAC;AACnB,YAAM,KAAKA,IAAG,KAAK,CAAC;AACpB,YAAM,gBAAgBgB,KAAI,OAAO,EAAE,IAAI,IAAI,IAAIhB,IAAG,IAAIA,IAAG,IAAI,IAAI,MAAM,GAAG,EAAE,GAAG;AAC/E,UAAI,CAACgB,KAAI,IAAIA,KAAI,IAAI,aAAa,GAAG,GAAG;AACpC,cAAM,IAAI,MAAM,yBAAyB;AAE7C,YAAM,KAAK;AACX,YAAM,KAAKA,KAAI,IAAI,EAAE;AACrB,YAAM,EAAE,IAAI,KAAK,IAAI,IAAG,IAAKA,KAAI,KAAK,EAAE;AACxC,YAAM,EAAE,IAAI,KAAK,IAAI,IAAG,IAAKA,KAAI,KAAK,EAAE;AACxC,UAAI,MAAM,OAAQ,QAAQ,OAAO,MAAM;AACnC,eAAO;AACX,aAAO;AAAA,IACV;AAAA;AAAA,IAED,OAAO,CAAC,MAAM;AACV,YAAM,EAAE,IAAI,IAAI,IAAI,GAAE,IAAKA,KAAI,KAAK,CAAC;AACrC,YAAM,SAAS,KAAKtB;AACpB,YAAM,SAAS,OAAOF;AACtB,YAAM,SAAS,KAAKE;AACpB,aAAO,OAAO,UAAW,UAAU,MAAO,KAAKD;AAAAA,IAClD;AAAA;AAAA,IAED,UAAU,GAAG;AACT,UAAI,EAAE,WAAWuB,KAAI;AACjB,cAAM,IAAI,MAAM,8BAA8B,EAAE,MAAM;AAC1D,aAAO,EAAE,IAAIhB,IAAG,UAAU,EAAE,SAAS,GAAGA,IAAG,KAAK,CAAC,GAAG,IAAIA,IAAG,UAAU,EAAE,SAASA,IAAG,KAAK,CAAC,EAAG;AAAA,IAC/F;AAAA,IACD,SAAS,CAAC,EAAE,IAAI,GAAE,MAAOJ,cAAYI,IAAG,QAAQ,EAAE,GAAGA,IAAG,QAAQ,EAAE,CAAC;AAAA,IACnE,MAAM,CAAC,EAAE,IAAI,MAAM,EAAE,IAAI,IAAI,IAAI,GAAI,GAAE,OAAO;AAAA,MAC1C,IAAIA,IAAG,KAAK,IAAI,IAAI,CAAC;AAAA,MACrB,IAAIA,IAAG,KAAK,IAAI,IAAI,CAAC;AAAA,IACjC;AAAA,IACQ,MAAM,CAAC,EAAE,IAAI,GAAI,OAAM,EAAE,IAAI,IAAI,IAAI;;IAErC,iBAAiB,CAAC,EAAE,IAAI,SAASgB,KAAI,IAAI,EAAE,IAAI,GAAI,GAAE,aAAa;AAAA,IAClE,QAAQ,KAAK;AAAA,IACb,cAAc;AAAA,IACd,cAAc,CAAC,EAAE,IAAI,GAAE,GAAI,WAAW;AAAA,MAClC;AAAA,MACA,IAAIhB,IAAG,IAAI,IAAI,2BAA2B,QAAQ,CAAC,CAAC;AAAA,IAChE;AAAA,EACK;AAED,QAAM,SAAS,CAAC,EAAE,IAAI,IAAI,GAAI,GAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,OAAQ;AAAA,IAC5D,IAAIgB,KAAI,IAAI,IAAI,EAAE;AAAA,IAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,IAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,EAC1B;AACI,QAAM,cAAc,CAAC,EAAE,IAAI,IAAI,GAAI,GAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,OAAQ;AAAA,IACjE,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,IAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,IAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,EAC1B;AACI,QAAM,cAAc,CAAC,EAAE,IAAI,IAAI,GAAI,GAAE,QAAQ;AACzC,QAAI,OAAO,QAAQ,UAAU;AACzB,aAAO;AAAA,QACH,IAAIA,KAAI,IAAI,IAAI,GAAG;AAAA,QACnB,IAAIA,KAAI,IAAI,IAAI,GAAG;AAAA,QACnB,IAAIA,KAAI,IAAI,IAAI,GAAG;AAAA,MACtB;AAAA,IACb;AACQ,UAAM,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,IAAK;AACnC,UAAM,KAAKA,KAAI,IAAI,IAAI,EAAE;AACzB,UAAM,KAAKA,KAAI,IAAI,IAAI,EAAE;AACzB,UAAM,KAAKA,KAAI,IAAI,IAAI,EAAE;AACzB,WAAO;AAAA;AAAA,MAEH,IAAIA,KAAI,IAAI,IAAIA,KAAI,gBAAgBA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;AAAA;AAAA,MAExG,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAGA,KAAI,gBAAgB,EAAE,CAAC;AAAA;AAAA,MAExG,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,CAAC,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AAAA,IACtF;AAAA,EACJ;AACD,QAAM,YAAY,CAAC,EAAE,IAAI,IAAI,GAAE,MAAO;AAClC,QAAI,KAAKA,KAAI,IAAI,EAAE;AACnB,QAAI,KAAKA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGtB,KAAG;AACrC,QAAI,KAAKsB,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGtB,KAAG;AACrC,QAAI,KAAKsB,KAAI,IAAI,EAAE;AACnB,WAAO;AAAA,MACH,IAAIA,KAAI,IAAIA,KAAI,gBAAgB,EAAE,GAAG,EAAE;AAAA;AAAA,MACvC,IAAIA,KAAI,IAAIA,KAAI,gBAAgB,EAAE,GAAG,EAAE;AAAA;AAAA;AAAA,MAEvC,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AAAA,IAC/F;AAAA,EACJ;AACD,QAAM,CAAC,8BAA8B,4BAA4B,IAAI,0BAA0BA,MAAK,eAAehB,IAAG,OAAO,GAAG,GAAG,CAAC;AACpI,QAAMiB,OAAM;AAAA,IACR,OAAOD,KAAI;AAAA;AAAA,IACX,MAAMA,KAAI;AAAA,IACV,MAAM,IAAIA,KAAI;AAAA,IACd,OAAO,IAAIA,KAAI;AAAA,IACf,MAAM,QAAQ,IAAIA,KAAI,IAAI;AAAA,IAC1B,MAAM,EAAE,IAAIA,KAAI,MAAM,IAAIA,KAAI,MAAM,IAAIA,KAAI,KAAM;AAAA,IAClD,KAAK,EAAE,IAAIA,KAAI,KAAK,IAAIA,KAAI,MAAM,IAAIA,KAAI,KAAM;AAAA,IAChD,QAAQ,CAAC,QAAQ;AAAA,IACjB,SAAS,CAAC,EAAE,IAAI,IAAI,GAAE,MAAOA,KAAI,QAAQ,EAAE,KAAKA,KAAI,QAAQ,EAAE,KAAKA,KAAI,QAAQ,EAAE;AAAA,IACjF,KAAK,CAAC,EAAE,IAAI,IAAI,GAAE,MAAOA,KAAI,IAAI,EAAE,KAAKA,KAAI,IAAI,EAAE,KAAKA,KAAI,IAAI,EAAE;AAAA,IACjE,KAAK,CAAC,EAAE,IAAI,IAAI,GAAE,OAAQ,EAAE,IAAIA,KAAI,IAAI,EAAE,GAAG,IAAIA,KAAI,IAAI,EAAE,GAAG,IAAIA,KAAI,IAAI,EAAE;IAC5E,KAAK,CAAC,EAAE,IAAI,IAAI,GAAI,GAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAI,MAAKA,KAAI,IAAI,IAAI,EAAE,KAAKA,KAAI,IAAI,IAAI,EAAE,KAAKA,KAAI,IAAI,IAAI,EAAE;AAAA,IACzG,MAAM;AAAA;AAAA,IAEN,KAAK,CAAC,KAAK,QAAQC,KAAI,IAAI,KAAK,OAAO,QAAQ,WAAWjB,IAAG,IAAIA,IAAG,OAAO,GAAG,CAAC,IAAIiB,KAAI,IAAI,GAAG,CAAC;AAAA,IAC/F,KAAK,CAAC,KAAK,UAAUS,MAAUT,MAAK,KAAK,KAAK;AAAA,IAC9C,aAAa,CAAC,SAASU,cAAkBV,MAAK,IAAI;AAAA;AAAA,IAElD,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA;AAAA,IAEL,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,KAAK,CAAC,EAAE,IAAI,IAAI,GAAE,MAAO;AACrB,UAAI,KAAKD,KAAI,IAAIA,KAAI,IAAI,EAAE,GAAGA,KAAI,gBAAgBA,KAAI,IAAI,IAAI,EAAE,CAAC,CAAC;AAClE,UAAI,KAAKA,KAAI,IAAIA,KAAI,gBAAgBA,KAAI,IAAI,EAAE,CAAC,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AAClE,UAAI,KAAKA,KAAI,IAAIA,KAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AAE7C,UAAI,KAAKA,KAAI,IAAIA,KAAI,IAAIA,KAAI,gBAAgBA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,CAAC,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,CAAC;AACzG,aAAO,EAAE,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,IAAIA,KAAI,IAAI,IAAI,EAAE,EAAG;AAAA,IAC3E;AAAA;AAAA,IAED,WAAW,CAAC,MAAM;AACd,UAAI,EAAE,WAAWC,KAAI;AACjB,cAAM,IAAI,MAAM,8BAA8B,EAAE,MAAM;AAC1D,aAAO;AAAA,QACH,IAAID,KAAI,UAAU,EAAE,SAAS,GAAGA,KAAI,KAAK,CAAC;AAAA,QAC1C,IAAIA,KAAI,UAAU,EAAE,SAASA,KAAI,OAAO,IAAIA,KAAI,KAAK,CAAC;AAAA,QACtD,IAAIA,KAAI,UAAU,EAAE,SAAS,IAAIA,KAAI,KAAK,CAAC;AAAA,MAC9C;AAAA,IACJ;AAAA,IACD,SAAS,CAAC,EAAE,IAAI,IAAI,GAAI,MAAKpB,cAAYoB,KAAI,QAAQ,EAAE,GAAGA,KAAI,QAAQ,EAAE,GAAGA,KAAI,QAAQ,EAAE,CAAC;AAAA,IAC1F,MAAM,CAAC,EAAE,IAAI,IAAI,GAAI,GAAE,EAAE,IAAI,IAAI,IAAI,IAAI,IAAI,GAAE,GAAI,OAAO;AAAA,MACtD,IAAIA,KAAI,KAAK,IAAI,IAAI,CAAC;AAAA,MACtB,IAAIA,KAAI,KAAK,IAAI,IAAI,CAAC;AAAA,MACtB,IAAIA,KAAI,KAAK,IAAI,IAAI,CAAC;AAAA,IAClC;AAAA,IACQ,YAAY,CAACrC,OAAM;AACf,UAAI,CAAC,MAAM,QAAQA,EAAC,KAAKA,GAAE,WAAW;AAClC,cAAM,IAAI,MAAM,mBAAmB;AACvC,aAAO;AAAA,QACH,IAAIqC,KAAI,aAAarC,GAAE,MAAM,GAAG,CAAC,CAAC;AAAA,QAClC,IAAIqC,KAAI,aAAarC,GAAE,MAAM,GAAG,CAAC,CAAC;AAAA,QAClC,IAAIqC,KAAI,aAAarC,GAAE,MAAM,GAAG,CAAC,CAAC;AAAA,MACrC;AAAA,IACJ;AAAA,IACD,cAAc,CAAC,EAAE,IAAI,IAAI,GAAE,GAAI,WAAW;AAAA,MACtC,IAAIqC,KAAI,aAAa,IAAI,KAAK;AAAA,MAC9B,IAAIA,KAAI,IAAIA,KAAI,aAAa,IAAI,KAAK,GAAG,6BAA6B,QAAQ,CAAC,CAAC;AAAA,MAChF,IAAIA,KAAI,IAAIA,KAAI,aAAa,IAAI,KAAK,GAAG,6BAA6B,QAAQ,CAAC,CAAC;AAAA,IAC5F;AAAA,IACQ,UAAU,CAAC,EAAE,IAAI,IAAI,GAAE,GAAI,SAAS;AAAA,MAChC,IAAIA,KAAI,IAAI,IAAI,GAAG;AAAA,MACnB,IAAIA,KAAI,IAAI,IAAI,GAAG;AAAA,MACnB,IAAIA,KAAI,IAAI,IAAI,GAAG;AAAA,IAC/B;AAAA,IACQ,iBAAiB,CAAC,EAAE,IAAI,IAAI,GAAE,OAAQ,EAAE,IAAIA,KAAI,gBAAgB,EAAE,GAAG,IAAI,IAAI,IAAI;;IAEjF,MAAM,CAAC,EAAE,IAAI,IAAI,GAAE,GAAI,QAAQ;AAAA,MAC3B,IAAIA,KAAI,gBAAgBA,KAAI,IAAI,IAAI,EAAE,CAAC;AAAA,MACvC,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,MAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,IAC9B;AAAA;AAAA,IAEQ,MAAM,EAAE,IAAI,IAAI,GAAI,GAAE,IAAI,IAAI;AAC1B,UAAI,KAAKA,KAAI,IAAI,IAAI,EAAE;AACvB,UAAI,KAAKA,KAAI,IAAI,IAAI,EAAE;AACvB,aAAO;AAAA;AAAA,QAEH,IAAIA,KAAI,IAAIA,KAAI,gBAAgBA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE;AAAA;AAAA,QAE9E,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE;AAAA;AAAA,QAEtE,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AAAA,MAC5D;AAAA,IACJ;AAAA,EACJ;AAED,QAAM,8BAA8B,0BAA0BA,MAAK,eAAehB,IAAG,OAAO,IAAI,GAAG,CAAC,EAAE,CAAC;AACvG,QAAM,UAAU,CAAC,EAAE,IAAI,GAAE,GAAI,EAAE,IAAI,IAAI,IAAI,UAAU;AAAA,IACjD,IAAIiB,KAAI,IAAI,IAAI,EAAE;AAAA,IAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,EAC1B;AACI,QAAM,eAAe,CAAC,EAAE,IAAI,GAAE,GAAI,EAAE,IAAI,IAAI,IAAI,UAAU;AAAA,IACtD,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,IAClB,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,EAC1B;AACI,QAAM,eAAe,CAAC,EAAE,IAAI,GAAE,GAAI,QAAQ;AACtC,QAAI,OAAO,QAAQ;AACf,aAAO,EAAE,IAAIA,KAAI,IAAI,IAAI,GAAG,GAAG,IAAIA,KAAI,IAAI,IAAI,GAAG,EAAG;AACzD,QAAI,EAAE,IAAI,IAAI,IAAI,GAAI,IAAG;AACzB,QAAI,KAAKA,KAAI,IAAI,IAAI,EAAE;AACvB,QAAI,KAAKA,KAAI,IAAI,IAAI,EAAE;AACvB,WAAO;AAAA,MACH,IAAIA,KAAI,IAAI,IAAIA,KAAI,gBAAgB,EAAE,CAAC;AAAA;AAAA;AAAA,MAEvC,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,IAAI,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC;AAAA,IACzE;AAAA,EACJ;AACD,QAAM,aAAa,CAAC,EAAE,IAAI,GAAE,MAAO;AAC/B,QAAI,KAAKA,KAAI,IAAI,IAAI,EAAE;AACvB,WAAO;AAAA;AAAA,MAEH,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,gBAAgB,EAAE,GAAG,EAAE,GAAGA,KAAI,IAAI,IAAI,EAAE,CAAC,GAAG,EAAE,GAAGA,KAAI,gBAAgB,EAAE,CAAC;AAAA,MAChH,IAAIA,KAAI,IAAI,IAAI,EAAE;AAAA,IAC9B;AAAA,EACK;AACD,WAASW,WAAU,GAAG,GAAG;AACrB,UAAM,KAAKZ,KAAI,IAAI,CAAC;AACpB,UAAM,KAAKA,KAAI,IAAI,CAAC;AACpB,WAAO;AAAA,MACH,OAAOA,KAAI,IAAIA,KAAI,gBAAgB,EAAE,GAAG,EAAE;AAAA;AAAA,MAC1C,QAAQA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE;AAAA;AAAA,IAC1D;AAAA,EACT;AACI,QAAME,QAAO;AAAA,IACT,OAAOF,KAAI;AAAA;AAAA,IACX,MAAMC,KAAI;AAAA,IACV,MAAM,IAAID,KAAI;AAAA,IACd,OAAO,IAAIA,KAAI;AAAA,IACf,MAAM,QAAQ,IAAIA,KAAI,IAAI;AAAA,IAC1B,MAAM,EAAE,IAAIC,KAAI,MAAM,IAAIA,KAAI,KAAM;AAAA,IACpC,KAAK,EAAE,IAAIA,KAAI,KAAK,IAAIA,KAAI,KAAM;AAAA,IAClC,QAAQ,CAAC,QAAQ;AAAA,IACjB,SAAS,CAAC,EAAE,IAAI,SAASA,KAAI,QAAQ,EAAE,KAAKA,KAAI,QAAQ,EAAE;AAAA,IAC1D,KAAK,CAAC,EAAE,IAAI,SAASA,KAAI,IAAI,EAAE,KAAKA,KAAI,IAAI,EAAE;AAAA,IAC9C,KAAK,CAAC,EAAE,IAAI,GAAE,OAAQ,EAAE,IAAIA,KAAI,IAAI,EAAE,GAAG,IAAIA,KAAI,IAAI,EAAE,EAAC;AAAA,IACxD,KAAK,CAAC,EAAE,IAAI,GAAI,GAAE,EAAE,IAAI,IAAI,IAAI,GAAI,MAAKA,KAAI,IAAI,IAAI,EAAE,KAAKA,KAAI,IAAI,IAAI,EAAE;AAAA,IAC1E,MAAM;AAAA,IACN,KAAK,CAAC,EAAE,IAAI,SAAS;AACjB,UAAItC,KAAIsC,KAAI,IAAIA,KAAI,IAAIA,KAAI,IAAI,EAAE,GAAGA,KAAI,gBAAgBA,KAAI,IAAI,EAAE,CAAC,CAAC,CAAC;AACtE,aAAO,EAAE,IAAIA,KAAI,IAAI,IAAItC,EAAC,GAAG,IAAIsC,KAAI,IAAIA,KAAI,IAAI,IAAItC,EAAC,CAAC;IAC1D;AAAA,IACD,KAAK,CAAC,KAAK,QAAQuC,MAAK,IAAI,KAAK,OAAO,QAAQ,WAAWlB,IAAG,IAAIA,IAAG,OAAO,GAAG,CAAC,IAAIkB,MAAK,IAAI,GAAG,CAAC;AAAA,IACjG,KAAK,CAAC,KAAK,UAAUQ,MAAUR,OAAM,KAAK,KAAK;AAAA,IAC/C,aAAa,CAAC,SAASS,cAAkBT,OAAM,IAAI;AAAA;AAAA,IAEnD,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA;AAAA,IAEL,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA;AAAA,IAEN,WAAW,CAAC,MAAM;AACd,UAAI,EAAE,WAAWA,MAAK;AAClB,cAAM,IAAI,MAAM,8BAA8B,EAAE,MAAM;AAC1D,aAAO;AAAA,QACH,IAAID,KAAI,UAAU,EAAE,SAAS,GAAGA,KAAI,KAAK,CAAC;AAAA,QAC1C,IAAIA,KAAI,UAAU,EAAE,SAASA,KAAI,KAAK,CAAC;AAAA,MAC1C;AAAA,IACJ;AAAA,IACD,SAAS,CAAC,EAAE,IAAI,GAAE,MAAOrB,cAAYqB,KAAI,QAAQ,EAAE,GAAGA,KAAI,QAAQ,EAAE,CAAC;AAAA,IACrE,MAAM,CAAC,EAAE,IAAI,MAAM,EAAE,IAAI,IAAI,IAAI,GAAI,GAAE,OAAO;AAAA,MAC1C,IAAIA,KAAI,KAAK,IAAI,IAAI,CAAC;AAAA,MACtB,IAAIA,KAAI,KAAK,IAAI,IAAI,CAAC;AAAA,IAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQQ,eAAe,CAACtC,QAAO;AAAA,MACnB,IAAIsC,KAAI,WAAWtC,GAAE,MAAM,GAAG,CAAC,CAAC;AAAA,MAChC,IAAIsC,KAAI,WAAWtC,GAAE,MAAM,GAAG,EAAE,CAAC;AAAA,IAC7C;AAAA;AAAA,IAEQ,aAAa,KAAK,OAAO;AACrB,YAAM,EAAE,IAAI,IAAI,GAAI,IAAGsC,KAAI,aAAa,IAAI,IAAI,KAAK;AACrD,YAAM,QAAQ,4BAA4B,QAAQ,EAAE;AACpD,aAAO;AAAA,QACH,IAAIA,KAAI,aAAa,IAAI,IAAI,KAAK;AAAA,QAClC,IAAIA,KAAI,OAAO;AAAA,UACX,IAAID,KAAI,IAAI,IAAI,KAAK;AAAA,UACrB,IAAIA,KAAI,IAAI,IAAI,KAAK;AAAA,UACrB,IAAIA,KAAI,IAAI,IAAI,KAAK;AAAA,QACzC,CAAiB;AAAA,MACJ;AAAA,IACJ;AAAA,IACD,UAAU,CAAC,EAAE,IAAI,GAAE,GAAI,SAAS;AAAA,MAC5B,IAAIC,KAAI,SAAS,IAAI,GAAG;AAAA,MACxB,IAAIA,KAAI,SAAS,IAAI,GAAG;AAAA,IACpC;AAAA,IACQ,WAAW,CAAC,EAAE,IAAI,UAAU,EAAE,IAAI,IAAIA,KAAI,IAAI,EAAE,EAAC;AAAA;AAAA,IAEjD,QAAQ,CAAC,EAAE,IAAI,GAAI,GAAE,IAAI,IAAI,OAAO;AAChC,UAAI,KAAKA,KAAI,MAAM,IAAI,IAAI,EAAE;AAC7B,UAAI,KAAKA,KAAI,KAAK,IAAI,EAAE;AACxB,aAAO;AAAA,QACH,IAAIA,KAAI,IAAIA,KAAI,gBAAgB,EAAE,GAAG,EAAE;AAAA;AAAA;AAAA,QAEvC,IAAIA,KAAI,IAAIA,KAAI,IAAIA,KAAI,MAAMA,KAAI,IAAI,IAAI,EAAE,GAAG,IAAID,KAAI,IAAI,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE;AAAA,MAC/E;AAAA,IACJ;AAAA,IACD,QAAQ,CAAC,EAAE,IAAI,GAAI,GAAE,IAAI,IAAI,OAAO;AAChC,YAAM,IAAIC,KAAI,OAAO;AAAA,QACjB,IAAID,KAAI,IAAI,GAAG,IAAI,EAAE;AAAA,QACrB,IAAIA,KAAI,IAAI,GAAG,IAAI,EAAE;AAAA,QACrB,IAAIA,KAAI,IAAI,GAAG,IAAI,EAAE;AAAA,MACrC,CAAa;AACD,YAAM,IAAIC,KAAI,MAAM,IAAI,IAAI,EAAE;AAC9B,YAAM,IAAIA,KAAI,MAAMA,KAAI,IAAI,IAAI,EAAE,GAAGD,KAAI,IAAI,IAAI,EAAE,GAAG,EAAE;AACxD,aAAO;AAAA,QACH,IAAIC,KAAI,IAAIA,KAAI,gBAAgB,CAAC,GAAG,CAAC;AAAA,QACrC,IAAIA,KAAI,IAAI,GAAGA,KAAI,IAAI,GAAG,CAAC,CAAC;AAAA,MAC/B;AAAA,IACJ;AAAA;AAAA;AAAA;AAAA;AAAA,IAKD,mBAAmB,KAAK;AAAA,IACxB,gBAAgB,KAAK;AAAA;AAAA;AAAA,IAGrB,mBAAmB,KAAK;AAAA,EAC3B;AACD,SAAO,EAAE,IAAAjB,KAAI,KAAAgB,MAAK,KAAAC,MAAK,WAAAW,YAAW,MAAAV,MAAM;AAC5C;ACnbA;AAYA,MAAM,MAAM,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC;AAExF,MAAM,QAAQ,OAAO,oBAAoB;AACzC,MAAM,YAAY,OAAO,KAAK;AAE9B,MAAM,EAAE,IAAI,KAAK,KAAK,WAAW,KAAM,IAAG,QAAQ;AAAA;AAAA,EAE9C,OAAO,OAAO,oGAAoG;AAAA;AAAA;AAAA,EAGlH,gBAAgB,CAAC,KAAK,GAAG;AAAA,EACzB,WAAW,CAAC,EAAE,IAAI,SAAS;AACvB,UAAM,KAAK,GAAG,IAAI,IAAI,GAAG;AACzB,UAAM,KAAK,GAAG,IAAI,IAAI,GAAG;AAEzB,WAAO,EAAE,IAAI,GAAG,IAAI,IAAI,EAAE,GAAG,IAAI,GAAG,IAAI,IAAI,EAAE,EAAG;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,sBAAsB,CAAC,EAAE,IAAI,SAAS;AAClC,UAAM,EAAE,IAAI,MAAM,IAAI,MAAM,IAAI,KAAI,IAAK;AACzC,UAAM,EAAE,IAAI,MAAM,IAAI,MAAM,IAAI,KAAI,IAAK;AACzC,UAAM,EAAE,OAAO,IAAI,QAAQ,GAAE,IAAK,UAAU,MAAM,IAAI;AACtD,UAAM,EAAE,OAAO,IAAI,QAAQ,GAAE,IAAK,UAAU,MAAM,IAAI;AACtD,UAAM,EAAE,OAAO,IAAI,QAAQ,GAAE,IAAK,UAAU,MAAM,IAAI;AACtD,UAAM,KAAK,IAAI,gBAAgB,EAAE;AACjC,WAAO;AAAA,MACH,IAAI,IAAI,OAAO;AAAA,QACX,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE;AAAA;AAAA,QAC/C,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE;AAAA;AAAA,QAC/C,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE;AAAA,MAC/D,CAAa;AAAA;AAAA,MACD,IAAI,IAAI,OAAO;AAAA,QACX,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE;AAAA;AAAA,QAC/C,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE;AAAA;AAAA,QAC/C,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE;AAAA,MAC/D,CAAa;AAAA,IACb;AAAA,EACK;AAAA,EACD,kBAAkB,KAAKvB,IAAG;AACtB,QAAI,IAAI,KAAK;AACb,aAAS,IAAI,YAAY,GAAG,KAAK,GAAG,KAAK;AACrC,UAAI,KAAK,kBAAkB,CAAC;AAC5B,UAAI,OAAOA,IAAG,CAAC;AACX,YAAI,KAAK,IAAI,GAAG,GAAG;AAAA,IACnC;AACQ,WAAO;AAAA,EACV;AAAA;AAAA;AAAA,EAGD,uBAAuB,CAAC,QAAQ;AAC5B,UAAM,IAAI;AAEV,UAAM,KAAK,KAAK,IAAI,KAAK,aAAa,KAAK,CAAC,GAAG,GAAG;AAElD,UAAM,KAAK,KAAK,IAAI,KAAK,aAAa,IAAI,CAAC,GAAG,EAAE;AAChD,UAAM,KAAK,KAAK,UAAU,KAAK,eAAe,IAAI,CAAC,CAAC;AACpD,UAAM,KAAK,KAAK,IAAI,KAAK,UAAU,KAAK,kBAAkB,EAAE,CAAC,GAAG,EAAE;AAClE,UAAM,KAAK,KAAK,UAAU,KAAK,eAAe,IAAI,CAAC,CAAC;AACpD,UAAM,KAAK,KAAK,UAAU,KAAK,eAAe,IAAI,CAAC,CAAC;AACpD,UAAM,KAAK,KAAK,IAAI,KAAK,UAAU,KAAK,eAAe,IAAI,CAAC,CAAC,GAAG,KAAK,kBAAkB,EAAE,CAAC;AAC1F,UAAM,KAAK,KAAK,UAAU,KAAK,eAAe,IAAI,CAAC,CAAC;AACpD,UAAM,eAAe,KAAK,aAAa,KAAK,IAAI,IAAI,EAAE,GAAG,CAAC;AAC1D,UAAM,eAAe,KAAK,aAAa,KAAK,IAAI,IAAI,EAAE,GAAG,CAAC;AAC1D,UAAM,gBAAgB,KAAK,aAAa,KAAK,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC,GAAG,CAAC;AAC3E,UAAM,YAAY,KAAK,IAAI,KAAK,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC,GAAG,EAAE;AAE/D,WAAO,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,cAAc,YAAY,GAAG,aAAa,GAAG,SAAS;AAAA,EAC3F;AACL,CAAC;AAGD,MAAM,KAAK4B,MAAU,OAAO,oEAAoE,CAAC;AAIjG,MAAM,eAAe,WAAW,KAAK;AAAA;AAAA,EAEjC;AAAA,IACI;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,EACJ;AAAA;AAAA,EAED;AAAA,IACI;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD,CAAC,OAAO,KAAK;AAAA;AAAA,EAChB;AAAA;AAAA,EAED;AAAA,IACI;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,EACJ;AAAA;AAAA,EAED;AAAA,IACI;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD;AAAA,MACI;AAAA,MACA;AAAA,IACH;AAAA,IACD,CAAC,OAAO,KAAK;AAAA;AAAA,EAChB;AACL,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,IAAI,aAAa,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;AAEjE,MAAM,eAAe,WAAW,IAAI;AAAA;AAAA,EAEhC;AAAA,IACI;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACH;AAAA;AAAA,EAED;AAAA,IACI;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,EACH;AAAA;AAAA,EAED;AAAA,IACI;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACH;AAAA;AAAA,EAED;AAAA,IACI;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,EACH;AACL,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;AAErC,MAAM,SAAS,oBAAoB,KAAK;AAAA,EACpC,GAAG,IAAI,OAAO,EAAE,IAAI,GAAG,OAAO,GAAG,GAAG,IAAI,GAAG,OAAO,OAAO,GAAG,CAAC,EAAC,CAAE;AAAA;AAAA,EAChE,GAAG,IAAI,OAAO,EAAE,IAAI,GAAG,OAAO,OAAO,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,OAAO,IAAI,CAAC,GAAG;AAAA;AAAA,EAC1E,GAAG,IAAI,OAAO,EAAE,IAAI,GAAG,OAAO,OAAO,EAAE,CAAC,GAAG,IAAI,GAAG,OAAO,OAAO,EAAE,CAAC,GAAG;AAAA;AAC1E,CAAC;AAED,MAAM,SAAS,oBAAoB,IAAI;AAAA,EACnC,GAAG,GAAG,OAAO,OAAO,kGAAkG,CAAC;AAAA,EACvH,GAAG,GAAG,OAAO,OAAO,oGAAoG,CAAC;AAAA,EACzH,GAAG,GAAG,OAAO,OAAO,EAAE,CAAC;AAC3B,CAAC;AAGD,MAAM,EAAE,OAAO,OAAM,IAAK,aAAa,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,UAAU,CAAC;AAWhF,MAAM,cAAc,OAAO,OAAO;AAAA;AAAA;AAAA;AAAA,EAI9B,KAAK;AAAA,EACL,WAAW;AAAA;AAAA;AAAA,EAGX,GAAG,GAAG;AAAA;AAAA;AAAA,EAGN,GAAG;AAAA;AAAA;AAAA,EAGH,GAAG;AAAA;AAAA;AAAA,EAGH,QAAQ;AAAA;AAAA;AAAA;AAAA,EAIR,MAAM;AACV,CAAC;AAID,MAAM,kBAAkB,QAAQ,GAAG,QAAQ,GAAG,GAAG,EAAE,UAAU,MAAM,YAAY,KAAM,CAAA;AACrF,SAAS,UAAU,OAAO;AAEtB,UAAQ,MAAM,MAAO;AACrB,QAAM,OAAO,MAAM,CAAC,IAAI;AACxB,QAAM,aAAa,CAAC,EAAG,QAAQ,IAAK;AACpC,QAAM,WAAW,CAAC,EAAG,QAAQ,IAAK;AAClC,QAAM,OAAO,CAAC,EAAG,QAAQ,IAAK;AAC9B,QAAM,CAAC,KAAK;AACZ,SAAO,EAAE,YAAY,UAAU,MAAM,OAAO,MAAO;AACvD;AACA,SAAS,QAAQ,OAAO,MAAM;AAC1B,MAAI,MAAM,CAAC,IAAI;AACX,UAAM,IAAI,MAAM,yBAAyB;AAC7C,MAAI,KAAK;AACL,UAAM,CAAC,KAAK;AAChB,MAAI,KAAK;AACL,UAAM,CAAC,KAAK;AAChB,MAAI,KAAK;AACL,UAAM,CAAC,KAAK;AAChB,SAAO;AACX;AACA,SAAS,sBAAsB,OAAO;AAClC,QAAM,eAAgB;AACtB,QAAM,SAAS,MAAM,OAAO,UAAU,GAAG,gBAAgB,IAAI;AAC7D,QAAM,EAAE,GAAG,GAAA1C,OAAM,MAAM,SAAU;AACjC,MAAI;AACA,WAAO,gBAAgB,MAAO;AAClC,QAAM,IAAI,GAAG;AACb,QAAM,OAAO,QAASA,KAAI,MAAO,CAAC;AAClC,SAAO,QAAQ,gBAAgB,GAAG,GAAG,KAAK,GAAG,EAAE,YAAY,MAAM,MAAM;AAC3E;AACA,SAAS,sBAAsB,OAAO;AAElC,QAAM,eAAgB;AACtB,QAAM,MAAM,GAAG;AACf,MAAI,MAAM,OAAO,UAAU,GAAG,gBAAgB,IAAI;AAC9C,WAAOgD,cAAQ,iBAAiB,gBAAgB,KAAK,GAAG,CAAC;AAC7D,QAAM,EAAE,GAAG,GAAAhD,OAAM,MAAM,SAAU;AACjC,QAAM,EAAE,IAAI,IAAI,IAAI,GAAE,IAAK,IAAI,KAAK,CAAC;AACrC,QAAM,EAAE,IAAI,IAAI,IAAI,GAAE,IAAK,IAAI,KAAKA,EAAC;AACrC,QAAM,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK;AACvC,QAAM,OAAO,QAAS,MAAM,GAAG,QAAS,GAAG;AAC3C,QAAM,KAAK;AACX,SAAOgD,cAAQ,QAAQ,gBAAgB,IAAI,GAAG,GAAG,EAAE,MAAM,YAAY,KAAI,CAAE,GAAG,gBAAgB,IAAI,GAAG,CAAC;AAC1G;AAYO,MAAM,YAAY,IAAI;AAAA;AAAA,EAEzB,QAAQ;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACH;AAAA;AAAA;AAAA,EAGD,IAAI;AAAA,IACA;AAAA;AAAA,IAEA,GAAG,OAAO,oCAAoC;AAAA;AAAA;AAAA;AAAA,IAI9C,IAAI,OAAO,oGAAoG;AAAA,IAC/G,IAAI,OAAO,oGAAoG;AAAA,IAC/G,GAAG,GAAG;AAAA,IACN,GAAG;AAAA,IACH,aAAa,EAAE,GAAG,aAAa,GAAG,GAAG,KAAK,8CAA+C;AAAA,IACzF,gBAAgB;AAAA,IAChB,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA,IAKpB,eAAe,CAAC,GAAG,UAAU;AAEzB,YAAM,uBAAuB,OAAO,oFAAoF;AACxH,YAAM,MAAM,IAAI,EAAE,GAAG,IAAI,MAAM,IAAI,oBAAoB,GAAG,MAAM,IAAI,MAAM,EAAE;AAE5E,YAAM,KAAK,MAAM,eAAe,KAAK,EAAE,OAAM;AAC7C,YAAM,MAAM,GAAG,eAAe,KAAK;AACnC,aAAO,IAAI,OAAO,GAAG;AAAA,IAYxB;AAAA;AAAA;AAAA,IAGD,eAAe,CAAC,IAAI,UAAU;AAE1B,aAAO,MAAM,eAAe,KAAK,EAAE,IAAI,KAAK;AAAA,IAC/C;AAAA,IACD,YAAY,CAAC,YAAY;AACrB,YAAM,EAAE,GAAG,GAAAhD,GAAC,IAAK,OAAO,GAAG,OAAO,QAAQ,CAAC,CAAC,CAAC;AAC7C,aAAO,aAAa,GAAGA,EAAC;AAAA,IAC3B;AAAA,IACD,WAAW,CAAC,UAAU;AAClB,YAAM,EAAE,YAAY,UAAU,MAAM,MAAO,IAAG,UAAU,KAAK;AAC7D,UAAI,MAAM,WAAW,MAAM,YAAY;AAEnC,cAAM,IAAI,GAAG;AACb,cAAM,kBAAkB,gBAAgB,KAAK;AAE7C,cAAM,IAAI,GAAG,OAAO,kBAAkB,GAAG,IAAI;AAC7C,YAAI,UAAU;AACV,cAAI,MAAM;AACN,kBAAM,IAAI,MAAM,4CAA4C;AAChE,iBAAO,EAAE,GAAG,KAAK,GAAG,IAAK;AAAA,QAC7C;AACgB,cAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,OAAO,UAAU,OAAO,GAAG,CAAC;AACpE,YAAIA,KAAI,GAAG,KAAK,KAAK;AACrB,YAAI,CAACA;AACD,gBAAM,IAAI,MAAM,6BAA6B;AACjD,YAAKA,KAAI,MAAO,MAAM,OAAO,IAAI;AAC7B,UAAAA,KAAI,GAAG,IAAIA,EAAC;AAChB,eAAO,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,OAAOA,EAAC,EAAG;AAAA,MAC3D,WACqB,MAAM,WAAW,MAAM,CAAC,YAAY;AAEzC,cAAM,IAAI,gBAAgB,MAAM,SAAS,GAAG,GAAG,KAAK,CAAC;AACrD,cAAMA,KAAI,gBAAgB,MAAM,SAAS,GAAG,KAAK,CAAC;AAClD,YAAI,UAAU;AACV,cAAI,MAAM,OAAOA,OAAM;AACnB,kBAAM,IAAI,MAAM,iCAAiC;AACrD,iBAAO,UAAU,GAAG,gBAAgB,KAAK,SAAU;AAAA,QACvE;AACgB,eAAO,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,OAAOA,EAAC,EAAG;AAAA,MAC3D,OACiB;AACD,cAAM,IAAI,MAAM,wCAAwC;AAAA,MACxE;AAAA,IACS;AAAA,IACD,SAAS,CAAC,GAAG,OAAO,iBAAiB;AACjC,YAAM,SAAS,MAAM,OAAO,EAAE,IAAI;AAClC,YAAM,EAAE,GAAG,GAAAA,OAAM,MAAM,SAAU;AACjC,UAAI,cAAc;AACd,YAAI;AACA,iBAAO,gBAAgB,MAAO;AAClC,cAAM,IAAI,GAAG;AACb,cAAM,OAAO,QAASA,KAAI,MAAO,CAAC;AAClC,eAAO,QAAQ,gBAAgB,GAAG,GAAG,KAAK,GAAG,EAAE,YAAY,MAAM,MAAM;AAAA,MACvF,OACiB;AACD,YAAI,QAAQ;AAER,gBAAMiD,KAAID,cAAQ,IAAI,WAAW,CAAC,EAAI,CAAC,GAAG,IAAI,WAAW,IAAI,GAAG,QAAQ,CAAC,CAAC;AAC1E,iBAAOC;AAAA,QAC3B,OACqB;AACD,iBAAOD,cAAQ,gBAAgB,GAAG,GAAG,KAAK,GAAG,gBAAgBhD,IAAG,GAAG,KAAK,CAAC;AAAA,QAC7F;AAAA,MACA;AAAA,IACS;AAAA,IACD,gBAAgB;AAAA,MACZ,QAAQ,KAAK;AACT,cAAM,EAAE,UAAU,MAAM,MAAO,IAAG,UAAU,YAAY,gBAAgB,KAAK,EAAE,CAAC;AAChF,cAAM,IAAI,GAAG;AACb,cAAM,kBAAkB,gBAAgB,KAAK;AAE7C,YAAI;AACA,iBAAO,UAAU,GAAG,gBAAgB;AACxC,cAAM,IAAI,GAAG,OAAO,kBAAkB,GAAG,IAAI;AAC7C,cAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,OAAO,UAAU,OAAO,GAAG,CAAC;AACpE,YAAIA,KAAI,GAAG,KAAK,KAAK;AACrB,YAAI,CAACA;AACD,gBAAM,IAAI,MAAM,6BAA6B;AACjD,cAAM,QAAQ,OAAO,IAAI;AACzB,YAAKA,KAAI,MAAO,MAAM;AAClB,UAAAA,KAAI,GAAG,IAAIA,EAAC;AAChB,cAAM,QAAQ,UAAU,GAAG,gBAAgB,WAAW,EAAE,GAAG,GAAAA,IAAG;AAC9D,cAAM,eAAgB;AACtB,eAAO;AAAA,MACV;AAAA,MACD,WAAW,OAAO;AACd,eAAO,sBAAsB,KAAK;AAAA,MACrC;AAAA,MACD,MAAM,OAAO;AACT,eAAO,WAAW,sBAAsB,KAAK,CAAC;AAAA,MACjD;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA,EAKD,IAAI;AAAA,IACA,IAAI;AAAA;AAAA,IAEJ,GAAG,OAAO,mIAAmI;AAAA,IAC7I,IAAI,IAAI,aAAa;AAAA,MACjB,OAAO,oGAAoG;AAAA,MAC3G,OAAO,oGAAoG;AAAA,IACvH,CAAS;AAAA;AAAA;AAAA;AAAA,IAID,IAAI,IAAI,aAAa;AAAA,MACjB,OAAO,oGAAoG;AAAA,MAC3G,OAAO,oGAAoG;AAAA,IACvH,CAAS;AAAA,IACD,GAAG,IAAI;AAAA,IACP,GAAG,IAAI,aAAa,CAAC,KAAK,GAAG,CAAC;AAAA,IAC9B,MAAM,OAAO,mKAAmK;AAAA,IAChL,aAAa,EAAE,GAAG,YAAa;AAAA,IAC/B,gBAAgB;AAAA,IAChB,oBAAoB;AAAA,IACpB,YAAY,CAAC,YAAY;AACrB,YAAM,EAAE,GAAG,GAAAA,GAAG,IAAG,OAAO,IAAI,aAAa,OAAO,CAAC;AACjD,aAAO,aAAa,GAAGA,EAAC;AAAA,IAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,IAKD,eAAe,CAAC,GAAG,MAAM;AACrB,aAAO,EAAE,eAAe,KAAK,EAAE,OAAM,EAAG,OAAO,MAAM,GAAG,CAAC,CAAC;AAAA,IAI7D;AAAA;AAAA;AAAA;AAAA;AAAA,IAKD,eAAe,CAAC,GAAG,MAAM;AACrB,YAAM,IAAI;AACV,UAAI,KAAK,EAAE,eAAe,CAAC,EAAE,OAAM;AACnC,UAAI,KAAK,MAAM,GAAG,CAAC;AACnB,UAAI,KAAK,EAAE;AACX,WAAK,OAAO,GAAG,EAAE;AACjB,WAAK,GAAG,SAAS,EAAE;AACnB,WAAK,GAAG,IAAI,EAAE;AACd,WAAK,GAAG,eAAe,CAAC,EAAE,OAAM;AAChC,WAAK,GAAG,IAAI,EAAE;AACd,WAAK,GAAG,SAAS,EAAE;AACnB,YAAM,IAAI,GAAG,SAAS,CAAC;AACvB,aAAO;AAAA,IACV;AAAA,IACD,WAAW,CAAC,UAAU;AAClB,YAAM,EAAE,YAAY,UAAU,MAAM,MAAO,IAAG,UAAU,KAAK;AAC7D,UAAK,CAAC,cAAc,CAAC,YAAY;AAAA,MAC5B,CAAC,cAAc,YAAY;AAAA,MAC3B,QAAQ,YAAY,YACvB;AACE,cAAM,IAAI,MAAM,6BAA6B,MAAM,CAAC,IAAI,IAAI;AAAA,MAC5E;AACY,YAAM,IAAI,GAAG;AACb,YAAM,MAAM,CAAC,GAAG,MAAM,OAAO,gBAAgB,EAAE,MAAM,MAAM,EAAE,CAAC;AAC9D,UAAI,MAAM,WAAW,MAAM,YAAY;AACnC,cAAM,IAAI,UAAU,OAAO;AAC3B,cAAM,IAAI,GAAG;AACb,YAAI,UAAU;AAEV,cAAI,MAAM,OAAO,CAACL,IAAG,MAAOA,OAAM,IAAI,IAAI,IAAI,GAAI,CAAC,IAAI,GAAG;AACtD,kBAAM,IAAI,MAAM,6BAA6B;AAAA,UACrE;AACoB,iBAAO,EAAE,GAAG,IAAI,MAAM,GAAG,IAAI,KAAM;AAAA,QACvD;AACgB,cAAM,MAAM,IAAI,OAAO,GAAG,CAAC;AAC3B,cAAM,MAAM,IAAI,OAAO,GAAG,IAAI,CAAC;AAC/B,cAAM,IAAI,IAAI,OAAO,EAAE,IAAI,GAAG,OAAO,GAAG,GAAG,IAAI,GAAG,OAAO,GAAG,EAAC,CAAE;AAC/D,cAAM,QAAQ,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,CAAC;AACxC,YAAIK,KAAI,IAAI,KAAK,KAAK;AACtB,cAAM,QAAQA,GAAE,OAAO,MAAOA,GAAE,KAAK,MAAO,IAAKA,GAAE,KAAK,MAAO,IAAI,MAAM;AACzE,QAAAA,KAAI,QAAQ,QAAQ,IAAIA,KAAI,IAAI,IAAIA,EAAC;AACrC,eAAO,EAAE,GAAG,GAAAA,GAAG;AAAA,MAC/B,WACqB,MAAM,WAAW,OAAO,CAAC,YAAY;AAC1C,YAAI,UAAU;AACV,cAAI,MAAM,OAAO,CAACL,IAAG,MAAOA,OAAM,IAAI,IAAI,IAAI,GAAI,CAAC,IAAI,GAAG;AACtD,kBAAM,IAAI,MAAM,+BAA+B;AAAA,UACvE;AACoB,iBAAO,EAAE,GAAG,IAAI,MAAM,GAAG,IAAI,KAAM;AAAA,QACvD;AACgB,cAAM,KAAK,IAAI,OAAO,GAAG,CAAC;AAC1B,cAAM,KAAK,IAAI,OAAO,GAAG,IAAI,CAAC;AAC9B,cAAM,KAAK,IAAI,OAAO,IAAI,GAAG,IAAI,CAAC;AAClC,cAAM,KAAK,IAAI,OAAO,IAAI,GAAG,IAAI,CAAC;AAClC,eAAO,EAAE,GAAG,IAAI,aAAa,CAAC,IAAI,EAAE,CAAC,GAAG,GAAG,IAAI,aAAa,CAAC,IAAI,EAAE,CAAC,EAAG;AAAA,MACvF,OACiB;AACD,cAAM,IAAI,MAAM,yCAAyC;AAAA,MACzE;AAAA,IACS;AAAA,IACD,SAAS,CAAC,GAAG,OAAO,iBAAiB;AACjC,YAAM,EAAE,OAAO,KAAK,OAAO,EAAG,IAAG;AACjC,YAAM,SAAS,MAAM,OAAO,EAAE,IAAI;AAClC,YAAM,EAAE,GAAG,GAAAK,OAAM,MAAM,SAAU;AACjC,UAAI,cAAc;AACd,YAAI;AACA,iBAAOgD,cAAQ,iBAAiB,gBAAgB,KAAK,GAAG,CAAC;AAC7D,cAAM,OAAO,QAAQhD,GAAE,OAAO,MAAOA,GAAE,KAAK,MAAO,IAAKA,GAAE,KAAK,MAAO,CAAC;AACvE,eAAOgD,cAAQ,QAAQ,gBAAgB,EAAE,IAAI,GAAG,GAAG,EAAE,YAAY,MAAM,MAAM,MAAM,GAAG,gBAAgB,EAAE,IAAI,GAAG,CAAC;AAAA,MAChI,OACiB;AACD,YAAI;AACA,iBAAOA,cAAQ,IAAI,WAAW,CAAC,EAAI,CAAC,GAAG,IAAI,WAAW,IAAI,MAAM,CAAC,CAAC;AACtE,cAAM,EAAE,IAAI,IAAI,IAAI,GAAE,IAAK,IAAI,KAAK,CAAC;AACrC,cAAM,EAAE,IAAI,IAAI,IAAI,GAAE,IAAK,IAAI,KAAKhD,EAAC;AACrC,eAAOgD,cAAQ,gBAAgB,IAAI,GAAG,GAAG,gBAAgB,IAAI,GAAG,GAAG,gBAAgB,IAAI,GAAG,GAAG,gBAAgB,IAAI,GAAG,CAAC;AAAA,MACrI;AAAA,IACS;AAAA,IACD,WAAW;AAAA;AAAA,MAEP,QAAQ,KAAK;AACT,cAAM,EAAE,UAAU,MAAM,MAAK,IAAK,UAAU,YAAY,gBAAgB,GAAG,CAAC;AAC5E,cAAM,IAAI,GAAG;AACb,cAAM,OAAO,MAAM,SAAS;AAC5B,YAAI,SAAS,MAAM,SAAS;AACxB,gBAAM,IAAI,MAAM,wDAAwD;AAC5E,cAAM,KAAK,gBAAgB,MAAM,MAAM,GAAG,IAAI,CAAC;AAC/C,cAAM,KAAK,gBAAgB,MAAM,MAAM,IAAI,CAAC;AAE5C,YAAI;AACA,iBAAO,UAAU,GAAG,gBAAgB;AACxC,cAAM,KAAK,GAAG,OAAO,KAAK,GAAG,IAAI;AACjC,cAAM,KAAK,GAAG,OAAO,EAAE;AACvB,cAAM,IAAI,IAAI,OAAO,EAAE,IAAI,IAAI,IAAI,IAAI;AACvC,cAAM,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,GAAG,GAAG,UAAU,OAAO,GAAG;AAExD,YAAIhD,KAAI,IAAI,KAAK,EAAE;AACnB,YAAI,CAACA;AACD,gBAAM,IAAI,MAAM,8BAA8B;AAGlD,cAAM,EAAE,IAAI,IAAI,IAAI,GAAE,IAAK,IAAI,KAAKA,EAAC;AACrC,cAAM,SAAS,OAAO,IAAI;AAC1B,cAAM,YAAY,KAAK,OAAQ,KAAK,MAAO,MAAM;AACjD,cAAM,SAAS,OAAO,OAAQ,KAAK,MAAO,MAAM;AAChD,YAAI,aAAa;AACb,UAAAA,KAAI,IAAI,IAAIA,EAAC;AACjB,cAAM,QAAQ,UAAU,GAAG,gBAAgB,WAAW,EAAE,GAAG,GAAAA,IAAG;AAC9D,cAAM,eAAgB;AACtB,eAAO;AAAA,MACV;AAAA,MACD,WAAW,OAAO;AACd,eAAO,sBAAsB,KAAK;AAAA,MACrC;AAAA,MACD,MAAM,OAAO;AACT,eAAO,WAAW,sBAAsB,KAAK,CAAC;AAAA,MACjD;AAAA,IACJ;AAAA,EACJ;AAAA,EACD,QAAQ;AAAA,IACJ,aAAa;AAAA;AAAA,IACb,GAAG,GAAG;AAAA;AAAA,IACN,WAAW;AAAA,IACX,WAAW;AAAA,EACd;AAAA,EACD;AAAA,EACA,MAAM;AAAA,EACN;AACJ,CAAC;ACxsBD,SAAS,EAAEc,IAAE;AAAC,SAAOA,MAAG,IAAEA,KAAE,CAACA;AAAC;AAAC,SAAS,EAAEA,IAAE;AAAC,MAAG,YAAU,OAAOA,OAAIA,KAAE,OAAOA,EAAC,IAAG,OAAKA,GAAE,QAAO;AAAE,MAAIhB,KAAE;AAAE,KAAE;AAAC,IAAAA;AAAA,EAAG,UAAQgB,OAAI,MAAI;AAAI,SAAOhB;AAAC;AAA4yB,SAAS,EAAEA,IAAE,GAAE;AAAC,MAAI,IAAE,YAAU,OAAOA,KAAE,OAAO,EAAEA,EAAC,CAAC,IAAE,EAAEA,EAAC,GAAE,IAAE,YAAU,OAAO,IAAE,OAAO,EAAE,CAAC,CAAC,IAAE,EAAE,CAAC;AAAE,MAAG,OAAK,EAAE,QAAO;AAAE,MAAG,OAAK,EAAE,QAAO;AAAE,MAAI,IAAE;AAAG,SAAK,QAAM,MAAI,IAAE,MAAK,OAAI,IAAG,MAAI,IAAG;AAAI,SAAK,QAAM,KAAG,KAAI,OAAI;AAAG,KAAE;AAAC,WAAK,QAAM,KAAG,KAAI,OAAI;AAAG,QAAG,IAAE,GAAE;AAAC,YAAMgB,KAAE;AAAE,UAAE,GAAE,IAAEA;AAAA,IAAC;AAAC,SAAG;AAAA,EAAC,SAAO,OAAK;AAAG,SAAO,KAAG;AAAC;AAAC,SAAS,EAAEhB,IAAE,GAAE;AAAC,SAAM,YAAU,OAAOA,OAAIA,KAAE,OAAOA,EAAC,IAAG,YAAU,OAAO,MAAI,IAAE,OAAO,CAAC,IAAG,OAAKA,MAAG,OAAK,IAAE,OAAO,CAAC,IAAE,EAAEA,KAAE,EAAEA,IAAE,CAAC,IAAE,CAAC;AAAC;AAA0jC,SAAS,EAAEgB,IAAE;AAAC,MAAIhB,KAAE;AAAG,aAAU,KAAKgB,GAAE,OAAQ,GAAC;AAAC,IAAAhB,MAAGA,MAAG,MAAI,OAAO,CAAC;AAAA,EAAC;AAAC,SAAOA;AAAC;AAA8U,SAAS,EAAEgB,IAAEhB,KAAE,OAAG;AAAC,MAAGgB,KAAE,EAAE,OAAM,IAAI,WAAW,wBAAwB;AAAE;AAAC,UAAM,IAAE,IAAI,WAAWA,EAAC;AAAE,QAAGA,MAAG,MAAM,MAAK,OAAO,gBAAgB,CAAC;AAAA,QAAO,UAAQhB,KAAE,GAAEA,KAAE,KAAK,KAAKgB,KAAE,KAAK,GAAEhB,MAAI;AAAC,YAAM,IAAE,QAAMA,IAAE,IAAE,IAAE,QAAMgB,KAAE,IAAE,QAAMA,KAAE;AAAE,WAAK,OAAO,gBAAgB,EAAE,SAAS,GAAE,CAAC,CAAC;AAAA,IAAC;AAAC,WAAOhB,OAAI,EAAE,CAAC,IAAE,MAAI,EAAE,CAAC,IAAG;AAAA,EAAC;AAAC;AAA8O,SAAS,EAAEgB,IAAEhB,KAAE,OAAG;AAAC,MAAGgB,KAAE,EAAE,OAAM,IAAI,WAAW,uBAAuB;AAAE,QAAM,IAAE,EAAE,KAAK,KAAKA,KAAE,CAAC,GAAE,KAAE,GAAE,IAAEA,KAAE;AAAE,MAAG,MAAI,MAAI,EAAE,CAAC,IAAE,EAAE,CAAC,IAAE,KAAG,IAAE,IAAGhB,IAAE;AAAC,UAAMgB,KAAE,MAAI,IAAE,MAAI,IAAE,KAAG;AAAI,MAAE,CAAC,IAAE,EAAE,CAAC,IAAEA;AAAA,EAAC;AAAC,SAAO;AAAC;AAAC,SAAS,EAAEA,IAAE,IAAE,IAAG;AAAC,MAAGA,MAAG,EAAE,OAAM,IAAI,WAAW,8BAA8B;AAAE,QAAM,IAAEA,KAAE,GAAE,IAAE,EAAE,CAAC;AAAE,MAAI;AAAE,KAAE;AAAC,QAAE,EAAE,EAAE,CAAC,CAAC;AAAA,EAAC,SAAO,IAAE;AAAG,SAAO,IAAE;AAAC;ACA7oH,SAAS,OAAO,QAAQ;AAC3B,MAAI,OAAO,OAAO,CAAC,MAAM;AACrB,WAAO,UAAU,MAAM;AAC3B,SAAO,YAAY,MAAM;AAC7B;AACO,SAAS,YAAY,QAAQ;AAChC,MAAI,SAAS;AACb,aAAW,OAAO,QAAQ;AACtB,cAAU,IAAI;AAAA,EACtB;AACI,QAAM,SAAS,IAAI,WAAW,MAAM;AACpC,MAAI,SAAS;AACb,aAAW,OAAO,QAAQ;AACtB,WAAO,IAAI,KAAK,MAAM;AACtB,cAAU,IAAI;AAAA,EACtB;AACI,SAAO;AACX;AACO,SAAS,UAAU,QAAQ;AAC9B,SAAO,KAAK,OAAO,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,QAAQ,MAAM,EAAE,GAAG,EAAE,CAAC;AACxE;ACZA,SAAS,QAAQ,QAAoB,GAAW,GAAW,OAAuB;AAChF,MAAI,SAAS;AACP,QAAA,WAAW,MAAM,KAAK,EAAE,QAAQ,OAAO,KAAK,EAAG,CAAA,EAAE;AAAA,IAAI,MACzD,MAAM,KAAK,EAAE,QAAQ,OAAO,KAAK,EAAG,CAAA,EAAE,IAAI,MAAM,EAAE;AAAA,EACpD;AACA,WAAS,IAAI,IAAI,IAAI,OAAO,KAAK;AAC/B,aAAS,IAAI,IAAI,IAAI,OAAO,KAAK;AAC/B,YAAM,OAAO;AACb,YAAM,OAAO;AACT,UAAA,MAAM,KAAK,MAAM,GAAG;AACtB,YAAI,IAAI,GAAG;AACT;AAAA,QAAA;AAEF,YAAI,IAAI,GAAG;AACT;AAAA,QAAA;AAEF,iBAAS,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,OAAO,OAAO,IAAI,CAAC,EAAE,OAAO,IAAI,CAAC;AAC9D,YAAA;AACA,YAAA;AAAA,MAAA;AAAA,IACN;AAAA,EACF;AAEF,MAAI,SAAS,IAAI;AACf,aAAS,YAAY,UAAU,QAAQ,EAAE,EAAE;AAAA,EAAA;AAEtC,SAAA;AACT;AAEA,SAAS,YAAY,QAAoB,OAA+C;AACtF,MAAI,QAAQ;AACZ,QAAM,QAAQ,MAAM,KAAK,EAAE,QAAQ,OAAO,KAAK,EAAG,CAAA,EAAE,IAAI,MAAM,EAAE;AAChE,MAAI,OAAO;AACX,MAAI,UAAU,IAAI;AACR,YAAA,OAAO,CAAC,EAAE,CAAC;AACnB,UAAM,CAAC,IAAI;AAAA,EAAA,OACN;AACL,aAAS,IAAI,IAAI,IAAI,OAAO,KAAK;AAC/B,YAAM,WAAW,QAAQ,QAAQ,GAAG,IAAI,KAAK;AAC7C,eAAS,OAAO,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI;AACvC,YAAM,OAAO,CAAC,CAAC,IAAI,OAAO;AAC1B,cAAQ,CAAC;AAAA,IAAA;AAAA,EACX;AAEK,SAAA,EAAE,GAAG,OAAO,MAAM;AAC3B;AAEA,SAAS,QAAQ,QAAoD;AACnE,QAAM,SAAS,YAAY,QAAQ,OAAO,OAAO,MAAM,CAAC;AACxD,MAAI,IAAI,OAAO;AACf,QAAM,QAAQ,OAAO;AACrB,MAAI,IAAI;AACR,WAAS,IAAI,IAAI,IAAI,MAAM,QAAQ,KAAK;AACtC,QAAIoC,EAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAAC;AAAA,EAAA;AAE7B,MAAI,IAAI;AACR,WAAS,IAAI,IAAI,IAAI,MAAM,QAAQ,KAAK;AAChC,UAAA,OAAO,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,IAAI;AAAA,EAAA;AAExC,MAAI,IAAI,IAAI;AACV,QAAI,CAAC;AACL,aAAS,IAAI,IAAI,IAAI,MAAM,QAAQ,KAAK;AAChC,YAAA,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAAA,IAAA;AAAA,EACrC;AAEK,SAAA,EAAE,GAAG,MAAM;AACpB;AAEA,SAAS,WACP,QACA3D,IACA,KACA,QACA,MACA,WACQ;AACR,MAAI,QAAQ,WAAW;AACf,UAAA,SAAS,QAAQ,MAAM;AAC7B,QAAI,IAAI,OAAO;AACf,UAAM,QAAQ,OAAO;AACrB,QAAI,IAAI;AACR,aAAS,IAAI,IAAI,IAAI,MAAM,QAAQ,KAAK;AACtC,UAAI2D,EAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAAC;AAAA,IAAA;AAE7B,QAAI,IAAI;AACD,WAAA,OAAOC,EAAI,CAAC,CAAC;AAAA,EAAA;AAEb,WAAA,IAAI,MAAM,QAAQ,IAAI,OAAO,YAAY,MAAM,IAAI,KAAK;AAC/D,UAAM,MAAgB,MAAM,KAAK,EAAE,QAAQ,OAAO,SAAS,EAAG,CAAA,EAAE,IAAI,MAAM,EAAE;AAC5E,aAAS,IAAI,IAAI,IAAI,WAAW,KAAK;AACnC,UAAI,OAAO,CAAC,CAAC,KAAK,IAAI,OAAO;AAAA,IAAA;AAExB,WAAA,OAAO,GAAG,CAAC,IAAI;AAClB,IAAA5D,KAAA6D,EAAI7D,IAAG,WAAW,QAAQA,IAAG,MAAM,IAAI,IAAI,KAAK,MAAM,SAAS,CAAC;AAAA,EAAA;AAE/D,SAAAA;AACT;AAEO,SAAS,sBAAsB,eAA+B;AAC5D,SAAA,iBAAiB,gBAAgB,MAAM;AAChD;AAEgB,SAAA,UAAU,MAAc,WAA2B;AACjE,QAAM,SAAqB,MAAM,KAAK,EAAE,QAAQ,OAAO,SAAS,EAAG,CAAA,EAAE,IAAI,MAAM,CAAA,CAAE;AACjF,SAAO,WAAW,QAAQ,IAAI,IAAI,IAAI,MAAM,SAAS;AACvD;AAEA,SAAS,aAAqB;AAC5B,SAAO8D,EAAYC,UAAI,GAAG,MAAM,IAAI,IAAI,EAAE;AAC5C;AAEA,SAAS,UAA6B;AACpC,QAAMvD,KAAI,WAAW;AAGrB,SAAOuD,UAAI,GAAG,gBAAgB,KAAK,SAASvD,EAAC;AAC/C;AAEA,MAAM,cAAc;AAAA,EAClB,YACS,MACA,MACA,YACP;AAHO,SAAA,OAAA;AACA,SAAA,OAAA;AACA,SAAA,aAAA;AAAA,EAAA;AAAA,EAGT,SAAkB;AACV,UAAA,IAAI,MAAM,eAAe;AAAA,EAAA;AAAA,EAGjC,UAAqB;AACnB,WAAO,OAAO,CAAC,KAAK,KAAK,cAAc,KAAK,KAAK,WAAA,GAAc,KAAK,WAAW,WAAY,CAAA,CAAC;AAAA,EAAA;AAEhG;AAEA,SAAS,WAAW,KAAwB,IAAsC;AAChF,QAAM,IAAI,WAAW;AAKf,QAAA,MAAM,GAAG,SAAS,CAAC;AACnB,QAAA,OAAO,IAAI,IAAI,GAAG;AAExB,QAAM,QAAQuD,UAAI,GAAG,gBAAgB,KAAK,SAAS,CAAC;AAC9C,QAAA,QAAQA,UAAI,GAAG,gBAAgB,KAAK,SAAS,CAAC,EAAE,OAAO;AAE7D,SAAO,IAAI,cAAc,MAAM,OAAO,KAAK;AAC7C;AAEA,SAAS,WAAW,KAAgB,MAA4B;AAC1D,MAAA,IAAI,SAAS,GAAG;AACZ,UAAA,IAAI,MAAM,mBAAmB;AAAA,EAAA;AAErC,QAAM,WAAW,KAAK,OAAA,EAAS,OAAO,IAAI,EAAE,OAAO;AAC7C,QAAA,SAAS,IAAI,IAAI,gBAAgB,IAAI,UAAU,SAAS,MAAM,GAAG,EAAE,CAAC;AACpE,QAAA,YAAY,OAAO,QAAQ,IAAI,QAAQ,MAAM,IAAI,GAAG,CAAC;AAEpD,SAAA;AACT;AAEO,MAAM,UAAU;AAAA,EACrB,YAAmB,KAAwB;AAAxB,SAAA,MAAA;AAAA,EAAA;AAAA,EAEnB,OAAO,yBAAyB,sBAAiC,QAA2B;AACtF,QAAA,qBAAqB,WAAW,KAAK;AACjC,YAAA,IAAI,MAAM,+BAA+B;AAAA,IAAA;AAG7C,QAAA,MAAMA,UAAI,GAAG,gBAAgB;AAAA,MAC/B,OAAO,CAAC,qBAAqB,SAAS,IAAI,EAAE,GAAG,qBAAqB,SAAS,EAAE,CAAC,CAAC;AAAA,IACnF;AAEM,UAAA,IAAI,SAAS,MAAM;AAElB,WAAA,IAAI,UAAU,GAAG;AAAA,EAAA;AAAA,EAG1B,OAAO,UAAU,OAA6B;AAC5C,UAAM,MAAMA,UAAI,GAAG,gBAAgB,QAAQ,KAAK;AACzC,WAAA,IAAI,UAAU,GAAG;AAAA,EAAA;AAAA,EAG1B,UAAqB;AACZ,WAAA,KAAK,IAAI,WAAW;AAAA,EAAA;AAAA,EAG7B,QAAQ,KAAsE;AAC5E,UAAM,YAAY,QAAQ;AAE1B,UAAM,eAAe,WAAW,WAAW,KAAK,GAAG,EAAE,QAAQ;AAC7D,UAAM,eAAe,WAAW,KAAK,UAAU,WAAW,KAAK,CAAC;AAEzD,WAAA,EAAE,cAAc,aAAa;AAAA,EAAA;AAExC;","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29]}