@prosopo/client-bundle-example 2.5.5 → 2.7.0

package/dist/assets/index-WqEmiYQ_.js

@@ -0,0 +1,4386 @@
+var Bo = Object.defineProperty;
+var Ao = (t, e, r) => e in t ? Bo(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var jt = (t, e, r) => Ao(t, typeof e != "symbol" ? e + "" : e, r);
+import { x as mi, s as re } from "./toU8a-C68WUzs_.js";
+import { b as Pr, B as Q, c as ye, d as te, u as C, R as So, e as Io, f as se, g as oe, j as Jt, r as gi, k as ko, l as Ct, i as Vt, s as Uo, m as I0, n as No, o as Ro, p as Oo, q as To, t as Lo, v as qo, x as $o, y as Po, z as Zo, A as Do, C as Ho, D as Co, E as k0, H as Vo, F as Le, G as Pe, I as On, J as zo, K as Tn, L as Yo, M as Qr, N as Xo, O as Ko, P as Wo, Q as jo, S as Go, T as Jo, U as Qo, V as Fo, W as ts, X as es, Y as rs, Z as ns, _ as is, $ as os, a0 as ss, a1 as fs, a2 as as, a3 as cs, a4 as G, a5 as hs } from "./hash-BR0YLxPF.js";
+import { g as ls } from "./_commonjsHelpers-DaMA6jEr.js";
+import { h as pi, s as Fr, a as us, b as ds, c as ws, m as ms, v as gs, d as Ln, p as ps, e as yi } from "./bip39-BQoZog_M.js";
+import { a as vi } from "./asU8a-DCECA0Qe.js";
+import { o as tn } from "./spread-DEmVz7RJ.js";
+import { n as xe } from "./emotion-element-5486c51c.browser.esm-CCAJ8JId.js";
+const ys = { name: "@polkadot/util", path: import.meta && import.meta.url ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf("/") + 1) : "auto", type: "esm", version: "12.6.2" }, vs = "POLKADOTJS_DISABLE_ESM_CJS_WARNING";
+function xs(t) {
+  const e = mi;
+  return e.__polkadotjs || (e.__polkadotjs = {}), e.__polkadotjs[t] || (e.__polkadotjs[t] = []), e.__polkadotjs[t];
+}
+function bs(t, e) {
+  if (t)
+    return t;
+  if (Pr(e))
+    try {
+      return e() || "";
+    } catch {
+      return "";
+    }
+  return e || "";
+}
+function Es({ name: t, path: e, type: r, version: o }, c, s = []) {
+  var E, _;
+  if (!t.startsWith("@polkadot"))
+    throw new Error(`Invalid package descriptor ${t}`);
+  const w = xs(t);
+  w.push({ path: bs(e, c), type: r, version: o });
+  const m = w.every((R) => R.version === o), v = ((_ = (E = mi.process) == null ? void 0 : E.env) == null ? void 0 : _[vs]) === "1";
+  w.length !== 1 && !(v && m) || s.filter((R) => R && R.version !== o);
+}
+const Ze = /* @__PURE__ */ Q(0), De = /* @__PURE__ */ Q(1);
+Number.MAX_SAFE_INTEGER;
+const qn = Q(256), $n = Q(256 * 256), Ms = Q("0x10000000000000000");
+function Zr(t, { isLe: e = !0, isNegative: r = !1 } = {}) {
+  e || (t = t.slice().reverse());
+  const o = t.length;
+  if (r && o && t[o - 1] & 128) {
+    switch (o) {
+      case 0:
+        return Q(0);
+      case 1:
+        return Q((t[0] ^ 255) * -1 - 1);
+      case 2:
+        return Q((t[0] + (t[1] << 8) ^ 65535) * -1 - 1);
+      case 4:
+        return Q((t[0] + (t[1] << 8) + (t[2] << 16) + t[3] * 16777216 ^ 4294967295) * -1 - 1);
+    }
+    const s = new DataView(t.buffer, t.byteOffset);
+    if (o === 8)
+      return s.getBigInt64(0, !0);
+    let w = Q(0);
+    const m = o % 2;
+    for (let v = o - 2; v >= m; v -= 2)
+      w = w * $n + Q(s.getUint16(v, !0) ^ 65535);
+    return m && (w = w * qn + Q(t[0] ^ 255)), w * -De - De;
+  }
+  switch (o) {
+    case 0:
+      return Q(0);
+    case 1:
+      return Q(t[0]);
+    case 2:
+      return Q(t[0] + (t[1] << 8));
+    case 4:
+      return Q(t[0] + (t[1] << 8) + (t[2] << 16) + t[3] * 16777216);
+  }
+  const c = new DataView(t.buffer, t.byteOffset);
+  switch (o) {
+    case 8:
+      return c.getBigUint64(0, !0);
+    case 16:
+      return c.getBigUint64(8, !0) * Ms + c.getBigUint64(0, !0);
+    default: {
+      let s = Q(0);
+      const w = o % 2;
+      for (let m = o - 2; m >= w; m -= 2)
+        s = s * $n + Q(c.getUint16(m, !0));
+      return w && (s = s * qn + Q(t[0])), s;
+    }
+  }
+}
+function _s(t, { isLe: e = !1, isNegative: r = !1 } = {}) {
+  return !t || t === "0x" ? Q(0) : Zr(ye(t), { isLe: e, isNegative: r });
+}
+var en = { exports: {} }, Bs = en.exports;
+(function(t) {
+  (function(e, r) {
+    function o(p, n) {
+      if (!p) throw new Error(n || "Assertion failed");
+    }
+    function c(p, n) {
+      p.super_ = n;
+      var f = function() {
+      };
+      f.prototype = n.prototype, p.prototype = new f(), p.prototype.constructor = p;
+    }
+    function s(p, n, f) {
+      if (s.isBN(p))
+        return p;
+      this.negative = 0, this.words = null, this.length = 0, this.red = null, p !== null && ((n === "le" || n === "be") && (f = n, n = 10), this._init(p || 0, n || 10, f || "be"));
+    }
+    typeof e == "object" ? e.exports = s : r.BN = s, s.BN = s, s.wordSize = 26;
+    var w;
+    try {
+      typeof window < "u" && typeof window.Buffer < "u" ? w = window.Buffer : w = require("buffer").Buffer;
+    } catch {
+    }
+    s.isBN = function(n) {
+      return n instanceof s ? !0 : n !== null && typeof n == "object" && n.constructor.wordSize === s.wordSize && Array.isArray(n.words);
+    }, s.max = function(n, f) {
+      return n.cmp(f) > 0 ? n : f;
+    }, s.min = function(n, f) {
+      return n.cmp(f) < 0 ? n : f;
+    }, s.prototype._init = function(n, f, a) {
+      if (typeof n == "number")
+        return this._initNumber(n, f, a);
+      if (typeof n == "object")
+        return this._initArray(n, f, a);
+      f === "hex" && (f = 16), o(f === (f | 0) && f >= 2 && f <= 36), n = n.toString().replace(/\s+/g, "");
+      var d = 0;
+      n[0] === "-" && (d++, this.negative = 1), d < n.length && (f === 16 ? this._parseHex(n, d, a) : (this._parseBase(n, f, d), a === "le" && this._initArray(this.toArray(), f, a)));
+    }, s.prototype._initNumber = function(n, f, a) {
+      n < 0 && (this.negative = 1, n = -n), n < 67108864 ? (this.words = [n & 67108863], this.length = 1) : n < 4503599627370496 ? (this.words = [
+        n & 67108863,
+        n / 67108864 & 67108863
+      ], this.length = 2) : (o(n < 9007199254740992), this.words = [
+        n & 67108863,
+        n / 67108864 & 67108863,
+        1
+      ], this.length = 3), a === "le" && this._initArray(this.toArray(), f, a);
+    }, s.prototype._initArray = function(n, f, a) {
+      if (o(typeof n.length == "number"), n.length <= 0)
+        return this.words = [0], this.length = 1, this;
+      this.length = Math.ceil(n.length / 3), this.words = new Array(this.length);
+      for (var d = 0; d < this.length; d++)
+        this.words[d] = 0;
+      var l, u, y = 0;
+      if (a === "be")
+        for (d = n.length - 1, l = 0; d >= 0; d -= 3)
+          u = n[d] | n[d - 1] << 8 | n[d - 2] << 16, this.words[l] |= u << y & 67108863, this.words[l + 1] = u >>> 26 - y & 67108863, y += 24, y >= 26 && (y -= 26, l++);
+      else if (a === "le")
+        for (d = 0, l = 0; d < n.length; d += 3)
+          u = n[d] | n[d + 1] << 8 | n[d + 2] << 16, this.words[l] |= u << y & 67108863, this.words[l + 1] = u >>> 26 - y & 67108863, y += 24, y >= 26 && (y -= 26, l++);
+      return this._strip();
+    };
+    function m(p, n) {
+      var f = p.charCodeAt(n);
+      if (f >= 48 && f <= 57)
+        return f - 48;
+      if (f >= 65 && f <= 70)
+        return f - 55;
+      if (f >= 97 && f <= 102)
+        return f - 87;
+      o(!1, "Invalid character in " + p);
+    }
+    function v(p, n, f) {
+      var a = m(p, f);
+      return f - 1 >= n && (a |= m(p, f - 1) << 4), a;
+    }
+    s.prototype._parseHex = function(n, f, a) {
+      this.length = Math.ceil((n.length - f) / 6), this.words = new Array(this.length);
+      for (var d = 0; d < this.length; d++)
+        this.words[d] = 0;
+      var l = 0, u = 0, y;
+      if (a === "be")
+        for (d = n.length - 1; d >= f; d -= 2)
+          y = v(n, f, d) << l, this.words[u] |= y & 67108863, l >= 18 ? (l -= 18, u += 1, this.words[u] |= y >>> 26) : l += 8;
+      else {
+        var h = n.length - f;
+        for (d = h % 2 === 0 ? f + 1 : f; d < n.length; d += 2)
+          y = v(n, f, d) << l, this.words[u] |= y & 67108863, l >= 18 ? (l -= 18, u += 1, this.words[u] |= y >>> 26) : l += 8;
+      }
+      this._strip();
+    };
+    function b(p, n, f, a) {
+      for (var d = 0, l = 0, u = Math.min(p.length, f), y = n; y < u; y++) {
+        var h = p.charCodeAt(y) - 48;
+        d *= a, h >= 49 ? l = h - 49 + 10 : h >= 17 ? l = h - 17 + 10 : l = h, o(h >= 0 && l < a, "Invalid character"), d += l;
+      }
+      return d;
+    }
+    s.prototype._parseBase = function(n, f, a) {
+      this.words = [0], this.length = 1;
+      for (var d = 0, l = 1; l <= 67108863; l *= f)
+        d++;
+      d--, l = l / f | 0;
+      for (var u = n.length - a, y = u % d, h = Math.min(u, u - y) + a, i = 0, g = a; g < h; g += d)
+        i = b(n, g, g + d, f), this.imuln(l), this.words[0] + i < 67108864 ? this.words[0] += i : this._iaddn(i);
+      if (y !== 0) {
+        var A = 1;
+        for (i = b(n, g, n.length, f), g = 0; g < y; g++)
+          A *= f;
+        this.imuln(A), this.words[0] + i < 67108864 ? this.words[0] += i : this._iaddn(i);
+      }
+      this._strip();
+    }, s.prototype.copy = function(n) {
+      n.words = new Array(this.length);
+      for (var f = 0; f < this.length; f++)
+        n.words[f] = this.words[f];
+      n.length = this.length, n.negative = this.negative, n.red = this.red;
+    };
+    function x(p, n) {
+      p.words = n.words, p.length = n.length, p.negative = n.negative, p.red = n.red;
+    }
+    if (s.prototype._move = function(n) {
+      x(n, this);
+    }, s.prototype.clone = function() {
+      var n = new s(null);
+      return this.copy(n), n;
+    }, s.prototype._expand = function(n) {
+      for (; this.length < n; )
+        this.words[this.length++] = 0;
+      return this;
+    }, s.prototype._strip = function() {
+      for (; this.length > 1 && this.words[this.length - 1] === 0; )
+        this.length--;
+      return this._normSign();
+    }, s.prototype._normSign = function() {
+      return this.length === 1 && this.words[0] === 0 && (this.negative = 0), this;
+    }, typeof Symbol < "u" && typeof Symbol.for == "function")
+      try {
+        s.prototype[Symbol.for("nodejs.util.inspect.custom")] = E;
+      } catch {
+        s.prototype.inspect = E;
+      }
+    else
+      s.prototype.inspect = E;
+    function E() {
+      return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
+    }
+    var _ = [
+      "",
+      "0",
+      "00",
+      "000",
+      "0000",
+      "00000",
+      "000000",
+      "0000000",
+      "00000000",
+      "000000000",
+      "0000000000",
+      "00000000000",
+      "000000000000",
+      "0000000000000",
+      "00000000000000",
+      "000000000000000",
+      "0000000000000000",
+      "00000000000000000",
+      "000000000000000000",
+      "0000000000000000000",
+      "00000000000000000000",
+      "000000000000000000000",
+      "0000000000000000000000",
+      "00000000000000000000000",
+      "000000000000000000000000",
+      "0000000000000000000000000"
+    ], R = [
+      0,
+      0,
+      25,
+      16,
+      12,
+      11,
+      10,
+      9,
+      8,
+      8,
+      7,
+      7,
+      7,
+      7,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      6,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5,
+      5
+    ], q = [
+      0,
+      0,
+      33554432,
+      43046721,
+      16777216,
+      48828125,
+      60466176,
+      40353607,
+      16777216,
+      43046721,
+      1e7,
+      19487171,
+      35831808,
+      62748517,
+      7529536,
+      11390625,
+      16777216,
+      24137569,
+      34012224,
+      47045881,
+      64e6,
+      4084101,
+      5153632,
+      6436343,
+      7962624,
+      9765625,
+      11881376,
+      14348907,
+      17210368,
+      20511149,
+      243e5,
+      28629151,
+      33554432,
+      39135393,
+      45435424,
+      52521875,
+      60466176
+    ];
+    s.prototype.toString = function(n, f) {
+      n = n || 10, f = f | 0 || 1;
+      var a;
+      if (n === 16 || n === "hex") {
+        a = "";
+        for (var d = 0, l = 0, u = 0; u < this.length; u++) {
+          var y = this.words[u], h = ((y << d | l) & 16777215).toString(16);
+          l = y >>> 24 - d & 16777215, d += 2, d >= 26 && (d -= 26, u--), l !== 0 || u !== this.length - 1 ? a = _[6 - h.length] + h + a : a = h + a;
+        }
+        for (l !== 0 && (a = l.toString(16) + a); a.length % f !== 0; )
+          a = "0" + a;
+        return this.negative !== 0 && (a = "-" + a), a;
+      }
+      if (n === (n | 0) && n >= 2 && n <= 36) {
+        var i = R[n], g = q[n];
+        a = "";
+        var A = this.clone();
+        for (A.negative = 0; !A.isZero(); ) {
+          var B = A.modrn(g).toString(n);
+          A = A.idivn(g), A.isZero() ? a = B + a : a = _[i - B.length] + B + a;
+        }
+        for (this.isZero() && (a = "0" + a); a.length % f !== 0; )
+          a = "0" + a;
+        return this.negative !== 0 && (a = "-" + a), a;
+      }
+      o(!1, "Base should be between 2 and 36");
+    }, s.prototype.toNumber = function() {
+      var n = this.words[0];
+      return this.length === 2 ? n += this.words[1] * 67108864 : this.length === 3 && this.words[2] === 1 ? n += 4503599627370496 + this.words[1] * 67108864 : this.length > 2 && o(!1, "Number can only safely store up to 53 bits"), this.negative !== 0 ? -n : n;
+    }, s.prototype.toJSON = function() {
+      return this.toString(16, 2);
+    }, w && (s.prototype.toBuffer = function(n, f) {
+      return this.toArrayLike(w, n, f);
+    }), s.prototype.toArray = function(n, f) {
+      return this.toArrayLike(Array, n, f);
+    };
+    var k = function(n, f) {
+      return n.allocUnsafe ? n.allocUnsafe(f) : new n(f);
+    };
+    s.prototype.toArrayLike = function(n, f, a) {
+      this._strip();
+      var d = this.byteLength(), l = a || Math.max(1, d);
+      o(d <= l, "byte array longer than desired length"), o(l > 0, "Requested array length <= 0");
+      var u = k(n, l), y = f === "le" ? "LE" : "BE";
+      return this["_toArrayLike" + y](u, d), u;
+    }, s.prototype._toArrayLikeLE = function(n, f) {
+      for (var a = 0, d = 0, l = 0, u = 0; l < this.length; l++) {
+        var y = this.words[l] << u | d;
+        n[a++] = y & 255, a < n.length && (n[a++] = y >> 8 & 255), a < n.length && (n[a++] = y >> 16 & 255), u === 6 ? (a < n.length && (n[a++] = y >> 24 & 255), d = 0, u = 0) : (d = y >>> 24, u += 2);
+      }
+      if (a < n.length)
+        for (n[a++] = d; a < n.length; )
+          n[a++] = 0;
+    }, s.prototype._toArrayLikeBE = function(n, f) {
+      for (var a = n.length - 1, d = 0, l = 0, u = 0; l < this.length; l++) {
+        var y = this.words[l] << u | d;
+        n[a--] = y & 255, a >= 0 && (n[a--] = y >> 8 & 255), a >= 0 && (n[a--] = y >> 16 & 255), u === 6 ? (a >= 0 && (n[a--] = y >> 24 & 255), d = 0, u = 0) : (d = y >>> 24, u += 2);
+      }
+      if (a >= 0)
+        for (n[a--] = d; a >= 0; )
+          n[a--] = 0;
+    }, Math.clz32 ? s.prototype._countBits = function(n) {
+      return 32 - Math.clz32(n);
+    } : s.prototype._countBits = function(n) {
+      var f = n, a = 0;
+      return f >= 4096 && (a += 13, f >>>= 13), f >= 64 && (a += 7, f >>>= 7), f >= 8 && (a += 4, f >>>= 4), f >= 2 && (a += 2, f >>>= 2), a + f;
+    }, s.prototype._zeroBits = function(n) {
+      if (n === 0) return 26;
+      var f = n, a = 0;
+      return (f & 8191) === 0 && (a += 13, f >>>= 13), (f & 127) === 0 && (a += 7, f >>>= 7), (f & 15) === 0 && (a += 4, f >>>= 4), (f & 3) === 0 && (a += 2, f >>>= 2), (f & 1) === 0 && a++, a;
+    }, s.prototype.bitLength = function() {
+      var n = this.words[this.length - 1], f = this._countBits(n);
+      return (this.length - 1) * 26 + f;
+    };
+    function X(p) {
+      for (var n = new Array(p.bitLength()), f = 0; f < n.length; f++) {
+        var a = f / 26 | 0, d = f % 26;
+        n[f] = p.words[a] >>> d & 1;
+      }
+      return n;
+    }
+    s.prototype.zeroBits = function() {
+      if (this.isZero()) return 0;
+      for (var n = 0, f = 0; f < this.length; f++) {
+        var a = this._zeroBits(this.words[f]);
+        if (n += a, a !== 26) break;
+      }
+      return n;
+    }, s.prototype.byteLength = function() {
+      return Math.ceil(this.bitLength() / 8);
+    }, s.prototype.toTwos = function(n) {
+      return this.negative !== 0 ? this.abs().inotn(n).iaddn(1) : this.clone();
+    }, s.prototype.fromTwos = function(n) {
+      return this.testn(n - 1) ? this.notn(n).iaddn(1).ineg() : this.clone();
+    }, s.prototype.isNeg = function() {
+      return this.negative !== 0;
+    }, s.prototype.neg = function() {
+      return this.clone().ineg();
+    }, s.prototype.ineg = function() {
+      return this.isZero() || (this.negative ^= 1), this;
+    }, s.prototype.iuor = function(n) {
+      for (; this.length < n.length; )
+        this.words[this.length++] = 0;
+      for (var f = 0; f < n.length; f++)
+        this.words[f] = this.words[f] | n.words[f];
+      return this._strip();
+    }, s.prototype.ior = function(n) {
+      return o((this.negative | n.negative) === 0), this.iuor(n);
+    }, s.prototype.or = function(n) {
+      return this.length > n.length ? this.clone().ior(n) : n.clone().ior(this);
+    }, s.prototype.uor = function(n) {
+      return this.length > n.length ? this.clone().iuor(n) : n.clone().iuor(this);
+    }, s.prototype.iuand = function(n) {
+      var f;
+      this.length > n.length ? f = n : f = this;
+      for (var a = 0; a < f.length; a++)
+        this.words[a] = this.words[a] & n.words[a];
+      return this.length = f.length, this._strip();
+    }, s.prototype.iand = function(n) {
+      return o((this.negative | n.negative) === 0), this.iuand(n);
+    }, s.prototype.and = function(n) {
+      return this.length > n.length ? this.clone().iand(n) : n.clone().iand(this);
+    }, s.prototype.uand = function(n) {
+      return this.length > n.length ? this.clone().iuand(n) : n.clone().iuand(this);
+    }, s.prototype.iuxor = function(n) {
+      var f, a;
+      this.length > n.length ? (f = this, a = n) : (f = n, a = this);
+      for (var d = 0; d < a.length; d++)
+        this.words[d] = f.words[d] ^ a.words[d];
+      if (this !== f)
+        for (; d < f.length; d++)
+          this.words[d] = f.words[d];
+      return this.length = f.length, this._strip();
+    }, s.prototype.ixor = function(n) {
+      return o((this.negative | n.negative) === 0), this.iuxor(n);
+    }, s.prototype.xor = function(n) {
+      return this.length > n.length ? this.clone().ixor(n) : n.clone().ixor(this);
+    }, s.prototype.uxor = function(n) {
+      return this.length > n.length ? this.clone().iuxor(n) : n.clone().iuxor(this);
+    }, s.prototype.inotn = function(n) {
+      o(typeof n == "number" && n >= 0);
+      var f = Math.ceil(n / 26) | 0, a = n % 26;
+      this._expand(f), a > 0 && f--;
+      for (var d = 0; d < f; d++)
+        this.words[d] = ~this.words[d] & 67108863;
+      return a > 0 && (this.words[d] = ~this.words[d] & 67108863 >> 26 - a), this._strip();
+    }, s.prototype.notn = function(n) {
+      return this.clone().inotn(n);
+    }, s.prototype.setn = function(n, f) {
+      o(typeof n == "number" && n >= 0);
+      var a = n / 26 | 0, d = n % 26;
+      return this._expand(a + 1), f ? this.words[a] = this.words[a] | 1 << d : this.words[a] = this.words[a] & ~(1 << d), this._strip();
+    }, s.prototype.iadd = function(n) {
+      var f;
+      if (this.negative !== 0 && n.negative === 0)
+        return this.negative = 0, f = this.isub(n), this.negative ^= 1, this._normSign();
+      if (this.negative === 0 && n.negative !== 0)
+        return n.negative = 0, f = this.isub(n), n.negative = 1, f._normSign();
+      var a, d;
+      this.length > n.length ? (a = this, d = n) : (a = n, d = this);
+      for (var l = 0, u = 0; u < d.length; u++)
+        f = (a.words[u] | 0) + (d.words[u] | 0) + l, this.words[u] = f & 67108863, l = f >>> 26;
+      for (; l !== 0 && u < a.length; u++)
+        f = (a.words[u] | 0) + l, this.words[u] = f & 67108863, l = f >>> 26;
+      if (this.length = a.length, l !== 0)
+        this.words[this.length] = l, this.length++;
+      else if (a !== this)
+        for (; u < a.length; u++)
+          this.words[u] = a.words[u];
+      return this;
+    }, s.prototype.add = function(n) {
+      var f;
+      return n.negative !== 0 && this.negative === 0 ? (n.negative = 0, f = this.sub(n), n.negative ^= 1, f) : n.negative === 0 && this.negative !== 0 ? (this.negative = 0, f = n.sub(this), this.negative = 1, f) : this.length > n.length ? this.clone().iadd(n) : n.clone().iadd(this);
+    }, s.prototype.isub = function(n) {
+      if (n.negative !== 0) {
+        n.negative = 0;
+        var f = this.iadd(n);
+        return n.negative = 1, f._normSign();
+      } else if (this.negative !== 0)
+        return this.negative = 0, this.iadd(n), this.negative = 1, this._normSign();
+      var a = this.cmp(n);
+      if (a === 0)
+        return this.negative = 0, this.length = 1, this.words[0] = 0, this;
+      var d, l;
+      a > 0 ? (d = this, l = n) : (d = n, l = this);
+      for (var u = 0, y = 0; y < l.length; y++)
+        f = (d.words[y] | 0) - (l.words[y] | 0) + u, u = f >> 26, this.words[y] = f & 67108863;
+      for (; u !== 0 && y < d.length; y++)
+        f = (d.words[y] | 0) + u, u = f >> 26, this.words[y] = f & 67108863;
+      if (u === 0 && y < d.length && d !== this)
+        for (; y < d.length; y++)
+          this.words[y] = d.words[y];
+      return this.length = Math.max(this.length, y), d !== this && (this.negative = 1), this._strip();
+    }, s.prototype.sub = function(n) {
+      return this.clone().isub(n);
+    };
+    function z(p, n, f) {
+      f.negative = n.negative ^ p.negative;
+      var a = p.length + n.length | 0;
+      f.length = a, a = a - 1 | 0;
+      var d = p.words[0] | 0, l = n.words[0] | 0, u = d * l, y = u & 67108863, h = u / 67108864 | 0;
+      f.words[0] = y;
+      for (var i = 1; i < a; i++) {
+        for (var g = h >>> 26, A = h & 67108863, B = Math.min(i, n.length - 1), I = Math.max(0, i - p.length + 1); I <= B; I++) {
+          var P = i - I | 0;
+          d = p.words[P] | 0, l = n.words[I] | 0, u = d * l + A, g += u / 67108864 | 0, A = u & 67108863;
+        }
+        f.words[i] = A | 0, h = g | 0;
+      }
+      return h !== 0 ? f.words[i] = h | 0 : f.length--, f._strip();
+    }
+    var st = function(n, f, a) {
+      var d = n.words, l = f.words, u = a.words, y = 0, h, i, g, A = d[0] | 0, B = A & 8191, I = A >>> 13, P = d[1] | 0, Z = P & 8191, H = P >>> 13, ft = d[2] | 0, K = ft & 8191, Y = ft >>> 13, qt = d[3] | 0, j = qt & 8191, J = qt >>> 13, Yt = d[4] | 0, tt = Yt & 8191, et = Yt >>> 13, Ne = d[5] | 0, rt = Ne & 8191, nt = Ne >>> 13, vn = d[6] | 0, at = vn & 8191, ct = vn >>> 13, xn = d[7] | 0, ht = xn & 8191, lt = xn >>> 13, bn = d[8] | 0, ut = bn & 8191, dt = bn >>> 13, En = d[9] | 0, wt = En & 8191, mt = En >>> 13, Mn = l[0] | 0, gt = Mn & 8191, pt = Mn >>> 13, _n = l[1] | 0, yt = _n & 8191, vt = _n >>> 13, Bn = l[2] | 0, xt = Bn & 8191, bt = Bn >>> 13, An = l[3] | 0, Et = An & 8191, Mt = An >>> 13, Sn = l[4] | 0, _t = Sn & 8191, Bt = Sn >>> 13, In = l[5] | 0, At = In & 8191, St = In >>> 13, kn = l[6] | 0, It = kn & 8191, kt = kn >>> 13, Un = l[7] | 0, Ut = Un & 8191, Nt = Un >>> 13, Nn = l[8] | 0, Rt = Nn & 8191, Ot = Nn >>> 13, Rn = l[9] | 0, Tt = Rn & 8191, Lt = Rn >>> 13;
+      a.negative = n.negative ^ f.negative, a.length = 19, h = Math.imul(B, gt), i = Math.imul(B, pt), i = i + Math.imul(I, gt) | 0, g = Math.imul(I, pt);
+      var Fe = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (Fe >>> 26) | 0, Fe &= 67108863, h = Math.imul(Z, gt), i = Math.imul(Z, pt), i = i + Math.imul(H, gt) | 0, g = Math.imul(H, pt), h = h + Math.imul(B, yt) | 0, i = i + Math.imul(B, vt) | 0, i = i + Math.imul(I, yt) | 0, g = g + Math.imul(I, vt) | 0;
+      var tr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (tr >>> 26) | 0, tr &= 67108863, h = Math.imul(K, gt), i = Math.imul(K, pt), i = i + Math.imul(Y, gt) | 0, g = Math.imul(Y, pt), h = h + Math.imul(Z, yt) | 0, i = i + Math.imul(Z, vt) | 0, i = i + Math.imul(H, yt) | 0, g = g + Math.imul(H, vt) | 0, h = h + Math.imul(B, xt) | 0, i = i + Math.imul(B, bt) | 0, i = i + Math.imul(I, xt) | 0, g = g + Math.imul(I, bt) | 0;
+      var er = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (er >>> 26) | 0, er &= 67108863, h = Math.imul(j, gt), i = Math.imul(j, pt), i = i + Math.imul(J, gt) | 0, g = Math.imul(J, pt), h = h + Math.imul(K, yt) | 0, i = i + Math.imul(K, vt) | 0, i = i + Math.imul(Y, yt) | 0, g = g + Math.imul(Y, vt) | 0, h = h + Math.imul(Z, xt) | 0, i = i + Math.imul(Z, bt) | 0, i = i + Math.imul(H, xt) | 0, g = g + Math.imul(H, bt) | 0, h = h + Math.imul(B, Et) | 0, i = i + Math.imul(B, Mt) | 0, i = i + Math.imul(I, Et) | 0, g = g + Math.imul(I, Mt) | 0;
+      var rr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (rr >>> 26) | 0, rr &= 67108863, h = Math.imul(tt, gt), i = Math.imul(tt, pt), i = i + Math.imul(et, gt) | 0, g = Math.imul(et, pt), h = h + Math.imul(j, yt) | 0, i = i + Math.imul(j, vt) | 0, i = i + Math.imul(J, yt) | 0, g = g + Math.imul(J, vt) | 0, h = h + Math.imul(K, xt) | 0, i = i + Math.imul(K, bt) | 0, i = i + Math.imul(Y, xt) | 0, g = g + Math.imul(Y, bt) | 0, h = h + Math.imul(Z, Et) | 0, i = i + Math.imul(Z, Mt) | 0, i = i + Math.imul(H, Et) | 0, g = g + Math.imul(H, Mt) | 0, h = h + Math.imul(B, _t) | 0, i = i + Math.imul(B, Bt) | 0, i = i + Math.imul(I, _t) | 0, g = g + Math.imul(I, Bt) | 0;
+      var nr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (nr >>> 26) | 0, nr &= 67108863, h = Math.imul(rt, gt), i = Math.imul(rt, pt), i = i + Math.imul(nt, gt) | 0, g = Math.imul(nt, pt), h = h + Math.imul(tt, yt) | 0, i = i + Math.imul(tt, vt) | 0, i = i + Math.imul(et, yt) | 0, g = g + Math.imul(et, vt) | 0, h = h + Math.imul(j, xt) | 0, i = i + Math.imul(j, bt) | 0, i = i + Math.imul(J, xt) | 0, g = g + Math.imul(J, bt) | 0, h = h + Math.imul(K, Et) | 0, i = i + Math.imul(K, Mt) | 0, i = i + Math.imul(Y, Et) | 0, g = g + Math.imul(Y, Mt) | 0, h = h + Math.imul(Z, _t) | 0, i = i + Math.imul(Z, Bt) | 0, i = i + Math.imul(H, _t) | 0, g = g + Math.imul(H, Bt) | 0, h = h + Math.imul(B, At) | 0, i = i + Math.imul(B, St) | 0, i = i + Math.imul(I, At) | 0, g = g + Math.imul(I, St) | 0;
+      var ir = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (ir >>> 26) | 0, ir &= 67108863, h = Math.imul(at, gt), i = Math.imul(at, pt), i = i + Math.imul(ct, gt) | 0, g = Math.imul(ct, pt), h = h + Math.imul(rt, yt) | 0, i = i + Math.imul(rt, vt) | 0, i = i + Math.imul(nt, yt) | 0, g = g + Math.imul(nt, vt) | 0, h = h + Math.imul(tt, xt) | 0, i = i + Math.imul(tt, bt) | 0, i = i + Math.imul(et, xt) | 0, g = g + Math.imul(et, bt) | 0, h = h + Math.imul(j, Et) | 0, i = i + Math.imul(j, Mt) | 0, i = i + Math.imul(J, Et) | 0, g = g + Math.imul(J, Mt) | 0, h = h + Math.imul(K, _t) | 0, i = i + Math.imul(K, Bt) | 0, i = i + Math.imul(Y, _t) | 0, g = g + Math.imul(Y, Bt) | 0, h = h + Math.imul(Z, At) | 0, i = i + Math.imul(Z, St) | 0, i = i + Math.imul(H, At) | 0, g = g + Math.imul(H, St) | 0, h = h + Math.imul(B, It) | 0, i = i + Math.imul(B, kt) | 0, i = i + Math.imul(I, It) | 0, g = g + Math.imul(I, kt) | 0;
+      var or = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (or >>> 26) | 0, or &= 67108863, h = Math.imul(ht, gt), i = Math.imul(ht, pt), i = i + Math.imul(lt, gt) | 0, g = Math.imul(lt, pt), h = h + Math.imul(at, yt) | 0, i = i + Math.imul(at, vt) | 0, i = i + Math.imul(ct, yt) | 0, g = g + Math.imul(ct, vt) | 0, h = h + Math.imul(rt, xt) | 0, i = i + Math.imul(rt, bt) | 0, i = i + Math.imul(nt, xt) | 0, g = g + Math.imul(nt, bt) | 0, h = h + Math.imul(tt, Et) | 0, i = i + Math.imul(tt, Mt) | 0, i = i + Math.imul(et, Et) | 0, g = g + Math.imul(et, Mt) | 0, h = h + Math.imul(j, _t) | 0, i = i + Math.imul(j, Bt) | 0, i = i + Math.imul(J, _t) | 0, g = g + Math.imul(J, Bt) | 0, h = h + Math.imul(K, At) | 0, i = i + Math.imul(K, St) | 0, i = i + Math.imul(Y, At) | 0, g = g + Math.imul(Y, St) | 0, h = h + Math.imul(Z, It) | 0, i = i + Math.imul(Z, kt) | 0, i = i + Math.imul(H, It) | 0, g = g + Math.imul(H, kt) | 0, h = h + Math.imul(B, Ut) | 0, i = i + Math.imul(B, Nt) | 0, i = i + Math.imul(I, Ut) | 0, g = g + Math.imul(I, Nt) | 0;
+      var sr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (sr >>> 26) | 0, sr &= 67108863, h = Math.imul(ut, gt), i = Math.imul(ut, pt), i = i + Math.imul(dt, gt) | 0, g = Math.imul(dt, pt), h = h + Math.imul(ht, yt) | 0, i = i + Math.imul(ht, vt) | 0, i = i + Math.imul(lt, yt) | 0, g = g + Math.imul(lt, vt) | 0, h = h + Math.imul(at, xt) | 0, i = i + Math.imul(at, bt) | 0, i = i + Math.imul(ct, xt) | 0, g = g + Math.imul(ct, bt) | 0, h = h + Math.imul(rt, Et) | 0, i = i + Math.imul(rt, Mt) | 0, i = i + Math.imul(nt, Et) | 0, g = g + Math.imul(nt, Mt) | 0, h = h + Math.imul(tt, _t) | 0, i = i + Math.imul(tt, Bt) | 0, i = i + Math.imul(et, _t) | 0, g = g + Math.imul(et, Bt) | 0, h = h + Math.imul(j, At) | 0, i = i + Math.imul(j, St) | 0, i = i + Math.imul(J, At) | 0, g = g + Math.imul(J, St) | 0, h = h + Math.imul(K, It) | 0, i = i + Math.imul(K, kt) | 0, i = i + Math.imul(Y, It) | 0, g = g + Math.imul(Y, kt) | 0, h = h + Math.imul(Z, Ut) | 0, i = i + Math.imul(Z, Nt) | 0, i = i + Math.imul(H, Ut) | 0, g = g + Math.imul(H, Nt) | 0, h = h + Math.imul(B, Rt) | 0, i = i + Math.imul(B, Ot) | 0, i = i + Math.imul(I, Rt) | 0, g = g + Math.imul(I, Ot) | 0;
+      var fr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (fr >>> 26) | 0, fr &= 67108863, h = Math.imul(wt, gt), i = Math.imul(wt, pt), i = i + Math.imul(mt, gt) | 0, g = Math.imul(mt, pt), h = h + Math.imul(ut, yt) | 0, i = i + Math.imul(ut, vt) | 0, i = i + Math.imul(dt, yt) | 0, g = g + Math.imul(dt, vt) | 0, h = h + Math.imul(ht, xt) | 0, i = i + Math.imul(ht, bt) | 0, i = i + Math.imul(lt, xt) | 0, g = g + Math.imul(lt, bt) | 0, h = h + Math.imul(at, Et) | 0, i = i + Math.imul(at, Mt) | 0, i = i + Math.imul(ct, Et) | 0, g = g + Math.imul(ct, Mt) | 0, h = h + Math.imul(rt, _t) | 0, i = i + Math.imul(rt, Bt) | 0, i = i + Math.imul(nt, _t) | 0, g = g + Math.imul(nt, Bt) | 0, h = h + Math.imul(tt, At) | 0, i = i + Math.imul(tt, St) | 0, i = i + Math.imul(et, At) | 0, g = g + Math.imul(et, St) | 0, h = h + Math.imul(j, It) | 0, i = i + Math.imul(j, kt) | 0, i = i + Math.imul(J, It) | 0, g = g + Math.imul(J, kt) | 0, h = h + Math.imul(K, Ut) | 0, i = i + Math.imul(K, Nt) | 0, i = i + Math.imul(Y, Ut) | 0, g = g + Math.imul(Y, Nt) | 0, h = h + Math.imul(Z, Rt) | 0, i = i + Math.imul(Z, Ot) | 0, i = i + Math.imul(H, Rt) | 0, g = g + Math.imul(H, Ot) | 0, h = h + Math.imul(B, Tt) | 0, i = i + Math.imul(B, Lt) | 0, i = i + Math.imul(I, Tt) | 0, g = g + Math.imul(I, Lt) | 0;
+      var ar = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (ar >>> 26) | 0, ar &= 67108863, h = Math.imul(wt, yt), i = Math.imul(wt, vt), i = i + Math.imul(mt, yt) | 0, g = Math.imul(mt, vt), h = h + Math.imul(ut, xt) | 0, i = i + Math.imul(ut, bt) | 0, i = i + Math.imul(dt, xt) | 0, g = g + Math.imul(dt, bt) | 0, h = h + Math.imul(ht, Et) | 0, i = i + Math.imul(ht, Mt) | 0, i = i + Math.imul(lt, Et) | 0, g = g + Math.imul(lt, Mt) | 0, h = h + Math.imul(at, _t) | 0, i = i + Math.imul(at, Bt) | 0, i = i + Math.imul(ct, _t) | 0, g = g + Math.imul(ct, Bt) | 0, h = h + Math.imul(rt, At) | 0, i = i + Math.imul(rt, St) | 0, i = i + Math.imul(nt, At) | 0, g = g + Math.imul(nt, St) | 0, h = h + Math.imul(tt, It) | 0, i = i + Math.imul(tt, kt) | 0, i = i + Math.imul(et, It) | 0, g = g + Math.imul(et, kt) | 0, h = h + Math.imul(j, Ut) | 0, i = i + Math.imul(j, Nt) | 0, i = i + Math.imul(J, Ut) | 0, g = g + Math.imul(J, Nt) | 0, h = h + Math.imul(K, Rt) | 0, i = i + Math.imul(K, Ot) | 0, i = i + Math.imul(Y, Rt) | 0, g = g + Math.imul(Y, Ot) | 0, h = h + Math.imul(Z, Tt) | 0, i = i + Math.imul(Z, Lt) | 0, i = i + Math.imul(H, Tt) | 0, g = g + Math.imul(H, Lt) | 0;
+      var cr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (cr >>> 26) | 0, cr &= 67108863, h = Math.imul(wt, xt), i = Math.imul(wt, bt), i = i + Math.imul(mt, xt) | 0, g = Math.imul(mt, bt), h = h + Math.imul(ut, Et) | 0, i = i + Math.imul(ut, Mt) | 0, i = i + Math.imul(dt, Et) | 0, g = g + Math.imul(dt, Mt) | 0, h = h + Math.imul(ht, _t) | 0, i = i + Math.imul(ht, Bt) | 0, i = i + Math.imul(lt, _t) | 0, g = g + Math.imul(lt, Bt) | 0, h = h + Math.imul(at, At) | 0, i = i + Math.imul(at, St) | 0, i = i + Math.imul(ct, At) | 0, g = g + Math.imul(ct, St) | 0, h = h + Math.imul(rt, It) | 0, i = i + Math.imul(rt, kt) | 0, i = i + Math.imul(nt, It) | 0, g = g + Math.imul(nt, kt) | 0, h = h + Math.imul(tt, Ut) | 0, i = i + Math.imul(tt, Nt) | 0, i = i + Math.imul(et, Ut) | 0, g = g + Math.imul(et, Nt) | 0, h = h + Math.imul(j, Rt) | 0, i = i + Math.imul(j, Ot) | 0, i = i + Math.imul(J, Rt) | 0, g = g + Math.imul(J, Ot) | 0, h = h + Math.imul(K, Tt) | 0, i = i + Math.imul(K, Lt) | 0, i = i + Math.imul(Y, Tt) | 0, g = g + Math.imul(Y, Lt) | 0;
+      var hr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (hr >>> 26) | 0, hr &= 67108863, h = Math.imul(wt, Et), i = Math.imul(wt, Mt), i = i + Math.imul(mt, Et) | 0, g = Math.imul(mt, Mt), h = h + Math.imul(ut, _t) | 0, i = i + Math.imul(ut, Bt) | 0, i = i + Math.imul(dt, _t) | 0, g = g + Math.imul(dt, Bt) | 0, h = h + Math.imul(ht, At) | 0, i = i + Math.imul(ht, St) | 0, i = i + Math.imul(lt, At) | 0, g = g + Math.imul(lt, St) | 0, h = h + Math.imul(at, It) | 0, i = i + Math.imul(at, kt) | 0, i = i + Math.imul(ct, It) | 0, g = g + Math.imul(ct, kt) | 0, h = h + Math.imul(rt, Ut) | 0, i = i + Math.imul(rt, Nt) | 0, i = i + Math.imul(nt, Ut) | 0, g = g + Math.imul(nt, Nt) | 0, h = h + Math.imul(tt, Rt) | 0, i = i + Math.imul(tt, Ot) | 0, i = i + Math.imul(et, Rt) | 0, g = g + Math.imul(et, Ot) | 0, h = h + Math.imul(j, Tt) | 0, i = i + Math.imul(j, Lt) | 0, i = i + Math.imul(J, Tt) | 0, g = g + Math.imul(J, Lt) | 0;
+      var lr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (lr >>> 26) | 0, lr &= 67108863, h = Math.imul(wt, _t), i = Math.imul(wt, Bt), i = i + Math.imul(mt, _t) | 0, g = Math.imul(mt, Bt), h = h + Math.imul(ut, At) | 0, i = i + Math.imul(ut, St) | 0, i = i + Math.imul(dt, At) | 0, g = g + Math.imul(dt, St) | 0, h = h + Math.imul(ht, It) | 0, i = i + Math.imul(ht, kt) | 0, i = i + Math.imul(lt, It) | 0, g = g + Math.imul(lt, kt) | 0, h = h + Math.imul(at, Ut) | 0, i = i + Math.imul(at, Nt) | 0, i = i + Math.imul(ct, Ut) | 0, g = g + Math.imul(ct, Nt) | 0, h = h + Math.imul(rt, Rt) | 0, i = i + Math.imul(rt, Ot) | 0, i = i + Math.imul(nt, Rt) | 0, g = g + Math.imul(nt, Ot) | 0, h = h + Math.imul(tt, Tt) | 0, i = i + Math.imul(tt, Lt) | 0, i = i + Math.imul(et, Tt) | 0, g = g + Math.imul(et, Lt) | 0;
+      var ur = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (ur >>> 26) | 0, ur &= 67108863, h = Math.imul(wt, At), i = Math.imul(wt, St), i = i + Math.imul(mt, At) | 0, g = Math.imul(mt, St), h = h + Math.imul(ut, It) | 0, i = i + Math.imul(ut, kt) | 0, i = i + Math.imul(dt, It) | 0, g = g + Math.imul(dt, kt) | 0, h = h + Math.imul(ht, Ut) | 0, i = i + Math.imul(ht, Nt) | 0, i = i + Math.imul(lt, Ut) | 0, g = g + Math.imul(lt, Nt) | 0, h = h + Math.imul(at, Rt) | 0, i = i + Math.imul(at, Ot) | 0, i = i + Math.imul(ct, Rt) | 0, g = g + Math.imul(ct, Ot) | 0, h = h + Math.imul(rt, Tt) | 0, i = i + Math.imul(rt, Lt) | 0, i = i + Math.imul(nt, Tt) | 0, g = g + Math.imul(nt, Lt) | 0;
+      var dr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (dr >>> 26) | 0, dr &= 67108863, h = Math.imul(wt, It), i = Math.imul(wt, kt), i = i + Math.imul(mt, It) | 0, g = Math.imul(mt, kt), h = h + Math.imul(ut, Ut) | 0, i = i + Math.imul(ut, Nt) | 0, i = i + Math.imul(dt, Ut) | 0, g = g + Math.imul(dt, Nt) | 0, h = h + Math.imul(ht, Rt) | 0, i = i + Math.imul(ht, Ot) | 0, i = i + Math.imul(lt, Rt) | 0, g = g + Math.imul(lt, Ot) | 0, h = h + Math.imul(at, Tt) | 0, i = i + Math.imul(at, Lt) | 0, i = i + Math.imul(ct, Tt) | 0, g = g + Math.imul(ct, Lt) | 0;
+      var wr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (wr >>> 26) | 0, wr &= 67108863, h = Math.imul(wt, Ut), i = Math.imul(wt, Nt), i = i + Math.imul(mt, Ut) | 0, g = Math.imul(mt, Nt), h = h + Math.imul(ut, Rt) | 0, i = i + Math.imul(ut, Ot) | 0, i = i + Math.imul(dt, Rt) | 0, g = g + Math.imul(dt, Ot) | 0, h = h + Math.imul(ht, Tt) | 0, i = i + Math.imul(ht, Lt) | 0, i = i + Math.imul(lt, Tt) | 0, g = g + Math.imul(lt, Lt) | 0;
+      var mr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (mr >>> 26) | 0, mr &= 67108863, h = Math.imul(wt, Rt), i = Math.imul(wt, Ot), i = i + Math.imul(mt, Rt) | 0, g = Math.imul(mt, Ot), h = h + Math.imul(ut, Tt) | 0, i = i + Math.imul(ut, Lt) | 0, i = i + Math.imul(dt, Tt) | 0, g = g + Math.imul(dt, Lt) | 0;
+      var gr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      y = (g + (i >>> 13) | 0) + (gr >>> 26) | 0, gr &= 67108863, h = Math.imul(wt, Tt), i = Math.imul(wt, Lt), i = i + Math.imul(mt, Tt) | 0, g = Math.imul(mt, Lt);
+      var pr = (y + h | 0) + ((i & 8191) << 13) | 0;
+      return y = (g + (i >>> 13) | 0) + (pr >>> 26) | 0, pr &= 67108863, u[0] = Fe, u[1] = tr, u[2] = er, u[3] = rr, u[4] = nr, u[5] = ir, u[6] = or, u[7] = sr, u[8] = fr, u[9] = ar, u[10] = cr, u[11] = hr, u[12] = lr, u[13] = ur, u[14] = dr, u[15] = wr, u[16] = mr, u[17] = gr, u[18] = pr, y !== 0 && (u[19] = y, a.length++), a;
+    };
+    Math.imul || (st = z);
+    function L(p, n, f) {
+      f.negative = n.negative ^ p.negative, f.length = p.length + n.length;
+      for (var a = 0, d = 0, l = 0; l < f.length - 1; l++) {
+        var u = d;
+        d = 0;
+        for (var y = a & 67108863, h = Math.min(l, n.length - 1), i = Math.max(0, l - p.length + 1); i <= h; i++) {
+          var g = l - i, A = p.words[g] | 0, B = n.words[i] | 0, I = A * B, P = I & 67108863;
+          u = u + (I / 67108864 | 0) | 0, P = P + y | 0, y = P & 67108863, u = u + (P >>> 26) | 0, d += u >>> 26, u &= 67108863;
+        }
+        f.words[l] = y, a = u, u = d;
+      }
+      return a !== 0 ? f.words[l] = a : f.length--, f._strip();
+    }
+    function M(p, n, f) {
+      return L(p, n, f);
+    }
+    s.prototype.mulTo = function(n, f) {
+      var a, d = this.length + n.length;
+      return this.length === 10 && n.length === 10 ? a = st(this, n, f) : d < 63 ? a = z(this, n, f) : d < 1024 ? a = L(this, n, f) : a = M(this, n, f), a;
+    }, s.prototype.mul = function(n) {
+      var f = new s(null);
+      return f.words = new Array(this.length + n.length), this.mulTo(n, f);
+    }, s.prototype.mulf = function(n) {
+      var f = new s(null);
+      return f.words = new Array(this.length + n.length), M(this, n, f);
+    }, s.prototype.imul = function(n) {
+      return this.clone().mulTo(n, this);
+    }, s.prototype.imuln = function(n) {
+      var f = n < 0;
+      f && (n = -n), o(typeof n == "number"), o(n < 67108864);
+      for (var a = 0, d = 0; d < this.length; d++) {
+        var l = (this.words[d] | 0) * n, u = (l & 67108863) + (a & 67108863);
+        a >>= 26, a += l / 67108864 | 0, a += u >>> 26, this.words[d] = u & 67108863;
+      }
+      return a !== 0 && (this.words[d] = a, this.length++), this.length = n === 0 ? 1 : this.length, f ? this.ineg() : this;
+    }, s.prototype.muln = function(n) {
+      return this.clone().imuln(n);
+    }, s.prototype.sqr = function() {
+      return this.mul(this);
+    }, s.prototype.isqr = function() {
+      return this.imul(this.clone());
+    }, s.prototype.pow = function(n) {
+      var f = X(n);
+      if (f.length === 0) return new s(1);
+      for (var a = this, d = 0; d < f.length && f[d] === 0; d++, a = a.sqr())
+        ;
+      if (++d < f.length)
+        for (var l = a.sqr(); d < f.length; d++, l = l.sqr())
+          f[d] !== 0 && (a = a.mul(l));
+      return a;
+    }, s.prototype.iushln = function(n) {
+      o(typeof n == "number" && n >= 0);
+      var f = n % 26, a = (n - f) / 26, d = 67108863 >>> 26 - f << 26 - f, l;
+      if (f !== 0) {
+        var u = 0;
+        for (l = 0; l < this.length; l++) {
+          var y = this.words[l] & d, h = (this.words[l] | 0) - y << f;
+          this.words[l] = h | u, u = y >>> 26 - f;
+        }
+        u && (this.words[l] = u, this.length++);
+      }
+      if (a !== 0) {
+        for (l = this.length - 1; l >= 0; l--)
+          this.words[l + a] = this.words[l];
+        for (l = 0; l < a; l++)
+          this.words[l] = 0;
+        this.length += a;
+      }
+      return this._strip();
+    }, s.prototype.ishln = function(n) {
+      return o(this.negative === 0), this.iushln(n);
+    }, s.prototype.iushrn = function(n, f, a) {
+      o(typeof n == "number" && n >= 0);
+      var d;
+      f ? d = (f - f % 26) / 26 : d = 0;
+      var l = n % 26, u = Math.min((n - l) / 26, this.length), y = 67108863 ^ 67108863 >>> l << l, h = a;
+      if (d -= u, d = Math.max(0, d), h) {
+        for (var i = 0; i < u; i++)
+          h.words[i] = this.words[i];
+        h.length = u;
+      }
+      if (u !== 0) if (this.length > u)
+        for (this.length -= u, i = 0; i < this.length; i++)
+          this.words[i] = this.words[i + u];
+      else
+        this.words[0] = 0, this.length = 1;
+      var g = 0;
+      for (i = this.length - 1; i >= 0 && (g !== 0 || i >= d); i--) {
+        var A = this.words[i] | 0;
+        this.words[i] = g << 26 - l | A >>> l, g = A & y;
+      }
+      return h && g !== 0 && (h.words[h.length++] = g), this.length === 0 && (this.words[0] = 0, this.length = 1), this._strip();
+    }, s.prototype.ishrn = function(n, f, a) {
+      return o(this.negative === 0), this.iushrn(n, f, a);
+    }, s.prototype.shln = function(n) {
+      return this.clone().ishln(n);
+    }, s.prototype.ushln = function(n) {
+      return this.clone().iushln(n);
+    }, s.prototype.shrn = function(n) {
+      return this.clone().ishrn(n);
+    }, s.prototype.ushrn = function(n) {
+      return this.clone().iushrn(n);
+    }, s.prototype.testn = function(n) {
+      o(typeof n == "number" && n >= 0);
+      var f = n % 26, a = (n - f) / 26, d = 1 << f;
+      if (this.length <= a) return !1;
+      var l = this.words[a];
+      return !!(l & d);
+    }, s.prototype.imaskn = function(n) {
+      o(typeof n == "number" && n >= 0);
+      var f = n % 26, a = (n - f) / 26;
+      if (o(this.negative === 0, "imaskn works only with positive numbers"), this.length <= a)
+        return this;
+      if (f !== 0 && a++, this.length = Math.min(a, this.length), f !== 0) {
+        var d = 67108863 ^ 67108863 >>> f << f;
+        this.words[this.length - 1] &= d;
+      }
+      return this._strip();
+    }, s.prototype.maskn = function(n) {
+      return this.clone().imaskn(n);
+    }, s.prototype.iaddn = function(n) {
+      return o(typeof n == "number"), o(n < 67108864), n < 0 ? this.isubn(-n) : this.negative !== 0 ? this.length === 1 && (this.words[0] | 0) <= n ? (this.words[0] = n - (this.words[0] | 0), this.negative = 0, this) : (this.negative = 0, this.isubn(n), this.negative = 1, this) : this._iaddn(n);
+    }, s.prototype._iaddn = function(n) {
+      this.words[0] += n;
+      for (var f = 0; f < this.length && this.words[f] >= 67108864; f++)
+        this.words[f] -= 67108864, f === this.length - 1 ? this.words[f + 1] = 1 : this.words[f + 1]++;
+      return this.length = Math.max(this.length, f + 1), this;
+    }, s.prototype.isubn = function(n) {
+      if (o(typeof n == "number"), o(n < 67108864), n < 0) return this.iaddn(-n);
+      if (this.negative !== 0)
+        return this.negative = 0, this.iaddn(n), this.negative = 1, this;
+      if (this.words[0] -= n, this.length === 1 && this.words[0] < 0)
+        this.words[0] = -this.words[0], this.negative = 1;
+      else
+        for (var f = 0; f < this.length && this.words[f] < 0; f++)
+          this.words[f] += 67108864, this.words[f + 1] -= 1;
+      return this._strip();
+    }, s.prototype.addn = function(n) {
+      return this.clone().iaddn(n);
+    }, s.prototype.subn = function(n) {
+      return this.clone().isubn(n);
+    }, s.prototype.iabs = function() {
+      return this.negative = 0, this;
+    }, s.prototype.abs = function() {
+      return this.clone().iabs();
+    }, s.prototype._ishlnsubmul = function(n, f, a) {
+      var d = n.length + a, l;
+      this._expand(d);
+      var u, y = 0;
+      for (l = 0; l < n.length; l++) {
+        u = (this.words[l + a] | 0) + y;
+        var h = (n.words[l] | 0) * f;
+        u -= h & 67108863, y = (u >> 26) - (h / 67108864 | 0), this.words[l + a] = u & 67108863;
+      }
+      for (; l < this.length - a; l++)
+        u = (this.words[l + a] | 0) + y, y = u >> 26, this.words[l + a] = u & 67108863;
+      if (y === 0) return this._strip();
+      for (o(y === -1), y = 0, l = 0; l < this.length; l++)
+        u = -(this.words[l] | 0) + y, y = u >> 26, this.words[l] = u & 67108863;
+      return this.negative = 1, this._strip();
+    }, s.prototype._wordDiv = function(n, f) {
+      var a = this.length - n.length, d = this.clone(), l = n, u = l.words[l.length - 1] | 0, y = this._countBits(u);
+      a = 26 - y, a !== 0 && (l = l.ushln(a), d.iushln(a), u = l.words[l.length - 1] | 0);
+      var h = d.length - l.length, i;
+      if (f !== "mod") {
+        i = new s(null), i.length = h + 1, i.words = new Array(i.length);
+        for (var g = 0; g < i.length; g++)
+          i.words[g] = 0;
+      }
+      var A = d.clone()._ishlnsubmul(l, 1, h);
+      A.negative === 0 && (d = A, i && (i.words[h] = 1));
+      for (var B = h - 1; B >= 0; B--) {
+        var I = (d.words[l.length + B] | 0) * 67108864 + (d.words[l.length + B - 1] | 0);
+        for (I = Math.min(I / u | 0, 67108863), d._ishlnsubmul(l, I, B); d.negative !== 0; )
+          I--, d.negative = 0, d._ishlnsubmul(l, 1, B), d.isZero() || (d.negative ^= 1);
+        i && (i.words[B] = I);
+      }
+      return i && i._strip(), d._strip(), f !== "div" && a !== 0 && d.iushrn(a), {
+        div: i || null,
+        mod: d
+      };
+    }, s.prototype.divmod = function(n, f, a) {
+      if (o(!n.isZero()), this.isZero())
+        return {
+          div: new s(0),
+          mod: new s(0)
+        };
+      var d, l, u;
+      return this.negative !== 0 && n.negative === 0 ? (u = this.neg().divmod(n, f), f !== "mod" && (d = u.div.neg()), f !== "div" && (l = u.mod.neg(), a && l.negative !== 0 && l.iadd(n)), {
+        div: d,
+        mod: l
+      }) : this.negative === 0 && n.negative !== 0 ? (u = this.divmod(n.neg(), f), f !== "mod" && (d = u.div.neg()), {
+        div: d,
+        mod: u.mod
+      }) : (this.negative & n.negative) !== 0 ? (u = this.neg().divmod(n.neg(), f), f !== "div" && (l = u.mod.neg(), a && l.negative !== 0 && l.isub(n)), {
+        div: u.div,
+        mod: l
+      }) : n.length > this.length || this.cmp(n) < 0 ? {
+        div: new s(0),
+        mod: this
+      } : n.length === 1 ? f === "div" ? {
+        div: this.divn(n.words[0]),
+        mod: null
+      } : f === "mod" ? {
+        div: null,
+        mod: new s(this.modrn(n.words[0]))
+      } : {
+        div: this.divn(n.words[0]),
+        mod: new s(this.modrn(n.words[0]))
+      } : this._wordDiv(n, f);
+    }, s.prototype.div = function(n) {
+      return this.divmod(n, "div", !1).div;
+    }, s.prototype.mod = function(n) {
+      return this.divmod(n, "mod", !1).mod;
+    }, s.prototype.umod = function(n) {
+      return this.divmod(n, "mod", !0).mod;
+    }, s.prototype.divRound = function(n) {
+      var f = this.divmod(n);
+      if (f.mod.isZero()) return f.div;
+      var a = f.div.negative !== 0 ? f.mod.isub(n) : f.mod, d = n.ushrn(1), l = n.andln(1), u = a.cmp(d);
+      return u < 0 || l === 1 && u === 0 ? f.div : f.div.negative !== 0 ? f.div.isubn(1) : f.div.iaddn(1);
+    }, s.prototype.modrn = function(n) {
+      var f = n < 0;
+      f && (n = -n), o(n <= 67108863);
+      for (var a = (1 << 26) % n, d = 0, l = this.length - 1; l >= 0; l--)
+        d = (a * d + (this.words[l] | 0)) % n;
+      return f ? -d : d;
+    }, s.prototype.modn = function(n) {
+      return this.modrn(n);
+    }, s.prototype.idivn = function(n) {
+      var f = n < 0;
+      f && (n = -n), o(n <= 67108863);
+      for (var a = 0, d = this.length - 1; d >= 0; d--) {
+        var l = (this.words[d] | 0) + a * 67108864;
+        this.words[d] = l / n | 0, a = l % n;
+      }
+      return this._strip(), f ? this.ineg() : this;
+    }, s.prototype.divn = function(n) {
+      return this.clone().idivn(n);
+    }, s.prototype.egcd = function(n) {
+      o(n.negative === 0), o(!n.isZero());
+      var f = this, a = n.clone();
+      f.negative !== 0 ? f = f.umod(n) : f = f.clone();
+      for (var d = new s(1), l = new s(0), u = new s(0), y = new s(1), h = 0; f.isEven() && a.isEven(); )
+        f.iushrn(1), a.iushrn(1), ++h;
+      for (var i = a.clone(), g = f.clone(); !f.isZero(); ) {
+        for (var A = 0, B = 1; (f.words[0] & B) === 0 && A < 26; ++A, B <<= 1) ;
+        if (A > 0)
+          for (f.iushrn(A); A-- > 0; )
+            (d.isOdd() || l.isOdd()) && (d.iadd(i), l.isub(g)), d.iushrn(1), l.iushrn(1);
+        for (var I = 0, P = 1; (a.words[0] & P) === 0 && I < 26; ++I, P <<= 1) ;
+        if (I > 0)
+          for (a.iushrn(I); I-- > 0; )
+            (u.isOdd() || y.isOdd()) && (u.iadd(i), y.isub(g)), u.iushrn(1), y.iushrn(1);
+        f.cmp(a) >= 0 ? (f.isub(a), d.isub(u), l.isub(y)) : (a.isub(f), u.isub(d), y.isub(l));
+      }
+      return {
+        a: u,
+        b: y,
+        gcd: a.iushln(h)
+      };
+    }, s.prototype._invmp = function(n) {
+      o(n.negative === 0), o(!n.isZero());
+      var f = this, a = n.clone();
+      f.negative !== 0 ? f = f.umod(n) : f = f.clone();
+      for (var d = new s(1), l = new s(0), u = a.clone(); f.cmpn(1) > 0 && a.cmpn(1) > 0; ) {
+        for (var y = 0, h = 1; (f.words[0] & h) === 0 && y < 26; ++y, h <<= 1) ;
+        if (y > 0)
+          for (f.iushrn(y); y-- > 0; )
+            d.isOdd() && d.iadd(u), d.iushrn(1);
+        for (var i = 0, g = 1; (a.words[0] & g) === 0 && i < 26; ++i, g <<= 1) ;
+        if (i > 0)
+          for (a.iushrn(i); i-- > 0; )
+            l.isOdd() && l.iadd(u), l.iushrn(1);
+        f.cmp(a) >= 0 ? (f.isub(a), d.isub(l)) : (a.isub(f), l.isub(d));
+      }
+      var A;
+      return f.cmpn(1) === 0 ? A = d : A = l, A.cmpn(0) < 0 && A.iadd(n), A;
+    }, s.prototype.gcd = function(n) {
+      if (this.isZero()) return n.abs();
+      if (n.isZero()) return this.abs();
+      var f = this.clone(), a = n.clone();
+      f.negative = 0, a.negative = 0;
+      for (var d = 0; f.isEven() && a.isEven(); d++)
+        f.iushrn(1), a.iushrn(1);
+      do {
+        for (; f.isEven(); )
+          f.iushrn(1);
+        for (; a.isEven(); )
+          a.iushrn(1);
+        var l = f.cmp(a);
+        if (l < 0) {
+          var u = f;
+          f = a, a = u;
+        } else if (l === 0 || a.cmpn(1) === 0)
+          break;
+        f.isub(a);
+      } while (!0);
+      return a.iushln(d);
+    }, s.prototype.invm = function(n) {
+      return this.egcd(n).a.umod(n);
+    }, s.prototype.isEven = function() {
+      return (this.words[0] & 1) === 0;
+    }, s.prototype.isOdd = function() {
+      return (this.words[0] & 1) === 1;
+    }, s.prototype.andln = function(n) {
+      return this.words[0] & n;
+    }, s.prototype.bincn = function(n) {
+      o(typeof n == "number");
+      var f = n % 26, a = (n - f) / 26, d = 1 << f;
+      if (this.length <= a)
+        return this._expand(a + 1), this.words[a] |= d, this;
+      for (var l = d, u = a; l !== 0 && u < this.length; u++) {
+        var y = this.words[u] | 0;
+        y += l, l = y >>> 26, y &= 67108863, this.words[u] = y;
+      }
+      return l !== 0 && (this.words[u] = l, this.length++), this;
+    }, s.prototype.isZero = function() {
+      return this.length === 1 && this.words[0] === 0;
+    }, s.prototype.cmpn = function(n) {
+      var f = n < 0;
+      if (this.negative !== 0 && !f) return -1;
+      if (this.negative === 0 && f) return 1;
+      this._strip();
+      var a;
+      if (this.length > 1)
+        a = 1;
+      else {
+        f && (n = -n), o(n <= 67108863, "Number is too big");
+        var d = this.words[0] | 0;
+        a = d === n ? 0 : d < n ? -1 : 1;
+      }
+      return this.negative !== 0 ? -a | 0 : a;
+    }, s.prototype.cmp = function(n) {
+      if (this.negative !== 0 && n.negative === 0) return -1;
+      if (this.negative === 0 && n.negative !== 0) return 1;
+      var f = this.ucmp(n);
+      return this.negative !== 0 ? -f | 0 : f;
+    }, s.prototype.ucmp = function(n) {
+      if (this.length > n.length) return 1;
+      if (this.length < n.length) return -1;
+      for (var f = 0, a = this.length - 1; a >= 0; a--) {
+        var d = this.words[a] | 0, l = n.words[a] | 0;
+        if (d !== l) {
+          d < l ? f = -1 : d > l && (f = 1);
+          break;
+        }
+      }
+      return f;
+    }, s.prototype.gtn = function(n) {
+      return this.cmpn(n) === 1;
+    }, s.prototype.gt = function(n) {
+      return this.cmp(n) === 1;
+    }, s.prototype.gten = function(n) {
+      return this.cmpn(n) >= 0;
+    }, s.prototype.gte = function(n) {
+      return this.cmp(n) >= 0;
+    }, s.prototype.ltn = function(n) {
+      return this.cmpn(n) === -1;
+    }, s.prototype.lt = function(n) {
+      return this.cmp(n) === -1;
+    }, s.prototype.lten = function(n) {
+      return this.cmpn(n) <= 0;
+    }, s.prototype.lte = function(n) {
+      return this.cmp(n) <= 0;
+    }, s.prototype.eqn = function(n) {
+      return this.cmpn(n) === 0;
+    }, s.prototype.eq = function(n) {
+      return this.cmp(n) === 0;
+    }, s.red = function(n) {
+      return new S(n);
+    }, s.prototype.toRed = function(n) {
+      return o(!this.red, "Already a number in reduction context"), o(this.negative === 0, "red works only with positives"), n.convertTo(this)._forceRed(n);
+    }, s.prototype.fromRed = function() {
+      return o(this.red, "fromRed works only with numbers in reduction context"), this.red.convertFrom(this);
+    }, s.prototype._forceRed = function(n) {
+      return this.red = n, this;
+    }, s.prototype.forceRed = function(n) {
+      return o(!this.red, "Already a number in reduction context"), this._forceRed(n);
+    }, s.prototype.redAdd = function(n) {
+      return o(this.red, "redAdd works only with red numbers"), this.red.add(this, n);
+    }, s.prototype.redIAdd = function(n) {
+      return o(this.red, "redIAdd works only with red numbers"), this.red.iadd(this, n);
+    }, s.prototype.redSub = function(n) {
+      return o(this.red, "redSub works only with red numbers"), this.red.sub(this, n);
+    }, s.prototype.redISub = function(n) {
+      return o(this.red, "redISub works only with red numbers"), this.red.isub(this, n);
+    }, s.prototype.redShl = function(n) {
+      return o(this.red, "redShl works only with red numbers"), this.red.shl(this, n);
+    }, s.prototype.redMul = function(n) {
+      return o(this.red, "redMul works only with red numbers"), this.red._verify2(this, n), this.red.mul(this, n);
+    }, s.prototype.redIMul = function(n) {
+      return o(this.red, "redMul works only with red numbers"), this.red._verify2(this, n), this.red.imul(this, n);
+    }, s.prototype.redSqr = function() {
+      return o(this.red, "redSqr works only with red numbers"), this.red._verify1(this), this.red.sqr(this);
+    }, s.prototype.redISqr = function() {
+      return o(this.red, "redISqr works only with red numbers"), this.red._verify1(this), this.red.isqr(this);
+    }, s.prototype.redSqrt = function() {
+      return o(this.red, "redSqrt works only with red numbers"), this.red._verify1(this), this.red.sqrt(this);
+    }, s.prototype.redInvm = function() {
+      return o(this.red, "redInvm works only with red numbers"), this.red._verify1(this), this.red.invm(this);
+    }, s.prototype.redNeg = function() {
+      return o(this.red, "redNeg works only with red numbers"), this.red._verify1(this), this.red.neg(this);
+    }, s.prototype.redPow = function(n) {
+      return o(this.red && !n.red, "redPow(normalNum)"), this.red._verify1(this), this.red.pow(this, n);
+    };
+    var U = {
+      k256: null,
+      p224: null,
+      p192: null,
+      p25519: null
+    };
+    function N(p, n) {
+      this.name = p, this.p = new s(n, 16), this.n = this.p.bitLength(), this.k = new s(1).iushln(this.n).isub(this.p), this.tmp = this._tmp();
+    }
+    N.prototype._tmp = function() {
+      var n = new s(null);
+      return n.words = new Array(Math.ceil(this.n / 13)), n;
+    }, N.prototype.ireduce = function(n) {
+      var f = n, a;
+      do
+        this.split(f, this.tmp), f = this.imulK(f), f = f.iadd(this.tmp), a = f.bitLength();
+      while (a > this.n);
+      var d = a < this.n ? -1 : f.ucmp(this.p);
+      return d === 0 ? (f.words[0] = 0, f.length = 1) : d > 0 ? f.isub(this.p) : f.strip !== void 0 ? f.strip() : f._strip(), f;
+    }, N.prototype.split = function(n, f) {
+      n.iushrn(this.n, 0, f);
+    }, N.prototype.imulK = function(n) {
+      return n.imul(this.k);
+    };
+    function O() {
+      N.call(
+        this,
+        "k256",
+        "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f"
+      );
+    }
+    c(O, N), O.prototype.split = function(n, f) {
+      for (var a = 4194303, d = Math.min(n.length, 9), l = 0; l < d; l++)
+        f.words[l] = n.words[l];
+      if (f.length = d, n.length <= 9) {
+        n.words[0] = 0, n.length = 1;
+        return;
+      }
+      var u = n.words[9];
+      for (f.words[f.length++] = u & a, l = 10; l < n.length; l++) {
+        var y = n.words[l] | 0;
+        n.words[l - 10] = (y & a) << 4 | u >>> 22, u = y;
+      }
+      u >>>= 22, n.words[l - 10] = u, u === 0 && n.length > 10 ? n.length -= 10 : n.length -= 9;
+    }, O.prototype.imulK = function(n) {
+      n.words[n.length] = 0, n.words[n.length + 1] = 0, n.length += 2;
+      for (var f = 0, a = 0; a < n.length; a++) {
+        var d = n.words[a] | 0;
+        f += d * 977, n.words[a] = f & 67108863, f = d * 64 + (f / 67108864 | 0);
+      }
+      return n.words[n.length - 1] === 0 && (n.length--, n.words[n.length - 1] === 0 && n.length--), n;
+    };
+    function $() {
+      N.call(
+        this,
+        "p224",
+        "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001"
+      );
+    }
+    c($, N);
+    function V() {
+      N.call(
+        this,
+        "p192",
+        "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
+      );
+    }
+    c(V, N);
+    function D() {
+      N.call(
+        this,
+        "25519",
+        "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
+      );
+    }
+    c(D, N), D.prototype.imulK = function(n) {
+      for (var f = 0, a = 0; a < n.length; a++) {
+        var d = (n.words[a] | 0) * 19 + f, l = d & 67108863;
+        d >>>= 26, n.words[a] = l, f = d;
+      }
+      return f !== 0 && (n.words[n.length++] = f), n;
+    }, s._prime = function(n) {
+      if (U[n]) return U[n];
+      var f;
+      if (n === "k256")
+        f = new O();
+      else if (n === "p224")
+        f = new $();
+      else if (n === "p192")
+        f = new V();
+      else if (n === "p25519")
+        f = new D();
+      else
+        throw new Error("Unknown prime " + n);
+      return U[n] = f, f;
+    };
+    function S(p) {
+      if (typeof p == "string") {
+        var n = s._prime(p);
+        this.m = n.p, this.prime = n;
+      } else
+        o(p.gtn(1), "modulus must be greater than 1"), this.m = p, this.prime = null;
+    }
+    S.prototype._verify1 = function(n) {
+      o(n.negative === 0, "red works only with positives"), o(n.red, "red works only with red numbers");
+    }, S.prototype._verify2 = function(n, f) {
+      o((n.negative | f.negative) === 0, "red works only with positives"), o(
+        n.red && n.red === f.red,
+        "red works only with red numbers"
+      );
+    }, S.prototype.imod = function(n) {
+      return this.prime ? this.prime.ireduce(n)._forceRed(this) : (x(n, n.umod(this.m)._forceRed(this)), n);
+    }, S.prototype.neg = function(n) {
+      return n.isZero() ? n.clone() : this.m.sub(n)._forceRed(this);
+    }, S.prototype.add = function(n, f) {
+      this._verify2(n, f);
+      var a = n.add(f);
+      return a.cmp(this.m) >= 0 && a.isub(this.m), a._forceRed(this);
+    }, S.prototype.iadd = function(n, f) {
+      this._verify2(n, f);
+      var a = n.iadd(f);
+      return a.cmp(this.m) >= 0 && a.isub(this.m), a;
+    }, S.prototype.sub = function(n, f) {
+      this._verify2(n, f);
+      var a = n.sub(f);
+      return a.cmpn(0) < 0 && a.iadd(this.m), a._forceRed(this);
+    }, S.prototype.isub = function(n, f) {
+      this._verify2(n, f);
+      var a = n.isub(f);
+      return a.cmpn(0) < 0 && a.iadd(this.m), a;
+    }, S.prototype.shl = function(n, f) {
+      return this._verify1(n), this.imod(n.ushln(f));
+    }, S.prototype.imul = function(n, f) {
+      return this._verify2(n, f), this.imod(n.imul(f));
+    }, S.prototype.mul = function(n, f) {
+      return this._verify2(n, f), this.imod(n.mul(f));
+    }, S.prototype.isqr = function(n) {
+      return this.imul(n, n.clone());
+    }, S.prototype.sqr = function(n) {
+      return this.mul(n, n);
+    }, S.prototype.sqrt = function(n) {
+      if (n.isZero()) return n.clone();
+      var f = this.m.andln(3);
+      if (o(f % 2 === 1), f === 3) {
+        var a = this.m.add(new s(1)).iushrn(2);
+        return this.pow(n, a);
+      }
+      for (var d = this.m.subn(1), l = 0; !d.isZero() && d.andln(1) === 0; )
+        l++, d.iushrn(1);
+      o(!d.isZero());
+      var u = new s(1).toRed(this), y = u.redNeg(), h = this.m.subn(1).iushrn(1), i = this.m.bitLength();
+      for (i = new s(2 * i * i).toRed(this); this.pow(i, h).cmp(y) !== 0; )
+        i.redIAdd(y);
+      for (var g = this.pow(i, d), A = this.pow(n, d.addn(1).iushrn(1)), B = this.pow(n, d), I = l; B.cmp(u) !== 0; ) {
+        for (var P = B, Z = 0; P.cmp(u) !== 0; Z++)
+          P = P.redSqr();
+        o(Z < I);
+        var H = this.pow(g, new s(1).iushln(I - Z - 1));
+        A = A.redMul(H), g = H.redSqr(), B = B.redMul(g), I = Z;
+      }
+      return A;
+    }, S.prototype.invm = function(n) {
+      var f = n._invmp(this.m);
+      return f.negative !== 0 ? (f.negative = 0, this.imod(f).redNeg()) : this.imod(f);
+    }, S.prototype.pow = function(n, f) {
+      if (f.isZero()) return new s(1).toRed(this);
+      if (f.cmpn(1) === 0) return n.clone();
+      var a = 4, d = new Array(1 << a);
+      d[0] = new s(1).toRed(this), d[1] = n;
+      for (var l = 2; l < d.length; l++)
+        d[l] = this.mul(d[l - 1], n);
+      var u = d[0], y = 0, h = 0, i = f.bitLength() % 26;
+      for (i === 0 && (i = 26), l = f.length - 1; l >= 0; l--) {
+        for (var g = f.words[l], A = i - 1; A >= 0; A--) {
+          var B = g >> A & 1;
+          if (u !== d[0] && (u = this.sqr(u)), B === 0 && y === 0) {
+            h = 0;
+            continue;
+          }
+          y <<= 1, y |= B, h++, !(h !== a && (l !== 0 || A !== 0)) && (u = this.mul(u, d[y]), h = 0, y = 0);
+        }
+        i = 26;
+      }
+      return u;
+    }, S.prototype.convertTo = function(n) {
+      var f = n.umod(this.m);
+      return f === n ? f.clone() : f;
+    }, S.prototype.convertFrom = function(n) {
+      var f = n.clone();
+      return f.red = null, f;
+    }, s.mont = function(n) {
+      return new T(n);
+    };
+    function T(p) {
+      S.call(this, p), this.shift = this.m.bitLength(), this.shift % 26 !== 0 && (this.shift += 26 - this.shift % 26), this.r = new s(1).iushln(this.shift), this.r2 = this.imod(this.r.sqr()), this.rinv = this.r._invmp(this.m), this.minv = this.rinv.mul(this.r).isubn(1).div(this.m), this.minv = this.minv.umod(this.r), this.minv = this.r.sub(this.minv);
+    }
+    c(T, S), T.prototype.convertTo = function(n) {
+      return this.imod(n.ushln(this.shift));
+    }, T.prototype.convertFrom = function(n) {
+      var f = this.imod(n.mul(this.rinv));
+      return f.red = null, f;
+    }, T.prototype.imul = function(n, f) {
+      if (n.isZero() || f.isZero())
+        return n.words[0] = 0, n.length = 1, n;
+      var a = n.imul(f), d = a.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m), l = a.isub(d).iushrn(this.shift), u = l;
+      return l.cmp(this.m) >= 0 ? u = l.isub(this.m) : l.cmpn(0) < 0 && (u = l.iadd(this.m)), u._forceRed(this);
+    }, T.prototype.mul = function(n, f) {
+      if (n.isZero() || f.isZero()) return new s(0)._forceRed(this);
+      var a = n.mul(f), d = a.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m), l = a.isub(d).iushrn(this.shift), u = l;
+      return l.cmp(this.m) >= 0 ? u = l.isub(this.m) : l.cmpn(0) < 0 && (u = l.iadd(this.m)), u._forceRed(this);
+    }, T.prototype.invm = function(n) {
+      var f = this.imod(n._invmp(this.m).mul(this.r2));
+      return f._forceRed(this);
+    };
+  })(t, Bs);
+})(en);
+var As = en.exports;
+const W = /* @__PURE__ */ ls(As);
+function xi(t) {
+  return W.isBN(t);
+}
+function Ss(t) {
+  return !!t && typeof t == "object";
+}
+function bi(...t) {
+  return (e) => (Ss(e) || Pr(e)) && t.every((r) => Pr(e[r]));
+}
+const Ei = /* @__PURE__ */ bi("toBigInt"), Mi = /* @__PURE__ */ bi("toBn");
+function Is(t) {
+  return typeof t == "bigint" ? t : t ? te(t) ? _s(t.toString()) : xi(t) ? Q(t.toString()) : Ei(t) ? t.toBigInt() : Mi(t) ? Q(t.toBn().toString()) : Q(t) : Q(0);
+}
+function Pt(...t) {
+  const e = t.length, r = new Array(e);
+  let o = 0;
+  for (let c = 0; c < e; c++)
+    r[c] = C(t[c]), o += r[c].length;
+  return _e(r, o);
+}
+function _e(t, e = 0) {
+  const r = t.length;
+  let o = 0;
+  if (!e)
+    for (let s = 0; s < r; s++)
+      e += t[s].length;
+  const c = new Uint8Array(e);
+  for (let s = 0; s < r; s++)
+    c.set(t[s], o), o += t[s].length;
+  return c;
+}
+function _i(t) {
+  const e = t.length | 0;
+  for (let r = 0; r < e; r++)
+    if (t[r] | 0)
+      return !1;
+  return !0;
+}
+function Wt(t, e) {
+  const r = C(t), o = C(e);
+  if (r.length === o.length) {
+    const c = new DataView(r.buffer, r.byteOffset), s = new DataView(o.buffer, o.byteOffset), w = r.length % 4 | 0, m = r.length - w | 0;
+    for (let v = 0; v < m; v += 4)
+      if (c.getUint32(v) !== s.getUint32(v))
+        return !1;
+    for (let v = m, b = r.length; v < b; v++)
+      if (r[v] !== o[v])
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function ks(t, e = -1, r = !1) {
+  const o = Math.ceil(e / 8);
+  if (e === -1 || t.length === o)
+    return t;
+  if (t.length > o)
+    return t.subarray(0, o);
+  const c = new Uint8Array(o);
+  return c.set(t, r ? 0 : o - t.length), c;
+}
+function yr(t, { isLe: e = !0, isNegative: r = !1 } = {}) {
+  e || (t = t.slice().reverse());
+  const o = t.length;
+  if (r && o && t[o - 1] & 128)
+    switch (o) {
+      case 0:
+        return new W(0);
+      case 1:
+        return new W((t[0] ^ 255) * -1 - 1);
+      case 2:
+        return new W((t[0] + (t[1] << 8) ^ 65535) * -1 - 1);
+      case 3:
+        return new W((t[0] + (t[1] << 8) + (t[2] << 16) ^ 16777215) * -1 - 1);
+      case 4:
+        return new W((t[0] + (t[1] << 8) + (t[2] << 16) + t[3] * 16777216 ^ 4294967295) * -1 - 1);
+      case 5:
+        return new W(((t[0] + (t[1] << 8) + (t[2] << 16) + t[3] * 16777216 ^ 4294967295) + (t[4] ^ 255) * 4294967296) * -1 - 1);
+      case 6:
+        return new W(((t[0] + (t[1] << 8) + (t[2] << 16) + t[3] * 16777216 ^ 4294967295) + (t[4] + (t[5] << 8) ^ 65535) * 4294967296) * -1 - 1);
+      default:
+        return new W(t, "le").fromTwos(o * 8);
+    }
+  switch (o) {
+    case 0:
+      return new W(0);
+    case 1:
+      return new W(t[0]);
+    case 2:
+      return new W(t[0] + (t[1] << 8));
+    case 3:
+      return new W(t[0] + (t[1] << 8) + (t[2] << 16));
+    case 4:
+      return new W(t[0] + (t[1] << 8) + (t[2] << 16) + t[3] * 16777216);
+    case 5:
+      return new W(t[0] + (t[1] << 8) + (t[2] << 16) + (t[3] + (t[4] << 8)) * 16777216);
+    case 6:
+      return new W(t[0] + (t[1] << 8) + (t[2] << 16) + (t[3] + (t[4] << 8) + (t[5] << 16)) * 16777216);
+    default:
+      return new W(t, "le");
+  }
+}
+const vr = /* @__PURE__ */ C(`Ethereum Signed Message:
+`), be = /* @__PURE__ */ C("<Bytes>"), Ee = /* @__PURE__ */ C("</Bytes>"), Us = be.length + Ee.length;
+function He(t, e) {
+  return t.length >= Us && Wt(t.subarray(0, be.length), be) && Wt(t.slice(-Ee.length), Ee) || e && t.length >= vr.length && Wt(t.subarray(0, vr.length), vr);
+}
+function Ns(t) {
+  const e = C(t);
+  return He(e, !1) ? e.subarray(be.length, e.length - Ee.length) : e;
+}
+function Rs(t) {
+  const e = C(t);
+  return He(e, !0) ? e : _e([be, e, Ee]);
+}
+const Pn = Q(256), Os = Q(255);
+function Ts(t, e, r) {
+  const o = [], c = r && t < Ze;
+  for (c && (t = (t + De) * -De); t !== Ze; ) {
+    const s = t % Pn, w = Number(c ? s ^ Os : s);
+    e ? o.push(w) : o.unshift(w), t = (t - s) / Pn;
+  }
+  return Uint8Array.from(o);
+}
+function Ls(t, { bitLength: e = -1, isLe: r = !0, isNegative: o = !1 } = {}) {
+  const c = Is(t);
+  if (c === Ze)
+    return e === -1 ? new Uint8Array(1) : new Uint8Array(Math.ceil((e || 0) / 8));
+  const s = Ts(c, r, o);
+  if (e === -1)
+    return s;
+  const w = Math.ceil((e || 0) / 8), m = new Uint8Array(w);
+  return o && m.fill(255), m.set(s, r ? 0 : w - s.length), m;
+}
+function qs(t) {
+  if (!t || t === "0x")
+    return "";
+  if (So.test(t))
+    return t.substring(2);
+  if (Io.test(t))
+    return t;
+  throw new Error(`Expected hex value to convert, found '${t}'`);
+}
+function $s(t, { isLe: e = !1, isNegative: r = !1 } = {}) {
+  if (!t || t === "0x")
+    return new W(0);
+  const o = qs(t), c = new W(o, 16, e ? "le" : "be");
+  return r ? c.fromTwos(o.length * 4) : c;
+}
+const je = /* @__PURE__ */ new W(1), Ge = /* @__PURE__ */ new W(2), Zn = /* @__PURE__ */ new W(1e9);
+Zn.mul(Zn);
+Number.MAX_SAFE_INTEGER;
+function Bi(t) {
+  return typeof t == "bigint";
+}
+function Ai(t) {
+  return t ? W.isBN(t) ? t : te(t) ? $s(t.toString()) : Bi(t) ? new W(t.toString()) : Mi(t) ? t.toBn() : Ei(t) ? new W(t.toBigInt().toString()) : new W(t) : new W(0);
+}
+const Ps = { bitLength: -1, isLe: !0, isNegative: !1 };
+function zt(t, { bitLength: e = -1, isLe: r = !0, isNegative: o = !1 } = Ps) {
+  const c = Ai(t), s = Math.ceil(e === -1 ? c.bitLength() / 8 : (e || 0) / 8);
+  if (!t)
+    return e === -1 ? new Uint8Array(1) : new Uint8Array(s);
+  const w = new Uint8Array(s), m = o ? c.toTwos(s * 8) : c;
+  return w.set(m.toArray(r ? "le" : "be", s), 0), w;
+}
+const Zs = Ge.pow(new W(6)).isub(je), Ds = Ge.pow(new W(14)).isub(je), Hs = Ge.pow(new W(30)).isub(je), Cs = { bitLength: 16 }, Vs = { bitLength: 32 };
+function zs(t) {
+  const e = Ai(t);
+  if (e.lte(Zs))
+    return new Uint8Array([e.toNumber() << 2]);
+  if (e.lte(Ds))
+    return zt(e.shln(2).iadd(je), Cs);
+  if (e.lte(Hs))
+    return zt(e.shln(2).iadd(Ge), Vs);
+  const r = zt(e);
+  let o = r.length;
+  for (; r[o - 1] === 0; )
+    o--;
+  if (o < 4)
+    throw new Error("Invalid length, previous checks match anything less than 2^30");
+  return _e([
+    // subtract 4 as minimum (also catered for in decoding)
+    new Uint8Array([(o - 4 << 2) + 3]),
+    r.subarray(0, o)
+  ]);
+}
+function rn(t) {
+  return _e([
+    zs(t.length),
+    t
+  ]);
+}
+function Ys(t) {
+  return typeof t == "string" || t instanceof String;
+}
+function Xs(t) {
+  return typeof t == "number";
+}
+const Ks = { name: "@polkadot/util-crypto", path: import.meta && import.meta.url ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf("/") + 1) : "auto", type: "esm", version: "12.6.2" };
+function nn(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function Ws(t, ...e) {
+  if (!nn(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function Si(t, e) {
+  return Array.isArray(e) ? e.length === 0 ? !0 : t ? e.every((r) => typeof r == "string") : e.every((r) => Number.isSafeInteger(r)) : !1;
+}
+function Me(t, e) {
+  if (typeof e != "string")
+    throw new Error(`${t}: string expected`);
+  return !0;
+}
+function Be(t) {
+  if (!Number.isSafeInteger(t))
+    throw new Error(`invalid integer: ${t}`);
+}
+function Ce(t) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+}
+function Ve(t, e) {
+  if (!Si(!0, e))
+    throw new Error(`${t}: array of strings expected`);
+}
+function Ii(t, e) {
+  if (!Si(!1, e))
+    throw new Error(`${t}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function ki(...t) {
+  const e = (s) => s, r = (s, w) => (m) => s(w(m)), o = t.map((s) => s.encode).reduceRight(r, e), c = t.map((s) => s.decode).reduce(r, e);
+  return { encode: o, decode: c };
+}
+// @__NO_SIDE_EFFECTS__
+function Ui(t) {
+  const e = typeof t == "string" ? t.split("") : t, r = e.length;
+  Ve("alphabet", e);
+  const o = new Map(e.map((c, s) => [c, s]));
+  return {
+    encode: (c) => (Ce(c), c.map((s) => {
+      if (!Number.isSafeInteger(s) || s < 0 || s >= r)
+        throw new Error(`alphabet.encode: digit index outside alphabet "${s}". Allowed: ${t}`);
+      return e[s];
+    })),
+    decode: (c) => (Ce(c), c.map((s) => {
+      Me("alphabet.decode", s);
+      const w = o.get(s);
+      if (w === void 0)
+        throw new Error(`Unknown letter: "${s}". Allowed: ${t}`);
+      return w;
+    }))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Ni(t = "") {
+  return Me("join", t), {
+    encode: (e) => (Ve("join.decode", e), e.join(t)),
+    decode: (e) => (Me("join.decode", e), e.split(t))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function js(t, e = "=") {
+  return Be(t), Me("padding", e), {
+    encode(r) {
+      for (Ve("padding.encode", r); r.length * t % 8; )
+        r.push(e);
+      return r;
+    },
+    decode(r) {
+      Ve("padding.decode", r);
+      let o = r.length;
+      if (o * t % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; o > 0 && r[o - 1] === e; o--)
+        if ((o - 1) * t % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      return r.slice(0, o);
+    }
+  };
+}
+function Dn(t, e, r) {
+  if (e < 2)
+    throw new Error(`convertRadix: invalid from=${e}, base cannot be less than 2`);
+  if (r < 2)
+    throw new Error(`convertRadix: invalid to=${r}, base cannot be less than 2`);
+  if (Ce(t), !t.length)
+    return [];
+  let o = 0;
+  const c = [], s = Array.from(t, (m) => {
+    if (Be(m), m < 0 || m >= e)
+      throw new Error(`invalid integer: ${m}`);
+    return m;
+  }), w = s.length;
+  for (; ; ) {
+    let m = 0, v = !0;
+    for (let b = o; b < w; b++) {
+      const x = s[b], E = e * m, _ = E + x;
+      if (!Number.isSafeInteger(_) || E / e !== m || _ - x !== E)
+        throw new Error("convertRadix: carry overflow");
+      const R = _ / r;
+      m = _ % r;
+      const q = Math.floor(R);
+      if (s[b] = q, !Number.isSafeInteger(q) || q * r + m !== _)
+        throw new Error("convertRadix: carry overflow");
+      if (v)
+        q ? v = !1 : o = b;
+      else continue;
+    }
+    if (c.push(m), v)
+      break;
+  }
+  for (let m = 0; m < t.length - 1 && t[m] === 0; m++)
+    c.push(0);
+  return c.reverse();
+}
+const Ri = (t, e) => e === 0 ? t : Ri(e, t % e), ze = /* @__NO_SIDE_EFFECTS__ */ (t, e) => t + (e - Ri(t, e)), xr = /* @__PURE__ */ (() => {
+  let t = [];
+  for (let e = 0; e < 40; e++)
+    t.push(2 ** e);
+  return t;
+})();
+function Hn(t, e, r, o) {
+  if (Ce(t), e <= 0 || e > 32)
+    throw new Error(`convertRadix2: wrong from=${e}`);
+  if (r <= 0 || r > 32)
+    throw new Error(`convertRadix2: wrong to=${r}`);
+  if (/* @__PURE__ */ ze(e, r) > 32)
+    throw new Error(`convertRadix2: carry overflow from=${e} to=${r} carryBits=${/* @__PURE__ */ ze(e, r)}`);
+  let c = 0, s = 0;
+  const w = xr[e], m = xr[r] - 1, v = [];
+  for (const b of t) {
+    if (Be(b), b >= w)
+      throw new Error(`convertRadix2: invalid data word=${b} from=${e}`);
+    if (c = c << e | b, s + e > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${s} from=${e}`);
+    for (s += e; s >= r; s -= r)
+      v.push((c >> s - r & m) >>> 0);
+    const x = xr[s];
+    if (x === void 0)
+      throw new Error("invalid carry");
+    c &= x - 1;
+  }
+  if (c = c << r - s & m, !o && s >= e)
+    throw new Error("Excess padding");
+  if (!o && c > 0)
+    throw new Error(`Non-zero padding: ${c}`);
+  return o && s > 0 && v.push(c >>> 0), v;
+}
+// @__NO_SIDE_EFFECTS__
+function Gs(t) {
+  Be(t);
+  const e = 2 ** 8;
+  return {
+    encode: (r) => {
+      if (!nn(r))
+        throw new Error("radix.encode input should be Uint8Array");
+      return Dn(Array.from(r), e, t);
+    },
+    decode: (r) => (Ii("radix.decode", r), Uint8Array.from(Dn(r, t, e)))
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function Js(t, e = !1) {
+  if (Be(t), t <= 0 || t > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ ze(8, t) > 32 || /* @__PURE__ */ ze(t, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (r) => {
+      if (!nn(r))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return Hn(Array.from(r), 8, t, !e);
+    },
+    decode: (r) => (Ii("radix2.decode", r), Uint8Array.from(Hn(r, t, 8, e)))
+  };
+}
+const Qs = typeof Uint8Array.from([]).toBase64 == "function" && typeof Uint8Array.fromBase64 == "function", Fs = Qs ? {
+  encode(t) {
+    return Ws(t), t.toBase64();
+  },
+  decode(t) {
+    return Me("base64", t), Uint8Array.fromBase64(t, { lastChunkHandling: "strict" });
+  }
+} : /* @__PURE__ */ ki(/* @__PURE__ */ Js(6), /* @__PURE__ */ Ui("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ js(6), /* @__PURE__ */ Ni("")), tf = /* @__NO_SIDE_EFFECTS__ */ (t) => /* @__PURE__ */ ki(/* @__PURE__ */ Gs(58), /* @__PURE__ */ Ui(t), /* @__PURE__ */ Ni("")), ef = /* @__PURE__ */ tf("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+function Oi({ coder: t, ipfs: e }, r) {
+  return (o, c) => (r(o, c), t.decode(e && c ? o.substring(1) : o));
+}
+function Ti({ coder: t, ipfs: e }) {
+  return (r, o) => {
+    const c = t.encode(C(r));
+    return e && o ? `${e}${c}` : c;
+  };
+}
+function Li({ chars: t, ipfs: e, type: r, withPadding: o }) {
+  return (c, s) => {
+    if (typeof c != "string")
+      throw new Error(`Expected ${r} string input`);
+    if (e && s && !c.startsWith(e))
+      throw new Error(`Expected ipfs-compatible ${r} to start with '${e}'`);
+    for (let w = s ? 1 : 0, m = c.length; w < m; w++)
+      if (!t.includes(c[w])) if (o && c[w] === "=") {
+        if (w !== m - 1) {
+          if (c[w + 1] !== "=") throw new Error(`Invalid ${r} padding sequence "${c[w]}${c[w + 1]}" at index ${w}`);
+        }
+      } else
+        throw new Error(`Invalid ${r} character "${c[w]}" (0x${c.charCodeAt(w).toString(16)}) at index ${w}`);
+    return !0;
+  };
+}
+const on = {
+  chars: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+  coder: ef,
+  ipfs: "z",
+  type: "base58"
+}, rf = /* @__PURE__ */ Li(on), nf = /* @__PURE__ */ Oi(on, rf), of = /* @__PURE__ */ Ti(on), sf = re("SS58PRE");
+function qi(t) {
+  return se(Pt(sf, t), 512);
+}
+function ff(t) {
+  const e = t[0] & 64 ? 2 : 1, r = e === 1 ? t[0] : (t[0] & 63) << 2 | t[1] >> 6 | (t[1] & 63) << 8, o = [34 + e, 35 + e].includes(t.length), c = t.length - (o ? 2 : 1), s = qi(t.subarray(0, c));
+  return [(t[0] & 128) === 0 && ![46, 47].includes(t[0]) && (o ? t[t.length - 2] === s[0] && t[t.length - 1] === s[1] : t[t.length - 1] === s[0]), c, e, r];
+}
+const qe = {
+  allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
+  // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
+  allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
+  prefix: 42
+};
+function he(t, e, r = -1) {
+  if (!t)
+    throw new Error("Invalid empty address passed");
+  if (oe(t) || te(t))
+    return C(t);
+  try {
+    const o = nf(t);
+    if (!qe.allowedEncodedLengths.includes(o.length))
+      throw new Error("Invalid decoded address length");
+    const [c, s, w, m] = ff(o);
+    if (!c && !e)
+      throw new Error("Invalid decoded address checksum");
+    if (r !== -1 && r !== m)
+      throw new Error(`Expected ss58Format ${r}, received ${m}`);
+    return o.slice(w, s);
+  } catch (o) {
+    throw new Error(`Decoding ${t}: ${o.message}`);
+  }
+}
+const Cn = { isLe: !1 }, br = { isLe: !0 }, af = { bitLength: 32, isLe: !1 }, Er = { bitLength: 32, isLe: !0 }, le = { bitLength: 256, isLe: !1 }, cf = { bitLength: 256, isLe: !0 }, hf = /^\d+$/, lf = 32;
+class sn {
+  constructor() {
+    jt(this, "__internal__chainCode", new Uint8Array(32));
+    jt(this, "__internal__isHard", !1);
+  }
+  static from(e) {
+    const r = new sn(), [o, c] = e.startsWith("/") ? [e.substring(1), !0] : [e, !1];
+    return r.soft(hf.test(o) ? new W(o, 10) : o), c ? r.harden() : r;
+  }
+  get chainCode() {
+    return this.__internal__chainCode;
+  }
+  get isHard() {
+    return this.__internal__isHard;
+  }
+  get isSoft() {
+    return !this.__internal__isHard;
+  }
+  hard(e) {
+    return this.soft(e).harden();
+  }
+  harden() {
+    return this.__internal__isHard = !0, this;
+  }
+  soft(e) {
+    return Xs(e) || xi(e) || Bi(e) ? this.soft(zt(e, cf)) : te(e) ? this.soft(ye(e)) : Ys(e) ? this.soft(rn(re(e))) : e.length > lf ? this.soft(se(e)) : (this.__internal__chainCode.fill(0), this.__internal__chainCode.set(e, 0), this);
+  }
+  soften() {
+    return this.__internal__isHard = !1, this;
+  }
+}
+const uf = /\/(\/?)([^/]+)/g;
+function $i(t) {
+  const e = t.match(uf), r = [];
+  let o = "";
+  if (e) {
+    o = e.join("");
+    for (const c of e)
+      r.push(sn.from(c.substring(1)));
+  }
+  if (o !== t)
+    throw new Error(`Re-constructed path "${o}" does not match input`);
+  return {
+    parts: e,
+    path: r
+  };
+}
+const df = /^(\w+( \w+)*)((\/\/?[^/]+)*)(\/\/\/(.*))?$/;
+function wf(t) {
+  const e = t.match(df);
+  if (e === null)
+    throw new Error("Unable to match provided value to a secret URI");
+  const [, r, , o, , , c] = e, { path: s } = $i(o);
+  return {
+    derivePath: o,
+    password: c,
+    path: s,
+    phrase: r
+  };
+}
+const mf = rn(re("Secp256k1HDKD"));
+function gf(t, e) {
+  if (!oe(e) || e.length !== 32)
+    throw new Error("Invalid chainCode passed to derive");
+  return se(Pt(mf, t, e), 256);
+}
+const fn = /* @__PURE__ */ BigInt(0), Dr = /* @__PURE__ */ BigInt(1);
+function Ae(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function an(t) {
+  if (!Ae(t))
+    throw new Error("Uint8Array expected");
+}
+function ee(t, e) {
+  if (typeof e != "boolean")
+    throw new Error(t + " boolean expected, got " + e);
+}
+function Re(t) {
+  const e = t.toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function Pi(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? fn : BigInt("0x" + t);
+}
+const Zi = (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function"
+), pf = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function ue(t) {
+  if (an(t), Zi)
+    return t.toHex();
+  let e = "";
+  for (let r = 0; r < t.length; r++)
+    e += pf[t[r]];
+  return e;
+}
+const Gt = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function Vn(t) {
+  if (t >= Gt._0 && t <= Gt._9)
+    return t - Gt._0;
+  if (t >= Gt.A && t <= Gt.F)
+    return t - (Gt.A - 10);
+  if (t >= Gt.a && t <= Gt.f)
+    return t - (Gt.a - 10);
+}
+function Ye(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (Zi)
+    return Uint8Array.fromHex(t);
+  const e = t.length, r = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const o = new Uint8Array(r);
+  for (let c = 0, s = 0; c < r; c++, s += 2) {
+    const w = Vn(t.charCodeAt(s)), m = Vn(t.charCodeAt(s + 1));
+    if (w === void 0 || m === void 0) {
+      const v = t[s] + t[s + 1];
+      throw new Error('hex string expected, got non-hex character "' + v + '" at index ' + s);
+    }
+    o[c] = w * 16 + m;
+  }
+  return o;
+}
+function ie(t) {
+  return Pi(ue(t));
+}
+function ve(t) {
+  return an(t), Pi(ue(Uint8Array.from(t).reverse()));
+}
+function Se(t, e) {
+  return Ye(t.toString(16).padStart(e * 2, "0"));
+}
+function Xe(t, e) {
+  return Se(t, e).reverse();
+}
+function ot(t, e, r) {
+  let o;
+  if (typeof e == "string")
+    try {
+      o = Ye(e);
+    } catch (s) {
+      throw new Error(t + " must be hex string or Uint8Array, cause: " + s);
+    }
+  else if (Ae(e))
+    o = Uint8Array.from(e);
+  else
+    throw new Error(t + " must be hex string or Uint8Array");
+  const c = o.length;
+  if (typeof r == "number" && c !== r)
+    throw new Error(t + " of length " + r + " expected, got " + c);
+  return o;
+}
+function de(...t) {
+  let e = 0;
+  for (let o = 0; o < t.length; o++) {
+    const c = t[o];
+    an(c), e += c.length;
+  }
+  const r = new Uint8Array(e);
+  for (let o = 0, c = 0; o < t.length; o++) {
+    const s = t[o];
+    r.set(s, c), c += s.length;
+  }
+  return r;
+}
+const Mr = (t) => typeof t == "bigint" && fn <= t;
+function cn(t, e, r) {
+  return Mr(t) && Mr(e) && Mr(r) && e <= t && t < r;
+}
+function Xt(t, e, r, o) {
+  if (!cn(e, r, o))
+    throw new Error("expected valid " + t + ": " + r + " <= n < " + o + ", got " + e);
+}
+function yf(t) {
+  let e;
+  for (e = 0; t > fn; t >>= Dr, e += 1)
+    ;
+  return e;
+}
+const Je = (t) => (Dr << BigInt(t)) - Dr, _r = (t) => new Uint8Array(t), zn = (t) => Uint8Array.from(t);
+function vf(t, e, r) {
+  if (typeof t != "number" || t < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof e != "number" || e < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof r != "function")
+    throw new Error("hmacFn must be a function");
+  let o = _r(t), c = _r(t), s = 0;
+  const w = () => {
+    o.fill(1), c.fill(0), s = 0;
+  }, m = (...E) => r(c, o, ...E), v = (E = _r(0)) => {
+    c = m(zn([0]), E), o = m(), E.length !== 0 && (c = m(zn([1]), E), o = m());
+  }, b = () => {
+    if (s++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let E = 0;
+    const _ = [];
+    for (; E < e; ) {
+      o = m();
+      const R = o.slice();
+      _.push(R), E += o.length;
+    }
+    return de(..._);
+  };
+  return (E, _) => {
+    w(), v(E);
+    let R;
+    for (; !(R = _(b())); )
+      v();
+    return w(), R;
+  };
+}
+const xf = {
+  bigint: (t) => typeof t == "bigint",
+  function: (t) => typeof t == "function",
+  boolean: (t) => typeof t == "boolean",
+  string: (t) => typeof t == "string",
+  stringOrUint8Array: (t) => typeof t == "string" || Ae(t),
+  isSafeInteger: (t) => Number.isSafeInteger(t),
+  array: (t) => Array.isArray(t),
+  field: (t, e) => e.Fp.isValid(t),
+  hash: (t) => typeof t == "function" && Number.isSafeInteger(t.outputLen)
+};
+function Ie(t, e, r = {}) {
+  const o = (c, s, w) => {
+    const m = xf[s];
+    if (typeof m != "function")
+      throw new Error("invalid validator function");
+    const v = t[c];
+    if (!(w && v === void 0) && !m(v, t))
+      throw new Error("param " + String(c) + " is invalid. Expected " + s + ", got " + v);
+  };
+  for (const [c, s] of Object.entries(e))
+    o(c, s, !1);
+  for (const [c, s] of Object.entries(r))
+    o(c, s, !0);
+  return t;
+}
+function Ke(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (r, ...o) => {
+    const c = e.get(r);
+    if (c !== void 0)
+      return c;
+    const s = t(r, ...o);
+    return e.set(r, s), s;
+  };
+}
+const Ht = BigInt(0), Zt = BigInt(1), ne = /* @__PURE__ */ BigInt(2), bf = /* @__PURE__ */ BigInt(3), Di = /* @__PURE__ */ BigInt(4), Hi = /* @__PURE__ */ BigInt(5), Ci = /* @__PURE__ */ BigInt(8);
+function F(t, e) {
+  const r = t % e;
+  return r >= Ht ? r : e + r;
+}
+function it(t, e, r) {
+  let o = t;
+  for (; e-- > Ht; )
+    o *= o, o %= r;
+  return o;
+}
+function Hr(t, e) {
+  if (t === Ht)
+    throw new Error("invert: expected non-zero number");
+  if (e <= Ht)
+    throw new Error("invert: expected positive modulus, got " + e);
+  let r = F(t, e), o = e, c = Ht, s = Zt;
+  for (; r !== Ht; ) {
+    const m = o / r, v = o % r, b = c - s * m;
+    o = r, r = v, c = s, s = b;
+  }
+  if (o !== Zt)
+    throw new Error("invert: does not exist");
+  return F(c, e);
+}
+function Vi(t, e) {
+  const r = (t.ORDER + Zt) / Di, o = t.pow(e, r);
+  if (!t.eql(t.sqr(o), e))
+    throw new Error("Cannot find square root");
+  return o;
+}
+function Ef(t, e) {
+  const r = (t.ORDER - Hi) / Ci, o = t.mul(e, ne), c = t.pow(o, r), s = t.mul(e, c), w = t.mul(t.mul(s, ne), c), m = t.mul(s, t.sub(w, t.ONE));
+  if (!t.eql(t.sqr(m), e))
+    throw new Error("Cannot find square root");
+  return m;
+}
+function Mf(t) {
+  if (t < BigInt(3))
+    throw new Error("sqrt is not defined for small field");
+  let e = t - Zt, r = 0;
+  for (; e % ne === Ht; )
+    e /= ne, r++;
+  let o = ne;
+  const c = ke(t);
+  for (; Yn(c, o) === 1; )
+    if (o++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (r === 1)
+    return Vi;
+  let s = c.pow(o, e);
+  const w = (e + Zt) / ne;
+  return function(v, b) {
+    if (v.is0(b))
+      return b;
+    if (Yn(v, b) !== 1)
+      throw new Error("Cannot find square root");
+    let x = r, E = v.mul(v.ONE, s), _ = v.pow(b, e), R = v.pow(b, w);
+    for (; !v.eql(_, v.ONE); ) {
+      if (v.is0(_))
+        return v.ZERO;
+      let q = 1, k = v.sqr(_);
+      for (; !v.eql(k, v.ONE); )
+        if (q++, k = v.sqr(k), q === x)
+          throw new Error("Cannot find square root");
+      const X = Zt << BigInt(x - q - 1), z = v.pow(E, X);
+      x = q, E = v.sqr(z), _ = v.mul(_, E), R = v.mul(R, z);
+    }
+    return R;
+  };
+}
+function _f(t) {
+  return t % Di === bf ? Vi : t % Ci === Hi ? Ef : Mf(t);
+}
+const Bf = (t, e) => (F(t, e) & Zt) === Zt, Af = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function Sf(t) {
+  const e = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "isSafeInteger",
+    BITS: "isSafeInteger"
+  }, r = Af.reduce((o, c) => (o[c] = "function", o), e);
+  return Ie(t, r);
+}
+function If(t, e, r) {
+  if (r < Ht)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (r === Ht)
+    return t.ONE;
+  if (r === Zt)
+    return e;
+  let o = t.ONE, c = e;
+  for (; r > Ht; )
+    r & Zt && (o = t.mul(o, c)), c = t.sqr(c), r >>= Zt;
+  return o;
+}
+function hn(t, e, r = !1) {
+  const o = new Array(e.length).fill(r ? t.ZERO : void 0), c = e.reduce((w, m, v) => t.is0(m) ? w : (o[v] = w, t.mul(w, m)), t.ONE), s = t.inv(c);
+  return e.reduceRight((w, m, v) => t.is0(m) ? w : (o[v] = t.mul(w, o[v]), t.mul(w, m)), s), o;
+}
+function Yn(t, e) {
+  const r = (t.ORDER - Zt) / ne, o = t.pow(e, r), c = t.eql(o, t.ONE), s = t.eql(o, t.ZERO), w = t.eql(o, t.neg(t.ONE));
+  if (!c && !s && !w)
+    throw new Error("invalid Legendre symbol result");
+  return c ? 1 : s ? 0 : -1;
+}
+function zi(t, e) {
+  e !== void 0 && Jt(e);
+  const r = e !== void 0 ? e : t.toString(2).length, o = Math.ceil(r / 8);
+  return { nBitLength: r, nByteLength: o };
+}
+function ke(t, e, r = !1, o = {}) {
+  if (t <= Ht)
+    throw new Error("invalid field: expected ORDER > 0, got " + t);
+  const { nBitLength: c, nByteLength: s } = zi(t, e);
+  if (s > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let w;
+  const m = Object.freeze({
+    ORDER: t,
+    isLE: r,
+    BITS: c,
+    BYTES: s,
+    MASK: Je(c),
+    ZERO: Ht,
+    ONE: Zt,
+    create: (v) => F(v, t),
+    isValid: (v) => {
+      if (typeof v != "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof v);
+      return Ht <= v && v < t;
+    },
+    is0: (v) => v === Ht,
+    isOdd: (v) => (v & Zt) === Zt,
+    neg: (v) => F(-v, t),
+    eql: (v, b) => v === b,
+    sqr: (v) => F(v * v, t),
+    add: (v, b) => F(v + b, t),
+    sub: (v, b) => F(v - b, t),
+    mul: (v, b) => F(v * b, t),
+    pow: (v, b) => If(m, v, b),
+    div: (v, b) => F(v * Hr(b, t), t),
+    // Same as above, but doesn't normalize
+    sqrN: (v) => v * v,
+    addN: (v, b) => v + b,
+    subN: (v, b) => v - b,
+    mulN: (v, b) => v * b,
+    inv: (v) => Hr(v, t),
+    sqrt: o.sqrt || ((v) => (w || (w = _f(t)), w(m, v))),
+    toBytes: (v) => r ? Xe(v, s) : Se(v, s),
+    fromBytes: (v) => {
+      if (v.length !== s)
+        throw new Error("Field.fromBytes: expected " + s + " bytes, got " + v.length);
+      return r ? ve(v) : ie(v);
+    },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (v) => hn(m, v),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (v, b, x) => x ? b : v
+  });
+  return Object.freeze(m);
+}
+function Yi(t) {
+  if (typeof t != "bigint")
+    throw new Error("field order must be bigint");
+  const e = t.toString(2).length;
+  return Math.ceil(e / 8);
+}
+function Xi(t) {
+  const e = Yi(t);
+  return e + Math.ceil(e / 2);
+}
+function kf(t, e, r = !1) {
+  const o = t.length, c = Yi(e), s = Xi(e);
+  if (o < 16 || o < s || o > 1024)
+    throw new Error("expected " + s + "-1024 bytes of input, got " + o);
+  const w = r ? ve(t) : ie(t), m = F(w, e - Zt) + Zt;
+  return r ? Xe(m, c) : Se(m, c);
+}
+const Xn = BigInt(0), Cr = BigInt(1);
+function Br(t, e) {
+  const r = e.negate();
+  return t ? r : e;
+}
+function Ki(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e)
+    throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function Ar(t, e) {
+  Ki(t, e);
+  const r = Math.ceil(e / t) + 1, o = 2 ** (t - 1), c = 2 ** t, s = Je(t), w = BigInt(t);
+  return { windows: r, windowSize: o, mask: s, maxNumber: c, shiftBy: w };
+}
+function Kn(t, e, r) {
+  const { windowSize: o, mask: c, maxNumber: s, shiftBy: w } = r;
+  let m = Number(t & c), v = t >> w;
+  m > o && (m -= s, v += Cr);
+  const b = e * o, x = b + Math.abs(m) - 1, E = m === 0, _ = m < 0, R = e % 2 !== 0;
+  return { nextN: v, offset: x, isZero: E, isNeg: _, isNegF: R, offsetF: b };
+}
+function Uf(t, e) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+  t.forEach((r, o) => {
+    if (!(r instanceof e))
+      throw new Error("invalid point at index " + o);
+  });
+}
+function Nf(t, e) {
+  if (!Array.isArray(t))
+    throw new Error("array of scalars expected");
+  t.forEach((r, o) => {
+    if (!e.isValid(r))
+      throw new Error("invalid scalar at index " + o);
+  });
+}
+const Sr = /* @__PURE__ */ new WeakMap(), Wi = /* @__PURE__ */ new WeakMap();
+function Ir(t) {
+  return Wi.get(t) || 1;
+}
+function ji(t, e) {
+  return {
+    constTimeNegate: Br,
+    hasPrecomputes(r) {
+      return Ir(r) !== 1;
+    },
+    // non-const time multiplication ladder
+    unsafeLadder(r, o, c = t.ZERO) {
+      let s = r;
+      for (; o > Xn; )
+        o & Cr && (c = c.add(s)), s = s.double(), o >>= Cr;
+      return c;
+    },
+    /**
+     * Creates a wNAF precomputation window. Used for caching.
+     * Default window size is set by `utils.precompute()` and is equal to 8.
+     * Number of precomputed points depends on the curve size:
+     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+     * - 𝑊 is the window size
+     * - 𝑛 is the bitlength of the curve order.
+     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+     * @param elm Point instance
+     * @param W window size
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(r, o) {
+      const { windows: c, windowSize: s } = Ar(o, e), w = [];
+      let m = r, v = m;
+      for (let b = 0; b < c; b++) {
+        v = m, w.push(v);
+        for (let x = 1; x < s; x++)
+          v = v.add(m), w.push(v);
+        m = v.double();
+      }
+      return w;
+    },
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(r, o, c) {
+      let s = t.ZERO, w = t.BASE;
+      const m = Ar(r, e);
+      for (let v = 0; v < m.windows; v++) {
+        const { nextN: b, offset: x, isZero: E, isNeg: _, isNegF: R, offsetF: q } = Kn(c, v, m);
+        c = b, E ? w = w.add(Br(R, o[q])) : s = s.add(Br(_, o[x]));
+      }
+      return { p: s, f: w };
+    },
+    /**
+     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @param acc accumulator point to add result of multiplication
+     * @returns point
+     */
+    wNAFUnsafe(r, o, c, s = t.ZERO) {
+      const w = Ar(r, e);
+      for (let m = 0; m < w.windows && c !== Xn; m++) {
+        const { nextN: v, offset: b, isZero: x, isNeg: E } = Kn(c, m, w);
+        if (c = v, !x) {
+          const _ = o[b];
+          s = s.add(E ? _.negate() : _);
+        }
+      }
+      return s;
+    },
+    getPrecomputes(r, o, c) {
+      let s = Sr.get(o);
+      return s || (s = this.precomputeWindow(o, r), r !== 1 && Sr.set(o, c(s))), s;
+    },
+    wNAFCached(r, o, c) {
+      const s = Ir(r);
+      return this.wNAF(s, this.getPrecomputes(s, r, c), o);
+    },
+    wNAFCachedUnsafe(r, o, c, s) {
+      const w = Ir(r);
+      return w === 1 ? this.unsafeLadder(r, o, s) : this.wNAFUnsafe(w, this.getPrecomputes(w, r, c), o, s);
+    },
+    // We calculate precomputes for elliptic curve point multiplication
+    // using windowed method. This specifies window size and
+    // stores precomputed values. Usually only base point would be precomputed.
+    setWindowSize(r, o) {
+      Ki(o, e), Wi.set(r, o), Sr.delete(r);
+    }
+  };
+}
+function Gi(t, e, r, o) {
+  Uf(r, t), Nf(o, e);
+  const c = r.length, s = o.length;
+  if (c !== s)
+    throw new Error("arrays of points and scalars must have equal length");
+  const w = t.ZERO, m = yf(BigInt(c));
+  let v = 1;
+  m > 12 ? v = m - 3 : m > 4 ? v = m - 2 : m > 0 && (v = 2);
+  const b = Je(v), x = new Array(Number(b) + 1).fill(w), E = Math.floor((e.BITS - 1) / v) * v;
+  let _ = w;
+  for (let R = E; R >= 0; R -= v) {
+    x.fill(w);
+    for (let k = 0; k < s; k++) {
+      const X = o[k], z = Number(X >> BigInt(R) & b);
+      x[z] = x[z].add(r[k]);
+    }
+    let q = w;
+    for (let k = x.length - 1, X = w; k > 0; k--)
+      X = X.add(x[k]), q = q.add(X);
+    if (_ = _.add(q), R !== 0)
+      for (let k = 0; k < v; k++)
+        _ = _.double();
+  }
+  return _;
+}
+function ln(t) {
+  return Sf(t.Fp), Ie(t, {
+    n: "bigint",
+    h: "bigint",
+    Gx: "field",
+    Gy: "field"
+  }, {
+    nBitLength: "isSafeInteger",
+    nByteLength: "isSafeInteger"
+  }), Object.freeze({
+    ...zi(t.n, t.nBitLength),
+    ...t,
+    p: t.Fp.ORDER
+  });
+}
+function Wn(t) {
+  t.lowS !== void 0 && ee("lowS", t.lowS), t.prehash !== void 0 && ee("prehash", t.prehash);
+}
+function Rf(t) {
+  const e = ln(t);
+  Ie(e, {
+    a: "field",
+    b: "field"
+  }, {
+    allowInfinityPoint: "boolean",
+    allowedPrivateKeyLengths: "array",
+    clearCofactor: "function",
+    fromBytes: "function",
+    isTorsionFree: "function",
+    toBytes: "function",
+    wrapPrivateKey: "boolean"
+  });
+  const { endo: r, Fp: o, a: c } = e;
+  if (r) {
+    if (!o.eql(c, o.ZERO))
+      throw new Error("invalid endo: CURVE.a must be 0");
+    if (typeof r != "object" || typeof r.beta != "bigint" || typeof r.splitScalar != "function")
+      throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
+  }
+  return Object.freeze({ ...e });
+}
+class Of extends Error {
+  constructor(e = "") {
+    super(e);
+  }
+}
+const Qt = {
+  // asn.1 DER encoding utils
+  Err: Of,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (t, e) => {
+      const { Err: r } = Qt;
+      if (t < 0 || t > 256)
+        throw new r("tlv.encode: wrong tag");
+      if (e.length & 1)
+        throw new r("tlv.encode: unpadded data");
+      const o = e.length / 2, c = Re(o);
+      if (c.length / 2 & 128)
+        throw new r("tlv.encode: long form length too big");
+      const s = o > 127 ? Re(c.length / 2 | 128) : "";
+      return Re(t) + s + c + e;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(t, e) {
+      const { Err: r } = Qt;
+      let o = 0;
+      if (t < 0 || t > 256)
+        throw new r("tlv.encode: wrong tag");
+      if (e.length < 2 || e[o++] !== t)
+        throw new r("tlv.decode: wrong tlv");
+      const c = e[o++], s = !!(c & 128);
+      let w = 0;
+      if (!s)
+        w = c;
+      else {
+        const v = c & 127;
+        if (!v)
+          throw new r("tlv.decode(long): indefinite length not supported");
+        if (v > 4)
+          throw new r("tlv.decode(long): byte length is too big");
+        const b = e.subarray(o, o + v);
+        if (b.length !== v)
+          throw new r("tlv.decode: length bytes not complete");
+        if (b[0] === 0)
+          throw new r("tlv.decode(long): zero leftmost byte");
+        for (const x of b)
+          w = w << 8 | x;
+        if (o += v, w < 128)
+          throw new r("tlv.decode(long): not minimal encoding");
+      }
+      const m = e.subarray(o, o + w);
+      if (m.length !== w)
+        throw new r("tlv.decode: wrong value length");
+      return { v: m, l: e.subarray(o + w) };
+    }
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(t) {
+      const { Err: e } = Qt;
+      if (t < Ft)
+        throw new e("integer: negative integers are not allowed");
+      let r = Re(t);
+      if (Number.parseInt(r[0], 16) & 8 && (r = "00" + r), r.length & 1)
+        throw new e("unexpected DER parsing assertion: unpadded hex");
+      return r;
+    },
+    decode(t) {
+      const { Err: e } = Qt;
+      if (t[0] & 128)
+        throw new e("invalid signature integer: negative");
+      if (t[0] === 0 && !(t[1] & 128))
+        throw new e("invalid signature integer: unnecessary leading zero");
+      return ie(t);
+    }
+  },
+  toSig(t) {
+    const { Err: e, _int: r, _tlv: o } = Qt, c = ot("signature", t), { v: s, l: w } = o.decode(48, c);
+    if (w.length)
+      throw new e("invalid signature: left bytes after parsing");
+    const { v: m, l: v } = o.decode(2, s), { v: b, l: x } = o.decode(2, v);
+    if (x.length)
+      throw new e("invalid signature: left bytes after parsing");
+    return { r: r.decode(m), s: r.decode(b) };
+  },
+  hexFromSig(t) {
+    const { _tlv: e, _int: r } = Qt, o = e.encode(2, r.encode(t.r)), c = e.encode(2, r.encode(t.s)), s = o + c;
+    return e.encode(48, s);
+  }
+};
+function kr(t, e) {
+  return ue(Se(t, e));
+}
+const Ft = BigInt(0), $t = BigInt(1), L0 = BigInt(2), Ur = BigInt(3), Tf = BigInt(4);
+function Lf(t) {
+  const e = Rf(t), { Fp: r } = e, o = ke(e.n, e.nBitLength), c = e.toBytes || ((L, M, U) => {
+    const N = M.toAffine();
+    return de(Uint8Array.from([4]), r.toBytes(N.x), r.toBytes(N.y));
+  }), s = e.fromBytes || ((L) => {
+    const M = L.subarray(1), U = r.fromBytes(M.subarray(0, r.BYTES)), N = r.fromBytes(M.subarray(r.BYTES, 2 * r.BYTES));
+    return { x: U, y: N };
+  });
+  function w(L) {
+    const { a: M, b: U } = e, N = r.sqr(L), O = r.mul(N, L);
+    return r.add(r.add(O, r.mul(L, M)), U);
+  }
+  function m(L, M) {
+    const U = r.sqr(M), N = w(L);
+    return r.eql(U, N);
+  }
+  if (!m(e.Gx, e.Gy))
+    throw new Error("bad curve params: generator point");
+  const v = r.mul(r.pow(e.a, Ur), Tf), b = r.mul(r.sqr(e.b), BigInt(27));
+  if (r.is0(r.add(v, b)))
+    throw new Error("bad curve params: a or b");
+  function x(L) {
+    return cn(L, $t, e.n);
+  }
+  function E(L) {
+    const { allowedPrivateKeyLengths: M, nByteLength: U, wrapPrivateKey: N, n: O } = e;
+    if (M && typeof L != "bigint") {
+      if (Ae(L) && (L = ue(L)), typeof L != "string" || !M.includes(L.length))
+        throw new Error("invalid private key");
+      L = L.padStart(U * 2, "0");
+    }
+    let $;
+    try {
+      $ = typeof L == "bigint" ? L : ie(ot("private key", L, U));
+    } catch {
+      throw new Error("invalid private key, expected hex or " + U + " bytes, got " + typeof L);
+    }
+    return N && ($ = F($, O)), Xt("private key", $, $t, O), $;
+  }
+  function _(L) {
+    if (!(L instanceof k))
+      throw new Error("ProjectivePoint expected");
+  }
+  const R = Ke((L, M) => {
+    const { px: U, py: N, pz: O } = L;
+    if (r.eql(O, r.ONE))
+      return { x: U, y: N };
+    const $ = L.is0();
+    M == null && (M = $ ? r.ONE : r.inv(O));
+    const V = r.mul(U, M), D = r.mul(N, M), S = r.mul(O, M);
+    if ($)
+      return { x: r.ZERO, y: r.ZERO };
+    if (!r.eql(S, r.ONE))
+      throw new Error("invZ was invalid");
+    return { x: V, y: D };
+  }), q = Ke((L) => {
+    if (L.is0()) {
+      if (e.allowInfinityPoint && !r.is0(L.py))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: M, y: U } = L.toAffine();
+    if (!r.isValid(M) || !r.isValid(U))
+      throw new Error("bad point: x or y not FE");
+    if (!m(M, U))
+      throw new Error("bad point: equation left != right");
+    if (!L.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  class k {
+    constructor(M, U, N) {
+      if (M == null || !r.isValid(M))
+        throw new Error("x required");
+      if (U == null || !r.isValid(U) || r.is0(U))
+        throw new Error("y required");
+      if (N == null || !r.isValid(N))
+        throw new Error("z required");
+      this.px = M, this.py = U, this.pz = N, Object.freeze(this);
+    }
+    // Does not validate if the point is on-curve.
+    // Use fromHex instead, or call assertValidity() later.
+    static fromAffine(M) {
+      const { x: U, y: N } = M || {};
+      if (!M || !r.isValid(U) || !r.isValid(N))
+        throw new Error("invalid affine point");
+      if (M instanceof k)
+        throw new Error("projective point not allowed");
+      const O = ($) => r.eql($, r.ZERO);
+      return O(U) && O(N) ? k.ZERO : new k(U, N, r.ONE);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     * Takes a bunch of Projective Points but executes only one
+     * inversion on all of them. Inversion is very slow operation,
+     * so this improves performance massively.
+     * Optimization: converts a list of projective points to a list of identical points with Z=1.
+     */
+    static normalizeZ(M) {
+      const U = hn(r, M.map((N) => N.pz));
+      return M.map((N, O) => N.toAffine(U[O])).map(k.fromAffine);
+    }
+    /**
+     * Converts hash string or Uint8Array to Point.
+     * @param hex short/long ECDSA hex
+     */
+    static fromHex(M) {
+      const U = k.fromAffine(s(ot("pointHex", M)));
+      return U.assertValidity(), U;
+    }
+    // Multiplies generator point by privateKey.
+    static fromPrivateKey(M) {
+      return k.BASE.multiply(E(M));
+    }
+    // Multiscalar Multiplication
+    static msm(M, U) {
+      return Gi(k, o, M, U);
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(M) {
+      st.setWindowSize(this, M);
+    }
+    // A point on curve is valid if it conforms to equation.
+    assertValidity() {
+      q(this);
+    }
+    hasEvenY() {
+      const { y: M } = this.toAffine();
+      if (r.isOdd)
+        return !r.isOdd(M);
+      throw new Error("Field doesn't support isOdd");
+    }
+    /**
+     * Compare one point to another.
+     */
+    equals(M) {
+      _(M);
+      const { px: U, py: N, pz: O } = this, { px: $, py: V, pz: D } = M, S = r.eql(r.mul(U, D), r.mul($, O)), T = r.eql(r.mul(N, D), r.mul(V, O));
+      return S && T;
+    }
+    /**
+     * Flips point to one corresponding to (x, -y) in Affine coordinates.
+     */
+    negate() {
+      return new k(this.px, r.neg(this.py), this.pz);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a: M, b: U } = e, N = r.mul(U, Ur), { px: O, py: $, pz: V } = this;
+      let D = r.ZERO, S = r.ZERO, T = r.ZERO, p = r.mul(O, O), n = r.mul($, $), f = r.mul(V, V), a = r.mul(O, $);
+      return a = r.add(a, a), T = r.mul(O, V), T = r.add(T, T), D = r.mul(M, T), S = r.mul(N, f), S = r.add(D, S), D = r.sub(n, S), S = r.add(n, S), S = r.mul(D, S), D = r.mul(a, D), T = r.mul(N, T), f = r.mul(M, f), a = r.sub(p, f), a = r.mul(M, a), a = r.add(a, T), T = r.add(p, p), p = r.add(T, p), p = r.add(p, f), p = r.mul(p, a), S = r.add(S, p), f = r.mul($, V), f = r.add(f, f), p = r.mul(f, a), D = r.sub(D, p), T = r.mul(f, n), T = r.add(T, T), T = r.add(T, T), new k(D, S, T);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(M) {
+      _(M);
+      const { px: U, py: N, pz: O } = this, { px: $, py: V, pz: D } = M;
+      let S = r.ZERO, T = r.ZERO, p = r.ZERO;
+      const n = e.a, f = r.mul(e.b, Ur);
+      let a = r.mul(U, $), d = r.mul(N, V), l = r.mul(O, D), u = r.add(U, N), y = r.add($, V);
+      u = r.mul(u, y), y = r.add(a, d), u = r.sub(u, y), y = r.add(U, O);
+      let h = r.add($, D);
+      return y = r.mul(y, h), h = r.add(a, l), y = r.sub(y, h), h = r.add(N, O), S = r.add(V, D), h = r.mul(h, S), S = r.add(d, l), h = r.sub(h, S), p = r.mul(n, y), S = r.mul(f, l), p = r.add(S, p), S = r.sub(d, p), p = r.add(d, p), T = r.mul(S, p), d = r.add(a, a), d = r.add(d, a), l = r.mul(n, l), y = r.mul(f, y), d = r.add(d, l), l = r.sub(a, l), l = r.mul(n, l), y = r.add(y, l), a = r.mul(d, y), T = r.add(T, a), a = r.mul(h, y), S = r.mul(u, S), S = r.sub(S, a), a = r.mul(u, d), p = r.mul(h, p), p = r.add(p, a), new k(S, T, p);
+    }
+    subtract(M) {
+      return this.add(M.negate());
+    }
+    is0() {
+      return this.equals(k.ZERO);
+    }
+    wNAF(M) {
+      return st.wNAFCached(this, M, k.normalizeZ);
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed private key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(M) {
+      const { endo: U, n: N } = e;
+      Xt("scalar", M, Ft, N);
+      const O = k.ZERO;
+      if (M === Ft)
+        return O;
+      if (this.is0() || M === $t)
+        return this;
+      if (!U || st.hasPrecomputes(this))
+        return st.wNAFCachedUnsafe(this, M, k.normalizeZ);
+      let { k1neg: $, k1: V, k2neg: D, k2: S } = U.splitScalar(M), T = O, p = O, n = this;
+      for (; V > Ft || S > Ft; )
+        V & $t && (T = T.add(n)), S & $t && (p = p.add(n)), n = n.double(), V >>= $t, S >>= $t;
+      return $ && (T = T.negate()), D && (p = p.negate()), p = new k(r.mul(p.px, U.beta), p.py, p.pz), T.add(p);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(M) {
+      const { endo: U, n: N } = e;
+      Xt("scalar", M, $t, N);
+      let O, $;
+      if (U) {
+        const { k1neg: V, k1: D, k2neg: S, k2: T } = U.splitScalar(M);
+        let { p, f: n } = this.wNAF(D), { p: f, f: a } = this.wNAF(T);
+        p = st.constTimeNegate(V, p), f = st.constTimeNegate(S, f), f = new k(r.mul(f.px, U.beta), f.py, f.pz), O = p.add(f), $ = n.add(a);
+      } else {
+        const { p: V, f: D } = this.wNAF(M);
+        O = V, $ = D;
+      }
+      return k.normalizeZ([O, $])[0];
+    }
+    /**
+     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+     * Not using Strauss-Shamir trick: precomputation tables are faster.
+     * The trick could be useful if both P and Q are not G (not in our case).
+     * @returns non-zero affine point
+     */
+    multiplyAndAddUnsafe(M, U, N) {
+      const O = k.BASE, $ = (D, S) => S === Ft || S === $t || !D.equals(O) ? D.multiplyUnsafe(S) : D.multiply(S), V = $(this, U).add($(M, N));
+      return V.is0() ? void 0 : V;
+    }
+    // Converts Projective point to affine (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    // (x, y, z) ∋ (x=x/z, y=y/z)
+    toAffine(M) {
+      return R(this, M);
+    }
+    isTorsionFree() {
+      const { h: M, isTorsionFree: U } = e;
+      if (M === $t)
+        return !0;
+      if (U)
+        return U(k, this);
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+    }
+    clearCofactor() {
+      const { h: M, clearCofactor: U } = e;
+      return M === $t ? this : U ? U(k, this) : this.multiplyUnsafe(e.h);
+    }
+    toRawBytes(M = !0) {
+      return ee("isCompressed", M), this.assertValidity(), c(k, this, M);
+    }
+    toHex(M = !0) {
+      return ee("isCompressed", M), ue(this.toRawBytes(M));
+    }
+  }
+  k.BASE = new k(e.Gx, e.Gy, r.ONE), k.ZERO = new k(r.ZERO, r.ONE, r.ZERO);
+  const { endo: X, nBitLength: z } = e, st = ji(k, X ? Math.ceil(z / 2) : z);
+  return {
+    CURVE: e,
+    ProjectivePoint: k,
+    normPrivateKeyToScalar: E,
+    weierstrassEquation: w,
+    isWithinCurveOrder: x
+  };
+}
+function qf(t) {
+  const e = ln(t);
+  return Ie(e, {
+    hash: "hash",
+    hmac: "function",
+    randomBytes: "function"
+  }, {
+    bits2int: "function",
+    bits2int_modN: "function",
+    lowS: "boolean"
+  }), Object.freeze({ lowS: !0, ...e });
+}
+function $f(t) {
+  const e = qf(t), { Fp: r, n: o, nByteLength: c, nBitLength: s } = e, w = r.BYTES + 1, m = 2 * r.BYTES + 1;
+  function v(f) {
+    return F(f, o);
+  }
+  function b(f) {
+    return Hr(f, o);
+  }
+  const { ProjectivePoint: x, normPrivateKeyToScalar: E, weierstrassEquation: _, isWithinCurveOrder: R } = Lf({
+    ...e,
+    toBytes(f, a, d) {
+      const l = a.toAffine(), u = r.toBytes(l.x), y = de;
+      return ee("isCompressed", d), d ? y(Uint8Array.from([a.hasEvenY() ? 2 : 3]), u) : y(Uint8Array.from([4]), u, r.toBytes(l.y));
+    },
+    fromBytes(f) {
+      const a = f.length, d = f[0], l = f.subarray(1);
+      if (a === w && (d === 2 || d === 3)) {
+        const u = ie(l);
+        if (!cn(u, $t, r.ORDER))
+          throw new Error("Point is not on curve");
+        const y = _(u);
+        let h;
+        try {
+          h = r.sqrt(y);
+        } catch (A) {
+          const B = A instanceof Error ? ": " + A.message : "";
+          throw new Error("Point is not on curve" + B);
+        }
+        const i = (h & $t) === $t;
+        return (d & 1) === 1 !== i && (h = r.neg(h)), { x: u, y: h };
+      } else if (a === m && d === 4) {
+        const u = r.fromBytes(l.subarray(0, r.BYTES)), y = r.fromBytes(l.subarray(r.BYTES, 2 * r.BYTES));
+        return { x: u, y };
+      } else {
+        const u = w, y = m;
+        throw new Error("invalid Point, expected length of " + u + ", or uncompressed " + y + ", got " + a);
+      }
+    }
+  });
+  function q(f) {
+    const a = o >> $t;
+    return f > a;
+  }
+  function k(f) {
+    return q(f) ? v(-f) : f;
+  }
+  const X = (f, a, d) => ie(f.slice(a, d));
+  class z {
+    constructor(a, d, l) {
+      Xt("r", a, $t, o), Xt("s", d, $t, o), this.r = a, this.s = d, l != null && (this.recovery = l), Object.freeze(this);
+    }
+    // pair (bytes of r, bytes of s)
+    static fromCompact(a) {
+      const d = c;
+      return a = ot("compactSignature", a, d * 2), new z(X(a, 0, d), X(a, d, 2 * d));
+    }
+    // DER encoded ECDSA signature
+    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
+    static fromDER(a) {
+      const { r: d, s: l } = Qt.toSig(ot("DER", a));
+      return new z(d, l);
+    }
+    /**
+     * @todo remove
+     * @deprecated
+     */
+    assertValidity() {
+    }
+    addRecoveryBit(a) {
+      return new z(this.r, this.s, a);
+    }
+    recoverPublicKey(a) {
+      const { r: d, s: l, recovery: u } = this, y = O(ot("msgHash", a));
+      if (u == null || ![0, 1, 2, 3].includes(u))
+        throw new Error("recovery id invalid");
+      const h = u === 2 || u === 3 ? d + e.n : d;
+      if (h >= r.ORDER)
+        throw new Error("recovery id 2 or 3 invalid");
+      const i = (u & 1) === 0 ? "02" : "03", g = x.fromHex(i + kr(h, r.BYTES)), A = b(h), B = v(-y * A), I = v(l * A), P = x.BASE.multiplyAndAddUnsafe(g, B, I);
+      if (!P)
+        throw new Error("point at infinify");
+      return P.assertValidity(), P;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return q(this.s);
+    }
+    normalizeS() {
+      return this.hasHighS() ? new z(this.r, v(-this.s), this.recovery) : this;
+    }
+    // DER-encoded
+    toDERRawBytes() {
+      return Ye(this.toDERHex());
+    }
+    toDERHex() {
+      return Qt.hexFromSig(this);
+    }
+    // padded bytes of r, then padded bytes of s
+    toCompactRawBytes() {
+      return Ye(this.toCompactHex());
+    }
+    toCompactHex() {
+      const a = c;
+      return kr(this.r, a) + kr(this.s, a);
+    }
+  }
+  const st = {
+    isValidPrivateKey(f) {
+      try {
+        return E(f), !0;
+      } catch {
+        return !1;
+      }
+    },
+    normPrivateKeyToScalar: E,
+    /**
+     * Produces cryptographically secure private key from random of size
+     * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
+     */
+    randomPrivateKey: () => {
+      const f = Xi(e.n);
+      return kf(e.randomBytes(f), e.n);
+    },
+    /**
+     * Creates precompute table for an arbitrary EC point. Makes point "cached".
+     * Allows to massively speed-up `point.multiply(scalar)`.
+     * @returns cached point
+     * @example
+     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
+     * fast.multiply(privKey); // much faster ECDH now
+     */
+    precompute(f = 8, a = x.BASE) {
+      return a._setWindowSize(f), a.multiply(BigInt(3)), a;
+    }
+  };
+  function L(f, a = !0) {
+    return x.fromPrivateKey(f).toRawBytes(a);
+  }
+  function M(f) {
+    if (typeof f == "bigint")
+      return !1;
+    if (f instanceof x)
+      return !0;
+    const d = ot("key", f).length, l = r.BYTES, u = l + 1, y = 2 * l + 1;
+    if (!(e.allowedPrivateKeyLengths || c === u))
+      return d === u || d === y;
+  }
+  function U(f, a, d = !0) {
+    if (M(f) === !0)
+      throw new Error("first arg must be private key");
+    if (M(a) === !1)
+      throw new Error("second arg must be public key");
+    return x.fromHex(a).multiply(E(f)).toRawBytes(d);
+  }
+  const N = e.bits2int || function(f) {
+    if (f.length > 8192)
+      throw new Error("input is too large");
+    const a = ie(f), d = f.length * 8 - s;
+    return d > 0 ? a >> BigInt(d) : a;
+  }, O = e.bits2int_modN || function(f) {
+    return v(N(f));
+  }, $ = Je(s);
+  function V(f) {
+    return Xt("num < 2^" + s, f, Ft, $), Se(f, c);
+  }
+  function D(f, a, d = S) {
+    if (["recovered", "canonical"].some((H) => H in d))
+      throw new Error("sign() legacy options not supported");
+    const { hash: l, randomBytes: u } = e;
+    let { lowS: y, prehash: h, extraEntropy: i } = d;
+    y == null && (y = !0), f = ot("msgHash", f), Wn(d), h && (f = ot("prehashed msgHash", l(f)));
+    const g = O(f), A = E(a), B = [V(A), V(g)];
+    if (i != null && i !== !1) {
+      const H = i === !0 ? u(r.BYTES) : i;
+      B.push(ot("extraEntropy", H));
+    }
+    const I = de(...B), P = g;
+    function Z(H) {
+      const ft = N(H);
+      if (!R(ft))
+        return;
+      const K = b(ft), Y = x.BASE.multiply(ft).toAffine(), qt = v(Y.x);
+      if (qt === Ft)
+        return;
+      const j = v(K * v(P + qt * A));
+      if (j === Ft)
+        return;
+      let J = (Y.x === qt ? 0 : 2) | Number(Y.y & $t), Yt = j;
+      return y && q(j) && (Yt = k(j), J ^= 1), new z(qt, Yt, J);
+    }
+    return { seed: I, k2sig: Z };
+  }
+  const S = { lowS: e.lowS, prehash: !1 }, T = { lowS: e.lowS, prehash: !1 };
+  function p(f, a, d = S) {
+    const { seed: l, k2sig: u } = D(f, a, d), y = e;
+    return vf(y.hash.outputLen, y.nByteLength, y.hmac)(l, u);
+  }
+  x.BASE._setWindowSize(8);
+  function n(f, a, d, l = T) {
+    var J;
+    const u = f;
+    a = ot("msgHash", a), d = ot("publicKey", d);
+    const { lowS: y, prehash: h, format: i } = l;
+    if (Wn(l), "strict" in l)
+      throw new Error("options.strict was renamed to lowS");
+    if (i !== void 0 && i !== "compact" && i !== "der")
+      throw new Error("format must be compact or der");
+    const g = typeof u == "string" || Ae(u), A = !g && !i && typeof u == "object" && u !== null && typeof u.r == "bigint" && typeof u.s == "bigint";
+    if (!g && !A)
+      throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+    let B, I;
+    try {
+      if (A && (B = new z(u.r, u.s)), g) {
+        try {
+          i !== "compact" && (B = z.fromDER(u));
+        } catch (Yt) {
+          if (!(Yt instanceof Qt.Err))
+            throw Yt;
+        }
+        !B && i !== "der" && (B = z.fromCompact(u));
+      }
+      I = x.fromHex(d);
+    } catch {
+      return !1;
+    }
+    if (!B || y && B.hasHighS())
+      return !1;
+    h && (a = e.hash(a));
+    const { r: P, s: Z } = B, H = O(a), ft = b(Z), K = v(H * ft), Y = v(P * ft), qt = (J = x.BASE.multiplyAndAddUnsafe(I, K, Y)) == null ? void 0 : J.toAffine();
+    return qt ? v(qt.x) === P : !1;
+  }
+  return {
+    CURVE: e,
+    getPublicKey: L,
+    getSharedSecret: U,
+    sign: p,
+    verify: n,
+    ProjectivePoint: x,
+    Signature: z,
+    utils: st
+  };
+}
+function Pf(t) {
+  return {
+    hash: t,
+    hmac: (e, ...r) => pi(t, e, ko(...r)),
+    randomBytes: gi
+  };
+}
+function Zf(t, e) {
+  const r = (o) => $f({ ...t, ...Pf(o) });
+  return { ...r(e), create: r };
+}
+const Ji = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), jn = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), Df = BigInt(0), Hf = BigInt(1), Vr = BigInt(2), Gn = (t, e) => (t + e / Vr) / e;
+function Cf(t) {
+  const e = Ji, r = BigInt(3), o = BigInt(6), c = BigInt(11), s = BigInt(22), w = BigInt(23), m = BigInt(44), v = BigInt(88), b = t * t * t % e, x = b * b * t % e, E = it(x, r, e) * x % e, _ = it(E, r, e) * x % e, R = it(_, Vr, e) * b % e, q = it(R, c, e) * R % e, k = it(q, s, e) * q % e, X = it(k, m, e) * k % e, z = it(X, v, e) * X % e, st = it(z, m, e) * k % e, L = it(st, r, e) * x % e, M = it(L, w, e) * q % e, U = it(M, o, e) * b % e, N = it(U, Vr, e);
+  if (!zr.eql(zr.sqr(N), t))
+    throw new Error("Cannot find square root");
+  return N;
+}
+const zr = ke(Ji, void 0, void 0, { sqrt: Cf }), Ue = Zf({
+  a: Df,
+  b: BigInt(7),
+  Fp: zr,
+  n: jn,
+  Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
+  Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
+  h: BigInt(1),
+  lowS: !0,
+  // Allow only low-S signatures by default in sign() and verify()
+  endo: {
+    // Endomorphism, see above
+    beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+    splitScalar: (t) => {
+      const e = jn, r = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), o = -Hf * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), c = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), s = r, w = BigInt("0x100000000000000000000000000000000"), m = Gn(s * t, e), v = Gn(-o * t, e);
+      let b = F(t - m * r - v * c, e), x = F(-m * o - v * s, e);
+      const E = b > w, _ = x > w;
+      if (E && (b = e - b), _ && (x = e - x), b > w || x > w)
+        throw new Error("splitScalar: Endomorphism failed, k=" + t);
+      return { k1neg: E, k1: b, k2neg: _, k2: x };
+    }
+  }
+}, Fr);
+function we(t, e) {
+  if (t.length !== 32)
+    throw new Error("Expected valid 32-byte private key as a seed");
+  if (!Ct || !e && Vt()) {
+    const r = Uo(t), o = r.slice(32);
+    if (_i(o))
+      throw new Error("Invalid publicKey generated from WASM interface");
+    return {
+      publicKey: o,
+      secretKey: r.slice(0, 32)
+    };
+  }
+  return {
+    publicKey: Ue.getPublicKey(t, !0),
+    secretKey: t
+  };
+}
+function Qi(t, e) {
+  return (r, { chainCode: o, isHard: c }) => {
+    if (!c)
+      throw new Error("A soft key was found in the path and is not supported");
+    return t(e(r.secretKey.subarray(0, 32), o));
+  };
+}
+const Jn = /* @__PURE__ */ Qi(we, gf), Vf = rn(re("Ed25519HDKD"));
+function zf(t, e) {
+  if (!oe(e) || e.length !== 32)
+    throw new Error("Invalid chainCode passed to derive");
+  return se(Pt(Vf, t, e));
+}
+const Kt = BigInt(0), Dt = BigInt(1), Qn = BigInt(2), Yf = BigInt(8), Xf = { zip215: !0 };
+function Kf(t) {
+  const e = ln(t);
+  return Ie(t, {
+    hash: "function",
+    a: "bigint",
+    d: "bigint",
+    randomBytes: "function"
+  }, {
+    adjustScalarBytes: "function",
+    domain: "function",
+    uvRatio: "function",
+    mapToCurve: "function"
+  }), Object.freeze({ ...e });
+}
+function Wf(t) {
+  const e = Kf(t), { Fp: r, n: o, prehash: c, hash: s, randomBytes: w, nByteLength: m, h: v } = e, b = Qn << BigInt(m * 8) - Dt, x = r.create, E = ke(e.n, e.nBitLength);
+  function _(l, u) {
+    const y = r.sqr(l), h = r.sqr(u), i = r.add(r.mul(e.a, y), h), g = r.add(r.ONE, r.mul(e.d, r.mul(y, h)));
+    return r.eql(i, g);
+  }
+  if (!_(e.Gx, e.Gy))
+    throw new Error("bad curve params: generator point");
+  const R = e.uvRatio || ((l, u) => {
+    try {
+      return { isValid: !0, value: r.sqrt(l * r.inv(u)) };
+    } catch {
+      return { isValid: !1, value: Kt };
+    }
+  }), q = e.adjustScalarBytes || ((l) => l), k = e.domain || ((l, u, y) => {
+    if (ee("phflag", y), u.length || y)
+      throw new Error("Contexts/pre-hash are not supported");
+    return l;
+  });
+  function X(l, u, y = !1) {
+    const h = y ? Dt : Kt;
+    Xt("coordinate " + l, u, h, b);
+  }
+  function z(l) {
+    if (!(l instanceof M))
+      throw new Error("ExtendedPoint expected");
+  }
+  const st = Ke((l, u) => {
+    const { ex: y, ey: h, ez: i } = l, g = l.is0();
+    u == null && (u = g ? Yf : r.inv(i));
+    const A = x(y * u), B = x(h * u), I = x(i * u);
+    if (g)
+      return { x: Kt, y: Dt };
+    if (I !== Dt)
+      throw new Error("invZ was invalid");
+    return { x: A, y: B };
+  }), L = Ke((l) => {
+    const { a: u, d: y } = e;
+    if (l.is0())
+      throw new Error("bad point: ZERO");
+    const { ex: h, ey: i, ez: g, et: A } = l, B = x(h * h), I = x(i * i), P = x(g * g), Z = x(P * P), H = x(B * u), ft = x(P * x(H + I)), K = x(Z + x(y * x(B * I)));
+    if (ft !== K)
+      throw new Error("bad point: equation left != right (1)");
+    const Y = x(h * i), qt = x(g * A);
+    if (Y !== qt)
+      throw new Error("bad point: equation left != right (2)");
+    return !0;
+  });
+  class M {
+    constructor(u, y, h, i) {
+      X("x", u), X("y", y), X("z", h, !0), X("t", i), this.ex = u, this.ey = y, this.ez = h, this.et = i, Object.freeze(this);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    static fromAffine(u) {
+      if (u instanceof M)
+        throw new Error("extended point not allowed");
+      const { x: y, y: h } = u || {};
+      return X("x", y), X("y", h), new M(y, h, Dt, x(y * h));
+    }
+    static normalizeZ(u) {
+      const y = hn(r, u.map((h) => h.ez));
+      return u.map((h, i) => h.toAffine(y[i])).map(M.fromAffine);
+    }
+    // Multiscalar Multiplication
+    static msm(u, y) {
+      return Gi(M, E, u, y);
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(u) {
+      O.setWindowSize(this, u);
+    }
+    // Not required for fromHex(), which always creates valid points.
+    // Could be useful for fromAffine().
+    assertValidity() {
+      L(this);
+    }
+    // Compare one point to another.
+    equals(u) {
+      z(u);
+      const { ex: y, ey: h, ez: i } = this, { ex: g, ey: A, ez: B } = u, I = x(y * B), P = x(g * i), Z = x(h * B), H = x(A * i);
+      return I === P && Z === H;
+    }
+    is0() {
+      return this.equals(M.ZERO);
+    }
+    negate() {
+      return new M(x(-this.ex), this.ey, this.ez, x(-this.et));
+    }
+    // Fast algo for doubling Extended Point.
+    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
+    // Cost: 4M + 4S + 1*a + 6add + 1*2.
+    double() {
+      const { a: u } = e, { ex: y, ey: h, ez: i } = this, g = x(y * y), A = x(h * h), B = x(Qn * x(i * i)), I = x(u * g), P = y + h, Z = x(x(P * P) - g - A), H = I + A, ft = H - B, K = I - A, Y = x(Z * ft), qt = x(H * K), j = x(Z * K), J = x(ft * H);
+      return new M(Y, qt, J, j);
+    }
+    // Fast algo for adding 2 Extended Points.
+    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
+    // Cost: 9M + 1*a + 1*d + 7add.
+    add(u) {
+      z(u);
+      const { a: y, d: h } = e, { ex: i, ey: g, ez: A, et: B } = this, { ex: I, ey: P, ez: Z, et: H } = u, ft = x(i * I), K = x(g * P), Y = x(B * h * H), qt = x(A * Z), j = x((i + g) * (I + P) - ft - K), J = qt - Y, Yt = qt + Y, tt = x(K - y * ft), et = x(j * J), Ne = x(Yt * tt), rt = x(j * tt), nt = x(J * Yt);
+      return new M(et, Ne, nt, rt);
+    }
+    subtract(u) {
+      return this.add(u.negate());
+    }
+    wNAF(u) {
+      return O.wNAFCached(this, u, M.normalizeZ);
+    }
+    // Constant-time multiplication.
+    multiply(u) {
+      const y = u;
+      Xt("scalar", y, Dt, o);
+      const { p: h, f: i } = this.wNAF(y);
+      return M.normalizeZ([h, i])[0];
+    }
+    // Non-constant-time multiplication. Uses double-and-add algorithm.
+    // It's faster, but should only be used when you don't care about
+    // an exposed private key e.g. sig verification.
+    // Does NOT allow scalars higher than CURVE.n.
+    // Accepts optional accumulator to merge with multiply (important for sparse scalars)
+    multiplyUnsafe(u, y = M.ZERO) {
+      const h = u;
+      return Xt("scalar", h, Kt, o), h === Kt ? N : this.is0() || h === Dt ? this : O.wNAFCachedUnsafe(this, h, M.normalizeZ, y);
+    }
+    // Checks if point is of small order.
+    // If you add something to small order point, you will have "dirty"
+    // point with torsion component.
+    // Multiplies point by cofactor and checks if the result is 0.
+    isSmallOrder() {
+      return this.multiplyUnsafe(v).is0();
+    }
+    // Multiplies point by curve order and checks if the result is 0.
+    // Returns `false` is the point is dirty.
+    isTorsionFree() {
+      return O.unsafeLadder(this, o).is0();
+    }
+    // Converts Extended point to default (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    toAffine(u) {
+      return st(this, u);
+    }
+    clearCofactor() {
+      const { h: u } = e;
+      return u === Dt ? this : this.multiplyUnsafe(u);
+    }
+    // Converts hash string or Uint8Array to Point.
+    // Uses algo from RFC8032 5.1.3.
+    static fromHex(u, y = !1) {
+      const { d: h, a: i } = e, g = r.BYTES;
+      u = ot("pointHex", u, g), ee("zip215", y);
+      const A = u.slice(), B = u[g - 1];
+      A[g - 1] = B & -129;
+      const I = ve(A), P = y ? b : r.ORDER;
+      Xt("pointHex.y", I, Kt, P);
+      const Z = x(I * I), H = x(Z - Dt), ft = x(h * Z - i);
+      let { isValid: K, value: Y } = R(H, ft);
+      if (!K)
+        throw new Error("Point.fromHex: invalid y coordinate");
+      const qt = (Y & Dt) === Dt, j = (B & 128) !== 0;
+      if (!y && Y === Kt && j)
+        throw new Error("Point.fromHex: x=0 and x_0=1");
+      return j !== qt && (Y = x(-Y)), M.fromAffine({ x: Y, y: I });
+    }
+    static fromPrivateKey(u) {
+      const { scalar: y } = D(u);
+      return U.multiply(y);
+    }
+    toRawBytes() {
+      const { x: u, y } = this.toAffine(), h = Xe(y, r.BYTES);
+      return h[h.length - 1] |= u & Dt ? 128 : 0, h;
+    }
+    toHex() {
+      return ue(this.toRawBytes());
+    }
+  }
+  M.BASE = new M(e.Gx, e.Gy, Dt, x(e.Gx * e.Gy)), M.ZERO = new M(Kt, Dt, Dt, Kt);
+  const { BASE: U, ZERO: N } = M, O = ji(M, m * 8);
+  function $(l) {
+    return F(l, o);
+  }
+  function V(l) {
+    return $(ve(l));
+  }
+  function D(l) {
+    const u = r.BYTES;
+    l = ot("private key", l, u);
+    const y = ot("hashed private key", s(l), 2 * u), h = q(y.slice(0, u)), i = y.slice(u, 2 * u), g = V(h);
+    return { head: h, prefix: i, scalar: g };
+  }
+  function S(l) {
+    const { head: u, prefix: y, scalar: h } = D(l), i = U.multiply(h), g = i.toRawBytes();
+    return { head: u, prefix: y, scalar: h, point: i, pointBytes: g };
+  }
+  function T(l) {
+    return S(l).pointBytes;
+  }
+  function p(l = Uint8Array.of(), ...u) {
+    const y = de(...u);
+    return V(s(k(y, ot("context", l), !!c)));
+  }
+  function n(l, u, y = {}) {
+    l = ot("message", l), c && (l = c(l));
+    const { prefix: h, scalar: i, pointBytes: g } = S(u), A = p(y.context, h, l), B = U.multiply(A).toRawBytes(), I = p(y.context, B, g, l), P = $(A + I * i);
+    Xt("signature.s", P, Kt, o);
+    const Z = de(B, Xe(P, r.BYTES));
+    return ot("result", Z, r.BYTES * 2);
+  }
+  const f = Xf;
+  function a(l, u, y, h = f) {
+    const { context: i, zip215: g } = h, A = r.BYTES;
+    l = ot("signature", l, 2 * A), u = ot("message", u), y = ot("publicKey", y, A), g !== void 0 && ee("zip215", g), c && (u = c(u));
+    const B = ve(l.slice(A, 2 * A));
+    let I, P, Z;
+    try {
+      I = M.fromHex(y, g), P = M.fromHex(l.slice(0, A), g), Z = U.multiplyUnsafe(B);
+    } catch {
+      return !1;
+    }
+    if (!g && I.isSmallOrder())
+      return !1;
+    const H = p(i, P.toRawBytes(), I.toRawBytes(), u);
+    return P.add(I.multiplyUnsafe(H)).subtract(Z).clearCofactor().equals(M.ZERO);
+  }
+  return U._setWindowSize(8), {
+    CURVE: e,
+    getPublicKey: T,
+    sign: n,
+    verify: a,
+    ExtendedPoint: M,
+    utils: {
+      getExtendedPublicKey: S,
+      /** ed25519 priv keys are uniform 32b. No need to check for modulo bias, like in secp256k1. */
+      randomPrivateKey: () => w(r.BYTES),
+      /**
+       * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
+       * values. This slows down first getPublicKey() by milliseconds (see Speed section),
+       * but allows to speed-up subsequent getPublicKey() calls up to 20x.
+       * @param windowSize 2, 4, 8, 16
+       */
+      precompute(l = 8, u = M.BASE) {
+        return u._setWindowSize(l), u.multiply(BigInt(3)), u;
+      }
+    }
+  };
+}
+const q0 = BigInt(0), $0 = BigInt(1), P0 = BigInt(2);
+const un = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949"), Fn = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+BigInt(0);
+const jf = BigInt(1), ti = BigInt(2), Z0 = BigInt(3), Gf = BigInt(5), Jf = BigInt(8);
+function Qf(t) {
+  const e = BigInt(10), r = BigInt(20), o = BigInt(40), c = BigInt(80), s = un, m = t * t % s * t % s, v = it(m, ti, s) * m % s, b = it(v, jf, s) * t % s, x = it(b, Gf, s) * b % s, E = it(x, e, s) * x % s, _ = it(E, r, s) * E % s, R = it(_, o, s) * _ % s, q = it(R, c, s) * R % s, k = it(q, c, s) * R % s, X = it(k, e, s) * x % s;
+  return { pow_p_5_8: it(X, ti, s) * t % s, b2: m };
+}
+function Ff(t) {
+  return t[0] &= 248, t[31] &= 127, t[31] |= 64, t;
+}
+function ta(t, e) {
+  const r = un, o = F(e * e * e, r), c = F(o * o * e, r), s = Qf(t * c).pow_p_5_8;
+  let w = F(t * o * s, r);
+  const m = F(e * w * w, r), v = w, b = F(w * Fn, r), x = m === t, E = m === F(-t, r), _ = m === F(-t * Fn, r);
+  return x && (w = v), (E || _) && (w = b), Bf(w, r) && (w = F(-w, r)), { isValid: x || E, value: w };
+}
+const ei = ke(un, void 0, !0), ea = {
+  // Removing Fp.create() will still work, and is 10% faster on sign
+  a: ei.create(BigInt(-1)),
+  // d is -121665/121666 a.k.a. Fp.neg(121665 * Fp.inv(121666))
+  d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"),
+  // Finite field 2n**255n - 19n
+  Fp: ei,
+  // Subgroup order 2n**252n + 27742317777372353535851937790883648493n;
+  n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"),
+  h: Jf,
+  Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"),
+  Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"),
+  hash: us,
+  randomBytes: gi,
+  adjustScalarBytes: Ff,
+  // dom2
+  // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
+  // Constant-time, u/√v
+  uvRatio: ta
+}, dn = Wf(ea);
+function wn(t, e) {
+  if (!Ct || !e && Vt()) {
+    const o = No(t);
+    return {
+      publicKey: o.slice(32),
+      secretKey: o.slice(0, 64)
+    };
+  }
+  const r = dn.getPublicKey(t);
+  return {
+    publicKey: r,
+    secretKey: _e([t, r])
+  };
+}
+function ra(t, { publicKey: e, secretKey: r }, o) {
+  if (r) {
+    if (!e)
+      throw new Error("Expected a valid publicKey");
+  } else throw new Error("Expected a valid secretKey");
+  const c = C(t), s = r.subarray(0, 32);
+  return !Ct || !o && Vt() ? Ro(e, s, c) : dn.sign(c, s);
+}
+function Fi(t, e, r, o) {
+  const c = C(t), s = C(r), w = C(e);
+  if (s.length !== 32)
+    throw new Error(`Invalid publicKey, received ${s.length}, expected 32`);
+  if (w.length !== 64)
+    throw new Error(`Invalid signature, received ${w.length} bytes, expected 64`);
+  try {
+    return !Ct || !o && Vt() ? Oo(w, c, s) : dn.verify(w, c, s);
+  } catch {
+    return !1;
+  }
+}
+const na = /* @__PURE__ */ Qi(wn, zf), Yr = 64, ia = 32, Nr = Yr + ia;
+function to(t) {
+  const e = C(t);
+  if (e.length !== Nr)
+    throw new Error(`Expected keypair with ${Nr} bytes, found ${e.length}`);
+  return {
+    publicKey: e.slice(Yr, Nr),
+    secretKey: e.slice(0, Yr)
+  };
+}
+function oa({ publicKey: t, secretKey: e }) {
+  return Pt(e, t).slice();
+}
+function eo(t) {
+  return (e, r) => {
+    if (!oe(r) || r.length !== 32)
+      throw new Error("Invalid chainCode passed to derive");
+    return to(t(oa(e), r));
+  };
+}
+const sa = /* @__PURE__ */ eo(To), fa = /* @__PURE__ */ eo(Lo);
+function aa(t, { chainCode: e, isSoft: r }) {
+  return r ? fa(t, e) : sa(t, e);
+}
+const ca = {
+  ecdsa: Jn,
+  ed25519: na,
+  // FIXME This is Substrate-compatible, not Ethereum-compatible
+  ethereum: Jn,
+  sr25519: aa
+};
+function ro(t, e, r) {
+  const o = ca[r];
+  let c = t;
+  for (const s of e)
+    c = o(c, s);
+  return c;
+}
+function no(t) {
+  const e = C(t);
+  if (e.length !== 32)
+    throw new Error(`Expected a seed matching 32 bytes, found ${e.length}`);
+  return to(qo(e));
+}
+function ha(t, { publicKey: e, secretKey: r }) {
+  if ((e == null ? void 0 : e.length) !== 32)
+    throw new Error("Expected a valid publicKey, 32-bytes");
+  if ((r == null ? void 0 : r.length) !== 64)
+    throw new Error("Expected a valid secretKey, 64-bytes");
+  return $o(e, r, C(t));
+}
+function io(t, e, r) {
+  const o = C(r), c = C(e);
+  if (o.length !== 32)
+    throw new Error(`Invalid publicKey, received ${o.length} bytes, expected 32`);
+  if (c.length !== 64)
+    throw new Error(`Invalid signature, received ${c.length} bytes, expected 64`);
+  return Po(c, C(t), o);
+}
+const ri = new Uint8Array();
+function la(t, { secretKey: e }, r = ri, o = ri) {
+  if ((e == null ? void 0 : e.length) !== 64)
+    throw new Error("Invalid secretKey, expected 64-bytes");
+  return Zo(e, C(r), C(t), C(o));
+}
+const ni = new Uint8Array();
+function ua(t, e, r, o = ni, c = ni) {
+  const s = C(r), w = C(e);
+  if (s.length !== 32)
+    throw new Error("Invalid publicKey, expected 32-bytes");
+  if (w.length !== 96)
+    throw new Error("Invalid vrfSign output, expected 96 bytes");
+  return Do(s, C(o), C(t), C(c), w);
+}
+function da(t, e = qe.prefix) {
+  const r = he(t);
+  if (e < 0 || e > 16383 || [46, 47].includes(e))
+    throw new Error("Out of range ss58Format specified");
+  if (!qe.allowedDecodedLengths.includes(r.length))
+    throw new Error(`Expected a valid key to convert, with length ${qe.allowedDecodedLengths.join(", ")}`);
+  const o = Pt(e < 64 ? [e] : [
+    (e & 252) >> 2 | 64,
+    e >> 8 | (e & 3) << 6
+  ], r);
+  return of(Pt(o, qi(o).subarray(0, [32, 33].includes(r.length) ? 2 : 1)));
+}
+const wa = BigInt(0), me = BigInt(1), ma = BigInt(2), ga = BigInt(7), pa = BigInt(256), ya = BigInt(113), oo = [], so = [], fo = [];
+for (let t = 0, e = me, r = 1, o = 0; t < 24; t++) {
+  [r, o] = [o, (2 * r + 3 * o) % 5], oo.push(2 * (5 * o + r)), so.push((t + 1) * (t + 2) / 2 % 64);
+  let c = wa;
+  for (let s = 0; s < 7; s++)
+    e = (e << me ^ (e >> ga) * ya) % pa, e & ma && (c ^= me << (me << /* @__PURE__ */ BigInt(s)) - me);
+  fo.push(c);
+}
+const ao = Ho(fo, !0), va = ao[0], xa = ao[1], ii = (t, e, r) => r > 32 ? Xo(t, e, r) : Ko(t, e, r), oi = (t, e, r) => r > 32 ? Wo(t, e, r) : jo(t, e, r);
+function ba(t, e = 24) {
+  const r = new Uint32Array(10);
+  for (let o = 24 - e; o < 24; o++) {
+    for (let w = 0; w < 10; w++)
+      r[w] = t[w] ^ t[w + 10] ^ t[w + 20] ^ t[w + 30] ^ t[w + 40];
+    for (let w = 0; w < 10; w += 2) {
+      const m = (w + 8) % 10, v = (w + 2) % 10, b = r[v], x = r[v + 1], E = ii(b, x, 1) ^ r[m], _ = oi(b, x, 1) ^ r[m + 1];
+      for (let R = 0; R < 50; R += 10)
+        t[w + R] ^= E, t[w + R + 1] ^= _;
+    }
+    let c = t[2], s = t[3];
+    for (let w = 0; w < 24; w++) {
+      const m = so[w], v = ii(c, s, m), b = oi(c, s, m), x = oo[w];
+      c = t[x], s = t[x + 1], t[x] = v, t[x + 1] = b;
+    }
+    for (let w = 0; w < 50; w += 10) {
+      for (let m = 0; m < 10; m++)
+        r[m] = t[w + m];
+      for (let m = 0; m < 10; m++)
+        t[w + m] ^= ~r[(m + 2) % 10] & r[(m + 4) % 10];
+    }
+    t[0] ^= va[o], t[1] ^= xa[o];
+  }
+  Qr(r);
+}
+class mn extends Vo {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(e, r, o, c = !1, s = 24) {
+    if (super(), this.pos = 0, this.posOut = 0, this.finished = !1, this.destroyed = !1, this.enableXOF = !1, this.blockLen = e, this.suffix = r, this.outputLen = o, this.enableXOF = c, this.rounds = s, Jt(o), !(0 < e && e < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = Le(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    Pe(this.state32), ba(this.state32, this.rounds), Pe(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(e) {
+    On(this), e = zo(e), Tn(e);
+    const { blockLen: r, state: o } = this, c = e.length;
+    for (let s = 0; s < c; ) {
+      const w = Math.min(r - this.pos, c - s);
+      for (let m = 0; m < w; m++)
+        o[this.pos++] ^= e[s++];
+      this.pos === r && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: e, suffix: r, pos: o, blockLen: c } = this;
+    e[o] ^= r, (r & 128) !== 0 && o === c - 1 && this.keccak(), e[c - 1] ^= 128, this.keccak();
+  }
+  writeInto(e) {
+    On(this, !1), Tn(e), this.finish();
+    const r = this.state, { blockLen: o } = this;
+    for (let c = 0, s = e.length; c < s; ) {
+      this.posOut >= o && this.keccak();
+      const w = Math.min(o - this.posOut, s - c);
+      e.set(r.subarray(this.posOut, this.posOut + w), c), this.posOut += w, c += w;
+    }
+    return e;
+  }
+  xofInto(e) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(e);
+  }
+  xof(e) {
+    return Jt(e), this.xofInto(new Uint8Array(e));
+  }
+  digestInto(e) {
+    if (Yo(e, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(e), this.destroy(), e;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, Qr(this.state);
+  }
+  _cloneInto(e) {
+    const { blockLen: r, suffix: o, outputLen: c, rounds: s, enableXOF: w } = this;
+    return e || (e = new mn(r, o, c, w, s)), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = s, e.suffix = o, e.outputLen = c, e.enableXOF = w, e.destroyed = this.destroyed, e;
+  }
+}
+const co = (t, e, r) => Co(() => new mn(e, t, r)), Ea = co(1, 136, 256 / 8), Ma = co(1, 72, 512 / 8);
+const Qe = /* @__PURE__ */ Go({ 256: Qo, 512: Jo }, { 256: Ea, 512: Ma });
+function Xr(t, e, r) {
+  return t === "keccak" ? Qe(e, void 0, r) : se(e, void 0, void 0, r);
+}
+const gn = {
+  chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  coder: Fs,
+  type: "base64",
+  withPadding: !0
+}, _a = /* @__PURE__ */ Li(gn), Ba = /* @__PURE__ */ Oi(gn, _a), Aa = /* @__PURE__ */ Ti(gn);
+function ho(t, e) {
+  if (![33, 65].includes(t.length))
+    throw new Error(`Invalid publicKey provided, received ${t.length} bytes input`);
+  return t.length === 33 ? t : !Ct || Vt() ? Fo(t) : Ue.ProjectivePoint.fromHex(t).toRawBytes(!0);
+}
+function pn(t, e) {
+  if (![33, 65].includes(t.length))
+    throw new Error(`Invalid publicKey provided, received ${t.length} bytes input`);
+  if (t.length === 65)
+    return t.subarray(1);
+  if (!Ct || Vt())
+    return ts(t).subarray(1);
+  const { px: r, py: o } = Ue.ProjectivePoint.fromHex(t);
+  return Pt(zt(r, le), zt(o, le));
+}
+function Sa(t, e, r, o = "blake2", c) {
+  const s = C(e).subarray(0, 64), w = C(t), m = !Ct || Vt() ? es(w, s, r) : Ue.Signature.fromCompact(s).addRecoveryBit(r).recoverPublicKey(w).toRawBytes();
+  if (!m)
+    throw new Error("Unable to recover publicKey from signature");
+  return o === "keccak" ? pn(m) : ho(m);
+}
+function si(t, { secretKey: e }, r = "blake2", o) {
+  if ((e == null ? void 0 : e.length) !== 32)
+    throw new Error("Expected valid secp256k1 secretKey, 32-bytes");
+  const c = Xr(r, t, o);
+  if (!Ct || Vt())
+    return rs(c, e);
+  const s = Ue.sign(c, e, { lowS: !0 });
+  return Pt(zt(s.r, le), zt(s.s, le), new Uint8Array([s.recovery || 0]));
+}
+const lo = "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141".replace(/ /g, ""), Rr = Q(`0x${lo}`), Or = new W(lo, "hex");
+function Ia(t, e) {
+  let r = Zr(e, Cn);
+  if (r >= Rr)
+    throw new Error("Tweak parameter is out of range");
+  if (r += Zr(t, Cn), r >= Rr && (r -= Rr), r === Ze)
+    throw new Error("Invalid resulting private key");
+  return Ls(r, le);
+}
+function ka(t, e) {
+  const r = new W(e);
+  if (r.cmp(Or) >= 0)
+    throw new Error("Tweak parameter is out of range");
+  if (r.iadd(new W(t)), r.cmp(Or) >= 0 && r.isub(Or), r.isZero())
+    throw new Error("Invalid resulting private key");
+  return zt(r, le);
+}
+function Ua(t, e, r) {
+  if (!oe(t) || t.length !== 32)
+    throw new Error("Expected seckey to be an Uint8Array with length 32");
+  if (!oe(e) || e.length !== 32)
+    throw new Error("Expected tweak to be an Uint8Array with length 32");
+  return !Ct || r ? ka(t, e) : Ia(t, e);
+}
+function Na(t, e, r, o = "blake2", c) {
+  const s = C(e);
+  if (s.length !== 65)
+    throw new Error(`Expected signature with 65 bytes, ${s.length} found instead`);
+  const w = Sa(Xr(o, t), s, s[64], o), m = Xr(o, w, c), v = C(r);
+  return Wt(w, v) || (o === "keccak" ? Wt(m.slice(-20), v.slice(-20)) : Wt(m, v));
+}
+function Ra(t) {
+  return [33, 65].includes(t.length) && (t = Qe(pn(t))), t.slice(-20);
+}
+function uo(t) {
+  if (!t)
+    return "0x";
+  const e = C(t);
+  if (![20, 32, 33, 65].includes(e.length))
+    throw new Error(`Invalid address or publicKey provided, received ${e.length} bytes input`);
+  const r = xe(Ra(e), -1, !1), o = xe(Qe(r), -1, !1);
+  let c = "";
+  for (let s = 0; s < 40; s++)
+    c = `${c}${parseInt(o[s], 16) > 7 ? r[s].toUpperCase() : r[s]}`;
+  return `0x${c}`;
+}
+const Oa = {
+  256: ws,
+  512: ds
+}, Ta = {
+  256: is,
+  512: ns
+};
+function wo(t, e, r = 256, o) {
+  const c = C(t);
+  return !Ct || Vt() ? Ta[r](c, e) : pi(Oa[r], c, e);
+}
+const yn = 2147483648;
+function La(t) {
+  if (!t.startsWith("m/"))
+    return !1;
+  const e = t.split("/").slice(1);
+  for (const r of e) {
+    const o = /^\d+'?$/.test(r) ? parseInt(r.replace(/'$/, ""), 10) : Number.NaN;
+    if (isNaN(o) || o >= yn || o < 0)
+      return !1;
+  }
+  return !0;
+}
+const qa = re("Bitcoin seed");
+function mo(t, e) {
+  return {
+    chainCode: e,
+    publicKey: we(t).publicKey,
+    secretKey: t
+  };
+}
+function go(t, e) {
+  const r = zt(e, af), o = e >= yn ? Pt(new Uint8Array(1), t.secretKey, r) : Pt(t.publicKey, r);
+  try {
+    const c = wo(t.chainCode, o, 512);
+    return mo(Ua(t.secretKey, c.slice(0, 32)), c.slice(32));
+  } catch {
+    return go(t, e + 1);
+  }
+}
+function $a(t, e = "") {
+  const r = wo(qa, t, 512);
+  let o = mo(r.slice(0, 32), r.slice(32));
+  if (!e || e === "m" || e === "M" || e === "m'" || e === "M'")
+    return o;
+  if (!La(e))
+    throw new Error("Invalid derivation path");
+  const c = e.split("/").slice(1);
+  for (const s of c)
+    o = go(o, parseInt(s, 10) + (s.length > 1 && s.endsWith("'") ? yn : 0));
+  return o;
+}
+function Pa(t, e, r) {
+  return !Ct || Vt() ? os(t) : ms(t, e);
+}
+function po(t, e, r) {
+  return !Ct || Vt() ? ss(t) : gs(t, e);
+}
+function Za(t, e = "", r, o = 32) {
+  if (po(t)) {
+    if (![32, 64].includes(o))
+      throw new Error(`Invalid seed length ${o}, expected 32 or 64`);
+  } else throw new Error("Invalid bip39 mnemonic specified");
+  return o === 32 ? !Ct || Vt() ? fs(t, e) : Ln(t, e).subarray(0, 32) : Ln(t, e);
+}
+function Da(t, e = "", r, o) {
+  if (po(t, r)) {
+    if (Vt())
+      return as(t, e);
+  } else throw new Error("Invalid bip39 mnemonic specified");
+  const c = Pa(t, r), s = re(`mnemonic${e}`);
+  return ps(c, s).password.slice(0, 32);
+}
+function Oe(t, e) {
+  return t << e | t >>> 32 - e;
+}
+function fe(t, e) {
+  let r = t[e + 3] & 255;
+  return r = r << 8 | t[e + 2] & 255, r = r << 8 | t[e + 1] & 255, r << 8 | t[e + 0] & 255;
+}
+function Tr(t, e, r) {
+  for (let o = 0; o < 4; o++)
+    t[e + o] = r & 255, r >>>= 8;
+}
+function Ha(t, e, r, o, c) {
+  let s = 0;
+  for (let w = 0; w < c; w++)
+    s |= t[e + w] ^ r[o + w];
+  return (1 & s - 1 >>> 8) - 1;
+}
+function Kr(t, e, r, o, c) {
+  const s = new Uint32Array(16), w = new Uint32Array(16), m = new Uint32Array(16), v = new Uint32Array(4);
+  let b, x, E;
+  for (b = 0; b < 4; b++)
+    w[5 * b] = fe(o, 4 * b), w[1 + b] = fe(r, 4 * b), w[6 + b] = fe(e, 4 * b), w[11 + b] = fe(r, 16 + 4 * b);
+  for (b = 0; b < 16; b++)
+    m[b] = w[b];
+  for (b = 0; b < 20; b++) {
+    for (x = 0; x < 4; x++) {
+      for (E = 0; E < 4; E++)
+        v[E] = w[(5 * x + 4 * E) % 16];
+      for (v[1] ^= Oe(v[0] + v[3] | 0, 7), v[2] ^= Oe(v[1] + v[0] | 0, 9), v[3] ^= Oe(v[2] + v[1] | 0, 13), v[0] ^= Oe(v[3] + v[2] | 0, 18), E = 0; E < 4; E++)
+        s[4 * x + (x + E) % 4] = v[E];
+    }
+    for (E = 0; E < 16; E++)
+      w[E] = s[E];
+  }
+  if (c) {
+    for (b = 0; b < 16; b++)
+      w[b] = w[b] + m[b] | 0;
+    for (b = 0; b < 4; b++)
+      w[5 * b] = w[5 * b] - fe(o, 4 * b) | 0, w[6 + b] = w[6 + b] - fe(e, 4 * b) | 0;
+    for (b = 0; b < 4; b++)
+      Tr(t, 4 * b, w[5 * b]), Tr(t, 16 + 4 * b, w[6 + b]);
+  } else
+    for (b = 0; b < 16; b++)
+      Tr(t, 4 * b, w[b] + m[b] | 0);
+}
+const Wr = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
+function Ca(t, e, r, o, c, s, w) {
+  const m = new Uint8Array(16), v = new Uint8Array(64);
+  let b, x;
+  if (!c)
+    return 0;
+  for (x = 0; x < 16; x++)
+    m[x] = 0;
+  for (x = 0; x < 8; x++)
+    m[x] = s[x];
+  for (; c >= 64; ) {
+    for (Kr(v, m, w, Wr, !1), x = 0; x < 64; x++)
+      t[e + x] = (r ? r[o + x] : 0) ^ v[x];
+    for (b = 1, x = 8; x < 16; x++)
+      b = b + (m[x] & 255) | 0, m[x] = b & 255, b >>>= 8;
+    c -= 64, e += 64, r && (o += 64);
+  }
+  if (c > 0)
+    for (Kr(v, m, w, Wr, !1), x = 0; x < c; x++)
+      t[e + x] = (r ? r[o + x] : 0) ^ v[x];
+  return 0;
+}
+function jr(t, e, r, o, c, s, w) {
+  const m = new Uint8Array(32);
+  return Kr(m, s, w, Wr, !0), Ca(t, e, r, o, c, s.subarray(16), m);
+}
+function Lr(t, e) {
+  let r = 0;
+  for (let o = 0; o < 17; o++)
+    r = r + (t[o] + e[o] | 0) | 0, t[o] = r & 255, r >>>= 8;
+}
+const Va = new Uint32Array([5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252]);
+function yo(t, e, r, o, c, s) {
+  let w, m, v;
+  const b = new Uint32Array(17), x = new Uint32Array(17), E = new Uint32Array(17), _ = new Uint32Array(17), R = new Uint32Array(17);
+  for (m = 0; m < 17; m++)
+    x[m] = E[m] = 0;
+  for (m = 0; m < 16; m++)
+    x[m] = s[m];
+  for (x[3] &= 15, x[4] &= 252, x[7] &= 15, x[8] &= 252, x[11] &= 15, x[12] &= 252, x[15] &= 15; c > 0; ) {
+    for (m = 0; m < 17; m++)
+      _[m] = 0;
+    for (m = 0; m < 16 && m < c; ++m)
+      _[m] = r[o + m];
+    for (_[m] = 1, o += m, c -= m, Lr(E, _), w = 0; w < 17; w++)
+      for (b[w] = 0, m = 0; m < 17; m++)
+        b[w] = b[w] + E[m] * (m <= w ? x[w - m] : 320 * x[w + 17 - m] | 0) | 0 | 0;
+    for (w = 0; w < 17; w++)
+      E[w] = b[w];
+    for (v = 0, m = 0; m < 16; m++)
+      v = v + E[m] | 0, E[m] = v & 255, v >>>= 8;
+    for (v = v + E[16] | 0, E[16] = v & 3, v = 5 * (v >>> 2) | 0, m = 0; m < 16; m++)
+      v = v + E[m] | 0, E[m] = v & 255, v >>>= 8;
+    v = v + E[16] | 0, E[16] = v;
+  }
+  for (m = 0; m < 17; m++)
+    R[m] = E[m];
+  Lr(E, Va);
+  const q = -(E[16] >>> 7) | 0;
+  for (m = 0; m < 17; m++)
+    E[m] ^= q & (R[m] ^ E[m]);
+  for (m = 0; m < 16; m++)
+    _[m] = s[m + 16];
+  for (_[16] = 0, Lr(E, _), m = 0; m < 16; m++)
+    t[e + m] = E[m];
+  return 0;
+}
+function za(t, e, r, o, c, s) {
+  const w = new Uint8Array(16);
+  return yo(w, 0, r, o, c, s), Ha(t, e, w, 0, 16);
+}
+function Ya(t, e, r, o, c) {
+  if (r < 32)
+    return -1;
+  jr(t, 0, e, 0, r, o, c), yo(t, 16, t, 32, r - 32, t);
+  for (let s = 0; s < 16; s++)
+    t[s] = 0;
+  return 0;
+}
+function Xa(t, e, r, o, c) {
+  const s = new Uint8Array(32);
+  if (r < 32 || (jr(s, 0, null, 0, 32, o, c), za(e, 16, e, 32, r - 32, s) !== 0))
+    return -1;
+  jr(t, 0, e, 0, r, o, c);
+  for (let w = 0; w < 32; w++)
+    t[w] = 0;
+  return 0;
+}
+const Ka = 32, Wa = 24, Gr = 32, Jr = 16;
+function vo(t, e) {
+  if (t.length !== Ka)
+    throw new Error("bad key size");
+  if (e.length !== Wa)
+    throw new Error("bad nonce size");
+}
+function xo(...t) {
+  for (let e = 0, r = t.length; e < r; e++)
+    if (!(t[e] instanceof Uint8Array))
+      throw new TypeError("unexpected type, use Uint8Array");
+}
+function ja(t, e, r) {
+  xo(t, e, r), vo(r, e);
+  const o = new Uint8Array(Gr + t.length), c = new Uint8Array(o.length);
+  for (let s = 0; s < t.length; s++)
+    o[s + Gr] = t[s];
+  return Ya(c, o, o.length, e, r), c.subarray(Jr);
+}
+function Ga(t, e, r) {
+  xo(t, e, r), vo(r, e);
+  const o = new Uint8Array(Jr + t.length), c = new Uint8Array(o.length);
+  for (let s = 0; s < t.length; s++)
+    o[s + Jr] = t[s];
+  return o.length < 32 || Xa(c, o, o.length, e, r) !== 0 ? null : c.subarray(Gr);
+}
+function Ja(t, e, r) {
+  return Ga(t, e, r);
+}
+function Qa(t, e, r = vi(24)) {
+  return {
+    encrypted: ja(t, r, e),
+    nonce: r
+  };
+}
+function fi(t, e, r, o, c, s) {
+  let w = t[e++] ^ r[o++], m = t[e++] ^ r[o++], v = t[e++] ^ r[o++], b = t[e++] ^ r[o++], x = t[e++] ^ r[o++], E = t[e++] ^ r[o++], _ = t[e++] ^ r[o++], R = t[e++] ^ r[o++], q = t[e++] ^ r[o++], k = t[e++] ^ r[o++], X = t[e++] ^ r[o++], z = t[e++] ^ r[o++], st = t[e++] ^ r[o++], L = t[e++] ^ r[o++], M = t[e++] ^ r[o++], U = t[e++] ^ r[o++], N = w, O = m, $ = v, V = b, D = x, S = E, T = _, p = R, n = q, f = k, a = X, d = z, l = st, u = L, y = M, h = U;
+  for (let i = 0; i < 8; i += 2)
+    D ^= G(N + l | 0, 7), n ^= G(D + N | 0, 9), l ^= G(n + D | 0, 13), N ^= G(l + n | 0, 18), f ^= G(S + O | 0, 7), u ^= G(f + S | 0, 9), O ^= G(u + f | 0, 13), S ^= G(O + u | 0, 18), y ^= G(a + T | 0, 7), $ ^= G(y + a | 0, 9), T ^= G($ + y | 0, 13), a ^= G(T + $ | 0, 18), V ^= G(h + d | 0, 7), p ^= G(V + h | 0, 9), d ^= G(p + V | 0, 13), h ^= G(d + p | 0, 18), O ^= G(N + V | 0, 7), $ ^= G(O + N | 0, 9), V ^= G($ + O | 0, 13), N ^= G(V + $ | 0, 18), T ^= G(S + D | 0, 7), p ^= G(T + S | 0, 9), D ^= G(p + T | 0, 13), S ^= G(D + p | 0, 18), d ^= G(a + f | 0, 7), n ^= G(d + a | 0, 9), f ^= G(n + d | 0, 13), a ^= G(f + n | 0, 18), l ^= G(h + y | 0, 7), u ^= G(l + h | 0, 9), y ^= G(u + l | 0, 13), h ^= G(y + u | 0, 18);
+  c[s++] = w + N | 0, c[s++] = m + O | 0, c[s++] = v + $ | 0, c[s++] = b + V | 0, c[s++] = x + D | 0, c[s++] = E + S | 0, c[s++] = _ + T | 0, c[s++] = R + p | 0, c[s++] = q + n | 0, c[s++] = k + f | 0, c[s++] = X + a | 0, c[s++] = z + d | 0, c[s++] = st + l | 0, c[s++] = L + u | 0, c[s++] = M + y | 0, c[s++] = U + h | 0;
+}
+function qr(t, e, r, o, c) {
+  let s = o + 0, w = o + 16 * c;
+  for (let m = 0; m < 16; m++)
+    r[w + m] = t[e + (2 * c - 1) * 16 + m];
+  for (let m = 0; m < c; m++, s += 16, e += 16)
+    fi(r, w, t, e, r, s), m > 0 && (w += 16), fi(r, s, t, e += 16, r, w);
+}
+function Fa(t, e, r) {
+  const o = cs({
+    dkLen: 32,
+    asyncTick: 10,
+    maxmem: 1073742848
+  }, r), { N: c, r: s, p: w, dkLen: m, asyncTick: v, maxmem: b, onProgress: x } = o;
+  if (Jt(c), Jt(s), Jt(w), Jt(m), Jt(v), Jt(b), x !== void 0 && typeof x != "function")
+    throw new Error("progressCb should be function");
+  const E = 128 * s, _ = E / 4, R = Math.pow(2, 32);
+  if (c <= 1 || (c & c - 1) !== 0 || c > R)
+    throw new Error("Scrypt: N must be larger than 1, a power of 2, and less than 2^32");
+  if (w < 0 || w > (R - 1) * 32 / E)
+    throw new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
+  if (m < 0 || m > (R - 1) * 32)
+    throw new Error("Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32");
+  if (E * (c + w) > b)
+    throw new Error("Scrypt: memused is bigger than maxMem. Expected 128 * r * (N + p) > maxmem of " + b);
+  const k = yi(Fr, t, e, { c: 1, dkLen: E * w }), X = Le(k), z = Le(new Uint8Array(E * c)), st = Le(new Uint8Array(E));
+  let L = () => {
+  };
+  if (x) {
+    const M = 2 * c * w, U = Math.max(Math.floor(M / 1e4), 1);
+    let N = 0;
+    L = () => {
+      N++, x && (!(N % U) || N === M) && x(N / M);
+    };
+  }
+  return { N: c, r: s, p: w, dkLen: m, blockSize32: _, V: z, B32: X, B: k, tmp: st, blockMixCb: L, asyncTick: v };
+}
+function t0(t, e, r, o, c) {
+  const s = yi(Fr, t, r, { c: 1, dkLen: e });
+  return Qr(r, o, c), s;
+}
+function e0(t, e, r) {
+  const { N: o, r: c, p: s, dkLen: w, blockSize32: m, V: v, B32: b, B: x, tmp: E, blockMixCb: _ } = Fa(t, e, r);
+  Pe(b);
+  for (let R = 0; R < s; R++) {
+    const q = m * R;
+    for (let k = 0; k < m; k++)
+      v[k] = b[q + k];
+    for (let k = 0, X = 0; k < o - 1; k++)
+      qr(v, X, v, X += m, c), _();
+    qr(v, (o - 1) * m, b, q, c), _();
+    for (let k = 0; k < o; k++) {
+      const X = b[q + m - 16] % o;
+      for (let z = 0; z < m; z++)
+        E[z] = b[q + z] ^ v[X * m + z];
+      qr(E, 0, b, q, c), _();
+    }
+  }
+  return Pe(b), t0(t, w, x, v, E);
+}
+const $e = {
+  N: 32768,
+  p: 1,
+  r: 8
+};
+function bo(t, e = vi(), r = $e, o) {
+  const c = C(t);
+  return {
+    params: r,
+    password: !Ct || Vt() ? hs(c, e, Math.log2(r.N), r.r, r.p) : e0(c, e, tn({ dkLen: 64 }, r)),
+    salt: e
+  };
+}
+function r0(t) {
+  const e = t.subarray(0, 32), r = yr(t.subarray(32, 36), br).toNumber(), o = yr(t.subarray(36, 40), br).toNumber(), c = yr(t.subarray(40, 44), br).toNumber();
+  if (r !== $e.N || o !== $e.p || c !== $e.r)
+    throw new Error("Invalid injected scrypt params found");
+  return { params: { N: r, p: o, r: c }, salt: e };
+}
+function n0(t, { N: e, p: r, r: o }) {
+  return Pt(t, zt(e, Er), zt(r, Er), zt(o, Er));
+}
+const Eo = ["scrypt", "xsalsa20-poly1305"], i0 = ["none"], o0 = "3", ai = 24, s0 = 32 + 3 * 4;
+function f0(t, e, r = Eo) {
+  if (t) {
+    if (r.includes("xsalsa20-poly1305") && !e)
+      throw new Error("Password required to decode encrypted data");
+  } else throw new Error("No encrypted data available to decode");
+  let o = t;
+  if (e) {
+    let c;
+    if (r.includes("scrypt")) {
+      const { params: s, salt: w } = r0(t);
+      c = bo(e, w, s).password, t = t.subarray(s0);
+    } else
+      c = re(e);
+    o = Ja(t.subarray(ai), t.subarray(0, ai), ks(c, 256, !0));
+  }
+  if (!o)
+    throw new Error("Unable to decode using the supplied passphrase");
+  return o;
+}
+function a0(t, e, r) {
+  return {
+    encoded: Aa(t),
+    encoding: {
+      content: e,
+      type: r ? Eo : i0,
+      version: o0
+    }
+  };
+}
+const ci = (t) => (e, r, o) => Na(e, r, o, t), Mo = [
+  ["ecdsa", ci("blake2")],
+  ["ethereum", ci("keccak")]
+], c0 = [
+  ["ed25519", Fi],
+  ["sr25519", io],
+  ...Mo
+], h0 = ["ed25519", "sr25519", "ecdsa"];
+function _o(t, { message: e, publicKey: r, signature: o }, c = c0) {
+  return t.isValid = c.some(([s, w]) => {
+    try {
+      if (w(e, o, r))
+        return t.crypto = s, !0;
+    } catch {
+    }
+    return !1;
+  }), t;
+}
+function l0(t, { message: e, publicKey: r, signature: o }) {
+  if (![0, 1, 2].includes(o[0]))
+    throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${o[0]}`);
+  const c = h0[o[0]] || "none";
+  t.crypto = c;
+  try {
+    t.isValid = {
+      ecdsa: () => _o(t, { message: e, publicKey: r, signature: o.subarray(1) }, Mo).isValid,
+      ed25519: () => Fi(e, o.subarray(1), r),
+      none: () => {
+        throw Error("no verify for `none` crypto type");
+      },
+      sr25519: () => io(e, o.subarray(1), r)
+    }[c]();
+  } catch {
+  }
+  return t;
+}
+function u0(t) {
+  return [0, 1, 2].includes(t[0]) && [65, 66].includes(t.length) ? l0 : _o;
+}
+function hi(t, e, r) {
+  const o = C(e);
+  if (![64, 65, 66].includes(o.length))
+    throw new Error(`Invalid signature length, expected [64..66] bytes, found ${o.length}`);
+  const c = he(r), s = { message: C(t), publicKey: c, signature: o }, w = { crypto: "none", isValid: !1, isWrapped: He(s.message, !0), publicKey: c }, m = He(s.message, !1), v = u0(o);
+  return v(w, s), w.crypto !== "none" || w.isWrapped && !m ? w : (s.message = m ? Ns(s.message) : Rs(s.message), v(w, s));
+}
+const d0 = [ys, Ks], w0 = { name: "@polkadot/keyring", path: import.meta && import.meta.url ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf("/") + 1) : "auto", type: "esm", version: "12.6.2" };
+Es(w0, null, d0);
+const ae = new Uint8Array([161, 35, 3, 33, 0]), We = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]), m0 = 32, li = 64, g0 = 32, ge = We.length;
+function p0(t, e, r) {
+  const o = Array.isArray(r) || r === void 0 ? r : [r], c = f0(e, t, o), s = c.subarray(0, We.length);
+  if (!Wt(s, We))
+    throw new Error("Invalid Pkcs8 header found in body");
+  let w = c.subarray(ge, ge + li), m = ge + li, v = c.subarray(m, m + ae.length);
+  if (!Wt(v, ae) && (m = ge + g0, w = c.subarray(ge, m), v = c.subarray(m, m + ae.length), !Wt(v, ae)))
+    throw new Error("Invalid Pkcs8 divider found in body");
+  const b = m + ae.length;
+  return {
+    publicKey: c.subarray(b, b + m0),
+    secretKey: w
+  };
+}
+function y0({ publicKey: t, secretKey: e }, r) {
+  if (!e)
+    throw new Error("Expected a valid secretKey to be passed to encode");
+  const o = Pt(We, e, ae, t);
+  if (!r)
+    return o;
+  const { params: c, password: s, salt: w } = bo(r), { encrypted: m, nonce: v } = Qa(o, s.subarray(0, 32));
+  return Pt(n0(w, c), v, m);
+}
+function v0(t, { address: e, meta: r }, o, c) {
+  return tn(a0(o, ["pkcs8", t], c), {
+    address: e,
+    meta: r
+  });
+}
+const x0 = new Uint8Array(), b0 = {
+  ecdsa: we,
+  ed25519: wn,
+  ethereum: we,
+  sr25519: no
+}, ui = {
+  ecdsa: new Uint8Array([2]),
+  ed25519: new Uint8Array([0]),
+  ethereum: new Uint8Array([2]),
+  sr25519: new Uint8Array([1])
+}, di = {
+  ecdsa: (t, e) => si(t, e, "blake2"),
+  ed25519: ra,
+  ethereum: (t, e) => si(t, e, "keccak"),
+  sr25519: ha
+}, Te = {
+  ecdsa: (t) => t.length > 32 ? se(t) : t,
+  ed25519: (t) => t,
+  ethereum: (t) => t.length === 20 ? t : Qe(pn(t)),
+  sr25519: (t) => t
+};
+function pe(t) {
+  return !t || _i(t);
+}
+function wi(t, e, r) {
+  return se(Pt(e || "", r || "", t));
+}
+function ce({ toSS58: t, type: e }, { publicKey: r, secretKey: o }, c = {}, s = null, w) {
+  const m = (x, E) => {
+    const _ = p0(x, E || s, w);
+    if (_.secretKey.length === 64)
+      r = _.publicKey, o = _.secretKey;
+    else {
+      const R = b0[e](_.secretKey);
+      r = R.publicKey, o = R.secretKey;
+    }
+  }, v = (x) => (pe(o) && s && m(x, s), s = y0({ publicKey: r, secretKey: o }, x), w = void 0, s), b = () => {
+    const x = Te[e](r);
+    return e === "ethereum" ? uo(x) : t(x);
+  };
+  return {
+    get address() {
+      return b();
+    },
+    get addressRaw() {
+      const x = Te[e](r);
+      return e === "ethereum" ? x.slice(-20) : x;
+    },
+    get isLocked() {
+      return pe(o);
+    },
+    get meta() {
+      return c;
+    },
+    get publicKey() {
+      return r;
+    },
+    get type() {
+      return e;
+    },
+    // eslint-disable-next-line sort-keys
+    decodePkcs8: m,
+    derive: (x, E) => {
+      if (e === "ethereum")
+        throw new Error("Unable to derive on this keypair");
+      if (pe(o))
+        throw new Error("Cannot derive on a locked keypair");
+      const { path: _ } = $i(x), R = ro({ publicKey: r, secretKey: o }, _, e);
+      return ce({ toSS58: t, type: e }, R, E, null);
+    },
+    encodePkcs8: (x) => v(x),
+    lock: () => {
+      o = new Uint8Array();
+    },
+    setMeta: (x) => {
+      c = tn({}, c, x);
+    },
+    sign: (x, E = {}) => {
+      if (pe(o))
+        throw new Error("Cannot sign with a locked key pair");
+      return Pt(E.withType ? ui[e] : x0, di[e](C(x), { publicKey: r, secretKey: o }));
+    },
+    toJson: (x) => {
+      const E = ["ecdsa", "ethereum"].includes(e) ? r.length === 20 ? xe(r) : xe(ho(r)) : b();
+      return v0(e, { address: E, meta: c }, v(x), !!x);
+    },
+    unlock: (x) => m(x),
+    verify: (x, E, _) => hi(x, E, Te[e](C(_))).isValid,
+    vrfSign: (x, E, _) => {
+      if (pe(o))
+        throw new Error("Cannot sign with a locked key pair");
+      if (e === "sr25519")
+        return la(x, { secretKey: o }, E, _);
+      const R = di[e](C(x), { publicKey: r, secretKey: o });
+      return Pt(wi(R, E, _), R);
+    },
+    vrfVerify: (x, E, _, R, q) => e === "sr25519" ? ua(x, E, r, R, q) : hi(x, Pt(ui[e], E.subarray(32)), Te[e](C(_))).isValid && Wt(E.subarray(0, 32), wi(E.subarray(32), R, q))
+  };
+}
+const E0 = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+class M0 {
+  constructor() {
+    jt(this, "__internal__map", {});
+  }
+  add(e) {
+    return this.__internal__map[he(e.address).toString()] = e, e;
+  }
+  all() {
+    return Object.values(this.__internal__map);
+  }
+  get(e) {
+    const r = this.__internal__map[he(e).toString()];
+    if (!r)
+      throw new Error(`Unable to retrieve keypair '${oe(e) || te(e) ? xe(C(e)) : e}'`);
+    return r;
+  }
+  remove(e) {
+    delete this.__internal__map[he(e).toString()];
+  }
+}
+const $r = {
+  ecdsa: (t) => we(t),
+  ed25519: (t) => wn(t),
+  ethereum: (t) => we(t),
+  sr25519: (t) => no(t)
+};
+function _0({ publicKey: t }) {
+  return t;
+}
+class D0 {
+  constructor(e = {}) {
+    jt(this, "__internal__pairs");
+    jt(this, "__internal__type");
+    jt(this, "__internal__ss58");
+    jt(this, "decodeAddress", he);
+    /**
+     * @name encodeAddress
+     * @description Encodes the input into an ss58 representation
+     */
+    jt(this, "encodeAddress", (e, r) => this.type === "ethereum" ? uo(e) : da(e, r ?? this.__internal__ss58));
+    if (e.type = e.type || "ed25519", !["ecdsa", "ethereum", "ed25519", "sr25519"].includes(e.type || "undefined"))
+      throw new Error(`Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${e.type || "unknown"}`);
+    this.__internal__pairs = new M0(), this.__internal__ss58 = e.ss58Format, this.__internal__type = e.type;
+  }
+  /**
+   * @description retrieve the pairs (alias for getPairs)
+   */
+  get pairs() {
+    return this.getPairs();
+  }
+  /**
+   * @description retrieve the publicKeys (alias for getPublicKeys)
+   */
+  get publicKeys() {
+    return this.getPublicKeys();
+  }
+  /**
+   * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
+   */
+  get type() {
+    return this.__internal__type;
+  }
+  /**
+   * @name addPair
+   * @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   */
+  addPair(e) {
+    return this.__internal__pairs.add(e);
+  }
+  /**
+   * @name addFromAddress
+   * @summary Stores an account, given an account address, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Allows user to explicitly provide separate inputs including account address or public key, and optionally
+   * the associated account metadata, and the default encoded value as arguments (that may be obtained from the json file
+   * of an account backup), and then generates a keyring pair from them that it passes to
+   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromAddress(e, r = {}, o = null, c = this.type, s, w) {
+    const m = this.decodeAddress(e, s);
+    return this.addPair(ce({ toSS58: this.encodeAddress, type: c }, { publicKey: m, secretKey: new Uint8Array() }, r, o, w));
+  }
+  /**
+   * @name addFromJson
+   * @summary Stores an account, given JSON data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Allows user to provide a json object argument that contains account information (that may be obtained from the json file
+   * of an account backup), and then generates a keyring pair from it that it passes to
+   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromJson(e, r) {
+    return this.addPair(this.createFromJson(e, r));
+  }
+  /**
+   * @name addFromMnemonic
+   * @summary Stores an account, given a mnemonic, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Allows user to provide a mnemonic (seed phrase that is provided when account is originally created)
+   * argument and a metadata argument that contains account information (that may be obtained from the json file
+   * of an account backup), and then generates a keyring pair from it that it passes to
+   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromMnemonic(e, r = {}, o = this.type) {
+    return this.addFromUri(e, r, o);
+  }
+  /**
+   * @name addFromPair
+   * @summary Stores an account created from an explicit publicKey/secreteKey combination
+   */
+  addFromPair(e, r = {}, o = this.type) {
+    return this.addPair(this.createFromPair(e, r, o));
+  }
+  /**
+   * @name addFromSeed
+   * @summary Stores an account, given seed data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Stores in a keyring pair dictionary the public key of the pair as a key and the pair as the associated value.
+   * Allows user to provide the account seed as an argument, and then generates a keyring pair from it that it passes to
+   * `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromSeed(e, r = {}, o = this.type) {
+    return this.addPair(ce({ toSS58: this.encodeAddress, type: o }, $r[o](e), r, null));
+  }
+  /**
+   * @name addFromUri
+   * @summary Creates an account via an suri
+   * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed). The secret can be a hex string, mnemonic phrase or a string (to be padded)
+   */
+  addFromUri(e, r = {}, o = this.type) {
+    return this.addPair(this.createFromUri(e, r, o));
+  }
+  /**
+   * @name createFromJson
+   * @description Creates a pair from a JSON keyfile
+   */
+  createFromJson({ address: e, encoded: r, encoding: { content: o, type: c, version: s }, meta: w }, m) {
+    if (s === "3" && o[0] !== "pkcs8")
+      throw new Error(`Unable to decode non-pkcs8 type, [${o.join(",")}] found}`);
+    const v = s === "0" || !Array.isArray(o) ? this.type : o[1], b = Array.isArray(c) ? c : [c];
+    if (!["ed25519", "sr25519", "ecdsa", "ethereum"].includes(v))
+      throw new Error(`Unknown crypto type ${v}`);
+    const x = te(e) ? ye(e) : this.decodeAddress(e, m), E = te(r) ? ye(r) : Ba(r);
+    return ce({ toSS58: this.encodeAddress, type: v }, { publicKey: x, secretKey: new Uint8Array() }, w, E, b);
+  }
+  /**
+   * @name createFromPair
+   * @summary Creates a pair from an explicit publicKey/secreteKey combination
+   */
+  createFromPair(e, r = {}, o = this.type) {
+    return ce({ toSS58: this.encodeAddress, type: o }, e, r, null);
+  }
+  /**
+   * @name createFromUri
+   * @summary Creates a Keypair from an suri
+   * @description This creates a pair from the suri, but does not add it to the keyring
+   */
+  createFromUri(e, r = {}, o = this.type) {
+    const c = e.startsWith("//") ? `${E0}${e}` : e, { derivePath: s, password: w, path: m, phrase: v } = wf(c);
+    let b;
+    const x = te(v, 256);
+    if (x)
+      b = ye(v);
+    else {
+      const _ = v.split(" ");
+      if ([12, 15, 18, 21, 24].includes(_.length))
+        b = o === "ethereum" ? Za(v, "", !1, 64) : Da(v, w);
+      else {
+        if (v.length > 32)
+          throw new Error("specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes");
+        b = re(v.padEnd(32));
+      }
+    }
+    const E = o === "ethereum" ? x ? $r[o](b) : $a(b, s.substring(1)) : ro($r[o](b), m, o);
+    return ce({ toSS58: this.encodeAddress, type: o }, E, r, null);
+  }
+  /**
+   * @name getPair
+   * @summary Retrieves an account keyring pair from the Keyring Pair Dictionary, given an account address
+   * @description Returns a keyring pair value from the keyring pair dictionary by performing
+   * a key lookup using the provided account address or public key (after decoding it).
+   */
+  getPair(e) {
+    return this.__internal__pairs.get(e);
+  }
+  /**
+   * @name getPairs
+   * @summary Retrieves all account keyring pairs from the Keyring Pair Dictionary
+   * @description Returns an array list of all the keyring pair values that are stored in the keyring pair dictionary.
+   */
+  getPairs() {
+    return this.__internal__pairs.all();
+  }
+  /**
+   * @name getPublicKeys
+   * @summary Retrieves Public Keys of all Keyring Pairs stored in the Keyring Pair Dictionary
+   * @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
+   */
+  getPublicKeys() {
+    return this.__internal__pairs.all().map(_0);
+  }
+  /**
+   * @name removePair
+   * @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
+   */
+  removePair(e) {
+    this.__internal__pairs.remove(e);
+  }
+  /**
+   * @name setSS58Format;
+   * @description Sets the ss58 format for the keyring
+   */
+  setSS58Format(e) {
+    this.__internal__ss58 = e;
+  }
+  /**
+   * @name toJson
+   * @summary Returns a JSON object associated with the input argument that contains metadata assocated with an account
+   * @description Returns a JSON object containing the metadata associated with an account
+   * when valid address or public key and when the account passphrase is provided if the account secret
+   * is not already unlocked and available in memory. Note that in [Polkadot-JS Apps](https://github.com/polkadot-js/apps) the user
+   * may backup their account to a JSON file that contains this information.
+   */
+  toJson(e, r) {
+    return this.__internal__pairs.get(e).toJson(r);
+  }
+}
+export {
+  E0 as DEV_PHRASE,
+  D0 as Keyring,
+  ce as createPair,
+  he as decodeAddress,
+  D0 as default,
+  da as encodeAddress,
+  w0 as packageInfo
+};