diff --git a/.github/workflows/code-quality.yml b/.github/workflows/code-quality.yml
index 949fe00..b28a986 100644
--- a/.github/workflows/code-quality.yml
+++ b/.github/workflows/code-quality.yml
@@ -93,6 +93,18 @@ jobs:
       - name: Light client checkpoint not stale
         run: python3 scripts/light_client_specs.py --relay-rpc https://zagros-rpc.pezkuwichain.io --check-age 60
 
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      # A wallet that finds a root it cannot verify stops refreshing its config, so every published
+      # signed/root.N.json is checked here exactly as installed wallets check it.
+      - name: Root chain verifies as installed wallets check it
+        run: |
+          npm ci --prefix scripts/root --ignore-scripts --no-audit --no-fund
+          node scripts/root/verify_root.mjs docs/root-signing/proposals/*.json
+
   chain-integrity:
     name: Chain Config Integrity
     runs-on: ubuntu-latest
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c2658d7
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+node_modules/
diff --git a/README.md b/README.md
index e62c319..0d7963b 100644
--- a/README.md
+++ b/README.md
@@ -78,6 +78,22 @@ Code Quality fails once the checkpoint is more than 60 days old.
 Code Quality refuses a tree whose files do not match the signed list, and its weekly run fails a month
 before a signature expires.
 
+### Replacing the root keys
+
+A new root is drafted where the wallet never looks, then signed by the holders in their wallets:
+
+```
+python3 scripts/signed_config.py root --version N --expires-days 1825 --root-threshold 2 --root ADDR ADDR ADDR
+```
+
+This writes `docs/root-signing/proposals/root.N.json`, keeping the current targets key. Each holder of the
+current root and of the new one opens the root signing page (`docs/root-signing/`, served by GitHub Pages) in
+the Pezkuwi Wallet DApp browser, compares the fingerprint with the others by phone, signs, and sends the
+signature code to whoever collects them. Once two current and two new holders have signed, the page offers
+`root.N.json`; it goes to `signed/root.N.json` in a pull request. Code Quality checks every published root as
+installed wallets do (wallet 1.3.0 accepts sr25519 only under the `substrate` signing context) and fails
+before a root they would refuse reaches master: such a root stops their config refresh.
+
 ## Contributing
 
 1. Fork this repository
diff --git a/docs/root-signing/index.html b/docs/root-signing/index.html
new file mode 100644
index 0000000..b3faa81
--- /dev/null
+++ b/docs/root-signing/index.html
@@ -0,0 +1,261 @@
+<!doctype html>
+<html lang="ku">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Guhertina mifteya kokê</title>
+<!--
+  Root signing page for the wallet's signed config. Open it in the Pezkuwi Wallet DApp browser.
+  It shows the drafted root (proposals/root.N.json), has the holder's wallet sign <Bytes>payload</Bytes>,
+  checks each signature the way the wallet will, and assembles signed/root.N.json once a threshold of the
+  previous root's keys and of the new root's keys have signed. Wallet 1.3.0 accepts sr25519 under the
+  "substrate" signing context only, so that is what counts toward the thresholds.
+-->
+<script src="vendor/bundle-pezkuwi-util.js"></script>
+<script src="vendor/bundle-pezkuwi-util-crypto.js"></script>
+<script src="vendor/bundle-polkadot-util.js"></script>
+<script src="vendor/bundle-polkadot-util-crypto.js"></script>
+<style>
+  :root { --bg: #08090E; --panel: rgba(153,158,199,0.10); --line: rgba(153,158,199,0.16); --text: rgba(255,255,255,0.88);
+          --muted: rgba(255,255,255,0.60); --accent: #009639; --ok: #2FC864; --warn: #EBC50A; --bad: #E53450; }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--bg); color: var(--text); font: 15px/1.5 system-ui, sans-serif; }
+  main { max-width: 560px; margin: 0 auto; padding: 20px 16px 40px; display: flex; flex-direction: column; gap: 14px; }
+  h1 { margin: 0; font-size: 22px; }
+  p { margin: 0; color: var(--muted); }
+  .panel { background: var(--panel); border-radius: 12px; }
+  .row { display: flex; justify-content: space-between; gap: 12px; padding: 12px; border-bottom: 1px solid var(--line); }
+  .row:last-child { border-bottom: 0; }
+  .row span:first-child { color: var(--muted); }
+  .mono { font-family: ui-monospace, monospace; word-break: break-all; }
+  .fp { font-size: 17px; font-weight: 700; letter-spacing: 1px; }
+  button { min-height: 48px; border-radius: 12px; border: 0; background: var(--accent); color: #fff; font: inherit; font-weight: 600; cursor: pointer; }
+  button.secondary { background: rgba(153,158,199,0.16); color: var(--text); }
+  button:disabled { opacity: 0.45; cursor: default; }
+  textarea { width: 100%; min-height: 80px; border-radius: 10px; border: 1px solid var(--line); background: var(--panel); color: var(--text); padding: 10px; font: 13px ui-monospace, monospace; }
+  .ok { color: var(--ok); } .warn { color: var(--warn); } .bad { color: var(--bad); }
+  .note { padding: 12px; border-radius: 12px; font-size: 14px; }
+  .note.warn { background: rgba(237,206,54,0.14); } .note.bad { background: rgba(229,52,80,0.14); } .note.ok { background: rgba(47,200,100,0.12); }
+  label { display: flex; flex-direction: column; gap: 6px; color: var(--muted); font-size: 13px; }
+  [hidden] { display: none !important; }
+</style>
+</head>
+<body>
+<main>
+  <h1>Guhertina mifteya kokê</h1>
+  <p id="summary">Tê barkirin…</p>
+  <div id="error" class="note bad" hidden></div>
+
+  <div class="panel" id="facts" hidden>
+    <div class="row"><span>Guherto</span><span id="version"></span></div>
+    <div class="row"><span>Sînor</span><span id="threshold"></span></div>
+    <div class="row"><span>Dema derbasbûnê</span><span id="expires"></span></div>
+  </div>
+
+  <div id="keysBlock" hidden>
+    <p>Mifteyên kokê yên nû (sr25519, hesabên cîzdanê)</p>
+    <div class="panel" id="newKeys"></div>
+  </div>
+
+  <div class="panel row" id="fpBlock" hidden><span>Şopa pêşniyarê</span><span class="mono fp" id="fingerprint"></span></div>
+  <p id="fpHint" hidden>Berî îmzekirinê vê şopê bi telefonê bi xwediyên din re bide ber hev.</p>
+
+  <button id="signButton" hidden>Bi cîzdanê îmze bike</button>
+  <div id="signResult" class="note" hidden></div>
+  <button id="shareButton" class="secondary" hidden>Koda îmzeya min kopî bike</button>
+
+  <div id="collect" hidden>
+    <p id="tally"></p>
+    <div class="panel" id="holders"></div>
+  </div>
+  <label id="pasteBlock" hidden>Koda îmzeyê ya xwediyekî din zêde bike
+    <textarea id="paste" placeholder="Kodê li vir bixe"></textarea>
+  </label>
+  <button id="addButton" class="secondary" hidden>Kodê zêde bike</button>
+  <button id="downloadButton" hidden disabled>root.json daxîne</button>
+</main>
+<script>
+(async () => {
+  const pz = window.pezkuwiUtilCrypto, pzu = window.pezkuwiUtil, pk = window.polkadotUtilCrypto;
+  const RAW = 'https://raw.githubusercontent.com/pezkuwichain/pezkuwi-wallet-utils/master/signed/';
+  const $ = (id) => document.getElementById(id);
+  const enc = new TextEncoder();
+  const show = (id, on = true) => { $(id).hidden = !on; };
+  const fail = (message) => { $('error').textContent = message; show('error'); $('summary').textContent = ''; };
+
+  const b64 = (u8) => btoa(String.fromCharCode(...u8));
+  const unb64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
+  const hex = (u8) => Array.from(u8, (b) => b.toString(16).padStart(2, '0')).join('');
+  const sha256 = async (u8) => new Uint8Array(await crypto.subtle.digest('SHA-256', u8));
+  const wrap = (payload) => pzu.u8aConcat(enc.encode('<Bytes>'), payload, enc.encode('</Bytes>'));
+
+  async function readEnvelope(text) {
+    const envelope = JSON.parse(text);
+    const payload = unb64(envelope.signed);
+    return { payload, root: JSON.parse(new TextDecoder().decode(payload)), signatures: envelope.signatures || [] };
+  }
+
+  try {
+    await pz.cryptoWaitReady();
+    await pk.cryptoWaitReady();
+
+    // The newest published root: root.json, then root.N.json while they exist.
+    let previous = await readEnvelope(await (await fetch(RAW + 'root.json', { cache: 'no-store' })).text());
+    for (;;) {
+      const next = await fetch(RAW + `root.${previous.root.version + 1}.json`, { cache: 'no-store' });
+      if (!next.ok) break;
+      previous = await readEnvelope(await next.text());
+    }
+    const version = previous.root.version + 1;
+    const response = await fetch(`proposals/root.${version}.json`, { cache: 'no-store' });
+    if (!response.ok) { $('summary').textContent = `Ji bo guhertoya ${version} pêşniyar tune.`; return; }
+    const proposalText = await response.text();
+    const proposal = await readEnvelope(proposalText);
+    if (proposal.root.type !== 'root' || proposal.root.version !== version) throw new Error('Pêşniyar ne koka paşîn e.');
+
+    const message = wrap(proposal.payload);
+    const fingerprint = hex(await sha256(proposal.payload)).slice(0, 12).toUpperCase().match(/.{4}/g).join(' · ');
+
+    // keyId -> {address, roles}
+    const holders = new Map();
+    const addHolder = (root, role) => {
+      for (const keyId of root.root.keyids) {
+        const key = root.keys[keyId];
+        if (key.scheme !== 'sr25519') continue;
+        const entry = holders.get(keyId) || { public: unb64(key.public), roles: new Set() };
+        entry.roles.add(role);
+        holders.set(keyId, entry);
+      }
+    };
+    addHolder(previous.root, 'previous');
+    addHolder(proposal.root, 'next');
+    for (const entry of holders.values()) entry.address = pz.encodeAddress(entry.public, 42);
+
+    const signatures = new Map();  // keyId -> {sig, context}
+    function classify(keyId, sig) {
+      const entry = holders.get(keyId);
+      if (!entry) return null;
+      if (pk.sr25519Verify(message, sig, entry.public)) return 'substrate';
+      if (pz.sr25519Verify(message, sig, entry.public)) return 'bizinikiwi';
+      return null;
+    }
+    for (const { keyid, sig } of proposal.signatures) {
+      const bytes = unb64(sig);
+      const context = classify(keyid, bytes);
+      if (context) signatures.set(keyid, { sig: bytes, context });
+    }
+
+    $('summary').textContent = `Pêşniyar: koka config-a îmzekirî ya cîzdanê. Ji ${proposal.root.root.keyids.length} xwediyên nû ${proposal.root.root.threshold} îmze, ji yên heyî ${previous.root.root.threshold} îmze pêwîst in.`;
+    $('version').textContent = `${previous.root.version} → ${version}`;
+    $('threshold').textContent = `${proposal.root.root.threshold} ji ${proposal.root.root.keyids.length}`;
+    $('expires').textContent = new Date(proposal.root.expires * 1000).toLocaleDateString('de-DE');
+    for (const keyId of proposal.root.root.keyids) {
+      const row = document.createElement('div');
+      row.className = 'row';
+      row.innerHTML = '<span></span><span class="mono"></span>';
+      row.children[0].textContent = holders.get(keyId).address.slice(0, 6) + '…';
+      row.children[1].textContent = holders.get(keyId).address;
+      $('newKeys').appendChild(row);
+    }
+    $('fingerprint').textContent = fingerprint;
+    ['facts', 'keysBlock', 'fpBlock', 'fpHint', 'collect', 'pasteBlock', 'addButton', 'downloadButton'].forEach((id) => show(id));
+
+    function render() {
+      $('holders').replaceChildren();
+      const counts = { previous: 0, next: 0 };
+      for (const [keyId, entry] of holders) {
+        const signed = signatures.get(keyId);
+        if (signed && signed.context === 'substrate') entry.roles.forEach((role) => counts[role]++);
+        const row = document.createElement('div');
+        row.className = 'row';
+        row.innerHTML = '<span class="mono"></span><span></span>';
+        const roles = [...entry.roles].map((r) => (r === 'previous' ? 'heyî' : 'nû')).join(' + ');
+        row.children[0].textContent = `${entry.address.slice(0, 6)}…${entry.address.slice(-4)} (${roles})`;
+        row.children[1].textContent = !signed ? 'Li bendê' : signed.context === 'substrate' ? 'Îmzekirî' : 'Çewt: bizinikiwi';
+        row.children[1].className = !signed ? '' : signed.context === 'substrate' ? 'ok' : 'bad';
+        $('holders').appendChild(row);
+      }
+      const need = { previous: previous.root.root.threshold, next: proposal.root.root.threshold };
+      $('tally').textContent = `Îmze: heyî ${counts.previous} ji ${need.previous} · nû ${counts.next} ji ${need.next}`;
+      $('downloadButton').disabled = !(counts.previous >= need.previous && counts.next >= need.next);
+    }
+    render();
+
+    $('downloadButton').onclick = () => {
+      const valid = [...signatures].filter(([, s]) => s.context === 'substrate').map(([keyid, s]) => ({ keyid, sig: b64(s.sig) }));
+      const envelope = JSON.parse(proposalText);
+      envelope.signatures = valid;
+      const blob = new Blob([JSON.stringify(envelope, null, 1) + '\n'], { type: 'application/json' });
+      const a = document.createElement('a');
+      a.href = URL.createObjectURL(blob);
+      a.download = `root.${version}.json`;
+      a.click();
+    };
+
+    $('addButton').onclick = () => {
+      const text = $('paste').value.trim();
+      try {
+        const { keyid, sig } = JSON.parse(atob(text));
+        const bytes = unb64(sig);
+        const context = classify(keyid, bytes);
+        if (!context) throw new Error('bad');
+        signatures.set(keyid, { sig: bytes, context });
+        $('paste').value = '';
+        render();
+      } catch (e) {
+        alert('Ev kod ji bo vê pêşniyarê ne derbasdar e.');
+      }
+    };
+
+    // The wallet's injected provider; the signing page asks for accounts only to find the holder's key.
+    const injected = window.injectedWeb3 && (injectedWeb3['pezkuwi-wallet'] || injectedWeb3['pezkuwi-js'] || injectedWeb3['polkadot-js']);
+    if (!injected) {
+      $('signResult').textContent = 'Ji bo îmzekirinê vê rûpelê di geroka DApp ya Pezkuwi Cîzdan de veke.';
+      $('signResult').className = 'note warn';
+      show('signResult');
+      return;
+    }
+    show('signButton');
+    $('signButton').onclick = async () => {
+      try {
+        const extension = await injected.enable('Pezkuwi root signing');
+        const accounts = await extension.accounts.get();
+        const mine = accounts.map((a) => ({ address: a.address, keyId: null, public: pz.decodeAddress(a.address) }));
+        for (const account of mine) account.keyId = hex(await sha256(account.public));
+        const holder = mine.find((a) => holders.has(a.keyId));
+        if (!holder) throw new Error('Di vê cîzdanê de hesabekî xwediyê kokê tune.');
+
+        const { signature } = await extension.signer.signRaw({ address: holder.address, data: pzu.u8aToHex(message), type: 'bytes' });
+        let sig = pzu.hexToU8a(signature);
+        if (sig.length === 65 && sig[0] === 1) sig = sig.slice(1);  // MultiSignature: 0x01 = sr25519
+        const context = classify(holder.keyId, sig);
+        signatures.set(holder.keyId, { sig, context });
+        render();
+
+        const box = $('signResult');
+        if (context === 'substrate') {
+          box.textContent = 'Îmze derbasdar e. Kodê kopî bike û ji xwediyê ku pelê berhev dike re bişîne.';
+          box.className = 'note ok';
+          const code = btoa(JSON.stringify({ keyid: holder.keyId, sig: b64(sig) }));
+          $('shareButton').onclick = () => navigator.clipboard.writeText(code).then(() => alert('Hate kopîkirin'), () => prompt('Kod', code));
+          show('shareButton');
+        } else {
+          box.textContent = context === 'bizinikiwi'
+            ? 'Cîzdan bi çarçoveya "bizinikiwi" îmze kir; cîzdanên 1.3.0 vê qebûl nakin. Ji pêşdebiran re bêje.'
+            : 'Îmze nehat piştrastkirin.';
+          box.className = 'note bad';
+        }
+        show('signResult');
+      } catch (e) {
+        $('signResult').textContent = e.message || String(e);
+        $('signResult').className = 'note bad';
+        show('signResult');
+      }
+    };
+  } catch (e) {
+    fail(e.message || String(e));
+  }
+})();
+</script>
+</body>
+</html>
diff --git a/docs/root-signing/proposals/root.2.json b/docs/root-signing/proposals/root.2.json
new file mode 100644
index 0000000..82a5ad3
--- /dev/null
+++ b/docs/root-signing/proposals/root.2.json
@@ -0,0 +1,4 @@
+{
+ "signed": "eyJleHBpcmVzIjoxOTUxNTAxMDIwLCJrZXlzIjp7IjYwNjZlNmE4NzI5YzM0MDk4OWU3YzE1MGVmYmQ2M2IxZWZiOWZmMWNjYWExZTFmMzhmYTAxNWMyZjFmOWFiNWEiOnsicHVibGljIjoiWGFPSGYzT1NTWUxxNmxabUVuSTNDRlk5cmR3UGU5eWNsc0R4U1A2NEdXWT0iLCJzY2hlbWUiOiJlZDI1NTE5In0sIjdhMzU1Y2Q1MWNjMDQxNTc5MDM1NzJhNjRkY2ZiYmIyY2Q2NTUzNTA4ODZkNzllMGM5ZDI1Yzc5MWI3MDQ2ZWEiOnsicHVibGljIjoiakhGZ3p2YThEUkJKSWRYa1dXdGxHZ3hBazVLOW1KeXhCYWIvakhPQlMyaz0iLCJzY2hlbWUiOiJzcjI1NTE5In0sIjdlZmQ2MDg4Y2FlOWYzZDMzMGFmZjAwOGM1N2RkNzA5NWE2MjczMjkxMjRhZTYwZTg2Yzg3NmZhMWE1ZTkwY2MiOnsicHVibGljIjoiM0lmZThTRnNVWkRhdFIrb3BsekdSZjdYSU8rQU93RGVmTVJOMFVLcjBRZz0iLCJzY2hlbWUiOiJzcjI1NTE5In0sImZmZjc1NGJiNjcxNmYwNDU1Mjk2NzJkNmRkNWQxYzhlNmUxNzBkODNmZThjZDA3NjUyYWE4N2E0MjdjMGFhZjgiOnsicHVibGljIjoicEsyMi9nUVVtRmZsekNJTXU3czdHNEpiNkhvNFNTR2ZLSHNLUk5hVkkwYz0iLCJzY2hlbWUiOiJzcjI1NTE5In19LCJyb290Ijp7ImtleWlkcyI6WyI3YTM1NWNkNTFjYzA0MTU3OTAzNTcyYTY0ZGNmYmJiMmNkNjU1MzUwODg2ZDc5ZTBjOWQyNWM3OTFiNzA0NmVhIiwiN2VmZDYwODhjYWU5ZjNkMzMwYWZmMDA4YzU3ZGQ3MDk1YTYyNzMyOTEyNGFlNjBlODZjODc2ZmExYTVlOTBjYyIsImZmZjc1NGJiNjcxNmYwNDU1Mjk2NzJkNmRkNWQxYzhlNmUxNzBkODNmZThjZDA3NjUyYWE4N2E0MjdjMGFhZjgiXSwidGhyZXNob2xkIjoyfSwidGFyZ2V0cyI6eyJrZXlpZHMiOlsiNjA2NmU2YTg3MjljMzQwOTg5ZTdjMTUwZWZiZDYzYjFlZmI5ZmYxY2NhYTFlMWYzOGZhMDE1YzJmMWY5YWI1YSJdLCJ0aHJlc2hvbGQiOjF9LCJ0eXBlIjoicm9vdCIsInZlcnNpb24iOjJ9",
+ "signatures": []
+}
diff --git a/docs/root-signing/vendor/bundle-pezkuwi-util-crypto.js b/docs/root-signing/vendor/bundle-pezkuwi-util-crypto.js
new file mode 100644
index 0000000..e2af032
--- /dev/null
+++ b/docs/root-signing/vendor/bundle-pezkuwi-util-crypto.js
@@ -0,0 +1,8325 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@pezkuwi/util')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@pezkuwi/util'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.pezkuwiUtilCrypto = {}, global.pezkuwiUtil));
+})(this, (function (exports, util) { 'use strict';
+
+    const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;
+
+    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+    const packageInfo$2 = { name: '@pezkuwi/x-global', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.26' };
+
+    function evaluateThis(fn) {
+        return fn('return this');
+    }
+    const xglobal =  (typeof globalThis !== 'undefined'
+        ? globalThis
+        : typeof global !== 'undefined'
+            ? global
+            : typeof self !== 'undefined'
+                ? self
+                : typeof window !== 'undefined'
+                    ? window
+                    : evaluateThis(Function));
+    function extractGlobal(name, fallback) {
+        return typeof xglobal[name] === 'undefined'
+            ? fallback
+            : xglobal[name];
+    }
+    function exposeGlobal(name, fallback) {
+        if (typeof xglobal[name] === 'undefined') {
+            xglobal[name] = fallback;
+        }
+    }
+
+    const build = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exposeGlobal: exposeGlobal,
+        extractGlobal: extractGlobal,
+        packageInfo: packageInfo$2,
+        xglobal: xglobal
+    });
+
+    function invalidFallback() {
+        return Number.NaN;
+    }
+    const BigInt$1 =  extractGlobal('BigInt', invalidFallback);
+
+    exposeGlobal('BigInt', BigInt$1);
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    function getAugmentedNamespace(n) {
+      if (n.__esModule) return n;
+      var f = n.default;
+    	if (typeof f == "function") {
+    		var a = function a () {
+    			if (this instanceof a) {
+            return Reflect.construct(f, arguments, this.constructor);
+    			}
+    			return f.apply(this, arguments);
+    		};
+    		a.prototype = f.prototype;
+      } else a = {};
+      Object.defineProperty(a, '__esModule', {value: true});
+    	Object.keys(n).forEach(function (k) {
+    		var d = Object.getOwnPropertyDescriptor(n, k);
+    		Object.defineProperty(a, k, d.get ? d : {
+    			enumerable: true,
+    			get: function () {
+    				return n[k];
+    			}
+    		});
+    	});
+    	return a;
+    }
+
+    var browser = {};
+
+    const require$$0 = /*@__PURE__*/getAugmentedNamespace(build);
+
+    var packageInfo$1 = {};
+
+    Object.defineProperty(packageInfo$1, "__esModule", { value: true });
+    packageInfo$1.packageInfo = void 0;
+    packageInfo$1.packageInfo = { name: '@pezkuwi/x-randomvalues', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.26' };
+
+    (function (exports$1) {
+    	Object.defineProperty(exports$1, "__esModule", { value: true });
+    	exports$1.crypto = exports$1.packageInfo = void 0;
+    	exports$1.getRandomValues = getRandomValues;
+    	const x_global_1 = require$$0;
+    	var packageInfo_js_1 = packageInfo$1;
+    	Object.defineProperty(exports$1, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+    	exports$1.crypto = x_global_1.xglobal.crypto;
+    	function getRandomValues(arr) {
+    	    return exports$1.crypto.getRandomValues(arr);
+    	}
+    } (browser));
+    getDefaultExportFromCjs(browser);
+
+    const DEFAULT_CRYPTO = { getRandomValues: browser.getRandomValues };
+    const DEFAULT_SELF = { crypto: DEFAULT_CRYPTO };
+    class Wbg {
+        #bridge;
+        constructor(bridge) {
+            this.#bridge = bridge;
+        }
+        abort = () => {
+            throw new Error('abort');
+        };
+        __wbg___wbindgen_is_undefined_9e4d92534c42d778 = (idx) => {
+            return this.#bridge.getObject(idx) === undefined;
+        };
+        __wbindgen_is_undefined = (idx) => {
+            return this.#bridge.getObject(idx) === undefined;
+        };
+        __wbg___wbindgen_throw_be289d5034ed271b = (ptr, len) => {
+            throw new Error(this.#bridge.getString(ptr, len));
+        };
+        __wbindgen_throw = (ptr, len) => {
+            throw new Error(this.#bridge.getString(ptr, len));
+        };
+        __wbg_self_25aabeb5a7b41685 = () => {
+            return this.#bridge.addObject(DEFAULT_SELF);
+        };
+        __wbg_self_7eede1f4488bf346 = () => {
+            return this.#bridge.addObject(DEFAULT_SELF);
+        };
+        __wbg_self_1b7a39e3a92c949c = () => {
+            return this.#bridge.addObject(DEFAULT_SELF);
+        };
+        __wbg_require_0d6aeaec3c042c88 = (ptr, len, _extra) => {
+            throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+        };
+        __wbg_require_900d5c3984fe7703 = (ptr, len, _extra) => {
+            throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+        };
+        __wbg_require_604837428532a733 = (ptr, len) => {
+            throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+        };
+        __wbg_crypto_038798f665f985e2 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO);
+        };
+        __wbg_crypto_c909fb428dcbddb6 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO);
+        };
+        __wbg_crypto_968f1772287e2df0 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO);
+        };
+        __wbg_msCrypto_ff35fce085fab2a3 = (_idx) => {
+            return this.#bridge.addObject(undefined);
+        };
+        __wbg_msCrypto_511eefefbfc70ae4 = (_idx) => {
+            return this.#bridge.addObject(undefined);
+        };
+        __wbg_getRandomValues_7dfe5bd1b67c9ca1 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+        };
+        __wbg_getRandomValues_307049345d0bd88c = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+        };
+        __wbg_getRandomValues_a3d34b4fee3c2869 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+        };
+        __wbg_getRandomValues_371e7ade8bd92088 = (_arg0, ptr, len) => {
+            DEFAULT_CRYPTO.getRandomValues(this.#bridge.getU8a(ptr, len));
+        };
+        __wbg_getRandomValues_cd175915511f705e = (cryptoIdx, arrIdx) => {
+            this.#bridge.getObject(cryptoIdx).getRandomValues(this.#bridge.getObject(arrIdx));
+        };
+        __wbg_getRandomValues_f5e14ab7ac8e995d = (_arg0, ptr, len) => {
+            DEFAULT_CRYPTO.getRandomValues(this.#bridge.getU8a(ptr, len));
+        };
+        __wbg_randomFillSync_994ac6d9ade7a695 = (_idx, _ptr, _len) => {
+            throw new Error('randomFillSync is not available');
+        };
+        __wbg_randomFillSync_85b3f4c52c56c313 = (_idx, _ptr, _len) => {
+            throw new Error('randomFillSync is not available');
+        };
+        __wbg_randomFillSync_d5bd2d655fdf256a = (_idx, _ptr, _len) => {
+            throw new Error('randomFillSync is not available');
+        };
+        __wbindgen_object_drop_ref = (idx) => {
+            this.#bridge.takeObject(idx);
+        };
+        __wbg_static_accessor_MODULE_ef3aa2eb251158a5 = () => {
+            return this.#bridge.addObject(undefined);
+        };
+        __wbg_new_with_length_a2c39cbe88fd8ff1 = (len) => {
+            return this.#bridge.addObject(new Uint8Array(len));
+        };
+        __wbg_newwithlength_728575f3bba9959b = (len) => {
+            return this.#bridge.addObject(new Uint8Array(len));
+        };
+        __wbg_subarray_a96e1fef17ed23cb = (idx, start, end) => {
+            const arr = this.#bridge.getObject(idx);
+            return this.#bridge.addObject(arr.subarray(start, end));
+        };
+        __wbg_subarray_7f7a652672800851 = (idx, start, end) => {
+            const arr = this.#bridge.getObject(idx);
+            return this.#bridge.addObject(arr.subarray(start, end));
+        };
+        __wbg_length_32ed9a279acd054c = (idx) => {
+            const arr = this.#bridge.getObject(idx);
+            return arr.length;
+        };
+        __wbg_length_f0764416ba5bb237 = (idx) => {
+            const arr = this.#bridge.getObject(idx);
+            return arr.length;
+        };
+        __wbg_prototypesetcall_bdcdcc5842e4d77d = (destIdx, srcIdx, offset) => {
+            const dest = this.#bridge.getObject(destIdx);
+            const src = this.#bridge.getObject(srcIdx);
+            dest.set(src, offset);
+        };
+        __wbindgen_init_externref_table = () => {
+        };
+        __wbindgen_memory = () => {
+            return this.#bridge.addObject(this.#bridge.wasm?.memory);
+        };
+        __wbg_buffer_5d1b598a01b41a42 = (memIdx) => {
+            const mem = this.#bridge.getObject(memIdx);
+            return this.#bridge.addObject(mem.buffer);
+        };
+        __wbg_new_ace717933ad7117f = (bufferIdx) => {
+            const buffer = this.#bridge.getObject(bufferIdx);
+            return this.#bridge.addObject(new Uint8Array(buffer));
+        };
+        __wbg_set_74906aa30864df5a = (destIdx, srcIdx, offset) => {
+            const dest = this.#bridge.getObject(destIdx);
+            const src = this.#bridge.getObject(srcIdx);
+            dest.set(src, offset);
+        };
+    }
+
+    class Bridge {
+        #createWasm;
+        #heap;
+        #wbg;
+        #cachegetInt32;
+        #cachegetUint8;
+        #heapNext;
+        #wasm;
+        #wasmError;
+        #wasmPromise;
+        #type;
+        constructor(createWasm) {
+            this.#createWasm = createWasm;
+            this.#cachegetInt32 = null;
+            this.#cachegetUint8 = null;
+            this.#heap = new Array(32)
+                .fill(undefined)
+                .concat(undefined, null, true, false);
+            this.#heapNext = this.#heap.length;
+            this.#type = 'none';
+            this.#wasm = null;
+            this.#wasmError = null;
+            this.#wasmPromise = null;
+            this.#wbg = { ...new Wbg(this) };
+        }
+        get error() {
+            return this.#wasmError;
+        }
+        get type() {
+            return this.#type;
+        }
+        get wasm() {
+            return this.#wasm;
+        }
+        async init(createWasm) {
+            if (!this.#wasmPromise || createWasm) {
+                this.#wasmPromise = (createWasm || this.#createWasm)(this.#wbg);
+            }
+            const { error, type, wasm } = await this.#wasmPromise;
+            this.#type = type;
+            this.#wasm = wasm;
+            this.#wasmError = error;
+            return this.#wasm;
+        }
+        getObject(idx) {
+            return this.#heap[idx];
+        }
+        dropObject(idx) {
+            if (idx < 36) {
+                return;
+            }
+            this.#heap[idx] = this.#heapNext;
+            this.#heapNext = idx;
+        }
+        takeObject(idx) {
+            const ret = this.getObject(idx);
+            this.dropObject(idx);
+            return ret;
+        }
+        addObject(obj) {
+            if (this.#heapNext === this.#heap.length) {
+                this.#heap.push(this.#heap.length + 1);
+            }
+            const idx = this.#heapNext;
+            this.#heapNext = this.#heap[idx];
+            this.#heap[idx] = obj;
+            return idx;
+        }
+        getInt32() {
+            if (this.#cachegetInt32 === null || this.#cachegetInt32.buffer !== this.#wasm.memory.buffer) {
+                this.#cachegetInt32 = new Int32Array(this.#wasm.memory.buffer);
+            }
+            return this.#cachegetInt32;
+        }
+        getUint8() {
+            if (this.#cachegetUint8 === null || this.#cachegetUint8.buffer !== this.#wasm.memory.buffer) {
+                this.#cachegetUint8 = new Uint8Array(this.#wasm.memory.buffer);
+            }
+            return this.#cachegetUint8;
+        }
+        getU8a(ptr, len) {
+            return this.getUint8().subarray(ptr / 1, ptr / 1 + len);
+        }
+        getString(ptr, len) {
+            return util.u8aToString(this.getU8a(ptr, len));
+        }
+        allocU8a(arg) {
+            const ptr = this.#wasm.__wbindgen_malloc(arg.length * 1, 1);
+            this.getUint8().set(arg, ptr / 1);
+            return [ptr, arg.length];
+        }
+        allocString(arg) {
+            return this.allocU8a(util.stringToU8a(arg));
+        }
+        resultU8a() {
+            const r0 = this.getInt32()[8 / 4 + 0];
+            const r1 = this.getInt32()[8 / 4 + 1];
+            const ret = this.getU8a(r0, r1).slice();
+            this.#wasm.__wbindgen_free(r0, r1 * 1, 1);
+            return ret;
+        }
+        resultString() {
+            return util.u8aToString(this.resultU8a());
+        }
+    }
+
+    function createWasmFn(root, wasmBytes, asmFn) {
+        return async (wbg) => {
+            const result = {
+                error: null,
+                type: 'none',
+                wasm: null
+            };
+            try {
+                if (!wasmBytes?.length) {
+                    throw new Error('No WebAssembly provided for initialization');
+                }
+                else if (typeof WebAssembly !== 'object' || typeof WebAssembly.instantiate !== 'function') {
+                    throw new Error('WebAssembly is not available in your environment');
+                }
+                const source = await WebAssembly.instantiate(wasmBytes, { wbg });
+                result.wasm = source.instance.exports;
+                result.type = 'wasm';
+            }
+            catch (error) {
+                {
+                    result.error = `FATAL: Unable to initialize @pezkuwi/wasm-${root}:: ${error.message}`;
+                    console.error(result.error);
+                }
+            }
+            return result;
+        };
+    }
+
+    const CHR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const map = new Array(256);
+    for (let i = 0, count = CHR.length; i < count; i++) {
+        map[CHR.charCodeAt(i)] = i;
+    }
+    function base64Decode$1(data, out) {
+        let byte = 0;
+        let bits = 0;
+        let pos = -1;
+        for (let i = 0, last = out.length - 1; pos !== last; i++) {
+            byte = (byte << 6) | map[data.charCodeAt(i)];
+            if ((bits += 6) >= 8) {
+                out[++pos] = (byte >>> (bits -= 8)) & 0xff;
+            }
+        }
+        return out;
+    }
+
+    const u8 = Uint8Array, u16 = Uint16Array, u32$1 = Uint32Array;
+    const clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    const fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,  0, 0,  0]);
+    const fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,  0, 0]);
+    const freb = (eb, start) => {
+        const b = new u16(31);
+        for (let i = 0; i < 31; ++i) {
+            b[i] = start += 1 << eb[i - 1];
+        }
+        const r = new u32$1(b[30]);
+        for (let i = 1; i < 30; ++i) {
+            for (let j = b[i]; j < b[i + 1]; ++j) {
+                r[j] = ((j - b[i]) << 5) | i;
+            }
+        }
+        return [b, r];
+    };
+    const [fl, revfl] = freb(fleb, 2);
+    fl[28] = 258, revfl[258] = 28;
+    const [fd] = freb(fdeb, 0);
+    const rev = new u16(32768);
+    for (let i = 0; i < 32768; ++i) {
+        let x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
+        x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
+        x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
+        rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+    }
+    const hMap = ((cd, mb, r) => {
+        const s = cd.length;
+        let i = 0;
+        const l = new u16(mb);
+        for (; i < s; ++i) {
+            if (cd[i])
+                ++l[cd[i] - 1];
+        }
+        const le = new u16(mb);
+        for (i = 1; i < mb; ++i) {
+            le[i] = (le[i - 1] + l[i - 1]) << 1;
+        }
+        let co;
+        {
+            co = new u16(1 << mb);
+            const rvb = 15 - mb;
+            for (i = 0; i < s; ++i) {
+                if (cd[i]) {
+                    const sv = (i << 4) | cd[i];
+                    const r = mb - cd[i];
+                    let v = le[cd[i] - 1]++ << r;
+                    for (const m = v | ((1 << r) - 1); v <= m; ++v) {
+                        co[rev[v] >> rvb] = sv;
+                    }
+                }
+            }
+        }
+        return co;
+    });
+    const flt = new u8(288);
+    for (let i = 0; i < 144; ++i)
+        flt[i] = 8;
+    for (let i = 144; i < 256; ++i)
+        flt[i] = 9;
+    for (let i = 256; i < 280; ++i)
+        flt[i] = 7;
+    for (let i = 280; i < 288; ++i)
+        flt[i] = 8;
+    const fdt = new u8(32);
+    for (let i = 0; i < 32; ++i)
+        fdt[i] = 5;
+    const flrm = hMap(flt, 9);
+    const fdrm = hMap(fdt, 5);
+    const bits = (d, p, m) => {
+        const o = p >>> 3;
+        return ((d[o] | (d[o + 1] << 8)) >>> (p & 7)) & m;
+    };
+    const bits16 = (d, p) => {
+        const o = p >>> 3;
+        return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >>> (p & 7));
+    };
+    const shft = (p) => (p >>> 3) + (p & 7 && 1);
+    const slc = (v, s, e) => {
+        if (e == null || e > v.length)
+            e = v.length;
+        const n = new (v instanceof u16 ? u16 : v instanceof u32$1 ? u32$1 : u8)(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+    };
+    const max = (a) => {
+        let m = a[0];
+        for (let i = 1, count = a.length; i < count; ++i) {
+            if (a[i] > m)
+                m = a[i];
+        }
+        return m;
+    };
+    const inflt = (dat, buf, st) => {
+        const noSt = !st || st.i;
+        if (!st)
+            st = {};
+        const sl = dat.length;
+        const noBuf = !buf || !noSt;
+        if (!buf)
+            buf = new u8(sl * 3);
+        const cbuf = (l) => {
+            let bl = buf.length;
+            if (l > bl) {
+                const nbuf = new u8(Math.max(bl << 1, l));
+                nbuf.set(buf);
+                buf = nbuf;
+            }
+        };
+        let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+        if (final && !lm)
+            return buf;
+        const tbts = sl << 3;
+        do {
+            if (!lm) {
+                st.f = final = bits(dat, pos, 1);
+                const type = bits(dat, pos + 1, 3);
+                pos += 3;
+                if (!type) {
+                    const s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                    if (t > sl) {
+                        if (noSt)
+                            throw 'unexpected EOF';
+                        break;
+                    }
+                    if (noBuf)
+                        cbuf(bt + l);
+                    buf.set(dat.subarray(s, t), bt);
+                    st.b = bt += l, st.p = pos = t << 3;
+                    continue;
+                }
+                else if (type == 1)
+                    lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+                else if (type == 2) {
+                    const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                    const tl = hLit + bits(dat, pos + 5, 31) + 1;
+                    pos += 14;
+                    const ldt = new u8(tl);
+                    const clt = new u8(19);
+                    for (let i = 0; i < hcLen; ++i) {
+                        clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                    }
+                    pos += hcLen * 3;
+                    const clb = max(clt), clbmsk = (1 << clb) - 1;
+                    if (!noSt && pos + tl * (clb + 7) > tbts)
+                        break;
+                    const clm = hMap(clt, clb);
+                    for (let i = 0; i < tl;) {
+                        const r = clm[bits(dat, pos, clbmsk)];
+                        pos += r & 15;
+                        const s = r >>> 4;
+                        if (s < 16) {
+                            ldt[i++] = s;
+                        }
+                        else {
+                            let c = 0, n = 0;
+                            if (s == 16)
+                                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                            else if (s == 17)
+                                n = 3 + bits(dat, pos, 7), pos += 3;
+                            else if (s == 18)
+                                n = 11 + bits(dat, pos, 127), pos += 7;
+                            while (n--)
+                                ldt[i++] = c;
+                        }
+                    }
+                    const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                    lbt = max(lt);
+                    dbt = max(dt);
+                    lm = hMap(lt, lbt);
+                    dm = hMap(dt, dbt);
+                }
+                else
+                    throw 'invalid block type';
+                if (pos > tbts)
+                    throw 'unexpected EOF';
+            }
+            if (noBuf)
+                cbuf(bt + 131072);
+            const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+            const mxa = lbt + dbt + 18;
+            while (noSt || pos + mxa < tbts) {
+                const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+                pos += c & 15;
+                if (pos > tbts)
+                    throw 'unexpected EOF';
+                if (!c)
+                    throw 'invalid length/literal';
+                if (sym < 256)
+                    buf[bt++] = sym;
+                else if (sym == 256) {
+                    lm = undefined;
+                    break;
+                }
+                else {
+                    let add = sym - 254;
+                    if (sym > 264) {
+                        const i = sym - 257, b = fleb[i];
+                        add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                        pos += b;
+                    }
+                    const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+                    if (!d)
+                        throw 'invalid distance';
+                    pos += d & 15;
+                    let dt = fd[dsym];
+                    if (dsym > 3) {
+                        const b = fdeb[dsym];
+                        dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;
+                    }
+                    if (pos > tbts)
+                        throw 'unexpected EOF';
+                    if (noBuf)
+                        cbuf(bt + 131072);
+                    const end = bt + add;
+                    for (; bt < end; bt += 4) {
+                        buf[bt] = buf[bt - dt];
+                        buf[bt + 1] = buf[bt + 1 - dt];
+                        buf[bt + 2] = buf[bt + 2 - dt];
+                        buf[bt + 3] = buf[bt + 3 - dt];
+                    }
+                    bt = end;
+                }
+            }
+            st.l = lm, st.p = pos, st.b = bt;
+            if (lm)
+                final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+        } while (!final);
+        return bt == buf.length ? buf : slc(buf, 0, bt);
+    };
+    const zlv = (d) => {
+        if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
+            throw 'invalid zlib data';
+        if (d[1] & 32)
+            throw 'invalid zlib data: preset dictionaries not supported';
+    };
+    function unzlibSync(data, out) {
+        return inflt((zlv(data), data.subarray(2, -4)), out);
+    }
+
+    var lenIn = 182731;
+    var lenOut = 356003;
+    var bytes_1 = 'eNqkfQl0VFW29q1bY6oyVBIyJ3CrCBAQNEwJoLbcagd69r3X7/3+a731I0NoDbZioFt7rXQbFejYTqioKPpEWwVtURw7ThgRFQVbHFpRoI0ztgNRtEXl6f99+5xbdW+lMoCyzD217zn77L3PPvvus8+5+xpzFv/aZxiG7zPfiJPNc84xTvafw78o+s6RMi4+AIIo8oaPgIAqhwSGgvwGXANQCqsS7hn4ZTjtUTbP+YNxcvScPzj/qb7+cHKebsE20XSZLSKZGw5aoe0PJOcPikxegoLUQP00ahDGWui8nc1x/b2+/gFX88pgif+sub+qmD37rLmnnj7/Vy2nzz518ezfnD6/ZcGpp7fMN0K8W+26e8bc1pZ5S2bPbztj0ey2lgVGgBUmsMKvZi9eMmfJqfNmz5k3r2Xx4jPaZv/sF8f+50+Pm92yYPKcOZNa5k6aOnHi1Glzphr5bFOj27SctmB2c0vL/JaJC6ZMmTZt7oLJU5pUjTpVY17b7xYtOWP2vOmN0xfMnTJp2vx5c+fPn9ukSBuh6vx68Q9VLXTR0rKgZcHcBfOaG+e0TFG1Rqtav2pZ8u9zTp9/xq//a85pv2lZPHtyY3PjlOmTp0yd3zh3/rRp81TlelX59Jazzjp1ySmntZz+qyWnzG6eNG1q89QFk+fOnTN9+tTpc1XV4apqW8uZvzm1rWX29MbG+VPnTZ4+bcqClubmxsmG30Xi4t/MndPWNud3s5sXNM9pmjqpCSgbG6dNnahq9UPivPkTm6dOnzgVfC1obpzaYhguyWjaFjQ2N02ZMrFp7pypc+dOmtysaCt2DdqvW359RtvvPFKd+5sFC1raZk+dP3Hu1OnT5jROnDtl4pwpk1wDLiLAYLY0T2yePnnynPnNEyc2L/BUWNyyZHbzlOmNTXPmTG6c1jRl/oKpcwwfK4zSkhFejj/1tNP+43enz5s9bercyQumzJs6ad7UpnmTJ05WdeMuSpec0nbGWWDyc/9nfl+RES3B1IyVGj6fLxwJGj4z6DMCvqgRDvhDvjD/RSJhnw/QYTHDCPqNiBEwCkLBPNTFlDZ9RiHaG2bEDJq+qN8wDYBMw2/6AtEyYg2W42+hzxcLojL+yzcDPhPWIOgL0ib4gCVg+lkwiTHoixHmC/kC6DQYjkWA0OeLAAK0vnARCcWPilBeCM3DAd4MR9Aa6NCqMmACXhX2BarNQBD0++JxVAkEDMNE+yjQBIJmwAij2wBYCaFTXH0FwIIe0FfICBph05cXAh+BfJKICkE0DrNinj+MjoCYIJ8fFJrBAOj1+QHxmXk+PyQBnGYhWlAaqBeEaIIhcmUaeeFwcZCYgNgIhkM1AZABjMV5/lAgmAfmfP4o6AuYwcLauuEhUBowIB7TNFHRDInsQB7EHTDDAQgbDGE4wY3f8BcUBNBC/4cmRqjAMEJmyMQwhiHdMESyyPfznwf9PqM0lAdDa3d0dBux8OXhcSGlw6ZR0nL2ktlzT100eTomy+ktbXOWtBj/d1gGCCPQcvoSmKffGe/4Kj3wX596+qnQ2XltLUuMS3zFnnuLYYKMpAv5b+ecdup8Iv9/MQGeNmdhy6S5RnOcv1rmz17QdsavVauHfFIDsMWn/up0o7pA//ptS9upC35nlBXx9ym/njNv9uJT5kya2mT80AOZOnGScYtPGi1smTdvzkJWuccNYI2HfVECFs1dOH/BJOMR9Wux2EbjGCEbjC1yUXW+rywNXfSbubPnnfHrRW2wy8bTvlLPjZazF2GWGrf6hDMBt7XMOwPUG8cLEQIS1n6qelVcvKppUBzs8OXLr7bZc37V1tJinFOtf86HFH7bAk5+t2jOqW2zT5nTNt/4eT83F5+xYIlxVJX3Jmg8DU8VuTdb0djm4rNdhA+QUDhTUdzmCP+wCH8vOeuMs41JQuBv2xaomuWFzk9dtWZk228WLyGz4G7hxNm/bZw9ZfZEyO30JawJraE2rDXrB6w2v2UxlO93xkPm4Tnr4cE65zenQT/a2vCEnDfntNPmzpm3cPaC041PzcYBW8CItvxqzmmeNp+Z8nTRxnPO/Pmiykt4d9EZp4KiNuM9v+dJgMZnzDP2mUUu4AIO2DZ/iQsEZqXiMv8wF7Tl7NOB/Yy2FuM1f94qmAzbF/vZ8/6X/V/79/s/933lf9n3jf9c3x7zb75tvl7/n8xP/R+bj/rP9//Z/Mz/y71mr3mzud28zb/B/5rvLj///dV/r/8e/92APOTv9b3gf8z/pf9f/if8T/nf8Pf4/+Tb5Z91xrW+P/peAXy//2n/sY+ab/lfM//ha/3vLf4d/gP+X200u3xrfM/4XzW3+m/3L/rM/NTM9y2OXro89pn/gx/4Zp1jGZbRYJ6cjFpma5N5smXYVmviOCtqH3NmIuqfaXcbVnRhsskyfxaYaTXh/6h1XKvls5oORPHsUK1PSkbtyiVo0/Gt/0w7sqQNxchv5RdKlb9ta0v6We+/B68XsKvOsgJ24VmL8df/28WtbHfs4O2qWc8avF4l69UPXq+QdBQKHYVCR6vlt4vOwp8CgPx2FKBkkMiOGhxZGevNHLxeOTstl07LdadoOGXwhpNZb9rg9aawgynSwRQlXb90ceLgTY9gvfGD18tnvcbB60VJSlRIiWZ4nZUMsWEo0zCUbog7bNjIeg2D1ytgBwXSQQE7sArRRYBjGJAxDKgxDBESEkhIQcKEhAUSVpAIIRGBRBQkT6j9ZTJGKmIZKmJpKnCHVEwlFVOFiqlCxRGtVkQa/3TwxhPZeKI0niiNG1utcKtVTXC1gKsFXN5qhVqtMoLLBFwm4Cngt9WaTPBkAU8WcLTVmtpq5ROcL+B8ARe0WhNbrSBZDQqrQcVqjJCYQGIKUkRIkUCKFKSYkGKBFCtIKSGlAilVkGGEDBPIMAWpIKRCIBUKUkWiqoSoKiHKT4BfAH4BgPLiVusIgo8Q8BECBuVFrVYjwY0CbhRwdasVa7Xy2E+e9JOn+qkhpEYgNQpSS0itQGoVpI7CAL6g4AsKPoiztNWqY906qVun6g4HYlTNk6p5UrUY2hYhMCLAiABBI9CGCQ4LOCxg0FiLISQ4JOCQgIOtVk0rBIHeqqS3KtXbCEJGCGSEgliEWAKxFCRBSEIgCQVJtkLK6KFCeqiQHtBrohXDAfAwAQ8TMHq1wCnBpQIuFTCUfgTET3CxgIsFDHWugvgJLhJwkYChqBUQP8ExAccEDEUd1moNJ3nDhbzhiryRhIwUyEgFqSekXiD1CjKKkFECGaUgowkZLZDRCjKGkDECGaMgDYQ0CKRBQcaSqLFC1Fghqo6AOgHUCQCUj8KgEFwr4FoBg/J6DArBNQKuETB0YmSrlWQ/SeknqfoZR8g4gYxTkMMIOUwghynIeAoD+IYLvuGCD+Ic3WqNZ93xUne8qjsBiFE1KVWTUnUU1CxBYEKACQGCRqC1CLYEbAkYNB6GISR4hIBHCHh4qzWuFYJAb2Olt7Gqt8MJOVwghytIMyHNAmlWkGmETBPINAWZ3gopo4cG6aFBekCv01oxHACPEfAYAaPXZnBK8GgBjxYwFPVwiJ/gUQIeJWAo6liIn+B6AdcLGIraAPETPFLAIwUMRR3Tak0geROEvAmKvEmETBLIJAWZQcgMgcxQkCMJOVIgRyrIUYQcJZCjFORoQo4WyNEKMpOQmQKZqSC2dbR1pDXJGm+NsxLWCKvCKrWKrKB1hFUOL0o8kdrkCbzEk5V29VlWpV2G1pV2+Czl91QmU7wMS/4A0DOtFB6S9qo31q0MtCZLeCM/Oas1CXOeb1W2WgXWD1qtQivVKrh/sPhM/I8y8UYFb1Tw2pddsPuCcGvyh0QQSR7fiic2GqB6Jarns3q+VM9X1e/uPPBCYGHyWFYPJI9pTRagej6qR1G9gNULpHqBqr5zy7p7fAuTP2J1A7Ql46CuANXzUT3O6nGpHtfVl+581t+a/LF1PLAe0was1jFn0lsYTqpLheoopVHSmiwE18BhlZFXPNvyrcmAoxwH+gLWIfoSQV+i0H/6583PB1vhHkWtwjZg5hXoC4m+UNAXKvQ/hBha4afFrRIgiwNSRmRlgqxMIdv19bmfhBYmp6BjIIuCJUGWT2T5gixfITsWQiLjJVYZkJXkZPwvmy5ZG1yIUYB0QBCRFQBZAZEVCLIChexHinHyDWRlOdncc/ubj5kcowJSlg9p9MPmj4VNuAslfGLG6U+U8SFZ7mK8nOjLBX25Qn/uAxev9LXCxRbGC/pnfHKa8fJ+Gd944VM3mq1wJwdjfEqacSIrz8n4E9/cvQ7j2zgo40MZ388f+upKTIyJg7KpxhdSDFAX/dBN4IVjUu4a8b5SPO+6ZV+FF4KhwRivbk1iShRiZMg4R7yQyAoFWaFC9tpnl94IXSxD70AGxnEFMj+R+QUZlihEdkRrEtYCnKSl2HeKX3T9in3+hclyIAkI47gCWYDIAoIMvjKRNWLJQwMAdEBWmNMAPHbH5TthAKohnCAIOpNXIAsSWVCQwa8ksonCZhzuEF3PmJUPDwg+OkQ5kMH4unf5eUBfCBqBPkBaib4v4zAYYDzkMg8hIgsJspBC9tTDy781KB1hPNg/42XCeBgEEhnVJ0xkYUEWVsi2PXHPGih2waCMlwvjMSALA1kIkBiRxQRZTCHbu+PmvUAWH5RNKAvYhF+ZRy8yTOc4RI+sCOUY0IdRp4joiwR9kUJ/+wUvvoRmxYMyjhkIxkMYniIgi+WU4q6XNr2LSrFBGccMBOOUIpEV5ZTi65e991dMwqJBGccMBAcRlxQjRBYRZBGF7M7dyzdilpQOymZc2IR/G6FLHKafF6IXnIdyREsxj+jzBH2eQn/Fvq6NsOHDBmW8WBjHuFh5QBbJKcWuDfu+w3OWQzIw4zFhnFIksrycUnyw49plQBYblPEiYXxgKV6857stMA9Fg7JZKmyKFOFThunGhrjeGViKD+5+80U8vDhIAzM+TM/ogaT4wlO3NWGpOSjfGBE9ofsX4vsv3nwjHnvFg/KNEQHfAwtx2ZW7HsWE5ogMzCVGBFyKEOHGh+nfhui5DyzErk0f9QI9p83AjGOMZEIPJMQDO+/+ADSUDso4RkRP6P6leMW1PdegRw7JwIxjSAad0C+/d9u60FDsFobEmdBYSYW5pghxRTewFB++ct29MD6DWzIM0qAT+sWPP/8Uz/vBLRmGZNAJ/c2tf/1oSJYMQzLohH7jzo5/HoTdEilijRXmOi7EZdXAUrz/3qseA/qhWrKBpbjigxc+hvEZqiUbWIq7d/1t80FYsoGl+P5d9+07CLslUsS6NmxNoBSxlB1Yirv2rd4K9EM1ZQNL8ZuVT79hcEiGZsoGlmJv9+3nwy4O1ZQNLMWrzrviOSAbquESKSKWELZmUIoIHwwsxc4duz8F+qGasoGluO2TGx+CkR2qKRtYivd/tekW9DhUUzawFO+9pneL+JRDM1yQ4jgGTMZJwGScBExgJie1WtMZxJguQYzpOthLbzJsHUVxI7YzsLifffmtf4HziiHavIHF/fzKfbvA+VBt3sDi3vfGg4/jyTFUmzewuD9ZtvFmPCeqhmjhIO7xFPd4Efd4ETfs6ZEIxxF8mIAPEzCMKxS7b4C9bxC+WI3LTI4LY9wDjsvep658EgSHBhVlhRZlZlz6ivKjS//xGh5sFUO2ouH0uPQV5f5v3r4GyIZsRQdkc3nH0q/xlBzcZlYJmzHrBGx51mIPc9agvEB3smnykiyyy+7JS4gyYlmovT0LnyFQhW00K4VmE6ghE0RDJoiG4MGBudh3w6WYAfeYa+D6LiqvvHXjbjyYaeDRA+KPiLoFrZDwgCv4DpG4kBCHzTDyjcp+VI6g8g9A4gSEgkHQ4ULQ4WoLEYtPm+TYQo4t5CjlxJq03wl5Qdc1nVii8AEB/MOA/xiwC2JEWiSmrw6gcgCVA6h8OMK3IGSSEDJJEXJ0Drlw04IaSEK4fO2rgZdc8tA2OAVhiKCyFdjjwB5VAxdKD1xfFaIIDcu0mhYmTG6HtyZ8tpGI5vtiMcvMbJObsk0eOzDBN+4P3Cwf658Gu4FLIyYQLl2+5CheV/mSY9vbk9XtVnXqq037V1/253t7dxrLUtYFyerUpZdf+MfXd5y343Xj99hqGrUs1XBBsqw9OcKqXpZqvACkD2/HxnbZspTvgmSS2E7mfvhYfwNq42JxA3qsf4MvOZrXFb5kPboa2Q7yRi5Lffj18tcfu/9fj4+QzmpSf+l96fO7Pnnkr0e1Jy1rtPRV2570o0WCrU9J+tqtJOLZKFeq3uLJkbys8yXH8NrpS45D7bp2qy51w46vXtt02evnrT5HsNelnrz776+tvWvlts1gJWiNEfSBdlimOmElJtXyiCai+jOSdbys8SUbeO3wJQ8D8vJ2/uj2WeXLUi8su3bv18+v/OMLSlzlqc7L913/3bavlv7TaIf1aZA+zHaEeVAZfUStCODtyQK5UdiORxxwzSLOWox3jVSqtSwwLRKFQoz1n5issULoOMQfJyWtdsTYQ1ZUeqwkOC7You2oXikYilEfcFQBDsARsR/rPxuVoRolaG1aEbkVwc4A7ixKjgB6sx3wWsFaC4WMtSeD7bBTqAnkoFlukgepUkKjIUhwEmGsfyba5ANJwAIrASssdcKWH4ywGjAAmcBFaQiHVORGaTusJpjKs4rkbp5VAAFZhYK8kHpM4qwKkufgFfZQQ0m3MI1X4Ka0BLzIqmIjWQYJzM9QNrAFrdp2Aq08weeHWDS7gjKP/WEAgBJ/USGKqkpiQTBHYQWsmnYAA1axVAiS5oAjqQJ2h8a4DyjokBvxdozL8HaEGEusYXI/nyNTKnhLQWed8Im5YbK9YBV+UEPxWZrG6+VzmGpEB0NRGUDMdTiwRawkRyNiQdLAFwDP4BOSV3zKoIJqoMRfVGA0EiIRSRVYCWDIs2AW/LSnWvIloppKSAVZ46kGBDWGUfBRykZ0vohDASUVhTatSuETUzlrPJUag594P+NZDJLQiH6rQ2Up6COVmPEA6kkBw0k+Ifl+xzMjqQLoHiUFjYBGEyySB82DjGcxBwRc5DujaWE+F1olgrcEdCYzeusZT9RQfJb0O54Qunc8sRMhVJZ9j/GsEUmN8I4naB5kPKG3w9hvlIqYGU8MLvAWg07KzyTerPFEDcUn/IOc41nKYTMxhhkqS0RqeRzoQx7PKpGU2KGDGU/obSknUtZ4ZvSWM8rkvM8aT5fe9jeeEJ93PItlFmitO8TxHCmSgn4d3HhCb4exVdZ4ZvSWesJZmj2eLr3tbzzBjnc84yK1PNqDQx5PpflQlYMbT+itKFjWeGbrrUw1z3i69La/8cTjyjueSm8jtAeHPJ58rmjNP5jxFHsrj3bPeGb0tlb4xJPgYO1tqZrU7vEshuaQSsyCQx5P6m2Ecj8EewuC+rW3nPecpYdgb+Vh5LW3fPppK3KI40lPI4+oD8Heot9+7S3xajt0sPZW/ASvvVVPeejPIY8nn8DYdjkkewst6NfeUtO03h6svRU/wWtvOQsinLiHPJ70z7QlO2h7C8PYr71VfgJG/ODtrTgXXnvLWaCf8oc0nj64smlJHbS9Rat+7a3y++RReLD2VpTAa2+VFcEsOOTxVE8m8RwP2t5Cwfq1t8qPl0fhwdpbEY7X3qqnArTjkOcn51GEM/wQ7C20vR9766zLZIl1sPZW9NZrb+l1aCtyiOOpVgIwcYdgb6Fg/dpbWkj9XDlYeyvOhdfe0g7lcaAPeTyVpMDnIdhb9NuvvaWfpf34g7W3Ihz3ePqs4ozXdojjSXuRR4tyCPYWgu/X3qrniujtwdpb8RO89lZ54dCfQx5P2osILcoh2FvYhX7trfLjxVU9WHsrzj8uaTorobkS92DwKaDHszI9nopUlGFnBCX+ogJ0Ki2rcnBK3fe3C1BJvpw0o4jGwAIzJ43LrTCgTnwIkZVCclGRHtEKSsfSmhuFrkWAF0MjITlg9ZEfnHOV5ijCLZd2uE94SNoBHlVhCiEGkCpYW/pWZbTdVTgDVyHYqsAvwmwVuCEIUa61qgQh/or61CD6jcrAUQEloJzwXKrAaCKghwoVDOihiMYo4DCu5qKG9aAtIMgJkNUvs6rRc1U7uoUMgbEaMTpaIMzcanAIGoRDk+EvYMHJSN5LJhzaRqSZTRDajJgrgr+e0Fs9UB62DLc6eGskXVXpCoyLMmLSgnmGRYV4CE1xPhK30sSjzzJrLMKxNZalB5jmuz0JW1AFUocr4SGuzFFBawSKk+x0FTutspJKgpipqFFnjeOtTt4aBbnVE+MycNKMKDVgY6B14JCwMGDrCBsNIhFDJqwKsA2ENaiOCasAbI0v9qdRpn1O+R9GGvYKRNrNesTB+ZbZD9Q7W6PXq3eyxqxPWcuXJn+egnR+sTbRYP08hXlw4trEWJR87cl/W5sYZ/0iZXWuTRxmnSjX8da/yXWC/W7v4xeGEpb9yZZzr/EnEvY9r3duDScOtz9/9tzXQokj7GhCwrgNyZ+uTdYkGq2fsl2yODHRqkmWJ6qt4mRhAgF5Hlo+JoGoNg87z0wgrs1D0naiXh23TiVGWcckQ8lgImbNTOYlCxIllp0MJP2JfCuVLE0OS2A3iQHxWYmfqQD5cYmfWLOSJyR+ZB2XPDZxvKZnkqZvsqZ3iqZ/qr7fpO836/vT9P3p+v4Mff9Iff8off9o/0wrjs2HEI4NJcvWYx4kWpOVIlerYb11mJSWJX9I5u34WbDIs1jEIXLesX4owIg1C5Dw+qVWCBh0E6ln558FE1WJ902k+iwB4DmK101QO7LeKvLUjpwF1cIR8DqnNgDDsXGSHIHaeeuBXtX+8VrsxECRAzgfkSxaD9uOU6uqY6t6vVXhQSoEHqeoDjuIAay2jgOkApgDwKCbSD1FdR73YTWfxwkswN3wUodF9hTxNAO12DlyekEbABDqoUClE4d8JU1wEOD+XiluVmXkplAJfXUkT6MCIIR3FMCloCrLpjdAuR0htUs1ucB9uBqT6mwyq0GVi8jDwOz6pclZEAOQq7r/TgoTpdaPHWKLqBrR9Rxz/MIjHntrShAYx+HZ1HsFAUAF1SAEejBeXl5FJbBTl/CIGuxYqF2RQ8gNwO2ivgJ7raD+OMrFwfwfQn0ejNJU0RCe/1djudQau94an63XEetHbg1Reh2yfgRIAFQEgUE3kXokMUgSq6T6jwRQQPWoUxJ3aFa1M2qsawMA7VWKUbAe6N16zZ0PHIyHVIfhhAVkJlSXr7cKPUhBYMA6XlEtd4gYwKB1PCAFwOwHBt1E6pFIPLd4El3zWYi6hA7D9iuQoBPpC+w6aqAagl40Exhb4CccAwp0KXpAP1l6PYzHgAtxc7iD0kEk9EGNRZpEBUA5NcOvUDn2IE3vMMptkodY4J6M2hCII7c0kaTKReR47EZDM34EyaUl8UvRjGEZvYa7S3FovUYgmsSIGDCOzjxLUx+SPWUX9aIG5BXj5ehImvoCbodPcWqL+MHOVKVRjjlIUz8WuDOcAlBI6o/nODqY/1OoL4DnMl0mYwnONjnkjltvTeir1yfk0usTtF7HgEE3kXpKr0Gz0usTNM1ikj16rWp79Rq13XoNqrP1Oh/nr0h1LXa/k+qm1bjemuhBKlQfq6gWzogYwBLrWP2UyQcG3UTqKXuN8xnoOSYt/KibnqMgRBuqkgwDqiHoRQURAVvgJ1wuTj3PAKX1WkRDTYVeOxNEIQJ9+dRroYuoRMzQa209HL1O04ut2tZkk4dY4G5WUs7PJrIRp8xdRE6goizFm2AuGf+XaEYtNCKt2WFqNoZYaXbQpdkYA0ez0/Tj/QfpN009TAKpx9Rw+nBRD2KnObVFR8DOdEW9o1Fp6sfhIL+L+omK+mPd1P8foR7xeJzJ4GQciTMrDrFw95Sn59LrmPUzpSGKZEevf6b1OgkMniZevUZ1Zy5qvRa1SdcWvcbLB0qvUbsfvT5J63U9jmaR6lE4i+Xodc16qzib6mLrJ269VlTHrJ8IH0utemDIptrR6xqtKor0IEnP6DXG2NuX0muBafKx+uuj10JMf3rtEjX02ivmvnrtknIN3pD0EAvcR/Yj5RpHMxSRY5Rm/KyP7YAXXWyd5NHr4vWQ2wB6naE/m/q+eu3VkaM8OoLjfUf3Q/1oL/U4LEvqf+KmXqYeVgX/rmlPhKz/cIoB65dOMWj9p1P0W//lFGPW/3GK+elZjbWGY4+wyIjbvoWJuDpDZB3RZM7H5XBm5UAArMn8b+6XNZkn4TKpyfwlLpObzBNxmdJk/hSXqU3mLJ5IajKPxaW5yZyJy7Qm8yhcpjeZ03CZ0WROweXIJrMRl6OazPG4HN1kNjCk0mTezDVtoMlcw2tek3kdr6EmE8tFhCKazJW8+ptMLGdNq6DJvIjXYJOJNSOCrU3mUl7zm0ysaU2rpElOs8SazLNxGdVkLsGlvslchMvIJvM0Rt2bzFNwOa7Z38MWs5r9O3g9vtm/ndcfNfu38HpsM4/6mNYJshI1rZ/IStO0fiarUASTQLmJazUo5/UwUM5rAyjntRCU81oOynkdD8p5HQvKeZ0IynltBOW8TmgyDxDvuCZzP6/FTebnvNY0mb28jmkyP+J1dJO5BytevL+bkLd5hyVwlAiv7Sai8m5vImL9AAeYEifwEkngFVosZAPtzX4LbX8KntnXL8Azr/i9ndcTwbP+3c3rv4FnXiGDDbxCButwTXWc19HRYTabn+OHbYAg3vSBQLnaHczmsse0Zybi5kznn14dmvY6U955MuxtRiuWvIkwFuRbVLEGxc2qWIzizIUsQR3tPT5vG5xnctrgsKLTButf3aaa/WS1wQrbaYODVE4bHPfSbQLsx/C2Kc20wSknp01Buo0fbXCa1t0EpwmdJuWZJoXpJhg7xB/YF45zV8Xvh8gYiCg7rkBK9VR2tdKGEDvRAd7hlAU3fi7lz0K17sbPDv70qeU3fh4w7fgJBSFERcyxqNps4LQIiwfMZgOnBW28p+30V5n0HVeA1lAUiWemnL6Clu30U4DzvboPv3WMCz84cPBL0cGP1ykd/HHih0ChljxrhiWixo8zaQ5+HPdy8CO+NgT8zPWg8UeIP8hSPoO4eOFS48/HM0Pjx46fgz+GVxUHwx8H/Y75Q6iotd4oitl7bthkxP/hN2L2/nSpc41TWuWU0IVpH6DWX+S391+72bAPA+AiP96NQhV7C+vdZhqxPePM0nNqGIvaMGphMoRYVMjuQqYNw/LFt0E4DWZXEKqC6yNBKFLI3oCbEL++eV8wUcbrhiBUK2Tj7WNGjPXNO4LQcFzXBRPFti9hmOfABA9DCqUTCgyrcIJxTNJnj/gJyjg3d4RhHOlbUc/iBMOcYVxebxU2GH4cJsUlDFUP2SswmoV2rNWewkOkOF2KhFIQDgqY8bFEiXkO0nhYx0u8p3isUZmsgg0hRvyIw4zoYgSWRBeNZDXMCX6kDMQkR6nrKn1do6/rcLWqUvmdqe/Uf/7zEaUkMDTW3FyfCnlu9BJ1aKxvY33K77mxhzeq3ZAeduxDhFHhMrbWp3yeJvtRwe6hj89rfWv8IxY6sDTN45lgu3MU/LL4gwgt2930o3AueMNLjxvxcQRgHcn3H8Lx/6Eyx1TbVcOJjD/H4a9fAbvgAYU1MGTvRxykCDPBL7+20xPjaXrdYD5ga+BzoL7dwGFgF7YZn0o4AkoRnhCWljsQQcE2hxWRllF2BTdabgJh/AsTD4cACi/4pAl+k1z5TeQ7FCPwYnkLF4EAzzhExxExtmJt8c3++Cs+/IzGV/rjlxB7EYEwoCH7aQgESztNJBqoEtQQvdvf+c60fSdQU/is6KZ2raLqxi+FQBrMVcFEnv3yVZtggW0j38S7ycK0H2pwTOda9oveMkJXfUCQSOaihyqpxLcHSDP3V+C+jFoGgmUJuLfX+DTgEZzP9qd/UsMeqYcqgiOlbVBHXd6G8gYpN5gvw43oysNEEOq76kE2ZwbwwWnZRu6WbewGo1tQTPFB2RFoVlyvAYHCiOZ8DTmHjNLcx/AwxLNphsHqVugIzNEjjcelPAGTdIbxBMvweYjbMpvMzUS7TdBiwuJNDZmtuAc/agVa0Y+6iFf4TZ28+mYYHbjaK0U6UCL7EWHfeUrDFPnbjuNYNZh7gngm4vpOkGRRO5VY7W5HgB8FWxO8vomrH08ijnTRT8QmBJqM7xJ8kaXJ+IZXdHx1koSIwfmaIL+Yof0sGjAPzcb5rIBipNm4UIoNRrzJuAJFaoSeLnnxyzgH4WNgYPxrYsmqlJH6+Lk/PvjK1S+GU0b8Q95dgbuEv77lhrdff+UTnwPfrlqti+Fge99WeIVeWq1+9tXXvv3uuzS8B3DWz8a2BgnMgG1DDCfX+2LboLFpG5OG411ZwZbdywZgI57sXnpVL12xZG2OXro9vfgdcAcasZPszrt1J9mddyC7FNFnd94NODrv7kfMnl7SnW/XnWR3vkJ3kt35dsBzjVaPB08a/RqNJht9j0bTR7Ce+mk0vbp6NpoOTKccEu2FOwlJdJhQndUHXrj87vueNv+QHJ1ufr6S0NpX37/l7VUZFtCK8HO33v+3L5/8Gs84zbLCtt3Edh2uK7DZhDP+Y7EU4eZiNYu9Pu6YVaemdHJP65dYa4/1Y0WAv508eJFI5S9fis02FzFjXcSIfmcRs0YT89WjLxnpAQaMdbMJXKEI7DGxkuY8A4F1UsAGmSUFUDpSdAMFPDvBjA+vZIDkUSQ5aY36LyEZi6paazjKNVatgmDZUmONUAxh+YG/q8BQe7uVQEMWkuMUb7Uu3o5w8SazLYu3DZoPN28dgLFuNm+98PIpYBO7FZy/4G24FMCbDEcvCjBLfG0Fe5Yy7CjAc5AXWMZjezjZQCYbrPGKDaxRa616lEda9YpJrB0ta6QqY51YZ1m67Ed5jGq1R5hfJ8yLAMY5AmhQAqhzCaDRJQAxBFkCmLlQeHXz3wM+WTWbf2TeIUt+hM84fmBfRrQbXMuIduCIgYxoNwpjrNGp8cvbEaEAYCbGhteT2yEFXBchfljXnjycwsDrWYrFs8HhKHCYVgGs0BNWUpWxhsZ2tirv91vDrREazvJhWstFLl1puUAyFHd/kpngkszwHJLZrsXgFg1WYKyaLRk4vQS7aopi+5OHy9g7+rECchH92I5C0horAhL1OLEdoXdcsc0vutWYnEQBTaaAJlmTFa/TICAqzjhrvAKcgr3scao4C0WqR701RitSIKNUnYGMUm3BSt6aqASGpQ8hGUWqSg0TcbklN0ZJriojLbjhJYrDNQE1vj3gUKZ5DxizrCOEMdEJHDapx6Y9R2isdZgioQFRyrGqeJIe7fQ478BrMs44r2L5cD3hhdRVeKVLqKvOEDpGCBW7BvqndGbTukrT2htQU3IDSKy2GoXEESDNM/0qtaDS825PAOXRioZ1cGsAERowaRQF2vpAs/rpfw37n4Du1GzpwHGNGnRLQ4YjGuil2kpq/RX8XQEgrRXseBlNcFf3h3sdcVdZNWiP0xR6UIPQRWnNZ0B7e7otXNESuN/KoY3Gr6BXHosv5Omj+B2mdrcL6Ehrb+t1EKy9rR0sGmNNLLV6ilQRS7Q9UsSyHSEcFuF57rCONC6OK8/zdWuGcamU6bzaPmTUBd5kdIbxEKaD8kCTCun+DNIOtoA3V9BsLGNREdATZQxghvEWr+Qy3mx8o8sdKO/T5f1FzcaHLMOR/KPkK2oyzucVDmlvUZOxWsoYRdS7Qpd7UL6QZTibN/AabDLeJw6zyXgbV3t7Satt2Ct9B2LOesCwV12D5Xq3oT1arjwQVcNzWwAE9WJVZmYWDVjrWSYXTlhwYNmHobZXRVyLDOaCYDUXrAtvqWIpUtrKZmKYo63xD+AwK69aFcutsvjvGAlw+gYxwA9i4v+u1+M+Oxj/vdDUgYV5JP57eMFYPXznw5ocf3wIsZng6JzjEdrxM5rL9REbGq0TkLV+puVP+PIDyJvMe6Zl8JwUpcC7xxUYMS6+SsT5l3EOtMVfM7nixyIRGEP2RaFWQPL91D1E+2g8GJQRHLKkkYUM4p9cE6LCSr1iiiAUmqeWSPDglQzjf0McIWGAZMPuiKrV4SqkPuKjmbUcgRv0WhKGxGXAN5o7a2EEQPArmP7FNbAeoDSMCwYwGr+cnGI9jpF7ItNvT0T1q2qpCg4VWFNez0bEikAWmunFOxb4oF3WjYzi5SQTiKBnDaJmjGr0wL3gdYe+btfXLfraq6/79bUD04rXTl4RtNhDOK7duNpbkmrRBe5lXdaL31RuyAaDCq3Bb47FBpxy4kB04kqieka0Im4KjUM9vD9q7xneyvWd3Y1rEeSh2EPyAZIPiWExqNWudTyCN0Hb+LFIixLJR6RBJELRFWihBeMItuGop1UA0XG40eTnDDhJEyJmB6WZhvmqoW1YwYXdbIyfI4kPIUNGUkAbfvJkakQFXvbgJ9601OGSFVj5R5iyTX514RdyUUrQQkUFcDoUQ89fjN3E0a6AWPESpcKH08mqn5ggASRPCv9jxhTvyK2XxTupdhjJV4yQN5zPjJ/rB+cRdHGHl3d3k3imSb7mGs0Um+DK4Zps8oyp5pp8kmszzWcETCiuySdzaDJkpPhEcBpcAw8O6/bhE+nzFJ8sgM+00oO6+L8QTAaXPloH8iATDvEvcsFYlk8Hm9YhZR7CSSpkhXJARbb2o+izitTQwLTScv05be9sK/6UCduCeAe+5EHU3MqRR/pg5gOgVXlCah7tDw1SjO8hxTf5xWriUmgN4wVKPwqBW8sXWz/eLFCR1u66hck8wPLsdchWioAv46V5iJdGEcfHdV0UEdc8ew1uMjSmbt4cRcAM1zU8updnr8JNGHV987oodidwXRXFfMqzV+AmEkPomyujmJS4rohiBybPfgQ3C6EUWALkTTAeido+hEztW7u7Dbsyvoeh4zwacySohjkyaDDy7G5EcqKqLZ+1vvhqRtE6mCcOg6MfVXl2Dx9V9peX4fFVGL8NgraRBACjXhR/BJTY23keDMDtykDlHeFbVQb7ACquLWOwBnmVt+hbln+GcTuEYZlH+tYVoM2yy4GUb4oXK1wdEjnL4LLX4Ngd4/rh+OtMQIAjtPEnwKG9HTu28lq13cGUl/ETUdqALV7k64k/TC56cV4Iz2cnhGTanz0CUeTF/86dlG9YppxfZFXsNr4D8bC3OCLrPRRVL/ZnuU+z/FG2QtT8S3YfiP+C44B0hPkAYYvSvlTdzycm3OfdilZFjavWKtYKq1qm3cFf8E3Urxv4KwK/SmjZjlb4SIG9ltBgfLmwAlgMrAfj2CMjEYhLAYrAWh5ckRhyAWQHTCAVxNAI90Y6MOSAo9WeWLIiR6sVupU3sAGqmOY6B7YVeCgDW28sWZkD2xqNzRv3gD5pbNm9rAE24snupUf1sj9XaAhy9vSioygQj+4ku/MNupPsznu56ZOj8w0I3aLzjvzcYkarTC/pzuGTSSfZnXcAWd/AEeoDnmu0tnvwpNGv0Giy0W/XaPoI1lM/jaZHV89G0+uBZ6orhesNQXUya+KRrjWxSMizJgZNaEW4dwEMlhW27jCiUJQvDuFXsrAdp+WrcCScqh3iofUKrmhxgh1rFSouIs1QBSapGK6WmTX9BMlEv7OIYaiexGSW3RhgwFg3m8AOReD2MJajuK4AgdVSwGsSdVIApRYLG1BICDMhrA9BcpIkj5AFKqBbZMGFcqVVpSA7cBrFqlUMbYERx+IkLCvD4X2W0Bnexrt4k9mWxdsazYebt15EGFk3m7cewCngMI6l4roGvNVIAbzJcPSggHT/gIC3ETLsWIUmZaRCCDzgsL0E37AsV2wg5l9lJVC2ZC0OSBeynciaGOVV2COz6nQZL+TKEpqCEOZXCfOupTkEMEoJwB0BdUdf+kZAMZCaWbcAtusQa7YAuEFCpsKIt3AEIQAZ0w3gW8a0FwUZ0w14pabeGqnjEwRAEGNEM1AYK8IKIlaFlwsOo0TGScyCmhrU6/S0IuzHOlvW7yivC+lgJWvi5UIJWRLOcoPWdZHOurR0IB8KvT/5jBswcIkZp2Xhls8Kfn0hl/JruKuuKHiEx66hA46edEA6oifdKIzQATxRk25IZ7RMExSUlgWRDxtiaqSYjrAaNcMUE5VojER4qBRBRFcYk6ISsUxlSUi8hRAc4nZUbD+OwToq1sUyQz+Ei+C6MmpVngn+pCVYryRY7o6O8NEvNOepsd4OPmXSbwd7CKUJe6IfDMok4BRyqEZbDVq1gwhOjdazHkeGZeDTQ74lLzPknSwzxEU43DdA8GaREFiRobVeBXNo6MCCBHM85O7R5PbkqTm6BlRWSOSIw1PunY+I8ihhpWfiDqRcsUYqIlYJoh1CBGaRjlQpe6SiSbkI6CUB4xipktnTi/4r0S9NW4VodIVErajLgn9dXjpkqGNNMNP94N5P3DhmjfaVVp0eWKQDUK35VFCRKmmLlWw+7V0tvScENl7GNjOOcfngVilnCUvoAZwlbG3ldJYAH8BZ0q36OEuA53SWsMk0gLOksfVxljS2Ps90YMvpLKle+nOWPL1knCXdSR9nSXfSx1kCPKezhJ2uAZwltMrlLOlO+jhLOXfZUB/wnM6SB0/GWcq5+4bqGk0fwXrqZ7wfXb2Ps+SBZ6orhcPW2kE5S2iV01lS2LpNbXWxkaKcJWwWOc6SL4ezhLbcyjtEZ0kT43GWAMvpLCkCscuonCUQqJwlCfOzAEqVs4SCcpZ8OZ0lXx9nyedylrBGVLuS39dZ0nx4nCVEBHM6S4BTwKZ+jMkOKgvgTTlLKChnCbyJIV7k+ErId5fDVyKPXl/J2bejJfa5fCW/y1cS3tUG5vf2lbAx18dVApu5XCVsYFGRTe0pyfYsC7I9yzuyhUmIbOa5PKVG7SjJVhWuJ+dyk07J9pLOdjlJzo4udRk569JOEsuOkyRiyWxtfk8nCZub2T4SApM5XKSc7pFfu0eOZnB/U7lHKHjcI+xvineE3S7RKiuXb8R3TD2u0UkZz2haH8eIW3aOY8S9X8cxYtlxjERYmf3Og3eMAtoxAofKMQJjHscI2Qj7+EWVGbdoVh+vKODyilh2vCJEPrjf+D28ooD2ikBiv16R40FmnKKAyylCPIcbid/PKUL3/TlFgn8dt+++j1OEDIEDOUWr+EKNyymSHIQs4Lsq2MwLxC/iUcC8scYeHJuUDlDuQVkYQXkHylqoxnaUoQyM0en4oBm/ikGqHtmi8jtQdTRInxHDQW1VxJaGU6GUzYLx91Xf/g2VoFYPXBfKnbrcjfIKXd6C8ipNx5oywGGGWV6H8ipd3oDyGl3uQnmdLu9AeYsub0e5W5e3oNyly90ob0BZzoDh+VeDA2hODHQDzmv6cMq1x4jj0D3jkYgCM2yJCyOhEhou4CXP7mT4N44j62gIFY42I4UqnuF1CBjHrplg5uuDuch77ke42I+AbIdsFPLAdnhJK49wY34nJI1pI1/KhiXg29qwEglLXrhOSArSON4wYQpRvsDNE/gJ7K34rMLjGfzG6Vlu0gEzf/Jor4SkW3k6tig1bblVlMI3GM9PNeAFFBQ7DoTPT1UKtKNjf9H5qcjypbwR6dQAlCtZRj3CG1BGc5SmdS5dCk1Tx6YT+OwqovnYFOTr4SXyBr78qExyHPUPUCAv4MuPSLJYsgNgmwvH1PEGCPfTucfPgwkwIUWpm3bd9ODF+y58cpPRHv9SXs3gQ5hvnNLuY7vF3aQ49dzWR2+4/PIXVn/qrY5UjlKdHyfLNClJvXDB1uvPXf74Dc8av3dXL9HVhyH+n2lSmdq8Zce+tRdecEu51BYOGpO18saG/JiWrJHXNuSHlRwu727Ij4YkVTPTA1JaSA/VTNKZ7mV4quufN1372NYNf5neD7eVsE9Oi7LUNWuu3rB64+b9rw3ErdOkNvVuz7V/vP8vN/R8PBi3bFKT2vO/z9xx0y17Pn1ZVRc+TuQBbDhl8uOkZIW8xSI/ZiZHyKss8mNWskG/zzIQuyNSG7/Z9/4Xd1x5YIyHoNzsNqQ2vvH4X1b2vPJ4yRC4rUpd9O7lX77z1zdX1Xtq52a2IvXWB9/e9WjXDcv/rkQpXCyi3uIsnPw4m+fK8WqM/DiZow4HW36ckhyrX+5RXdToLso8zNam9l7+yRXP33n1G595RwtZSqR6HdyaTJOxqedfvGXtdd0vrfjOO1oZdsvx9HKaVKa27nz7hYv/8u1l7ww0uE6T6tRH9+xceu8L59/zAzW2rIO9KGmDvSg/V8W06PRi+ZcTVjI48ywKPZPK+F5OWyyD+QoaXXwgHo4nOBLjy/HF4dLMxLsnrMhVAd67IQ4Tbxdw2xCpcjSvpKoqdec/H+p87+lb7qnx0J+RjrvF8NT19z3x6HWXfrImPoBwnBZlqfv/cu+uPV3v9xQNoAtOi5rUu133PPr0g+uWK83JIRt8bgEHTejyy135iyzXSBiAU0uQr5YNquGQOlc9fOpLthIRKLPqSw7pCkc2PmyVi3z5SlEf2VSkvlh6xzNfXLz18wn9aI67RVXq/GdWf3HrlTc+9Gx/ZsEtnOrUy1/+8Z9bH759xy5v9dzSqUzdv/bJVetWv3XgX3qm9BEPlld8Z0ByV+MvbQIXcvDHyqAhmG5KPFhN8p0HrmMhHCqO6AeyYIvqINW2I54NPrxzJSKGCuUSz9+737nohb9/2PO+V/fh4ggH/PSfW3d6V991+fp7Lnn/1f5mFj5Ll25Sk3r80Su6/rX8gW+fH2hmOU1qU9e99UTn0j+uealbm80+8sF6HnEq/IbNwF+aEa7TMYzV0JFaq0bJB+EAbmgyjAAm1WTiBzZFU7B+FtgWKJOW0natRDv6KhGJq0pt7Nl9+bZz//fS6UMQUl1q591/f3/5q6vvGDcEGVWn9i69pON//rnq3dAAKuS0qEz17npwe+8dz64c1o8GIX7CHF20I1ANMRpMY+TWHsT0eJaBdkWZHE4nEZ8IVunQnox0erUO7e+rQ0o6B97Y8sDL2zftHOPhoD8VuvXy1W8uW7vl4sP7mWFeDfr47yteefKx1Vc9N9AMy2jQG++/8tGDN51/3Uu5Z5hjloVtmOQKrl8cvXGMsdzkHIJMRC1gkh0tcplkZXbMfjTmH08/unvLP69b9q6X7v5UZt27/3j73lfPu19bhsF05tqbnule/fpz//PtUOZVZerJK7/ceefez5/S3ku2VByDLIyLMXbpS8YMqzmT1hQYY/WgymgKjLHcgjHOrSnXffXwqg8/XLZm99CszXc3fHn95gfe+2yI1mbv9uv3f3bZ9a8fPSRjs/389c89v/XDZ6bllIljhYVtWGCPpji2V25ipqQ1BRZYNAXa48gEFlhuwQLn1pQ9OzdteevAkw8cPiTb0rv+g5cfenjjvWOHZFteeezhzbc//9n+2JDUpOvPe688/5J198dzzh3H7grTsLkeLXGsrbInNDlaS2BtRUu81lZuwdrm1pItN2596sObNrxYNSR78tIry/+07Nydq4cPyZ5c8+rDB5774PqbvbaqPx1Zd9nHF/3jqrt2TMkpEcfOKmtCpl06ksvCiiLAwoqOeC2s3IKFza0jb993y52PXHX+Jd61TX86svXK5dfe+cztH/1taMZk31OXPvzlM/f8bedQTGxl6s+fPnv/o9+uvnrPUE2sS01ymVhlTHJ6vcqY0PvN+dh5d+Ped3f3PP35UEzs8FTPP3at+vzjHS/uH4pUalKX3PZo7/3/++bqb4bmuqy8aO8d32587Lp9QzWxLlXJZWLVg0eritfE9ufvKqnseGLfO7s7utfsHYqJrUtdvfSLCze99c6rO4diYqtTH1783gdLz736/MeH9uD5+2sPvPPCmzc+rfymwW2sS1Vy2VjRB5eX67Kx/Xm5SijvPPLenZfduuGjqUN67Hz1zYFPL37/hUe8Frk/RXnrtgMrrniy5/KyIelJ5+7NF5274o7Hozkl0tfGutQkl409ZI/2oTd2r1j7xTU4EDQULbn17puuer3rjbujQzIod65+58utHe/dUDwke7L6kk9XvfDepq6aIdpYl45k21guFB0vtkHrzfCMjZW1I2xsRQ6JDE8t/eayVS9+u/vjBg/Vgg5U13haNKSueOa65fftvf3dSf1IBGOWblGReuR/b73zxsfvev6oASTitKhKbbu2u+eZ/a9d8sTAFla59z4MGpUE25luC6tG0ieyUvZVIFAbFX4Q+yqrYNjXuiyBkJTK1APLvnrto6u/eGub12BmAlIeGaZuP3Dl28/f++xj/UbUGC1ymtSlPvpi5yv3frHz3TcGeuo4TcpTV2+4/sXNdy+/6SNVHZFxnObnjt/odgR8K60x7Yjtllr17Yj7Fluj2hHiZcpohH+ZhxyRXkGLLK8IR0pPyL2aSEjUFXlKm7EtZFh4hbwRl2QzNpAMy2ImFuQ1bcY2DFKeNvv56a+Rzdj5MKwEA7dYh5sMTT841oxlQtPMX4oT0Co0jVAyYx7uULJfQsllDCWXZULJKDqhZBYzoeQyVyi5zBVKLkuHkoHKCSX7GUr2qwwZjHbjk0WMduNrUox2I9GHxIpx7JuxZPnql4WpLl/Tks+NNSCNryQoxRF1xmflU2TgnrtmQGFgx9gdVEZ8j+k5OGwwMjJstTKZKhjTh0YO8wSVXdVxVF6qM66TaVLpCSq7qmPCSnWF1WlS6g4qMxMPg/9JXhqp0Qz+j0yjYJ4VZdkc4ogGMAu7na7QsatXuS1T383TSE/oOCdPnD5OkzpP6LhfnpwmSU/oWDF1UmI4LyfSkiM+nED64H6ZIh7AZuKQgitA7OpWbqOJ5WEK4eRMgDgnT3jpLd2i2h0g7pclp8VwT4BYsXQ2nte4LGI8E1FgzFkHR7nGkUjTRjyAnZy0PGHgHDzBTmC3wWlX7wkDu6rjdRWpXgzUmSZlnjCwq3qhrl4CS5RpUusOAyumYKSFehhpyE3CwH4YISZGZoZoKC0tL1LXSHyYxm0UWJOxhXlO8Oq4vyjCPIs8YZ4r+cUH9IrM/mkaPEFfF7VFmtpST4uEO+ibUxRFIMhpgUBlJujrqo3M7No2E6fTosId9E1LQjQHkoD0JOjL84ij8Jgqw14TAnFaEhINTvK9T9FdSoKvqFMS8GkcSYhXJy5vOffp0CsfIQ4Nde4Qb05JuFskPSHefkXhNCn3hHgHlAWb1HhCvDmFwRBvGOowmjsBUKQaq1wJg0FdpOcG2GJkVpr4cGqAKLQbgyJc3RG8SjihrzCGewK6g0pjpCegO6g0qj0B3UGlMcIT0M0pDQZ086ASylQkIRdx7EwJ4UbF0FdBJjL+cHORe0vc3FotDbi5Yhzg5pblkEatO3A7qDDq3YHbQWVR5g7cDioKyx24zSkJBm5j0Af69DhIQYkoSTBcmy/Ba64EZPDh3oq5cEIIKMK9FZWBe0tzkS0JT5B2UEkk3EHaQSVR6QnSDiqKCk+QNocs8EgGq3hvLGMqcFKDTxIIR4Yb5lIZCQRmM+ZSGQka4VxGwh2QHYKVcAdkh2Al3AHZIVgJd0A2hwRoLGkIXPYB+cDFY9GWAWZSLAPMpGMZYCZFOSQykMsyuIOvQ7AM7uDrECyDK/g6BMPgCr7m4D+MkVc+Xtoi4GtHblsAyyi2AJbRsQWwjKIcsIy5bYEr0DoEW+AKtA7BFrgCrUOwBa5Aaw7ukZY/2wpEvfMfllDmv7PgV5ZQFAOWMPf8dwVVhzD/XUHVIcx/V1B1CNPfFVTNwX2s7+xHykD37If1k9kP6+fMflg/UQtYv9yz3xVAHcLkdwdQhzD53QHUIUx+dwA1p/nrM/mZncM9+U09+RE0zZg/Nfm5H5Vr8ruDpUOY/O5g6RAmvztYOoTZ7w6W5jR/faY/Plnhnv4wfzL9Yf6c6Q/zJ9oB85d7+rsDo0OY/+7A6BAMgDswOgQL4AqM5rR/fSwAMnS6LQDs3yht/xwLAPsn2gH7l8hpAVxB0EH5H+UOgg7KfsIdBB2CBXAFQdPcS5BClk74VJPLAiSU/fNYANg/sQCwf6Mz9k8WarB/dbJc4ueQMv2Odgc8cy4d3S2S7oBnvytHp0WdO+CZg/vS9KKNLQrdAc8+3JfD/qnpn8ByCeEDZf/U9B+tpj/sn1xh/0Q4yv4huiP2jyEPHHQFZZl+E+7gZo6oDZdxmRYV7uBmjuV9DYjJtBjpDm66asu6FrV57iLTYpgnuJmDfb+e+3VQAnw0W1k/NfcTkIeyfrJShPVTHrJYvypt/fg1cnaEc9Lpjss8oUwXjU78BN8/cjWp9YQycwSEgBF4nSaFnlBmznBILYnQTao8oUyXBOTz/4gdypsSjOYZoIaxOfxgzFF9Owg/GIeU4F0lfrCdROgsyRyNRLISyMMPxjBVHA8/GNeUj/5Pww8E83To8vZqs+Qck6HL7b5M6BKHd3XoErlp3ZHLBkQuA/Z35x4In2lHzsaZ5Mqz1a+2JhzV9duBdPSRGYaQZJYJx1XaIWJBCacCmaBc5R9CcnKkB0YKFOYLZhZpfFYJiVIkf7CRRKLwOxgXjjaZksYbmcIlATkSZvI0qCwdZaXIVDC4zlzID8nYl12w+wK8wp5vr3pj3cpAa1ySkSOH8BZkZ2HXKHajeKJkHeCp451b1t3jW2jF7Ls7D7wQWOhpQPp1AzIgeZPRP5OTM3NyEjQxQ7nkawadTMjOjM2k/WRKjGlk7U//vPl5vjZr71y681n/oBTl23/ZdMna4ELwsuvrcz8JDUaRlUQCc6ZSZ25qUsF86ig3kAomVUd5fBIpSRdpiqL2uQ9cvBIv8hTae25/8zHT20EOioL2E9/czVzG+fbGC5+60fSy0JeixiSSwkvyd/yYkkTOKskAjx/TkmGdBh4/jkoi7RD2MRRVcfu865Z9FV6I8++fP/TVlUi6NAhVEfui61fs8y9ELtzXPrv0xoHkRDVh3AVn4OMviU6x/20+JK14RHLS8+cW/pQE8pK2ejN/3icZ7vkT2tZkMq28BK2YaUIdwpMMGwAjn4gPaZlxXelD9nLFE35hf6bI/rp3+XlQMfy8zpcssB+74/KdviFIfdsT9/DtxpD91MPLvzUGkDrJwttW/L6g4g8PKjd/YS9/ES9/8Dsy/PE1ASb4UDyt8SFXCq43+5ArJc0TnI4S+/YLXnwJr/Dh5x2+ZLG9d8fNe7MUIwdPYfv1y977K6ZnxN710qZ3kWd3QJ7wZhnDrw1QJsUXnBU3XzIy/Y4bPrCY4QsvdEgOGMXXyWqo5rtH6pRkqX3Fvq6NmHn4dRqG7c7dyzdmqVXOcXqw49plASpu14Z93w1kQcgTg6HIdKT4gYvg5kcGJsOPiD7DjzDv8MNlYmacFqlhWuIepbMxSA/ufvNFU/jBJyrti/d8t8U/KD9h+/0Xb74R5iFiv/DUbU0DDlEUL3III9hpGvrAeBQO2XtcA9OhJ9FSzySCm19qd236iK/bijZA4ZZduevRwRUuaF9xbc81kn75wM67P8h6HmRxg4TZhzAsHjVDViDXsMAkSGWYBNfAwCSU2A9fue5ezANlEorsl9+7bR1ytw06NN/c+tePQgsxNC9+/Pmn4QFVjVm+Dn5sPEpGY5AZGxgDqQxj4BobGINS+/57r3pMzRsYgwL7jTs7/hkcwsTZvetvm2HAkV/qgxc+ztLMLG7w1dRDGBuPptEEZMbmZDU0890jcwoGZte+1VvVlDkNWvb+XfftG/wBGbZ7u28/X6bMNyuffsMYkBO+9XTw4+LRMk7+zLgsUsOyxD0qZ0OnOnfs/pQZ8Dj5C+2rzrviOd8Q5sv9X226hfms7W2f3PjQQI96KvuhmDEx6O7ZnxkTzH6pjNnvGhXM/rj97Mtv/Us9bjD7C+x7r+ndMrgrFbb3vfHg48jvErGfX7lv18CPG2QsO4SHjEfDOPsz44LZL34GZj/SgmVmv733qSufTM/9kP3Jso03D+7uRO3937x9DfyjoP3Rpf94bbC5n9sRGHhkPI4O5z5TZ6XnvrjpmPt4JTIz9+0rb92425n59vKOpV8P/sDMsy+55KFtmPcx+4Kuazo9D8zkMBcvfPGL+e753VWrbC3o4qKIH19lf8fid0D9FrZOxG+uk/gpVv7+JX7j0zOSNdUaxtZcOPE7PLz7U/yWwn/jFImAsQZtME8CmEsq+W4Pv06CNR/3orBW+tPRZp5OWFe0MBnGWiksH/jQCevC8oEPZDTkBz5wi5lydLo6gG7mN2FxxQcF8nGTX1fQ6eoAvI5p/HHFdxbYkt9RYJLGWHwxfjGJHD7LoHOiAi9+IzGaKycqYPjKlfiAKmcbThQyj1myiHlL+f0ZDQcy+X6FGT8OQx8ea7wZbjZuRInlD1C+TZc/RfluXf4S5b/qcgfy/nfrcifKyMEk5RUob9flVSgjPVF4gvFdGDojpZ6wvd935gxjDevk2cecCdLbZhiPMTmmw5mXpyxukH0NnxWQLKz4wjaysHq4QmZAfhsbWVihw3GbfOJNUpO5DYWk/VG8UMnPZKDci/IKXd6Dcqcu96DcgbLdXZDJQAsx8sOXWZRFPXJ2EsVG+iWvW16BJXmowLQqGHTmeEORC+/owqSPGRElMZ2csomnsJhmoVi9I4/DTjQXPKZTiltpKHPSyZugwwBFIwVlLjoe+8EZI1ddJlxjNSBQAKamU2+buhsz9RyPDjHLhqsjNCY2INB9AMB2aWxMTadeV3VjY4o5OWKD1AAZbEzORvRpbEwhR2zoQlOh0rdl0DMpnbwXCiQZ9MxvR8xpRMzXRsxAprkGgIjSmJnFjjjSmJmmjjjSTZhSjk2AR/MKAJukcTD9G5uglmZI10g3YSI4AlBLN8HQ+iQFXLErp0KdK6cCmMrKqQC8aEW4N4MCSFTYkAKuglemgEMeSZUCjufmUEQKOHz9u5hZEfDFdLzvDhhSwOGvpIDjO/h4Rb7MRYzlIga09yGGKeBITCZ1A4QHGOtmE8gUcOhqRRhRQBKIbFAlQiAoxf6MSgGHbSqVAq5KmEHOOn6wvJYkq4QVgCIFHILrKJdawxQEKeBKrQrFEMwP/uoUcCoDQOazC8P6ydiCke/DG1PAkQ83b0wBx7rZvDEFHDmIIARNusEb9htULjgZjh5JeEcIeKuRYUfOq1oRRAgbN8OQ0UKlbmG2BDJAJqskMwFTtwCCFHAIFaoyUsCVWOWaeXxHSz40QbhiXme/cn+bYYQSQIlLAGNcAsBs6SMApoAjs24BMAUc62YLgA82jmUER2zJHASAVwklS4QMKXPhyZCq5HCsgoIoAlPAYW9CpYBDoFpSwNVbJTrRS70kqKemBsEn8z6kFQEp4PBetSojBRzOReuaYX4HX8NZZkoUSgf+IzOEubKbUOj9yafeJR/M8z7yYQo4ysItH6aAY90+yq/hrroy9nnYsaF4JNcYWZccaZQKCjjkpvNsUKcgHUuUTHIHslEQmWAgJn5+Au/J8ksEZJhiohIlJJM+FYSZ8pihg0rEvGVMEELxhRE/Z6IOwsMZRUPWPKVoKvEIMYjg9kNwmO1O6pBsCTIDPyQY9yTIR/4w4SZPjTUT28mkX4FCuU7hIgrCFHBV8Ew5VJYkNeGABRHgZkIRDhu+KyoDnx5yJKnLDDnL/HoF1R8ZZlV2NCGwOJPsxJ3PP64SgnjI3aDJ3Z6n5mgPqCxGaiBSWQHiPPMRKeCUmNIzEWnf0jMRmfVItBCBWaSzneiMJCX9EdBFAuqZ7UQsIlPAcfuFpg1bMOgFWzd6SAT/HqaAG6bylZQo3MX94e4m7rhVivZ4z1dhQQq4MtWaTwWV7UTaIvUAU7/BkcFfZGBWHyyATUCwhaMVlWfTwzdtffYf2z4PpK0AvxEJ+A3Pfb3+0/07MtrPrQIm75CHSHYrpn5jq6Uf3bhz17a9ZtrYAs762diYmowqFBWznY2N6eeI7btNnz/40fVfpmcrU78RW3YvTJhGPNm9MHMZxzQqtjG7F6bAYy/Xvtm787J1aWTMVsdOsjtn6jd2kt0506kRfXbnzIPGGZ5bzMykx16yOmcSO3aS3TlTv7GT7M6ZhC3XaDG1HvFkoWeaOqLJRs/Ub7mGj7nzWD8LDRPO5RofZrvLIVGmfqMBwf6qyzTjLdCBnSQ9PNlmmBnXqL5+ZW2ZfUw5Scg15jhJWGH2cZLEKjDT06E4Scw3l+0kMWVaTidJEYgEYfKQZOo35SQhRZSYBH62ST1RJVsdRcMkEn2cJCzls50k5A53nCR8eYYmUqV++z5OEtPa9XGSkPssl5PEnGgUMM/pcRDAmzhJ/ICRGg75NAzZBm9igJH6TflIPNnW10cijx6bjD3BtI+EPAkZH4nphZjhiTYP6zBP6rfv4yMxnV22j4SsZ7lcJKR+40Ay8R1HGCzKgDL1mwwov04kA8ocV3hIy1NHnpr4bJM4SEhzJv7Ribnco5OyvaOzM09KJA5KPynxFZ20c4S0YGnnCKnfKFJ36rfv4xwhJ162b4TUbzlco1xu0Rq/cov4jSu1mnE0gx848rhFSIsnXhFSv4lWWbl8ooZsl2hWxiM6RTtEaVcIGcDS+oScZWl9Quq3jEMkwmIuSC2qjFs0NIeo16+Glikd1QQHYx6HCKnf+vhDSN3ouEPTsr0hpD9LjzFSv6W9IaT340jrcT0Ub6g7oL0h0NqvN+T4jJkpF8g4Q8igR2Gq1G+H6gwxI2I/zhDS3lECwP99nCHk/BvAGUL8CEnZIvjQgDhC26P8YgVCPfLloQhSv6XjOCFe+JFXM75b4lR4XIchvkL1qPLkcQ2LR0W4NwFrWJ7CaLWnUD1Tslo5npY33yrIQSvWz8bGhzGw9RYqK56FzfHAvOlYsYGhHY3sXuiBEU92L3yGo5f9hcpWZvWS9szcyV1BmuMzZXXuOGbZndMxI/rszrnEQucdRTnFnPbMvJ07jll2545jlt05HbNco5X2vbzoHdcrG73jevVB7/hYXjSOi9VHRB54ujqdU0gCCW6H7jOBppw+EzpR2FbQZ8KVOUtLRZ+1z0S1yvaZqARoq+zOwftM4LiPz4SxyukzYawUgXDq6nilU1ciBIrPhAK9u0qhXXwmiqavz0RivT4TZ5/jM6GM9LH4q9J9fg+fCbrSx2eCogDW12fCoMC/oIDpM3EQxGciS+IzkSV5MpJt8ZkoB/kWKSv3dZrIhtdpIkuO04QynERlwcm84zShDIcRf13fvDx0pwn62cdpwoAD1tdrCtOP4FDSayJv4F+GlD6jDCl9RhlSBhAyXhMA8B0TvCJh7kheT+7jNQF4isdrIqN8fZiPVLLruE0UkuM2UUiO20Q1R9ze7U1+L7cp7PiObsnAb+zrNoUdb8pVU9SBnhP1QzwnKoGjH/QqM54TAPAmLV7xzUvRrcY+nhOA0zyeEwAnac8JRX4wNOM5UXbBjFLBzUwrFdxM5TlRqUReGTdzyJ7TGmyVyTgH1PAyYbSa5h7PCQC4gl7PCbAG7TmhOMvjOXEIHc+JA+l4Thxy0fkdh+A5rdO0bqfnRNn36znhJtPZZjwnisjxnCgo7AHShzs4z2kD+9eeEydLP54TuRP8+w/Cc+oibrfnxAHu33PqZgJTkz4TniTIBMskuem9NT2msuemZSZ7cUK/7NElcV5UesSvD7kzV6TK+7hjxzK+PXklrg3Gn2P84GGDsTaGz2VJnVdjzcZ9qr5/O8rrdXkLyrfocjfK16M8wXgjhh1V6xc42Rrm9+65O3ktNvgOY260yzcZ9h0rNxnx20x8+kt2L9/ixzBld/MIsIIPZKIk+3fM/8s/2EbHZyxZw4fPWPLuh9ivCtudRa36c+/Y6MQHL3FW0L4Pm7ti7cNMksucuEVEwW1D5MDlpi8ukg83zC836nS4ID/CbLgQbBH3ou+oMOPq3O6a+oXJKNzTqD0NH0VEfWwpR3G2Eh8+w2UaUgBEaVhxhFffmYKT4rg04i2JqN2Ab8Nhj1/dGY/j17g04DWCKE0Rvuip79TjeDIuFk5ZR+1KHKcA3+pOJXaucanFxnWUFq3UKok/hQ8TZv7hvMIIfnA+agXkU6dX8fRlQL40ulIXA0f6kMRDKkBMl0uxwajBsVENHTHDuAgnL+w3jJ8V4AxBg1GB7yviUorxx6UIX0vDJYYDMLiEcYYEbfw4QoLGY41pUJ8CVWyEVukikqx26CISPeznF/pQnIkMrTz2gOIsJCbVxRORsFQXT0IiUxTtLfjMGXeC9+e3xmvBZHSCsaVKuERpaxW+n88G0SOMZ6rwAX1dfg7lTlKFOs+jzp+k3GC8UwVWIXvC9wB+EcoTjG1V2D7H3e1VODqA68tVODqA644qJoppMHZV4SN3uPZU4dQBadmBj+/VKkoKfPJV0PwQP3+mKXqAwtQU3SflsaAIO+O6/HeUkRZDyruqmo21qj6oP9K3WcoTwNUM4ymU7T1VrRMNA+8aKUILrehUsIGXsKTanyIzjE26eWfkSF+3bn5R+QwDn6sj02AYh1DkU4H8NbOACrQFb8YX8Wpgcqjtc2l3FfTmT1A04luJT+DBVEYt9HGhhq0A7CIpT4D6zDAuYdloMm7gFXNzNa/+JuNqXkNNxhW84nO1l0ob0II6f9btL0L7tbr8FMq36z4289N7LEMEf9GwbsDu0HU3oe6dLBc0GY/xWtxkPMxrvMn4K6/5Tca9vMaajLt0v13o9wnd/hG0f5plvLOQspYvTVb/wHibh7Xfh+cPSOdRIo3CGcZW3eIBtHhWU3IfKIFp5uBhQJt923R5DcovqzIGtNnYSYxUXtP1XUJTvktYhi80cnDsrpA6UK+/JQjsHRHMN/R4XgSjxS+r6u8SYmWN+cpBx2xGVnHT+S5hBd5bE1x7Avw6ZQaX3ck9e7zWh68SRvnFRJy2MvhlQtzBhwf99sX8wuBV+ENIgB+l/IzfORWFwUeTOcXs8/HhRN5fUZ5RE3sLPwqb+dld7PrJVOHyrdeofNsV00u+7aqv3frahavdA5wGFFDVxqmlHbyL6wbe3Y7vfuIDhHZPsaJgA2j24XuaMAS4EybN+BAjjS1hnZAzTySpXx1CNaJJ/P4mTCvcSdzEpS2+mZ8Ilm9C47uZIiMkeZcJHJTf6EWLy8VvRaviGs+yNHAreqS4ddr4qP0NPvLIryWnAfvzWMOVWF66c8Yn59ceDX5hMWPy1kEfMbBYZAPG4Y1P1/wzLOL6tqNf2kHzfN0BmBY8O1juQnmVLm9AeYUur0O5k2V8kBqDsU4X8ZrIBl2kf6CLeI2km88imN//z965B8txlmd+Zs7MnDk6t5Z0dDe4ZyxAgGWbCpFddgLuqZhYgcQOS6Vc2fzhrdrUUpKLsiyX8aZ0w/axdRIIIkDWgCHKQrA3oMXhFmdhYxlMojh2EIEQB0jWJGxQCGHFZbOGhXh/z/N+3dNzzhEk1O7+ZYFP93R//fXX3/X9nvd531cTH7GWU5RfuDpEf+YvkTmrS1SbuviRVvYeTTj6GJb906yDGiLZpa1TCyYipUT/kQSQ5rDu0PH0AmOlh3d599EtRPaFkxa1QfBsx3u2z/5WijJMLF/Xb0tPKMYznfrQTxK7WZmdWuhnlIB5v2hc3jh9gUqg4NMYRcj5lzsYa0Gc83HYR8h3nJs++9WWBgJCzZZh82c9EGi4ZtFDdceHKXsPU+hv2CWQlUrIvVQJhGs9xXoh85mHdaQGTuqokYWFRqoN3sfAWOCxPjGoHbDa3xpdjSKUBXi5XBrxLHkoYGoacYpw6vJEHT68tk9YWJz4i09alkSJ6EkujiJLl0GZnZmqZicVwzJPPvy79SdnOzM97urqVbN4OFKWEkA+N8HyRqvlCAanCdeaPYbEVuTso7nwRHWB9BGPloqe3qMl0+OoPiGcor49EaTjA+l4fzo+no5PpOOZdDyrI1PD6XS8T4GQJ/bG+FpzA/+9SoMvb+7ehqAyzRjf01dP6U9OSDCatABKKF/NG6q9aGYiYbfoOl3acqo/ITrnVbNq+YbiHBOU+GU8xuFnqKIY/4gxenwwp9jF0TNxFsaMPkP04tscXwEh8x0Oevz9niDMapX67aSNMMNqI/qyJlG11cRMY1p9WcHSPQWqyJ/XVKYWYbcwnf3laLZQ0O3R/MwkpgkiJjTiukdw15amCV6SgrtKCIgrKcDr2rFp5G4E2nIaOZbONY0cTeeaRo5I6GX0uACjgLCeginBYwRZZ1L79YmIcsxHphEWtUKU5fIbWQlJNm0ZGYlc6xYHLW4ctF5ykMTLYQ2SuAMbzytWtSqh+AJvzv6KCMKPrW+1gzl6vGsrO1qzeWHj/KJxNQGopV/QhHYcZrFOGYCQIXzK5HcsnSrWuE5bOxv3doqnGrAp7+W3Gait4ii7iglD0kYEZVLYGYAfLMNG7ZRIgcuXgZoY08myQgSdAUlXPCXQWE+NY5is6oK7V8lNgLYskTuD3iq52aZpBcQJ3zPltvwtAlyVz/K3COiWMXBnMLXKWwS2j96SAFOqJ71k+cuFDusly18umFbZL3+58G9ZIJ+jmoXBr3y5cG69ZPnLhR3rJctfLtB3tdYSKD/Kp8peSLayWZ69MOXVmk/w+ih9lY0Q69XaR4D4KjUqMNkmyHSdEfq1voZ+uYbG0C9zqp3ZONZlq043agtjNhv7HkCEsn33AVY1Zgur7acP8DLAq8l8GljCttBh/gycMReI0nStMLVQQNG/lxVGsLIKM0LYbN7nJlxeQMG3Ko+s2m16fEDWgKHeswW/NNo2FBcEjdmGIej5nCILb5H/Q1AZG6/DsJ/mnKkzroDIwvuODyJim22cDQLNlWiZ4hvxbVO1bzuv9m0ebcu+TRC0vqP+bUJllXb5twmCVgXLyWPYISMD6YRvc3MIZ7cRtiBoew4AerWdu0MzwGHaoG/EWju+Aoh1Kl/LOXbl8Y0g0LN5Fufg02yX0rnm+IV4CpWrjbkr4DDiM/H9G+L715yDROt5YNn3A37oU+ufLwBaSZd/PpiHOnKyXZf2ww0qtb0bNLA9XQFlWwCjE8hnH4uopm3tDQBtQ/TrAWLXKGoglRHgo9zc8YXr+MKqB9zKYjsfp+DP2GzEOWD8dD6TrutcUat03dUyFrFNtX2uitlaq5jpVSoGtEaVUK8YlkClXFYvvlZL5i49Ea4TFLEtBipV4p4hBFIOO1U37hmAz3aLB1brXpXjEoC6yUNVIaRWrhqpG/UZfNrGheukjYnTy6SkMZ4pVY36ENbCZX9C31z1J1DcWaOpuu5i1iK2dUeYblVrC1Fr3bFIYV5lHbHNTSv1iwe41PazOAfQh7k7oLZfi3Cu1glYV8T5hO3KUWNq6KqN2Z9XbQyCgVebNNTZa9Uitk2OCroQAK1mNMpvgHasrEewevCwbMdglIZkMnFxZyja2MjrpYqqhhyA8BqDuxpsmNRUEdt6Jfgc8w696hzvh7ncApsAfPZAkd6hx2s1hRG0XxB3Pp/6rvN3xLapgI/XRN6T58r7mPLu5j2ep+SpUTGnj6c1+wf47GcRmUguyjI+AFrFkwJZa8Fs20ln/9jEVQhc4WOhc2kD96b+dk7ZirjROZ2K06OcIgH32YGzobjcm2N44oCvj61rtUKcO4I4F6HIIFDzZrMCJorHjfG24geiGfJjM/uCA7cgfcgLb2fQWSE1OJBXruvjyz1yN8u9HPauJms4jpCfGl/dgbJXFfUIjhK53b2aqOfgRc5tfPEnrsiqIiAeIpKks/wtki3kZ3c1EdAhSGpvSaIERVtVMqTa0kuWv1wCz0rJkOzj5cjAq1WzZN0VcgwlHpPZRi+RcLZSMqRGuL5aa5nNsTJ7CZIrZT++OWWzIvvVZDwKn5KvqKKx61VyCWdykN6i64yWhnW1pcE1NLY0OH6OMxtfCBx3yM6kJyK6juQD+66XcKaBH563mdw1KIVbMGyrMD3mVM6uXKc2fF9J0TF/XJjRCuQ4SatIjw4vZV/fcrpjF9cSGlVAL1N2la7VyV7kNYvbdzzrFkU2pQErY2Yte5Jn1lnjGawXVxDOQtrU+HXwssSpnC1Xk43xbb3at237voKn41wtEzzpKOIBrPJtklpUwXIsY4/eWpf0SXxbNIcXKLv/1lqsKGxaoSKOwOYcKwOtJ3LYlr5C35hZING6EP7CZ7xaReypKc/h+nYFm9RKIf/p9tRdE84UMrO+mv7zhVO6Z/rW+vcjl6yUTScknKkhUygecSrdoBLO3KDSfrtBtQqxKU8CiCLOSQBRmD0JIBGIT5KqNKtyAx2feF0SVKsecCvLpRZr+1hHCNOiqSoyhJ+qSDKrNK3q466WMU5lrN6rV8yWWsWAJa2omBVS64SEM6VcVi++VkvmjjCB+KmeYfld7V/2DCnQ5epYdeOegeBqv/AIZ+5VRF5U3ZhHEqFmFYGRuhlJOYpRmKQcRfCTEyiLGevjAmt01Z+QKqr+hHA2Y4qJ+pMrq8ap7CyXeai19VFrnbpQgH2LvxBOpZtWm64Y4HwYApU/zN0B4SxDq6rWCTKHrBNFWYrTy1JDV22MgFK1McLZdL41iooArpYumQE1KXJ9CDCa0Si/BZixsj6Rygqn0oNRe6dukh+nKdrYyJO9rypqNOQIcevdgirK+SROZSkepnmHXnWO92NEBWQl4SwGimXDjqewrntwN5+L/BFMVQNiBoToh4zmvLvnyvus8sZWOQS9yAWpfE08rdk/hDM/a5kaEagSyNDdSiCTmSDi1K+ubTWT+/xOKU4lEKuh1ckM2UGyiAgBxaawbF7y6qrWdFFTNZi0WoxEI5vCMseM0kqcUjIyGIkd4hVr+Rk9LGnMprAMxNqLYnVXBqPlXs9VuUlSEoFXm65RbpL8vPmZqeeWgJxRbpISlNtIJuSCMqqyl1hn8jOZjLKXtKCcq4wkfynn0dLIBWU0JlQpjypniRDKo3pEsoYeIZ+RvKVHxmQgPUKqkTSjFNUjEsV0gVRjEglwUbs2H679ISUSCQee6WJ+06KYAsdodXS/RiLB/rCtGQ0GTF0iqcNFdexqoVYYyr7qqr1cIpFopLTnkEiOpcgW2i9bThJry/FvtFh7khZclGQUpjCKLFrNaIZgPUZPoMjVlktCIpnyzsgT1Gj5GcFFPwAVWAmXhGSl71gukazES2L19iQc66sEEYuDkgtjuZHnkVLa8rSMROJFGokElokmeb4xeJchkaAn5zzwj1IOS8styzD7wfTt2hum6RECg2WylahIWkLqom9dIjvHwjuOioTgtcrKW0okExEjRuAQyoo0vXsVLkUUasGL7VnTVWurLnCRV93rEUxkCK3KCLKYV9bu+BpRwkUhqI1WLnGgSulE52Jqeb0IGaUmkcSStXrFbP4Boipi2TJRQxLJKoLqcoEuBJAI3FqJqAEkVvLbQkJVQkpbSBKJe1WOwEfdKHh8IiFaIsEGuL60yySmWtrXGncJWXWmkujBscpexaIevapnRmhIuF5ox2SR5bUmotzylRCljB+9vx1NK/jLA1zyaM/gSOoPSCQzrJlqHZwGlxIJrklKmSoaumpjo1llG+tc+FhIJ5ZDU+naI4kkGHkBF622aqNLclnhKnowShpUDHwVcZaijY28XqqiasghzFVDjrXecoNfG4DOCC46p9SAWmsCrwlIJJ75JKjL+4+msLZ7MKJjao6QSAQXjckUTMfnyBvtmSSSKcNFwtNDFA1piUpaJpFgOi05A3BmFN5fIA7yyNLT8sjT8sjT8sjT8sjT8sjT8sjT8sjT8sj/X3lE9hOlKPKnc4gimySKPAGtrI0o0vZyblFkhjXsxXfROR3Nr0NO/Oqpi7ctUlgomQUm4rKN7xt83ZR+dSORvalKzMiw4ODyFsqbnk8Ens3ME2t1aysze3pKkg18c4cO9Btvp087kuAm5307FRFRKBVNsG1tgajznnynDh0oK+mpF99+kGaf10OGZatvmIwXSQpiArtd0w6ZdoVXKR+m93U6avbqLctvjjYnh23CpiIXySszdHAHORx/gUQn+WW3nEb2ujUdtySLYLszykaC0VpU+SBnvuB5FlQrJoxu3lGf8bDl7wMatkrSIgmwO7Bbui2enLos50yH/H3SKyRd50V30af4X2fYupNe8iJ3qJ87cQBCJMlQt2PUEHM43OHIAfiZvzIYcpIWSexzp7yNq3Qv0JyjsODvmXjZVHrZlF61Ll5F876Cl9lD2GbcVkr8hJcoJ/NYksjxPEYI9jW3/loxP6kimofwrSyW692Eqbq5OgeFneh2ukCHcx2p6T12VTuUghepk+iLuMV3Ui/6Ft2C7CkhcNSs8oWPY71lV+ikvEtNO424RwnWp16NwKBWxQzHwyMNCBkk06DTeUomsU8NOgmLLxpUtCL3V2u1BJOqynxLcgwipKoNfZCqjQZTtWHRo2rzlyBB+nkpnarnMY1VW+v5bnq+q+dpA2u843mLiOwKUtVKuEzFxyWxh0jqsb4xTQ2rm6dyI55RqFQWNzyVRT26UKd1k+Wq6jQS0rhpWm6lb3eVyuNqb9kVmplXpplGzsfW1QaJxM40v5h8WatuSW1pVtnAU+kByZ5pQsE6qap4ZC9XnIQydCupx/rWfUjEqmsqDl+kqjhaISqenp2+EeNXPy+BtXoe4Ux9Tc9Hf4f5rOdphah4P++Kx3V/qngJlulDxitekiVZj1f89bzN9Z4G2StH1X4jt1zr6dat56r0bEWlE9/XEh5uQmHDeE6diUIgCs7KEA+NGxdn4yJiUCaxA/KufyMEIm6QKO6HxJIaEGJv7ZuQlnARXfskxpRMQymAJcH5ZRXGVUSGubHCKtQU1/HLqAOiEhLFWCtxFcFpdtlD1IIlCe5KbaxFFmEjquoy/bmubDb+Kb855af4FhK/vTJLVgmyHBJVPLlDf64uO0x6crZ8kkac0Jp6/0xz9jArar53MO14F729/bUyVBMnO5msNYu+rAPbUKztilQ8/uzZM5PiRLd2zyJP2cfJ7lkdm7dgUdAs5l9K6mYx+dMOmOGgFxjs6dGJmwdsOqndPXERUklbllnczd6jN5RJMGbbw5WizX3TTprFxC2DqeKyG+CNa1IsOtghzPApcJbbrcNyONRQQdnOaj7PPmmOt2qXJXkndHHUSTrM7GbwkkTn3d37MVRV8pfu3zY9mOUamaP7wq2uHOZCib68Ia5QYy9v520dXtAhVd69ZhbCNNLJS2dhHalwNw/m9vR70OtZKciEUB721ztVIK1g4aD155ptJNvTn+cGDX2NxtkkV+SLmJrP9XqNFQ4vHWTbABtSxWHuiUFNmRJ1URdrh0GmcqzZPVhHyqxKiclNlXKzUvLoD05JB5D9XReDxgHWBen9mEBU7+ezsBOl7lOYaL6LT1njT1mjemculUWSvkTTr25XH6Dyaj3tT83AINe9QddNxU5RlHhNJmupPTXXHjnK7XfturnrYNEElqjykdUA7yY7rqq79lyeyatmFV2EYRyeaO/+Y+jmn2RXgYdjCO4cMlj7HDbrD36MUzgSjIv6M105Gq6aQeQN1ZdaY/dgvtYM6SvgcVEbvFbEeIqur4geAO0puxe2fnRikdFzEZ6Yl7iM8UVbX+8+Y6a7Ek3V+oz7y4z6S4f+gsj/09Ffykpetb/gOZnDNYO5sf6Cy5Z6fyGResycU+qT5qqU8+P9RSnpMT8opfuL0tJfIm2nlpb6XNFf+C4+pcOn8JjmBegVEU9n1a6CLYiyiCam48xUHUdDUNXXiY5Da8tmAcJC9J8OPUP1tbzfONGKfiOrZk0t96m/fNv9pR39pYHNT6PfmWkv7xyq9VTna1brHNiFjDqH+gey4gmMGC9tbSbDWVq2vZeZhG6wV27E6R7uK8iZLvxaeuXmPf05W8XMFi3VkZz12xilaN28R+GAOtu0BvG/7u5t+mzkgZSLZElqAm64MlN197CYkY1d1TbdDKvinmqEnl7WNofJsPSgY2IQ8kuyB5lVI8zGZayJtGIcn2stHG7afCOjn7JodDTqkt/vjoYbMes03Oa5g31jcvvNpRlMdTn0+MSOjK3n8cv+Kl3ZkYybNLfmnee2MEdOZ5grXxtnxF+XM3RS/wQ1BWFAQYX41F2tXyC3loL7kK74QgMzsRvzLfdiW/TWIyexdaLO27Jzi9Us1jUZnDQGLXVCfaHYvjYhgtB+WPZbLGHYZA+w9JEX6xYWcySaaauztYoJhXtiJHRudrHb+6i9yZtvKp5xi4xPmrcUrX06aflEZm9X5e2bYuh3ZIqn9fNmGJmaJbJr8DClJWzfNoywKEz2AeRVnKCv4UGOd2Oq9hIKxnywqwXPgP/hNp2wRl/VOWZj8Bo6xRkzPPW5/EBsy74wwWJMSu46m6922BlzPNvJ/jhldppWUih9TNxap+b4kocbmGWR5lgXK3aOr+3SiVjq7un2p2W4rqd5ixKqivj9ZEeFLI7R/Pz6bgejm68yr15FeT3/9SLZmyzWxWBlK7yrdXemhdmf8tXOruZrRU2hhb/VAQTxuTJTsrh+pHvpxI1x+SihlG7NOxc3z3TUMn26KAne1MUUn5yvaOLXXOmav5ztar7V5xc3fzW7ovkOndNHjvsaQjIf/a5Iy2sIrZWu33hpC+dfvnwrBtk6nb688aiOWy5tPawjYgE+tJgTCCKgedlNml1S1oym6E5xCrPLZvY6CSCp0ambD7lJTnl0PDrHRpLj6TncDEQDtpyg+JKsvRsZsCm3b1ATEImD7Sa5yONW9mdUbvZd1ftZbLom9Nvvy74ny+Bu8Zqm1mJ3AxYj7trKOyOylGaax8MArVM8Mi+f8P+agdFSoCpe+RJmieifjsiekuyxlCQXAo39ov3GtzlF7Srdfk8/DMXKHFm6Y0DRf5mTRhljY+dMEYdXybR2tZaperFrsZl9BZAsfTGn/k470Uzf9SUmvU2qUcQITYq/jODCkq+QAn0ZEfcUyc3bGwYLWUlmZC5lnNYKrkaU+Cmz1Koc0ZRqKWAxj7K3iPHG7kKVC7QhQ87eKB4cq+koHtyXMOiP0hVtJ/fXgEmMSs4XyXgge72agbqXuFq62WfOjk6qkYsrPfzNEP9NR6aAe1K3dOdXPDgI+tnblMu7HGgt8iiemo/vc+/QZwAqjj7DiZGu6XpV8dgQjRdvln0VxUOvce6CbVq1YNThXk0vqXwzlM8VOpF393okt6N+FYIGT0zZ5yfYEPNnsjj/p3GG0CnOU22xBMlHCMuz7nUkVoHDrs0z2RxqNeHAOA8vIQznWO9YqFi4sETUTB4m+2VkPk+Ox9dkv4ddYnHmFLaRn9UDv4FJ7Af16+QfUR/yfUI31v+/+saHG9nv6rcsbSeLb1WGtXc8RPLN2Rky+tvp1sThBatMkeQijODRicrI1vZwMpjV6ZOt6hQAMp3aqhaRUla0T2j3NJHjpsToE8x8oU+4CWCzyHIqtDNwqlzBHgOgMlwVSJ4CACvJ9PBwfxOt3y7WsMoOkTeHPeTOK6j7aWSRbh+1Sn+Wa5rSND6kv50aNkER0f9ou4w0uph3DoI9bqaO16OfAuo8oB1RPqsbXIr9P9dnDwybd+KHg05f3kJjBiB3O1ol3VJomE2Lw+ZBxurmYfOooAf1kDJeIqaeMnvKJzEn1nEWs2QdcX6D9wxXZzKRDGPNZkYkVINwCbDQzm2Eg4XNZkJnAPcC3TQmFwaYCV9itg9ELExDAdkD/MCsJZmKgdnQe0vUwSBwWO8pUGvCeFIOwtREMdwYWHEY84Haixw6MqpTbhvQiY1yCyBpKqETg6xmuEZuG8rcBB8pN6CCkRmbckuwVFk2riq3hDTNj0zblNu6MjfRjBXzB2Pn0k5MeSUEOSVinVdWCyiEShzGZmLKaS7l5GwWAn+xRt3WQkAlWKQIJLLNItBIWNI1w5xRntvCoq5JG9hGUCBsBA61MY1gSMEeSeliy6/SJJAbLWl+BG5obuI+80yyHnMpTgn44nFwEMBlJxbkKH6pNRKleZkTH61QNrHXnXhGiUP3AuBY2q/JqqlEQqWidtJpJS0ZpcK7bM4l7YPZqkqqhBGg9pIwEgMTcu3cGPZ0oE2uNLj4tmOSDtrVBqZqU6swMLBRXlSXvSXrxbRoMv6qjAa54YIJo9Uq5Q8WumQL0TC0tPcrf0UWiYVYJbJ/ZbSkGElCEu26zInnI7Hw+aT9xs9LJCbqZuBW85F0bSRdE7UjFXnwbW3QJt2KFWRV7RD4vAaSyU1B/ec6ALzaT9Tx9Z8bxuBy5sg6osh8WIfftFuq/wQ51WIfi5GnGdx4MK9mr/aefkdyC4JChJ3Q786gj9qief4s83xQYxhH1hSJVGElU8UB0SRh/ZIIJFayVLSMZG7eM/vEVJfZOn/F+i2xWsxbma+TSjzCFCDHGqgUU6YyanpigoastHDofY99B3k/eRgPzbmeHRFygl0w4oskS3eqrEZvUSGrQiRbpDKcTTBwrBINRWdPCj2rHpe9PNk61Dgy4fhy9PLEdRi9PFnKj14uvZ5KU7482A1Jl11afYjTYfOXcNsZbI9tJbfDkLd0Z9b4S3tltXap+hdpwopjNAfmETBzWTsqYwLbm4hzb4WdjGpsREGg8spOZE1pI4B+Kyxogg0y0myb6sI0Ev9sXOjxR0ahHFtX0i/sTLBSqBMPvlJEE8ug0qhP2Y6y4l1ouFaq8mRkKO95ngHbdw7Ppu7RYPEeXnJ0OH/7HfSTT93FtjAqNcVe8rdiOlIzT5KoEuwTtUHVjvbBOkY6Cu+3o3ZMZJxaJ0oNW3UiVp8w03LNSpPhVgnfjixAdsGXNPPM8HOltQWKvblSEc/6YCpG+vbk3c+eA8XnpwIq8H7F2PBHM9u6J0GKcf+BFiKvMKmq3QteWZqDitPiKq3VDim8SI/R1iRWjFGykpuHWi+XsrVeOxIbVF1V7QSzBbMW03m0VLb5bPWSqn8gPGGektgArgjpfkbVMK9Ca1SOK+pXqwYCjCdOUKJOSHNt7Sf+M4VLjbWGrJNTA7C4iBZT73n2rZhqv5qGVVe8QdIFu07zDBIPLFmbaMWZX04wMGlgZWlRG8LqqHJW1bCLIdOKOSFySqIsIWMHicfkrKA4jZM1TJaQaclyQoO0NuXc+uLbU8FNGXHpV1h9OBy5CYQsHA/PN9dI6XLk4dkqzDiOFyXxv+cDr//uG975gbOfZ+vCCG4Nn3rX7x39xBs+d9vbDl/awi1ga/iNv/3I37zz3u/d+1tcoNCt4Zcfvff0Z0///Qc+woUjEo7pY8Qlv/dDbEhenEEOkBR4O+BvO/uVZutwkSP3H/vYI0CbE1eCQYEONreWaKA0G8ji2oKzDWIlZP/mBTGf2juYwlyYOIjT7SuLX1fmjezr0oBk/6QtJT8dcJC9i+ISFmcffER7E9wHye3MmfIXoRQVXV0grOJz7POTlI1tg+IZUniXtLj7449ouxTL7X1cK07WrzDJlNumM6NTlpDaDoqpNX049c73Zr9IgH9XDlARhb+YnwpyeBpc6MnbkKeKI7cpsbDJ8sVc0AEAsLz0BJeqV9fOz47O/XJlaG9InAhm8Ac1shcmyV1azZQj9SY5zIlDu3bEIA0bMRxcRsh5zxuTxTQwuZ73fh5I01Hpj8wDx6El869IDBABNszrvhlOt6p9FW/TtcniRYLw+J29Vdsq9xo+ILtCEAe+fxx5Ufj7zISZO2oSFztyz66Iuc35GuVOVd0HBwBmOdxvR9F6lB5UKnnakfrgyYbwa2EQ2Uk9zd12YcxVr0QkiZoOgDAyFWzVuEHfz+1sO3NPHyQW11FWBXW4qfLynWlXn7KUiqV4/OOzqrJaNtlH9LVP6uPc/8HiBdq3gXCliwGtVjLHNNdTZC3Q2IonHIglMPbxxl69UpE4VRFUsIZGeg9Al4quV4PPbVfzK1A/buXw5bSdVwJ5lBJm/fvikfh+O2ZztVkrxEtOdvTqbqpAI1TxNDKqsbjshB04Ra1gdk+tJPdUjLjXtDXkUiMJDldDUQFlF/P72uW71Gx5T1+nsJ20XIZzUgm3JOo651Dq0FfU5iIz4EyMmS/6DLc0u1UkrcvSyJDSvjzbUZ7pkOc9BikD4bj66w76CVVdmwIsq9ZnACy68fdAYo2aW0UVK4e+pdjy9O7ylB2/erofY63RU1qeN1cp86pgCmiv+tOklN3EBTy8tov7mns8fymFFipJp+WFIFiYIBIEjEj2KAAsVC8gq9tEnO1mvymg/wGyx0PbJx4JRcwvFs39iYhifkpirJjIEpSNO/h37U3ZX4tg3MmQajqZvcOk/JAfpAFkXP8bIV0nybctVGnQpXhBaxvgpE6nOCkcTPtUi7iyzb7j4LWaODXvZa8XjtnJ/qvczfHZykLfggZRquDyB31O2fhH5KVThJE0M4FPv0e5Ip6z2JlAcKS1z74m6FIelprzyqUqzY3VnMtkOzbX84XVhLsKWgZM5ZXDs24CzcCM5HBxaC31kSM5I4TouBSvPkmqjlxx45OkpzgG6jAoB2tuQTcD5M+61UeBw72HZ+XZbGL679a01obX4WP09N72hrUp+gey3Dwx2HgEYXXjodrVl58wS+E1crZciB7RvOnfFefvdzGat+wddG+WxvsW3BjeQlEEUDuR7pBCQPU0How3HWATy6K5t78B7gTEAo1azuTYT5qWefkX7oV+TV9wNGk2Gc872OBuzOdRP7UO0y5cuZAd0Prds5pvZq0YmxKlA/l0J6wH/phQIS05E0arP0PtgZmEpoABgjtourHU5KibZjT44emgMk36wtFTFE/IEU9q9qw/CYtixZNT/RnENZdLKlD1HBTOIuhwr3j8Eb7nreyn1MGQTfmKXMxCHDMPpqkt8TqLB5L6n6tHJqRGJoz2BGWQSmna6mbRFwbEalbqU5GaSgDYzWf3CjTQg0x/qmdnfgc7WpI29760v+AVAXdVewZrpVsF0tOHLWgRQ8kq/YM8ZVt5MFm0NV8DYUBgCjgabgtaS92SzlX1oVdQ9L39aXfBtZzmc8UZlUpgs5DL4vHqF9V1M11HSySNp/92b+NS3qaiJMltxk+sPytHsyFIkw8s60z8B/6Y/wAg3cj6kvOU3TTgf/OWPScO0W1QOt6yFxYScuzGQ4v//t5+Ns2Gcz5pmO0CZk9/YUQRcs/pFi11Fmna2Rf0it9v7ZGeJ8+ukR9X/0YEyDPVSq94oZxgoszO0WWqn8/Ll3XF7mjeIooFnKv+GvGMnHym1H3PqZHlIJkDNAMQQYaoNvv57O6bdHnfoHuTlJBsomjMYFDkc1oyPZNJFTNbnBlViVsbQI4p492M8W6kZJqLlE8qZQwgEGHH004pO0SOvuomkepN4Jx8KQSb3TdBREnqePhAkLITacO8Be04Em8h9PPA716GpYjXOFdvEDNXGjIwVR3WirdTKe/XBY3C/N+115hzAqD2El5Kf5L3TPKVg1Wpm+f8Rr69fCMFQjTxGwmz+hKV+SVRXslAftucu+7YS+ValRrkU/xuJS3fXXIGVOuqtkQQc+2wzdAKgOIFGsHNZDCD2KD6VSD4Ps3K2/lkDW+FnU48IKWlO6bkQaK4e7o1fXjCU608yG5vFE/+4SOidAU7YqI4w09phsszcB7OX6/g7Zf4dIGzC32G/LQLwoEysKxRzGQ/jkhJiqKffSVkhJb2amfQ/YhjgBwmjgFKql2t67RSXNG8MS7eYEmi9W85JEX6y+LG1SFiULJ0g31xdUqB5H52h3EOTTh9+/0eH01eNZv7qBqEzF9AtOJwXb/LZU52mJ8pohSwzM7GLhKyd+PGhYMZ8Q12Nl44mJV8qlnec1VvVsphXKeqfdq7Tb7p7oEDUTx4+KdmmzOzUoW1f3KWeRfZAp+7kguUBFe8Wh3vQOY/0fRk1dSezZWh+uwUh/dz6fLGC+OaZDIdDxSmSxDfBaW45EtcR7H3jIgvzOtbC9F+jmQ+nSjUeWFS7N5GOcS0CNVgvKPAq/ausVdp5mO9iRLMcoFKnKb5fT00iByuDwn9ZcXh6CM0vOh82qtTt43s55182eVm9vPTLNI8dyuyvp6T9t3YIgsCBXqlqyWyPpA39zqTnY195jxQ0n1qop2NG6unb4jGI5NUvBsQ13VhwF4CiV0Nq4+2U4i9xHIovkXXlIg/K5W0RFF3bTE5XNrst9FDRhIhQJR00NvHS3rFlltODF9z2x1Hjx0/eaR5qD/vwaDFx0pv8u/twXUqI3x+EdD48CI4U5X84O3DI+WPwwAct7rfSAxOb32QocEEaLfcLox7HPRLNmb7iptvUGT4mb3aMzBd6Ji9U/7F3KGK9t6Lm41iAySqW/KpmwZIbNsRpdgzSCPtISP9XW/3rPSAuC6fKjbfkr1OGyfesR2H0/EIP3JNcokUIO1U886xgg8bL2dBZmxIyGC1maRmIrHGuqYmFj8mrpuK6VdlT7mfXIheWoNq0AxeGTCGqE/Cnlrnebi6ELtajGFdW7gUDIkrL3SvIlOa+woKK+Fw+hZcnXHvkkFbgo2yja5yofyhaTlEvmjtLSb3DagJOUJ7f0vOzqkXdRdGp0EUKc3bWmVZGxlGzByt7DH8T8uD8AcfCqBFSUkTzCmtoQqa8fkJJtjha1Yktyy7LD2lYppEINBTcnCs3cL7sf61kOF9lCdvDQ3d++6HuPcn6Lfd3+nOqtalqVbv8DrNzCdbJZZ1NxJ8petGhVCK7EdHpwjYNbCkhD/OCrE5pUCglfAvJUBtb8A46RWdfhtt9gakyhf1ma37c/y3bthENLaqbyCFdigX5/sLXM/oYxuGDOoTd+YLd/zSYM1BdER4uboTNRO+qu9E2qOP3svCQhMA8R7tr2EQE2PoX0UIi0PDFwnBhMF4cLDx0KHhYURxRcA/ONhwr1AB223lnZ/atvfE0duHaJHAcvO5g30H/z+I5LdeESEo1Lq+iE82t23eOWwdGMpaiKwPHXSe+WrZzZMdDyoToo70N0oYnDuUbz7A5yLOHsrXHpA+LJ89lG880F9IOM96zLm0EK+DUaXjHKZwOrL8iAikJiqdI0fkVevPheVX1k9Jf752pEZOyuCtpWZ6zUiXnHTO26RCrhTKpS2MBMqkDr4yNJsoEnC6Heq/q61MxR7AGtFrIwGYO9E9IgE+9A0j9zcaWxKhCUzyZYi8CA8WZTaK2i4d7R3IpgsVzx05XE7Fw5Op+xX7BTFApdBI3wB3JN+S/Hi6s5FEG5SaSRniU7610orP26BgW6UQV6iUyrzH6jj4m0m9LZvCZXY6VtdeQp6bksfYFfYA7D9KjSsNXnrLvIzvCho/9VT5Q7XKvtQxbywTEPoo/Khr9i53taoty6SClfjQPexGPBSjXvJpfgmp07i51gyR2bzn7bKItIk+K1VQPnsHt2pZz14r+V6dJZ9ezNvvHbYOcn6HWSOQPNAnvVxhang3RGS/nlcaoFRu6MvvxCKhHOsGs3xjU3mD4Z7AMnqt9zOhjh3BtOhPARq+2WtddGhCuPole/sXixlzshlEmbubhGLheGMQZq4OFk3eP0+HB5r9Z+h4rNl/po6v7J+vw5WMVzNubPZ1f7Of63i0GfZf1/f7OlwmwrHINkys0jVRMRyBGQY6XscQ5XAJwJvZOvDCVbtMBhxvDUbPtf0LdNgh8q95OlT4Jah8TEG7BGzlHT/Rv5B+/wKuv6DY4csXa1F+QZpAX6CGeIEraI7JSzEULnbHWNQ/VqOc7tpnseYqyom4ymy7tEhVTi3SnzHbxfPsjBJAaYoEMIqcpLnYv8gEn2FrCRUpXrmwZsOHqhITWSwSM5st5S1yXRxeuoSmDmvRfOCNKamYWyPVLCoRZdleHL5oCevIw4u3L9I8zFy+zHZkcfjcJYWAzbPF4XOWiBhHknzjonlE6xeHa5bkTTh/xuLwsiUmIWKFLQ7nlwhr55xgPVGe4balwbMxbGNHtDjcvkRAPt8koEU+tzhctyQbzLy3OOwuEVaPSRYK0tLguZFI2Mm2xWFvafA8XnP+4nDL0uD5LsOORVqyneeLwx9fQlPRzNcuDheW1JWpr+F5SyjnnQO05nywONy5ZN/cvbgoW5QLFocTS7KPQvnli5ywoijviUXFNWJ3oB+Ti9oa5c9cHG5Q9iiq1EoXDeeWBs14EKA67y8On7/EDCP40xfbwwuXFGaFweTf8pLccoYXQr9aZFK8RL3kkvw5RIvT5a3UN0OCnaJ/NnkLg2EzdlOsk+Qw0Jh4Noo03X0WLcvQeC6zv34+b3GwlSGyAd6Wfm5fHGxgbMzlz/PP5y8ONjM2npM/C2drzmoLg2E7k5PublocbKT7Pz/f4Z/PXRxs6l+QzAPmoXbZwChURvmGUBaJ+gUvp5FvxIpYR8jALG0Mey9tDS1xLG0N+Lla2ho54tmtHFjpbuSw9VKIOo2cgALXc2BZvI4DM9+1HNaKT85irI0akIQ2aeCFkviQYSXkMccImwapCYUfwRSYQPIJQb3MXAy/6Q9NwQGZL0FAc0CCr1ERQCqHBGJXmKYhda/pHr3h+kN1eoj5HfKpYp7INHfF7RhRMUwNETHPFJNZ3Uf2GfOSEi5WvA7N637l2CO5SRg5N2Htkma6cgWSPKNL9zwiZKgw1SvEv9DbR85CwvPEKE8ps/WSKlPFTatru5Mb+VGeyfXtKE/JILpQ5SlygF4y8lmSXlJlyqo8RlKxXWg9T0k44z5mwq3vKE8xcPSSKs/SC02VKfJMjXtiXbP5WaEHt2WhvHB6jUS8sWpemnLzBBBF7WKCxd624KKimHkie19TKyCcWKeO9ab5JnZHkDylhBfT0lmHSBDZ8EfknTV5ngD1HjnnlE+F5G4CnQIyZ2KDWBkPBy3+DWeD1kY2IUxUXjzl+TPxVKRrKI31YVlga5HU8s4LxtZYZpV6fML6fNcQxrguM9QJfy5inb9WFtD+XDFvNL2LlVb5lrVafrJ0s8FeLpFbJPklDwTMEFLl14tAg/6I1PTtejk0asOfiVsK9o4bKIyaE43HLSSWkHbg8nZQeb5ERVHVCyyKqmKwX62cRbogl40VpL1KQTSLgDDwUHxskFWqT4YSVH0ySv0wAg2XK3V60Ch7xjYjtXrBsrdJK1JJnhPQE3gEBoJUXobkpp+caq0L3cURFPtdpi0ZfZURE7thLMdhIVkIlRETuYRZow4whQM04TJ7F4XokeUU20UBDkDUmGQKRQ3t4gQY19/9Pslmi6n+XPENnc4Xz/J+SKF8Xiz1389YjS1eOFu+8x1Rj/b70cY2rDsainJIr1KUQ2Q6RTlEjFKUQ0QuRTlkTCrKoequ4XCK9/vUQRbfn64SWZEtpq9i1fkNnRJqrLFvMHl5478JUSWW1qWXNv48nRIf8XQ6xSDpVDolPuJJVMKARJPFvMzYnPX2K5oilpDzsy9vENFsZ+PjHeSB7o7GH3aQTTj+cQchguMnOxJHdjQ+3WEXyvHPOwjsHD/fYb/SJYqe7fk+hlHVzYb4u8Uxwmei/sEZxnm6dWySyjIKg1bo4sabJ+PV3PkPfIff/abJePfdk/Hueybj3ccn493vmox33zcZ737vpN69s3G/okWS5xsER79x0ngFxZiW2lf3n3d545l+a3PHFU0Ko7P7ibW3PW6/n7p+dlw9C0qax9VvgIoNFC1IcfyiU56P3HNiuAOipyziJN7Ht+DIltzS13xjYsCTig7HNeXlfPj0/SiwWzL96Qp9UZDQPxBSRqNgo+xuu0MH5UFjuJkpES3kxqeMKPx8Kb+i+S2f7mwMLm/8o07XXt54o3rL5ksbv2J20K7GXR6Puxq36zi3qwFq1FVYw/+tIyFO/1fK7TyH8HRuz3RgT0b05Y336bhpV4OQZN184y7FkezmGwiwqOMCQRl1XE9QRrtMIigjR6150umzspXB7NwLsDEahSlUcDFRiCDirFF0QfcQBZ0ro9dRpKOTGhBEoES1ZvgwRSpEzXB543MyNqdqH0eiLSMVwsuPvCAqKT5VmdcEgZ+0cftN4sFORzi8T+sccVTxqNDMqlzSUrKgQzTiWrd4AghORIiv+Z5iTknDIxLEp3TygLs10GLax/GAryCIVFcUH7FbnJrwI7Lt0IOIQgTZkxkUwKkV7AThbFHCqxSeIAWN1ZdwYI3XAVrElLS2nenjlcB2ugKsWNstelUy2yT4jASpke2ARaueLiefd+bxjoj+FuzCZqIW0icY7RPnJNiFCQBmFnf62VGIIoSgmgO5KlBV6fytCgx0Br68OGYTpsSJabYsfwk2En1GUY78wkr0CfiGndmdI/nI1HGhZwmqMWZxbVDVtXJawhUp0yCH+IfG265MAX+8tiaWup2kYTxeRfTBF1YN9gm/6aUb/BTDaOTnKMICsZupguXA76yBQqV/8dL5c3IWN7GM2Dp5DmKr5XSX2a7Bx5mtyZqkXlMS4FV1VSNIVlUzlfXm0MKW4czjN4hFp/WinyCdMDEA7irdMZmJ6eb7/kzMkbWAhCft8FJF2hBAHrnD9/Z0ZDX2NeK2SdBWD6p6taR5uSCsPk9Sck2aN2wWXqfCp0SEKAosruRjmvxqgmP0EpFEK0lk9a+AVhvwLJ9hqwfEZ1HkLGeN2QTINU7ZtBO1bxtj2WIQkZijVYylRDZ12cQSvcNXVpYkQxjNhkSZGHFFwzlVONUyqBbhWypTiRTkQO1l65ARnXUsWovEztImwexQibAG9FC1ih0qfnctYIvZoQ4gp4AqveZWoVhPgNiJP9UsrjQJzSrBF4vc0cYazjr40gqvLbNnVgN+ArrbCcfWCJUoHs55Sqfwr8EnCYPH9Aya7d+Q+lEcrnuYeMs8FqSJl2kyXDXvuiPSZycREp04XBuQCyc7GqgZgtwAi4MdPZLcBuJPt4DXFL+6BTgGCon5K4pAHR9vOj51611Y9uv4mSaiCMcPSsvI8WGBaRxPC9fnCJa3SUfwM0hHO1ogcrhm2dH6qDA+ju8Vrsbx0SaiD8d7IMQI95cqH+cVxeSr80372VtxOvXqfP1+gCZ5DND1uf1idvj6/H4wprk9xeyr87X7YfwjiznJ9H5ZgTnJmv1yq+Mknf2Kz7ynWPfqvCsWD5ObU2/cD02Ck/2KiKSH9sMg513xyMZ8fXok+X3iIfKd2T+YcZLJ/fjU45Qks/vlZsh5UjI5VVDKLXotLyDtuv1wjIirTtrJ/VSYAi5B/+BOj4/19Ww/w4tPIo9nKDuotOVXkB0p/fnxFb39VOqWnA7Dj6n9bNr4UB7kNYyMqpjKgwddKVHQqf3sCqAjwUmaaWofBcHlUe3XUNvd430b1tI6zmEtqiM216A7bSQfWpgjVqMivOU9cwDZhxGXVUfCYn9GR6ytP6gj1qaiykn5+y4d0ZCJLiedNcsDDj2wQrUwONZZTfpQ33S/93go3itTzi/LJjq6srYtooFW/dljQuxMEUT4s1B8V498VkHW2QW5d4ryp2bZ1SKgEVeKLzCG2sVr30TCX0PsiLFAogW8BYC/X7kv36qyMLz2iZsjE1ZTce4pS8MmitLthpPBqUa2S+tRvg31Tqv0OSJRqFm8Vo/Z/vRhCXA7iq9yyD4qJZ1ZfUwnb+61dh5qHk54uLFn8HDGtPBww+NXByyeIysGHm6gGjxc+x3wcIPbVwaKPcLDjaGP8HBD3ZcFqJ1RdYGHG9UGD98QeDi8NeHhmwIPZ5Y0Hm4M/VZt8oSHbw083IB9o39ecfJQ/yIa8yIachsIL9hlvmURDNdRIxYWQYYBgkFkDUMvMnQ2LTIQQbbbi3l3EXyVJX7at0DIF/s7kQyBkIGzCe0hjRgQ+CIIKPdYWACyZ8jJQPb5MmbONy8CQecbFgGUGTGBVQMbA2HnAbbOAZ4LzNUNvEAaxO7LLtMg9iASrYF2x1uBsC8Qc8EQ9naRecYhbKhkCcK+gN4EGD2CsLfI1ZMhbLldASs3hL1ZuY4g7HmZRicImzEyDmHjZ0DANRC2AriAsQNhyyEpyYCwE5Qs71lkCYQNpIUSwBexqaTaBWFPSuAuMXXp2RPyjbGUolHGj21aNQ1ha0ycB3yc7xSEnV4hrhRwPhC2PUfFxY4gbOmZu/F7c35Rcfz4ww0p4oQz+CpKBmDqi4RlXwSmnNDsRdMzoG3GD5gE+TP9zX0h4c/OQ4/wrEW68/NAsRMs30ZF8cy8XwL3z6d6jWAL6n9WfoGfec4iHXeQn+8fuVD7EXLd36qJzrCxYWngZ8HO4M2ClrcFfAx9QFAMYLIhbCBtQ9RA2QmGFtQMNi04GTTaeHeJZ4NVC7IGzhYsDRCdoGeD44DgBr9BpAVvA1oLwk4wNcreEkk3Ug6yLigcRFxwN7h5Pj09/cFJbEFqsLXEhpJsDQFb1ASxaxQtbnsYd1wrCPhh7Cg+rAmLjYWoDiRSSDnT3K2fiwflmSauSe6E7W1OO5GGJZWE1xXJFb4thV92YVB+/NsZKjPI8j/EI4SL/uc/wme4mDXWQQEHZ3kG3B7LQL8jA7JyBtpXlRlsXJkBt8cy0O/IgKycgXhIZQYXrsyA22MZ6HdkQFbOQJvGMoPHTSgbz4H7Yznod+Qges/21V567kf80tVa59yPROts+pc84ropuv+8R9znUoP6nogjykmnZX+2Blt4+8HhR7/41FMPgkUhfCtcVWXUd93B4XdDdNets+mWbeCuH7ul2F9h8yWgeuwW1GHfgkfIMlvdanLrKKw8u/6BzJ79jSh5WynbUT4tb7LiIxjkLWxXuGg62m/hOcNsHOO2H+mF5dglsTVoFNuhY9YdG1XsQXhfl6AsFi/XXDLmDBh8iCD2UiMuPizBq+xaQ4Q8EU+PPC5EpHjXn4f4UQCisozwCoWUf8OpRrH0zOJLj/nI5eftyT4kUmEbaE1CFpigjWe0Gbu4+ezijtd9olG8dmfxwYf+oJF9x5LNgpSUu2ctOWWDpmgDlrA62Z/SShKqyEDQsthIV8mxIJTfoOxfBTOMKUq0skfUAbDaEdTFbiN4SMCxfLGC5Id3In6ICwM022xMUw/h36gn+mkjex+zYnqg5tBo7BF4oz5PpeF4obn79cQSoviQ8hmy6lxDhTYolVwj3ie+1DsgWLUl4ZCByD2IWDSMpFIzzdR//QCt+P2+AM5Yf1Is0WTnBZDiPMgLWtlqj0oEqxeuo8KB3Mto59gHXLIBxm9tWQXJ6G/ND8gEIZBsANLaxVf1YTCnJavGZi4c9Ch/w4bJlK+NT3KRvZOLrRFlJLrn6FWIlLxMHiNZwyDv6n1c433XOEApCLesmETMvVBd5hJBeT2oaXoLCo59VP2j7VcBix8Z3KT+EZ4mH23fsNe3i/NeVXxxsEd3msV5Nw5a2he3insviL1qGgLavY6GgD1eygim7JybB3Zsxdl56pWekuRz0EQ690oaJ2YnmrO0vPqhCyg+kgtotj13vKlWZWJDpAaw1O8d9+i33SQdV+uGjxopo4uHNQB19+8mgT6n7LmNrwx/BcYuAU9/JKmgw+BXIQYe/N67/+n9//nMr4vrNhbv8iiulVe9nwyVhw8/+JeLb/6bU/d9oroj5CwM7xXGb+WTZVTulU8KYrNa08EwVz5pLyirPhm45mp3tFB6pgebrYWjkHNyazpDRyuvGPL0FFftzrhSPMokGZesMjIKJFS+qb2XTwbZoEjCTVOAzCcFeVVKWJukl4kdX0IP20tguC1ImbGzjHuyYY6MILjLh4ozs6lyCFqGGutFMAyn3wjo1muCOUWYjdXqENQyTK4De7WGFIRSgOxqydmxrt7K8gSz6g1Zj4njYjW3gF3XG95BhCrEl10Wny9Np9zuJKUx+la5Kvaj6G71k0dUq+FS3d5X6iW0FnXQ3CZoETVrOBEPFT2QnrIGYohzuyln8rQ3oHqZcz3e/jlXinpA+xV7Tqza+yqD8xnq2GaEq3Y4WTfYhwK0QDeW/CfJRpwPCtGfsgozB8UofQsAZCgBD4TcH8rhMC2n4Dg254ZkfRYz051fsSf7MmbcJmkgJ3x0qtU53PNQTyiifSEnJ43MYXmgbNsFwkm4/zHaNNkwvFAGhGFSe4LdbfeE3dWyeX657JvEOuMDwpDSB/ajyXZSlJgbw6ITvb2yld9pXb1Oh+G3v3L69Jf/6De/9EXYDWxZrvfF3/lP733oxAOfefePHxzAxLnW1z7797d97SvfW/qfT5AQ/s/V+sL2IeAU1j02eNP2UtXEvskyYa5ZtwWzffjJz3769//0D9/zF8NDckF1/tLwrje/7313f/iv3vaOw4cAbFrM58uSTa1IJivZbHkyvFYtSyb7YNPp68lmViQD6pYP1HB2BhwWX027q0bS98YXaq3R9J0XH2Xfm9ZXAOMw1mL90FUwJSTZqFcGKRUP0OB+9MoWpRyef52WLeaD4Sc++Rfv//p//y9fec4Br95S4EwNJ5fsFNpQid3kXyelQZxej7JmHacztQ9a9jWL9R/Dt7/zQ1+5/Xde98vfaRwEBP8hHpr9YR7KfoiHxE5tHrBzH0zb7fMtZ5WXV2vR8any96py0wqKWCYgQtx72l3eECQJedRkXvZbxaRQePvKpmXG+8CyMgFEAeicq2D2goBU5MXdObfVpSU6KecfJedleW1aqr/r29/8y6+/5R/f8h6Y38rJ0rDFBAuJiBgSEpmB7XIUoQRKxahjOL/pZZ2/7KfDPt6xFmvvQp3yjKNiVVbv1KVclwQ+tGWhJz/HBTEzyt5Ojf2YDLDE6G29UJAIvAKpYwNXZXcWnvrk+Fx2ZraqZvb6TrcUVI5UgkoZcyypaMf8tIQJd1K4Sqc1ShESzujBpO3yg/j08TJCoKmYmEXLAlkRTUYSiVREyzKTCDR6x4g+NvaOuuccg9XIEIlvpAAKUgZpZq+W+1KI8Eol6QFMSQ5RJMFIabSsDBKJRkWryiBJaFS0EW9wrGjkVRUNSMpuSyIUl1cWlwkRB7WHy+iiga9bISZ3KHV2GzJHUKdKMptlGa0OFilGJa+KGM6xUsGrEkocGxW8XkJmOTQQKqGwXunQSgcxUqIlLpkCMbE4ljV6a5CqysI7qrekMcqYyo9c4fKXrpwkk4R3FuSUUamr8sl6oCp1VTy4uRZDpC8cK1WqjMvGi3X1eLGuC6dzZZXCC3SRJKbYuqhWjuqN4zWA3FS+iuhU9VdplNVeJdd7ATTWM0hShnMBlMC0SRwDSQ6Trfbhtg16kv8GdonX2vKQ3fet3rjaCa8mzgAMBbPoR0nb0EZNAKdMegBD1Y+TqX5xZnRKN/apyT8ypdJ/IU/YeNLekSv/DCs8NYR1fjgciE20reTwHMMWFJjakFBXyI9dIMi2L0rXyb4u0sgpWcAQzwasSDJTJCi/IKXBSYgJLHyeEkq47ga4ZMaeo+6M4UhWZTnUTUSzGcOEPBVE2BvHARq7+US6iRMgB6gZu+lZwxFrIuLPGJ4EqcnxbiI0zgMtLVgiCUjtKoW1lr1R7JXj4wX2HOAoL/n02CutnHOsl3zN2A1r2RzXJZ8au2H1naO75L2xAko/p8k5e1AQnl1pxKnU0RN4X7C1nY3pwmpMEM0Jm6QlpzN+RC2J5xHgBeeGJ2BdYaKRUAv+GVap0YB2eaL9X3qzGtmufSLMkzMSrF259MOQOHvISxE54okZiFsXJ4DffFE+b3QtAMVG0dENlZ6LgiqjiNg02sky/UmvrCrakUQOahC2qxpzcA+uEeBj7NqVXKOWxq5dzTUkxKpSLc5x7Vp/+4epPodvYvR+SyunXc+eDUPp8AxL55bqzn5iZaxiz7AMEmnYbBvqha3GBhlxpjtikVdxK2PvxzaHi6OQmuO8mFihlFkViFI7zHr4y9L5X5WAOXYsjqfWcmVZ+U3TCjsWPFQL9FgEzQh3V2VRJ+bEKqjUI2+MqQTl42btmKvMctAWIauMmx8xE+V5MyZqk8DM5tZS7Sk2L30EigbCXbuLY5n0+nRjOB0UBVr37GdQgoY38RCT7dlODlF1104HJQvMipo9W7r+Y9DhuGMZJZj0srqCPZIY2NOJzm3GzoYqlGZ4aCvRA6jKepDIZ3owPTmlJyM8FtZskVrraiKPsyAFHqIncZ1be7KrJ2NhqfjhDPjwMFrniutRvOnWHhVfu4qan/jOWpMSszrAEkACPdmuPSnqc2Uyt4z6zCRYMZ9K3rMUjrUUFLb2S3G/Rr/k+4Vx05LZcmX8wepZM/5Ax6YtO8t0kkoZdXdOstv2mpkC08mQjlUz5rjaIlWuoOVa9QBrVSjRHGROZldWmzk4iPVuaWX1uvMvX1fHXkTmXhTp0J4Q9UIQC79croFWLJF2S5oSh+ndyiVSmrS0RCrh2BKJp2YvWmMrjtkaY+tnbQ35f7B+agWKsGWrL41aEsVAiphlsYCNFdh0lFg/Z8Ze+X9p7VQBtXZa2ZWWSGnXyiXSDoq0RI4WRen+RE6RErHn9lO7anWTXjJalIVKjGL3pqRRm0xNpwUrNZIaPvW4pKQdLYXLV8HOaitgu1wBe9XqZz3fstVvB6sVAanGVrUfckV0G8WKOFr9IpjVZzQObdXwRLu0ahihXujBtoeZgpguClyTQpOIzG+dGc4t9sKwCw75eTire8gKCH5sltGD+HmyU9CAhiLH0oEWnu3c8Nsfe/JtyWmj4n92h3//nTs/9+CH/vGh89EE6vdvPP7tv/hYOHEkiikXPrX41v/xnU++6a5P8cRZXfj6P3zryd8Kr44KJ9odvufsp7/1vq999Hd/jL6t3x/5k99+9+Ph5VGOZQEvQYHk9w2vL0Q+uQllyh29m04Mj/7aN9/+1KPfvuMrDfblp2FlWLCCdoBJYvZG5XSE6eOYHOgpCupg5l5ZQDArzjjqm8g/LcX/QAMhgr0iu+hpYn87It7ubTLQZnK6i6yEi/ggmcLVI0ogbFPsvfWqeEG+xhu4mVfMUnd05OKeDz/UKF5QvJaDqUooOIOvpQKwr1Lx5C/E3gHlToMSytBCIl40gpbx9VbbmGdQvUuBdrSyTr8CPRwklPShySGin02M9tCLnkQ7g/mH/FQoL8VdkqaUbgETEj89kkX99PAw7wMo1uzAOFa9642c35/Oj3J+Xzo/wvnxdH6c85Pp/D7OT6Xz+zk/nc4f4JyYqhToVMse9i6L4hIlvOR+MZLDv426pEjwF3oK4OOJh6CmBVVRs5jrbpWqkRUyN7ICt76dvDm4AiXm8UFlBUZjoloM6x1MlCzzxpujZodHDr9CrsDoPkLSZJTdko8hq7Kh07k1QyeV3HgxDLH3blhNvUWx1BrFYyTCG0XcaZrbCtqmUEhyAsqd4s/uEkuVH5HhF8jwrzvNGTNVKkslwsHifOAttlMgRhzTKXWFd8leXDuOI8s3aFQLHKa+3G3kc0y3He0pW1IV4mluIC9cZ1MV29Cmkf1s5Rkxl6MzvwOKH0kjhc1iNAeWcUr8xkhRu5p8IaomQmErF2HytjiWqbTakSFuulZkCPoxulrL0IHayGHQyP5BjqXjmzl120u/l76ImpJJlmoH/BvXjUS+ANKXF0LIYlhWgPNnHFkG7D/OHF8vQbkZk/IgJg2htAXeKWg6IVxZKo+cDCjsSYqlRQSE7DZ9nGoWu2cFV/ui3DPP67LYdhNR83SCR933UYHiQw0V5qOJWuluCEoo7iP0Q6nMiVxShlQhwsYopMpZQKtUDThZK76gHMDHYfUSYoXXoJcZVYSsZyDQRfGoLMUkHTU8Xiwp72T2s4Jlsq/ZMG90l6j5imfHXeoh1QFrp3yb9WqNM6qMuhN5hCa8u6UflENmKPPy7af/V+FEPtGJMIynF0ptDe0InyA7yCl+U6Q8zw4C0eD+5Cm5+uOPPUblU6xI9nWaPPj6yQn1KLVUcjqkW0BF4sIoN91Fl223EEcVaTF7re/AEk5+W6zDIUKUj0Qs8vFkOj6Qjk+k45l0PJuOT+rIIvN4Ot7PsXgSf26IX8VpjvKKeR9Hvf/YuvC5ehZkXrEcH+C3iLSn+K3nziiqmwHmI4TEkdRDMbNfM/PElSQvVoD5jZ8KyYnQdayN2ccliZxcq3Yuv/E22Q+xXmZvd6U44pcxZx6xC1Py76540P56TuphkbUns3ckl7VqlGXv1lPLMlLe8CKzO8rH3zv+7voj86NHGCF+K48h2yhMIx2zk71D94+ut9NDfv6eYzPzU7PaXCauzuP8IjQa4p1+HVlQZShoj37dx6//w9zZR9t11nV+n5d77su592anTdq0N9CTQ4am2tggbZNJM9B9lzQJpVNUxtXl+Aejs7TmZmb1hqws1EouJMQLqyNxbGkQkKAOidjYgJEGqfS2Roi1YJQKGSkapUJgOjbOdCRqofP5fn/P3ufcmxuta2SNlNzz7Ge/PfvZz36e38v39/0h+/MNch1ie+IK5qFTjSnYVCPughY1Hh2kZXLr8r9hdakQWClkP97FF22RWSYB7L3N2pCnajjswmxvgZQOeEaAKBUUz0eaMDGxGWYYdYFnI9Ey+7RlydbipbYCVziks8Rz65OFP1Q7vRHqi75RHS7FRt7UAW9J9WGmiAORE5V/Ol2X1ytQPZ/ZDTKBsGU0t/ed1rSidDneN8OKw5503mG2RIW2zPtOOSOUyFn9HD5yOJ2nVal3v5Nsiensu73vHFtawuN+BzzdK/2Xd86xiXk2XfQsWxomOjHG0Xc492IKk1P+O/YofEUvPuBwygmo22K717Mr75ZHBavfedj3FLuooDregLalK3hblz39OZZeHTqgXZqwVcN1vkN3kDy9Iz/RyD8vPX8ov7eR/6wC7RiFqtZsqNVcFKQJT7p/SIPjl1v1Vk9LZnj0m5RLVmt/HWXlIvbd8n06Ro4VXfxwet/STf3UrpFWE8jVlFyDJykBqlKD0Va1U+AAGXZLgKjVWB0pVIUUGmP4UGMdlL5QjQ1yeu+8UI2NTP7eeaEa652osY47X6jGeidqrCPEF6qxDkSPPM1WYx2lH7nIrcb6ZNRYQ2YWqrHeuZga6x2LqbHesZga6x2LqbGB2bTuGiDRi6qx8cmLt1sfu5TWEsaZ4LWusRobr1Japt5WmHaZHeIF+WUbpHyhNfdFqbCVEVc6sVTYBFXFDVGpsDKCWYVt9FRTGfWsws6vCxV2fl2osFVdWPDmqbCemvhI3teqtTSDHiQzwKK5Ne29zpVKbWFuTWcXJMVs5NaUMvD9kVtTTITF8d9F3rjM+ck4QAHG4iglwHgmRCQgnsxHiuhv5MQgkxnOdO0P/DanLVO88WCKEVbYsWKEia5BamLiK2OEuarnTE4Vm4bmZtNJX5OdxHZ2WInCKM9RPpjKxykfSOWjlPen8qnm+uxUZGTMTlM+ncpnKJ9J5bOUzyoLugQU5dmWgJJ+j6ffo3G9xharXS7ebG3MRVKLosi5SKQ/epyLr7da5uId1spcfCOfZireyYeoPj5D9kVp32UiPApEAXHHokPMku8sVYv4JpUVt0SyjOLsw4rXVl8ROIWMXZzitw6Nm699EkXwfGr0HOVzqSwF8WwqS3E8o3Tomvb3j27LX5LqR+m01MbjlMumz1Eu236Sshu/n+x+StGcGj+s8G4Wil5WP/UwqJKTjlCj55V4LZVPUz6eyqcoH1VDTkF638rfG8pIuorE4TS6tDRj0HUaP93nTCa9dTD/KoHa+qNR19NgZUNcmMJPpNvtX21V2cqHV0tXMYw5Ex9CpzHByhP2Ak8+tanxer0mBVXxTAUil76jpa1MxzELCecnxIQTbJJjPPguE8KoGWBPQznNsckBQfefiVtXdi5TKPqTi+QFYm7UdywFN/+yP7P8fuDG0DBb5K/fXDx5KkhrIf4Eos+G/xj0zedovEnR2C4OsOKp2AE7bvPm/Fh9VStMIVKPZN9IZilohlByWmZlhkbFWpqQHzb6uL0kpGSVntC1lY21kc96sjGT/6ACS83WX96u0xKthLjl/5OAYcqZa37OMemuPgsQstk/poqrpkuyDxRKdRCrkW0IhmsL1QsIlpu5Ois+DmzkJ7Z3IMgcEnhGh6IYDtF4RqKA2EsYJEvIyyT0DS5gcVy6M7mimgidML2z/wOPJWyrWqyvSnmlWxVI3K20QkHfG49S0n/iTZIB3z8gAqTCrgiofO+1MGJqGQaqBz7Jq/km6hm/NkEseFlT3LZdnFILhrENslWc9AYOImW0n0sbMr346iKGlenLRi5ToCuk94JG2vN51vF3MUyYt30txdYWJ3Qhl3Rn6+DFE2Vd/nQjYy3lgikjx1PNWlufylEoloPlQIsqwzT/sKDFEnjE+L9VSPj4aiT/mYz0NdTfi9GtNk0TdoivX53mbDQyHeqX7YPpV3n4PNnqssdlIeV0BE4T9ytNnfgTtKpLt4iUauiBoYU4k5rwjHHCeUngxVFJn0iiwtdxMUuviHshj1s/IFEGp1UKSyS4Re6lQx/noqKuR550tKewfD36UKrENDLsgxma/Goetc7hzAfSsLTL0m8zibbEyluoD/2CjrT4b/1C1sLBXmeVfXVYsXDqo/R7IP3ul/6lTtdFMUmkDjebi0Rchgmmg9AQz5nNw51SPcABGG3dmh71oWvo4aqGxLfRxqpGvhmErNgSXo2IM8LNVSImbEWUjDkKNJs9XCb9kR0uCEhMsGxWhEFNxMcH4A9yEnARcpP7IBJGJEFFBPMIoyKbF4ukRJjS0s7Q54FFtavZ7DXIhVfdugMSdVYNBKMlt+7QeGspF8vIke6VionZeeQtwMwOda7sDEZph4IQyJRwm6T37ZGC+3afJxb3oO7PCekbwkZaxbMPFc845eXIdmVWRiVW1lgdeZc0yzX1nd1L8g0cpSgsluedOmpItNcMkgM4BanqOr75Mh19j4LS+SX8lTlMxNBMl/zejVHtEidSMa+xwgzEROK/t050hzXrKhMMq8wSqWA9s/dwsWmr/kwpwRmzQ3dw6w6CIFkjtxH6uTwlofGhZL0eJSpghcpXEKfcuWxaeQ8QubbjasZkuL3b3ipyGZjoJc7KiEgmZyiryDsK3Qw/qs3X2t+RIpRJTsB9Hy7DiZ3Ds1U8r2hib6PSyo467GgNzg6UBXG26VKUvJSSJyqueGFEcnH0dyoRtDj9GOWTzHZaKPU6oHP0GyNSAk4CXgUZFzAdKs8vxTdjQozSdrMcOx+ECWo4GEkipQCWqYMfc/enLMBDyQIOGb19tZ8dqA3aRDEy1R1k3GLlrcbtYHiI+JGHaLDnIVLVSq2YGtHS4B1Q3kp7FCbDT+40+oJBMqGgVTnXkUWaT8laBav+9V4WeRoZ34p3irqnGz2AJMYkOebzIb+vJCinuEDYkw+ipAIaFE8O63qPCog1fh4V0GCxH+FdBPxJNB+8rnZ6kAWaNvzJIOojXvKSCogXtzH7sOwXIzfVDrOrpAKSFc3XmmPWVH26VluyIhklKiqg4ZIKaFS0P/Qn2a7Jp6t2Svw9o9LRYc3Xw8WfxJFD+TeUA3Ekv13qA/uYLCDzQTwOGqF0pXPs0VrdIxCSFDCWw8VGjygNDZd4Cf/ukcV2EJEVfPV53xuRlfK5VD5N+Wwqn6JMmyzyqoITLOe7fE4Jh1P5LGXUBpfPUEZvcHmGqRKB2uVZygjULu+nbJs0N7l/aH32Dcprsw+IKE1S4KtTd4/wLndszP5AgwVFVK8ixvBY/jlbCQ2QnScPK1EIHeTxzI08nnnHIxrP/2UgKYx46GKdd/60NO8Z29ORHFFmC3t1JDcPK7HCLCU/yxPs087VpqfKkK20s9OcK5q7tqm2l2JLrF1aZcw6EkzfXt9E5C0naPoV17R+yQZrWid98nFwxCb79y4tbLpwMOo4LR1OILVpLrttQtBDp6toijDfQZFKNaXsCKaXdwY4W3VquzCbbS/OMsZi7QrG9fw+s9swik0vbgREC0Ms76KGyTVxCyuRaY9RGPmiL91rZJvWw5ZxzGUaocgblNpQijdNzNO2s/1NefHy5uzVPl/LN1c/LnjcUua+8HF7Tyug24t+WomFPK1Ev/S0lgZ5mlImkESxGvFRsHcMZp9H/joMx3tWLCHbgsy8DhLDPNPb09wVe/AbyWBTjov255r1wd0Dhm5XA1KN0RM40xJSGL1Zgg2Q69y3SGZVjXJDWeILyEmS/ZTeLLFq9V5TCdBUvqvS3GhmoxIB2n/Rk16Ti7kXrvInMEDMrWxGWnHEdJT/Urq+ki2lZkYqvRZZ+1o6WiYijgr1Kb1acH+CVpQWqsguZ6BAam1NDedzfOEqIS1giFMvy47FKDMsQ+HJurY7inDnmReu0pASJYYZxe9SrIl4OEy39cYgt79j1Zif5ub0OeuOjkWU4ewB3VsNExxHDRMzlSwz3Mnzg6hqSjunmxLc5X1mTCNLnXHdNGPzTZjKTS/HgeyU882X2uH2nV5g9HQSd7OCLUDMah2Q2Vq9h8Dt3i2ZxekRDcz2800sxyFtos2EWawnbaKCr1DqSi3RUq0qaTMMZtbRBVDA5iLdQ05gm6jkN8awwNiyLxmjCAyLC/zG7GclrWu/GmrHsaxm1iySgxAYAiJ3y35jDTHiSSJBlsxgNjjHEXW7eSPLjn2GvmMc0VeLsKl4Ielw6YI8p2YC0WwuuDBt+idfVE4FQ6LrchjLFMUJjHE2/GSId6XblOPEcBZeW625ZT1WJVF9pt7h9yQjF08vEY8oghp19PksCJUzYScCDcHi4HoM1rL6pbKsfgdTWdbAw7KaHdcDFCdSfsx4b/M62y6177XxHl+tvenlXn0Hcil9L+XVhkBBD8jimhZUvUIZmPoERO7sBZV+kGpzoW/2i80wOiGUh0+LuPhNkbREsHlmFnLfSHVTYh+sOKIZYJ9R/Mpr4jw2JI/WPoCEwZLqtCxAImSxFZv+tXg7PfHjSCaXTBnSr4fbyjuPnDNO2kYNkmsx5OClVXKiqM/oobunu83IdGPplAEP+iL/kLOQ5L6q5ExiluDFUgR2ZxhQDWk/9wrPqAyfMhctKd557+FT2ZumOkuAFGlfMxKYIRyUe5o7pgulXHlz+mFwyqYk5IHwPyAspritgCHOF8MyPUBkonLFsLo3lRZI2uWqLOVl0UdqClCp4IOpwaW9TXnw9H/ZpSQW8fJtLcPyY5ikDGE8KUKzsoD1Us6w/3rhODotqM1leom3wVSHKQ1wkZIj8Mr+TacOamOoS27Nuvy6Y+E3Hy0+/AdglAhFpNVLG5nEdUk8HBqh+8gytSmtgyO3KBcp9VMQ5iKJy8mN+9pfIpOS8iMjMsdV7HJXyr6wwDGWRtp/1azX39K0AFcFakLg1aNyYxEL3PYWx5rBw4SAEJ4z4pekGMj8qJXpf9utMgiiSZH0MH5GODidRUw9Lilzmc3IEhUsDQJPPHc/g/ydDjVc5vxkCnIroU/lXYq/zqYKsrjpAXWb5HjXLi6x9wCX+LMgxQr4lCgcKviUSOo3iOFw5luNPaJ8dSKs5+EGXOHamZnzS/ZMDu3bqx1Ds6mC8gqVOU71ayhzui41S95Ku98kPXLheu/CFMsLq9i7cL3vwvW+C9erC3OpuDAurHhIc+IhswQ/mZZqK5spMa+s/V55JbZp34Azhnw7WqRQT/MQkIpQ6EqG3lBx+j0BdtFEljT4NHIqRkCH0gH40hApntZ71mT25S6Gm0EHCETSygsNN5eH4QYDR7/hJtGKYDJX9jBbWnx87iyUw53LrWYwwV56TYZQvy5K6Fqo8ipBb5T2Qq27uXOpE02zxMscOlQ8KzYhRv2joR6IuI3sV/eejPRVdSFjsvLz4JWMOpkZs9c7H0J0xl8MNxx/j9aWhrN4ufZ9evF9PIGmzq8tvtcRJRAXFnh3GqRU1aiOz2W5866nqh02xBjFut6IWkr5+qyjL25jJvnBWWMRsuXBsELlrLE3T1XbjoDc0Nsvn7Tik8ttxUxwy2p7Q0RMxjZdPm5AedlnajlTBR007h5dmz0rGOdQ8QdGBoNm0opfjg5eliZUdOuNGTlfkcD8IKhvLm5YnzHqXLx5fYbnWMVs8/rskIpMbs+GmzRdbciC1Xg5ac17bXhq5Onf7fSLi70uIKFme2Hv1z92kb0K/3IPKHvZS8rQMPeRal4aNUZM0UHUQL8VXcwGhHLqfJXILRIR4JjUMHQqAcx4WDx5inHYuniB43oRE67QK3hplOj8l0SJllwRJVrAUFaJO1+pUsOEX8HXI6ePli2ZER+0KD7e669nrWVoErE+uaDDcG3ZOLp4lzjtp7PzRofoUYedzSG6I7bNm+zO8DYoThGXy9N3HwIEs7SMeWz9thnGpftHVwnx221EZ3GOekpIaQQpBdjHQ/qpm/HIregNbOoemNB0q/9SkiXvUS+qfdU2fan2x3bpH7M3EzvIp+pjjfy19FU5mOY+F32D+V35HFe1FJmIZIPtjlGFmKlU2MU3jtNPbNBP/O0bOu7FL2jYLbbXw+7dF9vrIftJvYHF9mLeMlohDSmnQLZGJ+Xc4y2qhGmQodKDMaoUtNZ7OYPqkTSWY1t81L2XqzgtlRRCqlErGAKGGREy2jDk3M/CpCVqqyA2lqFoi3I8y0PBd6w/G/Rnnf6sKffYtSFbJVMV2a6xWaIPyexEsnxSAZPrEbaqgVVI0XhIdzthuhO8ctMtYzUZ6Fn5vfZBVVCchB7OG1f8wFidFD2SNpuQFF7xg0hlxW7Zjf6tNZlzwSOnXpQCZmMpID0Sv07n19mpIjvpOZysYNw5xol+y/AUGotuzt/KaMAa10wBMINCdZXF/VXRuEQsaU4z1wgGLVkn/OBdx8PBdqvoOKYLhcVhew//k5nBr2A1dowwLPbzk3U1yHPT2keqnI0kZejfRRg0tc19nYnJTQt2Kd/chNKUrVCasnm75PQ8QHLwnCheG3+FT7lHNgWTHtmmipVfHQa49hVY6ZcpXXfYj5UDSUZF6qngY1FyaLGhKuH7sGwya/zUrB6kjHbKXhvROpfkx0hg38kxTTsVtLRbltn946H2tLlzWwZ3MtEVZz5F63D2tSnPkF9SZeUnPqj6V4jHppiLIssN6gBT3VKdK+t8O/8kyZPkjdKJr6C4VK3nhyawqx1iMfZ8fQNLQej8CLlIYb2mfILx0VBNF27Ye8ZlTUDHHFfYi4SU105Q4h5bJmwtOy1WBTIW80MWYWm/pjYQYNbeFqczQ9G9TLZnXJWXKvMdF9w/ju+JwZa/nTRUFr7t/3spV0up0NgaV0/kJUB+TB/vlDKzK9/KmM4kc5yjalLaNHBsbs6o3tKq0WTb4DKi/Cxmrk43uUxYbLdl1ViM0Mu8EizRK8qVtnuKrqR56I+X0COnM5JuEi9RseUb18Rm+VnUFKOF0bxnCePdCpdtNsfLNHmMcZ0128sTluiaIhw+6nYv4WYiTIaFwZ25Zru4iteQppq+wIMmq8QoXaIruffb+Wr5V2uukd0L5GCWesDMfTSOs1PC79D/LvPIDp/n/qurDJEHesWDVdG25avDbDxztXQyzhL5izuTMS1nl/KN8JhqIgMwGDAkzSkgZBvtCVCixBcNwtUcxayd3oqTKLi9+lV7aWgk5cbK+PKqSaerooHPL4/fU/x2ljk1/plUlH8gFfG1zqUiDtiTFIujXVk6zrx8W7Ek/xEPBkaavptUQ3ZK0HK8+0tsqrtkC2h85UfjF9PrThPz8G0H/NiWaMiSkp01xjfdoqbradBFSyJFrRY898khafavZXSR2G1bscl6vtKtSxOOy2JHvFp+FrIyT8nkrDGX+jBeWblbuXnn7aZLKvic7H5Xg3c7pXdXAeNkJlTt6YW1Z1R7ZmHtWdWe7as1I/s51Z67WjgTUfLQHJ7/emO0ecIn5j8hrqyLPSI46X/oEbX7X9gjlmyYjF9mF0BBfsvVGE7THaNGjx9jTXyK7gEn3ZbwtEquSSaEXkdIpx/YiRwKWfU2TMm9PtAe+oCdsef/2+PHpJnfGM+Xx/Ppy6meT6nwA9cVgQLznq950edr/gt7PuZcmICIRE/xIyPyHSspbcWRGkcy61JYExICscCrmkljDpS1TtMUkc/5aeNspUzBWWGIrdR/my0NqlU7/Bu7IiSZ4HsFH4/0oo5HelHHI1XUsYiwzWoVawzQnLS0SHft0TMY6qvWkiCAaGuUr2b+c1jkLHZXsn84xuUCkCaFNkuGIiH0UDiVvKL4CFbPcKti13WqHSHKHsS0/xGpXdh/ZRVcJfvvcikXWH4v7VxeIQRqCxECJL2xAfj4p7H/XhVAhXtUnojy/Y9QvrI4xk8gGk5/qnLhF8dUvsTlv28k7FW/T3akmD2FTTE5pNRZJLlQZ62LLcanfsiLop/XS0i2F6kW+CdpFgOBwy/hSvbqjAaOKiIcCWLgHgYpzQqkZCyVYwhYZRTF5DZgZAU1JeORoVY+X94i4QLi2kQe5BsFpDoncHl4xeTvxc82z/fm1NCOMWgJK/UFw6UU09FWmfgAgXXLspo8qjvjA/d9BEA9XbY3OFiwSARMDHoWu8b87IjxvlVTbdU6LgAXYLMI2Chm/jCu4Vgk8YDTqTjoY2lOv+fT74y6DYoYewJ0J7utqdRJs/oVXCv94pkIOJdOOiudg5PcXbBt9AKmeRgid5hh7az6QrOeR5gDAhwxjvn768XepOCPF7OpJLqu/Y/PZdfUuT5mo2K23JCRgu9uifKRSs0fzj8GxqIpZ4Ai9xpIp8ipmcJwBQZt57MNwE46FPs3hy6dvGK2e0l/HvhLZatdCdJg6aFpEihjZ1AFQBaJSfwbs6fB9nVbT8g1/fbuMuWHX3bx/PBr4qSww6BykB6ei+JnCASpSGfYhvqCro708IMpPbx8EH3p4YndI7UiDK8KDZZhvm7bmiEP0hXy+/gGBBAdxFFCYVSGbdbqW6Q2LJL+fVqnw7Gvb25UNxdupyLgG3DIViSbi2D8rP/8nzxUNHaBppV1Euyuju9ccqhLzjBZPHAy0vZpDLBM0VE14Eer82hKQeFPfUpJKBL/rZ5Lzl0lsa8BhrGPGHiRvA/TwEjpJ3QEQyCFKzapEXwi6yPBuwRFriTbAANrrllrvSUdgKX5lbMiwnC6qirBlNgwBicvvVvMGs5Y1UeNgfEcMoxuo9yZ92dsDKaMbrPcuaKXz4adYuqAr8M76331Iv+AAkT1agtsmfVN/iBkxt4EoEClDiV5TmTm3pQ5UGgyp+T4DMzgmzLT4era5GBsTP4ratQPDfjmNmUkkKC0nJIcKY3JMUrqm8bkACUF89aV3WlQj9fYt3dTRtCon7TTpDWT38FBJKjgoC4lUlZQupKSmDzqk5dQIgMGpRFKpMagVKdESkFKaPX2T8hMjz1/7SxXx4UVTYWatTF5Ncc6w+TkVZTIakHpckqkuaC0hBJ5LygNUiIxhnitkiNA/6vvmfxuXZPMGdHillq8mmPJQ81hKymRmZrSMkrkqqY0SonMGJSalEiVUV3ueZp4LXUkr9beXtvPsOM63eeK9tcGagOJPZyw7H668Iv9VxzH/Jaw0Y1aXeucagqP/qx46hHv7eLglNLd1CKdFV/q1Sq1HLUixf7TXi0B36pVfO+f9Wo131HLOy3O9GqxdahWiNQ/79VqkqSWMVH8Ra92pUTizWOMmeLLvVrNrtTK6/h0r5YvUVdQVPpf9mqxrKl2rHhrK/9WHZfEXyuj0+1jWHuZ+h+tqf5fMYc+HN2Cpnki2SdZE6IEUoXMgfXyTFLHcG49P4kLUUcI2Z75fIPCfb4cxFl0rMLnFFX/PjLIFH+MCHEfjhtD0D+lmr/ur0mNeM2Yn01zBLLLOXabUbyYlc/neR2Y6gDznn/3gjo04rML69D4Ty+sW7atOLmwjhXneFX3XNSRrebwwrrOtuLAwnNX076FddgtzuvhXHf+F3jc76T2um3FfmqLg9r1q4vuOlXtmlPpTxmmn2hFJCo8A3AGLDKwj/3joP9fCbz/GHzggtnv1ks6nOIyIC7A+qE3pQvFq9RRnh2vY9aWcaKWI7gXz8VrYoSoFLj982nUEATnOi4dLCSx+jVzFBf+DqwSZBo51QEVBAZYWWFTwF4R4CsLZj2H5qORtwD+PKcEqDVt6zLYbXJWPszVLGUNaotZ5oM3c9OgXFPNw2U3YCfJuWTqnar64r2jQzwPFMejT7hcqnVvqNaDnSkjBU4cvR/0ZysnE77uH+1UI0jKF81ixdU2se1jDQXMlL2NsUMhMw9UN+pIwUPY7d1YZXn446j4ynS6vy26rZ+NYpkmJhWWsCQ3g3PCn8xBGuin05Qh1GTH5lMz7kOIUt5QYFuHDPIDQUI9H+Y1p8bxBIq7hdFEKDLNdaZqESnKwGZ8G6MErY4Rpjouj4aeREiNLCehlzYG/Wz6g2gamdewGAZSQg2p7sJXleceYzE401i1kMHTK5MuLAiP1rpqt2Q7vQh7d8S6YR4Quw74/u95Hw/tb06nPMvH8xdLEGHtJJ4RJcqFYYg55gaDq2j2wjBEWKEFalmqt4j+2tkMm70DpEbtGF4TJadZdwnH8IYo4Vd6dWdUn4rdtJ/GrS5c99uT97kjRXFgbbbZUEjhGTdmdwZ0aM367MfLSL5sugzvy34igtRevT4Tg42KxPHhznSR6D5FpKlIzB+uTxcJFQToN6AvkvjXgZIT+3ANpxTIJOMMk8u1ck3peCvd/M4KCVmcZ0Xpd1yHR09SrD7Lj31cHCd2KfE3uZTi225W7qrF9/t8O6wW3695onhQLqtF9zvjzyneqXhUhqU+titmzXbFttnmlaZS/Mh9h/heHin4e1kqj7SDRUdiaR2xhUJzmoaZvGR4B+b4FAE65V+udy8hhW/+d7Im4VFHCcGnbhZkwhKK32fAk+dMrBv0JBhH+q1dzOhsx6bS+bIWLFs6kjV3c9TNaNgon182jsCGbaIGzGxjBbKe496Gj8SZN2o5KePA8pGVSn84xv6Vev6jiOGGshCv/B86br5C2kC+kIyFwl4KO2Ec8fPwhrlWejJ5OQxA62yT/8JsPnd0l9tbdNJJk5UX9bJ5Lp7Dql8u8ZKdr+fghZ6juTgAGY4DtnDAQv/R8TgAB9JlFziQjooEBuwqK5T9SC+z0ooHSfD3Ou111+S/5sN43kcFL5dJ4D7EnakHCD/BPZi9HVrCyycfe9t/f+tn/vD+rz2yG71iOcccE975ge6V9nwZ9D5EurXuBMd+Yu6X/u7r73voC7+lY1cAoYCuUCfpWBR9HZvrWF33LRxCPujOBEx/yzsrzGQbR+Zx5Aolcbv8bpKmXQGx4PLOFTrEB6xIrweTFmP8TX4nbdrlxu0AM1Lj28U9QojRa5iYGWW40TR6XNa5npWZvtM1eL0zIv2bTq8XPLJmSC1QAMpA5XnuZa3FNJHQHjYeDfewG8bJELRTYjuMqCFCogJ/+FTDQwAp93u/2bZ3vIJ5DIV3vIR56EzmVBAl8pOHyQw4t3MhphzgA8U3DAgf0qQU6IISPOZZ7Pl6D15AzfMsJ7Xw6omncHfMKB+7GC7D88k/jNo4fLG9QrcYupH82IbWCLhRbTswrfKLN8LljedVhKGBPZB1UiXiQoXXEFcmW8u1oOEB11JnLJrxHkbpkIYtgFBKqyYFnZxrHeWR1JbwU3yoOxw9xJK1wxKHfY4B1WDlel5y1UBxzF95LyA64byFoIHfPKAAQr4qsakBePkJRgybIO1F12MAIAsKu50vwQhc6SIpUgl3REQ6C8m8MNiZecmy/IxMii+zSbFffJFYbT6taKeFGQn3M5VIrxIfNXhpEu3nh8ieU9ouT5S2yy816kOBqS5FZNskLGdqGTcdvbQiMcEFfpgQ6cCAzbEYZFsMjwZ+6EE45/5TPnQ0QRQ7vZrW5EFWz5aMGRqfpeVKXyCWq6VI1qoOwiQMNOAoZW9RFkpn1WwbMmlRsQ6+VQbI6zIgj+URMDj5CJl24k5IJYLPytR/Q6a8svWC6zVNSeZ8/XU9n3zhHQNOm9cJhOYohrYDvprTLCrcRXCTOrX8bTvea0g7fLjGkHY044xcd1MMFE93XY1sSjJodaISVG5UYrBa0DOdgSOT62BhPcLcjX5OYvzO6N7+jnLyTyfIdUeZ3inRbAlBakYUY7Bqu/y+6AnhSpOAN9J+N8YiLfbnKsD8t41HQlaxfh6JYIGoeCSMLu/jkWgt4JFgHf2EORHoN/NK/BMYG3B16bq9c20CFt+rXLDp93T6PSXA6+M6Xgj4UyS/7eS/n87RzcwgkX51Gwc16x4vqH3jvoeO1+0VG0aQr8uKDSPQ1+XTlAn2dfkUZQJ+K5z70VQWzv14KosNYy6VxZJxUqFJ5mIwHJ1ohftlL29V5Al61CBPaIk3YVihb0OLMSiMLJxUzjlw95nGheFinPKQ1JwUMPTPF9Ell0FfRFckn+6L6CI1fhALpPxgCyK6NLgXxjiZ2Sz/QBnjJO/AvIgumeIvGtHVizq6MKJrQYrBMs5qXkRX48VFdHGpeY8b1BIYyC543N7TOojqxT6tgnoc0VU97eIRXe1PNsLgd3BJycc1A6FXPf+swkrg9Roxhjll7tJizO7yGkYQh98xotRERTaUTuA4BV5VpxI/8n4TeyP+K7QIfwi72ibN4m7i3HPg1oXXTsBNRmA6Q5BWjz8nA5gFSONxl37Pc4L9OjrxAEtdOQCdMwACGf+e1V61sWwh0sLmHM3ALfQ8+P5a8ar0VLvTQ6lrdYIeQsF7Pk4v16F8L2YrnkB17oDopdQCA379PmmH0RoKBBMzlfnobPLWrePUg0v0/n6tSTIGL9Jn0CL1vcrXIsOPWN2d+FGz/50YSMCjR66X/Aq9rhDA4LKVmOYIvi5WiDuD2jSCAJw3383DHiU8+TsYX4oDaGoBjTiAZi8O4M7iX5PcJaIAuEmaOaiPK8xilMsV5qUwALvfKSkMwJeg3c7Hlv9u+JPB30o4vZP5ovIw2enZvylXaN+mHKR9mxsSri0y3YAUvMOhrhEOJ8mTsdELWlVr7uixMgrOKqoffK8qsdysiRKrjagRKLHYrABp38Em8smG0E08/IRAN+VN6cq4mzPsyEwFt0HJVIlY12OqxNHrWHJSg7ttGFpOvDcA/ClZYPqGrWDIo0AJm4a9FHIH2eWhlCDSCXDlShHAhqO3XpzVqxO0/4VGmblDWXN6scCMxtdUM3uKCra051iWmLkaFjq0WKyC1tg8MpoQByfnsu+V/YjEQZ1B9NG9inGfHBKnemR1DAxXdGLPZzSIpqYVQ9VQ3A/jwTArmivuxEXVnO0/FEtLvBB4aUfFMH99T6nVfi1CDnrkDoRSDOFdmrdf645jIzl/tc5fOX8/Jh9kNQlcQ7ie5u0iTt+n3sWlh/ZxEFEX/fvhOvP+N9PoZbr0tfP3Ey9C8CQCHKd25u8iRoVlp4wL1hxfHH8STzWk1hWUVbtIvYBDcn/sqlJYhD82/5ITOeckzon8LLx1DIuh5GAyqWJv9Ro+TCzR7oZTtyD1BfRDg8UhS8VqR58V70b4kleFMHy5XLLiXa6QH+SMqItElgYLichIwnCqJpkyBJ5qF8GxwVDtoiLhU1GCloazmFma+WNOjQvbANcy/wUEBI2bapJvKT5F0Vx1a7M/5QDSLgSwuaaYOUpr1teIpVNp3foaMXYqbVhfY8yuzb4oEzda4J81lKDumuyrDYYkv882FNOlI74hvmgCl69WTvL1OMQQp9bjnUMqWo+7j6lgo0PEuCg2QCQxF5kMENBcZDZAtnOR6QDRTr18ELaWVykk7bRt8Y3iKQOnzdtWMjM0insVZaF1v6x4wjgd1May4gDrbLVfFxbFSiiZ5lxhVQ5BOrwC8QIa19SfaijH4JbYeLqhnD4k5NbGM40ukqYSig+u14vlaUM5XI/CEa/Rt4FeQMsizJKsLI82glQ5waAdlYhyIjPBoP0QSrXLiO2q0BRDU95thyYiAgmnZPbwEtc0ghO5ccUAIjhB8HLJoaAYQ4x/0iJHeCfkOoXr5oO1rVgHu7fs4O9TGfxCYudiDOtRHS6GckVDJayfIQgv/6IkL60lXloUcuSIPJGOdtEA6SKOJupY7j+QyB7lXMSQWlRrch4zIZJoNiY7gMii/nvrTDP/d9Jv1+rPtdEyN7lcFd2AU/0NMD54WdUA50ZH9v4KEQtg5HVVZ5G9slC490zuItO7NmaaWyfoe2VzfdGH6qmc+0+pZ2FVialWFovAgrc/N1hrmLrp4v8x0oanxgfqzVpN+hq+AMW0dW/BcVorrr4FD2xN72AM1RsNf5qtFwZunXZ1ZyteRbahGx8cRbOkaU19tUpCUVOznzpbA9ygJLwX7Hn6onueuuie4xfdc4Z4W+3RDIiC4F5acMhn45CAthRtrdGrEt9F3Qn1LF1LYjXujVUcqvXPFBzZad46oQmFYNky6HzefsHLt1o/vkWzdH1ncfIzjyruQ86WF+Sf08fSgMUoAh+bxfJdup5g9CGDNQV2EblRNo0tQbs1MkW8owGEFBhR3mbgIgw1tPqDH+cmfDdOd6RL9ygWQnHgjSkZdXOrKSJmZhQOTOFbug1wlF9/f/sWyVzaLM58ZoSvrV784rkRVZ77QnuquAumJZ14jvKXtt/qa4xOFe/fCRsTQacfovyTrn3bhqnib7/yBg7XjnN7Nty+Y6ypT65WfP5R8GzfVXz0MX6erBX7TvB7vpFPY5HR4NUzIwyJnQkrjoPVvvVpDnl58fhJft5XL77yOL+/Us95q6a/mtlT93u1z25JsnmhUW00oRfvWBHvtWLZLmhVHik2AgnRZnMXPBWphqAA+RL6ajACUTPaV6NXDG6prwa4I6Q7P1bUd1nFEkuvwHZ/b/nRSSH+j4uarpWQcBsfTQAgyG8tsAiLmJEh19RYaSR3fZP9oliu9W5ieMl1tfGbMmeuvmAMn9AYbn+9EuLmlIgmCXGLC25SEBfKbTXrNKXc1lxEbkvc5D25bWi+3IbUbUE4SW2l7LXmAqkNLd+J8S4itCHMW2S9iMx2R+zuXERke+NFJTZ0BgvKFxHYMExYer+IvCb7xUXkNQmsMltUxClJXiPZ/Tx5DYtGKa+99AJ57amevIbW1y+vRaLPfnkN7XxQOeVFzi52yimIPnCp78TGKDupzCaythrKHOut/0urM0HrPXttpuh/fWEi95giTQfLE95CQGnTzHoISLKYslYKH80xCuFNmR5AnjGbmGbhbvlAsFIIF+7MDrYO2mAp3JuybtiUVN7QoIUQFLiwfLJuBiZZYcAkUhQNnLEoQFjTYkt4BXO6uNL+yaHiLVxJZN/pSj6nK1e+egPaAgPVjRigHelgXY57DTR3K9JcbmGEiOkJOX80seZfCfIind+QZVkv7qf9fLpYUd8h862t8vLrRRz1oA6kVmIXJZNY6FB7hqJeL8LvDgGl/XQ9JaYg2Yy/1GosiHMPOK2BnGXWHSNIHS8o9DXnB5JUrIx6V8bkBqt15PUQwlUMyQqnEe+giLqNhgV7Ku7e4BTHzifKw0SYbqTuPIQuAlPC/5YA22BKlBygq4vTO9C2RMekuwp3rKCmRANuvKxD9FLFCODKw4G5Nd+rjrFWfy8ZBoT0FQWCC5gho2CWDo6DuTqRKuqZjfWVQVf37fEtCkOxNWC/iDm/o6+kzwJiVbqWCzuPZGQF3Mwv+T71nznlEQF2icCPHddq0V9TX0fDft1nrAGPK1ECn5jcMRoEtfyjqATA8jXWEwwblV3DDefK9fHq1xnPwHgRSExX6LDPc2VxNSUR6yjCO39zUGNJXhYLq0TG2F7jdf9J9Tm+iGhTHHA9n75UCVbBKwsJ0mp3kW02+rvTuHVCJBgsMnxXV5b72kz8wuYX7bum8q+Lm0YURP8j+GdM3Qgml7lQ80S6jSz70QCyKvweloOaPFnmfCpT9nLUD4Wt5A3R6DsExUAgURZfOsTPKVsLKA6x8OnpyyS+CjrV9FCZJ4oHHuUml9tV8PFGfQxDVjAOishYWOHu2BT0icIma+GSz4FPRksZmD91G/3kgFMk8QlF8ZlukH+3TlDhlLA4ibZOrMo1C+lYZe9wjoPbZbOgl5eZQJFFcHaytsf5jcSYI0I2tByzrXRymc2GtZkYV8hFd5sztfBSMGXqUhDW6ZPjsrKzO12LmJH0i8CmyQVWOt6r9OoWUMXxUdxAGv2cxjxGZUCaGV4rbecJ/BHHi+3T7IsDxQEA4LbjCB1fHK62fHNw0Er7A3JeMYNqQ0oHo6ZcUrZjKeyL1AbbCcRyykjDuNmK97Q4Xl1QzWqXjRWsqC2CkJWl+kW9JlFBa6nO2n8kiSSSakVASSIlcRbJLcFNcnP0XyIlUTRCGCOb+QqtIhFiY16SmInDGmmDUGWOLGlrRFdRmiPFDdOtB12wzJH1i9GScKNkSDYriS9SWiTFPAMGSUJ0WCR9FSvhyusqi6Rm4dI4GW02X5mbKA92/vN8VDK2DckWqFEvW2BjZ/A9JTugFUJHP7dEA0KirZIGhGJJA6JijwYEEaaiAUFMqmhAWhUNCJcKGhBZN8UpIRYQrCwY84aKJ5MRMUxBlRG5xwLiTJsWQvROeqbC82B5E6URU2oQAFc6Y+I4Hh8A79scUE+p4uF7we5d7oU3FGBxkHrP57SHCITeHi+jAtTJ9Olj9t7HMUBoq2M8FyEkS2C39OzZRSsY0u69Olp6HuXl+U8VB7StcEZMp0vyn8r3WcHwhX9Ru1wuby53sb3gkjDAXNI6T+LF0y5pAhMk1dN48QCnmxUoJaBiQUjHyZggiKvsCeVxmk7isRSnG8ep5YLMBsQP0D+ldbKCRPsOvPsiDw7zkB58Uzz4BtlMinU96zV2XW4pqzLFZ8qip3ZefS3/KbDfQaIU/qgN29QrkWIS4KPuSjx7dVcdIphD+1gDo4FCk8bLZFpE0Vhk3elMZCTs+b6UL0veVYbb0WYKHLaHrOS90doY9vVkB47o2ePYe2Q4wdr0HiGMjsMzb402R/AGeYSiCnhFUP5WcYxjMXrEHsXyaNKNu1HxLBOqkEuPsTeQ7ARpRfK04sFxOvmEyswiTsYGoTbSwY31h50R78Y6ftxa/l75nZ5TJq0eK46ce8nTF60VX320VnflaPtSeo0Sif28RokFmkaJW6XMzTa/fcygblvZnGhj8ivi0nfrBmld6rOj4wntMSOERjxe8Yz81KdwPBvXfF8KKIMcpHLa6p3hsq8DzY5l3sv3KAFhSDIK70lY3vDpyLIEyDaMcg3WbhsWxWuFWJOSrqyUp9KsW+VkKROrLIPMmtFtYFi9kjXgX3bciqLxeMWS3IcFwRN2SbBVGQ1HwhToE2wFsUTkpV6xeJqC86juNU5+BYcJ0UQzYptXS/RoaYhx8ZG4kWILr90OsD7ybKnNQ1QKdSG0vWmoONm0Zs5H4ssVdxG/IyzE0mZgtDXR6Ku+bYKRKgsOc4yyPmVT0xEm65HhKxK4bh97MJbUkGrCvXoULuH/Z5DFp3xwQlnsF8piRYmyEFl7Qlkkw3HAKoJH3SgLpcT7h1AWIHWAE9imWWXrMPW6BEfo18tMHQ2M+9zKmToon0nl45RPp/JRyqdS+RTlc6l8mvL5VD5DeQaYhfNIUJ7FZCzQBV/a7Wq8Pzx+gUq18hcEHBrKP2E4FJy6YIOJxHN5hjIhey6fx9tAGJ/L5xLXrrASxkXoyfqJ/iocxOBCHMRR0+b+XR2tQpIE7xmBJZf5zIlizKPn2iz/ezt2XaZWk3JjmkrZltELd4X72PhqUSs5uSs/IMJb6NmM6nOD02B2vBjUS23eDHLVbJqL0FECzIAdiAQZvKkY3MXVW7t2FDg7h7iAxj9OwuRqY9bfFY5Fiv7dJmv2dgxaYfVmypFr2czhGgcNa+RapLAs6HGg9cbYjSFglWZ1E0xaMPZHXE8twArWa4GtbEajqyHlklO1A9FuYTtk9uBjSJkgHc9Vp+dk1G609zdqqAIKZMtWEEX1z88OJ6lXjqpvy8UjMi8b+rZcXB5fOdO+LReXYyTLH6znX61pRMZLl4jffqhREqxicA1mJWE7g56yVawVvaoUC5aL77QzxXsY5txYbP4THFDDtM0wbidGAbHyJ7RdyP+SArblb4QPBp2yJ2xeVxuVpUQ5QUI+wOAjfhon6mQHCk1+wpzsrDC+N+4KEZor4UiE4sRqI3inBI2/qrM/zArU21WjRGrKLZflvwsthgkoFz2RdcUZqjpE4g4pMy7teeEnpoujitbDDMSrj8hbnycu8nTD1OJYluc1Gu07NZoPkmflWyI8RIpr5cfSN4lGSts8F4wCAxQFTxi8+h7DlA66kSCGhvm12p+v19vx4oJoTV7DYq8gFyVpmqHG3fE+0rSg4upRpgVVl6mMpH2bwQz1b3wy+/5IIwNFT7F71aB9RNgoKYuz+q1KCiyfobLPMZkw2+vVe1qbqb3W9HKyjrZ2EWSAsWJUt2H71dPdsSOz3fFD2Ouse2tOUXblRJVTSZOmqdd8pX9bkGZlk6drW7s2N9+iCF9ZMrmmsFZjU0f2dcb3QrLWnsS4osaJTlO62ZaJI/uIZd5zSJYhZIZd3Femsp1TZI+wwbMCInlZl328fbweMLkZuFbnISkiFl+LbRmcThCFUgFUQfpSA8Pippj8ni0vAMQpNUoE1Cu432Y+2wChpSCJXxjqwphcmubUjconGKa53nmyy+k85SEMu6Dc1nGejI2C9sd5iqDvnSe5VucpnWAQA/TuJ94A3c95CB3T7otGlH+kLjQwlW1np+8h7CDmZWH9Vr024Mn9FXje+fNSTVMqvGQyj8JKJjEXJox7pXClpzgKV0wyra3bt7dLjitP4muzK/DvHNG+FQRE+KDLcTe4cBkWfheWT66MwjJ8CS5cOnktV0Hw8Gz9CmKA+bO0bEpeNmVJ2ZTxsiljZVNGy6akvP80ZbRsSrtsykjZFHwlURgqmzJYNgUXBFfBd6/pl21sX6/ImmVTGmVTCI+OQq1sSqamyM8v2rEmUdh7Km/F96FzpJCP78OzN/ng+RdeeJb6N+xo/1Ja/Rodx2B744b66oiydrXCsC10aEOR2BJwvaFgbEnD2ojwbYWCO6xY37k3FJ/sHMraUIhyGanuKGVpdt5QoLJit72hWGWHtr+ydhndmioVrW1nHz4kt1WeNNq6LEKxXa22KkLbG2prLJBsqK2K59ZGxHgr4N1tVUC1N9RWASK8obYqHNsbaquitL2htip42xtqq9/UK2ut1FYq1dYr4hBeSwq9pq3NCMd2tdqqKG1vqK0K3vaG2qqYbm0Qod3+CnnJUnCq52x5YiorTPh2+JwIPLN7x8UOXlVQqrw3oSnMRVwMY0+TISRFlzYS8gIRFvNgHc9j8YFHwo0czkrrUlgo5PnsEkznKMfio2I61njgPOwtDIap/Ifl/iG41LoPYdPZf0YrfjrbnnASO6/LfnauuCkTZ9Yidwdh6bsf48r/lLvDLZbubns3U/FEPL88oUzP7W2Cx9R2rs3eNYdDNV0BBcf7FHZBM96U/7Cmcq2P7Xcl/Wy/nLaGvzqxOpm8yhzwwIXewfXldjcf9Du4z9pstk5TUXz3IrU7GEWTuOKE8r8Iwhylm8OArz/XFwfej1XtF9C2tXltGCvXKImAbLNBv66lxWQRtam4hMg6dByftqgh0iW0sdJJzIT5iNx2rCK+RDP/S4VCKP6tOKzDnQVNW8fLrWhytLSLvJ6Y/JxkiFX61sAtiSk0sir8YjKyqlec5A5eQiFcFI9KR/D9C6TAbC9GtMH8u2wWjW4JHcACRFxsru9iNh0E4beSZKlPpenxQv6wXhuWxxPNgETaBPiaZHlt9hIZcSODji3/wfghB0CY5IXi0WcgOUo2WtGXIDUC4o4TcMlDmSmXAr570awbmkS++GZx+W10EXLUzuIDkkgnzBUl9I0TjO0S2NUMUetkfSA8SDdoFpdt1lFrNyesA2VgdGUsCt/A2uzgQ4XCSRx90l8nDLst6Q7vpq2mBcEcr4RvNHnKRjo9snN7bGSWYGslmbAkU5o0Ben/Frk91QcGDWn4TbVlw044UZk2eaOS3T+EMtXnHntRttyZn8c8yOp8oS33A9rzsgttucjD68NMyp4wiQ7fWMd4qfz98pDJK2egK6XVMoH6euGnPX9MEWJ8Rvltld32Md3o6gvtttfUiba1TdU3ssX1mjo0KMqFJaUjnHbUQZKSGgT0S+43GvRD0aA3xNbrYut7FmnstTTRCAQ31lCFPoeeHkXKkWxr5UPJntz/UG8T42x6qNLs+jU9VMTe9tldbYJvn6nXkFpL9pa0gAg90UgLn8R0lpMefUoweYg+JfhAtL4EH4gWl+AD0cqSFqAVkIdo9dMyFTQiBhJ73dPqFjQiWvSCRkRrYdCIBDWJbqlltOFbammVOhkrLlJKWoilblbrMxAE39JoQ99So3PAt9TiP1DJBAO+pRMN+JaSIJoVSUyzIolpViQxzYokBlmpIokxr8m6kjWFa+1jt7db7T+RSadHOR3aKzMAq+dcACUcOW+LTs8cL/J01F0fhi6rowDpoM86swNpG2Seh8ZI59lrpbnFQZNJsZWuhCHPYLNlwht6FmdF9HSlSSV0OdmknB3Bk/sAE5a9W1jlGJUrbZruNs0BhEk6ZgnfM39jGy3CerKIyy/6EGUGBuV9wOZ3Qjqpzbehp2vq5PVJBaXzI3VoeRXZb62MSrIX3NWKMnNCUokG2u9JK2llgIYPBKVQFrHtSsgw9WOoVTKQ1TCjEoYdOTTy3wgnvbJUJEN0Alna3NzFUu5PHc26GDUQTjKEKzTqWj5Uk6D6sScv+UGtkSWIhrwSut3H3PcCxry1tCe7B2Ad06cYUkFyheuFOP2700kkkEuTnovS6FQEtKfsnMk5nkul5A7Cz9gLKIEk7v0RP6pMeHFvBU0670yY5SEFID5VhAxhjNOo0mfDHOe0PYF2uarT+jFYoeQGc8cbEOm+iidwuemyLyeyhq8nVVX5I+gd3rpB4TfVRDI1fwgz0EQ97Ft7q0yxmoa3JnbyaRuyrMCE/PeAN6oD7+KhAkHbiKwq0FMnB+NTOprxBgZBlu852TUXXKN3hRRoo3PQUCsMgoy1c6H0c+h/jGH7xhA2fsjCoNA6vqoliqvDXyA0FVcW/pu8gHJBq3AnDA3erW/PKWI17eATsjUgeT5cr3kvQPByxXsSi4P9UuCVtc4S8GlnU2j/bZpizrHYQu2mBfwmYOl2FW8SPPKjj1LC51kce0LpoEF2FA9/hQIrR6oi15PdRXNfxdAjEiJbaVZvy388RH+m8YB0Kd+gJCWxcuB3/rXgV5O85BidSJRLM23CECzldTIXaQnDyqBVj+njmvomAeZcul6gOpeulTfZpdXA9PjyxLhiO3AYhPDu5z+eIGZlOLDlLFZS+/XJzaMPsJb/NwtqWzTI/TVhhVdzTOlmuFRy9tPI1/mzrUJdOO110dk043uwzFc5/qmLDpK9XiI+eDu6/pF6yDmCRYbjUgFFAt2k8PGWh4cW76pC+Rf7iNeZBpWPq/8UwjL6CdyRll16vTOApRPvkJDp0l186Lapk0pSSaI9C4g4P0CfTvkQ1yrDqxSTXm17toiL2ptI4AfLxBnTnYiJRc4ZxeIoBtmB7tVpZZR8JJLYwRho529TyGbgD0K09yWy/IPR54nxDh+uRi6w8d/Q2I0XYgZpxMBvNYhV2oXxDU9CbXoVWTUCA2O/iHiUuRveDiXaRUZFBFeothMGjnWGJSiPyP3HegLgC5yMoY7hHCGqeRr9g7XRgVLgmuWncdzjgAj4cIErfpwPWCB00Htql7DKQzt32F0mmgLPd/K9QDUvU1btTQa4hk9BDtitAsfcqiyn7A6GbnPNpGaFtI7eyacjXSxsi51RM+0pOZAMqbVp5UgxNcD7QHY722lxj0qikfpfmpZty0qmlFfWXlqZUlZYgPFkfkN9ZWVHWWEZJtlRVliMqUwpkmRKU0qyo2DQSkYUrCOVBSUsIrag2CKSmAHDIlJZTXTtJDyGRaQ0nCSrCRauZDJ5ZW28spcIi5tMJjfUR/vsJbp2ZS/RtSt7ia5d2kuSsQQTV89S8s9pHXl7AqfMAavUcs9aGCsPQjzu00bxPF5OpfNDFHybs/+ur8+JaaciSPAXA9V6/i5eCdOYsBJa+ovnhUhLwetlWJN4+iOqyWujg5psua5oKaBjQKK5txZWdRHtY3oFStND2RBVIqzJmSqqJ/+axD0CZsuwH4K3WB1fI+vCjBKzKHInu7++PnsolX+O8kdS+R2UfzWV30r5g2a4x0xMVNNB14Mpr2NJpwWkEn1EKxtLFIttYUfbL8tTh8VBsNBEUepnzU7HyOVhM5BN4cdanxGoFl6n9RlOTJ7QuMuTpVwhNdp28ciF+MeCSD3vnEjKs+htxfzn33TWMhvfJadSKVOy9lu6EKSCDBHIu7pHWGComMVWVcv/fZWfNHLceTXR8drtKGgJHWU2O98v0pf21fYhqz0rpmBrMVSkCwp5HBfDn3XBxQSOrWr7LmZr99cVEBTPSTFFaiVciDD8FhUPDickhzwgvQRy9GSpmIhzJRSTSj0QVMn98yWrEwj64idtkJvNYK7aNlGIqiSkf4UdVKbwiC9ZFjHGtZ35MxpxxhmYzKxZPPObTGOYlYyEUCY+CmgaTtSltVubQiIEWwVPhPgRN/LLkAFLGdRSHG1nUD/k3uatB4UtLCAhHSl1h3kttMQrcF8rvc1d3QEmW0nbzOJ6EMst0nZArcRDs2T9plqs/kji1zX1ZRHCpgYip+kxJQ+3/2tCL8nYEZwl5rk7L8IrOhUKGv5WWXIsjw8Uq2DGcVjddHdwAsm9+NBvLX54PI1JbT6z+BUtDlWpzUyO4/wwFx7ZtKW0Ll//V39zsSMqDh5HlZRIokikQHS/RDLFN8r4Lz4k/jA9iW9JGV5w5+59PZf+ppjE5l9aJrWS1CZAMQD975DqpwymysYDsEG5TKWvNaC+kogvXA5LPeZXMGDrhJWdEIXfqojacTa7WrFK0sWP0pmit038V7yTJ+u1ERs2Jl/9M3Kpqo2OKuGlytYxoPrmnrvf3qn9tGoCKSz/2Z67OzXVEqrxqp+5m0CQV/2MDgBbJ7sI4JbygLu7I2kfViBZOnjA3r5R7WMK1M3kJql2+M488x5iPXoUWRDWLkjh4tiNPUSa9B2Eg0Vtqph1U3IWHTq8B5Lz/kMbixzqRbfT3tMZ/UcP9RpqB0/aj8en/Yk6eXQb8PtaI3CWt0kMUUe6wz+N7OZENXi0hc2yXgClYlgcHRqBuJ7AzMOTI3fIwCnVSGMh4k9E36Oo2M0TVgE7LYedaVWy1Gg775CS11uxkV4uVmYoGUO1gHxVTPWKLWrjoRrR07Ynh9SwyEfHbQk14gWKIieJ/Jwy2d6nQ+nBQ0UbNZfrYAEP1InzNPCyRiZvmD3UbQqBLSylCRU98/lZ00M646L1H+tqDoWX1/k3mO404f55vT4QkGXCW+1h0di5WV7fI7AE390FVWS4DwBmUWz9wBH6fAtzkHDNZNpn9tb3BJQZEQRNQHOxhH2b8QNCc6+yHv65VdtrpZsK3291dHWoox1nmJRGQJ/8ig4my6IsP7YOObj0mGpB71rr8XLMhJlfHlYX3wYb0u7p4kTvVmtCJ77WxJB2H9QB6+TENgfybKB4MmVj7Lfm48yNW1VWIqvC8t0+px1f8+HJYq9+35uyC7oPREBZasKGQzv49D11EImOeGnsVGwQZmozL+vtW9LexSDTe+N+GFBkxI84TB0UK7A9WcNbuyMT4j0PuqMUyqMPXD+jW7tj5V4B8r0acb3QzqSCFcRbdMYmgnxRZTB6t7OpVvBmb/dipsE+Esta0IBH6Lzo/QIEE/FRWwGypJt5O062VB+XifHdaWzW3s3KAchi/8Rn8WC9B7Y9xQqLO/T3sfSm5R5QoHQgLflrM4x7+lFaUNvfWF6VC96WSQVjFR/FW1c8yB+RPYFRgG2CGXmIaIfK0ieSw9L+d0EtiQnsTJu3Q1xCivxCHRJ/ZAoZ8+Ef0+Hs7ztcT4hoIVrPE+yVjQSdLnWKS/gBRGc2YO5Uo/1kQXFMV/49ilRLrfCGZABpwdy/ebMXUOH4Px7NFEIy2S/RxMwaq7eGlKF3GfYvgBj1kQC4HIS2srL+JZClRqy1g/mSvWE3N2QTIoxfm7U8RWaDeuNrIjxsTbbEFo3sUkeeZJdr3rwug75LJzQ0tYrry46aOvEqpM2XneAqhZJIEQR8sjHrKobJZrYOYaAvEwvYTbXVcvXcmK2XuHRj9kpnos2uU0fcmH2npNAbzUtAvNHLla3qVdlNYVyyg1NqhAiflB1WcUtifZJR2bkCg/UJ8JbkA1ifCNEWwpEbBMJRcoGHrrKl8YXu0yQol4PZahFYYjqUiJEYdixvB2OK8d640yQfV3pPaa6RS0NktJP0+pF9rNO1WXqIH834Q4dWsZpIXhQnrhyAM/WK80hh0+bljFDVXQU4BeSiiFjtNI7Mqt/Vu9O30VJlYtbCJCzPEFieIRC3ezrDSAaHqljHvjhozTYCeHLKUGfkB7vNiSnT2iQY5JHI+NU+lD5H0Z4CbVOYGDL2SeUs5Wt8vEYTArhFEEgkk+sMbcz+SME2vE+nuCXQo0QyO2eO06fLbj6cfxB5HK1KV2BK0+SZ5Y8r+IZoOULxsOrHpnJW/I3UMicK7kvbauJUKEH9C3mnfyH49C9MoIMm8xTdL/Frvk2teO7nUD6x3OrSVvV0ad8QBQH7XfkcTTfvCc1gg8UTop+JczSAm/n/FCAO/CwpCj1gfjl11EEwT4vkWHdydRnzZZ7py7Ee2dD1YSPx6ZtmDB8WBpCJnKA5G+GLbwRHF9GWDMCKU/EhR92spETTKxD02gw2suC2hG2jZnpBhrQ+AXq0AkCTGt7fxXETSwF+yl+vQ5TlhIveEfm/wRUHLPj/kvf14XZV5Z3n636eEDafBoJwcsq0UVFpVaDUD/adikSKgo9Fp33aOp3Oow2Ux3wYmZbADSRwsfRpqKipwnCx1KRKbKq0YrVyQahRUANFy1StaWE0WhxvWxyjRZjfx7vW3ufcG4gwnX9GH3L3WXvvtfdee+213vW+v/f3GwP7hW65hg1W9HpYBByK5lrDfWAuI7DLT96VZV7uzqZFAtzJihgwLWxTGFAMs2OKWvog8MzmRbItRJJEW4NWBjgg0ixO+2Ibk5c86SOWJMvB9sWRti8K2ReayknCWO7g8c6YiomczX0bSwdNjGKZVscMgWc8gPjFkB606DVlaBTFMrvn070nAwKn7eZp39TxOlZxpfLBdOlsRYT5oIXcO8K54IhOOUlgi2JSDBUpF+abY7C62FaEuTAdmYtcqehjLIB7WeyWXwAwRX8u5MBGp6OwKjAVEkRF6ETocKCXG7/CY2p7qdIRrlKEh40zGQXOhNXn+oiAWXguMSqwQAcxKjoXB5XHAw+wEKaiBwBfYQsol4xSCTTQHq6W2aNqLFd0PzLruqdcpKEdpGEeKgEd81DJShI0a+vkvHVabPEL4DLNE8/1NBY4mBxOLjRwB2PswqaGAP6FroE/ofqBGEIWKS0/+2Odru7JYQKwSLGeRZTFEa3cRzXjYxJWh8QXp/jpBPjBaVGe4MSJQQ8f/Geg8ULqHLdAGWnGHPALBZEOxVT5DeDyF4ZgBuAHvwGubygpEa+5QIaWd4CI4AixoY5EJClqOQIWSvXmKhQ4zPTfi+hSZ+ruBfviYnQWyEMAQVRSGpNoD3TamBpFp+0AA0Y6UV4jEZrhLjBey3HHYBVa8FppBjCMQYUwgr1p8IFGGeMFbSnSkjCpwfFNOs1H4HOMxCm6OFNgget/V9sWIYIkE7O0Iqi6xH+lTTAr0a3ITTArgVBLm2BWAu1XG1+W44k9BgIpvQ7pLv5ewd+Ug6KNo4BvNnM0UuOy6izXA28qb3HCeHHehE3GP1hs8Q8WQvyDDsM/QG05wVt/8PatuuWcygE2QfQW/gEpFf/QsmjNlWNv63fWkbeF45HF+YkIgxFk6o1OOZGzQZmj/+F28QCfh4SHJuJL4WTa/ly93UVJs2QEJrYAPR5fY6KNIqkwA1rFfTyY+aq4bLQ3JzRcxHHKOAFuarTO15qe03dlBBy7NV8kRSLLlXyKTIvJ55BrNlEI6MNAKwjXbCczadVHqewp/uYgqtJp6A25gGEscRnkElR0sTjWo0CRK0zbrUh5tH4ZDUjmwhQvVl4UkU8xOKNOeI453Y5CjA6PocfbV1/oh6QNRM0qSQv7Zlf6DwZR9wr9IfdZsbo4uw8LI58DmQmCi9psGHzvJzqVrcfpCX4nM2QRnoY/CO2Xeym9EOZ1OYM65Akup6npAsQvAg73J3WX/dySPsU8t0gJUj7CLSlV7OMWXRnlXmzhS+Lm1lwhb8+qGrMsY8gDpdtq2zuSjEiSgtG9iWjm0VnnqepGyO8GRBqjPM54LcovXin5C0Sad+BIi3sskPv4QMtBGQNA6iizcjPsfk3e/FDxA5nRm8BAuLRDzFmCnH39Vqz56nmwIuXgnu9yz9H1PeLzcp4tKZxB6UUYmCFYqiIgWP/KG2eYFRCsyPp9ynOuotZHnKOsFJ/DTA4n85ZLlfs7WAPBZxxeB+t67+ZcFz9nGTZ3w9ePNRedoPJ1ygVKiNLUfVA5KS69pN8EUQ6FnjLzDLsaPZt2fWrvmP7NbkIcQ+dKEvN6BXN6eADrFU9OPq7fwr4KJ35edc55YPeqHdee+nBgxs9fsxO+5Et7HQwFvkneY3VlcYXocvVSkr8uLBUD+IJSl0GQK99/Vx8jPwJh1OwuxQcjZS905+7NMarXjWw4u2Ri61yNDjalwX5qSxpv45la0jAeDsKSfosM6WNsSM81Bg1pUnI+mSF9TGVI486THY2zDsKOBvcR+iAZV9XZHm/Cio4krR4+SuBcGXla1Qf9GLnl8KPiljNd2HKQPRTX6+qwXXEm5vPAilpjSKewniUkKmO6DpyQa+UtG92QfpE9RrxenKsRHuCfkdMZxCflQBMxyfiKOWb523RN3KWgHSub84H6DFGJAHKuix6B+sGHb8B0yIOF3EGsn4gxPb9mt/Dy6qneBGfyCGC9xACdBsIfUkq2kJrGeAxNIWAe8Lu7Hvudu7h8PajNiMvBMHsnRr1TYZzz8tDGEByScO/x4vAEtgiHCXV5RJQkx6MCR3Q8EAACTrmAVqxfS1fjBl8UezbwQlpzJHgGOmIoPQh7I+NGP0gXW8lESGZR0gn+HU7Yx+L5p0HvbFje3kMYTRW9M2Zk0zvrvrSrsg5ojQTdXbmP8cdKNBzJQqykNnujT0s/u2I3Ql0Sphfz9fRkZr52CBcs0W4h7Eq5QaQzJt0Sz6T5wZN4Y+DlAXG0r0BzSUKas2AuIc4LxNEynMQXPXznfPr/f3t/97oYIbfGqvEgvTU2X5SVzo57kt0uF7HkpAybKzdzFZXSz6H0yeDxSiDc4BUmf9Ggwsg1NZ0kUFuPUEYHqZoPs45xWvFOU8eGaplp2l10DRsbad+/ImeveBbkqcEu1DJKeiHeXwFf2FBON7+UKq07/DaAZOGL+FIXPEMjiT5vHO1CxZV8v3SW4WcI90vHxcwfEO9B153EYTQatQOp8/ZXIrOZM/kkyR9fumbnzHbmtoyutxWIfE1MRHlwmBY1H6/JuBEsWRu1Z6Lb/VsWPMI/+klKjhgHxoWYpOAI6JRuaTPEnd3dtwmbYNqwCco0l1uDSCyUlaXyX+4jwgQfDa1jYlS4IsNtHBJHjfoorCPQ1OLJWqqDKQs0oZPIMkD+nbSqwGC0r9VX1HmeLqz5WLnNt0hHhHx8Fu6Pwv2QdeLf6RYK7QjGj3b/CP6dYeFMFM60+8CiPqe9lYVbBVxhRLJa63AnGJvx7zYewk3+AFMzd7CIm/zBBSR2sIib/MHlJXawKK00ufjEDhYJ3oJHR69mQ1Yy3Edu7B/pZWPW6z5iY/8ILyFz0eEb+4d7OZmLDtvYh4AZl5ZZKrzY2AeYiG+OqzT2XQYFcAuYiqDywFbjpIRtLEUhE8EC0h1jG4tSaEiwgKzHXCXzn71yIMYKWq+FBWehEz1EsG+Xf8hrzGeF/gKCrHPR1rv9k1ApXco/98TPB/2TFEm6jH/ujZ9b270Cl4kXsg3CwvglAme8hXbvcPwiYIovALLa+EUgFdu+3TtSNhpUoPH0SPZCKtk6+Jf+ke+DTmluiHyObcP+zOUix/sTRQJ3krVdeBgTa0/qTeBAEsdhNx9VBCIXW7eluIMosNz09Dag9Qe6bPWu6JbA6xrouwN734T3O9CJB/a+BR1ioDdX3Qelb0UPqnfrEX5vHA1rvXorW1itw37vuljC1kufx7RK2LrpK9qPwMuVav30sc2rhG8HD0h2DK2JvYf/Xlz7WnkOSdhrp7NiXJpF6Rq8Ou6PRelGeIt47yzC5iHytbeLPyaPH5+M6oI0r/VH8xReCt/ZKOTZ0jYwa3AE5p+KqYBgAmbZxWbOxgC3BIMmiKM53gJqWo2GVCYDxY6G9S83MdkZNYwlmiH+x74dN3TU29fh3zH824Hj1TLRpsEZx441vbF1GinJ6tIHNFmYIuOCItMKFLIM5LTWwRQEEybqKY9/O/45glWWk29ftxomipEG6ILkXWMsB7GpdWvW0T+DuxjVXYzyLmAlWY4J7YNqmqoGudv8l9O8rtLhmTyu0f3dVqt1aQoWd+yc0B+oxtplpT/mfYXbWzlq1hXqU6ZtBZxXjG6uGJU6gklfRwnMgDZcezO5pojE4HtC444GgwhVr5ktVIDelcswimDXF5vGxCCHCMk1ROIwh2iAKdWJRaCiwG6kqg5Tu1pcGZywXKUO7CHzLVZbNTpUgYKN6H2IL5nxp5p6Qcq4RwqmZrPIuYc/KizUZvES2Zwrw4/EPZovGWHUeFaPZIajSUxtle49h6Gclc9pWSn9SjAZ9VFO0Od3BsJKdiFpx8OpIz+XrukCeMLStGwvWHLSKa0fPflqvPGsDp/C2VU8FmsX2F94qTIp8PZfcZW8iiz3KpMBQKbwfwlogxu5eAA/x15w0ZIqoCrDGMkbcwE7LBflHFcBf8qy337TNbB43E1y/nGNocB+ua+qGSE2X21/7Q5SSs7Ml31BmBG4c4CoNlYK5MNXY4C6agojTAdD09EUwB/SZGVT0DfNcmnkuimwzLm/emzfHCykqswR5lkXcC2vpsAXXEeC+eYGgsu6m7CwclPA8VjVTAsPtlbt8oG/LPfE1djwbIexjcOtXl2q+53o9znc8WQebHJADTipK+/0HFa+9E4zEbqzTv5pOEnw5YdtWvmlMTutEwZs7IK1d0AKHy7oAtO9GGFNcpp6BPzVa5KDmjM2R5LUPeyDZrKIXNJcpw26pFElj9ufUNJ22H+Lj4uIHz4iUpTpjaZgHzDeKdhHv4gjfXQrKtKnP0870kcm9qz+AtMBfY7LIohFpMoYjFg8zIfnc5gv0vT4pEMxPqqQdQBqk9Q97p3D+02tVtPglUwRTDi0wx1kopY5bpmQJFPFhJTil0ViDbg2KSygu6Ff83jNM1xOYHsftqdjey+29/OY9nZDxH0Cbg0CQAER/31JcSFGDmEOnXRV59TGn3obFcGkju39uOBsbM9jmyy6PH4/LnJbbE/DYQcLU9sz2IZ5qe2t2IZtma4tEY6PcX11BpKzi/cZSBVBosTue1UCHSS284zK15ZQ+doSKl9bnhCVqx3vRAhoA8eIXuZSOSItHC2wkq80f1B1MISj6mAwR9VBKo6qSTwuMRJThUuNxFo2kiMxH7r0SEJ2hjDY/FQWFWkwtViaIg2mFktSpMHUYimKNOwb2ZsawqllgKmIN6VyBQ85kZn3mp3IdhPb1drRvxzhMRRUKFcen92/dPnigxsgETmvOhzO4ZpDGrXXncNx0V5rwGsdwNmqIFzXtZIAzNr3O7hD/t7auQucxgGL1UNVfmMiYy+PSASlAZ5OJGIOKNHy0MUiEV/kngEu0Vokguvtv+MBS+W/Kz7cqsccuHcf9x6W9zq6YMegqv8B94vaOKofoD01F6qzMVmFMfxF8T4OD0vxp9gjjLogA09Az6PuHjeVu31giGONkyhaib1AUSaMIUkQMsrwE0QZjhBgCBNsuWgPEwTwWLFOtSiskqLSceYnjdsbOFhyFAQMtjNgEP6ajKLElgCDfCEGDGKLQSfJgNExxQvxdsXwG8hAOucjf57SDwLGWtc8wQIfiQYwga38GU7CoPGWtgRz0FZiwjKyTZl5tTRAEX6TVSCl/EhDwnsZL2OIul3chGjoMAeq2JiIVEVKq9JGavRVompv0Id8oFOVx9Mov73gVAczcGqQts7VLONkM9oBJM8QbVQaBlyi2TJ1xJa8ES2StEd0lahZuJdYQLOXDiIbsAwrs5T2Lwk4c/hWpTR+uXITYT1RoEhADluX2yzUGXTa6YfSLm0rwyyQ2ftMniDdc36If9cnyHZ9PE56gn8MX/sztdIWYAjCRjsAdqBmlj0JduD/kmn2zWY9yJvGrX97L1gtlHZ8oHEriEaYqfmaxCpIhmRqEr8PJ/M4hJePBmtxDIsFvExahgc3PaH9qpIxVwwQYvtwIBaVvJOVcHQ8bjX45H+nnOFvtgJYCMAPnSrV2Tx+lvsZy8V+HI9BisUgSE5R2r+Kl0nIFVceuPsz0pLC9ND44IFT0ra+w88lQBMZ/wBZ4p/6AQIy0Qrs0R3ccySkqnJk4cElgcP49zXLnfHNr55vQyMHxIg0RqQBgfndrMwAqfmmc6Fj+MehULVx8l10HwgW94ExPqEHbkJni31OM8NnSeokGPpujjeno8CnQ5qfoGQ6SNpUkG4V35OThww3Plwbxf8yQyKBs1SHAoWfkux+0tQB+EOfYKP8nDkVJPIGbia6UJRYWu654c64wjX/HWCDH4m2CJiu8vMU2Z3GXsIO5vA37dML+8va1+cBn05jPig7+W+EcAbNvSx+oeFD+hq55yeGPY09MBgxOEiESUIWHIuCA4865VCgGIEeheK2sG0l/K6t05IaI005Gqewdl+Ls8fWYxh/rffA3CNFjr8q3LvxfSFgYX+YWGeSXAVvPt16p/hD+YqKb0ls5tPS8MfLKb5tCVoSmDOaA+4A3Ts5BFANsXUt/uAQhPR+A5gku+lZEAZKtQnIljelKFqH8aT2k9h898G492nQhT9jhuP1dMqsnGqeB5PiwU/jdR+VCI6J2qV/EcNm5FSijAmJJg4HMDB4xfNeMgiTlApM3Jn/F1PmwRAAQ5WV6a0LkFF1kOHzAmRooEC/VfxAivPPW8jO3C4fEfytjVhVlRD8Xck9NqjJr6RhWka3NJMSv1L+blG4BUzBIMxl2CXk+9t8GjYaPAh4Gt5RQsB1hhFwBkH9fYwGsIWAb2euPm1I5JaLioGjKSEMyhuFAjo/xLHymjneEbyMotxGCgdTkkTshBU1uSz058X4cxhD4zpPsSKBYE7jFkktWECypJXaIgl+r/zeFuAwoJVNbDWRQ1VVkg8Zqkp1DFbwqaEK9g2OdiSnpXnEGPNB53Bz3cuWazzL+qpMpzzVJEcKuTPr3pH4yIWG5uoKb0GH9Tnewhjw097CGPCzTmQ6wcvcntXeGuVn0ayU2ZyF8L5lNpEYS6iZk9Yps8m/SWYTvAyJH46KfvG17cqxv8LdCJkJ6kbKOgY5dHkLB88v1fK2yk+iBDvu4g7qyuLA0fLw8oHqQINKyod54JJyPg7sFM9R1Nqxv0iBgL16euOD7HZI2kV4Z6S85XpOuU4fYO+MHINO+THukLuRNOMsiV3onkoruDceKsh7pGzl7BBkVdntg6kouX0aK3Wq2BPKbcxfBhQH4/bb15Uf/9ev/fN/u9AZcJCn1SMFEV0D2Tr2XYqNoZw54IlLfCKI4RWWB9UGcX8DB1LbHz8xuaUSLz208oIhCwY7zaDwfDuHrbNKDnmAEMplwLihDD3g+Y1iVX9kufDVHM6VTCbjoiiRQIUdujAxtquQuqKlgDKueVafui5MUNFYzwXa8v44i8hiLLdiSlQjyy75NybP7rddRn8n+SziJ/Mt9V78c1n3Q8OGbHjWkxUuizw83LIhNVfa6LYeFafVsMk5C4eUVM3epqYV11A8GZOUrW7qVyWrm9vZ6qZ1lNcN/KELe+78CG+2ztbM4ZeZ4iJGogmjlG15fubIKaIoEdhDopi4C2G2T1gjZ9DXm8rlRPgeEmRRh0IxyvTCwSQ+FwUJ78A0T51yyfp0rPx6KDmc+KH5BjB1SBfLp4GYpd1FQjTItJV4NQMDTt773ij5rXH/IGakGAX4EUzPx4gthPYab2BuIDQnyYsi9bSJqenWRrnZyMZ1pEHgyd47ILZZlJaAtHLVrvEMHYYDHPK0OOIxk40wVoROvXpBXFUhJ5BOM+TUAy4PIaceMnqJNiRyVj4AUhBZUsFAfax5mSauOzzNN5iGMAPkpgkGImE0mMxIx0RcMxjxMawxWjl+9nITC4EtJrK4bPgK0k4K/tYGtDPOEp8Maa+73Y8H3iVxgLG5TsZUMMilYJOE6NyKEQ2ECsOECLWBgAj9XUwc/gGQQBpaKGYnDCHHF3bYo/C6aAMF9hXi/ptfJvws/oLs3/oRzQ18OAyNeLhOuUlUbbTiQMogE5IVC9RPSjoMBcFOgFUgTr6jsar4SS19/8FKmUZPkapUu7TiY/t6kqHwUIkhTEnMgCzTEETvXF38gdEsGBUV6Ysx685YfCe62ec37sOXY+4JjPNYIjZALipS9HvVeLsB0RHc38kAmTqUuBtLVgfbp1VCjJIkS8bXWdULaM5wbUuZKpPN3Yv1rTjN7RhxJbP1SgLxiMFFlejNg+PFTiLSP8WohWdgzgWIjNR8ifeIOYhsG6mvIIlZoiWmoyCf3ciFTPuUoWMqOuS8ggMj2BHIYKSFE9NZIQgVee9y+8OUUt4sT+b7vBAhyIdbfWq18SGqo7rmfSP5QmZ1EwXWqB/gUzENzh8gjTXNSykPFNP8vTHrg2OM0XyQVZ3SglCHvnRG5/lXOAT8FVoBfxHjZ1igWSi5guEFTusRXqC7gb4QuM4LgkhFHcIfTCy1vcxV0VA6KcIGuP+PV74BLwRE4EH7YZYfDhcD0aew8gjfITn+OkZLoolI7MUqYxfQ9LTkuNuZeKS41dphXEewACvuz6gIGmUC6KlpufxCML+uUZ4uYNs3IeGdRdz9MxqQUagMTDrt6NmglqRIRHrtw0YpeuNBOSR7oQMi1TBO0ZTc5dIMspJy95H5Vd7/rBBJDgJTGUiyshWnYytOj1FgPGQ2FUqipkDXUwvOdWdiFkB3Z7PVvNTSwjvl0PrAR7a8A1SL1JS0TbJu56VgzdzONChOU4rTMr17/WqMd6vjoN7Eup29MR/YIqcC3WkYfGAK9Me2J43uUYgp/FyTHXZ0ZbNxSsgwU4+ZIzJOfnmzhSL6tb46m7iGueJ7JP16X7s5Hl8nMHduUaU0cxyFKA8J/k1sy5xqfpxL3JXM5EY3sCJqlN+l4CFZA5g7i2tsGod8Hfy/Z8JNwp2rloN8jGChWfiuyQfAIX+Sf6R4xA14lyUsQOpdfr3oZl0TdnKVWFDGwjpMzFvvgjgQpcetxkKFveEy1eAU+ei9Sl+mKF+DvTEGDI4gdIWQ4xj7MCgQR+6q+RtdWQqrOhIRhjHW5FviffNAEOgEuwYJcvRLKBP2ZEIFiV40uhV/uFKj9HiQjlLonL2F30GMPNCFyNTAouEb98izk1+u0sANgjRMl0BmWiEZuvgKziOCNVs6VUEU5gfCEFqjzGopPnlnD9ZWZwP8RzmizwmHUTghgqkTukPO7UOVPsZot/ZsrfZ0NniP5HRqsIA/HXBCeoZf6FpcZoU2+hWDSCSSMu50Ugg0+5zgIRMg3I3gpAm5XFq0YruoYj11H+IxqXby/9Zr31XVnlM+gFtpJWZfsdBsnJqPgBWDcxHSAsEMSd8Ug6wf0J560YxTGnI4Lo41D84ix2oBO3isKXcWOdbsvQPHmoBn49SeHw0dK+4lbE4dAXmN6hyCALufibeS0+zq0xfX6iZdCLHFYl0CnymCHNC0CvbG8HXCmTF8nWBoiLoi+GywpGLShkkC3hmbiLoiCq2Zi+Y8stHC66MlrGgRwmFS85bEPOaMuA+GIcGI/NOch3ejl3Ae1lwKoE58V7V59zbhb/O8S9cWbjOmXOeZDMy5C+7VwfE/iUYn3ahHygrjzeGJXJTGeGsMTd43jnU33wkX1Yl2UWmIFM8HQd+igIK5lLJSFe6zo+xXsBNJ8+RUWMyXpnEwzAPwRMkJNRr0nDfBxoyPoAG1FUSKP/WjDzz+kQ/ve/dcYyM6GNXqbkUTrtsJSFAKHpNZEMfSsGqDgwcn3X3717a866HdO+7mSeBESnJLoDfEgYJUv35nHM7jW+kwYc56o3mn6RYv23IJWCp0wLLudXGLop+y1g2+T98KKjl/J1eyuCV8D/qaAA/y5UVHhUkYf3AC2wqXQXPoHpC1pGtL6VxX5fkwfXEM3rSOwUWS9hLPe70ut3o1dJiO7d7Gu+IolwP9rXqgvwbLQ3g86XxAopGolKnG6xSCFVLAKWHofZsNHwhwgH4RVSiQQA2NlyP+SCcTPKzf2syM1z288mbslajh9NzYFowaVwwJkJy3ttu9IZYVEYOVSJ8ImshSpPHyROpzi5CaimgbJEZGXWOqdDMNwwi/8sTATmBGpsowrGb5uOWvIF07v0f4JEPauIBushd8Ngibxe85SKKdoJKLoCmsvjpOgFnaJMDy8lIiVRT9U9IHPSEYS5D5wVq2IXFS1hg9KaG//xjzIUfK0YLaBzpC80lYnz7HDMOY0GDGrGxt2/1qrURUgxQxsAKFz1M1xPRzCo9KQX1EtW9uAhGndFauEtSoRF5bane2zaQ7mfRcoIAVpNgbuNsdaDkAtOlyASdjBUZB3yTqBN2PTWc44ubwzilXZvUA8EgpPYQegZRZ4YS0lw5UlMdKAJ+6pwKs7c3PuW03BhtYeMX9Pi17AAWozENNu/wb6hPSnMXwcg/bihqEvN4H+eNBMzoWr+LQioiAnTCrvXPWuRTaCTEJnoXhDtKBBFVBOrBNKhMM8hIh2sHFVkrsMSy4XT57A7XwqB/aPnO5hUwuWNpqNAnjMIN6q3xc2K8N5j5HR2+scZcGh7upx8RxqVAtYWIYyfmH0syBN5J7DgMtUA3obhT1vAv2lo0LyGWJuSyMbSb+dv9woJeys3GFUj5MZV8A8xUatdNUCZcQhQN9dBKFI5N0iMKJVDqLwjVronDNmihcM4vCoapKzk5dfLx8NOSEA2TCNQgo6DhX5jUro2lb4NouH7idOgdo+n8hz3y4ThhTtFseH+9XwRKSUgRaDzQ5UDp7AN4AjqwSeDlVYcERsz2OnurFNvkkheykmH3wvYhxk5LNIUYrmTYtv5UOg9t9Vyywmfiz0EI5fthCcUDn+MUCOl+PUCKikjmgc6Md5GQnsFcer35FPUCziL0hD+YfRfTCzheOOq/Eonct15r0J3IAwpKMYxKHIXyUHoawdq+GofBtaxBqF7fCMc4ByMOiBiAfHUTuHIDQV2MAcrRVbQonHngl3AIx9IR3ZRNfNRacuCXMbDsvBZqsN0O99Oi42/t4ExJUo080udakIUZqqDVARLJlvc9pZCjuiQc2L9kDRs+XpgUm17t5g68Pi3QGlWOpy9EsLXWndnsRS1hm84E7zszr21ZtX2v9ytbDe84kmeCGXvNM3hm/cgE3MfXSk8fZ4m2KIC1wGybuVZBbnmzWfR7b3VYFb7VsSqhDqwLJ/OMyBi5SID7sG85a3OrsZ53adLZP64xTxRWGrdNObTpZpnXyqU0zRdJjDZoCNtKJ5kJ7caJMhYOB7w+iwP1MN9s6qXtj5RFTVFk+8hCdCV5We0PF4gDcmZZPlL01XKPDWQoLK53HqZE+UmVGmCgSbm/MVswkUpxFTSI0l00ihx88VJRNECbtvwff0Jca5c2guVfc7vuVx1YTsCB6s+7VSwHikzgKG8uLPfHpZ+b30F8XJXl5PU7CkpF2LTfNhHCDC0Fezy2VsW+fjpg87EwsZn0sX4+P4JboTFcXH+V3y2QSk1mCgl5DFTFh3Mf5FhS0ipSH17U+RBOqYOUKnpBVy3dfD11MzvXaKh/kP4Cz7cffYjs6FsZJT/v0rEpcmR8LG0RuLLYGcoSLm3UQ3wkelwUUeaAdoVgOuwStCn1TYuPUnOO0YpkRTfaMFHE7cM8oUs9ApRqDADlk51jQNSptZuu/0uNFQYLfG+gZasvoGRjVn7xnTMsjgSEkVHfFDYcZemQ9odXS6boQCimY079IpVLhHERvGUXyvLFIiioq8nzAW5Q+mj0YzAXmtyX66FXrEGTjQdjo/oF9IgjiOVyA/byVSCKms+/YILO2T/P5jQn58OQkR/BRo4Vc+gGwPIQiU8aXEsOo7TpKUrtuH97V7aPbKgTRXNO9236EvIaXQ4Frp7wSH9i1bCNWCtl3kJG5Q0chGTGOctLO4keN56Ocu1MdlZwEWi7lozQlhaegdrQ8Be8dApGxxx5rmfJmufm7f90obyrK3b//Gf5F8bGw2WmMt17YDAcytkiXoMUBto8uH4ObsfzhseXD19zdKH4oo2gJX6w0vMR9G/SkWUnFnhl0PTPePsoTSez/23IEhyuSfp63E1yL7CxMwRvWKbYXSWYhwrfgAE6osrnx6rm3qb1YVWivCYLb3IEBGzvYsbmj0726MvQi6qoAhmZ48C4hPoJsaDiP5WG7kP+gAGI6+DCNl2qm9QexgZ7CcTF+lpwPOAqwzaDEan80SXxrzUKvciYci/GBqeNWMVH1yIpW4o2GEyR1E2RosKrWLyH3b08d7x4J3FW6jPGTrCiSq8VcA05dkyxlAroB4vxmZG1fGT0fte+ceqJ5BVwEWg/HKh0L0PYWG4xc6bp0fAuXpCxno3PF6/Iil7Mrc+3r8mW5nB+C6gcxi74x1N9BOciMo2HqKNUn8w0Vf8i5gobC1UoNChDFfDIa8XTiMQDS/iBjLcaaXpVe0EH6qMTBr1oBlrL3qRb1iZgPLvbL1X0MOaAW3IgdUG3MmBvyNwEIN/v1IerXk+jXFnDSXs6B2AveHH0s2puo6hnYW3Cuu6U8qwvO5Gy4UQZyrwVgSF67g6LXoiGroSFS3n4ZRIZDJRlskQBAkqRajgQH7tNhvxAifT7MH3Bk6rAum6H02SgzqvgCBrFruRLX2ueAuWmGcWORct9QQtjeqiAnhM27jOlndrYsSMNbmHvGVLbiOhpiIvu45uBvaaaemsdb2lbPDIxb2hHJgT/GLRXvzHcDZ1rN+uT4ZfkiZuDcTMsHes0cJAkF7DelLRYo4eTFF7LbZhSND+cGIKZEcn65cs4JOe52eTsrxOsJiuJ2+WkW0JjFA1Fgy5ZPp/uOarHlIKUU0drU3FRsnv2Ud5QFNxVcRMSfhojYXGjj8xaNza/EJUK/1E1Sx+oTEampZjeqLFeW86z5k+hCl1WDrOfBgUFW3i4MstKncOoqV2lm4A3N1LgYpjgPtV5VMLHKIJZpYHRE+OXKY+BFkEWD6iWDqNO4vjwx6frUZIqEhCe9/C/Ur/4KXxwDSP3iOa3LuNHL8oB+S7/N4ZzjOGmrwPYvXYDGFVmnn5CTK8KHydLk8Y1SmPMsDeFfeDJVivUTS5UkxLiLS7G+Ymmvu9W+3sEMqubCDCo8XrhLg1HrwO7SlJyU3aVNuEtbdpdCb6DuLoV/ZYG7lHNceEsXwk2JvB2Am14ktvfFCVkCIYoDQBIBVhaHPwDIAlPKk8JF5RaF7Z0WBxxEcMJ2+LiAJhHUwxMNMTlATuLDeZfFQ4wqh60NlSgTsAR7sSQ6YIxppFWEjs09NZ1ISC+74re3wwSihUYpLD5491L55mJZwmg5DYEcbJfLC446mdcohi0jqh6pZMnkVmidgTzheOARAQrLB3rxElyyoR+F3THUa6vR3RJhABkY6Jg70RVuz7EK9AwS9yVTA8Pn1F05JkF/fDj16dvKhgf8suhQcu0zMIBQAgZTJE8mC2QwbMFe2+RQ1WZUNsCJyoQtv+rVMTQCO2cUt8JRzLetpxq/YEMg4PotuhutAgnQmexFAw/wLiHogGfmNFDMcEmUatTyrXhPSDFgupN5dyMgoAzfw8mBJuEnSm4j4sWYCwW8mC0nu/P5BY3CfxjUbVNHX8ku/3h8Ep2p42fie4Sap3ZNc4UhrrojucuRyOd61/S0drWmJrlLKV7MH7wyf3CW5oiYzYJb6vk+852BTH84M3EEHlLcytGsXyQHU8f70iDtwNdMldO4X9wf98zlsMhz0+3i9rCHHEDaw8xx3m33ouYoe5BXZodewbhR2hy9lFB0Vc9tIoog6D7Tn2DHQsNAysT3N9abPH8nacHBe94bf/1O7MM946YuQeyqB/ggesul7CygeqoA0PxkkTrKXAkCEnrE3LbKb/u3/O/c/yh/d4sr0RUPzClB7xiPWyqrFN5480Kc2jjNW8BHn+wt4KPpmiJNxKkNDLUOe18esAKEEov3YwXHScVLZcDH6CkmPxZHkj5nUqEvNa3g4TSh5iSUPnw2AnrRJf8Br7eRZ6JVcaSjB00SzTRUXM4Dc6yO+7tsGasr4KLN8jOCdxIKl3AKynnxDB6X42Vw6G4tH/m33JOq88+5/LNWUdlxJaxmO6dx/NxOtBuw4VzhAh35q1aS6VDF5RVX45/Trt6Cf8dmtlBN5vlX4582SkanRlGS0mdxIFzxKG7yQIwjVIEZ49FjOnosjh7vrskGV5o/AAIERl3+DsQs3gybJ7gixEVN0FH54QEJ9scZ89gAM8ZZ7GyJpMO+yzrstH8zMfW7A9hwgNDkQLZuGjEXy+RN4+Ri+/IQeYAM4FqQUkdwct9UfQ+w8pQXRSwLl8WRDaAtZQNoS9kA2oqcl5Hi5UZS3m+4Pp3SFVY/tFnLXoXTD6hZhpTtGGl1wDNmm/di9didsCWE9/JHBhqflGtaZaGmrZ630J/5ydCPWNHvkV0H63jQ6tDpmPLiU9LQxV5qp9QnY7dNiSsyJCc+Eb7NGCqi0hdPtS/NOe/TTf1SZjt+zvinstvxc6t/KsMdP7f5J7PcdUmGP6izrWQj8jLpKOTzgGRlpX9AOgo/GMTFj9P0Q+rZYsHHD7FKg8RKPxiaVDqTlyUMuQOzyWA70GKMpwPWRTgNwcv0l+AhRccY8SARD3kDpER8p38RvAVnTWF4xt+3bswMTeLLihvxzrfknSeIXStu2TvfNLAzHuHk2PnGgZ3xsCtj57kbMxuVeL4Id4c70ixgrakf+sQW9JKaVwI9DQaCVPZCaB+pDFwEVdmEy8BKUJVBeYNlIBmYeu/9TzxxI8vGXHZuboigFeiuZrSDrAgwJoPeBvEhxa3OXl5eNc3ITVlsOIMGxGU0NRFbK+XfRNfFgXYumZN7evqSNdm9BFW3Cm+mWOZ6DcZPMg8Mr6mewRSwNw3SbzO2EyQxi81Cn0Fiia+uyz7Tq17PpBle9Q1mSPqZq/HPCzBMt6aehX8nLumNk2VnFAUwF7bQKBxL7tLeCAZ5GB5YF3C0P5ED//Ea+I+5GjMEacOiXg4egzUPVEpFlB+33nd2DNDE6sNDJhupgi5RA3vFeEpPU0QGvAkRsBSeSOz2sPURQMS/SWlO4dqqGoUsvnrAI/lHPvU7ZI9i9qJKtjz1iLxLLo9KjeZAIf/qf00y6/ICyGshoRAE8IsXBhCSZ4N762xYv6PrETFeg9iqlHEFmHY2uKoSKzCyIYWhXZFLMAFAH0DQ9hrxEb6TiUScqFsbVVwb9LKYVcn19SoEmHhThE3gEqKxk2KAI6MtFMghq/TM2buQxImPsomxPVR4EpU/MyOgo2xXHL/b4nam6BKkxWwKrYkI2ybXkdj7QYtGbwuvDfSbpz9D12MNbpkn5PLSKzNJIwbqRJE4sKlDQhscqqXgb/6/WqTXrrTz3/lKE+zMpxSbOt1Jbn21wc0rhGQWNG2Yv4QQtCUw8vfmZT6Psp2fJXe1cBAVqMGWJDyrbgE8aV7TPB77C/KlZd8EFYBptczYVq3/H13j0AuWTjZGRpojI62RkTayCLbMtdCzR7rlldNU40PJVXPcaHfLmWmy4be6pDbhcqhcok7Y5Nph6orp1ubi84yNwWgApXoseusx9hiuu79Uj0SUEyEiDQwC03GA2H1+49YvktQoiScTq9uHA8+W4keSpYgTxlYD9lPXMnnqqm+8/WlW/Ta4P8WllDxaWgfSiygkAg2h4h/EzuYFH19k9ZKr11m9uGAZAq02VdMj//muQUfW7ww80ANk2ec/ipM7+0z2J7O2EKi+1zICHLZ281D+QxeFDiz3xK/Ga5JjU+5JjpCIDvPcCLHgoyec+oJ8bcuMWPaNzvo39MeYuhJir1x0HDbGUVZgcyQBUM9RKS4mOzS/vUJAtTqYoOXklN4YoabyyhgWTkiPJ4X2wKQQFjdwGlmsZHikd+5GE8IkyVg2XIKLPj10SBHnlF3G60OIOKfsGuLjMQsnCmIkbw5D+BdpxoeeHvs69PSGA7fhWaqp6yn4mnzGA4hv7fnUomFZsgIxLLt6CEbocAd7HM5dRa12O80wLGMk/7PI8WoblE8VKx7OxMAc8dCLsM9agQfGM4uP47K/hCUe/c8BNFOKbGSOYGNt4jaiajpSRhXRIy8IgWZ06ZTtsxlAeS2FCWuI+uJhVP3W+pLJZNHJMS6FPmXkKGMn+8aV349jiRUI1mVT0k8zccsH2J0uyoetLAV6LFZIqx3cwYvZjaQ73bpx/Bi80D0dXm9wuFMSCoc7JSBwuIMZUH4NZ3HQ+yL/Ysz7Mv/ChngYf7vEEFZv60LrfqTkekJ6ys/euqgsL0B5/Df0P5IeUlqYkb0jbSVCIappFB8K4v/xbvdXm/DNyFWmWazml/KIJIgeo44jWLnHLDAydTrJMDuVG+ylV8Kwa6VZBl/p1Muv5AzYPT8HMCgVjX5uE4hL9iVKXMGxAeu6UKXjSFwx8IjfO0MXGgPxapDIlryu3V90J946WVtNqisppfbSqSA3xJoh9U2BQRGgCOCdmdynmsgQVYhhsjbaJ7Bq4E+Ld3P5kXCqTxNkGvP45dU8js1fEzw2LEaSnGBUZsY0u/tOvg9IztOPTTQiVjW88cAp4YGlcVs7CR1BerZ0vHU246CuL6orneMnq4InWvQmqoy2KToGVu0o4Y73mz4GBdhKk8hvKZnLwWi4fJCM1X4lPTSCtb+uJswBwOnr1zI8Rt9zc+qG2Wv/6s+/8JUPfa3x+jVr44zG1Owdj8x9Y989j/7a+b0Wz62OOh8Il7Xd1QlEnEJP6I5nuLeeJQhxzJfM1k4I4j0wFOAGqBH0SY8Ds6LRw4nMNNDDKcb0lkEemgPnJdNXqbFjHkhLy1kwE7lOxqAPQ85GLWuy0oFGk18ZQDQZrCRRtWbx0QQCceQgAKh5TE2Iq6R+k3Iza5ApDI75bSc8BCz4d6K9nSYt1NQv2EJoJQsBfGjAyzqpHj9uTT9I9nBL+kH/0c3ph/hv1CFenXEodukMkLCoa+eelZAVNTkGeYg4wGPdgAGDYQSrL3L448KV8QKqYCoQgtRsRC4jrBleUSKi6mHNasGbsrBeP0DaEPSubO4PBQRBAShEjbSS1LyQcrgj7F/PgQ0T7tdzd4FWU3kNxmvlUnoCmMZPO9y8xTGuAQyuHXRUyR+ULeLpli3qFi8z8xIu8Qa/SpLreuBSm2X6NdMEe5e42+jaJPqSySAVLfECNtzuawTZUZrlCFIQBaM9e7mCZjRAMCqHt9ntSul7MvKxQTNmpiLw6v5iqw1jlhrvJaDlSvOEHY/YAZGsGKjGgLjNOFpAIMJ0p7g7QnXAohvcA6s6rDo2c/c/5ZfmbuwcBizPiabEo3TKx95pjZlKOVyiCAnNiEBup7zmOk/kQnUQ4chmTQsor38QqMmmdcFAi9dRtVXTsqnjVIrVU22t1JsqPDtOnai5Ea+r9l3biDOG4KcCY8WOTflg2nWO65WbWsUvMtYln+A3WiIPxPE8KhMkxvidMWg0tGV+sEu9rd8GCuUCFB+NyUrJ8yAlL08AApugYYFZOHz8esrwgyGuxCG8P6xfp/4ega2vI9pjOwBeN01eUwqFsdjr23Hs8OQuGJ7bQD+W4YcDT3FKQzX1UEy/IFAegh7CyuPE5uyBiMuXk2d20Er0CAib0eqiIwypoQ91g0bxuObzVvnPXMEC6VDuh6ZQ+TyuPoEyeRe2b34PXvmfUPgLGLTiDnjOErYetmGj+A+pG7zaNdeoq8PVLDA/HbQev0h8AHenZnkW0n2s7iJHtVwbbxw0SI1TwxfDy+Lx2CMxtkhimq53isTKSU/paQ4AEqHmOLCTil42YgUuXet+CWMl4xJTX20sQx+tF3ud2DgCisb1Yq/cG0tgwdWL3YkbCOMMFI93X1c32kg0zIFH3C2cnWiL0UzPs5O2Y3ay3VYt1pPB9iq0NAHDNckhDlMaZPwXkgoUIL1gLXhPyODcazM2X+NubqOwu6qa2vzKRPVC9xQj2XRPafkYr84kaHRVVyRl4oDBHZ03+JARgfZHWSMGxA6+NNwbSeVEGIJhlk0CCJhpTNMz/qrNOZpFU5edx/C2UHxTG8+3AdSZ+su59//w29d/7G//8rLz1wAggMjlJ2ol+IAuOw+QhLCYGlNzl/+PTZ+/7z3fuh0713ZnmdQgQyhhLuSQe1El/5ft/sgyjS0kmUbIiot8Fa2k1XYBtZyaaxD8D4iAoADGKiJbMPTLaoVIF4z0QINKhByQiWQHXLwcfE4epUCUB4dkuUJ5meUK5MHlRQ3fLMR6muXl5Avji1wRlpi+ple6JjptXZUYDAFP1LKE8ESZbPgIKdcZ6WENABM1bWFJJ9zheXmpi4HDEA2RHOEGXiuUhvwVhKmPc6GrdTDGY4FUNEcRJuh+HQPGeezGTJz/LaTNEYuQIQ4yNrWGpS+hJy+V0A3Ox6BLWaQ64p0h4rzAFnATryYhEKcFJR3pFpywIEYPoLsFFMQGEH4EypuLGx3SKOF6vOJ1EbT0zBYhWQcx+ULrgUu+y3qwkmmekdRJ1BFHb4UmzxkmZjQHoj4JkJtzHNMfsuRy+BRtovC9HMr+9XI8tFlxNZR9+ydgJhzHHkz5Vy/c4ZvmkHstuRFIkSpVV3qV92Bt5098HmaBQBGHweMqcYfRqUbxTwKbQcCCD9dfgl25dA6lknI4HKU4yaVbfWzR79aPhVhHj4ehAhdAl9MyEeP1k2d98rL+5MCFcDJrQwVxDRTwvFzbXte2jKRIVW27XFsP9lGttj2kZajXNh+14RJxFyhgRbn6eVdPJEut+r30/tcrmp1wzagsnhoFrCjXvIuMJfWad+EI1pFPmYtTUE88Kwp4Sq5jb5yCo+KB4oh8ynwU4Kg4Ba+WufSjeID3PXbfH/zZrZ9pXdovaknCy6YaU9/Z/rff/OOHEL9N9eIslm+658+/8P27f1i9Dtc2N9YXTdT02CXg1qBO0OglfRL6MDt/tI9SIl/IrE94E7L3tWf/KEBOE3Ceb74EPaS6mcNqN3PMIjezNW7mB3/1NxiIo/FQxmOHb3DaN7h1jDQnuEGMspLg2YN7Wqo9uFNwT0N1CBvS7pnDDfe6w7e8m2JES7C9pHeISx4kTcchgOBwL5g7EA0fuwT/w9sgFnbxZ1tSe7ZjF3k2iMfrOerPNg/YHI8dfjbyW/IJxt34c3g2CQjN4tmOUtNj42iV4Nmepdc+Ei9oetGHnOFDHo7tQ3uH+8FuoxjPod7exu0j4uFJEHdElPvhx/nMizbAeK0BDq81wPJFGmBXPGy9AfagjMcONwAyevUuxyHHxYdDAzy7V0ydBIzU8XpsFEh4aRcaAshOHIKNFSpBQ+j978GG3v/eESrILeipgFbphR/Se5ZL9o/0ju49y0++Y7R3VO9ob+8b6x3ZOyrKgc3qHRmto463O7dOvX0YOUL7FLX2may1z3GLtM9ctEW9fbaijMcu6PxRXjtW734CEUw2D8LA+hj2pp6zCxtHYVRjC6rjzKF11HG2po4zy2aCWTLYTDtG0GUKPHDuLA+OYHuF99420uv1Vrh8/1jvhF4vOtdY7/jeCdFk471n947Hdrf37KhBDbcfDYev/Ug1WG5BLCDdgqOph9XCcjvwOehpJnCrfAg8p791bByKAZePJ4mvaTzVYcMveFvtBe8eiRecX+1t6Pbp1e6Dunj6CGbUpDsm4gaPyXdsuRjfqe57+HZ3xe3uideyF3e5BDMJ75KcSYfhtoreYXGZBQ29DbQ/vaVxc6pgt24CX5Fv4Slv4DbewCSu5+aax/Uncd0urushb6K3JF6J6t+H+tEHWftidU/U655j3SAtQi3GK/KVTqBX1s7mufwksJ7fTUwilT2RXTDJFWdKYRBVrV7ZJGfeqU+8/57P/f29jwKIGEMB9rL8xs//cOc/73+w+gSA22CzTdKMWHAWaAB01uZHbvrKV+/9LqAqMeKinMcP17bHtW2dpHGxoDaYwKrtiTsf/fgjN3w/f7J7o7bhq8yhNtYzfJVZLnXwYidprCy4ilTdUf7ef5j/yrU7cmV74iLDFwc/gi4yfHGk59AoWHDxeV98dvFmBgOOrjJ08dm4yPDFgQ3SRYYvDrbmRd8W8vBVz1D1cOirmuHq90Q1C6qP44eqmYvDFzRRlA8dDjogK0H+eJYSzlrMUgK0IwQtNVlDhTIspWZlKTUXsZSS9OTTspRAILDAUiKV/6KWkm8Q2pwad6FCGJZSO0bPOdypZspZbMhS2oUbXmhEQDVz2FJqVpbSjAUf8UDP0FLCYnShpQRH92KWkkIP1KcMMxXPpvluDs8mS2kW8jKa8CBg6AnvrclQWvQZEekYMpSgKJqHZCwzK0MJGoRpjthvQUQ9+zM2lABEWmAoQSZpMTuJ5FrU7gwzCY/4bOtshp20FU8vO2keG72woGQmvSne/Rnx6s9dzEZ64/AMenE1gQL7mS2kHZ1qGt2NGSdPo1aTzM3yDC0k0CoMG0hYDy9iHy1mG822PQnPpe4/jSZRX9mLjQHb6OToKTCG1FOwtlxoGK0cnq7Pqsyit4RVlO2h/Z3KHtrWCXuIXxT8AtkqUmNBfTQ1VWUbHZxVNN/2NL81fdd78GADVhFIrRYYRcuqV3rasEm0r1OZRJAXyyYRaL+lIPv0TaK5TphEuNcDmkTjC0xPcteHRQRZM2nPPiOLaBda6AAW0W5EsdACqP+ZWES3dZ7MIqK7WrDbyhjaw+i5HHMXUI9AodRzs+coQumOyRi7Y8+R/lAghRl31khhZIOeo89vlrsMwbDp9wCiSufR6+rOPCqOiHscoTcnCx04GHBrCgbweHiX6HazN698iqi4gOTtmnAF00YkXJEi4asG8zPheL4p4Aw8RuzydHIpDtXUL0hUEdlrjjaKkjjhsvtaZZ/U0r1I/imHpRBYwnZ+kHgyQaDonUYZ6SgUbZ08UxmOvKrJmhSS9Z0hNmlc0IOzoLYXcWn4twWKkl9bUCTdtkOWVpdhNBK39lKE+8llQ89b61zEa6yiSSa6lkUwIykO7P/SF4ngjTIMyoWxBEW6CGKFWAuDCRLNceDgAoUV0JHMzq3Ln9VsiokPiW3ybgLDnx2bLfzIXk3+qFLU8CP7M/mj1/05Om9PCHrQy4JuzbAOIbkRomxvkNheoPlAUbDewdPuGQpLi89H4kTghc8BhoQ+QOI6S63+7CMsvNQunguPdmoHxzLlejaYTnHovxj0P5vJdoH/+QxF03rIQzZfFyRr8EeEuebrEjg88XU5n7d+YPcVroA0xaXyNeJJxTyjeC+RFQ6fR7QX/RTecCJ12hd0zxDY2tnrjKwxdV+/jOsx0N7EdNT/sT5vOKnVH6YWy2h29LPDRiAIa7ARiMhyI8SnUlVRk9X9Td5X1Zn0ISwp7jGzCaq7S3CnFE+NKlKkwgEUpbgQrC7YR1JRE218kIrhOqenEMUZP/anr0f8Tv7io4LsW8fZ8KazlehDV3AwQOJHri6uyqmvBp+wgu81jd9rRZLYOUqCAFz86Y+799BjLz25tgbdGpWRcVoKrjOMrpr0B1RMCrUH91DU9MErSKg2XBPHIvWH2lijmvTHcAjXVAEjHmJNHIqipv8YYJOAllhrISR5JMgwDDCJz5D/ltuo6Pvc7ssUzTRdT220skCFIi0mPgG3NG4S2fCz5Gw5IkKypw/ObSkaXwXg9U0vGno/Hd/fUBw04p8pHgqVtMVDnz+Hq6Z0EKiKGKGHjVNMFMU/edwCQ7XZjSwo0n2xqj8bcExTlOvb54WDeIKwT0KpUoIIBvhu96UBry2+XElBM5Sjn7mRU0FuYxVgoFnwnXvcx/TbIWRDokqixjfvW+J2ia/j5UPzhrghTGnR5umcLXQ6Z5Da6TFpcLj1PBr4VsQEkeYn+Kw2e9qkzXIzycAd/S2ma9ubWrWbSA8hBh4PVk/9DC/Dy06Z4RoUFRF0uDCzlyXiJWeLC+qk6S+1IDXdIg42h/TWdvEnuAGBftjFrFNjcE+dphJX/1lZFPokOTkNT1n+7RcItfD6XPWQ6fOGAn9SQlP8j8zBHKrwHVfhviOr2U2sLMSIiUBS5+ClI+8qGyQmC4QdaePNRG2oFzT0ZoeM9jJsQ9wNG0QNphGeNFeasyYAji6hcFZcYfNOCKP8HoL1aOjw58ThFwfQDPFWvSEgGYYAYnl+ZnwYU5MIF8HgnqYm0xZ5agpEmIhFCDrFwEZDRtIYiFKnGZB475cEE8w5hzRwB9hIROXD32J8/Uz8b3Zfusj3EF/Dt57ya+CQqSaX2c904S4EXNJ8LYZFNPott7+aoLmVrcc+9epMSJknbohCHcyQudh4WU2VFfjOuckzxGZDMyNYgDIJZLr/aNZTB2Z8z7BLVhf/2WBIpi3f2hYuTRxtggGCxGp598UcBdhEgAAxq4iWnoBu4ltQ4Dyj/JLRmUb3+t16RgdZ/lPcJ4doGlGHEC8vtshgNgirXEQFgtWBRIa5Dk2gtgL1/dN6rHMY4D/HKH9uIrGBRF+Lkfx0Txuyg36qNtVXFO9fIp7IBDTJ+nkRCzY1V+mC6VpYt+F1HfBixkPIVP1Ru/vTnoNbZD3mN8TpykAHtIXaq2pXdYl0PmQQeD4H1qcalzdpcbPouHyarFDzXXqYEITCJLVaFFFdIyY5MSFFIx/MdZ9iPniq0/cc+PQj3AZ3YUFavgOqcMUVnVT2AMs+ilfFshdqhPjNsvmqNKbhdcCww6HuUuzPmDD47R4KE/uUxQxiWIzp60jczqm3Rjc4Kevs2VSEwpeRNrxdbKLgFpqGwvb8TFhdiy2AkjRWnlE4Kz23+5Jcv2fPnFbpjB0iYmgac3E3UpyfsvgO4q7uy3d1WJUBhKG2eLw9WNJiCSsksZxStxoxyApM7PWN+LKbWOFgdYBJc+DjHwK8YNB99Lok+MktoqnwrKTDrM7MAEBC/nSmLIfrkeLrBYG2bETwzJdwwBJ/M2aV8hPI9MBg8y8YcZTptoSZznONNeWeTdSiY4/orFm+tvuiYQEDapdx3fkF2Vmo+wZD+D/N1FGLBRRp8JylbsUT7e5S975punKmO9X+vfd7Pwe04ENm838H6FT7EnY4ta3GCmnCVR3EyaOV6p5nVaj7BRLzUqdOUOB2dGqxTLeoQyRHB57b/c3dwPPdYOcRX5M5PtBzOu4ML1BFXgxxaE0DmNTTNPTSVrnmL3A/HOZekIyc/N0ESjtmlw/i70s4ovpred7B1B4j6AvVqCbv4Li6yNEo5p62jj95YEHBcfV3+aIp1C3wG1W30bIojGXEoDMsLcoEGpfdI9GsSL0y4q3jFOVIGad1Ya7l7FrgPdQRck4fv8t2QN2mQdBNdsxzhtB+SsPAx2nfVpOrglgqcxqGEbWSw5ZWH9wWDaxSA2KR9sC774wsTxp9bO+DXX10f3JozGgW14lIvaLxUgf5L3qFgqx63dWTxYxks/rq1GwZIcD0lKvT/01+N61Obes8V9fg1E8TQ595XKP8Bnpe+Zxy68fQAcmo9h/yW4+XiOFN3CzNNcS/mqu3e5JT82sUVCQxeF2YXvK8acolLVT3RK8RaVslOYHguawo3rrvaUmEMDFWsXNKZJBeos4qZtvxc6dFiNWTkmWwi0dip1SiKBFlK92ZSII9YuNVGESF9Rb/Faz/1APRFJLZU5IKcwCVtaDFkO0wK0hJfWojWa2QMKzhmsfWr9QPiOUhGFi9wgU+sms2xCZOXexYDCmojlKcSnM0rXgS2nSTFA/hdXS7P5Faz2kVbLwkMJyyKLo/xbfN6KRSwZgbxi8TeUfwr/LLiIyxrt5oW1Z26IqFaVWjDdcFa6Qo7LhSXKYAQGK84Cu1DeGPEzTk9Pc5+Yvm2O5Wt/tsj7XrL8SAUS6h3JeEwfC3mGl7b8tck1TbWx2E4G1xP2BvELeLVEx74fnEXXDv8WwTzfx0ThCrGh1JLoLuKqWYndJ6E1DIH/ro7z927R99dP4rTiGaeuLmj8/cfe3fXf6+y5RFNPUv3/jEQ3+0/Ufb/xi/KZ72zXu37/nynn/66CfwW7dhSwkmsR8wLbT5gM+KT1dWJ5rpr1tweHZf2T0+6MHCGTm8aFm0Uq3nWOmxla3AfNQ3g469fPk6TL4rWC/fw4c8pmrY5Q/qGTSL3+aZzfKERM6kBoOr0A2GM0l39j3D4fUINAdony5FKi7P/Cxnz7vwj+5OjEfLcVfoo8uLC7snRJsikaqADAYHP/9lhtu2eJ3N4vE8LuLe9APnnOuz8fAHOvtonb2OClS9Rkbbixr1uMVuXTc+Ye7U9B8bjk52ud0zKyH0F86NFh/gosdoijogBdnt3jjRWoJJN9wceCNV+MUJtP0x4p4RpODMN4GPG4UogsNbHm6sq8CsDXHyC2lTIXEJ8QXAx1ERRdGs56Xnwy7k52u1qkUveFM6JYlVQBwzdhHGvDcD+s4EVErzQl1e632MJsu7WkeCkRA2HsUrGKTAoHIc7W2NUCcqR99shytbvf5IMJwX/VHSJeG7IeUhTDnS1KAKJXKPX1AectGbkZWzvp9qPJG6vNQDZVoVQ2py4j+Bo+U1l3kK087iMcgMASXR1DW0myBHiL4W8tLQudYozgTepXb3khgI09XP26DhKLoUwkH1CYQUQOwR7Q1sSJi1q5broVZCnBTj34RtZefInba6uN1iYzFs68dZaF3OfyIhWolkZf6QfW0NpKGrWc+Gq5EY5n+ez6abpIAqzVUtUjCBjxc3tPtLi//Z7GNyXzp1DJJLRYXPozikgbCHyxsXNTjiYbxDX3EzgCkkSsZXNsZPUerluDPwfQ88DmnFFPCWFC3mPkp2j2JZer/u7CTaoHqhcvrjDetlQTgA2dvyCY9J8wezjy4JORNOGSZ+Z4RMjT02M5UaAFw2S6eeePxH//b973799icam43Ll4GmpYfnFdrG5o/HN0dMd7pnh1dEZIlpy6vqEWX/4YUg1zH0W9AW/Ug4T0Eb0KMqxWpa87KV6ZTQsRq6uez1bilTxIpPtqG2376mP4k4HJ5VrwG44gvW9UbwhazCBwDentX9Sbqr+VWiESbjJZGURSeBxSFeUhSNpguNonfTCqXyVhvNrTeyBIU+jm8X1+GpUQYcUrxFIpLcIrBHgYDpTeDFjYNNJN3GkrgNUCD5Nqq+wiLrx+LrlNmJfFYs3X623I0/1nRP8VyNbENDoAZALNM4OsY03Cm+Ir9HjGxfaWvUDQeArnAXJYR+onwQf3SFZcP1hr8ihuPijZ5nwK1jk/TwcLesJ0+CsydQRfbq1O7kHE3gtKpv+TxmlReV11GgQU+F8ou6x4ShF/lNzm7Kl+ZMAZKt2kzhYk4lg8VYG6qXczyTfxoVayl4Ex8VOSUVgcFRVazz/xD3FoBtJMvaaInBGHQcVNgBM8ZhZmZ0ZFu2FduSIjAEHWZmZmZmZmZmZmZ+X7Xs3Zw9e//3v/v23OtEVdMzPc1dXdQ9OjCfHszVenACQkckFuvfE/g2Fb0hVsisBLipq74/svvPTcfPswKZDx+P3fvnw9tZgcyHk+Ez8MfD0VkBcsnJD+Er5rS/czE+SP4oxWTWwDi/5plZiqwaZ+kGM8VjqB+c0notl9vKPz9o55T6Qa91zo1++TPPxBGioNTzHBz3nGZT57ezMY/+cui3UpzmLTQGxfhzsUzyFTgk3/lOESW42QDcuO483YODZZ2H7uikTk0jvk4qvthV3018gKCmUO85Bew/lMuZ4jaXhw/ByAzclPLh5hHO8oc4dx/yYdLOvXTXeFXjYzOYbtYRL/FZGqD4DRD1MAupniv4uEqnPo6TxagCaecdjrxQA8UCZQ+TdgDKESZtAQTqj9dxURYJJYirYrjqLK5CcNVGXO0nXDYRl/l5wam6rA8LXJnSFpNNrqcss55/nqSeqVbgevJh2c4A6okKMrVEkSr8aZX613rC/vxbPVng+4/Vs8Lf1ZNl+DpVv/9eT6Z0In1OGOjfEnYmwgn/3lanoDhyFj0znT8LmZkWEvm3tJxF47ScqXJ5fk91wb+lKve86aRrbJLiDx/zmfP/3wrsrPTPvybNU/Z3wuXKhMuD53F/59eYPDEv/xpJUDeO5GTuxbGyIswf1GQ6Cyxm929kNEmQ3Kpbx4IK4OhZp1mNlbNVvZyfYD4sDqFyKsJ5e7UQ0p0xcOw7x5g9hxUYTFerfsbhR0Kqrfqej0ES+pJMfRhYYy0+NvO7Qh0hUaXTIHIi64ZZkQXpEI+r3uF5XwZ1YNUBR/9tLcpMDG8+A9OXlbTzqzbOpPfj7cykc6CkOCm56gnUiU9M5mb+7d7lrHtcBHz8XKwFTP0QLMqLZFEMR350jrU952QuPv+qff6LxwEW81KoIlvc+OQTllY800UCQoLGFx6yAlgpEciMJPEM/e3+EGf24mVcQ8d/OatZnYXJVLE703IGXogmhv6RZa086N8/UvYSB6N44v1aiF/1MjMDQZ7ZnCk5j1hBEzsPT+H+lPPpkArWu/KlBACiL+6X+02BmGWUy1Rl4lQJ3oAoePvMT57ho3B/7Ib+e00lH2KpYIeDv6oThWoOOrgUwaV7ZIqdSGy2BJyVk2Pg73VDXnGK9Kx556rCJ4uNfuJ8ffHhDEqqehseEF1wlfkSn5ifKbnG/zdP+P+vz/b/+5P8M/fzC7nv//IU///y/P5/Oa7fJRyD8zelqOdsYagU6lGh4XJaooXfCTcMU38x1F1m7dHa2NSym1yeVKzTsGp1nT4mxmCx23T6pCRdoiFdZzN2M9jUySZDstlkjNlNbtGGeKNJV0lnMMXqfHbLcLUbhyenJhhMOluSMcZoitd13i3pvJuy2ex6q10XnW436IymWEOabndundGmMzvsOnOcLtrsMMUiFJcZ3YMT/L+N/Ddpl+DoJrNdp9fFJOitzlf01vTyOqOdHxlNNmOsQbdbrfPh12y63cpS/4fc//8ll5ubIistUVa0qF23200XjQohL2eQMmP8Sy0jdfYEgy4J7YlsdmcXb/AdZ1S+R9mtelO8wZlwVoGLZKXifBZntor+MPAtJBZvT8CLns6HXNn/L695GU0p+iRjLF60W82W9D+eeEUbUTN+KWuE6OzpFjQLFa5tMBmsxpiqVqs+PTIyzmpOjjLaDVad1RBjMKYYYvGyzpBkSEaSNmerpFkMMXZ+QIHtk4zRNkOMJSg0LDGwI8qKN036JF2MGc1usxtMMenoFkNMoi5Ob0wS73jqbTaD1W40m3SdkwxxaF0vndUYn2DvnBlHq0Ox4+yRut0arfMJLv/mNc9/fc0Z/+9e9WhpSjSZU026mlar2cp3tI2b/xkoHGN2JMWKMWQ0Ge1GNGA3A3rSatDHRllN8RwnW1bDYqrxTON7RbPumRzJ0WgwdESq2YoRg2lnSbDqbSLWbqnI468NlZRkiEc76a3xDm5ZP8TxTzAnG/yT0xMM3fz9YvDE7G/FHLbZren+NmuMvxgIfjFWPUaxn9HsG1gupFxMXERMWHRodGhoeJz/H+n7BvgFBfoFi7cMMbE2PRKKMacYrOl+Vts/kE+MNd1i50z8AsQbGDPGtH8k6RiHNcUQFBoaWM43Vp9kSPQN8suqSCpeNqf+Z3IJRlUC/+lc/rY7MDHshjT7v2VgddjsDou/3WxOAhkD0fIH0YhOMvimRYRFhYX4OpxD2DfJaHKk+cabHP4YUP78FmPRCbjmm1YQP2RjNYi7gkb428xWu78N5NEQ629LxpLBN/5XyiAS9O/qMMYk/m0Z/jsNbdFbE7GcRSWZ7VGcKdq7nF9gkHj5t2f/6fqiWc2oLG7HJf9vNm6s1Rj3zzQslprYKJQW/8VsdzZpvMNu+09PdrtVjwXrH8nFgcXOHGvwNZmtGPnGbnpeQ1CdQL+gUJFCktmc6LD8M5lFJ+kTDUG+1rgY0WCBEeI1wXj8wzTFlm5DFiGZfcKL+b/n8A+POZsd1IOHXDoSSjfF+Cc7QMv8TeYo52L5P1qAzPUZU06f9H8qwn+nle2p5jTfBL0twTfQLyxzRNqMafb0qDizw/o/PLWZGftPTzcbGlH/H8rlz7X1P5nLn3WJ1sckgm/GVLGClfN3hIX8D1Xv/z7j/9iAsVux4NmZB/9HKhtvAB0GP5QsyGVgmJND0tuSg4OiovF2vOGfyef/tIBnznOOYrCKzP9nVgWLwRoHMSeKyQDnKFrd5s9BFPW3OynWuP+ZEsWCh0+2mG2GfyQ7Q+zvozjQDxll0rl4k97usP57Lv+pUZtZcX+LFeIjJ/jP0HCjKd032mgJLoc2DM+kDUmQnR36+H8mh2SDFVUF5fmj6SBzR/8zafMwi7ZyayLxsMz0rfpU/2Rz7P9Yx4CN/R/Nz7ne/Q/k+CenjiaNSjGAk/mbTP+7HPNv4w3agyxO5Z8hlJYU1NFuiAhz8uPOcQEyzBqc/9y0ydIZ/WM5oMlBcgIDMvUHetY94d4/kn4XWyZvHOwXFu6c9cbof2g5FO3sK4rLEzPID0v8P5hBNIZlom+0Iy7OYP2dav1DyZtNMYaoGENSEtr+D4XEP5X4fyWZ/FPpi4GZaIiJ0TOzh9H/j6aekKxniS08k9L+Yx0Kwc+XqZZzPP7Dif/raCmXOZn+ybJDnYm0A/1C/+G0LdGJsXFBok3+2YSZzMdkiW5gav7hBv9b4V7cFTlkcoSCfP4WtlkFq/XbnUzm65+ZeAl6bslyfuWci2iCPhSE6bfcsyYm36ubqbKOS9LH2yjGnqYrXFHHjfZHrKiUgKiQqEDw4UJRGQXR2sLa42QL7dbokhFVFw27gacwwghdt9PGQDZDUpwOt+yZ+niqBWuDPQF2EJs+2ZJkKOsMhAX7CvMNKsgmqFRowjlBhw3GAT2nZ4GJIVZv15OPKKSuhK55zepNULb6gVG1GlSt3TyqRdsmNaMaVm1ev5SuYsW/f1q9ccMmzWo2b163cSMUDHJZOle0UcsGDcjiiP49CKsK55gVdOafFQIzjAr+a1Q2+Pz2/PdrJ+P8xx00G5r6X98OC/nXrH4LJ9vieeAGB/0lgUoVdQG6EiXYIINQhYo6bI8T1hrbH93BZie0srBGoS9gcXDVIa0/zD+6srCM/J/+/hIfPp1/uSPxo78dJoaYZEcSS23O0WK0RUU7jEl2nxIYW76Vsp7a00r9H1/Hyvr/koSIwckU/tt04gz8XjeD1exTIt7gWwkRS//ZXWhBn/9yNFWr2+L34VJKV1kXHOzQRerCQh2lSNEc09NnN44hLxEDg1qUsI8JRjVSZ4MyCAY4pxkus6F8dpcppYs1Y2awPSlZb49J0MViUhgxNth29ZfIfG469cnjSW2AjfiVxE+wuL4sE2GsIj6WvfQ6NerX8HWqE8SliMNRWjWr1VhUtKquGVMNg91u1jWPSYAYadXhIZsNeUhbDZjGNpianPNMrwsOck7EP9/iSY44PBMtZshiIiMTcw01GtRs2sRqNsdB2I1MYGBJtFjNKZjBFMDBZhXjO1nFwyxkExEMmSX5IxNOE72H6z9qBbNELApaB2OfaJDakwxogzv4aeGdsgMW7x1aCUJl8Gsu3qxvSG8iGgYXRJdknhSPZ0vww3e8qKpJlyXbJhkTYUNNs4ApR52c2QpjORoAE09QsLIcsMGiaYwzIhKme7Na1SMCgoP8mmdNaHyY1hn5b1r4j1n/p3kyyxxpwGPQp0CUKauMqZllzArzT5T5b1J29r0o7n+j77IIfWalRWehEfzQwh6eIs+a+LnjlxVunnnv97AFP3QNTfH2JA9c18YvD35ZqTvNnH+mnhWvbmbaWfFgYTX9XoiseDkz42WFi2aGswSOrPvsR/N7ejYD1/PPOm1DPP6qm2dmvCbV6teoFaSzOr0RsqhkPHqJLdv2BL1JF+BAPfkdnnUarq+waqKoiAxtE6gpx230x9uYefFZLweW1SWZ44OiTH88hZdAEsaAXReYlW6fzHT/KLMzfZG0DWXOijfiL3XjDv+tan/EK5cZL9rYDWbqRGOq8S99jOU2c2374/Ulme3CZfmX9hOE5O/ewDzKfGcRfrl5XmWGl2amkRXu+Jc0/6u8G/w1nt6IbP89v9J/SR9fzvyXsBd+6t/SScZohyqHK/Fvg7xkXk/KgbjNMtNoaWJtgQ7zJNMQjnyz4lTELy9+jaBty9K9MbX4Yzn/raxZ70Tgl+v39vybyFlxq+CX/be4WaZ4weT8TfxqmWXOCpf4S5j75PcwX/MPZNfXlOxrSczMCMSxgZMzq7odHtAupyRMReF+SjF6iz7GaE/XcTniksxMlR5k9yQ7cH78FPjp2VkEyxcWrnidsMbpjMzFsbOCcyVDizusJqZIILjsS+H0LWJWBLMOurF0fpXpkz5ZF8tuEmZkUF7lSUlIf5TUWWp46sP5HRu38OPR7o9fAH46/JbtvDpoyuITm+9s/hhSxhDfGLfoj+92FYd/3OSjqNe45PVunmTjOqDgTFF+Dxf+LXwlM7wYZejNaeHn/Vv4bWZPZYVP4lfst/CZv4S5Z4vgV1/pSf2AG+JX6LcwU0setTa0bVdOH1uTuH2zwu/+Ev6EMNf79zCveg303dLZj8mux1IsuDKQ+hSj2WFLSgftQaOD5NvM6Au8k8uTOnA5UFeumz6aFfgmrT7aCMVROnCSAQBMAcMUvuaFhZHZGs0InR0jwg5rLBAYcy37mtlsjDBUOXKMIOiMnY8TjAZOCo8BUC67MQYXsPJb+a7VLF7m+DxyGJmtDHnBYuzQJ2n1sXoLYsQihdhYI0eOjXU+j+2CBIGSjQzBDAKmcFMwBjel1YPti+Yc47D0IuE4DF0kE4dRCxQPRgkQ0cBD4l2sArhOgEpOqzcm44c3jFYLDOjANm4dkEbcT4p2MIwxJ5hRuiQs7oBGA9JK4nCSAY0JPWIqYDLWDCD0AKAlQQ/IKj+OYDMDYCEBTAXHrtVjThkcCCbrQcbjgc1OKNoTqwn8n/TwoErnFE0xCdxQphhky0GsPwy5jKZ4K5I3GUGugBLFLRMS4eYwmUSDYr4liBdsqQLBG8uEopnsxq4OjpVmNPCAMOGHRQnpW8xY1DhkMejxggXTnSGzccBWI9K0xiQwEP2LKjLgNOHFhCjcatZkroA1mcttTUZiYg0GEm5rjMEMM4JrGSNuP87bajfEiSECHkpEgA3WmqjV2/jH/mZANr3ofDA5Aop4Nhv8p4Ds0OBo9faEJKzawGYUxW6HQY4RjHKMjHZHLD/LHOCOzMHoiOVx5YgXg0z0gsMumt1hR9857I5kRAKhFEMoBebmWNxOMfPQSoXkz5BHOXoXwGCDuAAc50BjpSbiEaKlGW3aaH10OgB84ZKQNi6QdbQeFjTAePxgmUDXAeMBR8QYi9YnR5vNQCb8YwTtI5D4GZI4klWMbWCEgTAVAdA1gIloo2jUFV0YbUC2DBHVgArhTUOMnicuMBcXJCQOALOGryHxAiagyoygfgDCuBdBHu6ASBqefZymyRCH1ovmPo1mYyGnzfZHRqmgTMDpZk7CGJMew2VBs0WDKwcQd50jLtqIZgKwI0mj8/Uk7jtA9BggFxItJCqVhM4GNOj5ORMIsMmcFtw4BLShCxiLCiZhXAJwgg4bUjdzhwAiBTPmZ7QZgzranBwNgMkL4EB68AdhwNkIBRgjnqtAPF6jmZxFm8F1Ix/nlIs2p+GH9DC0RCFBelB3tgYw5PhW0aBMFhgaunEATlAMxSiwGrkThM8iI87OasTohxUI1DbJyBcwLzMyiZfNnL3VOceFqQhQ1NERzTQ+2hHLFXQgcSQIJSHoE7AxCfk7klBhRxISd4CO8WNTrHgFLYzEQPg5Iwfzu4y4IbhdHDajSTS4w8YpOzvKkS5gt27aGH00xrKBMSoPiCRjmLrbgMR99DsYzyQGyQAwoOkZWQD4BZA9htBQM0LpASF+MjLzm+BrOCkTRhSQJTMDi9Eu3rPYuc2hQeMfepJRLIN4M0ML6gkEqgnIlxgeAAkMjCaOAmORuMXEMwYjBD+0WTxjjHVAQ7xZvC5mFWYQd5VzIgEKYhLDnQy3WYxIvAevWY4veCYgk41bAtcOcRdDAflgWRHFhjiPgifo0SmAyRaRGkQNbrcEvRkvJqCGaGp2cnbe5HwTuJxYy9CE7GXLEIIiozgGoroJPDuxRLN3AmPxiMcBIAQtjmHmZRQIxmUgjDAQkZgERwyvK8AmThjMnjbGGM/ta8RCgnULF1ae1OAlwTJzELQlxpiCORWTxGsrIAqG5dQYhwdJ+lQGfMW0CBAEHhC0FYjnAqBoqiRjHMqYZMS8BBSFSTJySlB4M0TbYp4jYzgMoGcw11EZ0CZO1MHvOHhMYcaLBktyiP4zMxUE5MYwg8qCA2L9CQAU6Iy42BCdATApsEIAg1QD8goAQolRzdFAiwBALDlGMpfNnCwaAxI4L6ZImnuVcSzWGMZxRiyNwGA9MH1wYXKmL1zTOQv21ubcTdCocE8wBQLgW1iMOYaFE7byiGEqDcAZgu6LdESVQI/4nkPUEusYd73ZwWs4kJVbCyRRVE80uDndjJUSemVuUque5z9QHFKCfMqAKwvShdRY94w3YCtF9lYwo4Bg6hny2glk4DQM6F4maTzRrEZuJhAw9IMVwwOtBH90BtwA4Am4lCBa6DerIwbuMox53lsdRi6qFS7VokQgrxyTCRvkZ/6BDUY8RzSegh2AzAWMlB0WJ3GHgw5zxozBm6AojswZxo47gHDf4HbC2AD9jIEDm9a5MsWCMMeCK8PcArIAcE8AMhHEhgKe0bHcHLFi4oubGHCxGM+xPJNjDVhu8YKByTYQ+AQOYfbDN5wv0NWMMJ4FRmeK6NyUqHGsQcSKA5XgQJwzFqZNrEEwrLEGnjmA4Js4YjIvLUDcWqDW3ILMmjNPBMwxBU8HxNwPkNmGrgLGhGG9ImYqhh4zYdBOoovQnLjgcQsEaZZRIgMW1xljhPIraEvOyc4DLxZTNwm9Csz0A4iHVKwRLDZGBzBiGplQoABG2N0BOZoR+fATjJNYTHSuDtTs3KvAcMDneBA0wc/FgtCIxyYzeD++EAMeiAGkf9EyRptzSOPC2ZRG7iWjDW2DjoBgJNZwXFhEE6KJnF3LLcnpsPzNyAxlLnA3jO9YsxBRgIR3Pi7Q+SALDCzgiYCTeVBBshK9aMbCyW9BfwAoABfEDBUeI25lMbcA4zH6gLh2mF08M4BTAXhGOSUe4cDLkDPEwEM/WEH+AERC3OKYHwDIEjQaAIQy1sEjBoOfxynzsrGC7AEiFvjQOG1sOqg28jNgjFsZomxg9MFJApoYYGygBY3iDlIAwBWWBQAnowZsMoOrNzDLIia/ASXgJjCw0IVgfLzWIHgYg1FwJoakaLBMhiTuAqyHkPm4BLz5Ac2aua2EMaQm50UKmHeOCi8HQLQiJhB8vxgxxwYEksV3DbwMQk0oFl4DdBMYn0BmFnaAUW2IJtz+QBg0PA3wExwjsJkpIthXrgzGGNfNhBpwyqZ4JgJAPAcNJhRM3O3C6ZuSeIYZIGnFo61MqIxAPDR4fQcxYi0tCoCp6AygkwwmMU8QtGA0YrAZujKPAYheZR4IPy6NVTwDiRQ1YpUKoANSMWaonl+HBITUIP+IEmEccxs5d9wAY4VH1Xg0i8e8DGNGgucCTMLIMaSJdkgT1jhgIdMDObkMXIgmT8N6ycVIE6K9Ic0gaCSwNYZpjSEtARwPJ5NgBK8OjLnKUNwTN9Aj6GKhdWfEMxZINEcapiCmDTDPDyAx3mH1Eb2TBgFCa0jHg3RQUQybOD3zyECoDwDIfTowSgc5H6MFECMWjG0SAyQYx4ICAI9gIF4G4sBp4BfDN6C5woCOYzk1jt340Mpx4J/wQ/sB8ngFMrIwGydkzTgIeli+EITmmHs3DgVzMCmLM2BE82ugQPjFMuAQ5HG+wT0Qx2YfqOJwwTMxTjA6cVgl40BtcQUlhyiCEbMDMF6kz60JgBLCBCZicecCchSMRwCevUBM5cBY8C2ukJHZ9DjQQhFdPOOwXXDsccY0Ldu/GHATQYZChCSufBJXEYjrkSRmLpAFgIUkQNAXQBFFTK24JAdkOECRAhrCDLoVB0KJXEAl45iNijNzjTApuA9ZLANAYmJ6sZTJJTVj+gqE9EE5mHoBg6wBCrE5DqyCSEtwcXC85iaAnAW1TrxoJVbRA2IaMQ3BBZcIYhTHYzLID7lEYGf5MXNJgFizAZldjQOvgVvMdsQ5EHSYsG7Ggc0Vw42Z9DhI/2jgeJbT7UAYuti0pU9LZySY+3guQzy4XPDFTDWAhAwEzDIUEBhbRoLOxUN+wY9jY0wB8IiLBz/BAQh1wsEI/QdsRHsCce54E9UFcvAAiEfriUIlcIXijUw243m9iDfGM0UH1eIBEm/EghPHQSvS44UjHsI0Ax6aQJwEhgFyga6Yr6HexRSKT4ILI0NwR4BcxSRevwBTATAz4nlgxJtjwRPgZe7peO5iAH4d0yUpSQ8MpQ0y5j5EdXl9Rmtw44M3iGbApRBSMiBXwcoUDpAThazMbICw1zDkloSYzADCCyDfNYPL5jjgcRmidGAW8QDTEzEdonQYqkiUrckMsQsTCGmlJ2sTIKTaAcHcQOiKA0jGisJIDDfQxFgAC9huyFsQ/BnxHSsGGWAKj2EWvoSeJAGqHoBuIgpL+ABJIE1AWBMBU5AMr5kJGI8JzvURiiAI5ICwMzGyAJjws+KmEY2La8QDAHUDx4E4aMgEnu/wosASiRTN0dApJWCGgveAkhLZmjEAAIzMlQJzn7F7CQDLeZDvOA7aGfotpM/qDFRMLIUYTU5BWgyrBDByfAmeK0HwVgkQqxJ4nCY4wHky5JUViBPAzIQkwJiVkkBIADoEEYElUEC+Y2NVtDYhnTUeWuYE4fZr0qKH9AywYILbNfJb4AJZyOGaZ+6TZCwIGfSdKIQRqmCeQUb0GfPLwEw/MIJ5hQPioQgkNJfADl4cIFklMBDLG9vO0S5ATvZbeNkwNApuhjcBomZAWOtQA6OJVw9GmM4CwzgChKHDkdFrGEyZm0eBu/CaB8Q0xGhijS8Qc7KAGLYiJbDggKwi5zg2FreAnC+yWMhILJpC8c9NgeVLPMX45NGHCzOAGIlAvEoBiZXeCJKnhS6b2xscB+g87kFTCmg3oNyg+OnaLk5VVRc9zxgg/kGL0wVDlxdOYBPDJND4LoZUDIcu5mj8MGO7MFPRBYODBxWzRV1YywTIndqFZe8uGApoGSAjmhEoEQDlTASrAY2wWZvIcxrAAoDFEVOYB3EiKwESMTrw47SxKYCvTfFgt4HR/4loZ/yg08DrXGUAMA9AqUZtogmLWKLJCLIHd2BOCk7B2iTQG/xQAUCUBmSQmVGgdADUBEuiBcDpGY4Lix0ctrD2AjIxAEStk1juY4jRzm+m6AE4eRA1ABsvJhAwRHyIENBxiGwM+jgGmG+A6BvmgZl+8z5lgHj+YdAA8sKVZDAKLhKMMboQbiJ8i414jGwAZoh1fA9aTn4udHCsQkEKELEAwFqAdGZ6OgOz3gnpcaMAIEtBfdgzAgByAwAXnKWMJGZHkmAdQA8IPhdMOC89LHMCCPIGtkAARDTDVsS58w4shkjAHI/Vju0gGDRAqJyZ2xK6CabVQk8DwEuzWFTAsvOrkGHw0BEv+G5oW5g7SnKYuDpC/E9ypPFMSkoHM2jTwlMT9NAAHIsfZwhowkiGRMZ3wDMI2SxZ3wW9ncw9nAzijoyYcuHHubD4zLMCGOpBQMFzAzNjnqxnBjkZdN+JUARA1osDObPGZhTOEGYMZ2qQlQG4cKJNhN8PQ7EViC9EyAo2jG2qIkaaMRncDsxAeB9jBSMVCFmAHvEIAEYOkL5g5EEVDdinwdCoB0xiSQiII4jWAuIpzUyGqAd4BQAruF6nmASITgYUkbCEZRrPgZnmAyZgaUjGusM1xuQTgwR8NKoF0ivSxDhBOXhGAjjLDrkcecPnnlsSDAfrUYB5VWHFBGfGkxbALrqBq29Mw1IBKCZBMux2/A4EH5TCDHUAXsFcx4+pJPuAsDQIzOQByNm6YOhQBTOXSujEADkRq4mFXxjjMIJBGyEaMn+VKSECiZSwOonRIewDyTwKAYyArJJKhp6cHzq4UBAAjBYMZBjlRMXwAlcajK/QveOCG4TJGvZBinGTzj6QjMRwT05HKU16njwQvBlYQMuAhBXBhJGSDigK53Qe0JrY7gbdYCIAWskEygAJgu+DmoL2mzKFahPEZcgRWFHEQ5SAxz9+wmZmMjggSCUB88ptMqTaANLwnMmzs2dNZh7aJliNGaIHQThN4A7ETXaBYMSl54UUdkQhRwMLwPufGIvk0IAcGYVxsFoX+Tnnr0moHFnJaoahBjxlOoBYF5G1ESMP1AMqOYFFNczRol/M0cKwrYXRA8wHFktMCVbGcJpmSO1aaGv5x0H0FYpgjuMFgMUOcyLYHuaDwAFxiknp0KPHaFE/5MpsL9t4MKTQ4GYI8iKA/gVDhBtQs+oBMbT5sUWwEGaL6B2MMSZZsI9zQiAHTAidWiVACGjobIgzXFIWPzgO+42iFc1W1mtowVIJTYFzQML2LrgLYGeIWQEgseqbWWBEo+Il7j3mmPHjq7R0rBBasxhcWnM3rotgdyxYz9A7Fp7OQllngYiCygIlA4DOMUQvAaI1AEUpLOC3GUL1y3GFrpQ32TGAVYkRxqeFiRq2FKLwgAKIGgKzxjpzsyEwzyYLr28WfbqYu7AhcyHQf6idMCgDgM3hAFYltAo3O37glJEPJGb0oAXrG9fFILTemVvwGHMXAvGix4YcCzO0DDHNnT5oQDiYg1ciC0Qi3DXGiNqCXeNRZjFCEwsYzz8Dp8LcJQDXlNc+NriwCtZiBHsMNY2da8eMBmC3bmhCZ5uCTeDs2QbJqQvOSqgVUWxRCnj+cT/wmsYQ+WEN4ztmMF4AeJnd8wDBYTDkR7xKA4G0AiAt1vxbzGBbRRThVQgMBW7mhc3I8xEXnA44YVQ3c4m18Kjh9oRqnWsjRHYLG7xFFhC4uJCst+d2tULfzI9ZVyxuC1cQYDsnAR8TZ9D5Ko9OQCx6/EzUAZp2rCsiKHoGCkrRIFaYgwCZyKDSLKnxKIJ6yyFSMrNqAkioiYEFWQAGiRaPzXEM0d0iaZYkuZB46IwGJiLTa0rr9JEEgssIiBJaDA3ngCzlZPkt4EWZ5FoEG2FxoL8ZQqizwHNXWNBwIWrggAeIMygglkielRbYNbml01FSMBestuPYwLDiJTOG34IVmFU9aAFxrgVDO4NuAFwlSLxMOdALsOmYGPM9RMTcQw8DGs2AKJwQiJ2dBAoO2oR8LQBcfOdOXEYYTpCWUR6weHwpshCTmo3MnEAqft1AYpxeKMLSyHIOZ25gThhQWIKhTmfRIvOoH8Y8/NlDDRQOSFhGMFq43zBYxCIEzMIPEM953qsgkoWYzs/ixaC1GkSfwi1Bn8ZQzA1gFt+F74IVijKuKtS4YrnABXMWQLwigxjx6AXCKicokxWEgWuGkQoKB8TcEZCYlcCse2ZNEAtMGMYxEHV4NAspFRfMzAIJf22+wDQTBbKxkg8Fd77GrmoiyKZOq4GFF8YpzuYDk8CFEbopawLWdrSBMZp/bGwWk0QQeTFRnEZ96PE5f7Hk8pKAF3mYYtpwWPjXCBs/hiDzDzx9BOS6M58NwAU3w9mAIbMamEzMemKyCEWOmCwAieBgBFeC6cJXQjzGVIHE4nTAARR3mOG2wkOAs2BB2AoSZWV2B8oT/rEbi9XB7IMNBcCP1xYgIX3b9JAibDxQbVhj+DFcn0yMnNDOgPPhvQgMuIag+RwTpikwd8BmaF6BeUgBCi7UxgsH67ZZe4krXh0A0CmAgl22QYzhUAIGDCOmkDZ2i+JUoJiGkQfFw7AVhnNcYPLCrAXFHCDLmmzjgiYdCJoM2In4x4w9m4z4De55SN9Mg53epIzEnAZ20gh2OmaQCBAv1jiwezzMgVAaHsEY+iChLPMCoSOEz7YoIxhwA0oIVocHig2t6UxbCFhAkIBtTG+12L/DsgAQhDVAocQRR/cAcgFYccQQgysOWGiPgURs5mkAkVaCGEU21g4x5NusgwXkhzxdAHHslTMSN38CaDs/4xFhSwAjzAVLQLWx2PCoxeqKpHhw24wQVgF5WAtbIfS0ojlYXgDA/AYU+UNoYHoALIaCsG4DcmqY14CCm8HK5uABizM28MPaYUsUQaEbAMJ4SeT1GhDvJLL5z5bItB4qDvQmBHgAViYACsohdlkw5NI6JV4gjmVmNg2Ib3DDCj22OBKJISeMEuOlZNZxALKDgQ0aYVTMxDIMILKBjgFtz2yvzcxhcKucq1lYsoEQ2wy+ywbeFEC0APhSo4iDQjF0Oozggtse4g4zNBiJaBleIzCesczyqT4A8CUD4JHJus5MKgbERQMLiGuxfgMK/RMwuEasmmC8xcYGcU8MXrBe4prTggghXhIthdWEC2dhtQAgv25kkRE2UwGZvRZUk4c2+BOOIAoHxgOAHb8AWfUJJPoXiyzkMFEuLI/s78RimfBUc+7dZhRrxCoKzK1pF5QAQgDPZDuve2yoRYJ8eB5DHhF2zsguamZngwsgJ8Bdz2oxM5AYpnYxXNh5GVD0B8z97AACzA3NezIZciPbxfCHyAQHHw6CXnB+VtEWYHNFGpgVrNGC7l14wAKLMjv1oJDkGDqcAg4ws6tATExtDqfzLDByB6PCw17s2QRibxpA1ukDi5eEGtoGYowfeEFAdne0OZgJAmSBFIgXTmBuXYdV2MeAuf3Ax2BJERdOwo+LFAhf8D0SljhgIWfZUjMpS6po6VQexVja0JipzKsDcq6pgqyk8szBwWhoh1TBEtv4nDutLR0mWbQipCz2pbClw1YJKLrE2cPsgClQPH4YQdA1cOMBJQKA67az0h/9y+YVGOf4Bl4HhDOLGSjNqEVnI0dAJMqjl4U9/FiQYIdW+FoA8TXKzrsPASDr8i4NpMYaejBGaCtAvJeAHa3pjNBwgHzJ1eKNiQC8XHJ89ioAZI4ICI1kZ303Q0FceIRxeZm4wFgo7mDps0ObJq45N2xWBrDgx5pxrH2sfIUHKreGWNQh0TI7CMy6ekCss3gZhNpuRmswM2fHpON8hNsfD1/w+UBOJ0QxjAHYVgkkSJwY1ACgC6zCxA+8MSCTXgx1bkboSNh/FRipY5hgNUbNwS7wi1jmRMkEiwMkygBSYoeKl51m0aBCWgRk0Zsxq994dwAigTG18ajGBfIWnkOArB4QfqFO5oonFwMMTEwwzlW4nrB4zKnDhCVSwIAD4GTMkOsYCU8KzEIRjesMpoUfgMPnNuJNgQy56tzD7B5kx4RiGps5SWFi1DNgURgcHiuUBKMHILoFKm7u8FSMJjxJZbIIiOepolVS0Wo4ZIuBEDMd8cgfKYOgwd6FtDkPIOENDHlDhJyOKc5hA2gGEC7qQKyncMCAwNIIOE3BUwOzazaQnQHeRRdlnm0BLHSs0F9hJjngqMosowP6fw5ahDbTYYFIhQ5yQDLm5EGwAZhy4HwzNJMDxkncYULhZLyYgxcu5wDssgwkHCQyE0dOzPik6MGQ2Rk5QK5TYDAwAPI6Bsh+8EBoOvjk849tzynwJbcCOl2x4LbJbzOvnQKPYm4aDIsUFAgMD+t0WM5kWgbMSRuwEQGAlYHcBNyHvGEGAK4PSUCY7JyXUbR5Cqu6uXg401bkBtGWZzkLiGZAcO1whYDxm6NC+ScwVmFOAHZn1BNYvGfTM0DbAzrv87xIYQchLTt+41o4Sgrnb1ha2C+VMXugC9enFLDXSD41E6DcqXBRAAC9Y3rLgNUhqVxe9snhsSKoLgAL08BoPQALA6SYKgwQqcwf82IC2sx2RSDuWkGpAbhRgATRSDVE4+cUh0HD+UAqYPavxvgWNi/4qCNzNH6qsF4B8iVPTkBOiSklABeNWUkAIYGnMr0D4PzZmoCd20iU11meJc5zMxnxE86ctSoArLsCEtVgMQuzicVYIHHNiTl9FFLN0J2mslwDKGZMKtsrAZADrzdCuQnA2Qr2CJALw/QmFcIqHrJhjOskCBkgt6BYwNOZpKVze6Wz3TVVm2528I8fCUaqGxw79IAwvwrVWjesP/lyepIee2iOZu5Luu/pDPO+Gt55NQE780zAnfHjfby/h3mXZFa4deZOx8yNWdXZUxcLfWawNer255YtZn9/e+DcwZV5o6bzUN/MXV3OP94Rx3ungv8SDsm859nOk0KB8fVt/jyJ2LkmzieIjBQeRpGR4hzc+mz6zNqsmVm+rDA3/p9n2uL9q9ivzHuMePdqvt/CUZnhrHpPydwf1RPtyM9mZe6044rZAoOcKNSJIgQKCnSikD/eWZiZRtYeLiMqx3uwwrErkPuiOH68r+3ft9+axL7vQN45j0tsm8cmXlwnJjqveau9cwte5mbsrM1w/54SDlLwQySfUvwmq/idIWqncZaRd63yTk/pn384uh5f0XNR44r/EP7FYQkuFmzmCwm+F5l1MWcLLs7ms5CKfCUSfNtaKpHUcQnI5SkxqKRKKb6GV1RSMF97l0iNRpJHLtFIZBJFGVl5Tek8Eh2+PCyRq+USmUorLSDBp4ElUrkaUbTSvBKptJxELpVLpTKZpKBUhjPhEVYggiSnNLdSwrGRtlqikmmlBfHJbAm+9KOR+CB5pCpTyCRyldRFpIoySJCICOeX4lz5P3IpIKkjkUuQuEQtaSqRqlzV0RKpxkVVV5oP6Ukk4e4S5KhwkRTTSOLkEnyPRCr1lsplnnJ8BESqlHhISEby/LIC0oL4WIhEpZZIXTQSX6TnkBaRpMjkUo1EKbuGAqC0Kk5RqlZqpZIAP6lrTnmAVi4roXHFsexSJb42zMVQRKDRJ8skbhIVZyeTHqxCkn34CNIICb4BpzRKSS7R6qRNpIR6yiXeUoVkkjRvdjdJCbU3eqOsLAB1QyElxSTV0fZSfAVILfGXBKMBpFIFal5aqpa85IaTYOB5giQgpbuSCQqSoZ5yH5lcsgB5VFWQtKGylkugvLskzAOfopRqZYFIVyWpKCumkKgr4aMqIRq0mlwqiZJJ5WgYyQyJTJ1LtK6zJ9xVMkV1CRqJB4RMjsq5S1uquZJe3NbO+xgtz1BiJXA+foo7XUQrGcRYkChII5F+kGjlcslo5C/HF5F8lKL3lFKZHzrhINKWSI6o0FiSZrlRQKTUTYlb6A2MQ85OQuj3EIVC5oU6Kz3IVSYjRXkVSSrLm/KXBqTkJ/UihUypVktVBeXjZRQuD1JL3CW5FRIPUkmyiVQVsZLZeKeinOQ/pe84ebQ9qZJV1DnjNQUEBgWHhIaFR5TTR8fA81nXXVcWhzDoumvLan18tD1L8c5V/svaLcr7oXlfOO8Tbu/n59eRVZnYjtq5sbDaREZCmYWlwadUZx3msl7XGRt8DZ11oGkOQ8WKAQEBgQFBAcEBIQGhAWEB4QERAeUCAwIDA4MCgwNDAkMDwwLDAyMCywUFBAUGBQUFB4UEhQaFBYUHRQSVCw4IDgwOCg4ODgkODQ4LDg+OCC4XEhASGBIUEhwSEhIaEhYSHhIRUi40IDQwNCg0ODQkNDQ0LDQ8NCK0XFhAWGBYUFhwWEhYaFhYWHhYRFi58IDwwPCg8ODwkPDQ8LDw8PCI8HIRARGBEUERwREhEaERYRHhERER5cqhiOWQPU6AQULlEKlcOUKvYRxLFSqVVK3WSLUKF6m73BNNnl2RI39OSS6pl9TbLb+igLoQRnQXeaLUJF0lWyPdLj0lPSM973pBc1F6SXpVcltxR/pQ8kj+WPpS91r+WfpV8U3iWrJ8pUaNR82cOav7sHET567dOnCNUqUJq1ip1bvTZ+Q584SFt2rde+nKVTtCb2cfNGTkTLmbe7bspQJDImvWqluvUeNYw9DhI0Zt3LNv/8FjFzts3JQvv0qtdcnpFVYucvGSy1c04aPHLFZpy1eKM44am80ctevlq3bRW7a+//6reYup0/z8S/q0nDF7zrz5ixav2Lp9v9LFNVeByMo1my5cdPzEbJV33iLFK1W+9ej5q18HDsp1RYuX8AmOiKxTr0GT5i1btWnXoVPnGENcoi2tZ++h85euWr379MpVJvOhGzfHdSrSXSGT+8riZBJ/v4y+BWSBHvnlxTQFFWUUNeTupTOWKovJi8l91CEujWQhrn3CNbm16jzla5aTxag1AbkVhWX5FPlKRMjrK/zlWpVGVUVXUu6qCZNFKvKq5K6qJnXDg92CVX5qrbKErIBamnG6madSrSnspy6dO2+J/Dm9NI2QWQ03b5VWWUddUuNwqVaptLK8QqtsqpQoPGUKl7ZqaYHognXU2oyFnYrUdNEq3XJEKrXKnPnLyr0ytlSIbe5aR6OtVTNfHXVzt7oqbSt1myLuWmUtbQFZ7brhMndkXA5pl5VrMz56q8rLCrSUeAS59ZsW53DJ2D+0QYxb/wDP3NpR0xR9a0/dEjnwYN9yqtLyDsoS2lpaH0WOPqsjMw62V4SUrS8vp8pWReGi0ky/WApHTsz50SfYQ1JA6S5X9xk+RJ6ocJNpVJ6jOmf8kPVZr/TyyOZRW2OvkPFRa1NbctXqltM1p2trjXfGoD61ZQOqeeTq36SQUplxoYyiUmGJxVeWVy7tU6VQtkiFpM/p0hkXy8glGbvD0Fi3Mz6VaiDXyqX9stVoUDFjbwWlRN5SkS9E2se9rDzWtZU2Y2VEAbeyco1K6q7MmNrviiybzE2WcVXpKpd4uMojUHkfdVm51F1Tsk8bdQF8M7K8vCC6KeNbfwWovUKhVEpVSrVKk02b38Xb1dvN093VQ+4py549hya3xEueR+Ity6vJJ8kvLZRbJysj9XXxkwTIA6VBkiXSpfJl6q/Sb4qfsl+aFWnpw0bMDWjdZtjw0flvuHvUb/Dtu59/5Q4do+72HzFyzNgla7ZuO3DwyNGb9x/8IrmYEuGR5SvWrdex/0g8XL9128GjJ0/df0B/TJjyPGM6xRr6j5k248jJU27ZSuFW3dbtO0XFGkaMWYI3Dhy5df/Ba7dsNevGGjL6r92+c9eFS6/f9BswbP7CnbsOHDp19VqdyTtOHDx5qm6jxq3bdooaMnLUmo2bdu05eOhSttxe7Tt8/PTzV0Zy15u33AuZzPkLRPXstXLVzVsNt23P7VWwUK3ajRrzpOnVe8OB8xeuv37zwWobZXeU8PNftGrTrkOnLt2aSlUmTQ4YVejkr0aN27VXqT08S/q/fGUyh1esXK1m83jH4SOnz1y+8ujnL9JFFel7S963hjqfXJmtz3L3jGUKnapPfpm3WiL3l4fIVTKJSqnKpm3ikV3VUiWT59dqZGqZSgYmReYqV8hclBL3XIpGqnyq1lgf8rg2kVeXgR2QZ1N6uEbKCxSP0iXLuxTPOKzou1qWV9n3h6ytKrcmj4aHXBdMlLzKtqoyilrasnIMClmgS1l5XqWLLGM5HjXImfFeXUHmIasEHqGMou+vbHnU/tl88UXBwh4Zw+V9p+Z2yTV4vMIfK5vUPY8mY2cRu2vGxbx9PBUZdzRvZ8rCNX065MzYrM64kbOCTKuMUNdSuyrtLgVl7eRtNRn98uTX5tY0kGcMVS6b7+olD5wj73O1hMpVoei7TldaiQcj5Bk7ZflkHjhcpQvYBhxdI7hh5syzwvhGjNjxz0YPaNX4wArn/hQcP6Nj4YQXQJwK0A+f4xmj6Ewdc8ym7F66Qq66zoVele1cpnTA7TLmhbPLShfrfAt+0/nRz85hM3/NDvshKRwu0erDi7kVjljmPqecf57Cke8KFq5fJWRO84L6Oy1ed9G3bGy+03LGdn0rOqVvbTgzpzVdLdyGbs9pu/Ju4fbP79/pcPqxvqOOXnZ6LekdBT2B1Tfr6Apx9gxEfWivdXCiFlaTP49AytylhpMK/jg/AouxUDnh6A6IeYcUztMSOqBefPKEnx8fSIXVOTog7U+moGq16jVq1hJu/qz/4WbAKQncHr1cnGdkZIUHIczt2swQVx2yHj6QI6yg+GgLK84Msc/F+RGqzJMk/mucsidq/B6NnBp/n3NwmbeK+ivXju69T0K3XrY8ejyRqFKZYaVVEPt0DV/UWNpOQaElgvfJJirIJ73eqvLJUloyyWhaqJPQ3rhV4cNwP59f97qzP6ro7KpJWnM/CUWk7PxY+5KKJsf2mqlqJaeQzW/zjUuR0dMqHTOW/gB/c661X51nUmqz3S7Vq3BaxeGKepemSvr1tcPowwNVtNfVk9JQz3mZZ4L8Hi7wW3h+5rk4WeFtmdLs72E+cyQrvD3z1Iqs8Lq/CbO0mxVen/l8qtx5chOfjMHSUFaYz43h8Ed80YzDx9HPfNZLVvhEZpgwDjg8ITP+vLS2OY42lNEOU67yPoslVAof7Jn7SEHbKsyOOVgO/bTx7skwnYJWz3avVzKfkmbkGfV9wQVI3647pnd6paKZDTIWThigogLf5XWCNkMOy0x/d2b65c80e2I4q6FZC3fmOhTjRvKUhGOGnQrqXbjioZfXZTQ1oEe+qoj44mHh+B11PKjd/fjlG7bKKN+D0Ge/fnlkjpNMjEOKXpz70CFvjJT6GE6k+z91oy83c1LVARcg2g3eLUUHlIcE+3t//R7m/soKZ/VXVjirv34Pc39lhbP6Kyuc1V+/h7m/ssJZ/dX2zdoS46cpqduN0ilNmsioWYZsd41TMkpNr3JouA3jLPnAjOQqUuqAfuZ2u5jZT1nhS5lha/nhHw6Oc6WPxff16XpLTRsbVHJx+aCmwAbzB4wLUlD9ivPOfemhpkpjqlxSgGmfa7vo5bOVqMfD9yV9KkkpJO/e22eDJdRnVKkvZxvLKWFpt0GK7BJKvzCuzYR0Oc2OnxYQ56aglw92uvmel9LB10M2er1RUsCklw0Wr1bQ/ZZdj3gWUJJnF83h6QrMV8niEZ27uZL74i13YueoyHD2+/zHhSR0fGnj8M3bVdS44av37fwV5Dniy+QqgQra0dLRZswyKQ25fNqt8jglTajWYNvA6nIa3iQ6MPmYjA7OtW5OQL9OK/OmS9+5CtJtW6CusV1K1VrMvvEsTU1FqoZmX/NLS2UHfhjx0uFChUw5T3UYr6WtF2vP39dXQm9fhT2IxTfbmlOLQn3HSqjDyLSZb75IacOaSo8WtZDQgL6l+7y5JqNJkypv9foKehIxff30j0oaMWCdWzuM/23rJj5cFimnXfMajT/dQUvRDfNutrVS0fndZ4pvaaKhHFVLXYmorKHD/cYu3KmX05rCQUunllVRw0/2GqnxUhqQsfbJapwMc6Rk+Q+NXsso8MHZCy8uSmjuus2Sw8kyCug07vyi29DSuB0/uemmhMre0DVagsO/vsw+uObbEhXlj1m8cGi8kgzrLg8Of6qg9GpTLl7Mp6W7973bPlquoksrIs7NrO9CsRkzZL0KKym5V7B6/k0lKftGZ9/TTUE2+T3DsdpKOrKi0ALFdDnlW1Vz9K7Hcrp4u2bkvZwK8vg5rH2F5io6krNX95b9FKReXVjnVUFFN0tnDO2P078+PtivqHVbQ1/jJ+U7vVtBwyKqzRoMunm5VvGV7UrKqU71gXWl7VVUpoTF846fgk60+9ZiJb5lt2Fp5Okzu2TUYYZ08oahEnoypPOPA2UhuE4b36FJCTmd7eY6OE8XOV09PjhPkflyutW8TDMD5n1yb5pbZK+aXqRem7aplQudyP6z4OOCcuqpUe1YotOQKeR5rx8hUhq3q3dQeYmK3Lq8eGHC+F31bttcwwYptfRuO+RkcwjFKWf6pmFhSpvnZ/OeQ5RUeuTWN+WVNPXW6OPjZympzvdpqWcC5TRp9lXz1kkY509P5ZAdV9KU+SP655inIU1R72rNj0E4/nHz5sQJMrqZvfeYIgWVOMhpeK2BIJp9duct0nyAnEzaRvVrHVGSTJ6n/9YoFSlGFD7fobyccm84Pc0/RUrrjt349uighHbcXb5P0xbtXMl3kqSwnBqu9Mx+MZuCTDPcJ7xKUVKbt0Nu592sob55JhSpW0FJ4UHTGl54o6X+1xqOLX7OnQbd1NWoM1BG0j4bO669KKXdNp+J65soaXyOkj/yq+XUt9jPh73zqqjF4cMLNmPcj0yu8uBYZRU1fX8qIOQmPk84fHn8lhaYx20N9ZPscioz9WByhe4qMn3dW+nNCzkdftr9UrvHrnSl+8i1c6+p6EnjewUWHFFQ7Wz22MO1FDS6hGbKrTmYDxffHxl+FGqj8ieO9E6UUadrk0LivKUU7/4m/dQb0JdeZbTHKsipS+qvW0OaEA0edu5O/xsSKqI+KKuZIaf1veeVPT3TlfqlTdiwF+XoF9dnZMRm0JHETS32b3QlhaHp0HLN3chxJizyLI6LSq590Bb8Q06lT78sWMpdik+z+Z3y81fS/REDJt/uqqJbBWumnf0AemCbErwmQEUO4zNdi4lKOpV7wa55ahm1+5VQ4MUCBfVzz/WzdHY3CpRuizuyCnSub4V+afslNCrn933l0jT0eVjPIcfqyamtrVmbA7cV1OHSKlv7cjKybLk/f5UV5fCYGZSziJJ+/AyVbIQKul/9HJ1yQg18fF9fzcD7EppyKUfUN4R7tagR7nMEfEaXm7P2N5FQ8Wy1NRNw9NSpwKPrX5ZS0fZdjg1Fpisp+93trdVjXGnyNsfsDWvdKWHx9ekVBkpI49WulHuqjHL80IW3u0ykXNa10C+UJ+r2mNTkoeCLtsyuXd+iIq9leZ/0XSmlE8rJ1S7i85NPL4/K1TJDSS1X7P91qLiK1k45dSYX6M/g6QurttBpqXn9Ez2r1ZHTgR1DH485o6GCx1LHHh+vot2TT+f/BKY34GzS8WUz5LRW8SXYoJXT/M1+y1/ZkO+AqOgWJ+TUvMnyvSX2K6mTpv7JTgsVtDHx7cAq+4kGpHknTKimosPfN7buBxXqy0qpESXj1WTRz0rf1UxFRYPvXV24XknXzzydWGuDik7nHfDkk0lNIfXa9N02S0aybsVHteompzErCmoGN5RQsZNr8rTPKaXkGXHzxkZK6EHP1rvzoz2aTRm2TXlURqNlFw70AY/5PEMVkj1UTqvmfr4xcS/aa1HOK19yKehCyyK/xgSq6NWO+Xs7NHajk8OyfW99Q0aHRoeUmwF6WrV4oW1+oOszfhXdlOsxUfUWd3OvHyilxzvPRPzcgTMi7XRo7GKix/N2hBV7IaWnY97SDyy0hefd7GPbSTRuzdrzzZ7IyD/AxzcF72Vvf6+CJkxNJ580czTc6EJR/V1+3i6oogfGI52VM5R0ZUmt2QX8XWjHB7+TZUYqaKh5+KfHw5W0Vj/2XomX4JtOuSzQVpSRl7liaXOCirr0aJu8MLuCmjoWWKbClNGgVoWhu0HH7pR7ebhQc9DNqUOjAvQK2rly7PMRk6CNm9tj5Qqjmlp4lCr6pKCGEseMGFIV4/98aKUDK7VqurB79SOf41K6nzT0WWfM94WpeweUksvp2bla3Q1hSupx4O3KOTjybenZSLJ9klCKx56ysRAEFn4v+7kOlHulqr/0rAA+xFBl754nUDYutE0sdnmQjEr3GHt98U43euVuuDByh4LuVDlR2f2Vmpa91gcvawK62Ul6t959nLAmLzmp+xcFPX++2xqSoKAeJ9f4DR4soV7KmgdiJ4HOeX6e2y9ISmeK9vqyKhXzctv2ERM2g99Z8XhSexzH5rB8WzexsYLixsaVkr9V0IeqdVeuGqWmQSnP9vfrqKGaVY/ODD+lIfu2ZtN/XsJ6UXBN7oOrFPSqyKjn9TC+/K4Uzz1znYxsg5ucb/9ZQR0ffyuXMFJFiQM2h3/ylZGy0Ztq/dDOjqqXhqRNlFGTBd9U3oUlNJhCR5XwUFHtqIw1/Woq6XTZfqvyldVS7kvn8+0O0tDI9ov2vX8up8ErTtU8t1tFLd9dt+iyySn2fpHpv66rqHjw7c5X6yloasqrkVc6SGn4NFnSA7T70OC04fULYV6U2Z77e1klLb2Skf1DDwm1W6LrtHKbjJ4vja7tcJNSzU3lD5n3qehMfdukQwvl5D5h3dBiaN9DlRYcaRHoTi8qmO+/2ayl6h+2hK75KaeV41aMPYP17dOJ7Av9GslpWb9cU95blLR+9KCrQ4fJqOOXprem1yPaPPHCtxgcxVfvwfKEab5SmnIgbPDIJXKa86zsupU4ODQw/bvDpaea6jq23m9gllDdnZV331+uoOm5Su9x76WlOI/mXi8nqKjXz+sxFXoq6WXewyteg180dO3b4HVFBb0OWB/c/qeUoke4dorLr6A+O54307aHPHb/+wTldQX1lDsO+GyR0YOBJZq+Ky+lFtfr7vI+oaSB+1YZCuvB98qi5+WFonvpYt1iv1gteVQO7L7tnYbulbJH5gMdnDfdq9loCGSnV70eZ9hD5GPvkL7fwPxgx6ZV8qO/XdZX9ADdmdN63Ll7oIsbF40/G7xMRutetN2avl9O5qCGedz2yanCq+NHxnqCHhdQ2JdfltGK09U/bNRqaNRVj+XvTrvRvQe24gVeKahbjk3tI71cafiYWFllHGjZfWhM8odBSspxeujYiSopBTdeoOh/TkGtpRVX53pKNLTwl9eBJgV9lt4ZHBWjoM0LjFcOHJNSt5BhR74FK+je/JytWn1X0MjJo1Mf3gH9qHt/6rB7GmreSrX+Wx0lWU9UufxmhJYM5zX2BoXRTt2S97u1Bl93d0y+WeCjllWrnGdjmJwm92m8dHkTBbXYn3N/tpJKsngZlHas+4a9A9/WOCOnPmNfvh5sl5BrSodrSTMltPm5rcoSyFefz1Z/F3NSTSPCCvZcDL7uyUzJ9hc11XT6tM+LqZPcKW/j8QNUK+R0f9rh7JpdWDeHvzu6Autt2ZPrJu7pJKXuksa/WqaoSD8qZ4cTS2Uk6Re4LwTjbs1pue9D8LGSeGvwXPAzxkm+8qkzpeQzusCx16tk9DbkwHuX6kqqYW1yf1+slCxj53nPaoD5tX3Kp/7gU6bsCPr05biWOlXRRT47hHIGXFm64Qf4j+HlH7ZeJKdWxSaNHT9SSmcbmB8/8pTQ/Q+yizOxPn4eKpHnLqigPEXqXX8JunG6/7hhS/IpaNxEl14tYRZd7b53yOptGKczXb5VvaUk851BLwZ5ulHAolkdrkk11DlP/9c/h0jJ3OtIocCTEip0bUPlylIlTf7+2DFpvYpqNtm1wrJCRpN/pu1pcUdJu6Ze/BkWI6HnX0ptiXstp3Htk2b+eiKnrWvrbx8yXEJHJ5SO3bVKSVsW5/hiaeJG28osn6k3qKit/X3xZstcqHb7ZTlfJMEQs/lFBU1ZDe05+yHa9SbRhsa2U5KJcvr4Oqbvvg3g35M3fKgULSfZhHwD6l/Dt5i9N6vH9QafVyi6Q9Gcckppl/d9VCHwy1uW2uIhL4bGTU9fHCmjmUm5vg+G/Jfwen7DqjHQZwzdeKUL+I7qK3Pn6HpOTm1G5Hc9kV1LbzuodxT8oKI7H+7Ffy0roS7n771xzZDQ4tdR+vDqCio8cubbg8GQpw/l6e15QU6d8i4417ge6PW2OvIT7+VUMFf1Aee6Kimn95i01GsS2pjXcsNYW0NxG9e/KYfPeXe/N7R+4WVy+rl69ittlJbOeM1eXHalisx7E3uUayajnd2LzO6G8Tws6ume4Q/BZxToFlnpp5JKm852u5JXRtFbdJoXEJR/bGxe/t4gCcXk7Da6VBsFjV10u87bqkoqEhd5oNALCfn6avIvrKak3meyPQr3dqHCVU+8qH/dlW5WHOY6q5WW5nRbEHtRBj777ZCGI59IaNLP77lXemIdcjlpzeYlpb5hu16Maaqg3cPehpVZo6DwXEtGM99Xve3O7w+/KMnj6cOn/pFSUhaSTBjeVU6FpnZKUBplVCDtcuMKO+U0ZOj3Ll2raSmlwq7775M01Cno07gP0Gu0z5Cfut5SRnVmGjdfdkP5R4x6FllLRcG7x5gGdMZ6cXsklTmF00prq0tmQ77XHBWONZysoNQvp47+fCqn7ld6tVHGSaj9/nbTL69V0f12Rbq3gSJ9X6+FcR57FKQd8jnIOkVBA1bk8Bt4WEu7nvxaVLM02m9y/a0lO6lpYWv/NzHzZGQ92HNAapyMal5qcsMkUVILuev8F6kqytZz86gxoHsNB7Yr2HOhkm4f8qx2AHqcjVsnVl42W0GO2oNXh4L/WRDbsNq7zypaNbDOWlUdKcU03h41+LILrSvastKEXBKqeDbPkktYD90DZx9r+QjrVaP0YmGllHRVf6ZgwRdE+8ybPd6NhLeCy69eLaNlFBo0XbEILh1FA/KmNIO+ISrHiZtnYcztEjElzjAG64qyW9GueSS0zvKydBL4nX1bjhd+98qFpmX7VHo++KYfdxP82g1X0KCP/gEvr8io7vwOHh3nKOnrphltpfMgl1yv8VmBcTT93NZQJfj73qW+u/2KkFLtrVUzbm1T0YXFuzRv7ihoT7aZETUg5y4bZ4kpDLqW78T0ST3Bx5wIrZKs66Cg4ik3R6/4qqIa+vzlBoK/rDVL7RdfCnqLlS+OD8ruTpaXRcolnsB4qVhjc9s+4If8Zj2/Aj1k8int6+7gZ5WdtSfLdoAcZT8x7HualA49C744Huus6uan97VOKahujf6rmoRAvmic52sp8LuDl41ppk/A+vSswYWmEeBvHiSt2NVWQYsGr191f4iMhi8Z3eprNehJIkL9KzVT0NlXC1pM10go5OXbd1rIx3lzXqr8CnL8kENtXV8+UVKjIQviroG/u3n+dHcT5OGo5hV6rU9S0MT+Fc8HFAY9qnSmW43jKlrdtuXH4T4wUw++8rrURi29KXzyztIeWnp26O2rZ34amre/5Cf/J2oqWjPqsAX0aprPJO2Bwwpq9rF28SYdVbTya8yCYlcVpIpJfxamlVHskpYbJJUxH1MiHixAe9YZ4V1WD71Kg4UZNU+0AD1af6ruzKVyil6Wu0XucDkNXPHjxjeM/8jtb05ORHv9VG7sZZcp6fhw1+0brqmp65Y3A56Y5TS1/sMwHyjoS5RttGhsQcj/V6tcGHNCRfMWjQmqVlBCN/Zar9d6KqNFt+4OHgCz+8/mN57Nroz14NH0Cee6Sul5fX9VKNaRoPc9j64eDD1k0s+fLdxV5Np37bz8Dik5Xkb2GHVRTl+zDWr8o64rvfigtbQ8BDlhaYsewTUhH8//knz4lIoiq13TJ9eSU71npw993C6hO576FqsvqGii4tCliZEqymGu1DkK/MmXe8s6yQbBthBS1GVtK8zryPqtOqyE3rmtVNZgBdxOplnqj8AxzNNeNR491EtLstu2jLmBLjRmhHfVhRIttR9hqTTwIdGaXS025oQrz6aJJaumnJGQh73SZNU+Gb0Z2qfgKfBxZdrOuVu+AOjts355WjdQ0FLTqrKBGBemmfO3lx6noNuFwly1WKfHfbylfhDlSn3Xdn29B+OgXpVCOSbc1NCKl/ZxRWdLSDfM4uH9EPzTq7p3CpvkdErne5LAL8r7Be89fldCjVdGtrw8Hrp9t6KzAiC3pG6OXx60EvJByaqXRz2V0NDBjzeUgH7gcvfsW1cvAH1sHDb5ZgMlPWqctLHvFnfqpN5ye18eKSWdvlvpeQt32ruswpiJMjVJq+U8Hj9JQ01iC6nuX8R6dL/S032QQ67ee3+i0gIoOM/2St+bB/Ln+gcZefdLqf6BGSNveyhp02zNvjdrlbR927Fs5UvJ6MWiNgNbv5dQ/sOp3bePg55k+ImExfEuVCLsygrv2tA75mx3ph74uKLfOnysWF9G5/ZNbbvhmTu1rF15U03oVcI76m2qNRI6b+35VCFT0d0ZQ69/gxzZ6OjpbSfB3+9o2zng6gGUo86u46+WQ+7cNCWpHfKPT5AG56kFPcySlGwrTqqoyMOGB9UFXaiaa+mxXVd50LPl+QvX2Q1+0b39NBP4wtP3G4fn3qyifrVbJVxD+9yKa9P3BBwpChxt0GDUNsjBr4882LVYSpdy7r9k85PR8crZ5HvyqaiZNrGR9xsJvX9jaTq6l4SeRZ4cd2gN0euJJ+91+aCkhes/DrwzT0qvFpdYFVvQlXpOUfy8GqKhoEMvtsy1q2np2O8Tt2/Xkm1sweEvJuJ8+WXHru6FvmJFw17TrkPP2uXMtIMnhilp3aqfS0r+UlKpmEL6SuiHPr6Hy3lCr3/g5O5LqzdL6Gyk1LI4Tk797ya3b1dGRfvC5/nUAl0Y8ajz+/gk8AnWhJsPRrtC3yQ5G9of/f9jYbd2dWSke5Twwg55r0SvCXd7or9K2O+lEuSqldM3+PyEknzTJLfcc/IqaWT2lr27D5XTwvtrD6zeqiRf/xsBhfvKaH3axy1toccb8VKmOHlQSqpptVIeeqmo1JmYCnLom9YFn3YtBf2N5HoLy6BzGoroF75h72c1DfGJmb7mlpRWN51Zp/gAGQW372ascxXr3kZr6tvzWD9KXDnT7RHkvw7X3hYIkNK9A+XnwW2D+soclTdAf9chVWLZ/hX64OKHWhQ8LqfpdyITL99xgd1vkVcA5u/Mbq73G59W089Td4rsg1OO77zwIo3Bb42Mqe6I2y2n3r0KHRniqqKek09Pe7FQSrObX7rfzSqhnI6TP975YT2r1POTVwbRseQ6ldxAb1Jqd+82CXavRfkene/UTEJxrc4MGg69dSmrOu5CbTXVOpLn2dpW4JsWbkyaHwF6FHB+aRnImbPqnt/jvlJOAYV7bWg3QU76eTtnHgbf8HPFLsPa91LqnxIpLZxHRqNq2r3W91TRop475047BvvD6q0e0yXId7l39l/Q4xypfzaqNeT7wKv6kHy9JTTQJ0lWMVFDwVXfTe9xHXJ2gWfS5woNHbEtv3ehhIYq1Ki8vy/0Us1OykKmecvpyJr8d5May6j/iLXnp2NdmLsj97aEHDJasiLH1C1Yr/c7SliyY71csfuJzwjoAx7V2PVrTXYVdV9xbnqRwxLa1meHeiyMJGaVm/Yb5Jveu68WOOfrTuuLLivaWepKYcePrOlcTEtNfK/Gau+7UFWrj++661LaVGLy6rGbldTx/fNynedBT95Lc3HfaMgfhfy6v2wtoVmWozP8oAf8uXbSr0dpMqo2bHyLn5vllNb90gqPdir61rJDtlTYF6o1GPCg8BU1xTcOO/jNTUXP30zfvKWOmkr4bFrzBnTsrO+QMXfeq+k49QvKhfES3fLz+9XgEwp8K7zv3kYJLd+Ze3pJ8Fe3vJZJp2E9fxFU9Xl2yMGpmze1KpYPeuMzg5oX3Ksg/6N1u+1Du9yYud2v+loZXb98qM+kIWq6JR0Q+MhNQ/ErRu/Mg/Uv35pc2a52VtPwoIAcP/Qu1NZv+Ka90FOnbhrrH6FU0fXY8PdtpCr6KJ/66yDk62trSxfqcADy9JRchj6u4PumPp7z2Q/6nw53s2d7jHnusn55m+pSKtt9bLv+0GMfb+pd9pLSjTrO/akotMOVji9+dakc9HNFm7bZsLSVhnoVOzR0CtaN1efMt1bkUtHcexef5cU6uOSwpGs+2JOMy0KXDUI/jrk6+3FhvYxOVOp4wEeFer6PK30Ceh63Ae3LBzeV0JYu+nm/RkjoQtzrJDXk/h4XdqzP6Kyk5YG1Jh0MgNz99sPD12vllDG1SO+54CPe5Bw9J4r5aW/F0zxNIeds1vl+roVvpDQ9dLRCPRn4mL3ejkgFPT44uPm2grCvfbA+MsHt7/Gc7DNsW4juVS5RPX8bKS27M/5nax+c6t+/z5tGA+VUYPNpl8jFCprjPWBg0VQXWlHe++y3Fmrq03BWuM1HQ9s+XlopS9LSuqkxk4Kgf5He6prXDQqxgoXOVHg9WEEF9hfv7LdRRVsb7tu9YpGUTvbM38a/m5L2rfUNVWDeFu/29PXoEtB3VlyQVAfrboGZE4xNh4EuHDe2bncYevfehq1P6kFP/3Xatdmgd6VdDjxwv6qmM9uLSZ+3diW3PB1vtYAcX2ju8MgZ+ERCizzne+4vJ6X5eScsG9dfRgXDR2/PCZfXoaNLjPqJ9beiud2iLrCzHH/Z7nH5HOBjpm0/cKMY9DDfQw5YoaeZNMF+m6q70MCBkzNcra406XqPMSWKSulYy291te4K8u5tcnEdArnMt/28CmthLyoWPrl4axWF+TzPvrg95ND907z7zlKR+8bJI25hPuzveOnHpioSGtvrnDTKRUbux0fmzn5WSh/zdF2eqyXWlSEFjcbWclpRfWH76xWVVDg+uWg49JvfbIWrpczUUGl15KWaFdzpoCLR4vFcStd824co7sloehdbx4wdsCsuKvhhQGvYKT6tzCbZo6Q9Ev+idhcJXW47qvP43FIaNGvUnEP4NMPm8OJ7m0ZIKFd4e5/DzWX0fl7xGV8vKujownlrf7Zzpf4bjkt2voO9dd2UjVborVy+GUrIRrrQjB6Dq361Qy5PMt0fUFVF1+ocrX0fbswBi5bkmfJeQV+/fd1VYQfkcMcn+SOsT18LDrl5FXx/ce9v12uCPpx6UqFGiwgF5dyzPG/6FOjZjjZs7Q66qalfdHxlk5JUhfpWT4CcPehF4UnNsqmo7uUpC+ZGqulahelfO2/VUoWmIbMjIK8832mLvPVYQRmTK08eC33FwYz8rcdDPs3XpkzMe+jvjsSeK5y/Lujz+hp150PeeZng1dGKz1Xcfj6427JHEoqqv39KHQX4/Zu7DIU+bipzv/DjNYr2x7ZW+M0Lnb+tUp0P8cYn3cQ35Pi8R11NPo8U3+URJyFkPoZHSdZXabAhIEHHh5/hO6R2+FvbW/FeED6Yix1L+OxMcQFHbeFg4txajG83/fnhJ0vCb19kwS4NOIDC/4TPoNE5LOxUg1g6nCpisNt05ji4qIgvj3GZ4YfDtu1jmf6lTbiENf4oObIV3vLNRUHxfTvsyRI3fve85+/C8B9f84+/X1SNvzTl9NsX8fk8GKfbuahb+h+J/PYe+wBwvCjeNIeYUTi5CCFseRGhaBHCXhoRioEfwFBPUrJfBjCX5Whm+HRm+HJm+GZmWHxC7rcyNbHi0H/eYlzd2Ry/PRLlAgkT5aqUWc6sMEQcca/GME/hy8RfRama6dfEfgrh+CIJ74ioBjd99u9pm3TOf/ys1tYxLdoNPth8a3Efd+e3sNjvib+GIj6TxHvgnAceRDo/G+jcJKjDlehz7GrC5g8+g9NqMkdmfV4m85s08C9ynpaRYnC6+7Z0bqHCx2hiIyON5sw9D/iYWDORRXVsqhA9FInBAo8hp99/M3tSbYPJGeNfH9RoVrVRjcjMEL4AJc4JwteFsPMPSVRv0hLFxH4/HR+ylZSeFZ3PccP+NTF2/6UO/E1zDHXxOXVsNuD9Bc424Nry3jE++PMvsZwR/NAkzgK24mri64m/vYDKYjMQ9kHgo0ciDu+yyfpmHU4vw8Zs/n5CZqzMyiBTbuY/X+ArNBQmUmTmXZ3zhB/E48MqsdVKh4ObcIJAVt9kHoPHH1ESzWy2RYmdJs5zpoVvttgOhINf8M2/WByzIDpHXPM34NDV/K2mf/tI0dxsznHEOz547PER8Dy/+dC7RBQdXmY4vAN9jqmOQmH7PAoZbeCPEPGZyRb+Os4N7Cppi3fHYHsO7xr5fb5V5y/4iE9661Lw5VD+6r3NgA+g1UK+7fGsU6bfUFaYd378HuYdOfzdtKxwj0xa0NbscH7dkr+M1EJ8ebMsPpWEoyKcI/svn1VixzlTyT+Gx5/pjcnMz5sTxO5IZ28x7cIBXPgMlkW3R0cZnXPr8GUG7OHhY0Iyv/PJ8cSzP9KC+uFfysoz/Pcw7x5iuiWB35UEjf77ffZdygrzziKO17xFs8bVanKz+QX9/oz9jE7ha0hwl6NENPjv4XoIsy9/E+fH//91TrDLvmgdPmKH90YSjQad4HKyzxG3Q1aYff047IMvB3IfcTvxVxSzwmMzx0tWeNxfwlApiHC7HM4w0y7+3tjvY6MGflvwnHccNYIrGe8Aa44R/nd0m7+h93sYLKO4FzvaSR/5q1C/08ff5gV2GKHKOJ6dz2VBK5QXy2IN58nlmd8F9MXKxosbvsDIiL/A6Pz73/LDutS1wrjvj1yp+tqNP6ueklJK3p7a/G1U9DqoYXNfyMdnB32N2T1aQYsvrK/WeYGEmp+Zmev4EAnJV1ZYehN+F5c3ZGv8eqmUxk6Pa9cWdpKobtMWrIP+obf6Vdt1sJutUlzbv/iDnBTVTqsWb1FQk6c52q+C383/lv/XLM33kVsgD7grFs3fNUpJ+SbNmFC3tJx+zKyV9wH0Pm0KBnk+gR/ErjwJCq0COKhloePQixf/euR41T5S6vew63t9Qym1q3HofXC6lDS/UvY/+QZ5sL7f5MRV+GpZ2tam2VdgjvZ4+WIl5J3moR+Pnf6i+l/zOwvsmiv12Us5VVW9yeUNf9ZW05OuTo/TUFLItaDdnaAfL9tlW2vYv+YP79l9IxiM4FKPanztD/nA3PFBI+jnR9v8+nesJiev+3n3x8IO3LX+U2l8kJw2BHQODwHRzNj3JbviFVH/4k3fLoH/zsXXS8aMBL/9v+Xv1qPSDXlcWw8KHaZwb/rdnVyPrx3hGg9/i+CTUy5PgryVT5nSaYyaroSMffcC+ucWFQotCwPjcvVDm5ejXoPfuTg7x0R8vvS2Lkc96RIZ5R0z98iVDxL6/P3r+HTw4wdG3D26+DLkCFfN2jWQw/Y/33tAhW1pBab7x7jfkNOVBUVKnDmppSvVauufjNDQuQ3XzEumw6+Fpp4PvwH/l6ZL67aAXW1Zx9qn0+7IKPukOdlrw8684r3HwL3QQwRWfH0xxQ3+JveVhb1qwD/A98WqpvisXbvGL6Z9D1FQSLNT5dpdVlDs4+xdja4YJ4fa9JuN8Tn+Th11Dei5y3xY3HVTbcip54xBW+H3ktHkw9Yv5dV0M2pnz5L7ZTS2wflVodBvVHJMqZIb9u+i9800SA757eLOo3rYMeRxbY77oFx3D43yY7/nU/odF+bBrv/wY8H2TXJDL9wmZOClOMw7/3YHB1Rzo0L2z8ejOymoxug1+i2JrhSh66oIyaWhyPSQqK2NNRSi3jN91nwVHSwyNC0H/Oval3trqv9LQbtUH9uNhPy27/mC7Q7Yy85/GmDMDfvW1EdaKgd9dbcvsekNYK+q2P7LHa8wCR2ovPhkqToSWvC8ayN/FxVViP0+MqcP/JnaT5FVcqgpLn7Z2qhdbnQxtOb2fVFq2jvhxqT+3WX0+Nf6i3VzKSnizBrfubDXzVztpzwF+b7Npwddp/+Q0o2bq5qthP5w0n3vuEUz4PfW8mwLJfR156t2OuvdF/5vBx32FBv8hgzFch6bAL3O8oWlL0vV1KTO9n5vqoFuKrX5G0N/q9LYFG13wV9nxZkqP6ZI6dMD+dSb8Ddpm//41pfQ/2pLfV4zB/q/UWv2tXr6Dfru9lXvvElT0fs9r+xtPsHeIfWuYhwqpYbXE5eEl4E/+sL4U4XBLJ3p5J+qi5dTkYtt3+0OUlKzu/PKaNZKKaNEth7Fo93pQo9ZFR0SNY1vNkPr8lJFJY82ePYN+rEZMZUiC/VXUVSNfQFPYU/vm+PRIvoqo5BrFSf6FpXQCJXLo7GtZFSoW2rOo7WldPr748SW16A/lX+9G1UG8nlB84oSPVzofvciXTXws2wwzdfN3yqnyNuNdLXgZwk2rcITlLvhve8T93+DDLGyZ+JOB+xAD08OyDVPTr8CykmfYMty9m8TzZvqwq9x5cKV8o9SelZ03Ljr4UqqPUI+bcUPGX1qJz+/Gv5S0oKvPZ9/x1rbqNj+GdAH7Ky9J1/3sUoqp14eMiBATVUqy2LD4C+57GfcmNQccqpR8GfdhbDnDjn+amUo7Clb3w6qU/2XhGr4uhfp84WoaYU8i/KOltPrz3mHt9gkodx9wpoPR3s8qRjxKBbbnEf1aLP6G+wcZ0psGrQ5n5ymjYnr0baBC+3zmLKxCdYde5GxM56hH/IOjO36AnaeJQctt7suVtPOWtXtNXpC3744dsHGvlJKLOr4nAH/xyauNQvs/Kaka9+zD7c+g113yPb6UzZIqLOyweLu9VW0eeWJN2mgg65vLq5Wwl+pY8Jbsr2UUR5Hwf6107XU6/HVwbayLvQ436RzK2Cff+Pu369JHjUN/la2S4/zKtp0sefM+y2ltHXmhZjCw6GXa0OlC8HucGTlsQYF2Q8kvVRKLugzbl98PTLnaSl9G/RoRGnYyc9+sXdSvJRSDnXgx4gqSvjVn2tzCvOoneP+1J7+Kqr33cNYsKsH5XJrHzq3rxut2zjg8anranry9PzWn2laKvk6JP3jWDmd92nZ5/RNFWWPy9tUj3lZI9fNJn7wJ7524dkc/18yiis3bnihBCmF5h5XWAE9U7OBAfXe2JU0us6SwdN3YB1+4n+6oaecFnTRXFM20lDR1Q+HTC+soatzB55fhnwKTeg8dm0VLR15Vadd+9xqKl2tWLZOu6TUamWr+JzwTwh4PGjqFTCdPzJWG47CXvThq3Z1zGHwK136z7bD6T6o4ORXC0A3Hu6qX2El+I+y/XKuCukgp+e/pvXcOAZ+WxvyzOq6TkNh5/oND2wBvdakMZu8YKfsPE3df3VNcKCy+M/rh8B+N219Rn7oqYrXGtOz1wW08wNDYetuGTW+7R2xBZ8k/bS4x3PpTRm9Gvss0tdTSrUiXS8UgV250ZAB4xb7ge9413LXTPjxHps4f1vULPhLt55ecHi0gpYVeaxeA/t83rBSK0d1xD6T7kvOHF6hJjsU5Hm7qOn8qfZDPafK0b49Rw73UpJD1tUW8lpCkzvX09eFXXDhrusD63WGP1KsV4/z+JRpU78ugWqsWzWbHKl5bZ2UXANG9GkMvxL73VmPh2hgj37+dMCwkq504m53Q1v4fZkHtTGe8fcgf5cSirVPtNTG4jFhS4AH9T7uG/kD+uagutm/LRkPvV+uoxkj8RlUY9DzCmdyqij+6OkzlaAUaHag0aBQ+LuV2vJmhPydhIpO8yp/CZuZXHrOe9D9IfyX+wW0sMNeWzr9Ua7C4GM3BWzZtgV6vBJB3sM6gs9qdb7gqEa5Yc9QFl3Tc5uC9jZY6zPhjJTe+QdsjoM9rOmKH1cOgy8sGd6+wzro7bQRqoxF4Gd3Rh89GA+7XNk9HUsXhf1u0Oocuwu0VNGJ8quzueLjz+6jLiy8XgXrQfU0eevh8C+Yb/NpcllC08/f7FUwVkVdPzS48OK5hFbvbdWs8m4pNTp5qpnqJdGTb7n73ID++Nkvjxzx8N/oMGHA5r7ws34asyTqrF5CPec37+7Io6LC/h7D7ngrSf58z/1b3+A/sq3g4cmXFJR45dqwWlPgN+O9pMvDim6Ud1rbvJ/hBzW2auEdiz+5kHdw9vkNC0Dfvf/h/jvjtHTq59X3tTDf5n26+XXUeKyz29/9OAG7c/EXP0c9gX+AolztqYWLww8ye9Ox9XMo6YVyfZnx4Kfv3thdcz/k2HmX9he5DP/AoNe19ys2Kqjc60evD/7UUI/aZY3bT8KPeol3l8mpanIfljpn6VMlLTvQ4JU//L+H9Niva5uhoLKTvnStDT6yyu5Zt3aAj+uzFpIV7HPPhj69nlJPSlUO7b61tgjs7XcyQrwfq2hL1eqzr1SW0Xbd0PiYw/BnGdp0rQp+NpJTExfkr+5K8pwZPa7mUtN6z1HmaRXUlLvKuCLGEDW1ul8u8B3sz3ny3EoaVUBGuevnrJ/0WUIzKl3a7JgMP7pFv668/oZ19/jGo92U8FOdIVMn9pbS0luU4Q//7uIHomePhX3Rq41qzNOtoJ/FBi4+NklGj9JzHP62D9vy/TsV3w563WTglFaf5rlT1R63z/cupaF8BctK18Ofe23btq/HBUgoz0E//9AdsD89HTwtzQH5r85Tr2yQMx7GqYJmwC9pkX9k04Gwf3vkuzMlEv4GyWsvnnLH+jtqxJ3QhPIK6jql8JA5gdArWx0zIv1hr9rf/AnBrjLE35ztFvwLBt++nbIXeumpsb+8Jy7XQP/a+FtNs5Lm/tzyMgKbpApds1hjVRI67GZ/+gZ+grfKbz4Yn01GCZ71m1WLAF35GTDjHOxop2dXLVwd8lTxvZsb/YRgP+x11Zjq2SFvlPDNe68u1tk1C3t3ywH9b6/UsSv7uFOT658P7CoipdEjvOaVbga76ZBGg67BbhGcr/+3DF8lTfpa8rUJCr3HwRNnVsCG/VcPNEV3wh4fUVdvbI6NSIMUc1c8wLov/ZI463A+CV077B1rhzBbvVkTj0dRcuqVc8JhXV0tdWwwXv9cBT/v3V63m5VUUbcnc29sKqKBX+S1j96QH4a7uE5ciHatm+/+gTvga6vOS25aGfRv5qPFP2RdJFTOPTL6jA/kKvU8SQ3wyZo+Lbecx7Ei8YNnf3wDPq9wUXMHc4yczrlcHJsL8/XCgQHdZ210o2dNWnn5dtPQjD27kiuBX3LfaYsoUElFn7X5LnxcAP/o5W4LW8F/ssTzod0doKM7MqLeV0R7Lpw4a3jlNCWdmJm2KATndjRbm9Z1I/xgr7qXvToP9POcJf/umqPht+JZPFf3dRLYW5sXTYD/x+33yxM6ww/nuL3b96kq+CXFuhgmYb5MaTR9+TL4y51Yu7a5FP5DG78Outx+voR67ElW1YE/5eJsSykD8qxdoz7yfI6cdu+IGTwcfmsBTWrVO7VaRr7dPqzcjKNPVhR/kqpcAf/Nmpfiq8K+07dL56HH4G+xNTB151dobZoEZ9vXHH40fdzUPw2wi83JJ4m7ckBGHw9+vFYFfP7hWTOGg72h4YnpLQbAHlqcJlh2bpaRZuFC3yEXlBRYz1tdEZvIht2ZFeAWoSS3l5vLVrgkp427t67oC3vmzgY3biwzych7eVB0yfmwe/Sqcc26R029Fm1SHPgsI8/Kvb+0XqwEX9e71e7vruTdqO9MV9CRr/0tQ8vCzpewZHGFT93lFO9TImUM1peTnhmN2e5wM/fTHl7gt35s2FBz6hX4M04p1ji+qIJylMhT4utnosnD5ZNto6AxznW+cQn4UZ/srvm5rJ4LBUUWl30v70pvN435eWialHLX639fv0hNnfZZs0d3cKfpdx9d84Kc82G8ra+tpoJuNPm48KUB/k6HRtib6MBXDa5l8+0Kf51xgSc/w6/pQQ+vzcWgzzhRJcTtK46YmTTzvCsOSqGT3stosj/8k3+Ypt6YpaXKPj5Lxh+Evbv+/ZcnwLfu67BWFQR/q+FtIxrmhV/Hsc8zKw0Nk5LL8rvqpS3Q4ItGVR4L/tG/zfyZS63wJ6x9MalqZQkNb3BkylLoR2r8gjrsI8afZHidRkYVXXxZ58kP+DnssC9oXFgNPzvZ6ebbcmlp7+Ky6TO9MG+qHO7yBH4yGyO33R1XVEtHBzYY6ljkQvV/XqyUC/JjlcmfVxYtraLpxinNdsJPOHfRHK8ewA9m69eD7hNRj5QmK8d9zAZ5/Oj4pbtg7xq0OWV8OvyK0uvUyq4B/e5983OuH6BnLs0uvSzdEP63i/aeNaAcVZ5GNGtv0dLE8h3XWpJc0f/ze+fZ7kK9rTHJ57DvJ7rzwo+fv2I9u7nYd8g2KT28e+j1edTn2+ecbd8Fych178CnubAuL15R7OrgZOyfLR1XRDkZ9Lyd9/Zn8JP6pnyS/3ITOVW2r8w/8TLm69aew/fBDhez/s6i9edU9G7F3Zv1+8N/JGZiyRXH5ORopls4ZyP2sySfHlPyMdbzCkuOWitK6f3ShGWbXiuoZszW88Vvoj8LXZpdbLSE8npGZTNESUg9KWf8aPjJrlpw7Mxlbxw8ovt58hv2kY0fvffdgY6utDJ9g65ZTRcaoiwYs8eiJt0095jdiVoafiLZ+8QX+HX4JJbogn0VHW/dta2civV0jffay25ycrvpVfMb9ic5uj8ObTFJQQnh3buwniAopoF/u35y6ly1elQA1t+VrRpJbmDf7+xB1dU3MF8zjneOz9MffhLBzQ2tqrM/blhMgr+aAqp/rNWiiBu5eNdZXKGtC3nJSySXhX/p+G1edUZnl9KHFptvekP+7nm18+3z0Fe4FrjovgN0ctHU/p2mwr+i2tq2hbYtV5JrTPPar7DfeIlv6VK1wG9dnDsiYLIN+qBiFm0Dd/hTXOo+b9VV5D+k0vXEWa704Orz679+Smjf2Bbj91oxD893qu4zAvosnynejZWgY9U/7PTA/pAKIy70u7EU8R4/69YW425nwImLNQ9hnUi71TK1h5Tm9R4XnJAqoZZ5auRuWkVB2xXD6w6A/qpJzC6PZrncyXjVvuvJFvgHZ9Op+/10pWo3S+o/2TS02niieQkP1PeOy6zB8IPWqJqO72KG301ustZ5q6Ixp+6cKch26XmW/X7wXx7gumdpxBHoUrumv4jFep7cKc+eNTvRrx6dR7eAX27tibkql3yDfWoui1peGqYm9cMOgyNnYt9hu3yDBxg01LHxuQQH+Kao672m7Bkqo2wFbw/t8V1Cjx7bWjYE/3u27odtFY4qqHrVA8916P+NA1ZYH2B+lF/TdJEX/KOPZ6yxnIP/bN73Z4qnh8PPRN25VatG8H/+eezKd+xrGHm7vOf6tnK6Udq3cv2pCno2ctvhEIw3Tb22OyvAnn6zQd/UyT+hR3J123f7LPRtXeMSJn2Q0ZRyG3u1waZp74NjNxy6B7pdQ5E0Bn5e5cds1Z6Bv+a1U302nIBCOWxUZMvb9xS09ldB+Trof+iX6p0M+wpe1Lji1kaG+WQY2/PTCFd6UnfdvVmo351V2gFDnqrJaFnWdE1uVxowfK3XRfhB6Nv1fOT3CH6aDb1+WZfAv++gLSbmLvRLa9NG5bsI//WwPU9eXSK6oI0dkn8Z/JcLvV/ZN0pBbi+83rXGcVy9StpXzR0jocfutRpXL+NO38593X0Q/KlHg+7jEvopqf0gz1KfsY+vpuL2tUfhWgrMWeFAfdDPvVe2dXSHf+ykDiunfzsMf91Ndzp0wHw4vqHJ/dt3od9dL4l/AX1ACZrb+w7s2c2rDR/8Hf65e4aqpmxFv+bKNs34FfsN9zUpXzt/BSnVKXC3QPwj6Gvm1G75tYSMrqyK2tvQ3Y0GjzoENzo1FdjYvNw08Fdbjlfwed8Sfj+dvb/F34Be8eeqOara8NsrM90vJ/b7ZeT5XCfPIaKBFYpevlIf/kxtfo5s/VhJG6pakttj/0yuXiHvLmIfR0fvUZO/Q193xzCvktdH6NlqrvxytaY7RUZfiwmHvP1lsLbJl2EudKRQzz2nnquoYL++Kp+jGH+X1vQMhv/dtwkRr5Kx/7J2r6VXf4yTQL56HF7hiJS+9jvgk7e6jNIvD7taF+tH/j3dqixeD/n59bMp3+AnfbDo/Y0bwEdduPHmVpOC8Lt2NApKqQh/r6oTWtSBf0insu+X/IC+61lLdattkIPqrMjRKzv2+zxvN1q+7qCCDk0bPDLRIaMhgfXGpEDOPLNDMW/NLTmVKtRH8Qv7lPyuVPCJfqGkO82eV8/VEfrgnZ6hecCHJHULqC6BH+uyd8PWj4LfdrdRexo9A5/XqdSvjtnCNCQ7X6hGjwgN5fRd0SkiToV9esphjWEoiS7f92Ma9MFq27khA+H/rdzsdbLrbCX2TUwadAZ+pFtT+h6+s0pFCSsO93lbAHJ2sfk7lPA7ePFmaYl8XjI6U3vo2sub3Gh3yMycL/eCfn2fGv0B+z+W1P3e5CnkumI1ghfmhL/R4gatJo2Gv2Tx0KLbG/WHX+zLH9Vrgk86m+/X0pLwd1WfstX5URgHsMXkimysk1LsfEOVqpi3/U69KO8K/z3dQpOlF8ZFsS3mtktHwA9oUoPDHcHvz9xbJeBxTzk9UhnW3hyioSm1r399eB709vHs3v2Gu9Gh6Qs6xGFfyBW38bkOGSQ0If+cyChstDf2v3dpcncF9V9x3HyD99eO/j5xQAL8wPSy810wDl9ZUxe3BZ81fydOSMc5Ba27lK38CfOhf0iP7ybsm0oOe14ubTL41N6nJhQCX7L9/vaRjpUu9OHqphVtoW/dNjsqYEdjKZ2a4zg+Gfslgx3aIneGQy+x545nN+zDjt11JmM5/G/WlVk/pi72R1irT2nfGfO1zdQOXe8FKmmU9dSrU0/AR5+s45P7J/ilNT06+g7A/H/QYaeHG/QH3e/VujsH+24v/FK8zOtGV1LD5A3WaynvxPF3GmN/2rEnS8qthJ7705cSGw5jv0aBJ/EZdbGueh0x15iRJqeRmxqplg2SU/V7wzuVPyehWvmezapaSULzH3ZsVcgqpanb3r5s5qqkbMkre+w94EJy04Qx47u40IICOY5sLaahDmV0Nz9hP6Nh2ohiqdCnvBn2o/z2IeAzqs7rUgn7Iuqs3HNxHvwbu7RxKTEI/fb9ePZ9R2A3aD97b6X64Aua5qrwei72P3ZfqK/lhf0TEW+HzN0Oum6eFLmjJfSHm5a/mZQHctVmVfdNZbGf4L0xtaIa/qKqk761fcq4UdMetqbh8L9srj5TuhLkoGVhKw5eh3/TxR0XqtxdCD7m5+fvjfeqKPf2OvmPYx/QEu/1pnNSOTWbnXP4R/jhljuzt31x2DO65Ak8/wj639wrFl32hR8m9XqxuSf22UQ28z/9sh38vcafHjMhJ+aFZY/8rVVJzbv0yTGwjAu5PzfPajIe/nzLA49ehn/81y2bbcnQJ6/7cnvKMfBrdcqFHfx6G+P4RJ37Oz9hXfa46ulxR05PdMu2JMEOdTrpaePvKPf80EO5xnrJqfCJRJ8twe40fvq1reuOutOXHbd6RTRS0RWPoQdyVIf8Wyy61eJCLlT6xfVLj2AUHZltpO0r7DNlXkZpeX097/16hgX6hCknAuqFYJ/t+yJhftWSpPR6g6KLEn5OCzPko2rcldOE19dun6gB+WlK6cC19XF+SYfPH0q7wu44+G2DWfAjzH50zgYT6OmZ46/m1hgGv8qfs1adPaOmffE3g7ywXyM0dynjPuybbnL2bZ13lbAuzpnTCeYIGnyn6+N7Pwn7raOD5kDOLh+6qkGxMtjPeHtvA2Wiks7twDmAKF/ggK7pJyA/rtg4KO3AQfh7tb1U6O0yN0of2Dz7eayTTQNLdnXJcKHOfdaEvIjF/pEC03xXWVXUvtGwGgPPg47kGXGjzUkpDavQJH4W6Ih0XOKr29B3T33o793gCvbjGOcWaVZbQes2D5yRBnvhdeO3Hftg36ms0n+fPQJyWKRrwpsM2O3Of6/QcZ6WPt04dOKBAv6My9MyBsNvPSIxsP5S+Pt1OVjmgU9H7EM91lRW0B37KwqtsfvD71B285Jr9hkyWtNq7cuO0GNv7lHCewSMyF++bVhyHXrbu3PKdli9TULBE0Y6ckFOvLqpi1YfAj+0D2dSHxm0NL9cwQYf3qipZolmE/K9xj7mmzOuXcb+9eOTtg4f1EKJ/VAfRxwaKaMiXebtXFkB+16iGj04+Az7BN0rjsbxheSG3ff+0EvOedhBobiPdg1aEFpPqqAZb6+2GP0Rcvawbm4FUO5jM9d2tMJOOcCsmOYKu+rlX193/YSfad0PDZ9sq+dKusB7l7Zh3ZtSNOCDA+tj62KN+q3h/eDb0vZ5r8T+8wtXOnWviXVQUTHNDfnK8m769R3+wwW9csnDwhRkSFNpggOltH1VSPUaTbE/ulX4gH2rpTSwdOlNxyCvTsz+s0mDTm7kuu9Vjhuw17x4kLHv4G4NLYr+dq8A7E/v1GMujsK5FYeXrHnqj/3ILvO2jJoLvnjyrHxHNyVDLsxjqdsGcmXijA3axpi3e2MSYgJht1ldrdfCB1oJ/I8Lvd7WDfk3frhlUQbsS0/Vhf0gJ2Y4mnu4ddeQb/8ju2OisT+lXM1efbHPLPJS9WtuoCtF16dH7tK50rSzt8bnygF/32YjnpRcKCN9qwFVq8Ae2r/frNMO8Eu+I4Z1Xot1oXaZ9vkNsMOX9LTEFB0IffhB770Xsa/9ZpuBvyrCnnhq95JfZ9FOrRudK9wa+weVrt1S/N9hvTIderrsAval3pHfeZLfla7tabEzF/xmdxw+UqZgO+wbD1/97jD2NU1OWmJuDbu4edC9wV1AF0913nKyKPaB1JsS5D2oo5RMLq3KX9yCfZ/nD+f0gZ/6i/nauzthj3meln3gixEKmnBk78bF7WW0a0DgsAXYr7FjW9ETLcGPfO5XZ7f3c+x3D9wwcSH46w4H4t6OC4e/avkjSwbDPnateNF57tPgN9NjT9eVPcBn1xlws9wv6DEOvNr3spKCfvhJn8z6iv23fXKUPQQ96OdCOwo6IL+eql23fAzszJ88stetDft869O7P53AfuoXI9LyPYK8M9i1/CgL9sWOW1dhZzD2FVQj/Zi0yXKySjr2njED9tSZ5SXjwNcfPVouavNe+N80nLYkoCP8Myc96bC7hoRe9Q4Z6gL6+8ne8U22q6ATP3d7L8f+7uRVj17YYJc1fenY6I5US/U3VNoufQr6Gjp4rWMw/KSfRDYdDj3hr1yz84Rh/mpCwqvHYnyuKlK+yQScb3Hr7tN8OtSjm+1X3Tawq39V1TbYHklpT9EGk97vkNIO/dnDW9bJyWf7krWPu2B96pDbs68SfN7p6OAaa+S0eXqz/E+gNzhl3XVwcgMtTbm8b7wBft/lv16alwP7FuNWjawaYdFQt0KmjYc2Yf/tlVcD5mD/3+eWnl23f4V+7mdY2izYBRf6Omq97wu/iAZBunPdJXRwclq2IThnxaXq7LENwX8sOpDmcQXz2ufq9v1z0D5Bxh3GOn2Qf8f5Y/ZtwvkEG0OX58a5C100Twrcwz7HhoHadUsWulFteSHzaeyLrRvp8tmC8znSph6uVA/++z3L9VnxGOeNxJrz72hzQEUVa008VywX7Md5Z9ZIbAM75Yt6o3uBXx9ZocDAs3fgt7xqdod6sAfsNFctnQ/ncLRKCnTpkt+NruW7NHOBw40KPC+UV4p9uSN7m5qWnOBCF6sv0qqgn++X7caxWDgRVX8W1L1+ZZxrEtp3wTJv8Pkrru+aAD3g9Kkd8/qiXP7VBrjopmJdvtF16S7sf1yaFvUUbtbk23fm3HTsg70Vsr5Zjg3QR5XIf7o79g3OPty5/KUQ2P+qj1989fb/Q9mbgOX0dXHDu3lOpkpImaKMJTKUMmQIIfOQQpRSaVIylCQVUSSSUBJKJJSKFA0qIYWEIoUMaTBkyPdb9//e//d+nuv5vuv9ci1rr32fs885e95rVGBecZct5g2RZWq6t2ZsD4M94juXUZGQQ5gb7ncaEQy/VXuGO554inNN7d3ZRtCPmHqtOfQZ5DxyGzecewz51uzhny1n3Ib81zE05giclk7vflgL7gWhr31stOoi2E+4JO9O+qjIUtmTQFagwN7/Vnploi3LNmrOeDLmmzw7f//ZYAdVyCW/jXTcCf7FtpkO6xdC/6Vvfer3NujbHlmUPeAV9E9u+n7TMD8myQ6PG7KpO/y6KCkuaVofLc1+33dtMpotxV5vdX6ws1mGdfLUDnOzgLxIrGfUAfwev+Zciyn2czfPdEl+ryDH7pjpS5Zivv5oL5a0Ngz6My5nM27EibPBDkMdx4+CvOH93vOS4K++n3y7aCbs7Tcv3mKZ5SjF9vfbunpEBOSET4Z00bgAfYK6uc4JsCN+ojuy6CHszZTf9UxdBD8cxpd8t3dbrchqckw8emB9uqJrv/Q39jGFRXvrkqJk2c6x+xTr0L5/dprvuIL9VK/nhRnh4KcG1LcfSNwhw/o/fVhQAH7v6aEJ24PuirFg27MBvpBXJSiNnHHRAOuHZC9Vf+gdvLs5auarzbBHezL7xs0yaXZCf9KbXFMFZnLu4d9p/SRYbdaQAcGQ/8ld2m8xAvUoPz7RNhnyxl43b45qkcb9H0oSJa5Abm524osN5Lfefw5/ToSdV4Hz4NmGOJcUqo4/8xX+eLop3k9TgL+XZQXFgWnglxiqFtcewb7w88L0K+3nZVnLlJSr4Y7irCh1yz4/+EG6NGLheodE+EU4MmfQryw51mqgZxQiBf2JcFX1c544N4c4Xr+H9bHc/9ndae6Qiy2rqjI5L8Vs7aoK30Oullwq/WUJzhczkodkZYFP/3HW0Z36sJOLfFffbftJyJ1Pb75zb4kC83sj3rGnVIFtqGtLPw/7Squj5nf3msqy9plPU77Lgx/drnSkpIskez7489N98KO2cvHebzXgg85o+la+Eo6puz4Kv50JfZn65d+6i6Ef3509WntIf8wzNmfWLk+XZoG3xMUmwOfXjRTHkRqQA4XmtlZFX5BnjdEGRqpYB8afXWo33lWKdXksNfvETwWmJ138csYlGfbbNaNmO/iPg1I3P/7sIAX+26XnY+TgR63RO0YCfNBxOppt+6DnHjBliuEW8CWP+pan/4Efhjfaj3t74fwXbCs+YoI++EeDs0uN5aSZhcQum5vYR/nuk/8udh9yvvUFCzSuyLJnC7OOWoCPMO3aEUX1OpyfXGsDA6MlWMeagW+3qkLPaVL1x26wB8hwbX+ujXlzy85dJzW3QU5zadCpt9ewLq707OwJ+wM7qYN5uwKxbpi5PPOFXNa36sXR99C3SUuxeP18Ouw6pD5GLk4XZ3c3Pss/naPAeo+JtSs6L8eiXbJ92kfKszt9PhvmQpm0sqXH0V6nwIfMXJk3ywD8DXZF7Vkk7K8O7k5/j3FW0KpbagH9o90f4jvf6SPNbg3LjX6IdbFWMqOgGueUiKBL53LgFFJ/UmWc3yc55m2tW9gBPYKhO3Ur5sF/07uRj699uCrHpKYtTbVskmNtSiOezYMdn1uvRXpXoe9xoF5FPAJ284GHvWO9YO+sNt1+RyHcv3/0VV3eYC3Nzs3N6PEMfOLBa+3sdmM+nhXtsnRskgzLOXk64jP4Lp+fnJafmo39sML4zWfaFOEnQVmhZ39p1v1gb8sYJUXWtrPu7Sl4rLw/XD3kAOzHjmSmdx0MParbgbe970O/41yS9Qtx6MFNvNdl0xw4fc4f1964HvKOkfJLipNtwA9vKahcBXlp0se87jt6wb583sCEj/DX1GjfYOM1FuW3RCxKxHzQtM5pe+xlBXb0WfaSM7D30+j6U64X9HFiFCdOfQk7fXtvd5nPNeDfVSR+/9hZmn1be8NpO/T19udrO32+hPlx5Zc/SrCntp52//gi7IOyjnjorIBfhuDbK6tgqMu+sLOWLRjH7o5RI75elGdLd92avuwp7KAmjT784bAMG3jtztzPCtLMNMCpQ8oPfPCRiRq/rGCXIR3w8acM7NnnmxRZw5/Zn11SBxbBxf3u3xERFVOk2J7d80edyAS/eOiVTnG7xFmHi2vVEDv0o4YXF3z/SDPV1hGDpw3DfOKl+8jwmwL7w14mfyyRZYbnGs06m0mwQyWtkzR7we6/g315Czmtpax/1F74Oyzv//yUPc4tZ03z5b1zwDe2elK2HefRce5578rPSbH679USz6Sw/0lJP7q7rxi763jwcj9dzN8NGxJuoD+a1mpKHYLSrmnURZmsg5h3f1Z8vPZWjk36ZdPdF+vetVWlo9YPhrzjxYA/O3wV2eURj273w3x/5qFNnSz8Uw5zK2qtxf54zDX1a1W7GUu6+a7QB/osXV7IZsdAj/Gvq9VTY9hRJ/cY1CEN+den7hFJ0tVYHxoN5efDf6b5LUdtUxfIfas6HVscp8BCP243HYj2V7C8OvMZ9n9dNl67PRdOPGfGl2Sfgd24hquBpAz8vCkHtS8Jg/+fUlZtWzRGgn1+4Ln4AcrTqO97yBR6qAOGlt10BB+ll8TwRD/I/TNbE/1UTOBs3GDbEM3VjLV+qb50GHoRXx/rxwyf0Ind2G71MOy8NGszUr8bgXOwuEpxcD3kZfsClu4shc5za+Ty1kcYL/3OTc7zht7E5Z79D+pDrjDuRpQNPpdZnJskGwn5vNrTwvrOjpADWJbcDMW5cGUveQsp2G2V5AZsNsb+p3DQ8VLJaZg4W1KP1EPvI3ajx5FezuAfXIx0VUB/XDjh3Vo/2Eu+2hK3sikO/piOD6tNxvn23Re790sR6sBArvujteAXPtV815IwX5wpvVs3dyDO5wm2+8I7ITzCy06t3y2goCw94dM5JfCPxu+64ZqLeWPRg8pbc+8ps+s+bzfYpMPe7IVj3xvwJ9TeZ6yVJvTvMtTclfbi/PHX5efaNx+l2Umb09mmkDsr7vslfw7z56Aup7I1IMc8kTzK+hbWsbTchc31A6TZYX03Fzp/lDVJiR2BX57Rn61VbbfgXPh89qup2GdOOn1TLwn81IEjB7SYtsixPXNGxr68Dfnc6d+nE8Cv/P1mNzsKu/55M7qNt4DRR+OGw5uDYb/358RYZ7UwrCsHr1iveIP9x1jN1t0jxdiwrJodadiva5usOj4Z+/rZG7Z32KD+eq8+tqcJ/LP3j6QmDoNfqfBLL7rErJFll7fcOyCprsx8zaN2hrdKsGR/tZv2OD9F1s6f12ML9BjvDIvJxzliqJ1P7Bfwv3YPben7Jl6ahToFjA+DPzP9C4WrfOBPpmhVrJE49E6kPYOym2E08FHRTPmoJPZVKR0PnuBc80X/QUAH7BkHP2x6t2+WLFPSbpDeCn6DQ7cd+8dAzhNcnlI2H/5mlqyODrYZKs8OxblKXe8Ou8IB52Rfge8ld9eqy7cm7A9chyo3oXvc+RmVHg8/hocf3nO9BX7dtFlWqfshL9P9GeA/A5Yzni/73VkK/Q+fzRkysw9AH8G0ffo6yBl2mwSdSoD9etYCjTtvZDAfP7YYr4Dzs9vFD8nymK9jwjNfVGB9Obroavj7pzLMqXDCtJHws/F4ZMPIw7Azf5H7a7I2xsnJyLjlMfCHJ73K4qe5D95z3rKk/P6Qvz067m2wCPNftVHLM8wDJ8Yfz3V6JMts+z5xnYJ+k3JO3dU4EHowRXmzTWBvWP9Kpns87M0+GBh+rbsuzvKlz+o8gfw6vntZ0UKs/8qD5WUs4afGbMzT3TPLIc8pq/g73UuSHY8NCI+Uh96Jmn9rJfYdyrldHO4Mgb++lLu9B+J8Ma9rpFOosRzswvdvFwPf7067VexCrJeNznvMxS4rsomD+1vP1pNlWT5Ze3poQn6RnWY+HOPGzHdn2dnvsK/bpKa6BH43vC5/XSEF+UDLvoeDShaKsUOqp2KUbkPeMjJJRxnr7rUZW+aslhVnj+qj/Zxw/jdzML4jj/knYemiqlnwR9I+yDNNaUUnZhAx5E82/JrlPZUYPVdbnu1JVepz74M08+i8zeIDzi8rLGvsbeGXIeShi5pPDnw7f7NUWw8/TA9eKYxth78pY73tMfPgl8RfNqH8NuY5Y4OwKWY9ITcJdreoSZVhe7/+kFGHv7/60HH+EdC7dFu47/aRZ+Dbmi9YWKUpy4Yarux/ZLc06x93Oa22BfuFXkPiNuTD3+Tl5rEf4bdIurnwq/xdrLv77VrK0P5b1NV1A8G38foVfbXaFXz8iPsKXXBeCjLdtDIO9udfnrnfaYP9/FD/Gc2J0PfQ2SXvMECmE/vp8+X9OMjXdQtsp0S8wPz7dG7KMmk51l5/J/YT9I1m2dtIl0M+YO871lUvCvr27Y+WjAXf8eqch9lBB8XZYiWtmgGQMwdOfj+r/QnspD+65jLwl788bZWQgh5RWfPasB44l3wqzn8+aooc67N13YkDhfLM82qf4wGwT/XKKgbvVpFtH3gjaiD8eGV7a1TVQn9VsaW0i/xR8LEG9nmVZwb/EQYJP8tqEBNiRsSG2NEybK39ka6/4Ncpuev3DD3wl5qiWrw/wf9oU+91Oq4O2F8uqA6QhlHag2WluS7gGx5fF15ZpK/E9J3Ozva5KId1duPT97WyTKa36pUA9Keoh8f7a8I/3/5FWuolOE9WjNizKRX8gYYoB/8/8NsWMjfn5hrsEyz1pGO7QH70p8tys4H14C9G6Pw5CT319ATXbxdCxdjcytUfmrEfmbj367a6q8pMqWD32FbI0xsaVwRkWCqy+E1huS+PyrITemcyXRLk2BLjPDsV+JvqFGpwoAvOBdoew2K3Yx4JrlDT2gR/X8GuUxedwfd8vHt8xVzwQYPm1+1u8oD8JfLWlCr44dLSezJ2FvyiLonxGT0d/D6/B6ErN/zCuWGJ7Iy6ECXW5aJv1Gz4F31u5rG0EXqxy8OeBz0Hn/T6q7Rl5uAPTRv0UacD+hjSll+qG+D300u/5++9CADiu2bcXT/IMTq/qnEOgBxFaYivofhNcfajomjJ5+fSLMK29xJ9tPefAdOmLIL/zaCiTFnWADt99a1GK4zlWaLB1+aVseD3fMlvbm+QZ8PHfZt7Ol6Bbeuy2uAH9g1tqTsvjsX4SNrWMkx/D+Qkp+KMxkSBL9Sjb/hU+CXRMR/7dCTmw2YWd6jcl7ECj9fsph3m8dHXmt9hvxk9bmxVEeThgY96Jw2OhZ23Y2FaIPgtS6e3jLkPfZD2jrA8XV8lZrlUv9dpOSXWo+OvrsRKSTbnpdOxN8PFWPNW/ew1sPd90ewwyxp+oipP+RQU9hdn7we0n3kOPaSMzQ1rAnA+uP/rzYCfmM/nmMp55WL97RyiL/4XBlBvuuQrvTgpxzrdW5VzSBZ6ozETxWbAjrfQcFpmp69yrEfty606XuDL1Bb3c8X5sWDgh6OGy8TYBL152m7gu7/vLzuuBPPC6biJpRngJ68aYdkvG3LclxK5WX5x8Kuw0mH0WejDaYTMN7v4AOcpnYFBZtCLHxp5reu7aQosc0KvvLWQ15/1uFc9A37Wjnkc7PQY51tF+eKM2cfl2fHqYDVFWfDLEzWbtuI85Od33EsJfhokzkyZtW0V7NuX5RmflMb4sDIwuIjzo2HWBNto8E28ol/dqoH99tr8y3qa0D8rma+SYAT+Z/CtF6uaHkKe8Oz6h8abOJcnn1R4tESW7U+52hiB83z5nEuOvSQV2MFK+/UDwLe39J20dBf4kWIya7yMsA+ob5Sq8IafjhDZ5xovYiDfeLWoqh3zWkeu3YWGNPhViE13k4O9z8WVs/rtg5+/Gab+j7PA35zbvOPxqmglpmv4oPHIOZwTLp5edTdAljkPFPtd/VMZ57tOcS2S8mz9p2b7kfCrbjLT+60S+OebJS97l8APy07tYc5x0P9NjHDN3wv/dD6XPowwxnoj3qMgIXmxBFvY/3G+61W0m7pm7OVOEixcZ2tqp8UYF/0zFBaew76zn4Z8C+S4n4/1e9Ifepq3VT1vTxgFPYba3u35ZpjHul8bsgN6QTVBs29Fgy90o/5JaCTkDPrdQ9a0YR82YkSC9TWcl847vTQdDAO5nlPXD1suif3WbxNzGfjJCXfucAyFkVnN78pPWpCjZqm0Sc7BfmrDyQe3Pk2BX4LZT3cveKPM2tYYlQybA73Z3vqWdrNl2cyfqwOStHCeq7o3bTLqc82uVReOYJ7vUCgJbYa/Rq/cXyYJVTinXr3xQhX+vO4nJWRdeYh1wipheki5JDuqILk8DOt9eLBty2n4LbLQHXMxHOewqCkdg0YoY/+ywbLYd6A89E0m5X2Gf3xlk77d1sC/VOSq1FXi0Hs91LEpwHEf/HtWfZ8+Bfxzv0neHeuwro98ce/OXOgNPv57WnYKDPVejKpO2Qk9n5VGZXfvQ46pufz00axB8KvT8PxNNvy8uSgcv+NsCz5Nw+pdK9vlWP7S8GMmF+Avd/ZJz9PHsK/rvujzEEn4+xjQ//UyyN3qKqxSrSE3uXvu2IPWsxIs7IOkkgPkU7c2WTy8h/XALPnYFB/IVy2na5vHYF+8z7F7i4OKNLuoMn7xwA+MlZ27a/oWemHdk5UXf/OGf62xMQYtU+B/0CkyfRrs6x8s7NOhP12BrV690noS7JPKrj8flQK+7onk7hoOWyWZoulK51rMO6kmP6r6wl7mjN2hMVNxXnV++aT5jDT80cjY3rnVLMme1v96ngr7LJ2uvvIFyXj/BeGy0ThXSs/M6lZRDX5sdfMM2YOdWFPxutP58Fdz7IPlgv7gbxwTa9Ky+iYLX6nltz360HlEdl8GzgnzzKTue0OPeqvHMJ2R8M/4cEXyTOte4P/W/ilORbseGDdiQyH8+R37O8FhDvzY/tm9uGII5v0Rt1/6ZkMvIbjce+J+2JN0/pEmN+iQEjuW92OzPvSZ1nfkj29XkWWpyXb+M2AfMkw+RrY/5Cnukm+LoD7AuvbrnbQLct3xkd8+KeSC76UtMfH6WOjHneocXgf9sS3Dw5W7wA/K5JTktW0lYmyx7eL37lbQy11edLAN8j5m5rWr/A70E5Klczo6UKDZzi2/wLex+/N2WtgV7DN6z85n2F/bLzu2dAn41FWVZtmefzBPrjzX53eVOOucqdyi8wx6HD1GDLsOvZcfK8xD/cFvypD72/vAJPgDCShYuRR+Cnc+XuWxeAv83A5M6pIFvrC6+95lheD/24yaVOkDObOS6bX039B3PL7qZsCYQvjFkAq7GDYPcs6sgx6la6VZnYe61yHo63b9dlgtFuN02+7XhlLQu/24U7trBuxF9J129LyDc0J4NyvpIKxrO69OWDsN5bw5VCGv+Bp+MVKzNhmhf1xaN7doLvQqtvYZbeWhCjlYWqh/vKMs0/Y8f6wFfhun7ysTb9wPvrHlx01R8D83qPhC6MjrsBtTrb3YA+e3fvtsUn1hj4cAgRnB2Ic8aHxp7/UC86HraYWN0A/tFq4dtRT+OFMa1oc8g37kyu8e0Tvd4c9BfOyFcVaQH7zp7Fj7Qo55KRx8eBP2LOuLrkfIF8mxWXMqrtgXSDP1Oz7mns/A31S5OXIW+Garmo7oJcN+clHE5osayyTYhIA7u3bD76jiTu8t2tB/cnhb/rY//IDrnn3RdBX6RAWP9K9VnICc/8cCGw34t7jimapuXA89/ZlaC9xMFNidO6cqn2C/o7zym25eIewHl/QPioZ+/cai49f1j0ux5HN9rWUgp9tk0FkrAv49nA8bnamCfnfXDMvFo3Nl2LG5cazitDTrFbVIxQeGtCtknHdXLoT8aHZDqx784TzeuiLkKfxlmo8Yu7TiiDxLP2Bc0oFyHv8wbsyA/x+f7vMOKx+AHxpTja6ncA5qeW54zRX+eTZFfg+4Fwt9zB0Kvcyr4a9ulP+5SdD79SkqPRExA+fRA5GqzSdhVzYq9YklxsWFT7K9SmvFWNc+F37cgH1J2I0SFQnYaTwOfL25DfphRU76H8M/KbLf8RKeVo+VWcWesV6P4JelbMlol12Qi05+PGrGZOj9zDtvPSWuAvaCLm9DXB/A/1jh7WvTsK5XVZ2O8wK/pXBYXO+JOIc6useN9YNejueEWbXbV8Nf8dtpZw5AT//6UQO3i3QuCLuQnIN5UCZUZVs45LWdXpxxUpssywJ6D9nfvRL82Q9LYqdclWfTbhp/WA1/c28V1K48CRdnr87WrC9+CP21Iy22frB72bZ6U+wc6L93xDzfUI6wlV1dTvV0gBwh2fnLIHXwjX///SLzCXrlL/KevN4HxeIsmTU/Cp7KMze5wFOOg5TZoym7Lj1/D37JaoMFG87JMXP9Bp21z5RYrHmPQ9aG8HMW0pjhC7n6pmP399iB79bXsbr8bir4ulf+FryFX6Hivskv9xRAj0Li721P6Ill9XhjYoP9mnmvgkVTIL9u8elIGgy94G/3lDflwD/vhmCdwHxZrDcG+Q2NQxSZg9477Z5GODcGmrkdxHiyN3m7Lwl8Yu0bFWVN4JvfVJorh2WX1QRe6O8Nv2ZmO2bGrIbcYM/ZArmpsO2esm5Y6gboNT71s9gRV8pYbOeezbnYz38svrS8BXqsXXNvbq36Bv3Pg1t/RZUpMo1BnZcFjJVjC8OfbTkAe8KFclLZCVh3PznZvvlxCX69MjpdvQP9lyNiz90PYz/zs1NA8yX4eTF9/kvvLvQ3DJf5HZssh3OY/46F03GeHjLuVM/ZIdAXbVcIGeXFWNOU1JLr7yFPvZm6shLxOm6M/D5tDvzAJivrTLNGnIB9Nd4L+mIf/uh+uFnFOvgT0lr8az/k1JtrTmnvgP7RVOnMv8rQjxl57ojpBvDpx7SmzVGBHlS3vdktk6EXUugedOES+JzH7LNWfD4BO/AgtRXrwDc8mO84Zwvsbar3l/2wQ79dfCRfQwX7xl8nErLGV8Ged+KYKG/IwT+mK44xQPwHpvPNaxD0FoKcet+D+ibz9PLorPFFhh3wP5WgZAh9kAGv00PBbyx97L/7M+ypMnwar1zC9ZNkjTr1hb59cu2kTC/UT0PN6wIX+F9OUN48I/g1+Nm+3fbE4v1HNK1x1rRWYM5/E6NVII8+MNCyPv4b9rW2McsfQB80UvXAJfK7r7MjXWVMAvzw+5cnakIOWLm54PRtzKeNo2QeHc3F/FgaXdIX85yquMRCeXSEX51P9GjGfvuAY+cHP1tgP3JtfHrvKkV2p4u/1c5VSuxF9yM6yyDva4+5dykdcqo5h1oie0BPeMGclENm0MuM2vPpjzz2w5vmbrPtgrgQxw4bdnoEeWCT24yZ03Hu3bqt8cSD3+JMtzzWscthcfi31xXbBH3/fgtnF0aAzxM8yaY4mPSWvkxddhMBZ86kfAxNgzwtq8Ws2vyPAjMqu5q1pwLj6kts76Hb5FjMIPWoGeCvJRW+WR+CfWvdRYsF2diXhtSvGimGfurpu3hfEPikG0wmyqhfxP65v9KkRvjlPfS3LZQdEWeah6s3hcNf0YqCCd+69ZVh1waPb7uOfVBa/OeRjTPkmKzqkq6bcR44Yj3Wxgfj2urUwqKZ4OMdPCNjZboD9izXWpwaMJ9bxaSsmwR+6XWrd9s+vJFivdSW7G0D3+G8VGSYPs4V0Xd679qJfibTr3fw4Y/Q7xjW8ndNqzgbm/J6LNTW2cCsPY1fEYejyHPH24gRsM/p8dR0LPwDdN3tbzmsK+xD5m17GYX3e3wgaMVL6MEN+LB8QQbkdTUdh0PXlmP9vNT7wh74JXiypSE+QB/+eq4r3izsDX6vnMo6J/hR3FhQojUrDvyV3W+a3sdJsk2rdx3uAgcPc6cO6V8EP6zphuNVpHFu0Ndqnbm9H+xTrNI0Jg0E32WA0coW6NEtmxEzNA12j3Ojhm8egPW8X874gGlPpNmMJ5WqT8G/OTI69y6Lgfzh+PSRYTh3X32tsj0QcnO3budV342HvbfFhUdr4Y/ub5qXFpYDNlS27LoqglVlmAQuHr4Hctc+D5Jjy2VY97dXl26AzfK3c7aRwyB36+UdefwV1tUJU3utLu0iwbbKPGtIngr/2e9jmvTg3MIre/Ko7ZDrlFgnXGvDulE23j3r0gf4eZLSktoAeYOD1us3nyBPFD/TLH8O/VP+6eXl/VsV2G/nVq3v9bLM6ZbN/dLrCmyAT2u/OujV53rtHOJvhzgkmg3Rv9skWP+hPz/IZEuwkxUrrk5Jhx6N9uLLVojn8KjL8Tn70b5Vq1V0L9+UYGfv7hwvDbnmp6jclfHwk9lknCCtCDsv1ZLUPH2cf3f6V24ZclqRdcT6bF8Hf62n5hZ5WA+TZUd3z7GthpxxxPrA05vUIPc4O7u8FO2i7vPlTxb4zRsmBO02hB9fk/bNNZ/AR9t0ZcyGhVexf6uY/ao/+FuLCg57TIWdzNR71+47Qv+oW/9L7x5Cn9UgUee4zG/w4fN3K04JhX7z+OKYCMzLw2pmvWmBH8bUM76d9Xcps/EpeopqZrB3GJ4TfAn2rmMbR/1ZDjnqV+uIWeES4mzCnNq/O2BvfOTix62L+ouxK+535HdD7/lv4u6tfRF/ZvOUvJwuWDc8R5x1T0C7uhatG2wLOxi2T3L0z9+QZ6dlGWzCOcFr0emzkyzAHwiMtnRuVGQnvd99Xuwiz14q6XrfVYT+wnnXEXOwDxy9ecHIMOhPHRk6OTUnFnrdUes3nwefObUpaFEl4tVE2g633g87/qkS5sfDwSfX0bhQmwdHLPHVVZN7QB+5+LxT3GTo26+9274ofK8kexCtuU8H8a/EbiSG1UPvTtFvcLeDQ+XY4dIPkzNht+j9I9LqBexr3coNNQxqxJjy95l/PmI/N9k+qrc8+GGWS8c8OroZ+0Cb/QumwdnL1GbvhWU7ICfV7aYItWMWbditX/sVMZa67sjpEYh34jNQ4b3eFJyDth16+gh8+EFaC3MX/oK9Svui3j3Aj5gn1z34OOx2S6YNHXpjAPSSxr/1u7VVipX0cfNUwXjSb050uwp9ePsDQ5MNcC42cD09oh1yvgvKcW3JlthXml6P+w65WeuSxIH5iMfgVTrpy1LIOwe88JqRl4rvWJ26Yl1vBbYo3/XNot3yTM8mofb+fEWWXf009gfqqTVs36H98IuZVNzvUS7ips1zHniuAuf7rla2d5LhTKZms/fak+APV3w52KkU+pMHOjcNnIb92Y8uX0MrYXecIZn2JP0+7GqbgqPyoN8zN1u7rhHyAcOsC6a3B0AfV+/NqVfY9z0adaekAn6EOzyPZTiB/7RI+cDyfQYSzErDaps+7ChO9Ky0XXFZjHkeSOtrbgH5yAn50u7gQ9dci7neGfsPownvu8UgrsnR/NN+wdCPjAgcsGk//HV8PrPAckqKPMvN/7VlLM6Rv360BmxWglxn951V68/Ls65escOkn8qxRbGdrs7COT1CbG3eQ+hNle9wOm6MYGe5Kuu630N9b/A73j8FemjLth44F4j9/cVZH7XHYH6IG2d/+hHO+01/lIMKYKcxoCmkLAPrxEs7bflGN3nm/MCkycdfmmkmd9y6/lqRZa7pqTD4swLbOs5v02r4R72s+L3JCn5M5ucrp/SFHlV/nWHnjLGPUL/RV7EY/qLLKiV3hYDPYmjgEHAV+5vZGTU5XlgPLE8uuh8J++v5sytnzDOEvrldxY3VkKd9tf6e+gz8loTrNxUfv8Z3daxUy9ORYn2+7tcLiVViqavBIITcz6/G+9EgyKvO7D3cZgZ9B6WN1Y4OMpLs1+/hlzeVYx4euWPkqtnQxyyuWr+gHr9/3T3SDgO2eWjDxz3Yb26asWv0Ruwzj29fcCcbeod/ri5wj90HPnbuRgVP6G/cTRbT3LMa+xCx3q0bsT/qHf38+A3YqdwV26iD4c+sxcPCn2J/9+F1bOJnyG0yZsvtGnwX9hnxkTn7sS7WuC3p0IScdcMA9X5BsLuzWbrG/0MM5KCFB71aIf9o7DH+YS/wEa0klseuvgg/Ce/2nGwGn2ro2c8xv2GfMzN++ITdwUps9NOzp860Yv1xUXWZh/lOo2jxxq+QbxcbmRv1hd7nXPmLzX0g71R1no8AzLCn9jNeORb8it8vbxprQf6yMH5Rw17olw1Rz143Cs7autaXv+wE/yDG0zLsNRG/JbLVJ6p0COwEF+5MkXyP/cbBVvMUxBVZ0stw11xbRfi17dKigbg4CjFpwT2grxDr4vLcYSD4YRP3Xh4Fvamjt8QnaZ9D3MaT11NuQd8/4kmkw604+FHotTi1BOfmy34/R8vAn2/CiuDyk1hXcsRKY6+FwZ9o69DwoitKTKklL3QH/ABcvFisWo/4Wjo1Rqah8D9/evXKCdkjGdOUndWpo0qGDWlZ360Sciq5h5qKpQ3gz7579qk34luIlxc3y8P+aqXdg+Ph8Ns6K1d9mwP4Cafjsg4UQT+veJLUwdpZ8Auj0PpnIfR62oMq6gsgp1v63KLrKwvYo7jouy41hV5Of/eQiBmQm+RK//kK+dqfyZriqUmQi3Z+8jMb/hbG7JCckAt7uo0nB02Yg33GMI3PaxLhT2O29Y2/FtAbjZiWecYQ6+O74+97WyPO0H2ljxuvhSOuydpnD8JmQi/TWW7q74/ov3uuHPz8SYmFZc/TyE1D3AhXhVBHzC+J+o2Fxpg/NLu6V+ftF2N1i/f3sauDPOXcKqlFizAPBCruM8A+9oa7xlFt8LVcl+w3a0B8nC+xyWG54K/n7TsaWwv/296Xhp2tGIE4aTnRTlPRX5OVVLprwb9mSUek6SvoU6+V2/I48gLmkRK23QT+XQdMb381AvwiOVPHDZGQF9Re/TG0A/zohvDOp+ugJ7FZrNkqEfoia9bIvTb5jXPH+o3XR2N+TF0is+Ej4hjIaYvXBIGPo6EZkTsH8+ksROFabSvLMqw7il/0Bx9U37y2En4o9k2KOBCKdX39rZdXu2xUYHEZ/cdHQ54co6DWdhV+Wj+sfPXyFuaZqR6tdg2wR/HT6Zw/+aEEWzy1u084xv/sSWYy+6GvaxyxOM0ZfodcPKqtj0E+uDMz0HteE/Qphy8f8Qv+U150eXK5C+rx9RvLKA/wb+PrDm/5gfo/kaYw2N5Hij1PWbJ3DuRUBXtGyW73lGGh2W91C2CX4gFFFFfwW8Z1S9qfDn1FsVda8pMRN7KuY0/vWNjtHp5dNi0L8qoxFbsy38Kvwvm8lXWTEWdHPcpEZ4WuLJsTernmLvT2e1RX/miD/ch+caeoILTH3KFP/X9BPn+7atseu3UYD5c2yHshPoGTSf/CBvCzNv82d62LQhyvJevF3LBuV9XJnMsH/3S8kePeu4hT87zUegCO/WxpdF8jO/ivVrrd3u8I9P0zg77af+kDu6h7PXvIQ++5f6xWjAv63c3zpas0vRWwzxspeQzxMt51vRo/FvP7OpWeX/vBLvF2leT9NtgTbjl2cpkc7P9mexuPqcU5osfgbctPIcjj4wTzuYkaiIv3KE/TM1ya3dFen2QE/nXAq+QHiZsQn2fKK635iHvlP3aQ7mjYfyw4bPh0q6c826+UuuUe/EJ4qHndPwY7WYXMoKLzQxGH6dnK5LZ0xLU8IjnkGdZTGzH18+uhb5Ho3K0w+zb4LIPfSX6AfVnHSRfNxgTYSzpNXrEG7Rv6sOJsG/TeinX1E8/Bv3jSlKr4DxVy7M3z1u6dwI/s7z1a2RXywX7GSRF9I7D+vlO2v452yC8wG64I734em9xrTsCe6+22LjvcusFvbUa/bTpYB7Z0G6bx+hDkQ0r1LwLh57vNeMao77k4h9nvXlsNO+WPYfslt8Fez/H0Tacn2Lj3HeCtqQb5Yp+tzwZuhD7T9ejCnr2hV2A/78RUrROyrNz4lkMG4hQdqlL86AS/EvLz0iWioU+/qST8xUPITaaFXPFbDHvJzfPtJxrAX+5quWsGUfAH0dlu4NbuOM8XNx/8YYr4iLu+/ZI9Df0tpe8ZRprYT3YuUltluEOBLfMfZfUOegthb8pfJGE+qJ/a52Yj4gB+ujdqqAn8f3RcrNpe2gl+nFzeX9oL/vprt3mdeyGu4ACHnF4VkP/OtVT5rQJ9w+P9nQ3yO0HPZOivsetg7+7t+3DTD5yDJP22O/qAkXuqU86SXB3U2/V5KXf2y7NH1eU5wc7Y19l5nez7SpHlSY3SSi2GH3HV49N2wl9NnM+RYZMQN+p2R5H5UuirbNYLH5YGf8gJtSdOzkbcmrbtD4KaEG/Bsyrfpi/278/7qI22h352VoVp8yHM5wvUF0negb/qCCutoVXimJeaa99cg/+pdLv5F6Jgv/17d9eT1R/k2PgNaYrD4b/HadKHr/mfoE866HR2XC78DwzPKhyB83Ze6NWejYi7Ybvi5ZrFOL8VN3uNX6ksxtaHPbN6DL/EIbpFJpHwN+Prmrh/EPxM+fc+eHvVWOw/bbvmmy8Hn7xuR8iL2UqsvEeBWSn8bh2Ynbzabpwie3ojMTmhSZFpa7em3MpVYqd2WI7Mwfw2qHtI7MNw8OVWBXf9CX2d8ITGF2HH4T/++eifvvAPtb/a52c2/AO9Wjf6gwXs5CT7+veOwH6/TH+88S7Iz5OeBh20xX4j4NfyI1O2yzHt0oEF+nOUGNQehpsdhn1mf43HZojHNymzPikQ/n6GxU+xOv8NdjCdO9kHgL9xvt83f8NZ0P8p8VxCfvBafVPDlWAXfrnF9oMB9CPLZ+u+n9gD+qVtcxMiwe803jPuugv43crjVx+bb4h5NmDY62xV7FdMMkaIgZ+dfPFBpi78UgX3fDTnG/Qy5ZfOOzksSompVz688ARxfzT7ve73A3Zdr7dZOz+eBz3zH65Hb0MfJX7FGf/lkL909t7/XAv+V36KfT0XDP3GmY4bylVgx7308mGl2k9SrFVq6d333xHv7eh8Q+Mpsszo87Jt244psA+jhkfPg38m7/v9Z5hCfjWj28yPww7hvDbCf3E2/B3N+uifZQh7vgnTbXuux7w4+ElpN3O0r1FDxIWD0PuOmNEvpQfm66uW5dOOg8/wzenSnimIh9RlplvsefTDmKZuVmdOQr7i02vCPQ1lVu8TlG4eKsVattxMjh6twB55jPC4JIdz6ctrY58vhL8vnfbvO8CfupZQ0O0n9OK3PthYfQN6zLIPfXKT4Rcvb9pubWes09eW78vbCv5YP6+vOe8Rx21ccJ/+l+E3xm39BM0F0E+Ik98kEw/7uLsBHoUmm+RY8c9KNynwMf3/9p3Tai3Pgjp3szxE/a3szKEsrGtRMyVOWMM+4Vh2YJT0QOgjWgYWzoEeWfH0ePF48IuUTxd6/cY5Ytj05Ud1EW+nUJfJFMLOyEztwaE1iK+h1qQx6DTk+VvkLzscgPxibXXh1b0/EbfsrO6RBvVOTEND40dkrAL76bS29RD4t2O9QkYYw4+/Ul/X1WaonwEPHEL7Y/zrbLBTzYZ8ZtD614//Qk/TJHGcSh74+VKxSyQG+kD+ujTiSDXi78gOvTCBzr3umd/nisE/xuTaP+O/i8M+qte8q7XPFNnCCpyfoRfip/3hoawZ4iCnHOtUin79/vRKtxvoxwVTF+9Ign3Imt7lP77AvlqvUfb0TfA9VDcGH6zG+fdWgnV5FM57yUtsVHxhf+LwWaH8B/zEW4vZpcMsgt3dutVA3x52SmeO536EvcKen1sT52Gdu6pU7NoWI8+eHpF1VrgGvmbD3xeS8O+xIse24BP81yk5rHCYgLiw6veV5hdBf+j6IQ+LizgHD+gbFzYT8uvJajZPlvUDH8AzWEYJDqAtFK1MRkK/XS6hf3gWzm/NnZfZPUCcZOkaRb0yyFEbXC2qahDnpyJnatREI7zY7Ts6KeCbTZy4wew0/PmXpRjZDoC9e3zg3jvj1uJclmGosxd+RzY/betniH3k8c+hnySBzX89TajFvkCpxHX6HNTPYruNqdNxzms9bLjZFnL+cSt1Vs2GfdrseUr+2eCn7uvq5n7huCLzUHlU/xJ6ba+rd1gnQF/olLPa/iOZUmzZxxcy5xB/wqVr28DTcLSqlS4t/RvyvmcxhnFf1BHP56PLm3r4a/gUdr/6B/xAPfd/YDISdmyT1A6si4d8fXvx6SFBivB3EMsO+UGvMmfkzCvkD3VFovwGB+gRFU+6sFgeds1Ff6TTo+vlWGmOc4Us/MvMHTQ05Aj0qxWdCiY6Qf/n17TM3Ezo64dJeOYb4nzfNSZ/0w3wfQzfqVZNh7xzWL8bF63AdxC3eaCZBfvkcRdPT0sBPy2vapTCVgP4jxx9ef4F+A96d7/vnQfwW5+waanOFcStMr7QKzvymQLzdF/+dx7s3M4cKFlhiHOgquab/ALYDfudb/i8HnLWA6/01I+Dv+3jsH1RFeSqGwdET+rkBLuucJMDkw+B7/KivWAm1m2riNddZkCPZ2W5vcnaK5CLZA5sa4R97Dsl1/jr0M//Nf08W7UVep4SxYGbwxXYkYOFl88tk2Xf7b4VtmCdPdGx7pkK9BC2Pb7yfCf8eg71VFPugJxh/6USzZfYX4U3pk4/jDhKPXz3B07Bue3WssEzjcH/r0ievyIR52MVpb5+UzCOrbq0d58GffmCzIY7fnmQF3vZpsVfUGBzxq/oUj8c9h/JM2c/7SzHXmxNuC+P/eXklG/Jg+Ava9uBRfuT8B0tlepdUhGPufpKP61a7Avthq/IGXMM+5CGpG1vMG/mfjN/OxX+EnebF1opL8F+d+J6yVOYnx+N7tpjFM65prtb+zyOkWNne165UwA7TefRiYrfocerKebUfBbxsK5LxMksBh/1246B317C7/yEzbL+gc6Yl0te5Bej/7SdkH8A90RMauW9jj/3wH/+9M0qBHbgiwZ0G5YJfSE5udxdUrCj6g2dAS3oH7yZXn5YHX4mxj97cCoccerkpXILc8C3vHlu2L05c5SZy83QltTtiM9j8XvZQfiHSump/kcNcr6N/l5DNtdjXQ82PayO8+ZRj5e7dOHvIXeN5ZNPkNcbK+rNKIDd7rCDOaa/oaepYNCn+R3s4p3zZjs44zyxd9CBq7rgP2Q81E+RQ3zXN1eWZWi+U2CaKRNOJ2Of5b5m/hMpxBvMvFCwLueVLLvu+/SNbzl8H19Z2U8H+hhjhp5Rdobe9th3zg9mrcc+hcUNWIF1ffueIT7vwfdfmJ002w3rE5O1996K8/eLhlEvamDfvifFMHQB+GWj6h6fssA6qzCiLnEg5Dj5v36n3ELcjZ12AX1OfZZnAUHbdOICoU+ScbYkHn7Fdj99rTcJ/k6ygw+bvRqB+LrnEmXGg19b3fnK5FGQ960OrjDYuQp+P9suSu6H35Qua6L/yMBfxbHyMYWPsN9rV470Xg27p5D7uxvj3aE3GPMr6XUt4hEaNBrpQo9DvaN1cH8F2MnYWkzPCZVnt4r6VC5FHHj1aS8fn8Q4tkh3MRkHfbVKyz2rukJusKvnXnlV8Im3OnV1WQE9qVkvx8RVwy53SlJOWbYP/Fs4zJ54LgX9X31JWgziBDj71359Crnz72HVWQaB8G9yqMvhqG7QN9+tOtoZfpo0jz+an+StyJrrvn++jXPoQNYn79Ff8lsi3+ILfw4v3Xb9zkH8pbT4tHk+4JcufTg/4hHkvxUf2dI6+GPavTkqZwDifVidNFRdAb30LnGdTwdBb9ZVak7la/DJPVZNTHsCeUXO9j0TX8L/07Wxtjf6Q+/2TMLmqwegT9J9tfSkZdvB1x19ZEroKcRjdtF8OR/j98PTYbV6mDeMVqkWBSHOzuPv73peQFyEdW0jLY/DPmKyT9sMf/inHGypVzce8bwfj+resXMJ+rXLhEODMT66L1/g5joKcqS3T8oc+yqwl8GfZnWFXqy1adnkHzg3Pg7w8VwJ/s290lGTvsIf15XqEOOZ3vBTrLf38034W3JZvX95xx7YhehPmzkdfjgihloVzIQeQKfABUE9wS8ssu1WU4V5YJP+26DDkD/f0lAsOl6K+HEVu7uth98Nd39rjVUu8M9Y0/71UaUya3hiv18BehJnPBcZdQMftam38dVVWGe2RgQPi9+O+fjsV/sz0F94XnEqqTv0Fb2eXb1tBb0e/y2PDPqCj3Mj1cvPDv4p/qqMaPBHHBuP0e+CfgBfn3zm5CPo65QfVFz7tJcs0+v0pPhSOvgdU/zPzd6twHquHJoyBnybzsanXO8jzs/HcPXMU4hDVDtu4q9wyPvmN1r4+2pAnj3F2e4Y4gQavDrzSRr+1DrJLNEZBT9rnrdiptYegV7UVqcL1uALWP+pcNLEvvvB5aPrusAe862xTVznz/DXM6vwax70h2Xte+j2wLz3Tsz10iYrRbaqwXyEPPT+jWJPm2vAH83ZO7YLX8jD72Lsy09XYO+yqofGiRzY3Sr4/LDeB/5Z9ZXfA8k/5u26Ga8yodc84v1pscewN56v7CPxC/qWvVM8O1n7yTId+d1LS9cqss8Kl9Lrp+Pcu7/J8zD8wxgumDWqDnGghktOH5MLueUt/UmeZg8Qd89h94gr2th/xfwyDYO8a8hJz4JkzAOfJydkXUf8z1irQcOWwt/1uKf3knbOhhyzzi03DPGYzNvTtefDL9vgLd/HDayQYpdSgvu+mIj4eNe3f1+LfjTE1CigvCf0R8YaJQyGv9yNBx+oxwyWZDNCzALMIGetTNEuVNeFfWvUzsx5qbC3LbR42QQ5xtcnlwc8Rxyvzz1lz4yGf4Lb9UF7RoJ/8Gq5xoyN8DtZe7PQrh/2iyZpssOlxyqw1PuLG1oRH2z9Uuev37cos7DHsTseVysyg/QVC7XgT3eH9qapMr8xbjboHSs/if1N/YtSb/hh/vmip9RsnLvm+N6R7Ax7vllDOi/M74o4pentEvMQL1BWO7r3J8RzuZg33qAv/NWuPdl2ZDL83gzqYWEiB72NLhJF27eXybGA/d9veNbDP/AnhR5b+igjrr7Tpws/sE7fKDOpgt/B+99qp36BHtSp+wNHXcP4f9rpUZ9x18XY6nh7K1P43Yy+nP7HGH6Q7SfMX4SJk636rO0zH/Lh7f4mJb9x3jDe99HtJfQs3XTaWGsj9MhmGe6ZN1WJJZUYzyx+DvnFh5wH3R4psMV6jzb8Bh80+2207NRAxOfKPfl+f50Y8x3zutYcdsuBZ+UX9YIfh0E91ucMgj5ZYuS8Jg3Iyz5cvbF6eAvkhyPmZ9jDH+GNP7+KDhnA7m9fjlg57LUOv92y6EYb7ODS1Q4WLYNcJPiP1njEQe7uoC/bgogdAfHLl8U0ybMLlk0e0eDL5MzvZlsBfZUmuUbJj6B3vWc6JfBXPiHz653JsKe55xH78xvs3GsW3X8TCf/Rr+UKxq+FXqb3uyrd3BmI36I4tnhJIs7Dz217h8Kf9bGHigPnQq//6ZUxc5Kw73zSbYF7I/TLjq/ZIW4E/e/I/uZVKvDjt8iDnb8I+/Ke8Y2D+kDP7sEq1rjJS4ylm1j0T4HeTOmrv4uHw1+fmLus+wjEJxwVI9a2GPzC/gl9hsnCP9KGLoZn9kK/QrnK2Ho47AUL811nRiNucv/f3ucT4EeG+Z4YP/yoHIu7eOeSJPymemde0t8DecbHrc0nLFB/hTa1I3aAX/WgSGnBrgApxG+783wy7J71Mtqkk83hd8odUXmhp9olxK2XJvRN6oYfdDgB+fqfh70eTEQc+FZlL5MlkzqxdFX9xbnwmzNz05M/03Eel3jVNWTVD8gP/z6+rAW71yn5UeYW8O/d9uP731fQV3z1fbH9K5yDK7+uGNUNerjDr0pt2gd5jbRmYGwJ9i31kerT7iDO5pu1xmX3cF6dZbFi6kbIryziO/QXwR48b8CRnakH4Ld8gP68R29l2YWk9Dq9XDmWEKPpvTkI59KVMxqjwpXY06qV3/Vg37jv5qgPQ6A/Vmg9qvQuzl+nj9i37wMf1/N42wVt2BemLKt/08MGfkq1VrbkW0K+8en4wQ2LwD+pVX27Bn5JXWf3eX4RfLRnqaX3+8O/dO41N7+kxfJMzmX9AJku8JcQNueB+klF5lSZ8HkC/I3qPZnqFygGf0dDi2vr4beqMXREj3ToXV/V76k00wV6xaP9sj9jvi/YN0f+IezO2kavH320CO28or0xC+M7ZOIBm0sbYaezrkvwEhtxNrzeq2BCGOJqnYus8rGRZ6myPtpbwYddatcg4fUc8oH+CqdqXsoyyb82AWfgz8Yk9OWEUvgh/bu207RK2L0Fj43clwv+e/eGN3kPEF9Od75eRiX8sBduM85oewRxa371rB3Q5x7j4/BsviTie28+r1eCeHYeg65dHA09HNPLh7QmwJ/+FsMdgwPzZNnrx36LhsLv2ppFMpVdwX8z1utuOx/84BsTfmZWQy5QuWdA/kjoXaywX2s2Dn4sNx6ODj+BfcOzkfoaozH/ZojNYbvmSzOb3u/HW8Ee5sRZ5iQGPxZSvbrqZiO+f7eswzpxqF8Pkym/bFqlWWOjltsb8AvVFZsTWn7DP3HAvrQdnxGHId+6rB37suVptq8DN0mxc67KCxbA39aPOglTf/h7trg1c6Q92jlswxSzEsgTNun+HegA/y/f0g6/HtmC+BXmRYvj4afmZPZdA2n4J6px//0jexD8Tkb+lX55RYGd7pypc1oe8Wo3PssZieet96vJGwe71nUDqv8azpBkzk5qG8Wwb0v5qtrpEvgGuqZH96XDvuTTll1/7BC31Xe+32cr7FuXpaXeWw4/X+smxE1UgJ27/M5QIxns91dWHc86Br6PrfuJsBToo+g/E7f9jn1CaLGf7tbOSsxQbuW1dRqKDEae3fwz5VjewJEbTMF/8trmpt4D8SOUw2YoNNZDj6ubvvS1eITXPLG3+yr4cV1wdJLiLwcxpvL5Y9Un8F/F1QM/qMK+wyh/xUI1tJNlSP3YPtCLK3Fp2JhQA77MUhm5PfCrcnBmYMnTR9DPTHV934bvzC35NH8K/MgdlO+31BPjtE986MtekG8ZL/OoaDktzkLiKiYd387YvWWuAbdwrjeN8szfCT7MhQNVUQYTpVj32e8Kx8Jvf+3Y7X3vgL/YcjDhVBXkPId2KX7q/EeO1S7W+ZQGe/383P315Fc0SdW8SAX6c2svDqpJxP7yTIlMRndHCfakQyM2BHHC+uy3GRID/Yh0/5KwF/AHXrF913TLy4wVNvacdxN6WseWx1bB4xUTmxN+2AHrsd/9HWVfcJ73XzDN4z7iGAaev++dBD+46QusnbXroKd7zX3sTvjd2rXnza4ZS+TZ6F+TRkR3lmXF66O8Z9XCD3PG/UE918M+M/9V3Hbwu83MpjSdJ78QNWtzbzySYNvU8t7FwM9F2xD1zC7QY4nyis4NwX6oyq308k/wRbVeau6XxTmnKay1f/IqBSaeFGW7An7rEoefzrOA/uYU/ysq9woxrg2nN6YjTrCa81mVztDH32i+6poz/EVola3qd6YX5t+soyG/4W9XNvx6gQf88f5wGXlUG+v1+9ZzzQtWIv6Lzo0H+ZAHXqgsz9iFdos9PEClDv2i02rpNcrolzYN06K+Ii5fj4qP+3ebob7HR+y1VkF/UDeuCJFSYL8O1gd9hT7z0NFliRbgc6avH3i1Hfsq+S+105dhn7Qv2rvbPMjLHqzxqv+D8TZNOq9iKvxRb+2kZm+CeP2PrfPrKD6sccecnzNAO6+beHEG9nv2WRVmg8GHmvB3ZZ+RsE8o/9WnPXaSMns9pGuHEuLLPm531DSH38+AYZfaPoP/d19171pL6Pfpz8vUbdwBfqlpQW9n2MefLFNrDIGco1P2xB+ToZe1cEHOHQn4DziyPfxcaAjsumyfivX+CT2uQzUPWTL0CHVuiGlnIt7Jnet7ghd3YttOtAXntEBu9T7sYRn01vWPLN12CPHtDvQ4rdthLsGW9/DxmwX9DJ1M31+lR2FvllgwfpE7/EPFdF0jizhuj09WyVzBeuZgGVHcP0yKLVr7Nssc6/raDLH0gfCbNnHAqfAiyN2Hvwx79AH+SKRSXvws2oi4jWNOmm3rJc+2/UxLdcQ+XqxXuNks8CXbb+ya2oY4jy/DCvrMg7+0dsNP44bAHr7no03zL0Jv4tjBiB3tiAehlrsxcg/sQQuPt1szrGOlIy+7hSPesu7mD7YvELewsFwsqT1JltXLrwkSBz+g+tNyyeJhCuy+/qrRk3cosa85S6+dwziMMG6d+w52CV+/XY/uDP3g92saNrpAD7XgpWrJ40TElWluzH4P+8WFC/Yceg/+0M4LMc+uwt+v53uVAsel4BeeqFZSPIt5atYKkyrMGy11b8ttwMdxNfKapwJ/lufLP9be8YU8x71rn0PwWzpiCLt7F/odrdNfG6wHnyC4zuJVOvQPZ3p/e6YEOeNc74I+jfA/Ft784qoc/DuXNpsv7Qf9J5ubw7Ni4D9n9YrpjxMwD93q937dIfj9fPG7YMRF+EO6siBZPbodehSfbQ/HH1Fgr++ZahqA73imx8s73e/BT9oJ9ZjXunJMvtbDa1KiBMv12G45HP7Auo/bO/Igvuetpl5yT/jpnWgUETcT8Ujviyn1KUE8X4PKr7HmiEufM23MHiP45Xt3YFy9LvxSZIZFdnTDuhFWcjDHugP85rclIc8Gwp/T9l9xAbJYd+9P8nY9BH89bjbt7vB/OCRp6qCaodDj9dL/Ywm/cebzNdT3QT9P64NP5Rno203bXT/wL4ImDT4iZd+BuI7a17a+8URcxh6llQmXrBEH4HhEmhz8CExzLCo5hud/zgu/ZgO/RDJldb8zEd/fya+b6qJ7iiwo1dU2dIki81d5ULcQeiuruqodnQS/eq5ftpy8j7jZU5yvmCdhX13jdHr8ROhvatS/nhQK/72WU2QUGzCezveOm7wnBXoy3RXCtaE3tN3sTKQG/MvaJ56VPAD7A6eg8T3uIsKd3WalkJ7ov6fC0nZE+CgwjdpqHy/4j3u/L9jUpg1+ZsqGB0wFP8jdWXHHPchDlte9q/mF/ra8Xtq6B+wGyiz8340ZCz5rm+9g1U2IGxwlrRS7DHLBKYka37HvjU8KKfkC+ah17+A5IYh3FOf4QG37dMQ1txsqoQu79ZrpB28Ngrw8z7TssqOvPHPoHdzy/Qzk3p06ywQhXsXloedUg1wglxjh2fP8PcitBl5dchP6XvN31j8+hn3MjKboDftg33DKRTt9PeaLnddvW/1FfM9Bh5+pnFEWZ0sX/L6gAXn1th8l4kUPsF7PWvgpB3qjqyc1rb+G+BvPtwcOHAn9aNODm0NfxSizCT8i72+MgH2FnnKXAfCv3f1n88b34NOWtrfOdYS8ZPi1S7krINcv8TlyeRDkl8bLupTvx7koY4OHxT74c1XUFp8YDPs/lcUpaYdhL1vcf952VchlJr7KemcE/d+FB4YfWl4J/lH4zchuMZDT/dLoPwd2wHE+4RPLUY933l2v/on1c7pih9587BfPLWsKkINAu+1qkFc/8NW+Shno5kAP74jd0/4rMS912GhfsMB6rPtwSW9JyAe32L85UzwcelKlQTruiANjKr1j6yRNObZm7yqjpaPhZ9rRq6oR/FQ20MngG/zEfI3elr8Pca69LW+q3YR+hcXwH3sjIAfs7CJvsxB2kI8/NMVsx7rRK8opaSr0Ud+/XeM8CHyeC/1C0m2hzyA29WryUZyP1n2ScQ2HHLM4zurFoJ7QJ2wMWvUO8WDMrM+W1+G8eMbp7s+gm+B/y3ZojX4gx9Ze2pW0Av79LwXu3GwCf2WTaweMNILfIOO+zlfjsb5b7nIZkwm50YL6K3H3oE9i+qNTvB4CgH2d7LvuLexMTFY9W6gGPeuwa/NzXOE36JXbvqk5sEc9dvXw28OdFFnccZfj3xFHd3PxzfVJ8Js8+cPE7Q6XoB8/XGGlBc5XcxcsVXnPxJn1JqlNUogHatPJqq8r/L81yZ3+Mor4zvGra2bCn1jVtdArn2qlmMStX6dnwk9B/+QVc+Zgfb9sNqptTCn2CSlld5uxv/247EJyL8yvi502PdgLe4BJPQ65d4Wfschmt+/msNO01C9csQzyyc4z+1eeRByJrkFm6y/Bz1HKp4V7t2G/I2GkEuMHPeuiDc9edwEfc1mmsbzxaMgH2s6E3gV/tNA5XoL8NG5t+na9M/GdGofNa4UffHtdh7FH1sgzaamAUXGwa62QkFaMQFzwy2t7HW9aiLipyjVfA7AvHHgkMngA4ng8vicRtAb+fqQCg71Vwbd3jYu+XwZ7Qdkb7uMzXWEXtPvVd89uOK/rBd/tCf7CstK/x5IQxE3NqOvLNk/ox6Y9G18FP8kDKnISkuEn2SaqV6/58Et2r12nzA/z4aMhexSmdlJmv3eqOUrMhz21v9elyKEMetwR7b0Q1+zKR2tne9g3zVJ1rTlqjPFxq177tjX8Api2jakDfzlx6ET/MESCG6cYNlwH8VOeWde/33gL85nDxr+m2A/+3DFGbk9PnL9mPVyxGnb7D9WGDbgI/096j97+OAx+xOs7JvGPt8BP56POz/MRT+1NvyMLu0F/PPX1qbllOP9U53WcMoJc8u2Kn0p2iKPW/VDzWVXoMXl3eetyF0H9MkwadulgHx9uE/eoGHye6KwXwb/gr33M9qpKQ+g5Xx7S5DEa+qr7X1glT4PfWd3OCZ+mwe/41q93d86GX635j8/YR0Cv4PvwHfYb4cfmZNXAOZbg35stOGSMbRV7tHvpn7Gw96g5JjZNG35GLsc8eLsO/nFfSJRHLode1IK4UfFzsc8Y7bvAbSriIW/u2st/CeQKPdVKxxQ8UmSvR23zGAE59JPEn5kR0QpszH2Hq58Qh//kkOcJhzDPnVGx9lgK/2+e05nJV6zn3he3DTmDuDdzdA42dIX90Ok05y09MZ90D9vmUIY4Vp6XdAdnrBNnMSvWnRyNc5KDitY7NazLxfFDVvofkGUnj3b70DxRlqnXzf1iM1aeqajedRg9RonpTByu9Q52Cn5q14admAV+gGvv5QfAb3/Y6FFeBL1i7yT7Hc7wp7Z4vnJ0EuxiEkJ3LKI4UzsnTNL1hT+8oXe21D8BvzZo//plFpCjVsicjFt9XpFtHPrNSBn6Gjunle7fA//ef3u2BOhh3Hwb9rS803N55vR75lhHyCNLR3+z6HkQz+mn/8AG+q8DQv0LdGgeebsvMRv72jkePTrvgh6d1ME372zy4Ucvob7JEnrZNYk2+a+xPjQ7pL3qCX+6bpNK2g9my0Lfz726HXokd15lNhpelmc9Fg4OyoGcovJtlMpH7M8/hxySnY141Jrf9k0eA33J9a59bAJhV2/1pCEzG3bfQweO6nwNzw3x2xj3BOfllpsX8tJQ/vwdH2O3Qo658dqrD9fB1wpqCb83BfqSARLuqw/CT/fomKnzfP7IsLczhs6bNRf81fzx2z8FQc+scIZYKuS8nh5G+6dh32gSsr4qCnKjVq+7i/y3Qh+qb/DC2R/EmXxuboNcIb7v87qgDbBfcKo65XMe9jCXhh+rjIAcTCaGmQ6BXK5s9d/39rAPb2/JkK+E/fabet/+SRlyLPDN5YbLVUrMqGv0tISfisx1v/uNrvAbf2FEroU89k+Ruw9uOQU9l411o34OJH2OUs1hD6EfEv9h+49W6H3NvNa93hN61F80ZeY7QK9TesHhSRtxnjhx4oi0LezqX8tPMNSMFmM3bhyuvOcGvqTqnprekKt087d8PFBSjlXFn3tqCb/UGwYeGHsDfghuS/3MtPGUZPHDS5OeQ46xc/f9snDsT232WpzbhPgIt7V6pZrDX96VtFEH5yI+znnXlCEqkFNObetZqYQ4/dpHLg5fh33PzyC9ZYPhvyut8eBr2/lKrMTumOfAtbJs2obOKXbwX5ldnynZD/vCC5EPMxS8IG9/vP3rnmPQb4+X7JGDfeYQyzn3ZsDuukqux+ZheL/y+Vkm3efAP59/wz016FHp7FEZdQHnuGsLV+Tr60FvbtrBVarQP042yH5vgfn0VssmOzsHRWYyyaXMFn7OTur0fGLarsAcHrofbw6UY88bVvvGgA99+Zb3uLWwy/eNtbw1Ff5uVvwcse8x4sT3Hx5m8g36K0MjvqgPgb+xwceLltWDLyC26WO3K/CjckBx/layB3rVtPmYJvigmW92pX9Fu1sMKQ0u76bAZmc3v547Sp61Rgwfe/CeLNvqeGiD4hg5FvVnWe8J0GczGNBnz3PIXaTzvda2gM8Y1c2jXAb6jGl/nG/cwXnp1JrOT3zwXRvSfn+q+gG/xmNznr+DHql8a8goS+gDbo1pnuMG+9nXXbObEhBHRrFv2aQ3s+RYieqARD/4ffZal6H0ww1++uY/62OAdbEo3KtiJPRHN2mtFlOAnGvDqR9X1zTD/3GFxqiLGxDnacRTw8NHUA8lcCm4BXaOP7rf+qQpyWYGNunsQ5yO9oPmS+rA90+US1vsPRPxA2c/DLyK/e4r7bS6B28kmWlyeV0fyPf3nfvs/Q36ARc61u8OxHl776yG20Ohz9dpXMVJa/Bjv5c+2dYVepNG0emZJG/bcCZ4irYu/OPpGcQMh53a2FXjHwdDXnh44kefdvC1z1536/4O8cVmOtiu3AF/I5vWxIv9xHpkvOHgXmX4T9G6d23JeOiR+A18++gp5EKrdU9UjzkJvyrlqT0WIGLrX+NDfa/BPn2Jhse3o0WQj+u3vO4hjv1je2JECvwGFKe2dhuNeJJfdt68fqMDctBuEZHTIUeQ1tlp1GiFeBlF9/tvhV9p+bYU9TjwJQ6J+ZpIIh7K2/dNC3vivPfL42SBL86xpQvrer2Bv3rP7xMfGsK/t8nXop/Tobe3wfBdgQf4InHVMtLe0Ie+ZnJt+zjof+/eez65LgLnZ8MQk/fQH4u6K/5HJRTyaM2M5Dycb33Glx3ZCz2t5LmzO9TgLzBRu9nrK+QRem6/L7VDrlA4SOnYIeifDWxSW9mA80rU4R+DzsIviNc3SU3y9zP1VItZEfb/m4x2Jm+HPqjGEqfbZxEf99e5Sd08EVdNbGzHgXXgdy/LXja8K/QNB1XqzwuAP7LFIVfCLBDHL/3bd8lK6AH8WVf+7S347XvcJZps4Adtd5feH/cEybGLYdN6TQmCn9AFBhsa4W+4csGHNO8AyIcO7U88D3/jsxM934nDTmVr6vqugeBn18ksGZqK4LeHh9aZHYBex0hxOT1p2N3sT3+7Tg1xET4anVrYCXEEQsKHaB5GPD3Nif1ap2BdXXtLPPYE9J+j7AfW12+APWzoo2e5+xEf70ZVYxn4EiezGn7Uwj5i/Bzb3zWwO60dvzypN+JmfBmufbcC9hbVqRPLHCHfV8l70qoM/ULVIP+TX+GfKWNs3t4fkDNU/3AaEQM/N/vnLlfyisQ40xH/8wG0VOePujszZFlJ9sDy+w8V2Y1NM35e7g5+29SvK4fg96g15yVf5SCOkdPRv4ewX2NLTFbPw7i+OaU2/wTsnAaXfJr8E3aSxbp/1uzF+mT7p2bwvXzEhb04/cOtYZBHp7eHH4TetL/i/Vhx2Elfv6RifR7+3GYNWBhQCz7pvry6bUs+IE5a1rYTWTj33PDQXVYMea6ByadhaZAf572bcCkE8eayVTKilWAvsfd9/7i1OPd3u33maSX0VydXRvrqT4ef0NN1/uuw/ivOuX2hWxDsmMIGK7vAbvBlYZepfeHX/LfnuUkhWQrss5rjlUrIK+pdR/Y9B75HQ3rdxE1WsLdy3PHHEH5Mho3Kn3ERcfEWSyyrWQH9Wpusv4lG2vBXaG7+8Dv8tJVOCWleCbnDuklFkx7AXtnz+X7duiYxZtQl5a019Ob03z3wj7gIe/fePTq3Q/4uCAo8X/D/Gjfn9Vb/BAcWBnOn7KGrKca5hZ2Pq62Dm5nW2NFaggyt+Q4ITG7ngSDRwhDDWo7/XOPq5uLhMpTizNu6u9u5CcJT/xMnHBHX3T2GIfY8IhabGGu5u635h3BQU2FQGRfEY6ZY7xMlVdgyYBcARG//0pjuBLGgOQ32AYPo7l8aarAMIbr/peG+jY2g2N/q/8SWRjhMQexoUZrK74LnLxLGgCadJf471Dr+43qi6XpLZ8RCp8DstpRA+HsthF72cnDxdEd0ytV2ds4IJO/g7oJo6oChFOD9/4Q3/ydc90ZbH0Hk6tV2Wq6IU45I1f8Zivw/Y0FPZ2ZHIu8wBZjzIfAVYJ3UP0HNwR/8Dxp2D4IX5DTiNQuCWnM6SXC92Tsq7EMytO/+uZ2eQelMuX9iVVNMcmoLTlOsaFHa7r9oiGv/g6Z6F6UJRGkeA53TPEY6p3lf4DTVPdGzbH1cPD3+iZ69QFVFUI46bK8pHjanIfr/Dxqu5gV9itOYcgV0AdqcngvXKIKyOR0EgFuqf2ksBdAt+T80TGEY1CD+pSkmN/U5UZpizXOa6refCA1WLMM08B80xSLnNO/DojQ1K/3J3s1uXd8gt2F8YvGuwJT1WXo/DnW4tTpPaB7de9W4r5YJD3c2XNgxX3leHycTvb32Usccb5j9SqoK6OOjvb1rj3u1y+/1+CeOvSWgK+BI93+eAbelgjrgNMV51xSh9wrrhNNUH1QHnKY46PTOojTVAacpZjl9syhNcd45TWOUxvEaWyfMElo28+3cPZ08xo3zdN7sZus6aLANxXW3ddayQdPbaHnZOnnaMaoHqgP6fvp2+m76Zvpe+lY+ZiUxZunbOC33XzRcT//HGCeahlCAwj9x4hHaTzAncFoJ9xNNU6Oth6eb3bhxgg6p5avl7uLptsZunNYcjHot8vUoOoZp7lpj60yDXmSca9mu2eTp4GantdET820veRUGl6iCtqF3vII+C5EHA5tLED9flKb65zTCRgrqnNNQyxPEu///mn8niMy//L75uI/i+XMa5lsMofv+g4bq0r80zFsZTCX+paFOL2h3TmObJ5h+OI3tIoPLJsFcQ3876WPxF/IP9hP8Aw4V5uM6QcpfmC8nvA7be8Ef9VP6Q77gF2jTCjDu/wf/87NfsPA+CSEWF2LhY/zkhQnh/X78ecIL/Ph7yArzNzqs1TLRQtXROEC/oPkOJoCsuwgdI+zzojTNAxKdVBjMYQT1QHXNabDuBO1O8wfCmwow1J4EGGYOAgx1SAGGupEAI+wDg0if6QAjtJPgPsJ0H2G6jzBdT/MQ/U6YfidMvxOm3+cIy6e5ga4jTNcRpusI89/pepq36DrCdB1huo4w/U7zDOXT/E3XEeY0XUeYyiNM1xOm71kj/B5aY+g+wnQfYbqPMF2PEKyC3wnT74Tpd8L0O7UNlU97CLqOMF1HmK4jzH+n6xFSUnAdYbqOMF1HmH6nJZnyCfP6hxql4L0JEw22moAmTDTcBwpowtROdD99H2GiqXyiCRON7aSAJky0opAmDFMwAaa1ljC1Kz2X6oMw0fRcogkTTeUQTZhoeg+iCRNN5RBNeJrwPWitJ0w0lUM0YaKpHKIJE03tRDRhsGYE99Hegfcrql9qD8KCfYaQJkw0lUs0YaLpvYgmTDQ9h+ZNKm+DEFsInwcVdQGGSYugPp2EmGjKJ5r/Tt9HNGHq53Qd9Q/CRNN1RBMmmq4jmjD1d3pf6ieEiab3JZow0VA3E9CEaU9K5dJaQZhoKpdowkRTuUQThutrwXUI1STARNN3Ek2YaLqPaMJE031EE14gzPcQYqIpn2jCNB6p/qkfEyaavoNowkTTdxBNmGgah0QTJpq+i2jCRFP7EE14sfA9NwsxjXvCNE44TeOF9uP0fVuEmGhqX6IJE03vSzSv957CeiVMzyVMzyVM44uuo/FFmPoLYeo//H7CdD+vB8J0P6fpvXhd8DTP53MAT/N8XgZP83w+d/A0n6f5HMHTlE/fy/N5ukDYHnBRKcA0vqh8Gl+Eqd8Tpn7Pv4/qn76PMKd5X+VphKAXXA+TFAGmccTHO30Xlc/HAb039Xv+/tT+fM7maXpPwvSehBHCSoAh6vt3vYJbGcE9hIkm/X6iCdO8Q/k07xAmmvKJJkztSPnUjoSJpnyiCdN3Uj59I2GiKZ9owjS+KJ/GF2GiKZ9owtRelE9tRZhoyieaMI0vuFcQjC/CNJ4I03giTPMc1R/Nc4R5e/K2pO/h6xdhvl7yduFpvp7yfJ6mfCqH8ghzml/H0zSuCNM4I0xtRvXflUwIhGmoYzGYerOzwraB+aEAgy3B4MJPkIZKqQBDNCbAMJUWYJgYCTBUmv4pS6RcupbSdA1hsHcE+TDX/Kd8kXsII6zw/3knYZrnQcT67zWE4QpBgBHa8l9M14HVLfhGwkTD5azgd6hkCGiI1gU0WOWC62CSJZjPiCYM114CDBNkwe+E6T6o0grugwqkgIbKmoCm6+m6ycL74OL6n34jxHBxJciH6YEAw1WJAI8Qoak8ovn78+cThqmjIB8usQSYyiNM5RGGCZIAjxFi+g5qZ3ovwkRTPtGEwSIWYKjMCzBCCwgwWHACDFUNAUaIXgGm+qFy6PsIE035RPPfab4nmjBcWQvyKaYaYYgEBBihLgUYrgMZxOECDHdrbLoQEw3zGwZTOwENlRQBRohJAYZLJgEehAPPBABUtwTYQIi7C7GqECOksQD3EmJtISYfM4T1hBih0wUYKmcM4nYBfgI4BcgGxAkxXDYLsD42/xMAZJJHWFWI1YQYqiECrCfEcJXLFgEIQ71NgBcDtAETADDdEOAIwBMAQvawm4BCISaa8s1x+FwEyAFUAgpE8GMhzhPB9Js5Dg4mgGlCTPRiAMRXrFiI74tgnlcDgAozSwfMEuJ5QrxIiJcLsSngKmATwE2IPQCXAX6ANCGmfMIRwvtihPiUEJ8R4iQhPiAsd4AKfH8ApGDzbAiQEWI5IVYQYiUh7izE44R4ghCbCPFEIZ4kxAI+jHBeJkw8IZo76SxGmGiE9xHQhIlG2H0BTZifq/ienadpH0730z6cMNF0P9GEiab7iSZMNN1LNGGiIa4T0IT5Pp6fdXia5/OzD09TPt1Hefx+iFsFNGG+/vCzAE8jFKDgfdeJ7N+pTFr/CdO6Rvm0rhEmmr6HaMJE0zgnmjDRVDbRfP8PdrqAJkzrNr0PrduE+TmTn9V4mvY1hGlfw2l6HtGEiaZ6JJow7ecpn/bzhDlN38DzKE35dD3l8fuovogmPFv4vI1CTDR9N9GEiaayiCZM+yPKp/0RYaIpn2j+Oz2HaMJE03OIJszXe34G5WmeT/XB8ynNzx387MrTPJ+Xw9MIgSPACBn+L03vSTRh2gcRpn0Qp+m9iSbMaSqP51Ga8ul7KI8w7Y/oftofESaariWaMD/P8Gt4mp9beD5P8/t5Pk/Tvosw7bs4Tb8RTZhoeh+iCRNN9Uw0YdrX9Rfu6wgTTf2QaMJE03VE8+t5m/CzEt/3Uz1wHgFPk7yAroGrTQEmmt6LaMJ0LqL2onMRYaKpPKIJE03lEE2YaPpOogkTTeUQTXiJMB8hggWYaLqPaM5voXzaD/LzFJ2/6DxFmGgqh2jCRFO9EU2Yxi2vT/5etOen8gjvwDmCyqV5le6neZUw0TBH+4fHL8KvEuX1iPKxOC+Ip3k+L4OneT7nEfE0fz7nIfE057/w5/I0z+fP5Wmez5/L0zyfP5en+XM5j4enab6lNM21hImmcgQyEiFN9xNNmPPlRHlaovw6vg7wNM/nZfI0z+dl8zR/H84r42maf+k+mnsJC+QSQpowzSuEaU7hNF1HNGHOBxTloYnyB/k8xdM8n5fB0zyf8954mj+f8+Z4mvMB+HN5mufz5/I0z+fP5Wmez5/L0zyffztP07gnTGOe01QO0YQ5P4LPFzzN8zk/gKd5Pi+Dp3k+59HwNM/n78DTNM6pPIGIUEhTPtH8dyqXaMJEU3lEE6azGp0RCUPd4F+ayuJ5PE359E08n6cpHy7S/82nNJ0tKZ8w5XGayuJ5PM3L5fk8zcvl+ZSmMyXlE6Y8TlNZPI+nebk8n9J0zqV8wpTHabqH5/E0v5/n87Ms5ROmPE7TPTyPp/n9PF/0fvoWnk9pOndTPmHK4zSVxfN4mpfL83mal8vzKU3na8onTHmcprJ4Hk/zcnk+T/NyeT6l6cxP+YQpj9NUFs/jaV4uz+dpXi7PpzSd/ymfMOVxmsrieTzNy+X5nF9B+YQpj9N0D8/jaX4/z+d8B8onTHmcpnt4Hk/z+3m+6P30LTyf0sQboTTHVAZPc/4Kv5Z4HlQGYcrjNN3D83iavwPP52n+Djyf0sS7oXzClMdpKovn8TQvl+fzNC+X5/Nxz+cIPt74GOR9no8J3qd4n+Ptx9uU1yGvY/49/HtF55ypInMOT/PvEf1NlObfJfq7KM2/T/R3TvM5iaf5c0XnNtHfRGnR54rOc6K/iz5H9Ll8zuBp/lzRuUf0N1Fa9Lmi85Do76LPEX0un1N4mj9XdG4S/U2UFn2u6Dwl+rvoc0Sfy/svT/Pnio4D0d9EadHnio4J0d9FnyP6XN6/eZo/V3SciP4mSos+V3TMiP4u+hzR51I/o70jYTpP8PHEf+NYtJ/ycSfaZ6gMwlQGYb6+8vWUrqMxR/xfvv6I9hWORfsHv44/h9ZCvj7ydYevS5ym63L6CMc0sGCMA/M1hN6TML0n5//y+UCUL8yvpzy+TtC9hOlewnyNoXs6hM8kzGk+D9N9hOk+zmvmcwx/JtwBCtqJMJ/7+f38HWieprIIU1mE+VxOZcC0U3Av1THlc147qVvxeYz3PY5F+yefs3l909rE1ys+B/M5mtN0HVzWMnEogUgAKI/4JFxmcwBKGXDVyCKE+JAQPxDiCiEuF2IJKPcQlhViBSHuJ8QDhHiCEE8W4qlCPF2IjUk3hc5HQno2v0+YbyLEa4X5dkLsJsTuQuwlxJuFeIsQ+wrxTiEOEOLdQhwkxHFCfFaIzwlxkhBvFeJtQhwuxBFCfFmI04T4ihBf5fUEhSU5wAso2RBtgfRRwGwhthTieUJsJcQLhXixEC8V4uVCvFKIVwmxrRCvFeJ1QmwvxC4iOBrgJqQJE+0ppAkT7S2kCRPtK6QJE20upI8LcZIQXxDii0KcKsRpQnxViNOF+LoQZwnxDSHOEeJcIb4jxAVCXCTE90UwvVe5kCZMdKWQJkz0UyFNmOhqIU2Y6DNCukmIvwhxsxC3CPEfIZ4Ohbc2MEqLYSdShPRDMPH0wdCrB7MqBrGaCebhYPUQCqNBOKhNR/obmAIOYP4EwpZ7IuIbZ0KR8AcUlPbDJ7Q4hK49wUisAjPuJZhcxlA63IB7m8kOCOV6olxJMDh7gsk2FPdqwo58LhSmPuBAeg/KeWuDMUeAMf3Un7E+KLMYSnNqYNxuQJm/cU8ZnrEbB9n0eSgfDLs7YC4/wjNV8NtbvJMYtJakUe4KQBMUlfThN9gFuuk/ode+FwykHTgcnoTC2t0AvAdsdnfg+Y+hZFUDJpMklCZttjK2HWWsRnnFuD4PdfIdtvlP8ftqKGt2xbOe4V064X2Ho5wx8JNggd/L8S6ky/Uc71UK6AVm00383ozneOJ3Pyho3cd3Uf104HljURdvoYTXBZNnEOrJFQdfNdTNLzwzB993Du+ihGtKwcT1BnOjL8q6jd+t8R5iYFjNQL2SzU8m6vISbPj34LoOlF+/E98HJr4dykvB/Q54l7sAfzC93uLbXPB7Oe67jzb5ineeBGaiO8XuRT3n4zkd+C5d1NGFSNR5NNY81E8Z4BiuLUA/2YznrcbzPHD9AaECbDTaoB/umwHlrmAw1Ypxfxve1wX1MRDXfsa79kO7zUR9q6GceMANPLcIfSQPbUzfcRflfcU3++LdU/AME7yrJ+rlDb6hHQxHqqtM9JNeqK/LyHfAc6LR/8zxjFER6JOo4+loa3X4wQpF/aXgHa7gGzOQ/wr37EY5z8Ao/oxyJqIdj+JbqS3K8M6T0G9+4x234h33ob/vwXcOw33BeE9f9L1WgBnaPAZjQw7PXYq6dUQ7qeAbrfG8jajfYagHb9yjh2f0wHs24npdfHsovmkK6kkN9U/tvBvXDEa5nfD9dtSf8Kw5KP8sfq9HG0qj/Nco3wffdh918wpQiu94jfsmov0z8Q69ce8DvPcRXPsTYyYevy2G0t0JtFMUyirBs99h/JSgD2oh7mcE6vIW+vNR1PcS9MNbqIvR6Jfj8B4ygDOo+0d4/8e4LhD1o4n7r+C9xuP9Z+H5s1F+KMblI1xnim+9hXlgGfqhB655CVoX31WMOpyAOrcG2AH2U3xttMdNlHkD39IF4/EH2tmI/MYDmlBvvwGDMC9cwdh8ibx0PCcFbfcWdTib+i3e7Q1gHr77OJ4pjX5gDzDFs88C1qL+nAGH0L72qOMwQAvAEm37GhCO9wtEvW7G92ig3vqijzqj3vRQF31Rd+FoQxO85wzAdMBcemfASsA+QBjAFHXoD7iFeqQ+LYfxbgZwwzdJoe99Qj37YEwRLEYfUkE9HQaIoZ7HAh5h/pDFPHQNdUnfXodv/It6GY9v98R7f4Z/S3XcOxBtchXfbA/wQx1MJQwoxPf/BND3LwQcBbwW1n8aYArG7gLAajC5B6HtytFGVQAH9LsLgKd4xhzUiaywfmyEdTQK7X0HY60Xxu58wCLUF7UnzbU9AYsAPhiHNL9Q369G/ZUI61AT/YjqMRHzkCHq8iKA+sAm1Kk0+u54QG/0hz4A6hfVgDbATFxvCihFvacK69QX/WM56pXq1kRYp/PRN5sAPlhXzFCXu4V1moP+Q32oBED1S/PoJ5pLkQ4BUD0boZ7dUM9HKQ4Q5oWtqG+qc+qL1QCqewXUPdV/F6wLtL7NHCTOpgAqoVB/HEok6qYoEzADseQfrECc6+2wMcV1YQC4r2MIEctgrsQQEorBrJfBJEuA84Q4WySP0pT/QHg94Qwhpt/gFkeAYV4qwI+EGOaUAoywdAL8WIgRNkOA6T0II2yGAFcL8XMhfinEMGMXYIT1FuA6IUY4KgFuEGKYnwnwOyHm746wE/++B1weC943R/g8wlQO4XIpMYHM5JkQH0U85kzAMSFOEOKRncWYDkBfiKfBz50JgPBiwE7AXcAuQBYgFJAHOCDMpzSHDCGm/Ouwh8oEEL4kxDcAGd3hNw9wXYgN4Z9sBEATiuQcBgtxH2GaMNFaItfwPNHf+TXr4UuPYM1/YYLFD8WYHWDJf2FnkbSLSNpVJL1JJO0GuC5MZwoxp6ksnkdpnk/l8nxKG2OOMQKYAfrCvtSG1klAFkAcc+4WwFEAzb/3AbGIDTROWlwwFy8ArAVspr2NlDi7jt/WI70PYAE6Cvg07X1QdjIwzWU1iJ34FVgC81cNrh8PbA5wA2wGdIdhBM1vfJ6neU4Kc700gPZCMwA09y8DuAO2AXaIwBD4ZHLFXFSMdA1gDWK6fQBupjKwRsYCjADTAfaAOMA3gArmTyvAGsAuIdC8mgRIA+QBVCGUpPVGDXgesAeA1srPmHPLkNcGUEI6FFgfeCQgGfCmG/xhAX8HSGNe1gD0pfkZcBaxshsBH5HuiflaB/AU6XXAn2Eo8hsgizncRAhFPWD7DPwUQPufVoA67FEpdrY01j0rzO99gcnHqo1wLbwF2Ad40xtzFvYhDcDOwI6ArYBXgNeA4UZYh4EHYa0wpvUCsBp5AfATvxX4Eug0wDUA7cEj4hEnD3gk4vgRiGHN6kvPBxTi+gz463iGGMSrQTsC6pAXDXwP8ATQDvDHWjQOdlq9ALRmV8DnTiHwdKxHswC0ThHeIlyrLgNOAy4CXgrXLTp7qGDt6glYCUgFVADmYi1T1BNnxsC/QdsDBwDeAJqR3xdrXD7S5wDDYGjkAHo74DhgM8AJebRvcALII0ZqHfAPrIczAD2wJtBeQhb4Da6LQJ+OBJBCSQzyL2DNqoISDV87tQHWACvAbawpM3DfT6QDAfOxH6E9yUb4TQsD7gPoBsEkrTuTgOMBjYCz2JvGw+axGlgdTAVtrMOJRvBNCjwHtBvwCeH6nAXYN06cKaCtfwLPwT4yewL8+QLfA6wHqGINNwHQXojWcweANyAQoGmMmJbAw7G+OwMMwNygtb4Q8NBEnLXjN2es+9YT8c6AAqTHYtzRPqAn4DCunwm8DbAZcAEwAHPCVOwR1mB/EwOcBDv+Qdgn0H5hLkDWHH4kgCMpbxpibcJv/hbsIUIByWCeJABnABNMw75iBYD2F4F0vgD0hHFaf+wzRiNukQlwBDCdoU6g/6pgr3HKEvGNAVPmwt4U18piPac9SCvoFkAP+I0wAGhiP9JHCLQ/oXU/FNgc+DCg9wLUJ/YrdHakfUsd8gYi1hDtE6OB8wG01/0AGA6mFO0XZwIsAVuXwoYa9tAEn0GLQ/EqCfEPCrDvuQvQAe2H/UU59kAnkX4HXAdg2Avthr/qNcBi6FeFwOLYc04FjAI9CLFtpwGWIl0FvAX7JhP4r4kE/incQz1bK876wWebDdJngV2BV6EvVuKey0hLYN+qAAUtE+CrmH8S14uzq4CDuCYGQONbEhCL/ZQjrgtHOhRwHJCGeTCVMOAGoAEwAf4t6OzZG/u2NYALgH6AG4C3ANobWwEXA0oBzwGjYbDouBHvBKwHYX4zrmkFqOJMU+yO+PnAQ+AHaiV+swWkIl3uinuQnis8468HOADOAfYAlLFnfA1Me8dBAEfAbsAT3PMKWAznmXakbYDXANbDD/oT4JcAQyiO/QTOwlqVAj+l6xCz7SbyCgEnhXtN2mcuxJ7+LPw+JQHnAnpi37kZMBwxmCVlxVkJ0tmAL4CXoCvAW6F9aTl84X4CHML+tBnQGXvUYbBn7wlshL3qE8BT2rMC2nFW7n4I7xMqzkJxFo+EEkM68OZ9iDuF9G3saS9j/u6H/exUrLMaUHp3hgGJF6AWefKHEEcV6cPAtN8lGAy4hvgjr4ENwEQdjLNXIiAP0AEoQ94IxMOmfbEpzpN/AGVQJvsEWI8zWhliYfxAWgq218px4iwckIUz5yIokLUDdwCksEfuBFAFjAcw+LH+JKsi0EUjW0hU7X/QpKtH9n0E3DaK0sR/RshShjAHApr4wXCFKEiTDh7ZiZIOA+EpyKRyeZrfx/NJ/4Nsa0j/g2wCSD+O9MLpHQhnQ3ecdNdIJ4t0Frl9BqW5jQbpMPI03U/lEabyqBzCpAdH+YSJpjIJ8zJ5ebws0kOCGx7BNaRzhu7GfAH+ANJJIj0G+l7iyROmfTVh4nsTJrsHwqTrQJh0lzENCN6HvoX0pdDcgt+Ij87rkdc1pS8DMoQ8fs7n57ruBQC4F2ZwuSiQG+QB4CZQIPuMJ5429v07AaT3DLcAAj1ownDJK8CkB014tjLaBHAPgLA9LAlwVIhPARSEurZcv5b0bXn6OfRmiddPthikt0p1SHo/YdDRIr1O0sXk7UtyAWoT0mekNiB9F7iNF+gHkm4f6c2Rrgnpm1E/wzLAsAQw8d7/6MJSu5AeEaZthmmaYWoW6IySPibpRiIkpaDPYUlgqrhHDUA6h6RHRnorvUFjihLoxQ1Amuo2jXjqwrqEq3JBH6S2puvpOn4N1S+/BqExGY6eAl1csuGGSzLBu5A+K5YFhm0Ww5TO4HqQwU00g+sO5ovnHQfGdMoCkUZ4SQaXhwzTJYPLBYbplHkAENacYWpjOwEIESuwa4WLFYbwVKwX7sN0wxCqR9A/4bKLYWoR2NNQH6E6u0llifRFkimJYpLt8P7F01y+yNO8D3K5IaW5zJGn+TVclsjL5Nfw/ivap+laPpf834AK/iOM0EFsGOny/g+g3/VpTvkvMPwfQPbBBHSPFMok+3kO/DdK/3dZdD3ZhVPfoPmK7MVpbiT7Y2yjBa4NyIa2C2QyJHci++fBwvmF7qN5j895/3/u5/4NqE/TXEH9nuYk6u80h1Cfp2dQH6c2p35O44jSdC/ZS1Mf5WnKJ11yhPwUYPqN8ql8nqZ+fwB9jq6huZ/GF41hDgIda/xOY5qAxjO9C41nAiqLxjNtv+ldOJBuLY17GuM0P9B9lKY8mnsJaP6g96Jvpmvo+fQ7lUn8GOJtEB+GeDDUFvQ7zT2kf0rzII3TgwC47medUZc0F/E5g68tfA2iuudpqn+eJszbjGhqM2o7nub51IY8n9J8PaM0tTFP8+u5nwGe5vnU/vxeSvNrKE3vyNP8el7v/wtI75cDp0V/++/rqd44cFq0XaktqA6pDaj+/t+A5kkOnBb97b+vp77MgdP8N+pL1Bep3ah/U1vwutdDm/43DPsf8H8z3kTbmQPdQ5i3M9+z8Hbk7cb7Dm8XKo/upfJo7FIejV9KUz5PU7k8TWXzNJXP0/QMnqbn8DQ9i6fpeTzNv0OUFn0+/y5RWvQ9+HeK0qLvw79blBZ9L14PorTo+/F6IZp+ozmb8gjTexCm5xOm5xKm5xGm5xCm8glTuYT5N/M0L5d/K0/z8vk38jR/Dv82nubP49/E0/y5/FsoTd9G8yr/Ttqf8DT1X56mfszTNA/xNO0VeJrmWJ6m+ZWnaTzwNM1dPE3zP0/TeOFpGi88TesCT9P8ydO0VvA0+Xrgadrz8DStEzxNawpP09rA0zSueZr2wjxNY5mnaX/M07RfoTTN13ye53tFmsf/b/aKousKrSd8v0hzG+0Zaf4iHWNaS7jvHz6XUN1TnVNdUx3z9eC/11KqK6ojqhuqE76u8v0gfSt9I30bfRP1h/+ek8hPDgGt5f8L6Ln0zrbwwXqP+ER0DsNHDiK5H2AiYCkgELAXcBKQSfn4eDuAI2An4DAgCVALID4uVQzJgduJd4sK0gAYAcwAKwAOgJ2Aa4AiQB3gCV6kDyrvAypPHJUnD+gO0AGQ3HkueJl+gB+ATuBbEj/TSMjL3ASoxhm3HtAM6AC4gQe5BbAD0AYgnqQCeItdAXMBtgB3wG2ALBpoNMACMBwNNAoQBIgCnAZcB9QC6gFfiL+HxhsE0CIZN4DkX2mAEkAFoBrQCY3ZDTAK4IiG1EUjjgaMB0wETAMsBSwHJAN2oYGDAc/RyA0AdTR0H8AgwAhAKPGuAF5o/G2AFEAO4DPJzdAZXgNaAePQITIANwEe6Bgk220HuINf9AMwGnyfeYAQAMlbSQ9CEdAFYADYASDfMHXg9zQCWgG/AYrg2fQE9AE4A9wA3oDZ4KE4AkzBDyEZMPFKtkMGR3LgcgADL2QMeB/mAOKHeAOOA9aC5+EKSAMkge9BeiXHwPsgHYWrgHDwPWaA31EAILk26ZVsBl/DD9ALPI1rgOuAd4B54GNYA1YDHAAlgE+AVoAYeBhnAdWAGsBh8C+OApIBZ6G38BRQAxgAXsZwgD5gAmAZoB58DU/wKkj3IwFAPIzbgHuAhwDiZfwBKGPcdAVoCXkZMwHzAaQjQHLDk/Qb7asxSGkMTAFMBVAe6dYQJp2cPYAQoQ4R6f2QUyUxwHmAOCAZcAEgAZAESAEuAVIBlwFpAAoweRWgAZAGyABkAdoAOYA8QAGgCFACKAM6AVQAnQFdALaA1YA1gLUAO8A6wHqAPcABsAHgCHACbAQ4A1wAroBNADeAO8AD4AmwAXQDdAcUAooApYAywCPAE0AVoBfgBaAG0BugCdAC9AX0A+gABgP0AEMAQwHDAMMB+oDRAFPANMAsQDOgBbAYsASwFLALEAjYAwgHRAAOAWIBp8iRlXC+kwNUY16SBx4KUADoYwzSnNgDgDA2bDDmphGYt2hepPWF2oyvNdRmPE1txtPUbjxNbcTT1FY8TW3F09RePE3txtPUdjxNbcjT1JY8TW3K09S2PE3vSe0s+q6iNL2vKE3vLErTe4vS9O6iNL2/KE3fIErTd4jS9C2iNH2PKE3fJErTd4nSvN+Klk99UvT51G8pn/pz0v/4jcoQvYf6AU9Tf/j320TS1D94+pBIPun6/FuXIvm0ZvL0SpF8mhd4mtaXf6/H2vHvXh1rCU/T+sPTNDfyNK2hPE3rFU/rYrPx7/uL3Et6LTythI3Mv3smrEk8fQrz9b/vLHL9FazvPF0n8i1bRcpZh/X632uwVvG0GDZSPF0oUv4CkXrYKPKsziLX07rE07Q+UdoSG7CtWONp3d4PmQnt0fgZn5+nCHPg52najxPm52jahxOmPThh2n8Tpr033UPTMj+X8TIIc6DyCFN5NMZoXNFYovHD52MaG3wO/l/zLx+bfEzyscjHIB97fMzxscbHGB9bfEzxscTHEB87fMzw69KFz+bjhMYClUlzOGGi/3tupD5PfZ36OPVt6tPUl6kPU9+lPkt9lfoo9U3qk9QXqQ9S36M+R32N+hj1LepTT4HHYJ6lfZ8D9gG6KNcVZb5DWVJYw6kvHEXeGuyzROfmBuz7WnHdeEAU+h31Pepz1Neoj1Hf6oUyqX2onQlTOxPm/A9qZ2pDamd+7uZ9hLctYQ6cz8JlFlQeYSqPMJVH1/AzPtULlUWYyiJM1xGm6whTWYSpLMJUFmEqizA/d/I0L5f3cUrTGYbOGHTeoPMDT9N+n/O86NwTh4JOC/WBzwLOC3WcSb+ZdJtJr5n2I6TPTLrMpMdMOsykv0y6y6S3TDrLpK9Me5ZiQAmgFHAPUCbUWSY9ZdJNJn1k0kF+CagB1AJeAV4D3gAaAO8A7wGNgA+Aj4BPQl1l0lMmHWXSTyadz72kryGiF/1b+B6UR/fSM08J6VYRfWiiCeh6uo7qgN6bruE63ZRHNH0j1c85IU31RPVA1/Hn0fWUTzTVH2GqS7qerqU05dH30u9UNn0fpelbbwvLIZq+lX7jZVHZlEdlcZrSVIdcD/2/9dLpW+h+outFyuO/0zdz3XOeT8/gmNcBvRu9M8+ntuLfTGXwfGob/g3/fe9/03QNr2cqg+vEU53wZxOm51Afoj5IaapH6ot0D/UzSlM+12mnPkpl8HKJ5u3H6576MNWFaDvT8/l1PE3vKFo/9Gyuk09l8Dan5/DvoXei/k7A64L6Jb0TjRHRPir6HNF8fh1/LvV9egbX86c+S+/C65/n82/mNNUNtxEQHQeifY3bC8SLtCm3I6Br6DsTRe6ne/kYoudR/fDxw8cVzQs8TX2Q3oFouoa+jf/GxwWnqRxuK8FtFyiPnsHbl49Hek9uz8Drn2j6jV/Lr+M2D/w9eZqPH95fqL9xmq6jNNUBtQWlKY+uozTdS+/6VpimeYyXwWnqYxyLtieVQ2OIj1fRNO9H/z3GaF4UnWc4Tb/RfMnnNnoWb1v6jWhqM9F+we8jzNuaz7E0PgjzuuM2LUSLjm9ae65jbaf1hjCtOYRpPSNM6xlhWs8I03pGmNYzwrSeEab1jJcjWiYvl69nPM3L52syT/PncD4qT/PncT4qT/Pncj4qT4t+D38u39/xNH8u8e5oj8l9fRMmniLxAYnfRzStu8THozWXeHmi8gSOqUyepucQ35HKcMdelvTXhoLfRGsc8cFov6MMOgv7INpDdQLvSgN7G9pHUfn0fOIdEiYdCMJULmHiLxImfibxPYmfSZj4nYS5fI54kHStKE1lE2+UyiZMZXNM+wp6Bpd/czkd8SSJ5ml6Hk9zHiulaR/C01Qe54ESpnrh70OY+KacP0qYrifMgd6ZMJfDc6A65r9RmmN+Hc/jbcCvpTTH/Fqe1x38VeLJiqapHN4n6Hqepm/nafp2nqb+wfuPaJqX97/y6Blczsp1Uage+LsQpt+pz9HvhOl3wvQ7YXo3wvRevG8S35quJ0zXE6brCdP1hOl6TpN9JdGE6R1JFkHX/z/snQeUFcXW77tnYAIwQ04DQwaJkkEyA0gGEZAcFUGy5KjkICImVETEhEgSERERERHJOUk8ZDgOOUoG3+/fdYo5zsLvetf61n333XeHVeyuqp1rV3V1VZ1uQcWT1q3lR5tkg9baZYeNE+XVP0SjehuPWtNW/xJfxYb8pXVy6af4tUnyxUvr4sFxIzxB8ZYcXWutXPXqm4J2j0/XwtO15Eie/BFsj8qVbDvavW21j9b/tR4vv4i3/Ckbbb+z1xpb9Oyj9hNUHAlqPBHUGCao8UtQY5egxi1BjVmCdqy015avHSvtteVvx0p7beXYsdJeW3l2rLTXVq4dK+11sD1Wrh0r7bWVa5+v7bWVa5+z7bWVa5+3rZ+sXPvcrWu1qx2f6nIOhs+MOb2/MO2huNL4pK0IPrfqNNE716kry7ceOH7oNAZyPM4bT2xSPAjacSa4zJbbPRgL+7P/P5AkqDNOgt1JLweV89l450Tgdxw6L6Dfa+g3Efr9xeHA7yj02wmduxCOyvtwFkqJT6r+Kb2cKPFJ7D8lPl32pzQiUeLT539KsxKl2YkSn3z7UxqTKI1PlPiU2Z/Sa4E0OZCmBBKfdvPStEDik/tempsofZUo8emsP6WvE6XlgcSnhv6U7Ps1g9+zGZxWJkp6/6ZNwe/j/DJR0vk1JT7N6KUNgWTPtW0OJD655KWNgcSnRv+U6gSSfR+ozsk96lr6P+pa5+kedS09HnUtXR91Ld0fdS0d/9F1sP6Jr7ckSraucNA1n4V/eP3kX/ASzB+gExSNIJ+q96DoBEUjKHw+Y+jhCwpfUPiCwhcUvqDwCwXwBVUvqHpB1atOfARVb68FlRdv5QVVJqhyPvfolQuqXFB1gqrns45euaDyfN7TwxdUuaDwBVVfNlAuqPwTAVguQCeofPlAXlB5Pivu5QVFLyi+grZe9grKXj4b5eEJql5Q9YKqrx6IUUHxFRS+oPgK1ghA0QuKXlD0qhOdoOgERScofEHhCwpfZcG+tz4XtEn4NoZqBvAFhS8ofEHhCApfUPi1AviCqhdUvaDqbQwI2pgVP6uboI1ZJT576bxI4nOqHlSdoPb8+GS683TgukHQdcOg66eCrhsFXQuKj+0b4m+v+UTwI/uStfGv+pV4CIo+uD+J7lH9SviCwg/uT8J/VL8SvqDwg/uX8BP3s0fF4V/F3T+Kr7+KI9HbmJEO0k9Q+gXHh03BcWLbUdfW99bvwbGXOB7+0dhnYylx2yn+/s7YJ7y/M+YJz7bBPzOm/bNjmcr/2THtf2ssSzx2/d0x6u+MSXZ8+J/Gor8z9ojPo8YcG1v/aKyx49JfxUviuHhU+wsqb9tPUPlSgbyg8o/yk7Uj2J7E+vGp5odjmq7tmKZrO6ap7dVPBEWnNldeUHm1ufKCyktH5QWVl47KC1p/KW/9Jj8qb/0pPypv/akYVV5QecWk8oKWv2gFxVNQtME+0jggfQTFR1D0gv/p9v0j+uCYErTzlr8aS/6KX+L5jsbwekHQjn02zu1Y9qhri2P7rO0fFsf2a3ttx8HgMdJeW362bew8xNplbbTjqr22OJbPo64trR1Xgq/tWGvH2+Bri2N9+KhrGy+2nYLbLPja4ttrO4bbGLI+DL62bRU8Tw2+DsaxfcL61I75f3Vt+4ott9e2L1kce0+w9wt7be8JwfcHO6ZZ/9hrO4+w9tr7g71HBF9b/omvrazg60fFkdXDyg2+PwffbxLHY/B9x96rg+9R9tqO05afvbZzG8vvUdcWJ3h+Y/1sdbV19trOUYKfxYKv7RwxGMeOXbbf2XIry+oV/DwWXG77lOVj+4WNc3ttYzj4OSR4zmjnaxYn+H4cfI8LttvGkvWPpQ2Ot+AYs/Fs57SJn1uC5xXBetr5THDcJm6v4HmctcPqb+PCzrWtXDu3DNYneC5mx5zgscjqZuXa+4100tqJbLfXGqd1bedQdg5vnz+C+0HRID7WT/YepHUOW27n9OKnctXbNrT0Ng7stff70ES6qCwxP5Ul5mn7uursteUlGumodQ5bpu8YuixihpB0HlvfH7K/8cpAWUbSo35Tlg4BaUn6RquS/T0Wx5v0028nHXTpSalIqUnJSMlJ9l18KUhRpGhSSr1TT+e3gn539lfQylOyuksf6S397e/UpN9f6aTvOuqbqPrmptY2OWLuvfNQ7zvU2XN9z1bfN9W3MfmpvCdb92/NCQXt87F9NrbPxXYuaZ+N7XzSPh/bOaV9RlbePjM3DuQFcwbax36fJ/g7PYm/15P4uz2Jv9/zV1B4Sort4FQgkDSmBSfNw4OTva/YZO/tNqnfBSf1FyWtOSgpDpX0XKqkGA5OGguDk/pHcNL4GJx0rw5OmoMFJ/Wd4KT7cHDSOBOcNC4EJ40Dwcn2TZuC13gSP5sHP0vZpHZTCl5fDU6236rtH3WtNnzUtdr+UdcWqm/o28DqAzbG1Rf03VfbX2y/UP9S31D/0u8e/+7vNO04oj6l/qR+pX6pvvSv+m2LxhP1Y40p+maxxgu94/Vf9ZsXjTmB12A4vPLCGYdjx5M0ztqxT2PX3cB5MZ1/0VmXzwPnWnSe62TgfJTOcuh8g85F/L92Jk7nM3ROQ+c7dM7+P+l3A5/qG8qkBUHve5gN/Fx7zxSE0Ln0bt83SXq379ukjynbTNrBHt9Okr7L+D6wCYnXEzmd2f/7HDiLxGtZnOb6/Tq/aW8BbEeaS+K1KA6vTHE6kHjVhfdb4xn6nT9pLGmefhOvdyiQkhx1nSnsL/bSd9R1DQwD6vuPvDbEGaTf2CtmgRGUvwTkVXF8dJn4IvHqC6cLOn0BnChcBoXXgbw+w+HVGc40kr4T/TNpNSkZPLKR/lX9/O+OSf9pv6n7d7DnP8mW/+22sbbIBqt7Yp3/WX2l6/+k5//vPg9+t4q15R/Z8D/p/39b90e1gXT/d9L5v+Ppf+35rz3/tec/zZ7izGXLau6t70wE3pkzNfBdlXcD31HRe8T0bZPppA9IM0gfkmYGvgeid+zoeyPC07vGZgXeSzab9IW+dxH4Pkg4D+T6Vkzwu7b0frKlgW+76L1V+s6K3mH2Q+Adcj+SVga+yaT3+th3m/1CWhP4Jop9F9eGwDdLQpAjvuInXqoXnej/a+d/7fyvnf++dvpIh/V9+r/5vPtvj8eZ6OKkEiR9078USd/a1/f09Q19fSdf3/avQKpI0nfyq5CqkuJI1Uj61n0N0pOkmiR96742Sd+413fzG5JeYUFG3+xvRmpB0vf1vyJtJ/0zOlj5kv1XcnXWW7LfDMh7htSeNJ/0NHp8DbRr7loz13q41oC1/m33nu3eVvD5Fa2Ha81a69Ja+9Z6tD3XYNfmtcaudXWthWu9W2vavQJnjj8h9Q6Sq/Xn4H20fyQrsRzJsOedgvcog+mDaYNppM+jdAm2/Z/VJdhe2ZrYx3a9PbGf/zd8/I/a8n9Dhn2flqDW5NW/BNXHBNXPBNXXBNXfBNXnBNXvBNX3BNX/BL13OwS9f0rzN3uteZy91nzOXmteZ681v7PXmufZa8337LXmffZa8z97rXmgvdZ80F5rXmivNT+015on2mvNF+215o32WvNHe6155MP3NgRda15przW/tNeaZ9przTfttead9lrzT11rH1H8tZcoP0munfeKj/D+VfNh8Qr+vZTwJU9Qyf4+yNJKH+FaaN9dKFm6lk76vpi+kaZ9BLuXoPdPNWdTZQtM7W+N9a4FfRvgJO9S0rtmZpHPwWQ8J5NsfZuoAUwns/Gi7yssIh+rbzWxIaJ3R83lnQeXMaQcxqVjcv4O/J/RpD7w/oa6vFtB70zQ+xP03oRw6vROpibgjWKSPpRJegS0I/U9Iyb/3jsL4KvvMizFWQ14p4PaqTDlaiddi6+9lu72+hXsstf6/aS9lix7vY+HBHt9WO8OC1w3xy5dv4edl9Dz797/7PujFSMqC86rDdDW2Rca5vAGfPcVZ6GT3eMU5rAU73wER+3hmSef16CPcVxnpDOV+kbeTlc7J7n3dKS9PR5iHG48TlbvxbMR5LOy85eT64xOuHbQKUnhpNN7cpyk7NXx4OOkdOJ8q9c5yd9BA4OTxIMMRl5tCm9/j50Vj2eox9P8hXv0IV6ZrpLpHblQCyrPT4g828yfdEvF/+H4LcKr136kC7aupXUqIj1VQK64aQtJf9I68qFtLtSGH69a9kqFp1ftGlzzv0upqGg5/nfhGgLHJODJtiT0cUFpGBrQUJTJA5xcrDYcw7gOx3uuE02ZZEsb2c7+00N5ycDLGNDc0KX3asw1r4ym1ugqj5pS+dnQJ0MPtZXBML5JAnfxS+LE3VlL67znpvD8GkqJ6Cw3ecn12tr4RZYLLyllqlHLJHEyOJk8OqNTUs9OXcd4Xjd+SBbwpexNw/8qM9ZJppGXBFuMf4wF4ciMm74e/epIoGlu6xJjmhQyrpUiIQGjVGbdIAFSVArHIjbuqhhGmugRQtzEDRS0NcFm3G9CUXQyW5zUiMahqje4ybzmdqkzBoTAXfJNKArTCBGfuIsS8muIDb9wj6PBljNM6JuAlf7GXslXGMhFphsIJ8Ey21iSEO3ZqL8kXnOb5jB4xmsK0gQb1ZxJA94zNIaPCRjRiZt4Soquox7aI6tTPuw4anIbMsZ7pg0MbthD2xKaVtaFeFraMumhzqDQkYYGz7SD8ZLhbGps4xmuIU7cts14t56QxNYQi7lhbxyr/5MGlLTOVYmaUaVyj1FVuHGztsByuyusPws3Y4QZy4yL9M9KMS/llvtt8BlXmBLLx45ppp+aXiTphl6Rb4JPUhL6iQ0YI82EuZWoPzWhMOReG8iW2voj7sFW7DrjytGmoRQcCgSDqaY1sq2j7ZhkG0q10taO5gpz2wFMYBn5CaOrkWz0TKyXDXvrW0uZWGKC743PTYkJADsyRXjaWP9YDnG3tmOxy1AyegcXp3MliLKCzWCZ0Mj2lmH6gWFolTMqmb5t1AgeMKVemOOvG+r4d8Q4/l2kV3a6/v5p3cgGyRx/me6uf3Os4387qeM7FuL6O6d1/fkeOP5pEU7kk7FuZr6N5vsgqeO/PNvx3yzi+M/NcQYui3ayc/bLHxfu+IbtdH1FHji+nfGu/wh8ch+DX4yT7gca8GRWx78twvEPQ2bPLI7fP8fxlw93wn9J5/oLU743zPHlQK9Tcxzf/qxOeJk07rHHizn+Wmdc/3nGo1WpXX9B+MUjq1i44z8Gn/Tkn4ZmONd5o1z/ffikTOb6ZwDvod+JOU732tGOf0uME3/hlOt/EOv4GqR0j3yJHe3hs3Ke41+T1AmvmMLJEUP+CjSnSDMo25Ta9e1D59opXV95eH43z4ksn4r6MCe+BTInJHH8X8c4Z9tyC92GnyqFOikW45tfczj+zHTAslkd91o3d9MO/LCHdDLWCfdj9+FYJ7JURsdXAxsOUd441Bm6GR13xzi+8oxdZRmby8I/Er4NUjj+Xlkc9yw850e7/kvhzii+teC+gJ/3xru+dSkdf5dQ51Qh/HQMXReecP0HgetjnPAKaV1fU/gcx55p0ivG2c/3xiJHFHF88TmcyO3ofBx/ZAh1NvGNDv+T+Ln2GXfoxmjn7FZ0bBDluPFZncjvU7mRu9D3XXjM2+lG8z09/9gkju82ul/Ehuahjm8P7X0bOZW5PoPvb2V1fLvj3cixKR1fRniPwVcX0K0H18+RDuVwcnIe0H8c3OPAPMTYHtrwFPo0jnQu8/0Lf/2Urr8OqSX1vfHbOeRdKez49xEnpcKdY0WxuVta1z2Nb+7C5wXsqYENmY65kemZ8FWLdf0X0akKvaLrTnd0X3xVlc7I+ZzRw7gen9I5ew6Zh2Jo12gnsmYq15cJX/CdDl/hB078DdqrYqQTWSPWjVxNjJ5HjzMxTlbOQ/pr7HL9scReFtJg2m0ePkkD3Wp09CMzZ4TjezzUycEZSP9mdFtH+RLaZAXt2S6t458J/jXw4pF/mtjqTv97MZXrL0n/yw3+NfD5PoKvZko3vHpm15edWKgV4/o3oGtcdtf/IfyP4OPXiMcMYU4mvl8YviKZ4ztAe1XK7PqrY/OBHI6vqHjQL+8QO/HwHDrbOdsOXu/Fuu71bq7/51inyxPRju8X9DiA3OvExh/RbtQ39I8C9ONstMOWCOfMvVgnlvOf/p5Rrq9NmLOfb935S8D3MDqMoY3ew54F0JQA/zcG5HLJXN8F4rB7lBv+zVzGhlAnN7+l8j2V0o0sTL/PhKxLtOUheO6lzQujU4UoZz/fvhv9EjHzHfq8D8+r+Ois2iE58Q//BvC/G+t0r4vOF2n3S37XV4eyfdi6C577Ipz0fP/QX+q46/8NOV2IiVZhTmQY17/RTtvxQVFibX2sE5PtruN/B9yu0F9mzDkJ/Xm1SYSThm8+ulfxT1Xi++Jp1/8Ydq+Bfjn+rxjl+D6H7go8t6OnQwwMwa8d8XUtfOH3u5GlGKvCKM8X5bon8MMW5L5OXM4jji+dciPL0W5DQ11fcfhfp6674j3UGfg9dt2hbd9Hl63ApfDPBp91wGPk1+KDEVz78NsFdN4NXn7qN+DDnRFO/PlTrq8iPLsxFh6l7BJ+8RNfsYxHFZM5kcsZZy7NcUbzrRa/D7l5oS9BzO3Al49FOPuzEDe7oClCm4XCl2/U+L7A1jP4pS/jyR+MC6XT0I/x6+kijss3xv1tiec84D6gr1RJ5kZuJcY5vxlZjThtStnWZM6puZmcUzeR15wYyIT+C4jHjcAQ/HQ4I77g+iCpLXYN5t6yBx0KwHtvjBN7FbsKF3N896G5TMw8gT1nqP8Vv5Y47g7dgM9qYzPf3fHnpW17Q883RvyfoPc57lsj6Ffp0O9J3TPmOOGr0rv+O9izCn2c1O6pW7FOskXgpkc23y7xZ0SPj/DLQNo7P/xykEpDmwQep/FpS3B+h/aPIs7o4fgxJbE7n3btin92xLsnejLGVs7s7i9HXYpj7t5t4E6gv/zMveY+cpMdc8NLgX+W67HEy2FkXYb/SfK6gx/Etgv4qeADJ7x8Jtc3EtrnkRl1zI1gLcKfPcLJeoU+VoayD5M6kRfmYy9+TIf+fOclskpW178V3f0aT0kn/W6qpdi3E38tgFd27PgGXU7GOEM34bt8tHEeeM2nLid9fjr68N0kfy7sTnPMzcI5cH8n+KbL6ET+hO/+IA6HY+P7jEf5uD6a1TnTBvxs0OWJciOrZHD9Objuh40pj7luF3A7oM/L8G+f1oksl8lt3YwY6ab7W3In7HJv15cb+pvw4hyvf9hsx8c3XiILZaQP53DiY6i7hA/70641z7i+x9CrEv4qn5n4Oeb67lNXh/lBE2L2o6ROlsvw2Y78RtD1oB/cUlvOdrqUI/b34tsR6HEJXx/AN+eQ11rtznj+MX3rJNe/gn/R7/pbMN8/hc8WzXPc3fSPE7RJOeReIAaa4LNn4H+b+naU7+L+dxee0ZQ3g8chdLgIn0GhjMXQ3OOas8v+88BNGmeh24feBcB7k7bpg68u0p+jGDergV+XuEgL34bAUvTP3xnnLjEOXUDGVcbDmuncyBu04WjuYR3Qowo0p+H7OL65gv8yE3shlJ8D/wXgfpZNzmH7JeTVIl8I3PHckwfQLmfRaz9pPH45hF5nGddORTjZM1M2E7wH3BM+Q8fU+Hov9QfReyM++B7/teO+2At+O/FPGXTonsVJ/jW43zBOrsGe0uhxBjibMl+Ek5pv6voXo/eXyLp4wg0/k8b1rYLPFfgtofynefRrfNmP+3pp+L5Em2dA57LwyYD8rKFOfHrKT2PPfmTeKOJk5Hu2/izo+Rv3pc7wXYvsrcmdUwspHwR9Se5TheY6vlbgpGGRZ0Wk/Ob612BHRsaHa1mcsCu9Xf84Fn745q2/JvwfILM48FdwopGbl3gsSR87Q34F+h6Blw/5qehLnIX176NsJrIG4PsbanvmmteBT/C4sgefRYA3Ed34FpjvgnzF/enSCffgHfgdx99n4VeMsgLIqowfkwIzg1su1MmWiXbISn0OeJQEJyt1hR447swVrj+Sst9pY76v5M/H9RVsLYKuS+mDi2jbwthdDD7f4pNNUc6mXOAV6+6Gf0f9Tupb6X5dxIk8y5g+mPvR/XDnYEHGmKPIjKJuN/oVQTa/R/HdBvamLDXJB78G3ANWw+M89hwAvxZ6nwD/RcbBB4zVadGzIXQV0OdqFsZNzQvR9RpwJ3h8T8q3Cb9ti3FSfpvUGT2UNj5LPhd+u8Ccoz1joR/fNaG9MtK2fFM3Ld809h+LdXLx2xFfD/pMQXjVRW5uxq2K4P/GfKQebXsanxbvzjNNpNO9Hv3+PPKu4ZtZ9PFYzUeZY4yiPcaRfkfeBxFOntS6PxDrhUKdNOuR8zRyjzLOXunm+j5V/GPjQdIc5gan0WsZsVoWnhUyM1ZjY9GOrj+j5gLY8Avy4rF1ENfDiYshjAM/46v7LnNUzTeYf9fI4hwpB20m7P4K/hOY1/tzOE2fYWyszniUE14n5/CswDi7i/5xN9r1NQt19vPNYf9F+B/E9nqa3+P/48jhu3K+H5HxU4xz5lnKp6JnKcquouMkaPaA/wN4c5G1H37j8FNyPU/Nccb2Rwc/ZaPB2w9eZ+g/Qu+9XO/A1lTk1yIzFWPiZeZFj0H3Hn7bwZyBbxX7lsG3zhk3shrjwQmu30LGCeJqFWPyrqxO2uXcp3akdcMrpnWPTKduIP4oTSyfZ2xoxPNVBXxf/Ljr82sOdsL1vbrTPVKEe74P2a2R7SLvAjiXizjZ+N2R/4DijJjaBOxLHByj7LdYZ1NOcEvT7seYM9cOdbrXoe17UtYH2f3ov5fBP6d5K356ifvS1kgnw4+aAzK/a43sxczR655x++j3V95POjrwOD0i5KbzNVBLGiWdMq6WQ9mGdy8CtJzRlAVrPvXq1A6J8FaTzF+nhwsFZjUoG0vZkfxIIgnLi9rWMHXaEBEXHegRLy2lus6NQK22UexCalUdOXeOPly00TJGEpZ3i3k/AMnkzPG2SOyqgBbXxdP8rEV/JTz+2b1jRVqzSwveY4HliBByZb2l0MweVmGW1rW4nrCWpZXDXPzMRThmOVze0NaN9BRv4ab2dBpAXouwGVjz0zqcfnCjBZxkLMmkCiw3hVMuz+gHK7W95WGzohGCjKzeKlsSfrijhehosLTkniOwtKJFV7OiUSSwFF4S7e36XRj0+oGCVi/zoqVZ3C7vbSJoNSSbtyKoBZ+461cDC01aI8niLfub5V2zSC4s/VxI66tm2YZ7hecT2WoWyCRfC1Qp0MB4yWwDaItByS4yZcUXxlNGc4MlW8yqjHxiSiLhoY030ebw1mokJxr+rvcjJrOgZvRRrEgDUYpvlOc3ZlgPNyzMaq6RkcKJi7+OxXx1W0hmnTHunoraGz+atSK1cHL+mTUlu7xooFmFVWkBTyu7vC+5GT3r04NhtNJWi/ljZevU74jpbQqsC/hcZGAt0exhRIEY/XCBVXhm2dmu72vnR2FkFrGta1N5gZTEc5REZny43sjK2qkbWlnLxZq6Ll5zs9IqdrFT4u0WjmXGUwukhb1W0F9yBPOLlKDFQkWD6uy6thZnzbKt2fixC4ZKxj/CjvTUMkuuhjIcT8VNuYVWH7mSaVb1wgI8EgxMWPOzy5JyiTYowgIbVcJ73LNB2hp50sZEgV3sTNicUUwpZ6Lc9FtBo5fxh+GSC2/JrXFLbytI1Hra0DArq8FLixoMghfE7aBhW8Ks+QrDdF2t6Cbz3JOU/80aMkEy8w5iJrjGTQnm6yoVHShh0T1hZyxhmd3scWlHJ/nDxpFxkYGBRvETvOJrok+7PmqwcE/HcChNjCoq4xbdRZ+eNlyt/9XrEnJm98P0XpGasc0u0puFcrN8bpRV7zACorwyU2f3XPD17HsK2bRI10U/s41lVm3lyISFazNGGm6mzY3bZKq2N60TzTK9XJ4isJRvm8dIV4Sot5veoM2yuKX3ET3ADFkmiO3AZXbBbNDIZLHW9ovERGKU2coyWz8SJzFS1e6fmkAXVxM/f15vp88ueRBwwEpd7NTXQh9upJrBQgTajLR7M3ZzQJ42O0kaLsxWigkms01g1DLRbvd8TNLYrpbVvdlss9jAsxu9pkearcMosEyPl2yVKHDMMCVKo0/CAn8CLzN+xE0buZ7R0Ag1lcbLIjaCtPVkm1CxGRzptu/Z3VvLXqabJrUG2B1c0zvi3hiF2KMhCXvEwX3I9W5YtsRKVKvJKeaWY/7s+GsHDjnC1tqtMdPmdjNRpdJOe9YJ2xWaGhidg7c1Em/UKWI0WUj6cFPNbobYqDM7TXZPxYSJaRjTDKajJEiQx8wQbrqmaSAz9FpNzW6N4frnPR5BNbDtiHZDN2FvLG7kWPzMvCJusi5YurG3YRN0JixtdzU3ELMLZzeFzV61tFSYm4HB5M19MbjlkhOO3nTmjoSFyk1xb4zjku0Nu9eU4FnbNnZ3ymywGum2G8i/pqeaXXUj08SqGd2Nn+IeSEy/4BlNghhzrEBoCeUJm5qRXp8yW6FmrzV4nmFC2x4OSNhN1vhqNh7j7o2Xixku35qgrhS8NSf1NbjbDUO78aiuZUwxrk/YErS3GrsXn7Dja+rtLr7dtEP+pImIHcPmq+hMoBjuCTdCO7ab5jKO/jNG8LhgbouawJgmsCOVne3ZK3uHsfcNDkhMewVdatneb48XWBOC+5eNYTNZtrd6G0+Bu1682D1lJJlbs9HP+i5hXmgsNIdBTEcw4R1869ZsSZhxqyfBtpKZPNvwMLoZwoRdcIVwQhMl2KCTEK/CpErCuBosSbMa0z7Swg4NSva4h2k/PLZLbPQp7qATK2aIt0EgySZcTd9OGN2sRhoFE6YGttz43oS+6S+yJW7d5EC47tBFuB1R4o4p+7yZUgV3UXt+xPWODCm+rC1GPbtZb10W3NBmSDY9yESfrhkVdr1mu0rwEQXpZ9rDjj52ZDJhpzuR9Y25s1vXJkSRoTIWmzHKltBme6bIdi6O6OLoOK/T2Il3wmEVo7Z5pDKUJuSMLDsmG3Ps3DNhaLARYq/MwZMKt0Oc91K4TtdbIc7a5K5T+TYPwJGu83h2HMx2QTLqO1O/+Q4n5ZO5zgRgK2Bryr+j/Hnwa4J/F/rm5MsD34VPaxp4U0iI8xV8BoQncQqDP5H6idn4omaSEGcz9XuoT0b9YpYSCmDeVZr/Vfi3g/99+LQE/0voIqNcZyh0nVhGnIq8Aci7RHk9yreBVxC8rzC0JPxSw2cXfDaANxe8d+D3AvxWgZ8V/Lnw+Qk+v3snJkOcktC/jr51wS8Efg9gA2Bl6NJC1w5YEtgXusbonY38Herba2EDOZ3QfwJ+CgfOx44J4I0Ebzx4LaErCr9U4B9GTjn0zHgnxOmHHv0Yf/OEhjg7wM8H3Sbw5oO3IS3n0nj+rAL+B+j1Pnr/Dt0NYGPoViPnPbYwVsD/dfgfJL8+PMT5nvr01P8On73w6QffpujxIXgvgleA/ALktSdfinwd+H8O/+rokYnyT1UP/gzoX4K+APYtwT/j4L8vLImzCvys6PE2eNPAG8lqwZMRIU5Oyl+CTyP45oXvII48vkP5fejn4Z9ieusAy+w9yWcj/yn8x8B/DnxW0A4dd7pOVbbQpkLfBfoY5O3HH5+AXwP8XNj1MnJvUx4C30rQZ4N+gd6QQf4M+U3kX4HfWPQqDV4s7VEUfkngl4z6cxGucw94GLw30fcC+r4E/YfQfw7+U8RnP+QVRF6du7xhI1mIswn6D6EfBl0b6O6jR0v8mxzYBX0+o3ws5QWRuxD//QCfN2iHj6m/R30e6pNSP4z6Lti5GbmPqR2BjYFX6HwfE687oFsC3e/gTUnKchZ6HMHvj5NfynJlO/hUgU8G4E3sqIFemdErA/Aq5VmhP4K/TiWl7dG7AfLnwv976ieDFw5dPHTtsHcE9kbBtxf61oWuEX66Tf1B+KyHLjf21SNfmPzL6HkQP9Xn6S0K/POUb6X8K/SriZ9iwR+CnHj4dUP+l8RDE/iXgu4N6DZQngF7GiOnA3Keonw+5Y9RPgd+tSmvHxbinAOexf418P8c/qfVz6H7AXiV9vyW8ncpfw2834nDryjfiT8HY1897BuAHjvRYzkwA/rnon4m/M8CX0SvgrTn1/jlaeq/BK8kc60j+N2HPk+Q/817E02Ic5N8E/LnwKsFn/7YWVh2Aj+mvjN61EKPMvDbDL9J4PsV9/olCfza4N+XsP8GePvA+wI4ETgaPZ9Bz33AecC4LBxqRr+26JcTO9Jg1wb0pIn4pWGIs4DyDZRfRo/66KGhuhvln0I/APrdjHPVkNcP/k3hT+g69cm/iPxXkT8E+o7Qd6L+Seob07+zIu8S+R3kW6hd8Gsd+H+OvX3gnw87C6LHA/SYCP8Y+DWn/AZyK1FekvZ7Ffoe0K/UCXDkZMD+vtj/DvxmwO9N6vtS/y3lqeGbCtiD+mXo/Sp6n4ffFB5UI8F/nrj+gfqM4B1Hj0rY2RA4j/xC5PXBqPu6/8gp0B+H7xZmKHfQqx75HPD7BfgucBtvUcmMPn2IvwrAzd6yIu0NfTvi633weoC3TG/Eof5lxT/6DqC8NuX5OzJGM/4MRv+WyPEjcjT+mKL+CJ4fvaqh30n0rYJ+bfH3s+hxBLy+2PMccsbin9rgX9R4Dl5h8HLB/x78tgM/Rc5nGifgdxI926PHHsq/oLw+evUk/xr5DuT3wn8g/FmFdqbRD8pQnlz3H+CT4oM+f8A/C/WHaK+2wEHIn095OHqmB++K2gl7PgL+xPjaDPsUSmPxyxLwR3P/qEZ9bupLcR9ejbyF0I2C/yT4+OFfEbxi8N1JvgjEB8ivpZ8+AcyHX1fo1wDofc9bxmdOQ/nnGoew81n0TgH/C7TfN+QPE4/H8EtF+HZHjxj8m4bywfjrI/BGosc30I+Efwf0rYS+270l4RBnq7dwz7gO/ZvEUwj4J+Fbn3i4iN4z0O8WfOPQPwP6r6V+tjeeMc4AH+hNReh5DHnN0G80fI7Apx9026GLgu4ieG2AxaF3KG9D+X3oj1D+LHqNwg/fQ5ee8t/1dh30vwa/SdhZn/I58PuV8lbEwwroPtQ4Bt1h7GkN7A99H/R4DT1+gH9G/DmP8o7E+VRgSmBD+N2jX2jDZCr8L8BnG3yWgJ8K/JTMGzgp5BxhPM6A39JTfwM/TID+KOPiYvJvgx/G+FKR+nro9QV6VYL+ffRmWuFMxo9dwX+H9ltHfS7K//A2QUKcQchvQ3ymQU4v5HAayUnJOshj4I3RPAG+jeC7nHwG6CYg7wXkpaG8psZb4roj9r2EvAPUv8ANvwTzmPqMlxcYL+tqPAcvG/Bdjf+031mNw8TffuBhb/uFfgz9Vug/oj36av5Ff+hE/WfoXQs/HSU/VnTAl4GNsOs8dAe9LZkQ5zfFOf57HD6T4JMJPW/jp23QL6I9CvKqs27kR6FvLfRNiT590eektwWCXuh7Gn2T44cu+CGW/Jfk3wDvLfwzD78UQO4o+D6L/cU0j4H+R+AN6pPrfkj+WWBh8m3x1/f4T0u2taEbQf4Q+VzoE088zkJPdc5nKP+a8tfJn0PvHfD/Gv5bGd8youdQ6vdS/z10k7FjA/k8mn/jJ05eOrOQt4h+Vh/7T2HHZeTNRN4i8IeA/yWwJ/57Cv7zoRtA/hviICly/PijD3xqaDz1zvyHODPhfwd5oeC3B78ceDHoM5V2uw7ffJSPpjwHdHcpn4/8tci/hNwZ1DeAf0vivh6B5xIH+cnfob88A93X0K0g/xZ6VYPuBP4qDf8M8PkhHbEK/jHwKuKXdtiThPYcBiwPrAD+HvC7Aavh33S4bz/lyYjDqpTnRe9R6D2Y+nboEw/dePUn2rsLfpxA+2UmrrfBvyD8xwKP6b5P/XO6f6DXPPRai13T8EcY/J6FXwf0i9M4BZwKDKH+JPB7jfvoURm6Mtj7Nfl9yE1P/PSBf3Hi52fiJ4r6H2jv+dBPhq4c5dspb8W4MAy5iyh/k/IY4F3a4xZ6NYV+EHA3+m3HjobYkQP+07FzFnjjwB9IeTHNU5A3BPzr+H82/k9FnpM9Ti/wntJ9APgxcCZ6lCYOGmDXXOyKBo+TcE449sRT/xv0b0B/UvNw7hNb8FdF8rPJN4EuJf7ehry24JfQ/BL5g4mXp8jnId8JyMlGZwXjeEPacTpyh8H3V+wojpwv0P97/HMb+c9g12Xqd8oO5HZGzlnvl3EhTm/qN6PfW9BdBC9a8znNm8CvrPk+ctro+Qp9QqDbzMpXGONnHHQfQueH3xTK2+v5ivZZTb4H+fPAd4HRxEsN+L2Bffl4PmH6zBsgQpzM1DelviVyyiPnFu1zgPbJi/1XaL9V8HuA/nnAX6inbGAP4Hpv8Y37Ifq2wM7HoU8JfSryPdB/LPFVBz4noW8Pn1LANcj/EvlFkVcYe1w9P6H/bvT/APrh0Md7G9X0H/Dngf+JIPbUhe9s+LbDz+XwcwXo3oOuE/k63D+bkl8k/wEvAn+gvD54KdF3Ivyeg8/j8NmtuKSdlwLHEfc1kJsXuYXgP0H3B9lJe49Hz4zyJ+U/UF4CfcPRNyPwGvgZ4TcO/xeHTxrGlZHg+cArQn0IeFPQ4yx6LKC+K3FUkfLUlEdqXGZcOATciPxN0HEi1ClKPor+lJtllUXIvU35M5QvgW4CdD8h7y7tMA59OyO/F/ifgf88eD8jtwDyxiEvD3if6vmW/APyW4D5qffxWsvutMc12nsW/D+Evjh65QFepH2+gk9y9T/k1UXe28DOwI7wK4jfcuKXOfhxC/gL0Hsp+GnAfw74E/wPgVdL/Z365+HbinwMdNHI74YeyeB3TuMp+Jc1nwMOAl4Ebzh0XfQ8qXkH9k0H7znwOdXp9AVvG3hD9CtD9D9L/Wbqn2A82cp4MhO8PuCFaL6D3duAufDvAGAL5NekPgv11cE/DH4y9OmMPumx5w3saQn/b+G/U2+ZhP9i8tHY9RrwDOUvQ/+04hT8EsRFF+h/gX4O5cMofwl92qHPMuD7wBeAdYD1mLckR59W4BUFL4nmzzrcgZ3NsHMK8DbzmI10xGvoVYR8OOWFwHc0r0NOTuT3o/wr4qsf5TUpbwifePhMQ84Q5DQAPg7sjL6rwc8GHKr7l36FTztPUzzgh0nQt4X+jPdLV2yDr592fBF+ebBreirXuYkeY7h/JaXfvEj/LYc/RsPviNabkPOG7gfwGQ+fE+R/Ib+Zek5CO7XI5yc/mOevgtidnXHqLHzzUz8W+l3o0xd9nsSuT/BfbuSfo93HIaceckKhP8V9oC71s6mvQn05rTOhfwf45aZ8BOU7gUXgl5rygZTvAm8Z/Xk4dlRE3invzavcw+BXHX2uUz6d8qHAJ4C1KS+geTL5BeRTol93+D0B36nwd4BtgIWYh6REr8rkp5N/A7ufw+62zN+2YUcP6DZA14DyXLpvwvc39C+LPrnRewH515BznPxu3V/RNwp7NwOzEp+1oP8M+p7Ufwx+fc2nGE/8mt+CX5H6adSvAebAvxdQ7U3m27f1RlL0moZe19ErBfIvIOeY92tbxi3wT0DXET4jiJvhwJ+BnwCryk/QfwD9RfKXkeOHTzXwn6Z9WmFXBq1XoscQ5JXBP0xPnCk6zgN+OvSsTD/aR5zUwb6CyC2LvLc1PpJPS/4D/JYW/k/B5w/4PA1Myrj1OvAN4nAP8tdrXYb7MCesnOOUt8Qv+ThjUp72XA2fz+BTBLkrkNsJ/VZh52vAMxrPkJcfujw8x+YlTqdhf3f871LeFj12A4tS/67WRZDXgfrS1D8LLKt1Vu93wwQn8tuAF4Zdc5CfH3mLtTFA/lvy0+FzA34vArfoeQL83noukT+pv+L9apz7CXoVpT4zet+h/Qsw3+4KLIGffsFPtZEbi9wm1JfSOiX427HjceSt1H2J8hqUN4Hvc/i3Ifmi5FsRZxtojwLIHwf/wuAv1/0aOA34HuXXKN8K/4/hn0XP7/hvL/AJ9HsSPvm07gjf1rR7efD4FZRTH7o50K2j/gvqG6LnFfTMAd4p4nI3eLPBG0y/jKOdxsPvZfxYBPxo8FtTX0zrqcBswPXA6cBY6h9gd2PsW4h9FaHbq/kpcBbwCeozQ58Z+QOQjyhnOfFVHfyPwC+JHmvRYxl6TCIu94G/DPy6lJ+hvBZ2H8Puech7CXktoFsC3ST4j0e/49QPo380gv8CtQftNYD26gF+nO5n8E3Ofak/+Vq6D4M/XOM/5X3pH78ibymFL1Jfnfq5wOHA6/BrBJ/awFm6z4G3QvMFPX9g1zXKn6Jemyi5sOc9+GVBzqfA6sBm1C+GbhTjYmHwj0LXhPaJAx7T+jTzlArEcWfyZegnv2FXdfB/RP4byC+IvOTIW07+NfK/glda+wfwv4cTF+n5ALob5O/it67gVQavOP4NZ54Xo/EPOzOgR1+Nw96xOeYc0M1GfjzlNdC/JPgpiLcyyMuIvPPwOw8/Lc0swa4vKZ9C+WPgj4FPM/RcjP+LE6ertB4Hv4Zaj0beOu0zkF8N/9Hw2cx97jHgTfSOhO556HLAz9X6Ivzegh+/wnKieU6ZDyyk8RW8DeDthk9R6ELh+yJ850D3itaByc8kX5h8FPmNgd/SLyH/jp434PuO+i3564pL/PIYfkmFPTu0nuG9FYJNM+R00Po48ABwI3gzwMuq8YrxKxtyPgWvBzArdC1ZTz2h50HwHiDnSWAM+Gmon6R1bPhMUjxTHqH5emrmlMQvIeasgN7H+LdTz13YWR4+49Gvi8Y74nwZR8Hnah2P/toQvN7g+alfr+dEJixZiJM3uT/rvF4l5vN18e9B5hkpgW+B1w88/SY8BDmDGM9fgP/XlL9FeRT5RuRv6m0O8B1EeQvK16Dne+hZAZgK+Cr6/4b+Q+j/1cFzKT8B3hDNmzHiWejHUL4X/5bQfQm+0+CblP7Wkfx85hF3sfcK/HdB1xQ/RhMXS+GbhvbIC7/7lO9Gz2boWYT6Jeifi3nvQvjMhW6S1rO0s0/5UOT+iNzm0BVGvznITYKcY3oOo78nId8Bvl+A15z+9gv8womXMZQfpXwL8bkXvnu8N77TxvBZoPkY+J+Ctwi9UoC3D1gSeBf5Pu3vQd8cORlptyPo+TP5WPKvAn9T/EPfg/H6BPnKlOdF/yXIGaq3g+CfTPDrjx/HaN0P+7/TvhntuknzYvrtVeobwucN6M8DjwIrwKcl5d9CF4k/nyc/hvxR8vugXwV9X/LbyLcDLgd+C11qPQej96/onRZ996LvdeRMRs5B6stQX0br7PhzN3quQM8/KG9N+XDgfuTfg38Een8J30jlgS2AxaFbCd0C4rUIdCO1foQ9u/B/U+S4yD1B/zoKXIX8Mfi3Gf6tCd9PoX8OPj+h56vwv8A4MJz6p6h/GvqLtMfPWp9jnLkFXlPwv4EuJXrNJh+i9XHkFkfuRsr5Na+zH1gKmJX6wfBdjj6X0acJ+a/IZ4Lvu/D9jnxa6JeBnw78KsAPyB9Dz5/Rcxx808N3IninoPuQ8pd1f9P8DH5rAvvcuZhn5KS/taBdh+CfF6ivyHhbkHlONHbnhO9L8O1AfylKfXb68VfEv8uJ4xTUT8S+k8TJDGAR4rMs+m2CbzH8kFT3UemPf48jfzXyX6f8Wcqf4EYfi9ydlC+mXEd01+HvGdT3pn405c9pvw35+5Cvze2a2FOV+vTU96S+IfVx6PUYeuUBbyR4fUHND5/s2tdE7tuUX1LcU/45/WkA96l8Ws8jnwK8E8CXgf3xV1rG5/fgOxi+R5A3GnkHvC8m6LmMZy31f/wZDr+h6NEAPe6Qb6b1DOgu4Y8xwE7Qd4NvJvi+AF4l8HAbb7bkPkXc94XPHfyVBL1DgDPopyGUt6O8PHrvQr+uwCq0w5fQj4T+FvrMQ5/dwP7AK3o+h24K42UkzvscPVz0KAt8W8+j1L8An3eh7wp9A/Tx67mB+3F11hNyo2cS9PyO+knUp0aPdfSni95Lepin6m056Fec+jDtY0DfFv81wJBLtP9570026Ilf1iI3J/xCtO6Df/Mj91vkn0T/Z6C7Cl5H+JSBTzTtvAW/NEVeZ+LmAPqWhv4T6vtTPw5+x8n3hl8j+PUnv0PPCfBLhr01gH74X4auvuYd0DWF7gj4P4H/Ofgufjyr9Vj63U/Uv0V9c/zWDr/l1P4W9IsoH0P5M+RT0R9uAadifxb43KMdG5EPQf9z3mF9nqtpn87wfYr6Ysg5Bb9J8KuAfTvkB2AGjRfgtQXvNHjrtP6HnBva30bfCPTtpv1+7N7A+B+CHqnBu4q8/MBInVdAbk30yUdc59V+OHRPQneH+kPUn6G+J34Yqf0b+KTV/IP8ZOyO134McL3infIw6HOQH67nH+hL6BwI9+v7tJ/Pe+MYZwDQdzD6VgVvBngNkTdP68TofQr8dND9jn7FgWnITwJ2B3alnXNpnZz8TPKL9VUL5K1E7lQWEVfDJxv89sNnvtqH8q20x+vA+4yTqZHLL6uddtiTB3vXIT+X/Isfz6LXXvht1HhE+Rr4NEZOSa2fwbcG+UbwacN9sxn0aaDfQv2X1O+BvgXtsBK5byI3t56D9RML4vZX7H4XvEHaf9b9A7pD8CsLv/TE5UHoIqk/i725GRdz06+6w6cqfGrRHoXQZ4e+siE76UdN6Ec7iYMXiYMh4NUHb4TWNb19F8Y9tTt0T2t/EL7fkj9IfQ3aK4r8ReTkAoZSPlnrkfglLfVD8et1faEDuonwaQ3fTYEz5ymo70H9Sh5cM6JfJ/yzCv0P6Asf4IeTf07Px/rpDPbsgP4z6EPxd3v8uxc5K2mHJdidSuc/gJdo7yfhGw/fxyAsjF0XvDeX0TehTwb9Pa2Pwa8DePmx7yXpAaxPfU7ts+G/RdRXwZ4c2JMaPXpq34iqdJS/TXl/zYfJb9BzjubP9K+ulNfVejJ6FAf/fT1Pwbc3sD4wC/xv6rlb83nyEeB10v6Vnj+I/5HQd9Q+OHhFNH+iPoniBX/0886T0H+wm1+gcZaI5zTw+MUp+xPMNcFLB59ttEc5YH7iqQ9yGiGnO3zrw/cacA9wKXSvQLcfvF/w3zuUD6T8tva/GDeKIvdV9PoJvlm0Xgx+KPjpKH9R6zrkZ+k5Evy3mXe/jj550OcT6u9Tnx//XcZP2cgPJZ8a2BO4FX/VpXw9cj9hflQQvOuMw93JT8f+PMx3FsNnA/lZ6LUaOe8g5zf026B1IPi0ws6N+kIM/ohAv046JwGsjp4/gD9Fz9fExyDy5ZC3hfaJpfw29FfRdyL2TQP/OnTZgcOAH1DfC7qRwCbANpQv034q8Gn4xAAHan0Bvebi1+7osR57WgGX6lwacvYipxH5BeQP0Y+GY0cf8lvJv4j+T+ucFeUjKY9RfyU+o+HbTftkeo7G/gLgJRMe9Q1ox1e07kf5PugGQ1dU+xP4uwN8V8D3Ga1XUz8LvQehd0vg48B6jA/nGB9+Ai+L/KP7J3bfhs8C+LyD3CtaJ6Q/N8ePS5H7HnJXgHedePkdvDl6boJ+NHIyYN9b2NeE8jaU14L/SfhHaD8dfY6DV0nr1uD1pj2ToocffhHwPcO4UI76d+DTnnxVnUsCbyn8ouHXWPMA78cq3Hf0hjv0qYF+H8MvJfiXof8EOBq6HdA1In4+wO4CzM+S0M4ddB6G/Ne0SyzwOH67Bf4B8E/Cpwr1Jyj/lXibiL0N4L+a8myU70beWvKr9AUiYG/qywI3UM8v4Z0L6F0HPdoAl2n9TuuX8P9F8Up8XgVeg+956muDNw54HLwY9BoIfQbi26d4pzy3zrPoHB56RlK+mvL30XMoeu6kfCn8pqLHR8gfDP4e+LTBv9kYVy5o3Z/6m+Dv13wO/crrOYZ8mMZh/NIVv/8aeIteBP4/o+ds6DPR7hm1b095efgUJF4eQN8K+sKat2k9Ez5FdB4H/Ajk1cEPRdAjG3rGo2cN8GqCNxG8rlovV5wQv8co34lePYAfUt8ZuRWIv0LoPwH9u4BXDn4DkbcL+6tTn0njFeXroK8E3vvgHQGW1/M/sDf5Aej7OHKHIK8V8qpBP5P6B+SPkv8MPgPh05/8M+TnAV8F/gz8VItFzOeTEzdJoesI3Qyec28TryOgawzdG8g5r3MW+Pt17IyHbiN0Eyg/SbmW9TvotCz59uS3w6eQ9gfJh2pfGTic8mL0g5/ge8l7cyVxxH20Jfebsti3CftKQDdFz0U8f6RHzjoYvy//4C8Xf1Uhn458U2AB4CHt19GO+ai/TpylRE535FzWOiL+SA7eefRsTvk3lKcif0nzGuLtRT1XUt4IeYsYj0uznrQLu76R/yifCf50+Oal31xAvyHw3w+srHko/A+i/x7oamh9CPwtij/oK0H/FnKe17os9qyE/ynqq2qeAf0I+v8x4qUl9mG+0xg9ORHNGgttDt3n0BXGT9+yXlIO/O3gL4RPMvTd4P0+ibEMfpm0z019P/TpRv06zRO1noM/tlJfgPwsIA867JuwXk37rud5ISXzhkvYdZV52vvU/47e+4GlwKsFv/O0w0L0ewb9XsG+rNg3Bb06otcW70eujBvgD4EuDr65sHcAsJnWdVk/OgX+p8wPS8Dna+QMI97D0GugfjKMnoukN+PYVPD6Uv8l/Xsh/JJRvgf5JbBnFLA/42o15GZEbj7uc0vBr075KfgOgu476M5qXQq/7Ub+Eq2/wmcAeq0ExmheBH4c/IpRn1rnReHXCX7tWTfZBb9i6DNZ+xTgb4TuLHq9Rbkfus6MA67GLeAJ/NEWfxzWfBt7MhE//WmPgfSHtykPg8+z8PkFmJ3yCPAWQleBdaza6FuIZrhJu4zXOS/meb8ETn9Pwb+5dG4Uub2A6/U1N/i1xo9+7ZN67/tkvoWdlbFzqs4L4JdKwP3yL/aM1blh9C+j5yb4z6aflIUwE/ZepLwu5T8DY731QsYLYBrqrxEPg8nvIT8CeAh4SesLikf4l2QcKkp+FfLXwfcj7F6FvLd1Dhd71oC3KnDuPRL/ZEfvbdhTFb2jqN9E/Uz43tH6FfFQCn2nILc3eiVFn474+2fkuLRPS+9oIPd++Q05VYEVad+S0L+u/qkv58G/GOWpKH8bfo/Drz7xHEo8h9Eez+L3T8F/AH4K+L8A/wPkS1OeWee7wF8b+AXkR9p/o1+3pf573YdZZ0xN/Sid38R/A8FvhZ+bo+8TOleHfmu0L0H5x5QvBh7EP9ORc0PzN+BY9X/vQD77qNDVho432znzoOuCnF+0XkQ+Wucz8eMfOu+Jn1aS30/5c8THYOR/j31PU58PP0+E7pR37ol40zqevuiHH4qQf0XPzcD7wGra/0Jv/Xg/Qu3C8+UD2mG5vhqo5xX0vYW+qdSvsPOI5rn4vTl0vaGrir45dd5M52yo15T+Zf0cn/xZ8grE48TLReJ0OnwnY2889r4CPK1zTLTHE+ClQJ8XdB6a8gbA2uhxD/wu6DEBPTJS34/ya9Q/pXUU8nv1vAL/asgfDmyr88rEUTrWY/KANxL+B5E7VPv65G9753cYA7VvpK0u/Nab/GadB8aejNjzK/6bgxE3KW+i+z7PNY8RJ/PIh5E/T7w+jz40pbNM55C0fgVdXupHaV0NOemAr2r+C1JV8jO0H0D9a2oP6I5Bd07n8ICz0XuC1j+AzYEf61w0dL2g2wTde+jTTeuyyI3VOXXwxoP3PnJzMR8arf1ePVfp+YL2P6NzHfAdC/0xzaOQt4F8V87hlcKOFeiRSfvS1H9G/RpgDv2ug/NctzSukZ+s53idE6BdMskO4FJ9TdJ7HgUH+u/QYxp6bENeffiXIp+e/CLytbWOBpxFHPSH7k3oZsD3ls59o89Fb77B3hJyrwIbwm8W+tejXz0L3krwTgPjqO+lKQb4k+HfE/7twF9O+bvAqzpPo31kxsUnyX+i8x6Mzyux4wPob+rcB37LrecXxtPK2geEz3fw6QDdS/irCXRfSQ521sWPHaH7Ebq2+OOqnvuon6p9J2Bm9DwFrAqsDvyI8irQ+eDbATtHIaco5a9SPhI+Pvg8i/zilJ9D7hbk+oA/an8E+XWIm560bzXtg8InufaDoTsHXTPwyoI3lvrmOjeOHzoQr2sZt6Jox9PeF1Q5t6T5DXEwG7kh6BWt53T6Zzv8sEPn7+B7m3nAXu9t5axjKM7x82z9rgB5/ZG3A3lroc8J/SjgYfQvhPwUyE+C/NOar1F+kvJO0BWDrhDzjG8YzOdT/zL6pae+j86vwG8Q/Fogfw3ywxlfn9NzrfeTJ+Y64H8E/jvgXQHvJHaNpH3HYVc4dpWiPpL6L4BDgW/p/Af6bgQ/r/oP5dc1D0e/HzQ/Ru4XGrfxc078PJPyEZq3Ma5ko13yIfc8/JdpfkL7bmJcSaL9RvhVEJ2+COGdY0SO1r917ga81uj1AH8NQ15D9OgCrOit37NurPOYyC2AXU1p9wFab4LfGu2XgdcIvM/h8w1+KkH5FMo/prwf5fHaT2bw/pryKO3Hot8J9DsM35Xw5SOZzMlDnWbgF9J5eeTU1u95wH9a61fI64O855gA1mT+u0T7pchpBX0FPc9yP0pLew+Evo7Wb+C/FP5Vif/6ZE5g73jsfVPrltjZCv5LNc+Efq3WnxknysD3FfLdyIfq/k08NUWvy/jjUOAVCrmhG6HzDfBPBr/a1J+gfDh67pe90I/S+AD8CrhaX3kAL464OUTczAMvDPqs8Bns7fdgF3gndP4YeS8g9236Z049lzMf+g68tPjhFnkH+yOx76zORetLt/q9CXzXw3d14KeXJ7Fzos7v6bkMO1NgfzXsn4rcy+jXnPJ0lMeg/yn8sxn5C3R+jDgqDb8VrJOlJx7fBf8q+P0pr6T9PeTO1e9NyFchry2G0cj7Gv2i0K8Ceuz29vnoe9pfYj52DD02MZ7cUPzrORN7WlC/BOLS4G8E/2P4VEOPzPD/HT34+Sd7c8wRtN8K/mR97VznjdHnsDc/wZ+KQ+pzUD9c542x5zB8yyE3H/etAlqPI1+HfGPgQm8dRr+e1fl59g28+yjrhOT/gG9r7QMgPwX21UCvo+h1Eby6Wm/Fjnj97kLnPxm3rkK3G7qeyK2N3E7omwr9t6JnZfDu6I34OjcGv3HwqwreEfzfDLzrWt+gPD/lH8H/rubRwI2a7wFDNe9Czl7sWo6cD5BzWedviItd6Pm41gno3zm0jkw/aISdizWeMw4+j9xxyD0En7LwmYQ+2RTvev7WeQ/s2oldK6mPoX455VPoj9e9LyhgH+10XudmkXuFeUtrYEXdn5G7C79nBw4D/gjMjB5NqS+t+Rr5l3W+m3harPuv1mO17sj41wk528FbBN5c5CbV/F/naYjvbpTX89ZPGC+BNeDzsc7BoOcP6PktfpqIn34O/NZzMP4rBf+94JXQcz72pWK+k558H637AH8AVoBfVp1b1XkA8Jdq/0PnKLRugx9qwTcrfD9An5ua59NfumF3Heobotdc+CRV/4ZuFX6+6r28iTNf0PXU7z6p/07rjMhZiJyF+ko1fh8G/U/Qv6X1Tc13wYvWeUHw2mvfiPIz6BEGn9/0uxj97hP/nwWvpofH3izwBPnKGu+p30McvAZ9L/CbIWcQcsqD9y712+DzCfpM1jwdeS10VA09n6G8IOVrtE+Gvcs5J5CZ/vwy9VXxR7TOg2sdEb7F4TseeSew56bO9yPPB/8naKej3Md8+GUSfM4wz/gZvlPhW4r6N5B/XvMv4vKSns91fgW8ythfHb55tF9PeVrKO1P+Gv0mFXAN/LcjrxD0H5OvpFdRwu958guI6zL4+zTtMVlxS/kFylvArxz8Nulcls7H0u5PUJ8RPv3QuwF0MdBVx6792rcA7gLe1u/WtD4An8expzP4q8HfQb4weVe/D4UuinxX5LQC/x50eYGLgGOR+7zOlQDv0x8mY397rU/rPsl9pifjYEnaow36dkAfvTKjF3RfgTcavDLIewt5qxj/l3n764yH8BsB7CB7qM+H3ILIH695B/TL9LsDff0cvg3hkxs+G4AfAI9i/3bs7wX+JvA/xO5i6B8Cn3bISar7h+wh39VbZ2Dur3mJvqqNHwpTPpHymvSv4/SvPujRGD1+Ac4CVqR+mtYVgQN1XpryGdqPQf4IPf8jfyjt2I08b3B1vgEvpdbJwZun52bgdmB37dcQj4WBi9HnafC+hF8aYC+ds9V6HnFRFz7Z9RyuL6xr3Ur7ivodoPcFbdah4Hdev3/T747hUxW9D+hcLHxe0X2Aqs7MFz6Hz2D46HVobfDfcdqlNUw6Yv+P+t0A62JZyO+H3/e6v4CfRudw4Pcj/MaRb6H1eOJ9i87DaL+NuFyI3G301ynwOQufMfI//WCtviCv86n6whX4/4er+wD7cmoDAJ6WIiUNSSqViIhSkqQyQkbSUDS0J5WK0KBImrSXBhVpDxTJSEiyQyozskKRkvH97vfp8X99XVfXec85977vc57znOf871OWHPPx3as+V30sPr3ifQBeAXG2D95+frvS+iQ/PWqB3xLvB3E+mZ3Ooc9o+hyt7Kx8VPlP7LujUwOdWeqH1E+M311FfGs/KdY75N2G3yJ88sV5Le1Fw5/gy8T3Zc/BMsb96er3Z/2u3RwW59HZ9y92ezd+n8PeM7Uf1F6DnGXjO4B6NfQW63+D/kXVe8U6KfZh6HGT58TPsb+vXsT6tAU5Nqq/gP8c/D+EdwG6HfF9MZ4LylbBP97/43dP6o+p/6RsGL/DUb6jnjv2D/SX4o8D8Z6vvX3si8b3TvPGO8pK6J6KT774bqn/7DjXDL4g/40g565Y13rudCF/N/0b4W+P9xt4x8M7IJ5ma/8z3i+V+5Q19W82nr/IunnGszj2g+h5rrIke4wQT9fy9x/oN4vvYuqV1OfjOyDWxejMRaeiODsG/TgyPASdS5Xb41xH3ASv3AW/HvzjlLfEfi15xsZ6XX2lem71XfCn4FsmntfqJ8bvjdE/Os67Kz9A/Ff9B/SXj30V9jqOP9+PdbS4fC+eQ+A+BPe9sgG8l8DljvOr5Cus//Os23fYMyvdoP1EfK6P/exsqVCOcSrFPSZWF3HPVpozIdLm2RuM32fHWQ2//IgzwmmiqThH1xpUpC1c6u8KkgUGl0hPWDvXlCPyZN3/k8mlEaNm+OEME92yTowknMr5f1HWV+mikgI6PJvslmXlfNgF99n4/bV69aykMQ8c7t/st3Nxx1Ds9nbKUkPi6ayEffn9+inNAlHhcMKzJJlMJD2Me38igV+qeW7pHK+VeSLSgTz7b/6Llln3qyb56AIyblRNLwGpxhKP+uVcXr/WzJeV6ivutYlMYmVwOzdL7jgPERmagmqkzpNsbuOE1+TFCSKR9e2krFQUVQ4LN5nZI1/K1VlpeOL6pOR6oTOz0lnUzfqMFZvacVlrXAEbF2UlFyAlN68k+T1KZ11kFVdblTlsXJEQmU1emoj177IAZZJFlTicUy4y6bSxXR3coyVUmXq4J7LqFMjxhLa4LKv+v4lkIqtNkqqjRhZe5HNMM9wlqUDiEq+oJxc5xaH0NN9OmsEmTeYU5ovEbZGGLRIbhb5x6KpVlsOq/Ju7J0lQVNpGQEIh0v4dfZh7GmBnZV3qlmSti7ODHu2H809GrpRImhSJyZJMYPE/DvEkKbbS1FaRUsoH5H/TmCWJSApn/VU1K31IDIjI0pakxUpCIignl0udi2NygVPyr7yALJElY0gYfg2oCIgz/s3Eki8ri2OEe/msi7FCwiQvZUIhkxcy0qq4PULZKiub4hnaIw9hvqxsbcmgTFKoRUKtVD45Xl6ayv9nRJaU6lk5W6Rc/lfIJDdN1lFLxE5RPz6y7h0IlJE5ozdEjRvY0vw3IViSjDJN6VgFXhKwaX6cxGQBWezfzGWJgZPcVbnMvKWykg1Gisw0fVvipCSPX5KGsPy/WQXT+2iOz5KizuFsQEdmGT5JexMwkRyzUtaoSyhGprKQwCmAww49JYtimmUy0f9Uhiz5781Z4eJyWal2CgiFkCaMW1LirhlsstSVLElKP9NrVtLFuAMrSaYYuSoTN2TugUlvv0kDJUlFF8kdk5vFEqvGMAj4yJqXyWEZPUnmyzRAk5R+9mAPa5hc5JS5LyhNWxdwSX5F7t84k9y/HJGm/8ukmErTBIZPT8m6uS3m3fQ2mvhX799LmJIbtdKhFgOrtv+JbQsftmd6h5Hn2OFEo1bpYDP3BsXUkU5DYb90cMdMGfZP0oKlGiTaR/LY0DEZ9kf9m2y0xb+3kUWivaQtshOmaVNlrdowi+b3HL41KM0FlF7uFJJENtHwSxLZSZ6hJJNR+qDLflVO0az0jGnSwUwqvzSlaWKFSCaaZkQMrCKR02nLbJLs80xMp59I6pXkU0uyEmWu/kpSYx17eNL4/0SfhUBXyJbTKMmgmMmql6Ywy3v4yZUmkUozWGZSjYX+aUKo/95blNx0dnyWBMn8kNwrlzcrJpNYTcbx0VkTd5ruK/rTTEypL3nh/bkRf/HF5N80i4k+QTOXWAnZ0ovFwgfx6Elnk9gE820yW0atRJPICpvkn0sS9SY5tZLsfun4T1Ly2g77T+q08FKkaI3e0CXmpIy304k/g5G0JilT0/S16cVLaRrmJBlXMoKT7IyZe5+SrGBpArvkwRezS25yZrIXJvkKw6ppotUkt9VJ2ZLNJVSjL7VP6J1EXQKfJMBMc5q6wiKbLV26cVjeNMNiMq9ktEh8E9lYk9vFIpIjiqI1uRkwTf6W3ASYPPbSOS4zyyW84oKz+TyfdUddmhSsQtaQSzLUhjoREpGKNUknVvbw4E6zd2ZfPKZZTYsfbjktS9lIDboAkzzxLIpHXVTcveFWk8P30GVlBtwWzQ4Q5D8scXLtXfb0g8ny4L8ZZBOPJ6l9wwOuXFIGVDLGExtGeuA0x1uMj3qvPY7ZVG9cCXayCky9mtw8lqZli6VT8lc8B5N8axHVmaxzSaLgRMY43ZjMihHnSUwl+GHK5BkesVjocPa85P7ENH4zFwvW2/sECWfGD2qyUo8WyVpOZRIdFsjikPBNE31ncsNFrKfZeRNXZG6rjFhMn35JS/LMKJQlcZKoO3L7prokK4PIO51Sz8xFmVk99VNEZvb3lvQ2ubBaPE2SJ0dy01pyvWF63VnRw+lak9VL4SyvpPNrmo43+z1vaSrvRJpjDy8gk1VMesFgcjFhurIJ/ZJU18mvkNLMijGXJOmz0+vX0mybabLGJAIzIz6ZOY2eKYsPx1HCLdEm5thkvZAmA0xtkv/fVIeJJ9M7/LLH8wn/SW6dXJOYmYEy6WmTVVfoksnfmibKTe8aNayeX0JCNzKkdymmD6Uk+23qoCSpavpKmZla04dYghsKnpzFPp3QkoFiQD2+FJuuSTQmwzq5lzOTUzBZiWZSJqbTRxpBSRwk75SJbxPrpSuTXFnRkPqs3rRlGMZ3iX/fsTK6Zc/AnVlUhJ7pTZvxQJdY94sgIllD5l7Q9JmRyp49GWlCsEyOejOWQ1ueleA4zTObmCEVIX2KpO+4SSrIZHJM8lJGyu9MfsyEjit1/vMUTPI2ppdvJpaIFWIy6pJ1SRJF6SySSTOaRE7MMmni1njC1du6guSfZ2VyTCwZa5U0GWomutNU15n8mol14szW/6+Z02SraRSmARVeTiyT5A5PnswZW2auB83ONb3nNnlOp3ZI7JKubf97Z25yoWkSVenq0MjcsIqmWSnzkxjXtC2ansyaUpPlZZpzM02TnVy0m+Z+TVNXxhI0syTIJKlPzZNeWJkxS7qoy0yxSbbxGHNpzv9wRyYLaHqFbuZFKpROhlC4Jp0IE3dmMtGmecHTtMOZEZCkbU5dl07eyfI/SQ6cuXEyXULHu3Ua5pk7aTO577MP6MQSIWEGJp0601ekTGCnSUZTCumNA+nDNn2kpA+rCIOsJKRjnuEz968W+vepkYnLyFkejOLG5ExrZmWWEv8v83pfBMnI7Hl4cCXLv/ThkhmAyYPLNdMT1kCYmDVo/t8G6ct2Ytc0K3HyuhR7GukwS7OOp4uMWL5lUuUnMZWkBU8nv0w23MzttukFz5lHHHVWrI2oJl2aezmTDDad1dMoSWIyib7EP0lW5lTq1MDJ9Q2piTODOXO5cppWOjMMkzsNMql5s+f6TbKnJ5YIXvV2P0vmOKSfLcSiI7mEJX2mp5lr/z9HLKUXPodA+XRN+v95hTPX4Fpubg1QP0xPM8+m77dpUudYZaTrqnBjhHH6LE2iJ7Ou8qY0fx1ynx6e+5N3rCT3eGriTAQmT/w0P3iamj652yCVIXPbbiZ+k1sxMhonT7xEzeTJEjTSW4czmcdT7DSrcWZ6SC5eTp8F6S0L2XdYk8ui05zSXDRuPT0jn8q/t1Akrsikss/u50xC5Uw27vTa7oxaaWbpECR99U4WfClWIoAM7ONewH5s1lydSeSefVmZXmKcPCaSeE0eIOktH8lrehoTySIwk588jZr0kuL0MuFMLub0ivd00yeznE1jLR1F/5Uwmbn+/3qEJADSzaFU2yQAEmen9XTZmj1feGqjzNyQ/QLqhG/6ypL6IpP8+r8vwtnT+wenZJMj5Zk+XLNfTB0yJlatt+hlfnmDXzKp/rNnX08e9ZlQjuVKCpXMeOmTKHONfDLIsif6T2a9NDt26vd0CGfu4kmvlcnkaE/yzGfP454ZUukMlFojk6Y6sXCaMj+dcFIbZ6yQ/eUjfTHPJBH//4TWaZSmN7hk7gxJE2Knz5jMNJeRMPsiMnaMQ8L05TT7DdMZ72bPYP//lzFkj8Z0Wyy1b717X4295+zTZ/oQyKiTPNpCiBC53jOBMjLrRork/SkdEOkwTyCz72Umbz6ZCTpNSZ8Ju/QRnN4KkT2lfzLPJY/I9LKU/8+Sn8692ZcZmcz5GbdkDP/fGyyyX8GfWcj994Lu7MMq8wDPMuPm19nEL4Uzd3r/N+f+/1/PnvFO6v94iGSW3tlx6i3chLifd2be8DKTYL3N0ekGtXSlm3n6Z0ZD1lphfwC+4cNwejdB8sxPZ+rM+iW5eD17/CRb2On9ONnXjf+N+cwoTcIhSbafGYcZFydOzYzfxOUJx3STOYObOjf7XJi+cGQPgESq9H6ljFvTsZsZP5lZOpM0PzVu2v//tz1kfJU+/+ptfpNNF+/99/ajjBAJUhmfTY/0e+WzlSWUsyWnfc2Lyac+d9Q2kTb929kPB4D6SHp0q6sbGynzK1+RvHWihCWP+9F6f+dRz/ep9pbIDSUZ683OD43zu5fIBzbCJ9bv5Ceb5lBuF+cEnwYf51e7q5+v3hu/jvjN9h1qE5kaSK76s4R7x+Kz2IHsnehWcmX57ZFLy9ekK36xo+mHf5eBnw3+Rv3xG/QCytXOWgyOXD+Rs4t8G8j3NX6r8PtMfxU/cFuEflNy1Yc/A/509UvU7yPP9eT5mHGuiJym+C23bL2X/sUlcKyt/yj9j8N7F95a7S3IeYb2g+g/j/5O38rr0ydylwz0ZXYr+13DrjXY9WH2XOC3T/vJswH8NfoX6F8D7/3IrcBOp/rm/gl57iLPP+i+gV9u7aucqXjYb8fakqc6/fPT/37fAh+SEO5s9j6Xvb/e7HwDvKnoDUEvD/tNZr9L8Il9umrKUcql5Hb7a45e9DvCDNkP/o3w74UXOdQmqt+uPh/cpeAqwBsI73rynEyei+k/k/4v6b9Zf2188vghSjd61aJXAfKv1t6D3tfTew68W+G1Q3+/+BiovyI5h7LHIP5cwF5b+f8E5RPsNhW9neKrIHo7+e9I/Nvif75kLR+gs4c9bvNDp8fF1wp0+qNXRtkK/cg1dDm8EuT4CN/Hwp/iIX7jsS9yu/Frf3FxGbovK8crJyk7Keui8y25G+A3G7/ryH8++TeSp6Prd5ejNxi9OfR/g/571Neq51W+j98D+N6gbEm+2c6ebFE2ipxp9NpEvzr6C+q/l9yjyXsBurnY7W/9I/hpOH634FeGHK+Rozf8FyJXcsT1kXlyHMdfw/n/Z3jdyXMnvpfj/xa4xs6c/LogyZHamP8u5b9J6A1Eb4ZyqLIWul+iW3avfCHi50X+a6tei1xHkesHcrQjx1niK6cfiF6hHjkvcinv8hu575St9T9DnnfFyVp2KiL+XoM/CX4d9L9BbxO6XUP+OLscdz6wbxX2FZ5ZZ0iugDeXfXuSqwm5HkVvsmtm14iH4tqX0ydyYfZTv8Z4mU3ffeJhFvqXs9tT7P8Z+49FP347fR86PdAZCW4tuGns+xi4wsZLafYqg/9+/Uu1r9E+XXtX7cvIPSj8gd+X5qc1WdsgPpyz3+nsdzp6n9P3TvJFDsOp9H/a6ZYB2ofh09n460P/l9B/mH7PozcKvfLs97WrhFeS/yhnhFbz01B+egr+r+z5JHlHkuda8fy99pWHX18b0u9XdluK3mD0bkX/TvR/Z89pPkfsJsdF5q9X0DmOXHfToyE9arLHePgj8GmO3uXo/IJOf/JcRp4B2hto/wleF3jv4r8E/wfp/T2954G/hl3OpPc59N6A/wT8PwX3LLhf8W1n/v0OnaeCvvp8Z7iepN9e/vlYvbT+b9DrYVx+oL0qP76gPEm5BN+v6H2y+B3vvbQl+53Kft8KiA/xLYrfj/jcT44q6seDn2ceeBFcM3FeGP3Xzet9tHeOnMji9zrx201/c3Tu0H5bjC9wQ8nVkJwnkPNEftjCD0+r36d+A30uwucPcdNFPK9k18bs1CbOlMdvksVlOfbeSI4e5GhKrlPY4Rx8fmK38/njEv1vgquonKw+S/kW/hX150RnCv/cot6GPDvUT6fHZPw74v8hf8zjj7bo50f/de2Ttd/Pj035Ma/yBOWl5DyTnIP0XxV6qOdSPwrf9ux5Jbnfl+Clm/I3z+WO4KqBG0jOcexxEvtcxj7P4jcCv8e0/6P9XOVv5DwO/2fpvRG9MuTPQ87Z5D6R/yvw/+f8Vgefwex5cb7cOYagfw36ndRzGqc7ybOWPO+CqwJuGjt1Y6fLlCWVrcn1HbkeFZdvistTxMXpnmsn4f8q/mvJ9QC5lqIzBp1i5LgFnSL4l8L/M+3PxXzlg2018s1A7wLydsavmufVa+BP1v4xuNWxbmHvyCU5AH5r+KPwWUffN/G92rzYhH7xW5FtnusNzT+74W2AN44dzueHcfTqZnzfQv465N8hLt/Q/jh6w9BrhH7kAFkObkP89hJeH/1nKN8n1+XirBR7L8L3ePF6O/je4Pfif7vx0EzcbxT39filS3G/wWTPU9mzGzmuI8eZ6ofYI6fSTcY57hAHDcTBE+g3xqcO+sehvwT8aPA98GlFv0Xms6fiufdkklP1bPJd4fk6m70uItevkjHdD+86elxCj+rsngf9iuSLnJJl2dHt0Tmmqa81rz3DX1/w1/XoH4f++fh/gU5389SR8Nuhu4dfS5EjNznWwvuTng+o36reGf4LWbe3ORsJbpX+n/XPYNce7LpOPSf/l0H/jZiHtM+N5zu5PlROxq8ufXqwl9usc5QE9yK4ZvjvjXUjeY/l95ni4DXzzh/07Wve6UO/FuT7Cv698N9D91H0Cul/0bwxmnx9Y34B1zXOtfPL37lz5zifvY9E9yr95+p/A/6t8Aeg3xL9reJgg3o+9l/gzaYXunXR/UX7p9q7snvcHXAbvFLqdc0HDcnXHt+D/NBUva16HfJvw+dZ9tkVL/H4buWHdeC2i6dO9K+h3kmcxl0j72o/ml5HiYOT2OE4/Feax86D/zD8a9FtiW4V9oxcO1XE1Q383Ip9nuLP9ezfOp6/6pvUz4E3Cl539Q3qI+jbi76b4Zdl31roXYpef+2ttG/SXkr7EvJETsJF9L6b3r965+ge57/o8w59FrHjMeL7D3hb4Z0Ibp+yNHu8iv8pyi3K+dr7w89Fn+L02aN9JHvdzg6XotNU/W9wX7D7ReS7F72u6AyOXJj4fa39Yu2d+e9a/rsLnSvR6Yb/U55ft7LfRex3KbtNZ/dm9F0K7yvyR671u9Frj94xyt/wHUi/geLyJv2RO6o+u0xHvxk6FdG5EP5k+M3Z8UtxfK5yvXIKOdaIix/J+yA6l6EXeZ5eibtgvGh9hF7c5bSAvrfT96B6R8+Zj9Cdj+778PrDexO9HvSdSN474o4C/Vfqv5I9SrDHPvUX1bvxSz9+uYC8cRfEb+LuS/hnofMh/BHoVPBeshSfyE39Or5T8e3ELivYZTg7NWOn9eScQc4v9K/Q/yU+S/FpCy/ugCoqfi4UP59rX6x9p/bIkfgFPoPxqxK537ySN+b3PfrXgntA2UVZI9Yv7FeAnPfyT0f+Gar9Ou3z4V8LfxG7/cZuD9NjQeSEDn/G3RTgh4AfCe5ccGuN93rmz0Lk32p8lhD3r4j7asojyTcK3ZbotmS3yDl9CXk+U39B+xhlWXb7mX6nofcO+9zAj8v58Tl0G6B7Dvg3w77w2xhfY5Sd2P8L/DqL44FOfjYVB9XJVZNcXdnrfPTa6F8YuRbB3wTvWnQfR7cWukdYv88wD88nf1523qPcyn7xG4xbHRVuhl5u9mmlLKb/L/2/8Nu4eG9UL8Iv+8HfJE7msc+77HMEfd7i/yL0eA7cCvy247cI/+Wev13hNYI3jFy7+PkL+JFLt5z+4uK/K/q/itez9F8aOYaN267w+8f7L31bs9NZ6E8SHx3ExxB8KpFrCrqD0a3H3sXYeyL93vUcGAr+evAH4fem/5HorvM+ul37Qu3N2KkiO03HtxZ5ryLvfPzuos8A+pyCT+S0bY1eNfTGgasCbps4OC/sQ/6Z6L6P/rHWIZ8oyyuPZoeP0R+D30/0nKjenv8egBe5I8bh31b/DOPkMfH3JX6NzFv16XE6Pe4lV2Ny/Q1vE7xL9cedGnfQ92T69iRPW/JU8LyZwg5dtBfWvgvdlfE+D38M/IX4/SR+d9jljN/qd0e/Mfq/6H9R/8fG5avw8sD7IPZD6BO5U95C7zbtR/N/B3ruxa+3xEKFwH0K7g9l3FtXB52i6t+wy/3s0o+cPcn5Lr/dHJez6z+E3xTwXcDHHU+F4jfj9PpR/RB73c5+T4jb+2J+VI87nc4iZ/FYX9BvOv2u1L7oyLw5ZsDrxh5z8dmMz/XGxU/qd+HTkByFybmUHZ8CvyXuxuK/y+E/Ks4Xx/ORP942HnrTr2S8xyq/Ivc/+H2CXy9yNCfH81mfUHPluEt/BXAL6HcZuHvYs7/3/kfwuwW/BewVdwbugL8GfiX1+M15D2XcyXc6Oc4U1230X6Z/N7lbku9ycTaXfVqT/w/y3yIOBoiDk9npF3SrwWvqfeAdZX7xVFtcHyuuzyR/feOiDDqrzasT+WcP/3wFbwV7vso+E+N9DVwp76EllH+Yjw6yy2jzyDx834rPBegutb7sQ4/6+LVFZw06XbTnM06rskMNdtgFv5v5ZSL6HWOfTPsF2j8RN6+zyzns8pzxeqL+79E5Rn9x/aPR6cD+NfA9GPs45I0cwMeQ7xN07o55Mk+eHPvY5S12OQn//vhfYD7vQM+q6iPVi7P/enYfhl78JuU8/W31HwvvQDxP4r1SXKyixzD824mXr61XF6sPVH8H3GL067NfcXhj2HkqO/+B/2B6faJsq/ydnPeJ73Lk+5l8vexHxF1u69VHs+cl8K6Fdwf4LeLnBHK9RK7m9Ioc7OvIW1x/YfzvF29jxNuUeF6S7wj+myZu1huH7clVjVyd4R8b8xa8X+iZT/uX8TzGbzx+28RP5Gqeqb0n+Ob8tozfnvEecJlyJXkr8+fF+EeuxkpxGRW4Z8hXlt97ql8Y+0LoFUTvVfXJ6mv4ZwL/rOKve+OeHuU72scYJ63IPUv9Vu138Wt+z+fIEXuTcXA+O54c7yvkHUHea/GN30w/zC7T6F0f/ePRaUSvg+yyCFwe7X3RuwS92uzyBPqD8Lla2Vf/m7F+R/cedM/D7yVx1Bi9VvB6olOcfZ6gZ0F6rqfXWXEHBPiW4MvHHX/x3kC/v9EfqGxIzynw6sFbxV472aml8bVfe2N4teBdgM9GfK5WblMu5pcD/PKleH4HXpmIf+Nutf4m9OiC/3Xm2dXgjrUf0p2eF9Dz7viNnfe5r/BdFu/B2pvFe0LWiWTw6vepT6B/B/I1BVc+/Kp9Yfhf+3nab+WPZvzxEf1aicN+vlBEju976XEGeWord5FjDv7vk/M1dCah8xF5N8a8Ta8fY//DuGgmvruCP079IfE3XdlEf216F4f3VdwzSq+l9O4av10P+4H/GP1uxscZ9s2WghuI/lRlZ2XVGHfGV3X2HMeePePug8jFCO929M8ndyfz0cniYY04PBvcSHD1+fFqfrybnz/g55vJcTk5rqd3eXLUIMeL5MiL3lzjIw86T3suD4gcePHbLHgt4N0A/jTwb5FneuwTiJ+rxM8R9K1O3lLwjsqTO8cafqojTn4Avxb8B+Spat65ib0rs3c9ZXHlI+D/8Txerz5W/XfvmSPY7Xj06ipPwOcb+Avo8Q491oAvJ+5u5O8PzCunoBt3O/1Jn4/oMx7fzeKjK/9U91xfH3dK8N88/cNj/5Iev9HjKvYtR979/PZVxDW7Ri7UXPSd5vnXGt/KsT9NrhLkuoAeR5NjH/jPY58JvT+Vn2pfHPNnzOf4Pk6+/OLmLfTysOOf7Pq4cVsWfD78rwJfCvy1+FfCf4P6w5F/Q/9P6C1UPghuIr4d8e1LnrgDbzp9XhJvn2h/UntN+xnnxL6RuJoT30X4d4L6kexyN3+04Ze6sZ9nvL1Pj9vp/Ta9x+F7Dr4Pk3Mfu3cG/4uvOV3wvTbywpPnTfI8DP578AXpsc577yz2f53956pP8DyaR69LxOmJ6OTl75+V/ej9MbvNw+9Y/Uti30ZZP+IZnwPWGY/Bnwa/v980XRc5NY233sZbIWUJ5cn43onvEfTcQZ5jyfMZfT9DvyP6U9nhOXYowN7zxNOF9Ckc32/0j6BPCXRORucscRG5IPqCbwj+K357l52uZI+vYxyJrxvhDY278dj3F3Kvi3Z0rjN+Sqv/wA6PwH8D/kpyvyY+yoGPXALFybcn1oXgGsH7WRl5K0bwx3h8+hmPpZW3oRe/OZ/KP3P45xT6DaJfUXTmi48G+h8k9wPkHW/+nswPg9C9j95NYz3K7hvZ/WL0fmDHu9nzaPGUH5126JwA/gjw68GPjnGmv29870JvMv33sVM/z9H22n/ij8L47bT+WI3up+iO1l4Z/HR07kVnOD5nRx5Bz9u4W+FCfCbFuKdfxXi/Rq+EOO/AHn9aR1WEVxDeD/BGwGuNbzX7P5Ph/QyvhvZP0f+BvZ7jxwH6+0UOHfrHnc5neh+swL7L2PkI8VCOP7/0nnYW+DyxflR+h/5vylfUl6N7FDsuRPd6/Cao/xjrFHiF+PN6cOXBnU2vtfY1Fx7+GLoT/QvA9RN310YuuvgNeuRmJs9N4uhWdF7Tvy72F80vLdVXxncudhoT3wci7x5+y9S3qb8N7zR4o8XbreLtlthvMN9Mwrc6fUeTr0Y8D5RL1Jtp/4L9+4qDweRvrmyn/I0cLbyvjUSnJzp9tA/UngveorgojH13o1OcPLfG/gs//MPPD6F3tv77jPMmxvlv/NHRvDVT+YA4PU5812KPTvCvZr9S5I0c8BcZh4vAn68ed5hUQ+8Ifv3c+HgLn5vgx13A5cBFTrlfxEHcbVFSfH0X+xDsM8g4HI/uneg+Qv64U6IVeufwa3vj6x/0xpOvKvnG8kcbeDPx6R7vTfRrRL8G+t9mj0fY8zX2PAH9b8HdjG/khOlB/2LkeQH+uNgHxidy416GTlF0ThCH69n/S+uvZvB/xb9vAXdZ4/+X/ifQvxz/HeCfUM8V85b19Q7ytyP/MO2NtXdQX2b8TcanMz7v02sZve4kR/F4LwTXGlw58ryB3knax7Hf0eD2ka85fvv030G+uJOik3pOfuxCn5r81IYc39OzFzp14uIi83YV+v+E33r8/oIXufO3qy9S74Vuc/zb0ud842in8hJ6fgMu7gyaLQ4OioMZ4u0V46YJPhXwGS4+HyJPTnqOzZsnx8fwasV3Bv359Tdmr0LG7Qr1Ieq9473YPDyGfGfGvjO5vyLfKnq2QudPcJvAzQ564Bait51/z1FGDoSHyHszeR8i7x2xjohcBnF3Lz1XxH4Ov77IL1/wT9PYP1M2V94J/mbwA+FfDb+qcZtXnO5X3xjrOPhXwr+JPAfiHkpxfIHn1Vhy1STXYPIWNv8VNF6OZ+fd5HyKnH/Hd2rxvz/2Ceh9Hn0PKaFn3Sm6gd1OYven2a0o+/3pRwvDybMMXHnrlBrkKh3zH7rd0N1vHfIAuZrAWwz+aXT30/8+fCI3+Mv4xr0nR2kfyR7jxdGv4qgi+X/VvlX9RnF2Avg9efPmWM4+peNucPpWoM/N7LMW/yvRKQl+G7z5kR8c3CLPhbzgHrVPPNn47hjvy/hswX8D/dvz15foVgfXHP6p8MeSvz/5TwcXd2PfyJ5nsOeD+lvqv964ax37f/SZQJ+n0GmKzmPiZgm7lmKHV9jrH/FZK3JVsvfX+ofgfy3+7cX9t8blEvhHotMCn0rkWQHuRvjnxXtb5Fxg33Osw1toz6m9C7jrxPGayC+vnos875HrJvx3GxfT0fuVPB/SpwR98pNjFjnqgSscF+bGukr9gPpG9QnoLxb3Q+B9HPu4kVNI3M3BPyd7j1L+yA8z6FGDHofY9dXYj0DnQfF/c9wdHndCkm8N/QqRbyJ71WTvAvz9IDknxHugcq7ySXJeCa6SuDgzvuMKqOvBNcT/Mfy3oj839v3BfeR5MxPeAnjV2bsuO+3ilxf5ZTK+cbdkHvDv0eMXfHvQqwW6l6N7hXh4VDzMA3cseUrQdzc77VE+B36R/q3xvgnvALvfDS5yTw/G50F8PkN3ETmq8VfcpdFI+42xPgS/nP3fJ99t9HiOfSJnerW4AzpyRNCnr+9Idfg3jlWPRufG+E5Iv77hF3YaEPuM9HiTHgWUv6q/i17v2H9h1xnsmpf/ZsUd5fhNJV8j9VesD1YpNxkvRePcjnXHS8pz8d/Ej6eiPwX+J/APxHkf47evuL0k3gPweS/WQeTYCe49dM9ir2H0jruiP1fGHYY5we8E9yN5RpGnDzoV8evIXs+zV2X2PTu+V+l/Qby1ilxlcUeJ9rZhd3qvoPdK/B5Gpwr5LhfHr5CrXcwL+MfB3L74d487O/DrR74WcZcaOg345/j43gK+IT3m6u+jfxh63WMdDy5yhh6n/Xv1IfTuE+dU8MknXp+Bf3/ENX/NiP0K9v9U/Xh67DKPz5yf5Kh8jfyd6VcX/LH6TxKv71snvUmucuxSNZIU8ls98+aOOFeCX29yrGSHHbH+gT8Q/jfwV8MvRa9+sU+Fz3nxnVl7nTh3In4f5t9X1SfGc4P/D8HLyU63xXdE/Laxw5/kv4f856PzMDofo39HrHvoG7n/y7LHm+Tqxs6NY/+bHC+R42ZynUOua7VfrP1Xcr9A3v7w/zF+puM/D//T0Im7z/KI5xL4ViDPr/Buh99AuR38XfjdCL8S/DXsPSW+I9Jna+QsBfdTrHvU/xaXe5SNxNdF7HwlO3eN72KeawfwaWf9tcf6Z3t8v4XXFv0r2HEXui+qP6ReUflXrHfw66F9nvI25bvs0JwdKqv/wV59yHWIHsPI20T9K/6uF+tI9Vzq4+jTmj4fkncleg3RLRX7NMqTlbXx/QjdV+K5QY+H4bULv+DzrXmtOPqrxHET/MrFOQxl3NdcmJ/Wssfr8b0Q3uPgGqifi08pfIYqu8Xzgd3PYvf84FfoL6V8RfkiPmPx+ZI94g72x9T7qt/E7x95z+4I/yr4Z/B/1h2n6sPUq5H3LfxHku8H8t2BfzV27YL/PnIerb6C/duDvzLOHSj3xvPGvHNpfIcmzwjyXIffyfG9WpxsECc74J0qLs83j1flryPIuZCcF4CvDb4A+O3s9Rp6j8U4018H3ZXsODT21cTlcfCK6D+k/X12mh3rG/44xnvGg9p7w6sKPj/4u/Rfob8+fXYqB+hvq/8xelyM79v6Z8R7ND03e5/7SbzsQLcRPYbQYw65BpHrafDNwE8S/x+YD0orXzcOxsL7mX3u5P8r+P8D+3id4jsqPQuz19v6m4qjb+lxP7qbtf/Djx+Qbx75vkN3BLqfKQfHdxHylCSPaSArZ9Bsfos7P27gr8389ZT+Yfqv4a+su7z1x50J3eNOlcgNRb+x9OtoPPRipwvx72Pea4v+D/z2E7gGxsX97Pip+G2CTuRyWmJ8PkO+Zvrjbq3v+WENv3VktyPo3xu9u9H7hJ1rxnlFAlb0fJkUlynFdyz26MQud4K7D1xF9ruW/faSN+5H+QafG9jrjZiH464M+N+a526Edzq8PtpfYv9p5NoX+1jaa2vPqXwI3pP8cD85HqHHhex0hfJd47E7OS8g58vkKgtvDD6zwi7suyzmI2VZ5W3sd6R1fzF+eB7+AHhXwOtMvurk28IvucTlEfi3ROcidH4zHsqR6+S4mxp83O/0CvvOYd/r6HkTPavHd8LImQQ+cn49To5v41wAvvPxXXv4t9d94d0Y4wS/j+I5QK9n4z0TnSnoLIgMPcrjxVGZuBMavbFxHoqdPmOnqll5kbzPxs+PrcOmw3sU/GX0+SnOV6o3UB/IH5EDcAK5+om/xviVpd8g/DvG+7zyNWUneIX4+484D1TwuBwbyH1ynGfU/gd6xfF/lD6zjNOa1ltHgZsT5/rYvbn+6uSYI947RjzTPxc5Z1rXDgI3PvZx8ZmAz9XsUJodTtH+IfwK9DsZ3lv4VY7zX/jk0/4iO1e1fiiLXgHnGIfFPhA6f8F/M9YNylfjnC75hpG7Fr3y0WsMv7SOOCVP5KR9Fp2K6Fwu/gaKz9bad8ZdneafJ/hhL/kfIv+l4B4wbk8VV5VjXwm9P+O8Lf7P25f+VlnPc+UGcDPE5YY4Nxp33Kvvhncs+jVjnqPHIf7uaZzkR6c8uBPY4xvlheLpdfy64FcZfFPw9cn/vfqzyg70OEm5UX0wOUvz6+f0WUqOBuSqg9418D8xbn/x3jIUfjF2fk48bBAP5e2AdGaX82L/BJ2WsZ4jX3/zTRfy5Ia/zLheG+//4qOz+DhAzw3xfCHf9fRrgV8l/PbgM5ocF8P7NJ6P+r+ibx/6NTBu9vDnJv78DJ+B6PUhb256n6r+dqxfstLpOaeC/rnwh8BvAH8JulfH84rfT+eHR8l7WzwX8S2L73fwh8f+C7xB8G5Uz62+Qlz8EHcq4dswzruyx2n0KQXuO3in4T9VHE3Tfrf2R9G7LfbVrKsil3df+0FXeR4cwH+mc5Ed4FVFv0acUxRf56G/S3xXR/8k9GuQ70zxsy7uKqHHqeT8W3tdcHFXdXPxWFo8jmTHSexYiJzP0Os37QPtwx303PiG3MeS6z5y5cbv3Xjukmu5sie+xxuPDypbs0sb4/0Z8d/IeI2cs/eob1M/nj5l6ZMrxpFxMQd+b/gfov8K+h+gOyf25/n5E/uzHej3s/joF7ll0dmv/a44bwNuY7xvK0+P8+joHW3d+3rWVoWsZvidEheFi8tq3lvvAXdtPO/J15Z8cUdYLv66Fv8ycS6FPR6Li0eV29mlprKQ+pnG1Qjj6hJ2rKz9Hfyb4T8Zv4/ifBh7zGOPrex1B/lfZs+C9BovrhaKn43oT0B/NPvfBO4ichxDjuvB/xn70MoNymLo7vGe8Tl9h6h3ROdy7z9FY77nn7na62l/iB0OsUNTci0hV3v99cEtxe9v/IYaD2PIsZ7+Jeifm5wTyXMz+ouN65zab+SH/uS5lDy11Seq10ZvEnrz0fkSnd+Mx+HG4yr7H5Gw7BFxMR+92vDi7vZt5BlAnrPZtwW4pvQ8JZ4f6JUG15iccbdvW/zPZ6cH2POG+D4c86J5YA38G+BfH9/XzUfT8X8Fn8Hs3Imdc5sHZplvG4P7lP9Pidzh6N2M/tr4wSG9+3jOVwJ3wHzxs3VJF/jnkLM2/oPxuxa/JvgXw78iuJ/iHA16z6N3EHxP8NXYpYnn39foNWOnYso57N1R+3L2WohfLvQaao8c6uW1V4j1hnnkT37shX5X9KuR+8T4fQN9bjUOBuJzjP2ej9llAbvUI9dV6EyC/3vst6A7mB5nw/8R3xrs2IYdX2KfMtrb4Bc5tWeC269+FzoN0WlFrzPjPIb6HTH+wNfV30Nc1SLPWeg0R+dp8kwiz3ztfbWvxqeq8fFP7Pvgt13749qra/9dvSm5P7R/WpGd426T6fG8x/8B/m4uTprQ5zN2mwuvF7wN4rabOBtGnibkaUa/m+P5HN/Rja/myk89JwaBOxXcVfqbx/u+eLqe3U/Ddwe+C8j/tXjryy5xJ+T14mBR7C+Bbwp+uPJhZSP61KTPHXEnuvn6OnKUIccE80l/88mL6mPVT447QyP3PPpL+GWt8fAy/hfBPxX+KPLeFO+X7HdP7D/CawqvOf5x90oP7bXjOxf5XyL/1fz8rf6DxsNIdm3JDl+zw1XonIROEf7pwf7H4LeAPldqP1H7VHS6onMz/c4U73+rb1ZvR79n45w7ut8EX/I3IH9L8tWL72zs9ZtxkUv7Mdr32seOO3wLqBdTv1v/KbE/r15Q/bt4fuHfjR41Y/7nt7j760VylWS3W9Fthu7zyunxHk++RnGei35xZ/0c9K5Ebyf8hfG9FtwQcHeDuwpcV3KfT+5vzM8fxDk4en5Pz87xnVCcH8cey9jjqPCf766XgC8az3d+a4z/4+j2j+/M5KoJ72d0X0D3EDpzC+bLURX/T+i7mN9OsM7uAe92eL3EXT1x9zv8l+G/BL8A/B7sli++W+BfEv/1ys/EWwd8z8W3gvi/mp/6+/7dJ3I1k28H+c7D57M4TwDuzjgnyQ+z+KEX/LLoPIpPb3yeV45S5hdnA81zf5Ir7p47jT3vYecd5F9M/tXotY7vqOS6zP79edoLan9dvSQ5T2HHY9hxFvqj0K8Y+9biaZJ4nB3naeEvj3UafkXwq0Xu9uTezY49PV8u1l5Y+zJ0h6C7QntR6747zVuRc/xZ/SNi3wyd7bGfIB6uYJfB+N9jnmqgv5j+A3HOkzyvwo8c05O0d9B+On2G0udB+sXdCBfyx5HO8V0FPu5suoIfmsTvOthrHHuNUt6k3EuvLfR6Cnx188lEfmrPT8fQb43vrTuM7+vItwn8FPBv41MJnYLsORRcY+3l4n2GX9qR+3v8LzCPj0fnZv3F9O+ibwF4Hcl3HznGwT8d3+PifHLkMkd/kP4Po589x8XvqOj3lXm1D3px5/R76PdBvyX75IrncnwfEift0OuJ3pXoVY3ztcbPLfa1nqN3XHzyJbx74/dB7LSHnKXRLSYnVh78Wsf5WPUpcW6HX36BPw//pejHHcVFyT8s5te4k4I/zot5CZ9HwN2kvDi+z7DbcPNSfs+jJzzfXse/IrpTyVkfnbHqs81vt4vfvvTchl8b8VCB/KU8J2erH6E+Bv1e6D8Gfof5s3XsuxjP48j5LXqnkO9P/MbS56w4Zwm+Cvi64qyj94YzlE3EW0/ytiJvPXjT4jsdOleJ0xuNs9/FyW3qp8WdU+Seyj43kPMIcm4CX54d59J/kfpwvyKNHN412Lee9rH6d6M3nD9+iVzY5GhIjpPZIX+8v+t/Xn9jcpbj7xng4u7fvOQsRM7n9BdD513xMDuee/Augfet+tPqxcl/EfkX4r8K/yLwH/M+cit9bqbPXewUOeCXopMPnf38+VLsM8Z3QM/vh+HFvXMfxXkLcuxH/130l9DzJHH9IfhH4/lI353kvsl8sdp80S3Oa/LPGnz+CD7ovw9/M7heMa7hz4zvOOzWmR2343czf/1Dz7fo+YN6b/Uh9GxPz33xOwnzxwXxPmvdXkZcbLNO6QS+RpzfIFf5OL+I7jfozsP/M/4eHetF8b4FfoWYj/krF3pvo3MkO7TUfgb5vmX3B+LcD/z94m42vReSszf9LqLfRnBF4Q8Vv43FbxX6PECfk8hXMfaf9UfO87n45SL3I+x/S3wnUj4W52nQvwX9fdId3xDnLtDdHvuvxvsa5zPqsct3+i+kT5EY1/q36a9Fr3L0asdvccfNVHRqgrsd3QbRr/6KefstcE/GdzdlB2VX8jSxLplIj1n02Ib+ncpbyfccf4/XPlN9Mbgv6N+MPkvjPGL8fpS9DuHX3XwzQf+T+t9Dd2mcC/d8ezu+m+A/IH4vRN6+8Xse9eJxXpH/J0ReOnS2WaefTI+f4ns2/rXiHA46I+J3w9pvifUC+oPjOx66n+kvJ14bitd5/DPTeHoP3CxwF/F3Ee2ngn8l7gxm9zvYPS7xnsCPT/JbUfFYH3534/YT8jyB73TydY/9evFwr/lrr/YXtDc0/prFPjG9X6L31eo3xP48/PPxqQwvVzy/8NtL/2fwG4/fRfS6w7iYh19O/GbT6wpyl4bXAN4meNPiOzo9P6BnHfaYEucwwL8grp7LSjeWK0cxcj9O7hniqZt4qkvfEeL6FvTX8k8r5XzlDPL2iPNH5Bse5yLQvxP9EeTpQZ772acJ+zyD3+T4/Sk9y9NnMX4lyfcO/U6H146cR5NzlnipI346qB8T3wH0l41zY/jEvW0DlVcrd+kfqr8l+VdGViL0D0a8aG8W4xfcR3FOid4303ss+bvw19HkKkqu5eS8R/9Qco+J37kob4nf48TvacTXdnaty+/Pof81+k21x52928XBJvQLkf9J/bPId4A+D6F7G7rT0JmLzurD+ei+pf9q+o8j3+3x3km/XvTbjf8z+B+vfxd9cpN7sfbl6IxCpwd+z5CjL/i/7B8OURbRPyj2e+gxCt9d+C6Cfyf6jxgvj4f92HeLeeUedDqg8w49TifnOPU+6oP0dxNnn6LfwTxQR/8+8TqavVrFuiv2jcEfJZ6f9Fzba53SLc69scOXypr45cWvATnmiIebyJ0H3xpxXjG+v6oXVD/GvHFvzEPo/hN6krcXebfDO0VcDVb/SL0du1zBLlPFWedYV5DnRPG8jLwjyTuRvMvo87P2buR6D58byB33hT8S59XEafE4F8vu89j9G3Z9Gr/+4Dbx1w74tfAZSe4WsW9Dj1X0GAZ+LPjp8PPAHxTjHN/ayrirPjc6n8U5SXZYbx7vjN5K/ihI3v34Pgh/Ivwt6J+B/qv804l/PkUv7pS+n97N2LOu9jfMf5Xpex+4t5SnwesC71zvExepT9G+DF4pfIuy3zp0ribviZFPAP5B/q+BXl703lHOUq4iTwnrwFPUf4v3F3I+Rc6HY7/fOG5Gj7iL/A10psbvWtC9idyXer58rl6ZHR5gh1H4xl3zN5JjFTkmxTkdeB3pXz3ef+K8OL178099/tloSqtkfvjeOPg4vhPob0iOS8CfAD4f+/ys/Wn+e5j/muD7F33usA6Kuzz34HeJebsu+GLxPY0dmvDvYnpeBe5n+jxPv/nxO3zzQ11xtBjfk7T/GOee6XMK+Y9E/1j0a9DjodgvIMc14q8V+E/sB7UBXyXWp+AfinPA6J8Xv9OgX21xdBv6fSL/A3v8oP9c80Sr+N0QeQeR/2d6bOb/Z9mlKH8VQ3cEOc7Btzq+w9F5iJ0aqtdV747+fn4eEd/ztV8gPi6DtwT/u9F/jjwPxnsj+KvBX03uBbEOwT+vei18xsd+CLi3Y7+KHFvJOwW9VZ6TJ+jvo//UuOM17uZlt23stpyc48jZgnxv0bsgu36j/p5xVjDWUfH9zzqnjd/3PQyvGj1voud55KiF7yzP++bo3k7+I+xz9CP3kPg9Hjp5yZE35nvvgw+Spxq7fB7ne42/6eTsTp8zwOUENz7yHdD7AHnex381+uPQb4NeN/ReBz8Z/BzyH218nEPeR9izBvvkju9I/HELf1+r/xlyP4ve3+j1Qa8FeuvY65vYVxKH18Tv7vR3Cj+iezG6T5OrtDjsw06RMOkK7SdoPwX9fcqa5LiYHFvNZ53RGcguncyD5fX/on8Desei9yA7VGSHI7V/oP1Tdqwc53HRfTrOPeHzl/HwGPi3yVeSPS+O/ANxl3AkvI/vseKwRFzfEN9R2KEIO1yGziPWkZ3peY24G89u7eO8mfZfrfdzk/d99R/hvR771+S7EL9W4M8G3xjcZnAzwfWMcz/sN5gdvkJnFbx7tTfW3p6fCvDTycpN4udr+tyn3MuujYy70uQ5Nc4XoXuP/eA34E+Hf4/5dBS8D8FV4J9q7FWHvapFvoJYV8LrBK8xO0RSx7Xot495kJyTxNdu9lrFj6/Rvy4/FCDfPeT7Ef116L9CvvHkG6FsEb8HU36p/Ul0mqAzl383x36Kcp6yCL4r8b0a33r4Lj2cTKYDeufG+kIc3IB+f3LeE/vD7HO/8woF8X/Xuq4KOx4f7+38tJGfSsH7Nfb18Lsg5I7zqdqnodMFna/pfS693xEfbfFvQ45nlB9oLxd3ldGvZ+SnIPdM8j+lHKZ8gX3bsO+P+F8tTqpqzxnnxcmfTzwfG+dQvE8vYN/l+K5DZ2SsF437T5TLwQ8G35xcLlHLcWfI77n1Nrq3otua3GfF72hivonfTSpvZ5c72L258d9B/VLzw0j0J8LvxT+vx/4Guk+iezX+a71vFuGPB+JcNr6H8F2MT0Hj+C/4w9Hrwo63sWNl9bfwOQPe2c75v6FeWn8n+HvML8PxHWPcrNC/0TqkFTm/Ne+1w/dZfFfjOxTfy7W/o/1v46Kw/ZfX+WNefO9Wloz8FeAGgvuVHAPIsZeeL9GzvP6j9T/HTg+Scza4XuCGhn3jfLz2d+L8iPYfwB+n/U32/RreS+Fvdv858mvQZwF95pDrD3I1JM9Wz9EW+FSKdSG+7Y3Tx9j9anZ7Bt4F/FWcvxeaf4rGPmrcMa2/uf4K6BdA/xC8ITH/icuB8TsN+yQNxOWo+F5Dvu88Fz8Cf7Hn8fHmhdOUv3kuT8G3S8Q7eXLH91N09ovTrex7Lvt2YN/v+eca/vmO3kPxrYzOPfCui3mBvs/G+Cbfm+bx5/DbFr9/Yo88kY8GvSXmpRPIVY5cN9D3K/Y/wfxUnxyr8S0Y39nZ5fI49wv+TnrkQWeG79zF0f861mnwVsNrAa5DnBOmd53YX9F/Lf4jjZeW5PxJfV38zl//d7Evo5wN7mnj5nPj5jZy7iDnlfQv7bvNdvW4e70FuLrgyuJ/IvtfiM4x6HyB7z3i/QV+uJ4fSpP3dn4rp38vuXbF+yI7lULvnciDAa4muIrs9Ba8VfQeS+8rwUUi2gvZcyE5b9F/fHyn0z868grh2z32YbS/Ce868i6MGy/iHBj637Pn03F+lN1r4nsjueNuzGbs9LHx0B5cffG1CdyUOB8K7gf6lGDneuy8FP+v8e8Krgm4x/DLg19z+iyjzwZ4D8f3Ls/juPuoMjk+IEdDdqmGTj5yFibngLjL3vpwova74/s0uP3xfm4fOe7g34XOcnTuY7dSnlddxU0eeCsOJ1N8AL/P8cuFTl/jrwM9tsCrSt/Rce6DHc/kl778eXHk6UB/D/p/kfde8rbFt0HsHxvv7c0zu8X11jhvjN7r5oEx+vvF7yPIe0LkV0L37fgdMfyucdcSfrnjbj7z0qQ4J89OHdjzOvaJu/iKkXulOFvPTo34cQ3+7cB9ge7z6OZUf5I8R6P3uvXHBHK2I+cj/PCguP8Tnfv4axo654N7Hv/d+O/CZ3X87gqdaeiMIUfcpZVH++exno/vGc7DPqTsYT/3KPG1LfyM3pnkGkafzvRpgd6K+F0d/sXNA6Pht4rfmytXRp4H8i2L9Rn6OeP3ytoPoh93Gv5lHdBAPNzpPf8DfI7zXKhJzpdjXMX36rjDD/4t8b2b/mdGfg9yTDcOpuB30Dg+Etxccn7Kz0/Gvjv82+O7N7gi4PLj9xV+O/llMzrT4s7tuKEAvdXsciJ9Fse5UvW/1E8VD0PEQy/ybos7u9XbqJeMc6u+zzZSjuS3uvSeFvsj6H8b35XjO632m8lRhRyjyF09fuep3Ba/K1D+E+MPnyr8uATeoDjHjv/ZcY4C3l7yXuQRXSruAhM/M/mxM/4v4J8n9rnJ2S3Wq/wxln5tYj2HzvA4lyL+jo9zPOiUwv9o+EPgt9V/tv6e6n/H93VyHmK33yO/E76tyJWXnAXkWB4S333Z7624+FEcFYm8U+y2M/Iq8XfJeN/Gvyj+z+JXAr9H0NkgHn6l1wDrpLetC9qgs9p8f3H8jpkdV8T4hVfD8/UH9TrWV1XB/4L/8/BzxzkU8f8iPsvRze07/zn0OyLO0+I7HN9n2KGwefaQeP0wfi+sLKwsBz/uAN1P7snOBVRSj7tibyf/ZeS/Db0rrLueQuchdJageze6l5BninXmEPb4nD0aoFcFvSfIsTJ+F8SOF7PjO+w3J76Ts19P4/k+8v8U3+Vjn0S8VvP78Dv463F8P2KH89Apg86H8d7KPiUiLw39NqIzCZ0PlQuULT03OtJnBL2+iPdi8BWU49H/C/2Z/HJZnIuJ39+zW1xuvSXOk8Z6JM+ROYbR7/r4DgG/E7zjtH/hOfmC8mzjsA15Pzef5SbXIPa+Br3f43e36L+IfjHjro55+Df+6hH58OD9yQ5vsM9UfPKCXxq/NyL/V3EODJ/38Kkf50nFeVH2XiFONqrXxi8/vX+J57n2LdpHke9G8r1D7pmxD60sFL/3xP/nyMsD/qn4Xaz5NTc5bkRnrvVcY2Xc5TuGnVpH/jD0upPjED2GsuN15ClAnsLwlnm+DSFvI/JuBj8D/AnaX9NeU3s+7W+w319xbkX5dL48OXbGesa8/Tf4LeBv4If2/NDBeF7HDlU9H7aQ8wv4y+J3vuLm6DgHpL4P/Enxu2Rx8zE6rdHpxi4vs0tv/fXAXwf/R/jXsf9T4mUL+XvG+Xx6x13M74GvjF/+yP8mTgeR45rYP9CfK85zKgtqXwXumPgexQ9d2LUyfhex+3h82uPTX7xc53kzK66yI0dT8EvIcXecU6LvSnH8XOz7sPsdsU6K74+RDwrfuLO4Cvlm8M9Y/a0iXx45niDHMv27xfET6P+Afn70X/ZcOZkdKrFDzlg/qZ8ddxvq32V+eC/yurDjveQdgM4V6FTGbxd/9UT/glhHk/uu2K8g5z/kHIX+NOOyt/JSZXd6FkWnKv5x93UR5UzlDva7m/2eAlck1s30ej7yOKJ3XHxvhneU+kh8b8T3Qvb/OL4jam+h/f44FxUXhZL7cXL3jPdF/A6S65X4HaD+lvJdvQm+d4z7yDsAvhL5PyX/E+gOiPFP/6Po/6a4fULc9ma/nOgM4q/d/HoNeUrHuSvwz8f5LfH0SfzeifzjyX8Wet+i154cS2OcobMAnQPs9zW+leAfjHUv/kvMr3eoX47eMvbKz67r4F/pubFO+8iIa+0VtG9Wnxbf79E7D73b+GGQ9oeMvzZxDpwc75HjU3ItjfwTyk1xjpb8JfhvEnusjN8nkWuCcdeMXSrE8wudyeg8QJ7m5GmAzpzI88QvB/klP74fozOS/nEX93hwfQKO/b+Ev4nJqsYd4+RaT64u5H2R/+bC60Pes9B7EL0B7JPHumw6/GHsXizWj57nPdm7SeyLgVsM7l1yPYLumfpr2U893Tg/ZJz3Z5e7xPWF2gdp70e/S8m1Fd1+kQ9Jf4/ID8i/F8f7vv4D8fsB9KvFOlD93rAHO7RlhzLmxcvNRxPwa4dfD3yqWP/1Qu9370X92a0AuBHwWkS+PnAXgiuIzxP8m48cj3vP6sB+t0YeP/7dFb9npf+j9C/EHr9Hfi94BeDVVT8tzpezy4nsslyoXhT3zuC7hn7z4/ca7NoC/QqxTmaPLXFnJPzd4FuguwLd3fxQw/xRNvIV8k8tftiK/gf6z4rzqPRvhO+52t/WviPOUZH3A35vGb+fFy+XiJfS9PqNPA/Qtxy/zCNXv/geFPnkwK9jp5LxuyTjcH383pEdy7Bjp8j/Zx1+Z7x3mz/yR94R70ud1Bt6734In73ifneM9/idiPJs5W/0eDHyBuk/khzF1L/Erwr8Sz33Ssa+j3goRK7dkf8G37HxvhfPO/Tep9+Z9LsI3HDrxXfxq0zOEfxUhp9Og/cPvO34nY9fh+BLzjz6+5ufq/N3a/7+h/16s99Cel8hbt6EN5N/69PvQvodZIdXyXWC/qeNw9r8ViH248nzKHm6s09L/rke3XXoLqBHv3gOxB3lxsdf5BtovVBJ++/olIi8SPz0Cnod8MuN3g+hFz804oeZ2mtrHxfndtlzOryukY+B/5/k/4P6Z1vvlCXn75FXkn8PgP+FnOtjHaksFPEE/zv4G+FPiDxI4F+O/QDt0yNOlN8rL2GH3tbhz7BPsThHHvk+jaeS9BlNnpH4nSYe2rBHQ/YoqSyvnBH7SbHfEOfHzK+vkqNn5O9A5/TYh0W3EfueQZ5D+DZF72X2uUoc7o7zieCmmEcbiPcT43fe+JTA50/yvhb5atBrGOd/9M/xneVH8nbg38X674rvOfob6B8vDn6IdZT+4nG+XLkzfvfGrg+xz2vqJbSXJseeOA+lvkf//fF9Kp6L8EfH773R/YLd5qn/Hb+rIk9/dh2v/eY4f4XeXeit4vd1+FZEbz96uSOfqX21N8B3i3M34EbF70P1/6+r84CK6tr6+ICGIihI7KgZTKIIDoIhqPlsKPrUz8azxK6UAUZgBodBQI0KohLsPfYWDdbYjR0r9v5ij71iL09jLN/v7+db763HWrMO55x99v7vfcq999x99g2WvyXpQtK11EdSb4FfXfkvoVcJ9DZil4ncrzmwa3fsuhx7ejIfOoBjqeJTkY7TewfkDMTeF1hXDiA/Azl9kLMbPboxLnuQb0p+HetIOOPkIuPPn3HtSz9EaJ8Fvt9wHzEUu/nT3p3xVpn+PQTfvxTnEDk1mE+/Ms7O0z4NXCXon1j4N5dfP3o0RY9Q6sfreQF+o+RniT0zuM/cB99E+K6i3Av8fzLeDmKfb7XOIHcb/V1R55nAWaA4sNC30Xsx/NKDkRuIPd6jf2mdT2NcrkTOWeScRg8jehSCIwE9XeF7nfYtoK+EXvngX8x1fB32Gyf/Muj3Mu+y0eeirjvkPWn/O3LX0u5z8Nzmfnkc9Xeoz4BfS/lp0T9LFF8NftvcXAwW+EXK/4r25+D3A/aozPpxHz77de6EfrTrPAr0E7kvLA+e3azbW8mfw54t4D9P94fQd4W+DPa7iZz+yAuXHzz5fdhzCGk7+d+g9zr0fg2+H+QXxXWkHXa5D/0W6C/Sr225rkYqzgHr41LF8YBuKDjagmM7+HsqDiz5CPIdSKvqnDU4nOFTjXQQeEKRV1zv1bF7KOcBtsJ/NPxHUX9V/nXYfQ92v0v/jFB8LPqtKeUW5G2gv1dgjwrYsxT08dp/h34j9KHo76b3/tgtC7ud4fkiVnFZtH/KfPuJ8oF63w2/PPZHv6B9huKAos9J1vlC7LQIO11BjyHo4UP+jd5fo4e/9nHA2Vnx7qh/xnPGLcXpZR+yD+MiTP7c0Ntpvxb+rjxH1oP/RPjb0KOC/F+oX0+9n96DMB7bw+eS/Dyh+0vnJZgnWeBvQL2N+oHw6cV1JFPPr/L/Q84a1pGr6NMKP5bx8p9Fr5q0z6a9J37qLfng+2Zw/ghOb+yxkvEwAXu9Yfz8hh4jdR8DjrKKq0Penbw//fFacanB2Vj+8/LHZPzEw78d189Qyi/LTxq6b3Xei7SW4pWBsxbPXw/g8xt8ftF+CDhbMq/rsZ6kUh6u6yvycpHXBz5u8Hcwjt0Zx+Xhc0f7yeB9Q/0u5JVAPyv1H1gXUqhvovMY2Omp9q/hF6z7Q/rRSj8eYx/njT4ihV0WyR8U/s/l14K83vCzk/fVewvFs6J/ppBvSH4caV3SIugKobuDnSPk90s+Wn5PpPtI05HTCzl7aN+Ted+YcTaDcbYDel/odysuIPM+Cpwhel6Dbjw4+kK3WXE3sYOvnnMo34/8Gno+pl+Poe9c9G5LuyqKo4K8TOS9pfwI5SVIb5HPQu8yrAfTkTOY/pgIfZTi2IIrD1xzsNdu+n8K/I8r3gbXNQPlnUmfYqdf0bMrel6l3Sqdf2ccpOg9CfxtyHlCvjXr5hH0qYk+x7DvTPkpyV8VvUw6OMb9Zyfov9I5fur7UJ+NXpHo9YL2XWj/K/KN2CdL8WDBGajncvSsB747rCdXuF4cBUc4etZEr+aM17nIe0z+sOwN/83wT1Q8Ieb3cfLzyE9C/xD6cx1yszT/kJOPniPQP0Hn+3TOjut+DnqadH/JuJkPrrrgq811/j31w1mfMlnHcnTOGTvEaz8cvWZxPX8C3i7a96Pdz7Rby/rWhH4r1H0f49ihuCjIy4NfN8XJQc41+dGjVxXsXgF8GxmXVvA10PoH7rHg/gI5j0nrI6ck83kYesbLrwy9R8rfS+etdf4eukDwjATnHfSOpt/ew6eBrrOsr52h80NOdXCcZ1wloscA9KgEP2f4lYZfP+27IfcL5PnS7g33/33BEwQfB/kAxTknP4r8DeQkYI886LtDvxs+83TuU/sB2j+Cf1P4TyWdo/cK0NWAribtwuhPV3DMAsdD+j2cfh+C/l6Mz1fk+5AfhT7fo09J6I/TL73gkwCfEYyvkay3O6Dvhf3ag6eK9u+x+0vWiXzkZCDnLvWjqF8Ev5KM0xbgKqb39zofyvVtEfq+Vfwx8tmMsyzoinQ+DXkvsV8t+M2kn1rRX98p/iP6NUe/hcg/q/i92scEfwj98pniNoCvD/jmU3+Seif4jsZ+T/A/z9Y6DC4fnSNmXLTnOtKbeb1J++ekU+WPBZ7b4BnCeIxmPA6EvjX0VuwUw7jJpP4U9Y0U9wj7JSm+DPcz5+RP7V7c0BwcFXVfJL9Pnh/aQ58vf1LKH7Buj4PPHvgkU75f5+DRKw79mqFXoK5TrH8ujPMIxuVD7LYce5THbmeR15N+DgaPK3iKyKeQT2efNUsf7if/GnsV6VwV4z+Z/GY9z9Dej/br2FcciL6l6c9rtJ+qfWr6YQn1PtQ/JW1Lf38JrsHgqgWeMuCpBO7D4LbTv03kL01/zFM8WOx1D3sNw96jsXcN6L30HoX2UbQfJn9X9OxG/99iPvVGH1fmcxR2baPzS9D11PcY0McbPM3IzyZ/C/oc9J5L/hX55/TbCOxZAP85Wj9JE+Q/B91B+G6Cb1+9B4O+Mjjeod9hxutAyr+kvCvz7wW4OyG3BXKHad8PvbP0HoO0Fvp9oPw8/Rim+w7am2h/ivYOnXtAziHk/ICeufC/xrjphN47oa8M/Qnwzwf/Nfi1YRxe1mei6b809M9Afx9wJercFvwKFG8FOlfFAae+OuvrQ52/pR8nkD6lv6YhZ672SeiPZ8yD78BXCv0jSCuQjgKPkfk5CX0c4L6uc9fcrzShvgz1fWmfqH0CyhMZBxXA9wR79aL/ArU/AJ4Z2i/T85riupDPU1xR7JxD+/7w7ap9Evq5AD3aYu9vab8XvH3AO5bnlOnY5RF6elLfkvpg6rtDf4p8K+QuY9xfQt/B8utEj7KMr8fo51DcAO6HopFTFbxnGVctwVUOXDfRa7j8hLB/vt7HUB4nfynyb3V/hl790WsyfBvAdxD5kdq/R7/D1PvpPDXPl9PBn6n4wZR31Pso6OMUT4j666wv6z99JC0SPOPYn+oO/wDkvUSPk7qOoccqxvcv8BkOn1D4eMCnHPpvpn8HYDcbdlsJv/Wsw5sYD831dWzwFum6T9oX3GnY9Rh2fYNei3iu7gW/1jpvovtA7LCP9Dvus5Yzj/5B+0vMz8Hgmg59mPwN0e9HrdvkQ8nXA59R72/R5yD5Gsh5ibwe1N/R/NJ+JPqUh+6D4qmCuzS4K8lPl+uSK/ZezPXxL/Q9KP9j8JdlfExGzizk+MDvKuULaT9S7x+JY9wJ/C2YP9fR5zb8Nio+AvKf6Xz1x1c67K+hV1Wdu8Ru47FbV/Reo/cUpP11/6pzyshPg29PvbdEzh/yQwH3GnAvJ5+puAfMp2rQz2G8uDJeDpP3l78L/KfCvxRyNyH3D3CsAkc/0u9Ix0I3m/V3PvkU8mb6qSXzrjd6WdCrK/x2K04i8tcozh12ytE5EPj20XcCuI85pjg22MUVXLvgV1Vxz8BdQ35G6JGquEHwXcb7qOnUb+S6soj8W+QEwK8+14E86G5A15v3yxORZwNPY8UrJ72i+AnQ35D/CPq2QN+SlN+m/Ef4TQG/FXydyVvhUwif2lwXamDPfNJErnsNsdcB7PUlfE4rbi36dZRfAe2+pl0I/Nx0ro1+Xc64XM483aD4xNBl6Fwv8zuPeefEOJjBOMjFniGan+BJ1/l70nWKg828fka/1qFdQ70voHwC5bPlP6/7NNoF0W43OH217ivuCvN9BPYaK3959GkB/jvg2qP3MfJTxD426KqAKx0+Q+DTCP6t9BxKeQTjMIn2PRTnmfWhHTidSeuSPqf/OnJdykDeST1XY4dirH9B5Efp+kB+kvyW6c928kNgPv0sv0TkV5Q9Ke9MeQryBiGvH/g/B/8S5J3RfRj4TOALQV535FXH3l+xjr1D74Po7YT8aayvW7BvHva9B72V+duA8eLJeJmHnZfKzuQbah8Dfbrhr9AP/t/Dvww4kzWPkB+p7ywxn45oHxh+DXQdlj+K/FsVB5B5Ug7c7/V9GtaVCPQYpfjDrFuvsduPjL8tOj/J+B2J3lWxwyHF52ZfNJH590bxH5DnJX9q6O9j5wLyFclvRN5IxZVG/0j454JnMuUzwd0P3CbSd9Q/A4eV59Da0J3DrhHYwUfnbZEzifXFGfuUZVzu0f0jOC5C30j+2OAeoft+7FWX+VuB9rtoH4WcJORspR+m0Q9doGsI3XP47lR8ZOj6gCcG+d/IL4n5eF1+QZRH6VwQcpZz33lW5zmR44U+CToXjb7r0Hck/JLh1xj6u4rrRHmO/BuRV1/ndbD3JZ3LQ3+L3s+R+is+L2kuaTXal9BzLHhM8q9Gzmf0m6/u05Bngd8r+O2Afzx4fMB5XfuO6LmTeT6afA+dG2BeGXmuciZ/ivr98F0oPwjmw1zmtz95b/KJ8O8mPxXs4tD8gf6V4plA9zV6FdGveYrPhZ7vdF+s7wfRj2HocQp8MYzvbYyLLNpF6nw86W+k+2ln1vey0LsjetfifVo15NbTd0nkh4Z+13QODboAxk065SGMq07wfaLnb/Clgs8Luss6d0Z+BflipEU6D8B6X4t1YQ3tOyDHBbm/y98bO1zFDgPAe1z7irQvBr/K4PgaHDX1vMJ9fjb6jtVzDnbcQ/s46HdC74t9x2HfrfDtrnhb1J/S+y3a16H9a/xuxsJ/Kzhm6Hlaz1GsF4+hH6fvQkCXDZ0/cv8J7lj4bofvAublcsXjop89wbmNdAzpUOw5DXs+gE9r+CzDnmewZzT90ph9kQD0eiP/B8pv6ny4vk/DvsZ17Zsoji38N+j7F/BZD58X4DqhfUP0+BU9JlJ/n/pEvR/A/ivBsUnx27U+Mr+3oZ+Z/FydW6Z9FvkAfX+FfvhT38OA7irjw4E+Tck3Yr6Fsv47IecedCWgX6d4yOjdQXGsSBvreyTIH6PvzNEfD3RuHP2e6TwbOBaCYxM4ChTfjH6YTz8kgXMfOL+ifaDeW4GnJvd3L7HrFO5XOlK/QvsHyF2GfqHgcdZ3ypCTybwbTf1N7W+RLtP5LejyoTuh87rkbyt+vOLvg3e9zt3re0zo9ZDrizvt/4GdF8lPkvZLoF9L6gGuvcz3eqwrN2g3zJtzB9At0P654s2y7prR7zj6uem7ZqwLq+inc/TTFHB/o+dMyotD5w7es7Q7BK4l4Bqr9796HsbOp3V/Bt/m1F9jXKzR/Tt02/W9JNpfYZ3bCb0L/Z2NPgN5zh0OvkvaZ6b874rfBt1c6E5SH0R5DvuS3Zkfv+v7QopLip2WoOdpyqMpfwX9YHCl0D5G+5Z6v8j8O6g48qzfG+RnTN6GfufRLxB5OfIbwg4V9RxD//gxXlZDXxo+QeB/D+6V0LnI74N2z2mXgx0qMb/vk6+n5zmua224rj1kXb2o+G3QB0LfjHIr72ec6X9P+j9Dfsnwj8YedfR+mvVsOvcJjbBLdeyymutRI33XDLqT6H8BvH70bzvGUzfdX9DugOYZ8nvQD9+QL6HnOt1vcX3NpT+66HtF4DoDzqrwdZG9sVMV5tdW+EYw/mbhT/UAe6XR7gD2LUv5JuQ5KX4s+gyWn5HOWyJ/HOtKAvxOwS8fvZzAUU7vBdmHn43dmqOvkfpV1H9J/ojOy4Jrq/Y/0P/v2OU9OC4oPjR8C3S9xh5VtM8Mn26K08bzgj7s7gd9a+hztV8rO2H/OoyfZeRLg7st7UvTPgx9FjIPA9D3tfb14OMNn2tab7GXEbte5rnHg/YXwbGUNB26IvDlKm4w+JrJz03Pp6wXodi3MXp1QY4vcoOhx5HKUA45eawLk9DvLfqdUfxFnYci/Zn7UxPtT9LeTfvkpGvBMwz7f9D3zVj34pg3O+nPGdjtmb6fwTpTHtzrocvWeyn4vle8CPrzIfedMdBt03oBv53wc9FzNOly8A7S+RDaN+C8YiZ6VEOPhvDxkH+s5gf9+zfwroa/P+0KtU+GXnHolQ69Efoa2OUZdokA11xw+dL+nvaloa+tcx36Lhzj6ADqB9Ef0dijsfyNwemuOKr042/a/2Z+n0VuK9qXJ90Df4vegyJvjL4zCN6fwBtA6kR6jjRfzzW0D9H5DejToP8b+oRh377IXcH92QDGRU/GRX3ssVfxfKGroucGcHsofqTGqZ4HKD/NOAuDb0n4Pte5QPo/Hv7t4N+A9oW0X0DaBLqS9Odl6Nzh7wN/H1Jf0go6b82+1TTq43R+g/wkfeeHdq7M7xOUz6W8Kfmj8NtMfpT8V3TOhutYSXBs1PMS5Su0H4Kdbuo7RdjFW3Er6c/F9Gdz6svKLwQ+7XVOF7w/67uTlM/Wd0LAfV7+49RvR84O2pXHji+o3019M8XX5f7iIvUDaX8R/r/I34l0FWkl7PBMz320syBvCdeh1Yp7Qf4y+XD6exb9XQH62/CbQ75Q7xmRu4l206B7rP1Q7NIUuzyEbjN8l4HTA7vmUp6o+3vyO8BdhP599T6X8lydF0L+9zo3zPp3Qd9n1Xs6+nMG9YOoHwe/njrXRH9X0n4x+LZCdwC9XmHvm/KrRU5D+D6VHxW4Jut6z3qQzvq5g35vy/zvy/i+oXN38HuHHqnQWxi3R7nevWJ/rhF6TEcPP+3r6xy49iO4PudB3xX5damfQH3+p0/5dkTO/yAnhvoQ6h9g39H6HpbiLbDuZTCeh9MP6ynvqPjE0H8GfUv4LJDfH/qlod9C0qGkTuBL4Xo0CXtEY4+65BeBdwP6VeJ6O//Tp3+f6vmF9SESvn/Q35nsL+aA30S74rTbiJypyHlC/XjkboL+BHYaxPi6xfjqDl2AvpuC/pexV1XqizM+shXflfmRCr4j4OvGPH0pfynGaR3s/ZLxtEdxXhwOc3KKwxxrdNiMFqvFYYlKsgw0Gx0JdnNUrCnJFhOVZExPsCSZjRaH0ZJqjDZbrPHGWLstJcUcKx8vb0M2miR+/A4nz9D8qvMrp28U86vIT6HUFCZN5ZjxY0r3Gxry2zja23CZX7Ex3oaK/Orxi+Q3jN8CfoX8XvOrOtbb0Ihf8Y9/Tk5ccgxtPn1Guu2n9H8N4fMLDhk8MHP4k1384/5vivAJuynwe5KXcXjLI7fAzwKupoyv86Zqh317/ZalBy6+uN5l4f3EG02H0VKEAzolmI2p6B5lN8bZ7JgD1TOkf5o10WpLt35ibPip/OtyPbJ4Hps69vqltSUNb2c5u3qMKmXoWdOl+74tHoZLfw6J25HJGZsz3n+NP+Fq2DsjvHNCXnHD+vLv8t1KlzIU7Gx/oXMLT8Oi6ukXvmuJ9D1Id6v99sOH9x8+fDCET9xLnv76+Hf80AXT9X8W1uDj3AdUXubRloO17QtKGpwj3qZ5TOWqG9lcuquuSXh42IkxvZ0N77YWy3vRr5Th0qotsPQywJa/f6W8hfhId6rxo2HVts9M3RpQ9P8VyN68Dz4VPsne1S592QzDs9B/fQ4eOa9VL2PP3y+Qe27uLLF0aCebf24pp9+HNLtpCC9Q+RKnWl3WNMw/aj6bHOpw3VfCP0+a/edfyOqLzWcaJ98deuhu/zJ5yxqWLcqZdHNC0t2jiWd+8Ts1Mrj/0L15q9b3L7vf5eWcFW4+1fb+lyD79i99B09zvpIRl2W8Xy3Ip3usT65z5eqLrwb3LGizMqbjI6ep/f2T3A2f95zRtXakq6HVk9n3QkM9DfczI2679Oc+0RzY795AXOMKZXuNUP4YCRMOkNeHswxN5vsYhrin2G2xaTFme6qTJ//GmFNTzbGm6Mzin9nTUh0xVUKC6n8bFGz0/7Z+veC6YSFhZmOd4DphpuBQU0hoTc/O0WlWR5oxJinKGl+6TkhQSFA9o39Y2sfSkJou6VFJcHEJDqoTHPSNZ3pUarIp2mKNjTdbVRZEeM4pTl6OKHu82dEnzhzlSLObU90CvZLTHFHRSWZTfJItOiopNfBzq83qsEelpDBJTXEpDpvF6gj0iE5LSjQlm5Nt9sxAt1RLvNVkznAEetnNcWa72RpjNjkyU8ypgSWS05IclgFRSWnmQK//aGOypTgCyzEZkkxAstjNMQ6TbYDZnmSzxv8fwxv+GA==';
+
+    const wasmBytes =  unzlibSync(base64Decode$1(bytes_1, new Uint8Array(lenIn)), new Uint8Array(lenOut));
+
+    const createWasm =  createWasmFn('crypto', wasmBytes);
+
+    const bridge = new Bridge(createWasm);
+    async function initBridge(createWasm) {
+        return bridge.init(createWasm);
+    }
+
+    function withWasm(fn) {
+        return (...params) => {
+            if (!bridge.wasm) {
+                throw new Error('The WASM interface has not been initialized. Ensure that you wait for the initialization Promise with waitReady() from @pezkuwi/wasm-crypto (or cryptoWaitReady() from @pezkuwi/util-crypto) before attempting to use WASM-only interfaces.');
+            }
+            return fn(bridge.wasm, ...params);
+        };
+    }
+    const bip39Generate =  withWasm((wasm, words) => {
+        wasm.ext_bip39_generate(8, words);
+        return bridge.resultString();
+    });
+    const bip39ToEntropy =  withWasm((wasm, phrase) => {
+        wasm.ext_bip39_to_entropy(8, ...bridge.allocString(phrase));
+        return bridge.resultU8a();
+    });
+    const bip39ToMiniSecret =  withWasm((wasm, phrase, password) => {
+        wasm.ext_bip39_to_mini_secret(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
+        return bridge.resultU8a();
+    });
+    const bip39ToSeed =  withWasm((wasm, phrase, password) => {
+        wasm.ext_bip39_to_seed(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
+        return bridge.resultU8a();
+    });
+    const bip39Validate =  withWasm((wasm, phrase) => {
+        const ret = wasm.ext_bip39_validate(...bridge.allocString(phrase));
+        return ret !== 0;
+    });
+    const ed25519KeypairFromSeed =  withWasm((wasm, seed) => {
+        wasm.ext_ed_from_seed(8, ...bridge.allocU8a(seed));
+        return bridge.resultU8a();
+    });
+    const ed25519Sign$1 =  withWasm((wasm, pubkey, seckey, message) => {
+        wasm.ext_ed_sign(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(seckey), ...bridge.allocU8a(message));
+        return bridge.resultU8a();
+    });
+    const ed25519Verify$1 =  withWasm((wasm, signature, message, pubkey) => {
+        const ret = wasm.ext_ed_verify(...bridge.allocU8a(signature), ...bridge.allocU8a(message), ...bridge.allocU8a(pubkey));
+        return ret !== 0;
+    });
+    const secp256k1FromSeed =  withWasm((wasm, seckey) => {
+        wasm.ext_secp_from_seed(8, ...bridge.allocU8a(seckey));
+        return bridge.resultU8a();
+    });
+    const secp256k1Compress$1 =  withWasm((wasm, pubkey) => {
+        wasm.ext_secp_pub_compress(8, ...bridge.allocU8a(pubkey));
+        return bridge.resultU8a();
+    });
+    const secp256k1Expand$1 =  withWasm((wasm, pubkey) => {
+        wasm.ext_secp_pub_expand(8, ...bridge.allocU8a(pubkey));
+        return bridge.resultU8a();
+    });
+    const secp256k1Recover$1 =  withWasm((wasm, msgHash, sig, recovery) => {
+        wasm.ext_secp_recover(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(sig), recovery);
+        return bridge.resultU8a();
+    });
+    const secp256k1Sign$1 =  withWasm((wasm, msgHash, seckey) => {
+        wasm.ext_secp_sign(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(seckey));
+        return bridge.resultU8a();
+    });
+    const blake2b$1 =  withWasm((wasm, data, key, size) => {
+        wasm.ext_blake2b(8, ...bridge.allocU8a(data), ...bridge.allocU8a(key), size);
+        return bridge.resultU8a();
+    });
+    const hmacSha256 =  withWasm((wasm, key, data) => {
+        wasm.ext_hmac_sha256(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const hmacSha512 =  withWasm((wasm, key, data) => {
+        wasm.ext_hmac_sha512(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const keccak256 =  withWasm((wasm, data) => {
+        wasm.ext_keccak256(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const keccak512 =  withWasm((wasm, data) => {
+        wasm.ext_keccak512(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const pbkdf2$1 =  withWasm((wasm, data, salt, rounds) => {
+        wasm.ext_pbkdf2(8, ...bridge.allocU8a(data), ...bridge.allocU8a(salt), rounds);
+        return bridge.resultU8a();
+    });
+    const scrypt$1 =  withWasm((wasm, password, salt, log2n, r, p) => {
+        wasm.ext_scrypt(8, ...bridge.allocU8a(password), ...bridge.allocU8a(salt), log2n, r, p);
+        return bridge.resultU8a();
+    });
+    const sha256$1 =  withWasm((wasm, data) => {
+        wasm.ext_sha256(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const sha512$2 =  withWasm((wasm, data) => {
+        wasm.ext_sha512(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const twox =  withWasm((wasm, data, rounds) => {
+        wasm.ext_twox(8, ...bridge.allocU8a(data), rounds);
+        return bridge.resultU8a();
+    });
+    function isReady() {
+        return !!bridge.wasm;
+    }
+    async function waitReady() {
+        try {
+            const wasm = await initBridge();
+            return !!wasm;
+        }
+        catch {
+            return false;
+        }
+    }
+
+    const cryptoIsReady = isReady;
+    function cryptoWaitReady() {
+        return waitReady()
+            .then(() => {
+            if (!isReady()) {
+                throw new Error('Unable to initialize @pezkuwi/util-crypto');
+            }
+            return true;
+        })
+            .catch(() => false);
+    }
+
+    cryptoWaitReady().catch(() => {
+    });
+
+    const packageInfo = { name: '@pezkuwi/util-crypto', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util-crypto.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.26' };
+
+    /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    function isBytes$2(a) {
+        return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+    }
+    function abytes$2(b, ...lengths) {
+        if (!isBytes$2(b))
+            throw new Error('Uint8Array expected');
+        if (lengths.length > 0 && !lengths.includes(b.length))
+            throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+    }
+    function isArrayOf(isString, arr) {
+        if (!Array.isArray(arr))
+            return false;
+        if (arr.length === 0)
+            return true;
+        if (isString) {
+            return arr.every((item) => typeof item === 'string');
+        }
+        else {
+            return arr.every((item) => Number.isSafeInteger(item));
+        }
+    }
+    function afn(input) {
+        if (typeof input !== 'function')
+            throw new Error('function expected');
+        return true;
+    }
+    function astr(label, input) {
+        if (typeof input !== 'string')
+            throw new Error(`${label}: string expected`);
+        return true;
+    }
+    function anumber$1(n) {
+        if (!Number.isSafeInteger(n))
+            throw new Error(`invalid integer: ${n}`);
+    }
+    function aArr(input) {
+        if (!Array.isArray(input))
+            throw new Error('array expected');
+    }
+    function astrArr(label, input) {
+        if (!isArrayOf(true, input))
+            throw new Error(`${label}: array of strings expected`);
+    }
+    function anumArr(label, input) {
+        if (!isArrayOf(false, input))
+            throw new Error(`${label}: array of numbers expected`);
+    }
+    function chain(...args) {
+        const id = (a) => a;
+        const wrap = (a, b) => (c) => a(b(c));
+        const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+        const decode = args.map((x) => x.decode).reduce(wrap, id);
+        return { encode, decode };
+    }
+    function alphabet(letters) {
+        const lettersA = typeof letters === 'string' ? letters.split('') : letters;
+        const len = lettersA.length;
+        astrArr('alphabet', lettersA);
+        const indexes = new Map(lettersA.map((l, i) => [l, i]));
+        return {
+            encode: (digits) => {
+                aArr(digits);
+                return digits.map((i) => {
+                    if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+                        throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+                    return lettersA[i];
+                });
+            },
+            decode: (input) => {
+                aArr(input);
+                return input.map((letter) => {
+                    astr('alphabet.decode', letter);
+                    const i = indexes.get(letter);
+                    if (i === undefined)
+                        throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+                    return i;
+                });
+            },
+        };
+    }
+    function join(separator = '') {
+        astr('join', separator);
+        return {
+            encode: (from) => {
+                astrArr('join.decode', from);
+                return from.join(separator);
+            },
+            decode: (to) => {
+                astr('join.decode', to);
+                return to.split(separator);
+            },
+        };
+    }
+    function padding(bits, chr = '=') {
+        anumber$1(bits);
+        astr('padding', chr);
+        return {
+            encode(data) {
+                astrArr('padding.encode', data);
+                while ((data.length * bits) % 8)
+                    data.push(chr);
+                return data;
+            },
+            decode(input) {
+                astrArr('padding.decode', input);
+                let end = input.length;
+                if ((end * bits) % 8)
+                    throw new Error('padding: invalid, string should have whole number of bytes');
+                for (; end > 0 && input[end - 1] === chr; end--) {
+                    const last = end - 1;
+                    const byte = last * bits;
+                    if (byte % 8 === 0)
+                        throw new Error('padding: invalid, string has too much padding');
+                }
+                return input.slice(0, end);
+            },
+        };
+    }
+    function normalize$1(fn) {
+        afn(fn);
+        return { encode: (from) => from, decode: (to) => fn(to) };
+    }
+    function convertRadix(data, from, to) {
+        if (from < 2)
+            throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+        if (to < 2)
+            throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+        aArr(data);
+        if (!data.length)
+            return [];
+        let pos = 0;
+        const res = [];
+        const digits = Array.from(data, (d) => {
+            anumber$1(d);
+            if (d < 0 || d >= from)
+                throw new Error(`invalid integer: ${d}`);
+            return d;
+        });
+        const dlen = digits.length;
+        while (true) {
+            let carry = 0;
+            let done = true;
+            for (let i = pos; i < dlen; i++) {
+                const digit = digits[i];
+                const fromCarry = from * carry;
+                const digitBase = fromCarry + digit;
+                if (!Number.isSafeInteger(digitBase) ||
+                    fromCarry / from !== carry ||
+                    digitBase - digit !== fromCarry) {
+                    throw new Error('convertRadix: carry overflow');
+                }
+                const div = digitBase / to;
+                carry = digitBase % to;
+                const rounded = Math.floor(div);
+                digits[i] = rounded;
+                if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+                    throw new Error('convertRadix: carry overflow');
+                if (!done)
+                    continue;
+                else if (!rounded)
+                    pos = i;
+                else
+                    done = false;
+            }
+            res.push(carry);
+            if (done)
+                break;
+        }
+        for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+            res.push(0);
+        return res.reverse();
+    }
+    const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
+    const radix2carry =  (from, to) => from + (to - gcd(from, to));
+    const powers =  (() => {
+        let res = [];
+        for (let i = 0; i < 40; i++)
+            res.push(2 ** i);
+        return res;
+    })();
+    function convertRadix2(data, from, to, padding) {
+        aArr(data);
+        if (from <= 0 || from > 32)
+            throw new Error(`convertRadix2: wrong from=${from}`);
+        if (to <= 0 || to > 32)
+            throw new Error(`convertRadix2: wrong to=${to}`);
+        if (radix2carry(from, to) > 32) {
+            throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+        }
+        let carry = 0;
+        let pos = 0;
+        const max = powers[from];
+        const mask = powers[to] - 1;
+        const res = [];
+        for (const n of data) {
+            anumber$1(n);
+            if (n >= max)
+                throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+            carry = (carry << from) | n;
+            if (pos + from > 32)
+                throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+            pos += from;
+            for (; pos >= to; pos -= to)
+                res.push(((carry >> (pos - to)) & mask) >>> 0);
+            const pow = powers[pos];
+            if (pow === undefined)
+                throw new Error('invalid carry');
+            carry &= pow - 1;
+        }
+        carry = (carry << (to - pos)) & mask;
+        if (!padding && pos >= from)
+            throw new Error('Excess padding');
+        if (!padding && carry > 0)
+            throw new Error(`Non-zero padding: ${carry}`);
+        if (padding && pos > 0)
+            res.push(carry >>> 0);
+        return res;
+    }
+    function radix(num) {
+        anumber$1(num);
+        const _256 = 2 ** 8;
+        return {
+            encode: (bytes) => {
+                if (!isBytes$2(bytes))
+                    throw new Error('radix.encode input should be Uint8Array');
+                return convertRadix(Array.from(bytes), _256, num);
+            },
+            decode: (digits) => {
+                anumArr('radix.decode', digits);
+                return Uint8Array.from(convertRadix(digits, num, _256));
+            },
+        };
+    }
+    function radix2(bits, revPadding = false) {
+        anumber$1(bits);
+        if (bits <= 0 || bits > 32)
+            throw new Error('radix2: bits should be in (0..32]');
+        if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+            throw new Error('radix2: carry overflow');
+        return {
+            encode: (bytes) => {
+                if (!isBytes$2(bytes))
+                    throw new Error('radix2.encode input should be Uint8Array');
+                return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+            },
+            decode: (digits) => {
+                anumArr('radix2.decode', digits);
+                return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+            },
+        };
+    }
+    function unsafeWrapper(fn) {
+        afn(fn);
+        return function (...args) {
+            try {
+                return fn.apply(null, args);
+            }
+            catch (e) { }
+        };
+    }
+    function checksum(len, fn) {
+        anumber$1(len);
+        afn(fn);
+        return {
+            encode(data) {
+                if (!isBytes$2(data))
+                    throw new Error('checksum.encode: input should be Uint8Array');
+                const sum = fn(data).slice(0, len);
+                const res = new Uint8Array(data.length + len);
+                res.set(data);
+                res.set(sum, data.length);
+                return res;
+            },
+            decode(data) {
+                if (!isBytes$2(data))
+                    throw new Error('checksum.decode: input should be Uint8Array');
+                const payload = data.slice(0, -len);
+                const oldChecksum = data.slice(-len);
+                const newChecksum = fn(payload).slice(0, len);
+                for (let i = 0; i < len; i++)
+                    if (newChecksum[i] !== oldChecksum[i])
+                        throw new Error('Invalid checksum');
+                return payload;
+            },
+        };
+    }
+    const utils = {
+        alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,
+    };
+    chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));
+    chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));
+    chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));
+    chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));
+    chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));
+    chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize$1((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));
+    const hasBase64Builtin =  (() => typeof Uint8Array.from([]).toBase64 === 'function' &&
+        typeof Uint8Array.fromBase64 === 'function')();
+    const decodeBase64Builtin = (s, isUrl) => {
+        astr('base64', s);
+        const re = /^[A-Za-z0-9=+/]+$/;
+        const alphabet = 'base64';
+        if (s.length > 0 && !re.test(s))
+            throw new Error('invalid base64');
+        return Uint8Array.fromBase64(s, { alphabet, lastChunkHandling: 'strict' });
+    };
+    const base64 = hasBase64Builtin ? {
+        encode(b) { abytes$2(b); return b.toBase64(); },
+        decode(s) { return decodeBase64Builtin(s); },
+    } : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));
+    chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));
+    hasBase64Builtin ? {
+        } : chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));
+    chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), join(''));
+    const genBase58 =  (abc) => chain(radix(58), alphabet(abc), join(''));
+    const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+    genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');
+    genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');
+    const BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));
+    const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+    function bech32Polymod(pre) {
+        const b = pre >> 25;
+        let chk = (pre & 0x1ffffff) << 5;
+        for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
+            if (((b >> i) & 1) === 1)
+                chk ^= POLYMOD_GENERATORS[i];
+        }
+        return chk;
+    }
+    function bechChecksum(prefix, words, encodingConst = 1) {
+        const len = prefix.length;
+        let chk = 1;
+        for (let i = 0; i < len; i++) {
+            const c = prefix.charCodeAt(i);
+            if (c < 33 || c > 126)
+                throw new Error(`Invalid prefix (${prefix})`);
+            chk = bech32Polymod(chk) ^ (c >> 5);
+        }
+        chk = bech32Polymod(chk);
+        for (let i = 0; i < len; i++)
+            chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);
+        for (let v of words)
+            chk = bech32Polymod(chk) ^ v;
+        for (let i = 0; i < 6; i++)
+            chk = bech32Polymod(chk);
+        chk ^= encodingConst;
+        return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+    }
+    function genBech32(encoding) {
+        const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;
+        const _words = radix2(5);
+        const fromWords = _words.decode;
+        const toWords = _words.encode;
+        const fromWordsUnsafe = unsafeWrapper(fromWords);
+        function encode(prefix, words, limit = 90) {
+            astr('bech32.encode prefix', prefix);
+            if (isBytes$2(words))
+                words = Array.from(words);
+            anumArr('bech32.encode', words);
+            const plen = prefix.length;
+            if (plen === 0)
+                throw new TypeError(`Invalid prefix length ${plen}`);
+            const actualLength = plen + 7 + words.length;
+            if (limit !== false && actualLength > limit)
+                throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+            const lowered = prefix.toLowerCase();
+            const sum = bechChecksum(lowered, words, ENCODING_CONST);
+            return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+        }
+        function decode(str, limit = 90) {
+            astr('bech32.decode input', str);
+            const slen = str.length;
+            if (slen < 8 || (limit !== false && slen > limit))
+                throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+            const lowered = str.toLowerCase();
+            if (str !== lowered && str !== str.toUpperCase())
+                throw new Error(`String must be lowercase or uppercase`);
+            const sepIndex = lowered.lastIndexOf('1');
+            if (sepIndex === 0 || sepIndex === -1)
+                throw new Error(`Letter "1" must be present between prefix and data only`);
+            const prefix = lowered.slice(0, sepIndex);
+            const data = lowered.slice(sepIndex + 1);
+            if (data.length < 6)
+                throw new Error('Data must be at least 6 characters long');
+            const words = BECH_ALPHABET.decode(data).slice(0, -6);
+            const sum = bechChecksum(prefix, words, ENCODING_CONST);
+            if (!data.endsWith(sum))
+                throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+            return { prefix, words };
+        }
+        const decodeUnsafe = unsafeWrapper(decode);
+        function decodeToBytes(str) {
+            const { prefix, words } = decode(str, false);
+            return { prefix, words, bytes: fromWords(words) };
+        }
+        function encodeFromBytes(prefix, bytes) {
+            return encode(prefix, toWords(bytes));
+        }
+        return {
+            encode,
+            decode,
+            encodeFromBytes,
+            decodeToBytes,
+            decodeUnsafe,
+            fromWords,
+            fromWordsUnsafe,
+            toWords,
+        };
+    }
+    genBech32('bech32');
+    genBech32('bech32m');
+    const hasHexBuiltin$1 =  (() => typeof Uint8Array.from([]).toHex === 'function' &&
+        typeof Uint8Array.fromHex === 'function')();
+    const hexBuiltin = {
+        };
+    hasHexBuiltin$1
+        ? hexBuiltin
+        : chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize$1((s) => {
+            if (typeof s !== 'string' || s.length % 2 !== 0)
+                throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+            return s.toLowerCase();
+        }));
+
+    function createDecode({ coder, ipfs }, validate) {
+        return (value, ipfsCompat) => {
+            validate(value, ipfsCompat);
+            return coder.decode(ipfs && ipfsCompat
+                ? value.substring(1)
+                : value);
+        };
+    }
+    function createEncode({ coder, ipfs }) {
+        return (value, ipfsCompat) => {
+            const out = coder.encode(util.u8aToU8a(value));
+            return ipfs && ipfsCompat
+                ? `${ipfs}${out}`
+                : out;
+        };
+    }
+    function createIs(validate) {
+        return (value, ipfsCompat) => {
+            try {
+                return validate(value, ipfsCompat);
+            }
+            catch {
+                return false;
+            }
+        };
+    }
+    function createValidate({ chars, ipfs, type, withPadding }) {
+        return (value, ipfsCompat) => {
+            if (typeof value !== 'string') {
+                throw new Error(`Expected ${type} string input`);
+            }
+            else if (ipfs && ipfsCompat && !value.startsWith(ipfs)) {
+                throw new Error(`Expected ipfs-compatible ${type} to start with '${ipfs}'`);
+            }
+            for (let i = (ipfsCompat ? 1 : 0), count = value.length; i < count; i++) {
+                if (chars.includes(value[i])) ;
+                else if (withPadding && value[i] === '=') {
+                    if (i === count - 1) ;
+                    else if (value[i + 1] === '=') ;
+                    else {
+                        throw new Error(`Invalid ${type} padding sequence "${value[i]}${value[i + 1]}" at index ${i}`);
+                    }
+                }
+                else {
+                    throw new Error(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+                }
+            }
+            return true;
+        };
+    }
+
+    const config$2 = {
+        chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+        coder: base58,
+        ipfs: 'z',
+        type: 'base58'
+    };
+    const base58Validate =  createValidate(config$2);
+    const base58Decode =  createDecode(config$2, base58Validate);
+    const base58Encode =  createEncode(config$2);
+    const isBase58 =  createIs(base58Validate);
+
+    const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+
+    /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    function isBytes$1(a) {
+        return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+    }
+    function anumber(n) {
+        if (!Number.isSafeInteger(n) || n < 0)
+            throw new Error('positive integer expected, got ' + n);
+    }
+    function abytes$1(b, ...lengths) {
+        if (!isBytes$1(b))
+            throw new Error('Uint8Array expected');
+        if (lengths.length > 0 && !lengths.includes(b.length))
+            throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+    }
+    function ahash(h) {
+        if (typeof h !== 'function' || typeof h.create !== 'function')
+            throw new Error('Hash should be wrapped by utils.createHasher');
+        anumber(h.outputLen);
+        anumber(h.blockLen);
+    }
+    function aexists(instance, checkFinished = true) {
+        if (instance.destroyed)
+            throw new Error('Hash instance has been destroyed');
+        if (checkFinished && instance.finished)
+            throw new Error('Hash#digest() has already been called');
+    }
+    function aoutput(out, instance) {
+        abytes$1(out);
+        const min = instance.outputLen;
+        if (out.length < min) {
+            throw new Error('digestInto() expects output buffer of length at least ' + min);
+        }
+    }
+    function u32(arr) {
+        return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    }
+    function clean(...arrays) {
+        for (let i = 0; i < arrays.length; i++) {
+            arrays[i].fill(0);
+        }
+    }
+    function createView(arr) {
+        return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    }
+    function rotr(word, shift) {
+        return (word << (32 - shift)) | (word >>> shift);
+    }
+    function rotl$1(word, shift) {
+        return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+    }
+    const isLE =  (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+    function byteSwap(word) {
+        return (((word << 24) & 0xff000000) |
+            ((word << 8) & 0xff0000) |
+            ((word >>> 8) & 0xff00) |
+            ((word >>> 24) & 0xff));
+    }
+    const swap8IfBE = isLE
+        ? (n) => n
+        : (n) => byteSwap(n);
+    function byteSwap32(arr) {
+        for (let i = 0; i < arr.length; i++) {
+            arr[i] = byteSwap(arr[i]);
+        }
+        return arr;
+    }
+    const swap32IfBE = isLE
+        ? (u) => u
+        : byteSwap32;
+    const hasHexBuiltin =  (() =>
+    typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+    const hexes =  Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+    function bytesToHex(bytes) {
+        abytes$1(bytes);
+        if (hasHexBuiltin)
+            return bytes.toHex();
+        let hex = '';
+        for (let i = 0; i < bytes.length; i++) {
+            hex += hexes[bytes[i]];
+        }
+        return hex;
+    }
+    const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function asciiToBase16(ch) {
+        if (ch >= asciis._0 && ch <= asciis._9)
+            return ch - asciis._0;
+        if (ch >= asciis.A && ch <= asciis.F)
+            return ch - (asciis.A - 10);
+        if (ch >= asciis.a && ch <= asciis.f)
+            return ch - (asciis.a - 10);
+        return;
+    }
+    function hexToBytes(hex) {
+        if (typeof hex !== 'string')
+            throw new Error('hex string expected, got ' + typeof hex);
+        if (hasHexBuiltin)
+            return Uint8Array.fromHex(hex);
+        const hl = hex.length;
+        const al = hl / 2;
+        if (hl % 2)
+            throw new Error('hex string expected, got unpadded hex of length ' + hl);
+        const array = new Uint8Array(al);
+        for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+            const n1 = asciiToBase16(hex.charCodeAt(hi));
+            const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+            if (n1 === undefined || n2 === undefined) {
+                const char = hex[hi] + hex[hi + 1];
+                throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+            }
+            array[ai] = n1 * 16 + n2;
+        }
+        return array;
+    }
+    function utf8ToBytes(str) {
+        if (typeof str !== 'string')
+            throw new Error('string expected');
+        return new Uint8Array(new TextEncoder().encode(str));
+    }
+    function toBytes(data) {
+        if (typeof data === 'string')
+            data = utf8ToBytes(data);
+        abytes$1(data);
+        return data;
+    }
+    function kdfInputToBytes(data) {
+        if (typeof data === 'string')
+            data = utf8ToBytes(data);
+        abytes$1(data);
+        return data;
+    }
+    function concatBytes(...arrays) {
+        let sum = 0;
+        for (let i = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            abytes$1(a);
+            sum += a.length;
+        }
+        const res = new Uint8Array(sum);
+        for (let i = 0, pad = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            res.set(a, pad);
+            pad += a.length;
+        }
+        return res;
+    }
+    function checkOpts(defaults, opts) {
+        if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+            throw new Error('options should be object or undefined');
+        const merged = Object.assign(defaults, opts);
+        return merged;
+    }
+    class Hash {
+    }
+    function createHasher$1(hashCons) {
+        const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+        const tmp = hashCons();
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = () => hashCons();
+        return hashC;
+    }
+    function createOptHasher(hashCons) {
+        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+        const tmp = hashCons({});
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = (opts) => hashCons(opts);
+        return hashC;
+    }
+    function createXOFer(hashCons) {
+        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+        const tmp = hashCons({});
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = (opts) => hashCons(opts);
+        return hashC;
+    }
+    function randomBytes(bytesLength = 32) {
+        if (crypto && typeof crypto.getRandomValues === 'function') {
+            return crypto.getRandomValues(new Uint8Array(bytesLength));
+        }
+        if (crypto && typeof crypto.randomBytes === 'function') {
+            return Uint8Array.from(crypto.randomBytes(bytesLength));
+        }
+        throw new Error('crypto.getRandomValues must be defined');
+    }
+
+    const BSIGMA =  Uint8Array.from([
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+        11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+        7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+        9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+        2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+        12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+        13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+        6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+        10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+        11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+        7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+        9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+        2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    ]);
+    function G1s(a, b, c, d, x) {
+        a = (a + b + x) | 0;
+        d = rotr(d ^ a, 16);
+        c = (c + d) | 0;
+        b = rotr(b ^ c, 12);
+        return { a, b, c, d };
+    }
+    function G2s(a, b, c, d, x) {
+        a = (a + b + x) | 0;
+        d = rotr(d ^ a, 8);
+        c = (c + d) | 0;
+        b = rotr(b ^ c, 7);
+        return { a, b, c, d };
+    }
+
+    function setBigUint64(view, byteOffset, value, isLE) {
+        if (typeof view.setBigUint64 === 'function')
+            return view.setBigUint64(byteOffset, value, isLE);
+        const _32n = BigInt(32);
+        const _u32_max = BigInt(0xffffffff);
+        const wh = Number((value >> _32n) & _u32_max);
+        const wl = Number(value & _u32_max);
+        const h = isLE ? 4 : 0;
+        const l = isLE ? 0 : 4;
+        view.setUint32(byteOffset + h, wh, isLE);
+        view.setUint32(byteOffset + l, wl, isLE);
+    }
+    function Chi(a, b, c) {
+        return (a & b) ^ (~a & c);
+    }
+    function Maj(a, b, c) {
+        return (a & b) ^ (a & c) ^ (b & c);
+    }
+    class HashMD extends Hash {
+        constructor(blockLen, outputLen, padOffset, isLE) {
+            super();
+            this.finished = false;
+            this.length = 0;
+            this.pos = 0;
+            this.destroyed = false;
+            this.blockLen = blockLen;
+            this.outputLen = outputLen;
+            this.padOffset = padOffset;
+            this.isLE = isLE;
+            this.buffer = new Uint8Array(blockLen);
+            this.view = createView(this.buffer);
+        }
+        update(data) {
+            aexists(this);
+            data = toBytes(data);
+            abytes$1(data);
+            const { view, buffer, blockLen } = this;
+            const len = data.length;
+            for (let pos = 0; pos < len;) {
+                const take = Math.min(blockLen - this.pos, len - pos);
+                if (take === blockLen) {
+                    const dataView = createView(data);
+                    for (; blockLen <= len - pos; pos += blockLen)
+                        this.process(dataView, pos);
+                    continue;
+                }
+                buffer.set(data.subarray(pos, pos + take), this.pos);
+                this.pos += take;
+                pos += take;
+                if (this.pos === blockLen) {
+                    this.process(view, 0);
+                    this.pos = 0;
+                }
+            }
+            this.length += data.length;
+            this.roundClean();
+            return this;
+        }
+        digestInto(out) {
+            aexists(this);
+            aoutput(out, this);
+            this.finished = true;
+            const { buffer, view, blockLen, isLE } = this;
+            let { pos } = this;
+            buffer[pos++] = 0b10000000;
+            clean(this.buffer.subarray(pos));
+            if (this.padOffset > blockLen - pos) {
+                this.process(view, 0);
+                pos = 0;
+            }
+            for (let i = pos; i < blockLen; i++)
+                buffer[i] = 0;
+            setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+            this.process(view, 0);
+            const oview = createView(out);
+            const len = this.outputLen;
+            if (len % 4)
+                throw new Error('_sha2: outputLen should be aligned to 32bit');
+            const outLen = len / 4;
+            const state = this.get();
+            if (outLen > state.length)
+                throw new Error('_sha2: outputLen bigger than state');
+            for (let i = 0; i < outLen; i++)
+                oview.setUint32(4 * i, state[i], isLE);
+        }
+        digest() {
+            const { buffer, outputLen } = this;
+            this.digestInto(buffer);
+            const res = buffer.slice(0, outputLen);
+            this.destroy();
+            return res;
+        }
+        _cloneInto(to) {
+            to || (to = new this.constructor());
+            to.set(...this.get());
+            const { blockLen, buffer, length, finished, destroyed, pos } = this;
+            to.destroyed = destroyed;
+            to.finished = finished;
+            to.length = length;
+            to.pos = pos;
+            if (length % blockLen)
+                to.buffer.set(buffer);
+            return to;
+        }
+        clone() {
+            return this._cloneInto();
+        }
+    }
+    const SHA256_IV =  Uint32Array.from([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const SHA224_IV =  Uint32Array.from([
+        0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
+    ]);
+    const SHA384_IV =  Uint32Array.from([
+        0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,
+        0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,
+    ]);
+    const SHA512_IV =  Uint32Array.from([
+        0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
+        0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+    ]);
+
+    const U32_MASK64 =  BigInt(2 ** 32 - 1);
+    const _32n$1 =  BigInt(32);
+    function fromBig(n, le = false) {
+        if (le)
+            return { h: Number(n & U32_MASK64), l: Number((n >> _32n$1) & U32_MASK64) };
+        return { h: Number((n >> _32n$1) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+    }
+    function split(lst, le = false) {
+        const len = lst.length;
+        let Ah = new Uint32Array(len);
+        let Al = new Uint32Array(len);
+        for (let i = 0; i < len; i++) {
+            const { h, l } = fromBig(lst[i], le);
+            [Ah[i], Al[i]] = [h, l];
+        }
+        return [Ah, Al];
+    }
+    const shrSH = (h, _l, s) => h >>> s;
+    const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+    const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+    const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+    const rotr32H = (_h, l) => l;
+    const rotr32L = (h, _l) => h;
+    const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+    const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+    const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+    const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+    function add(Ah, Al, Bh, Bl) {
+        const l = (Al >>> 0) + (Bl >>> 0);
+        return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+    }
+    const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+    const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+    const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+
+    const B2B_IV =  Uint32Array.from([
+        0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
+        0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
+    ]);
+    const BBUF =  new Uint32Array(32);
+    function G1b(a, b, c, d, msg, x) {
+        const Xl = msg[x], Xh = msg[x + 1];
+        let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+        let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+        let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+        let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+        let ll = add3L(Al, Bl, Xl);
+        Ah = add3H(ll, Ah, Bh, Xh);
+        Al = ll | 0;
+        ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+        ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh) });
+        ({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
+        ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+        ({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
+        (BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah);
+        (BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh);
+        (BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch);
+        (BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh);
+    }
+    function G2b(a, b, c, d, msg, x) {
+        const Xl = msg[x], Xh = msg[x + 1];
+        let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+        let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+        let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+        let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+        let ll = add3L(Al, Bl, Xl);
+        Ah = add3H(ll, Ah, Bh, Xh);
+        Al = ll | 0;
+        ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+        ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+        ({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
+        ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+        ({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
+        (BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah);
+        (BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh);
+        (BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch);
+        (BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh);
+    }
+    function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+        anumber(keyLen);
+        if (outputLen < 0 || outputLen > keyLen)
+            throw new Error('outputLen bigger than keyLen');
+        const { key, salt, personalization } = opts;
+        if (key !== undefined && (key.length < 1 || key.length > keyLen))
+            throw new Error('key length must be undefined or 1..' + keyLen);
+        if (salt !== undefined && salt.length !== saltLen)
+            throw new Error('salt must be undefined or ' + saltLen);
+        if (personalization !== undefined && personalization.length !== persLen)
+            throw new Error('personalization must be undefined or ' + persLen);
+    }
+    class BLAKE2 extends Hash {
+        constructor(blockLen, outputLen) {
+            super();
+            this.finished = false;
+            this.destroyed = false;
+            this.length = 0;
+            this.pos = 0;
+            anumber(blockLen);
+            anumber(outputLen);
+            this.blockLen = blockLen;
+            this.outputLen = outputLen;
+            this.buffer = new Uint8Array(blockLen);
+            this.buffer32 = u32(this.buffer);
+        }
+        update(data) {
+            aexists(this);
+            data = toBytes(data);
+            abytes$1(data);
+            const { blockLen, buffer, buffer32 } = this;
+            const len = data.length;
+            const offset = data.byteOffset;
+            const buf = data.buffer;
+            for (let pos = 0; pos < len;) {
+                if (this.pos === blockLen) {
+                    swap32IfBE(buffer32);
+                    this.compress(buffer32, 0, false);
+                    swap32IfBE(buffer32);
+                    this.pos = 0;
+                }
+                const take = Math.min(blockLen - this.pos, len - pos);
+                const dataOffset = offset + pos;
+                if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+                    const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+                    swap32IfBE(data32);
+                    for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+                        this.length += blockLen;
+                        this.compress(data32, pos32, false);
+                    }
+                    swap32IfBE(data32);
+                    continue;
+                }
+                buffer.set(data.subarray(pos, pos + take), this.pos);
+                this.pos += take;
+                this.length += take;
+                pos += take;
+            }
+            return this;
+        }
+        digestInto(out) {
+            aexists(this);
+            aoutput(out, this);
+            const { pos, buffer32 } = this;
+            this.finished = true;
+            clean(this.buffer.subarray(pos));
+            swap32IfBE(buffer32);
+            this.compress(buffer32, 0, true);
+            swap32IfBE(buffer32);
+            const out32 = u32(out);
+            this.get().forEach((v, i) => (out32[i] = swap8IfBE(v)));
+        }
+        digest() {
+            const { buffer, outputLen } = this;
+            this.digestInto(buffer);
+            const res = buffer.slice(0, outputLen);
+            this.destroy();
+            return res;
+        }
+        _cloneInto(to) {
+            const { buffer, length, finished, destroyed, outputLen, pos } = this;
+            to || (to = new this.constructor({ dkLen: outputLen }));
+            to.set(...this.get());
+            to.buffer.set(buffer);
+            to.destroyed = destroyed;
+            to.finished = finished;
+            to.length = length;
+            to.pos = pos;
+            to.outputLen = outputLen;
+            return to;
+        }
+        clone() {
+            return this._cloneInto();
+        }
+    }
+    class BLAKE2b extends BLAKE2 {
+        constructor(opts = {}) {
+            const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
+            super(128, olen);
+            this.v0l = B2B_IV[0] | 0;
+            this.v0h = B2B_IV[1] | 0;
+            this.v1l = B2B_IV[2] | 0;
+            this.v1h = B2B_IV[3] | 0;
+            this.v2l = B2B_IV[4] | 0;
+            this.v2h = B2B_IV[5] | 0;
+            this.v3l = B2B_IV[6] | 0;
+            this.v3h = B2B_IV[7] | 0;
+            this.v4l = B2B_IV[8] | 0;
+            this.v4h = B2B_IV[9] | 0;
+            this.v5l = B2B_IV[10] | 0;
+            this.v5h = B2B_IV[11] | 0;
+            this.v6l = B2B_IV[12] | 0;
+            this.v6h = B2B_IV[13] | 0;
+            this.v7l = B2B_IV[14] | 0;
+            this.v7h = B2B_IV[15] | 0;
+            checkBlake2Opts(olen, opts, 64, 16, 16);
+            let { key, personalization, salt } = opts;
+            let keyLength = 0;
+            if (key !== undefined) {
+                key = toBytes(key);
+                keyLength = key.length;
+            }
+            this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+            if (salt !== undefined) {
+                salt = toBytes(salt);
+                const slt = u32(salt);
+                this.v4l ^= swap8IfBE(slt[0]);
+                this.v4h ^= swap8IfBE(slt[1]);
+                this.v5l ^= swap8IfBE(slt[2]);
+                this.v5h ^= swap8IfBE(slt[3]);
+            }
+            if (personalization !== undefined) {
+                personalization = toBytes(personalization);
+                const pers = u32(personalization);
+                this.v6l ^= swap8IfBE(pers[0]);
+                this.v6h ^= swap8IfBE(pers[1]);
+                this.v7l ^= swap8IfBE(pers[2]);
+                this.v7h ^= swap8IfBE(pers[3]);
+            }
+            if (key !== undefined) {
+                const tmp = new Uint8Array(this.blockLen);
+                tmp.set(key);
+                this.update(tmp);
+            }
+        }
+        get() {
+            let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+            return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+        }
+        set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+            this.v0l = v0l | 0;
+            this.v0h = v0h | 0;
+            this.v1l = v1l | 0;
+            this.v1h = v1h | 0;
+            this.v2l = v2l | 0;
+            this.v2h = v2h | 0;
+            this.v3l = v3l | 0;
+            this.v3h = v3h | 0;
+            this.v4l = v4l | 0;
+            this.v4h = v4h | 0;
+            this.v5l = v5l | 0;
+            this.v5h = v5h | 0;
+            this.v6l = v6l | 0;
+            this.v6h = v6h | 0;
+            this.v7l = v7l | 0;
+            this.v7h = v7h | 0;
+        }
+        compress(msg, offset, isLast) {
+            this.get().forEach((v, i) => (BBUF[i] = v));
+            BBUF.set(B2B_IV, 16);
+            let { h, l } = fromBig(BigInt(this.length));
+            BBUF[24] = B2B_IV[8] ^ l;
+            BBUF[25] = B2B_IV[9] ^ h;
+            if (isLast) {
+                BBUF[28] = ~BBUF[28];
+                BBUF[29] = ~BBUF[29];
+            }
+            let j = 0;
+            const s = BSIGMA;
+            for (let i = 0; i < 12; i++) {
+                G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+                G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+                G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+                G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+                G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+                G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+                G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+                G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+                G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+                G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+                G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+                G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+                G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+                G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+                G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+                G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+            }
+            this.v0l ^= BBUF[0] ^ BBUF[16];
+            this.v0h ^= BBUF[1] ^ BBUF[17];
+            this.v1l ^= BBUF[2] ^ BBUF[18];
+            this.v1h ^= BBUF[3] ^ BBUF[19];
+            this.v2l ^= BBUF[4] ^ BBUF[20];
+            this.v2h ^= BBUF[5] ^ BBUF[21];
+            this.v3l ^= BBUF[6] ^ BBUF[22];
+            this.v3h ^= BBUF[7] ^ BBUF[23];
+            this.v4l ^= BBUF[8] ^ BBUF[24];
+            this.v4h ^= BBUF[9] ^ BBUF[25];
+            this.v5l ^= BBUF[10] ^ BBUF[26];
+            this.v5h ^= BBUF[11] ^ BBUF[27];
+            this.v6l ^= BBUF[12] ^ BBUF[28];
+            this.v6h ^= BBUF[13] ^ BBUF[29];
+            this.v7l ^= BBUF[14] ^ BBUF[30];
+            this.v7h ^= BBUF[15] ^ BBUF[31];
+            clean(BBUF);
+        }
+        destroy() {
+            this.destroyed = true;
+            clean(this.buffer32);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+    const blake2b =  createOptHasher((opts) => new BLAKE2b(opts));
+    function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+        let j = 0;
+        for (let i = 0; i < rounds; i++) {
+            ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+            ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+            ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+            ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+            ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+            ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+            ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+            ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+            ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+            ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+            ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+            ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+            ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+            ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+            ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+            ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+        }
+        return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+    }
+    const B2S_IV = SHA256_IV;
+    class BLAKE2s extends BLAKE2 {
+        constructor(opts = {}) {
+            const olen = opts.dkLen === undefined ? 32 : opts.dkLen;
+            super(64, olen);
+            this.v0 = B2S_IV[0] | 0;
+            this.v1 = B2S_IV[1] | 0;
+            this.v2 = B2S_IV[2] | 0;
+            this.v3 = B2S_IV[3] | 0;
+            this.v4 = B2S_IV[4] | 0;
+            this.v5 = B2S_IV[5] | 0;
+            this.v6 = B2S_IV[6] | 0;
+            this.v7 = B2S_IV[7] | 0;
+            checkBlake2Opts(olen, opts, 32, 8, 8);
+            let { key, personalization, salt } = opts;
+            let keyLength = 0;
+            if (key !== undefined) {
+                key = toBytes(key);
+                keyLength = key.length;
+            }
+            this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+            if (salt !== undefined) {
+                salt = toBytes(salt);
+                const slt = u32(salt);
+                this.v4 ^= swap8IfBE(slt[0]);
+                this.v5 ^= swap8IfBE(slt[1]);
+            }
+            if (personalization !== undefined) {
+                personalization = toBytes(personalization);
+                const pers = u32(personalization);
+                this.v6 ^= swap8IfBE(pers[0]);
+                this.v7 ^= swap8IfBE(pers[1]);
+            }
+            if (key !== undefined) {
+                abytes$1(key);
+                const tmp = new Uint8Array(this.blockLen);
+                tmp.set(key);
+                this.update(tmp);
+            }
+        }
+        get() {
+            const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+            return [v0, v1, v2, v3, v4, v5, v6, v7];
+        }
+        set(v0, v1, v2, v3, v4, v5, v6, v7) {
+            this.v0 = v0 | 0;
+            this.v1 = v1 | 0;
+            this.v2 = v2 | 0;
+            this.v3 = v3 | 0;
+            this.v4 = v4 | 0;
+            this.v5 = v5 | 0;
+            this.v6 = v6 | 0;
+            this.v7 = v7 | 0;
+        }
+        compress(msg, offset, isLast) {
+            const { h, l } = fromBig(BigInt(this.length));
+            const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(BSIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l ^ B2S_IV[4], h ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);
+            this.v0 ^= v0 ^ v8;
+            this.v1 ^= v1 ^ v9;
+            this.v2 ^= v2 ^ v10;
+            this.v3 ^= v3 ^ v11;
+            this.v4 ^= v4 ^ v12;
+            this.v5 ^= v5 ^ v13;
+            this.v6 ^= v6 ^ v14;
+            this.v7 ^= v7 ^ v15;
+        }
+        destroy() {
+            this.destroyed = true;
+            clean(this.buffer32);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+    createOptHasher((opts) => new BLAKE2s(opts));
+
+    function createAsHex(fn) {
+        return (...args) => util.u8aToHex(fn(...args));
+    }
+    function createBitHasher(bitLength, fn) {
+        return (data, onlyJs) => fn(data, bitLength, onlyJs);
+    }
+    function createDualHasher(wa, js) {
+        return (value, bitLength = 256, onlyJs) => {
+            const u8a = util.u8aToU8a(value);
+            return !util.hasBigInt || (!onlyJs && isReady())
+                ? wa[bitLength](u8a)
+                : js[bitLength](u8a);
+        };
+    }
+
+    function blake2AsU8a(data, bitLength = 256, key, onlyJs) {
+        const byteLength = Math.ceil(bitLength / 8);
+        const u8a = util.u8aToU8a(data);
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? blake2b$1(u8a, util.u8aToU8a(key), byteLength)
+            : key
+                ? blake2b(u8a, { dkLen: byteLength, key })
+                : blake2b(u8a, { dkLen: byteLength });
+    }
+    const blake2AsHex =  createAsHex(blake2AsU8a);
+
+    const SS58_PREFIX = util.stringToU8a('SS58PRE');
+    function sshash(key) {
+        return blake2AsU8a(util.u8aConcat(SS58_PREFIX, key), 512);
+    }
+
+    function checkAddressChecksum(decoded) {
+        const ss58Length = (decoded[0] & 0b0100_0000) ? 2 : 1;
+        const ss58Decoded = ss58Length === 1
+            ? decoded[0]
+            : ((decoded[0] & 0b0011_1111) << 2) | (decoded[1] >> 6) | ((decoded[1] & 0b0011_1111) << 8);
+        const isPublicKey = [34 + ss58Length, 35 + ss58Length].includes(decoded.length);
+        const length = decoded.length - (isPublicKey ? 2 : 1);
+        const hash = sshash(decoded.subarray(0, length));
+        const isValid = (decoded[0] & 0b1000_0000) === 0 && ![46, 47].includes(decoded[0]) && (isPublicKey
+            ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
+            : decoded[decoded.length - 1] === hash[0]);
+        return [isValid, length, ss58Length, ss58Decoded];
+    }
+
+    const knownGenesis = {
+        acala: [
+            '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
+        ],
+        ajuna: [
+            '0xe358eb1d11b31255a286c12e44fe6780b7edb171d657905a97e39f71d9c6c3ee'
+        ],
+        'aleph-node': [
+            '0x70255b4d28de0fc4e1a193d7e175ad1ccef431598211c55538f1018651a0344e'
+        ],
+        astar: [
+            '0x9eb76c5184c4ab8679d2d5d819fdf90b9c001403e9e17da2e14b6d8aec4029c6'
+        ],
+        basilisk: [
+            '0xa85cfb9b9fd4d622a5b28289a02347af987d8f73fa3108450e2b4a11c1ce5755'
+        ],
+        bifrost: [
+            '0x262e1b2ad728475fd6fe88e62d34c200abe6fd693931ddad144059b1eb884e5b'
+        ],
+        'bifrost-kusama': [
+            '0x9f28c6a68e0fc9646eff64935684f6eeeece527e37bbe1f213d22caa1d9d6bed'
+        ],
+        bittensor: [
+            '0x2f0555cc76fc2840a25a6ea3b9637146806f1f44b090c175ffde2a7e5ab36c03'
+        ],
+        centrifuge: [
+            '0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82',
+            '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
+        ],
+        cere: [
+            '0x81443836a9a24caaa23f1241897d1235717535711d1d3fe24eae4fdc942c092c'
+        ],
+        composable: [
+            '0xdaab8df776eb52ec604a5df5d388bb62a050a0aaec4556a64265b9d42755552d'
+        ],
+        creditcoin3: [
+            '0x4436a7d64e363df85e065a894721002a86643283f9707338bf195d360ba2ee71',
+            '0xfc4ec97a1c1f119c4353aecb4a17c7c0cf7b40d5d660143d8bad9117e9866572',
+            '0xfc9df99a665f964aed6649f275055e54df5e3420489538ed31d7788f53d11ef6'
+        ],
+        darwinia: [
+            '0xe71578b37a7c799b0ab4ee87ffa6f059a6b98f71f06fb8c84a8d88013a548ad6'
+        ],
+        dentnet: [
+            '0x0313f6a011d128d22f996703cbab05162e2fdc9e031493314fe6db79979c5ca7'
+        ],
+        'dock-mainnet': [
+            '0x6bfe24dca2a3be10f22212678ac13a6446ec764103c0f3471c71609eac384aae',
+            '0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'
+        ],
+        edgeware: [
+            '0x742a2ca70c2fda6cee4f8df98d64c4c670a052d9568058982dad9d5a7a135c5b'
+        ],
+        encointer: [
+            '0x7dd99936c1e9e6d1ce7d90eb6f33bea8393b4bf87677d675aa63c9cb3e8c5b5b'
+        ],
+        enjin: [
+            '0xd8761d3c88f26dc12875c00d3165f7d67243d56fc85b4cf19937601a7916e5a9'
+        ],
+        equilibrium: [
+            '0x6f1a800de3daff7f5e037ddf66ab22ce03ab91874debeddb1086f5f7dbd48925'
+        ],
+        frequency: [
+            '0x4a587bf17a404e3572747add7aab7bbe56e805a5479c6c436f07f36fcc8d3ae1'
+        ],
+        genshiro: [
+            '0x9b8cefc0eb5c568b527998bdd76c184e2b76ae561be76e4667072230217ea243'
+        ],
+        hydradx: [
+            '0xafdc188f45c71dacbaa0b62e16a91f726c7b8699a9748cdf715459de6b7f366d',
+            '0xd2a620c27ec5cbc5621ff9a522689895074f7cca0d08e7134a7804e1a3ba86fc',
+            '0x10af6e84234477d84dc572bac0789813b254aa490767ed06fb9591191d1073f9',
+            '0x3d75507dd46301767e601265791da1d9cb47b6ebc94e87347b635e5bf58bd047',
+            '0x0ed32bfcab4a83517fac88f2aa7cbc2f88d3ab93be9a12b6188a036bf8a943c2'
+        ],
+        integritee: [
+            '0xcdedc8eadbfa209d3f207bba541e57c3c58a667b05a2e1d1e86353c9000758da',
+            '0xe13e7af377c64e83f95e0d70d5e5c3c01d697a84538776c5b9bbe0e7d7b6034c'
+        ],
+        'interlay-parachain': [
+            '0xbf88efe70e9e0e916416e8bed61f2b45717f517d7f3523e33c7b001e5ffcbc72'
+        ],
+        karura: [
+            '0xbaf5aabe40646d11f0ee8abbdc64f4a4b7674925cba08e4a05ff9ebed6e2126b'
+        ],
+        khala: [
+            '0xd43540ba6d3eb4897c28a77d48cb5b729fea37603cbbfc7a86a73b72adb3be8d'
+        ],
+        kulupu: [
+            '0xf7a99d3cb92853d00d5275c971c132c074636256583fee53b3bbe60d7b8769ba'
+        ],
+        kusama: [
+            '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe',
+            '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636',
+            '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf'
+        ],
+        liberland: [
+            '0x6bd89e052d67a45bb60a9a23e8581053d5e0d619f15cb9865946937e690c42d6'
+        ],
+        matrixchain: [
+            '0x3af4ff48ec76d2efc8476730f423ac07e25ad48f5f4c9dc39c778b164d808615'
+        ],
+        mythos: [
+            '0xf6ee56e9c5277df5b4ce6ae9983ee88f3cbed27d31beeb98f9f84f997a1ab0b9'
+        ],
+        nodle: [
+            '0x97da7ede98d7bad4e36b4d734b6055425a3be036da2a332ea5a7037656427a21'
+        ],
+        origintrail: [
+            '0xe7e0962324a3b86c83404dbea483f25fb5dab4c224791c81b756cfc948006174'
+        ],
+        p3d: [
+            '0x6c5894837ad89b6d92b114a2fb3eafa8fe3d26a54848e3447015442cd6ef4e66'
+        ],
+        parallel: [
+            '0xe61a41c53f5dcd0beb09df93b34402aada44cb05117b71059cce40a2723a4e97'
+        ],
+        peaq: [
+            '0xd2a5d385932d1f650dae03ef8e2748983779ee342c614f80854d32b8cd8fa48c'
+        ],
+        pendulum: [
+            '0x5d3c298622d5634ed019bf61ea4b71655030015bde9beb0d6a24743714462c86'
+        ],
+        phala: [
+            '0x1bb969d85965e4bb5a651abbedf21a54b6b31a21f66b5401cc3f1e286268d736'
+        ],
+        picasso: [
+            '0x6811a339673c9daa897944dcdac99c6e2939cc88245ed21951a0a3c9a2be75bc',
+            '0xe8e7f0f4c4f5a00720b4821dbfddefea7490bcf0b19009961cc46957984e2c1c'
+        ],
+        polimec: [
+            '0x7eb9354488318e7549c722669dcbdcdc526f1fef1420e7944667212f3601fdbd'
+        ],
+        polkadex: [
+            '0x3920bcb4960a1eef5580cd5367ff3f430eef052774f78468852f7b9cb39f8a3c'
+        ],
+        polkadot: [
+            '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+        ],
+        polymesh: [
+            '0x6fbd74e5e1d0a61d52ccfe9d4adaed16dd3a7caa37c6bc4d0c2fa12e8b2f4063'
+        ],
+        quartz: [
+            '0xcd4d732201ebe5d6b014edda071c4203e16867305332301dc8d092044b28e554'
+        ],
+        rococo: [
+            '0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e',
+            '0xaaf2cd1b74b5f726895921259421b534124726263982522174147046b8827897',
+            '0x037f5f3c8e67b314062025fc886fcd6238ea25a4a9b45dce8d246815c9ebe770',
+            '0xc196f81260cf1686172b47a79cf002120735d7cb0eb1474e8adce56618456fff',
+            '0xf6e9983c37baf68846fedafe21e56718790e39fb1c582abc408b81bc7b208f9a',
+            '0x5fce687da39305dfe682b117f0820b319348e8bb37eb16cf34acbf6a202de9d9',
+            '0xe7c3d5edde7db964317cd9b51a3a059d7cd99f81bdbce14990047354334c9779',
+            '0x1611e1dbf0405379b861e2e27daa90f480b2e6d3682414a80835a52e8cb8a215',
+            '0x343442f12fa715489a8714e79a7b264ea88c0d5b8c66b684a7788a516032f6b9',
+            '0x78bcd530c6b3a068bc17473cf5d2aff9c287102bed9af3ae3c41c33b9d6c6147',
+            '0x47381ee0697153d64404fc578392c8fd5cba9073391908f46c888498415647bd',
+            '0x19c0e4fa8ab75f5ac7865e0b8f74ff91eb9a100d336f423cd013a8befba40299'
+        ],
+        sora: [
+            '0x7e4e32d0feafd4f9c9414b0be86373f9a1efa904809b683453a9af6856d38ad5'
+        ],
+        stafi: [
+            '0x290a4149f09ea0e402c74c1c7e96ae4239588577fe78932f94f5404c68243d80'
+        ],
+        statemine: [
+            '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a'
+        ],
+        statemint: [
+            '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f'
+        ],
+        subsocial: [
+            '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
+        ],
+        ternoa: [
+            '0x6859c81ca95ef624c9dfe4dc6e3381c33e5d6509e35e147092bfbc780f777c4e'
+        ],
+        unique: [
+            '0x84322d9cddbf35088f1e54e9a85c967a41a56a4f43445768125e61af166c7d31'
+        ],
+        vara: [
+            '0xfe1b4c55fd4d668101126434206571a7838a8b6b93a6d1b95d607e78e6c53763'
+        ],
+        vtb: [
+            '0x286bc8414c7000ce1d6ee6a834e29a54c1784814b76243eb77ed0b2c5573c60f',
+            '0x7483b89572fb2bd687c7b9a93b242d0b237f9aba463aba07ec24503931038aaa'
+        ],
+        westend: [
+            '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e'
+        ],
+        xxnetwork: [
+            '0x50dd5d206917bf10502c68fb4d18a59fc8aa31586f4e8856b493e43544aa82aa'
+        ],
+        zagros: [
+            '0x1b0b4727bbb5e44ed587d1056b4ad537ffb330034509a58866a088d77e792cd5'
+        ],
+        zeitgeist: [
+            '0x1bf2a2ecb4a868de66ea8610f2ce7c8c43706561b6476031315f6640fe38e060'
+        ]
+    };
+
+    const knownIcon = {
+        centrifuge: 'polkadot',
+        kusama: 'polkadot',
+        polkadot: 'polkadot',
+        sora: 'polkadot',
+        statemine: 'polkadot',
+        statemint: 'polkadot',
+        westmint: 'polkadot'
+    };
+
+    const knownLedger = {
+        acala: 0x00000313,
+        ajuna: 0x00000162,
+        'aleph-node': 0x00000283,
+        astar: 0x0000032a,
+        bifrost: 0x00000314,
+        'bifrost-kusama': 0x00000314,
+        bittensor: 0x00000162,
+        centrifuge: 0x000002eb,
+        composable: 0x00000162,
+        creditcoin3: 0x00000162,
+        darwinia: 0x00000162,
+        dentnet: 0x000002de,
+        'dock-mainnet': 0x00000252,
+        edgeware: 0x0000020b,
+        encointer: 0x000001b2,
+        enjin: 0x00000483,
+        equilibrium: 0x05f5e0fd,
+        frequency: 0x0000082b,
+        genshiro: 0x05f5e0fc,
+        hydradx: 0x00000162,
+        integritee: 0x000007df,
+        'interlay-parachain': 0x00000162,
+        karura: 0x000002ae,
+        khala: 0x000001b2,
+        kusama: 0x000001b2,
+        liberland: 0x000002ff,
+        matrixchain: 0x00000483,
+        mythos: 0x0000003c,
+        nodle: 0x000003eb,
+        origintrail: 0x00000162,
+        parallel: 0x00000162,
+        peaq: 0x00000d0a,
+        pendulum: 0x00000162,
+        phala: 0x00000162,
+        picasso: 0x000001b2,
+        polimec: 0x00000d10,
+        polkadex: 0x0000031f,
+        polkadot: 0x00000162,
+        polymesh: 0x00000253,
+        quartz: 0x00000277,
+        sora: 0x00000269,
+        stafi: 0x0000038b,
+        statemine: 0x000001b2,
+        statemint: 0x00000162,
+        ternoa: 0x00003e3,
+        unique: 0x00000295,
+        vara: 0x00001370,
+        vtb: 0x000002b6,
+        xxnetwork: 0x000007a3,
+        zeitgeist: 0x00000162
+    };
+
+    const knownTestnet = {
+        '': true,
+        'cess-testnet': true,
+        'dock-testnet': true,
+        jupiter: true,
+        'mathchain-testnet': true,
+        p3dt: true,
+        subspace_testnet: true,
+        'zero-alphaville': true
+    };
+
+    const UNSORTED = [42];
+    const TESTNETS = ['testnet'];
+    const customNetworks = [
+        {
+            decimals: [12],
+            displayName: 'Pezkuwi Relay Chain',
+            network: 'pezkuwi',
+            prefix: 42,
+            standardAccount: '*25519',
+            symbols: ['HEZ'],
+            website: 'https://pezkuwichain.io'
+        },
+        {
+            decimals: [12],
+            displayName: 'Zagros Relay Chain',
+            network: 'zagros',
+            prefix: 42,
+            standardAccount: '*25519',
+            symbols: ['HEZ'],
+            website: 'https://zagros.pezkuwichain.io'
+        },
+        {
+            decimals: [12],
+            displayName: 'Bizinikiwi',
+            network: 'bizinikiwi',
+            prefix: 42,
+            standardAccount: '*25519',
+            symbols: ['BZN'],
+            website: 'https://bizinikiwi.pezkuwichain.io'
+        }
+    ];
+    function toExpanded(o) {
+        const network = o.network || '';
+        const nameParts = network.replace(/_/g, '-').split('-');
+        const n = o;
+        n.slip44 = knownLedger[network];
+        n.hasLedgerSupport = !!n.slip44;
+        n.genesisHash = knownGenesis[network] || [];
+        n.icon = knownIcon[network] || 'substrate';
+        n.isTestnet = !!knownTestnet[network] || TESTNETS.includes(nameParts[nameParts.length - 1]);
+        n.isIgnored = n.isTestnet || (!(o.standardAccount &&
+            o.decimals?.length &&
+            o.symbols?.length) &&
+            o.prefix !== 42);
+        return n;
+    }
+    function filterSelectable({ genesisHash, prefix }) {
+        return !!genesisHash.length || prefix === 42;
+    }
+    function filterAvailable(n) {
+        return !n.isIgnored && !!n.network;
+    }
+    function sortNetworks(a, b) {
+        const isUnSortedA = UNSORTED.includes(a.prefix);
+        const isUnSortedB = UNSORTED.includes(b.prefix);
+        return isUnSortedA === isUnSortedB
+            ? isUnSortedA
+                ? 0
+                : a.displayName.localeCompare(b.displayName)
+            : isUnSortedA
+                ? -1
+                : 1;
+    }
+    const allNetworks = customNetworks.map(toExpanded);
+    const availableNetworks = allNetworks.filter(filterAvailable).sort(sortNetworks);
+    const selectableNetworks = availableNetworks.filter(filterSelectable);
+
+    const defaults = {
+        allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
+        allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
+        allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
+        prefix: 42
+    };
+
+    function decodeAddress(encoded, ignoreChecksum, ss58Format = -1) {
+        if (!encoded) {
+            throw new Error('Invalid empty address passed');
+        }
+        if (util.isU8a(encoded) || util.isHex(encoded)) {
+            return util.u8aToU8a(encoded);
+        }
+        try {
+            const decoded = base58Decode(encoded);
+            if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
+                throw new Error('Invalid decoded address length');
+            }
+            const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
+            if (!isValid && !ignoreChecksum) {
+                throw new Error('Invalid decoded address checksum');
+            }
+            else if (ss58Format !== -1 && ss58Format !== ss58Decoded) {
+                throw new Error(`Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
+            }
+            return decoded.slice(ss58Length, endPos);
+        }
+        catch (error) {
+            throw new Error(`Decoding ${encoded}: ${error.message}`);
+        }
+    }
+
+    function addressToEvm(address, ignoreChecksum) {
+        return decodeAddress(address, ignoreChecksum).subarray(0, 20);
+    }
+
+    function checkAddress(address, prefix) {
+        let decoded;
+        try {
+            decoded = base58Decode(address);
+        }
+        catch (error) {
+            return [false, error.message];
+        }
+        const [isValid, , , ss58Decoded] = checkAddressChecksum(decoded);
+        if (ss58Decoded !== prefix) {
+            return [false, `Prefix mismatch, expected ${prefix}, found ${ss58Decoded}`];
+        }
+        else if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
+            return [false, 'Invalid decoded address length'];
+        }
+        return [isValid, isValid ? null : 'Invalid decoded address checksum'];
+    }
+
+    const BN_BE_OPTS = { isLe: false };
+    const BN_LE_OPTS = { isLe: true };
+    const BN_LE_16_OPTS = { bitLength: 16, isLe: true };
+    const BN_BE_32_OPTS = { bitLength: 32, isLe: false };
+    const BN_LE_32_OPTS = { bitLength: 32, isLe: true };
+    const BN_BE_256_OPTS = { bitLength: 256, isLe: false };
+    const BN_LE_256_OPTS = { bitLength: 256, isLe: true };
+    const BN_LE_512_OPTS = { bitLength: 512, isLe: true };
+
+    const RE_NUMBER = /^\d+$/;
+    const JUNCTION_ID_LEN = 32;
+    class DeriveJunction {
+        #chainCode = new Uint8Array(32);
+        #isHard = false;
+        static from(value) {
+            const result = new DeriveJunction();
+            const [code, isHard] = value.startsWith('/')
+                ? [value.substring(1), true]
+                : [value, false];
+            result.soft(RE_NUMBER.test(code)
+                ? new util.BN(code, 10)
+                : code);
+            return isHard
+                ? result.harden()
+                : result;
+        }
+        get chainCode() {
+            return this.#chainCode;
+        }
+        get isHard() {
+            return this.#isHard;
+        }
+        get isSoft() {
+            return !this.#isHard;
+        }
+        hard(value) {
+            return this.soft(value).harden();
+        }
+        harden() {
+            this.#isHard = true;
+            return this;
+        }
+        soft(value) {
+            if (util.isNumber(value) || util.isBn(value) || util.isBigInt(value)) {
+                return this.soft(util.bnToU8a(value, BN_LE_256_OPTS));
+            }
+            else if (util.isHex(value)) {
+                return this.soft(util.hexToU8a(value));
+            }
+            else if (util.isString(value)) {
+                return this.soft(util.compactAddLength(util.stringToU8a(value)));
+            }
+            else if (value.length > JUNCTION_ID_LEN) {
+                return this.soft(blake2AsU8a(value));
+            }
+            this.#chainCode.fill(0);
+            this.#chainCode.set(value, 0);
+            return this;
+        }
+        soften() {
+            this.#isHard = false;
+            return this;
+        }
+    }
+
+    const RE_JUNCTION = /\/(\/?)([^/]+)/g;
+    function keyExtractPath(derivePath) {
+        const parts = derivePath.match(RE_JUNCTION);
+        const path = [];
+        let constructed = '';
+        if (parts) {
+            constructed = parts.join('');
+            for (const p of parts) {
+                path.push(DeriveJunction.from(p.substring(1)));
+            }
+        }
+        if (constructed !== derivePath) {
+            throw new Error(`Re-constructed path "${constructed}" does not match input`);
+        }
+        return {
+            parts,
+            path
+        };
+    }
+
+    const RE_CAPTURE = /^((0x[a-fA-F0-9]+|[\p{L}\d]+(?: [\p{L}\d]+)*))((\/\/?[^/]+)*)(\/\/\/(.*))?$/u;
+    function keyExtractSuri(suri) {
+        const normalizedSuri = suri.normalize('NFC');
+        const matches = normalizedSuri.match(RE_CAPTURE);
+        if (matches === null) {
+            throw new Error('Unable to match provided value to a secret URI');
+        }
+        const [, phrase, , derivePath, , , password] = matches;
+        const { path } = keyExtractPath(derivePath);
+        return {
+            derivePath,
+            password,
+            path,
+            phrase
+        };
+    }
+
+    const HDKD$2 = util.compactAddLength(util.stringToU8a('Secp256k1HDKD'));
+    function secp256k1DeriveHard(seed, chainCode) {
+        if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        return blake2AsU8a(util.u8aConcat(HDKD$2, seed, chainCode), 256);
+    }
+
+    const SHA256_K =  Uint32Array.from([
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    ]);
+    const SHA256_W =  new Uint32Array(64);
+    class SHA256 extends HashMD {
+        constructor(outputLen = 32) {
+            super(64, outputLen, 8, false);
+            this.A = SHA256_IV[0] | 0;
+            this.B = SHA256_IV[1] | 0;
+            this.C = SHA256_IV[2] | 0;
+            this.D = SHA256_IV[3] | 0;
+            this.E = SHA256_IV[4] | 0;
+            this.F = SHA256_IV[5] | 0;
+            this.G = SHA256_IV[6] | 0;
+            this.H = SHA256_IV[7] | 0;
+        }
+        get() {
+            const { A, B, C, D, E, F, G, H } = this;
+            return [A, B, C, D, E, F, G, H];
+        }
+        set(A, B, C, D, E, F, G, H) {
+            this.A = A | 0;
+            this.B = B | 0;
+            this.C = C | 0;
+            this.D = D | 0;
+            this.E = E | 0;
+            this.F = F | 0;
+            this.G = G | 0;
+            this.H = H | 0;
+        }
+        process(view, offset) {
+            for (let i = 0; i < 16; i++, offset += 4)
+                SHA256_W[i] = view.getUint32(offset, false);
+            for (let i = 16; i < 64; i++) {
+                const W15 = SHA256_W[i - 15];
+                const W2 = SHA256_W[i - 2];
+                const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+                const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+                SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+            }
+            let { A, B, C, D, E, F, G, H } = this;
+            for (let i = 0; i < 64; i++) {
+                const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+                const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+                const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+                const T2 = (sigma0 + Maj(A, B, C)) | 0;
+                H = G;
+                G = F;
+                F = E;
+                E = (D + T1) | 0;
+                D = C;
+                C = B;
+                B = A;
+                A = (T1 + T2) | 0;
+            }
+            A = (A + this.A) | 0;
+            B = (B + this.B) | 0;
+            C = (C + this.C) | 0;
+            D = (D + this.D) | 0;
+            E = (E + this.E) | 0;
+            F = (F + this.F) | 0;
+            G = (G + this.G) | 0;
+            H = (H + this.H) | 0;
+            this.set(A, B, C, D, E, F, G, H);
+        }
+        roundClean() {
+            clean(SHA256_W);
+        }
+        destroy() {
+            this.set(0, 0, 0, 0, 0, 0, 0, 0);
+            clean(this.buffer);
+        }
+    }
+    class SHA224 extends SHA256 {
+        constructor() {
+            super(28);
+            this.A = SHA224_IV[0] | 0;
+            this.B = SHA224_IV[1] | 0;
+            this.C = SHA224_IV[2] | 0;
+            this.D = SHA224_IV[3] | 0;
+            this.E = SHA224_IV[4] | 0;
+            this.F = SHA224_IV[5] | 0;
+            this.G = SHA224_IV[6] | 0;
+            this.H = SHA224_IV[7] | 0;
+        }
+    }
+    const K512 =  (() => split([
+        '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+        '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+        '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+        '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+        '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+        '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+        '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+        '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+        '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+        '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+        '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+        '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+        '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+        '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+        '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+        '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+        '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+        '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+        '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+        '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+    ].map(n => BigInt(n))))();
+    const SHA512_Kh =  (() => K512[0])();
+    const SHA512_Kl =  (() => K512[1])();
+    const SHA512_W_H =  new Uint32Array(80);
+    const SHA512_W_L =  new Uint32Array(80);
+    class SHA512 extends HashMD {
+        constructor(outputLen = 64) {
+            super(128, outputLen, 16, false);
+            this.Ah = SHA512_IV[0] | 0;
+            this.Al = SHA512_IV[1] | 0;
+            this.Bh = SHA512_IV[2] | 0;
+            this.Bl = SHA512_IV[3] | 0;
+            this.Ch = SHA512_IV[4] | 0;
+            this.Cl = SHA512_IV[5] | 0;
+            this.Dh = SHA512_IV[6] | 0;
+            this.Dl = SHA512_IV[7] | 0;
+            this.Eh = SHA512_IV[8] | 0;
+            this.El = SHA512_IV[9] | 0;
+            this.Fh = SHA512_IV[10] | 0;
+            this.Fl = SHA512_IV[11] | 0;
+            this.Gh = SHA512_IV[12] | 0;
+            this.Gl = SHA512_IV[13] | 0;
+            this.Hh = SHA512_IV[14] | 0;
+            this.Hl = SHA512_IV[15] | 0;
+        }
+        get() {
+            const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+        }
+        set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+            this.Ah = Ah | 0;
+            this.Al = Al | 0;
+            this.Bh = Bh | 0;
+            this.Bl = Bl | 0;
+            this.Ch = Ch | 0;
+            this.Cl = Cl | 0;
+            this.Dh = Dh | 0;
+            this.Dl = Dl | 0;
+            this.Eh = Eh | 0;
+            this.El = El | 0;
+            this.Fh = Fh | 0;
+            this.Fl = Fl | 0;
+            this.Gh = Gh | 0;
+            this.Gl = Gl | 0;
+            this.Hh = Hh | 0;
+            this.Hl = Hl | 0;
+        }
+        process(view, offset) {
+            for (let i = 0; i < 16; i++, offset += 4) {
+                SHA512_W_H[i] = view.getUint32(offset);
+                SHA512_W_L[i] = view.getUint32((offset += 4));
+            }
+            for (let i = 16; i < 80; i++) {
+                const W15h = SHA512_W_H[i - 15] | 0;
+                const W15l = SHA512_W_L[i - 15] | 0;
+                const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+                const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+                const W2h = SHA512_W_H[i - 2] | 0;
+                const W2l = SHA512_W_L[i - 2] | 0;
+                const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+                const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+                const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+                const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+                SHA512_W_H[i] = SUMh | 0;
+                SHA512_W_L[i] = SUMl | 0;
+            }
+            let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            for (let i = 0; i < 80; i++) {
+                const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+                const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+                const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+                const CHIl = (El & Fl) ^ (~El & Gl);
+                const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+                const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+                const T1l = T1ll | 0;
+                const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+                const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+                const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+                const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+                Hh = Gh | 0;
+                Hl = Gl | 0;
+                Gh = Fh | 0;
+                Gl = Fl | 0;
+                Fh = Eh | 0;
+                Fl = El | 0;
+                ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+                Dh = Ch | 0;
+                Dl = Cl | 0;
+                Ch = Bh | 0;
+                Cl = Bl | 0;
+                Bh = Ah | 0;
+                Bl = Al | 0;
+                const All = add3L(T1l, sigma0l, MAJl);
+                Ah = add3H(All, T1h, sigma0h, MAJh);
+                Al = All | 0;
+            }
+            ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+            ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+            ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+            ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+            ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+            ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+            ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+            ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+            this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+        }
+        roundClean() {
+            clean(SHA512_W_H, SHA512_W_L);
+        }
+        destroy() {
+            clean(this.buffer);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+    class SHA384 extends SHA512 {
+        constructor() {
+            super(48);
+            this.Ah = SHA384_IV[0] | 0;
+            this.Al = SHA384_IV[1] | 0;
+            this.Bh = SHA384_IV[2] | 0;
+            this.Bl = SHA384_IV[3] | 0;
+            this.Ch = SHA384_IV[4] | 0;
+            this.Cl = SHA384_IV[5] | 0;
+            this.Dh = SHA384_IV[6] | 0;
+            this.Dl = SHA384_IV[7] | 0;
+            this.Eh = SHA384_IV[8] | 0;
+            this.El = SHA384_IV[9] | 0;
+            this.Fh = SHA384_IV[10] | 0;
+            this.Fl = SHA384_IV[11] | 0;
+            this.Gh = SHA384_IV[12] | 0;
+            this.Gl = SHA384_IV[13] | 0;
+            this.Hh = SHA384_IV[14] | 0;
+            this.Hl = SHA384_IV[15] | 0;
+        }
+    }
+    const T224_IV =  Uint32Array.from([
+        0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,
+        0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,
+    ]);
+    const T256_IV =  Uint32Array.from([
+        0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,
+        0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,
+    ]);
+    class SHA512_224 extends SHA512 {
+        constructor() {
+            super(28);
+            this.Ah = T224_IV[0] | 0;
+            this.Al = T224_IV[1] | 0;
+            this.Bh = T224_IV[2] | 0;
+            this.Bl = T224_IV[3] | 0;
+            this.Ch = T224_IV[4] | 0;
+            this.Cl = T224_IV[5] | 0;
+            this.Dh = T224_IV[6] | 0;
+            this.Dl = T224_IV[7] | 0;
+            this.Eh = T224_IV[8] | 0;
+            this.El = T224_IV[9] | 0;
+            this.Fh = T224_IV[10] | 0;
+            this.Fl = T224_IV[11] | 0;
+            this.Gh = T224_IV[12] | 0;
+            this.Gl = T224_IV[13] | 0;
+            this.Hh = T224_IV[14] | 0;
+            this.Hl = T224_IV[15] | 0;
+        }
+    }
+    class SHA512_256 extends SHA512 {
+        constructor() {
+            super(32);
+            this.Ah = T256_IV[0] | 0;
+            this.Al = T256_IV[1] | 0;
+            this.Bh = T256_IV[2] | 0;
+            this.Bl = T256_IV[3] | 0;
+            this.Ch = T256_IV[4] | 0;
+            this.Cl = T256_IV[5] | 0;
+            this.Dh = T256_IV[6] | 0;
+            this.Dl = T256_IV[7] | 0;
+            this.Eh = T256_IV[8] | 0;
+            this.El = T256_IV[9] | 0;
+            this.Fh = T256_IV[10] | 0;
+            this.Fl = T256_IV[11] | 0;
+            this.Gh = T256_IV[12] | 0;
+            this.Gl = T256_IV[13] | 0;
+            this.Hh = T256_IV[14] | 0;
+            this.Hl = T256_IV[15] | 0;
+        }
+    }
+    const sha256 =  createHasher$1(() => new SHA256());
+    createHasher$1(() => new SHA224());
+    const sha512$1 =  createHasher$1(() => new SHA512());
+    createHasher$1(() => new SHA384());
+    createHasher$1(() => new SHA512_256());
+    createHasher$1(() => new SHA512_224());
+
+    class HMAC extends Hash {
+        constructor(hash, _key) {
+            super();
+            this.finished = false;
+            this.destroyed = false;
+            ahash(hash);
+            const key = toBytes(_key);
+            this.iHash = hash.create();
+            if (typeof this.iHash.update !== 'function')
+                throw new Error('Expected instance of class which extends utils.Hash');
+            this.blockLen = this.iHash.blockLen;
+            this.outputLen = this.iHash.outputLen;
+            const blockLen = this.blockLen;
+            const pad = new Uint8Array(blockLen);
+            pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+            for (let i = 0; i < pad.length; i++)
+                pad[i] ^= 0x36;
+            this.iHash.update(pad);
+            this.oHash = hash.create();
+            for (let i = 0; i < pad.length; i++)
+                pad[i] ^= 0x36 ^ 0x5c;
+            this.oHash.update(pad);
+            clean(pad);
+        }
+        update(buf) {
+            aexists(this);
+            this.iHash.update(buf);
+            return this;
+        }
+        digestInto(out) {
+            aexists(this);
+            abytes$1(out, this.outputLen);
+            this.finished = true;
+            this.iHash.digestInto(out);
+            this.oHash.update(out);
+            this.oHash.digestInto(out);
+            this.destroy();
+        }
+        digest() {
+            const out = new Uint8Array(this.oHash.outputLen);
+            this.digestInto(out);
+            return out;
+        }
+        _cloneInto(to) {
+            to || (to = Object.create(Object.getPrototypeOf(this), {}));
+            const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+            to = to;
+            to.finished = finished;
+            to.destroyed = destroyed;
+            to.blockLen = blockLen;
+            to.outputLen = outputLen;
+            to.oHash = oHash._cloneInto(to.oHash);
+            to.iHash = iHash._cloneInto(to.iHash);
+            return to;
+        }
+        clone() {
+            return this._cloneInto();
+        }
+        destroy() {
+            this.destroyed = true;
+            this.oHash.destroy();
+            this.iHash.destroy();
+        }
+    }
+    const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+    hmac.create = (hash, key) => new HMAC(hash, key);
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$9 =  BigInt(0);
+    const _1n$8 =  BigInt(1);
+    function _abool2(value, title = '') {
+        if (typeof value !== 'boolean') {
+            const prefix = title && `"${title}"`;
+            throw new Error(prefix + 'expected boolean, got type=' + typeof value);
+        }
+        return value;
+    }
+    function _abytes2(value, length, title = '') {
+        const bytes = isBytes$1(value);
+        const len = value?.length;
+        const needsLen = length !== undefined;
+        if (!bytes || (needsLen && len !== length)) {
+            const prefix = title && `"${title}" `;
+            const ofLen = needsLen ? ` of length ${length}` : '';
+            const got = bytes ? `length=${len}` : `type=${typeof value}`;
+            throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);
+        }
+        return value;
+    }
+    function numberToHexUnpadded(num) {
+        const hex = num.toString(16);
+        return hex.length & 1 ? '0' + hex : hex;
+    }
+    function hexToNumber(hex) {
+        if (typeof hex !== 'string')
+            throw new Error('hex string expected, got ' + typeof hex);
+        return hex === '' ? _0n$9 : BigInt('0x' + hex);
+    }
+    function bytesToNumberBE(bytes) {
+        return hexToNumber(bytesToHex(bytes));
+    }
+    function bytesToNumberLE$1(bytes) {
+        abytes$1(bytes);
+        return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+    }
+    function numberToBytesBE(n, len) {
+        return hexToBytes(n.toString(16).padStart(len * 2, '0'));
+    }
+    function numberToBytesLE$1(n, len) {
+        return numberToBytesBE(n, len).reverse();
+    }
+    function ensureBytes(title, hex, expectedLength) {
+        let res;
+        if (typeof hex === 'string') {
+            try {
+                res = hexToBytes(hex);
+            }
+            catch (e) {
+                throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);
+            }
+        }
+        else if (isBytes$1(hex)) {
+            res = Uint8Array.from(hex);
+        }
+        else {
+            throw new Error(title + ' must be hex string or Uint8Array');
+        }
+        const len = res.length;
+        if (typeof expectedLength === 'number' && len !== expectedLength)
+            throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);
+        return res;
+    }
+    function equalBytes(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let diff = 0;
+        for (let i = 0; i < a.length; i++)
+            diff |= a[i] ^ b[i];
+        return diff === 0;
+    }
+    function copyBytes(bytes) {
+        return Uint8Array.from(bytes);
+    }
+    const isPosBig = (n) => typeof n === 'bigint' && _0n$9 <= n;
+    function inRange(n, min, max) {
+        return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+    }
+    function aInRange$1(title, n, min, max) {
+        if (!inRange(n, min, max))
+            throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);
+    }
+    function bitLen(n) {
+        let len;
+        for (len = 0; n > _0n$9; n >>= _1n$8, len += 1)
+            ;
+        return len;
+    }
+    const bitMask$1 = (n) => (_1n$8 << BigInt(n)) - _1n$8;
+    function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+        if (typeof hashLen !== 'number' || hashLen < 2)
+            throw new Error('hashLen must be a number');
+        if (typeof qByteLen !== 'number' || qByteLen < 2)
+            throw new Error('qByteLen must be a number');
+        if (typeof hmacFn !== 'function')
+            throw new Error('hmacFn must be a function');
+        const u8n = (len) => new Uint8Array(len);
+        const u8of = (byte) => Uint8Array.of(byte);
+        let v = u8n(hashLen);
+        let k = u8n(hashLen);
+        let i = 0;
+        const reset = () => {
+            v.fill(1);
+            k.fill(0);
+            i = 0;
+        };
+        const h = (...b) => hmacFn(k, v, ...b);
+        const reseed = (seed = u8n(0)) => {
+            k = h(u8of(0x00), seed);
+            v = h();
+            if (seed.length === 0)
+                return;
+            k = h(u8of(0x01), seed);
+            v = h();
+        };
+        const gen = () => {
+            if (i++ >= 1000)
+                throw new Error('drbg: tried 1000 values');
+            let len = 0;
+            const out = [];
+            while (len < qByteLen) {
+                v = h();
+                const sl = v.slice();
+                out.push(sl);
+                len += v.length;
+            }
+            return concatBytes(...out);
+        };
+        const genUntil = (seed, pred) => {
+            reset();
+            reseed(seed);
+            let res = undefined;
+            while (!(res = pred(gen())))
+                reseed();
+            reset();
+            return res;
+        };
+        return genUntil;
+    }
+    function isHash(val) {
+        return typeof val === 'function' && Number.isSafeInteger(val.outputLen);
+    }
+    function _validateObject(object, fields, optFields = {}) {
+        if (!object || typeof object !== 'object')
+            throw new Error('expected valid options object');
+        function checkField(fieldName, expectedType, isOpt) {
+            const val = object[fieldName];
+            if (isOpt && val === undefined)
+                return;
+            const current = typeof val;
+            if (current !== expectedType || val === null)
+                throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+        }
+        Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+        Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
+    }
+    const notImplemented = () => {
+        throw new Error('not implemented');
+    };
+    function memoized(fn) {
+        const map = new WeakMap();
+        return (arg, ...args) => {
+            const val = map.get(arg);
+            if (val !== undefined)
+                return val;
+            const computed = fn(arg, ...args);
+            map.set(arg, computed);
+            return computed;
+        };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$8 = BigInt(0), _1n$7 = BigInt(1), _2n$6 =  BigInt(2), _3n$3 =  BigInt(3);
+    const _4n$1 =  BigInt(4), _5n$1 =  BigInt(5), _7n$2 =  BigInt(7);
+    const _8n$2 =  BigInt(8), _9n =  BigInt(9), _16n$1 =  BigInt(16);
+    function mod(a, b) {
+        const result = a % b;
+        return result >= _0n$8 ? result : b + result;
+    }
+    function pow2(x, power, modulo) {
+        let res = x;
+        while (power-- > _0n$8) {
+            res *= res;
+            res %= modulo;
+        }
+        return res;
+    }
+    function invert(number, modulo) {
+        if (number === _0n$8)
+            throw new Error('invert: expected non-zero number');
+        if (modulo <= _0n$8)
+            throw new Error('invert: expected positive modulus, got ' + modulo);
+        let a = mod(number, modulo);
+        let b = modulo;
+        let x = _0n$8, u = _1n$7;
+        while (a !== _0n$8) {
+            const q = b / a;
+            const r = b % a;
+            const m = x - u * q;
+            b = a, a = r, x = u, u = m;
+        }
+        const gcd = b;
+        if (gcd !== _1n$7)
+            throw new Error('invert: does not exist');
+        return mod(x, modulo);
+    }
+    function assertIsSquare(Fp, root, n) {
+        if (!Fp.eql(Fp.sqr(root), n))
+            throw new Error('Cannot find square root');
+    }
+    function sqrt3mod4(Fp, n) {
+        const p1div4 = (Fp.ORDER + _1n$7) / _4n$1;
+        const root = Fp.pow(n, p1div4);
+        assertIsSquare(Fp, root, n);
+        return root;
+    }
+    function sqrt5mod8(Fp, n) {
+        const p5div8 = (Fp.ORDER - _5n$1) / _8n$2;
+        const n2 = Fp.mul(n, _2n$6);
+        const v = Fp.pow(n2, p5div8);
+        const nv = Fp.mul(n, v);
+        const i = Fp.mul(Fp.mul(nv, _2n$6), v);
+        const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+        assertIsSquare(Fp, root, n);
+        return root;
+    }
+    function sqrt9mod16(P) {
+        const Fp_ = Field(P);
+        const tn = tonelliShanks(P);
+        const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+        const c2 = tn(Fp_, c1);
+        const c3 = tn(Fp_, Fp_.neg(c1));
+        const c4 = (P + _7n$2) / _16n$1;
+        return (Fp, n) => {
+            let tv1 = Fp.pow(n, c4);
+            let tv2 = Fp.mul(tv1, c1);
+            const tv3 = Fp.mul(tv1, c2);
+            const tv4 = Fp.mul(tv1, c3);
+            const e1 = Fp.eql(Fp.sqr(tv2), n);
+            const e2 = Fp.eql(Fp.sqr(tv3), n);
+            tv1 = Fp.cmov(tv1, tv2, e1);
+            tv2 = Fp.cmov(tv4, tv3, e2);
+            const e3 = Fp.eql(Fp.sqr(tv2), n);
+            const root = Fp.cmov(tv1, tv2, e3);
+            assertIsSquare(Fp, root, n);
+            return root;
+        };
+    }
+    function tonelliShanks(P) {
+        if (P < _3n$3)
+            throw new Error('sqrt is not defined for small field');
+        let Q = P - _1n$7;
+        let S = 0;
+        while (Q % _2n$6 === _0n$8) {
+            Q /= _2n$6;
+            S++;
+        }
+        let Z = _2n$6;
+        const _Fp = Field(P);
+        while (FpLegendre(_Fp, Z) === 1) {
+            if (Z++ > 1000)
+                throw new Error('Cannot find square root: probably non-prime P');
+        }
+        if (S === 1)
+            return sqrt3mod4;
+        let cc = _Fp.pow(Z, Q);
+        const Q1div2 = (Q + _1n$7) / _2n$6;
+        return function tonelliSlow(Fp, n) {
+            if (Fp.is0(n))
+                return n;
+            if (FpLegendre(Fp, n) !== 1)
+                throw new Error('Cannot find square root');
+            let M = S;
+            let c = Fp.mul(Fp.ONE, cc);
+            let t = Fp.pow(n, Q);
+            let R = Fp.pow(n, Q1div2);
+            while (!Fp.eql(t, Fp.ONE)) {
+                if (Fp.is0(t))
+                    return Fp.ZERO;
+                let i = 1;
+                let t_tmp = Fp.sqr(t);
+                while (!Fp.eql(t_tmp, Fp.ONE)) {
+                    i++;
+                    t_tmp = Fp.sqr(t_tmp);
+                    if (i === M)
+                        throw new Error('Cannot find square root');
+                }
+                const exponent = _1n$7 << BigInt(M - i - 1);
+                const b = Fp.pow(c, exponent);
+                M = i;
+                c = Fp.sqr(b);
+                t = Fp.mul(t, c);
+                R = Fp.mul(R, b);
+            }
+            return R;
+        };
+    }
+    function FpSqrt(P) {
+        if (P % _4n$1 === _3n$3)
+            return sqrt3mod4;
+        if (P % _8n$2 === _5n$1)
+            return sqrt5mod8;
+        if (P % _16n$1 === _9n)
+            return sqrt9mod16(P);
+        return tonelliShanks(P);
+    }
+    const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n$7) === _1n$7;
+    const FIELD_FIELDS = [
+        'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',
+        'eql', 'add', 'sub', 'mul', 'pow', 'div',
+        'addN', 'subN', 'mulN', 'sqrN'
+    ];
+    function validateField(field) {
+        const initial = {
+            ORDER: 'bigint',
+            MASK: 'bigint',
+            BYTES: 'number',
+            BITS: 'number',
+        };
+        const opts = FIELD_FIELDS.reduce((map, val) => {
+            map[val] = 'function';
+            return map;
+        }, initial);
+        _validateObject(field, opts);
+        return field;
+    }
+    function FpPow(Fp, num, power) {
+        if (power < _0n$8)
+            throw new Error('invalid exponent, negatives unsupported');
+        if (power === _0n$8)
+            return Fp.ONE;
+        if (power === _1n$7)
+            return num;
+        let p = Fp.ONE;
+        let d = num;
+        while (power > _0n$8) {
+            if (power & _1n$7)
+                p = Fp.mul(p, d);
+            d = Fp.sqr(d);
+            power >>= _1n$7;
+        }
+        return p;
+    }
+    function FpInvertBatch(Fp, nums, passZero = false) {
+        const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);
+        const multipliedAcc = nums.reduce((acc, num, i) => {
+            if (Fp.is0(num))
+                return acc;
+            inverted[i] = acc;
+            return Fp.mul(acc, num);
+        }, Fp.ONE);
+        const invertedAcc = Fp.inv(multipliedAcc);
+        nums.reduceRight((acc, num, i) => {
+            if (Fp.is0(num))
+                return acc;
+            inverted[i] = Fp.mul(acc, inverted[i]);
+            return Fp.mul(acc, num);
+        }, invertedAcc);
+        return inverted;
+    }
+    function FpLegendre(Fp, n) {
+        const p1mod2 = (Fp.ORDER - _1n$7) / _2n$6;
+        const powered = Fp.pow(n, p1mod2);
+        const yes = Fp.eql(powered, Fp.ONE);
+        const zero = Fp.eql(powered, Fp.ZERO);
+        const no = Fp.eql(powered, Fp.neg(Fp.ONE));
+        if (!yes && !zero && !no)
+            throw new Error('invalid Legendre symbol result');
+        return yes ? 1 : zero ? 0 : -1;
+    }
+    function nLength(n, nBitLength) {
+        if (nBitLength !== undefined)
+            anumber(nBitLength);
+        const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
+        const nByteLength = Math.ceil(_nBitLength / 8);
+        return { nBitLength: _nBitLength, nByteLength };
+    }
+    function Field(ORDER, bitLenOrOpts,
+    isLE = false, opts = {}) {
+        if (ORDER <= _0n$8)
+            throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);
+        let _nbitLength = undefined;
+        let _sqrt = undefined;
+        let modFromBytes = false;
+        let allowedLengths = undefined;
+        if (typeof bitLenOrOpts === 'object' && bitLenOrOpts != null) {
+            if (opts.sqrt || isLE)
+                throw new Error('cannot specify opts in two arguments');
+            const _opts = bitLenOrOpts;
+            if (_opts.BITS)
+                _nbitLength = _opts.BITS;
+            if (_opts.sqrt)
+                _sqrt = _opts.sqrt;
+            if (typeof _opts.isLE === 'boolean')
+                isLE = _opts.isLE;
+            if (typeof _opts.modFromBytes === 'boolean')
+                modFromBytes = _opts.modFromBytes;
+            allowedLengths = _opts.allowedLengths;
+        }
+        else {
+            if (typeof bitLenOrOpts === 'number')
+                _nbitLength = bitLenOrOpts;
+            if (opts.sqrt)
+                _sqrt = opts.sqrt;
+        }
+        const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);
+        if (BYTES > 2048)
+            throw new Error('invalid field: expected ORDER of <= 2048 bytes');
+        let sqrtP;
+        const f = Object.freeze({
+            ORDER,
+            isLE,
+            BITS,
+            BYTES,
+            MASK: bitMask$1(BITS),
+            ZERO: _0n$8,
+            ONE: _1n$7,
+            allowedLengths: allowedLengths,
+            create: (num) => mod(num, ORDER),
+            isValid: (num) => {
+                if (typeof num !== 'bigint')
+                    throw new Error('invalid field element: expected bigint, got ' + typeof num);
+                return _0n$8 <= num && num < ORDER;
+            },
+            is0: (num) => num === _0n$8,
+            isValidNot0: (num) => !f.is0(num) && f.isValid(num),
+            isOdd: (num) => (num & _1n$7) === _1n$7,
+            neg: (num) => mod(-num, ORDER),
+            eql: (lhs, rhs) => lhs === rhs,
+            sqr: (num) => mod(num * num, ORDER),
+            add: (lhs, rhs) => mod(lhs + rhs, ORDER),
+            sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
+            mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
+            pow: (num, power) => FpPow(f, num, power),
+            div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
+            sqrN: (num) => num * num,
+            addN: (lhs, rhs) => lhs + rhs,
+            subN: (lhs, rhs) => lhs - rhs,
+            mulN: (lhs, rhs) => lhs * rhs,
+            inv: (num) => invert(num, ORDER),
+            sqrt: _sqrt ||
+                ((n) => {
+                    if (!sqrtP)
+                        sqrtP = FpSqrt(ORDER);
+                    return sqrtP(f, n);
+                }),
+            toBytes: (num) => (isLE ? numberToBytesLE$1(num, BYTES) : numberToBytesBE(num, BYTES)),
+            fromBytes: (bytes, skipValidation = true) => {
+                if (allowedLengths) {
+                    if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
+                        throw new Error('Field.fromBytes: expected ' + allowedLengths + ' bytes, got ' + bytes.length);
+                    }
+                    const padded = new Uint8Array(BYTES);
+                    padded.set(bytes, isLE ? 0 : padded.length - bytes.length);
+                    bytes = padded;
+                }
+                if (bytes.length !== BYTES)
+                    throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);
+                let scalar = isLE ? bytesToNumberLE$1(bytes) : bytesToNumberBE(bytes);
+                if (modFromBytes)
+                    scalar = mod(scalar, ORDER);
+                if (!skipValidation)
+                    if (!f.isValid(scalar))
+                        throw new Error('invalid field element: outside of range 0..ORDER');
+                return scalar;
+            },
+            invertBatch: (lst) => FpInvertBatch(f, lst),
+            cmov: (a, b, c) => (c ? b : a),
+        });
+        return Object.freeze(f);
+    }
+    function FpSqrtEven(Fp, elm) {
+        if (!Fp.isOdd)
+            throw new Error("Field doesn't have isOdd");
+        const root = Fp.sqrt(elm);
+        return Fp.isOdd(root) ? Fp.neg(root) : root;
+    }
+    function getFieldBytesLength(fieldOrder) {
+        if (typeof fieldOrder !== 'bigint')
+            throw new Error('field order must be bigint');
+        const bitLength = fieldOrder.toString(2).length;
+        return Math.ceil(bitLength / 8);
+    }
+    function getMinHashLength(fieldOrder) {
+        const length = getFieldBytesLength(fieldOrder);
+        return length + Math.ceil(length / 2);
+    }
+    function mapHashToField(key, fieldOrder, isLE = false) {
+        const len = key.length;
+        const fieldLen = getFieldBytesLength(fieldOrder);
+        const minLen = getMinHashLength(fieldOrder);
+        if (len < 16 || len < minLen || len > 1024)
+            throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);
+        const num = isLE ? bytesToNumberLE$1(key) : bytesToNumberBE(key);
+        const reduced = mod(num, fieldOrder - _1n$7) + _1n$7;
+        return isLE ? numberToBytesLE$1(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$7 = BigInt(0);
+    const _1n$6 = BigInt(1);
+    function negateCt(condition, item) {
+        const neg = item.negate();
+        return condition ? neg : item;
+    }
+    function normalizeZ(c, points) {
+        const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));
+        return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));
+    }
+    function validateW(W, bits) {
+        if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
+            throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);
+    }
+    function calcWOpts(W, scalarBits) {
+        validateW(W, scalarBits);
+        const windows = Math.ceil(scalarBits / W) + 1;
+        const windowSize = 2 ** (W - 1);
+        const maxNumber = 2 ** W;
+        const mask = bitMask$1(W);
+        const shiftBy = BigInt(W);
+        return { windows, windowSize, mask, maxNumber, shiftBy };
+    }
+    function calcOffsets(n, window, wOpts) {
+        const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+        let wbits = Number(n & mask);
+        let nextN = n >> shiftBy;
+        if (wbits > windowSize) {
+            wbits -= maxNumber;
+            nextN += _1n$6;
+        }
+        const offsetStart = window * windowSize;
+        const offset = offsetStart + Math.abs(wbits) - 1;
+        const isZero = wbits === 0;
+        const isNeg = wbits < 0;
+        const isNegF = window % 2 !== 0;
+        const offsetF = offsetStart;
+        return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+    }
+    function validateMSMPoints(points, c) {
+        if (!Array.isArray(points))
+            throw new Error('array expected');
+        points.forEach((p, i) => {
+            if (!(p instanceof c))
+                throw new Error('invalid point at index ' + i);
+        });
+    }
+    function validateMSMScalars(scalars, field) {
+        if (!Array.isArray(scalars))
+            throw new Error('array of scalars expected');
+        scalars.forEach((s, i) => {
+            if (!field.isValid(s))
+                throw new Error('invalid scalar at index ' + i);
+        });
+    }
+    const pointPrecomputes = new WeakMap();
+    const pointWindowSizes = new WeakMap();
+    function getW(P) {
+        return pointWindowSizes.get(P) || 1;
+    }
+    function assert0(n) {
+        if (n !== _0n$7)
+            throw new Error('invalid wNAF');
+    }
+    class wNAF {
+        constructor(Point, bits) {
+            this.BASE = Point.BASE;
+            this.ZERO = Point.ZERO;
+            this.Fn = Point.Fn;
+            this.bits = bits;
+        }
+        _unsafeLadder(elm, n, p = this.ZERO) {
+            let d = elm;
+            while (n > _0n$7) {
+                if (n & _1n$6)
+                    p = p.add(d);
+                d = d.double();
+                n >>= _1n$6;
+            }
+            return p;
+        }
+        precomputeWindow(point, W) {
+            const { windows, windowSize } = calcWOpts(W, this.bits);
+            const points = [];
+            let p = point;
+            let base = p;
+            for (let window = 0; window < windows; window++) {
+                base = p;
+                points.push(base);
+                for (let i = 1; i < windowSize; i++) {
+                    base = base.add(p);
+                    points.push(base);
+                }
+                p = base.double();
+            }
+            return points;
+        }
+        wNAF(W, precomputes, n) {
+            if (!this.Fn.isValid(n))
+                throw new Error('invalid scalar');
+            let p = this.ZERO;
+            let f = this.BASE;
+            const wo = calcWOpts(W, this.bits);
+            for (let window = 0; window < wo.windows; window++) {
+                const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+                n = nextN;
+                if (isZero) {
+                    f = f.add(negateCt(isNegF, precomputes[offsetF]));
+                }
+                else {
+                    p = p.add(negateCt(isNeg, precomputes[offset]));
+                }
+            }
+            assert0(n);
+            return { p, f };
+        }
+        wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+            const wo = calcWOpts(W, this.bits);
+            for (let window = 0; window < wo.windows; window++) {
+                if (n === _0n$7)
+                    break;
+                const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+                n = nextN;
+                if (isZero) {
+                    continue;
+                }
+                else {
+                    const item = precomputes[offset];
+                    acc = acc.add(isNeg ? item.negate() : item);
+                }
+            }
+            assert0(n);
+            return acc;
+        }
+        getPrecomputes(W, point, transform) {
+            let comp = pointPrecomputes.get(point);
+            if (!comp) {
+                comp = this.precomputeWindow(point, W);
+                if (W !== 1) {
+                    if (typeof transform === 'function')
+                        comp = transform(comp);
+                    pointPrecomputes.set(point, comp);
+                }
+            }
+            return comp;
+        }
+        cached(point, scalar, transform) {
+            const W = getW(point);
+            return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+        }
+        unsafe(point, scalar, transform, prev) {
+            const W = getW(point);
+            if (W === 1)
+                return this._unsafeLadder(point, scalar, prev);
+            return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+        }
+        createCache(P, W) {
+            validateW(W, this.bits);
+            pointWindowSizes.set(P, W);
+            pointPrecomputes.delete(P);
+        }
+        hasCache(elm) {
+            return getW(elm) !== 1;
+        }
+    }
+    function mulEndoUnsafe(Point, point, k1, k2) {
+        let acc = point;
+        let p1 = Point.ZERO;
+        let p2 = Point.ZERO;
+        while (k1 > _0n$7 || k2 > _0n$7) {
+            if (k1 & _1n$6)
+                p1 = p1.add(acc);
+            if (k2 & _1n$6)
+                p2 = p2.add(acc);
+            acc = acc.double();
+            k1 >>= _1n$6;
+            k2 >>= _1n$6;
+        }
+        return { p1, p2 };
+    }
+    function pippenger(c, fieldN, points, scalars) {
+        validateMSMPoints(points, c);
+        validateMSMScalars(scalars, fieldN);
+        const plength = points.length;
+        const slength = scalars.length;
+        if (plength !== slength)
+            throw new Error('arrays of points and scalars must have equal length');
+        const zero = c.ZERO;
+        const wbits = bitLen(BigInt(plength));
+        let windowSize = 1;
+        if (wbits > 12)
+            windowSize = wbits - 3;
+        else if (wbits > 4)
+            windowSize = wbits - 2;
+        else if (wbits > 0)
+            windowSize = 2;
+        const MASK = bitMask$1(windowSize);
+        const buckets = new Array(Number(MASK) + 1).fill(zero);
+        const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
+        let sum = zero;
+        for (let i = lastBits; i >= 0; i -= windowSize) {
+            buckets.fill(zero);
+            for (let j = 0; j < slength; j++) {
+                const scalar = scalars[j];
+                const wbits = Number((scalar >> BigInt(i)) & MASK);
+                buckets[wbits] = buckets[wbits].add(points[j]);
+            }
+            let resI = zero;
+            for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {
+                sumI = sumI.add(buckets[j]);
+                resI = resI.add(sumI);
+            }
+            sum = sum.add(resI);
+            if (i !== 0)
+                for (let j = 0; j < windowSize; j++)
+                    sum = sum.double();
+        }
+        return sum;
+    }
+    function createField(order, field, isLE) {
+        if (field) {
+            if (field.ORDER !== order)
+                throw new Error('Field.ORDER must match order: Fp == p, Fn == n');
+            validateField(field);
+            return field;
+        }
+        else {
+            return Field(order, { isLE });
+        }
+    }
+    function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+        if (FpFnLE === undefined)
+            FpFnLE = type === 'edwards';
+        if (!CURVE || typeof CURVE !== 'object')
+            throw new Error(`expected valid ${type} CURVE object`);
+        for (const p of ['p', 'n', 'h']) {
+            const val = CURVE[p];
+            if (!(typeof val === 'bigint' && val > _0n$7))
+                throw new Error(`CURVE.${p} must be positive bigint`);
+        }
+        const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+        const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+        const _b = type === 'weierstrass' ? 'b' : 'd';
+        const params = ['Gx', 'Gy', 'a', _b];
+        for (const p of params) {
+            if (!Fp.isValid(CURVE[p]))
+                throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+        }
+        CURVE = Object.freeze(Object.assign({}, CURVE));
+        return { CURVE, Fp, Fn };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n$5) / den;
+    function _splitEndoScalar(k, basis, n) {
+        const [[a1, b1], [a2, b2]] = basis;
+        const c1 = divNearest(b2 * k, n);
+        const c2 = divNearest(-b1 * k, n);
+        let k1 = k - c1 * a1 - c2 * a2;
+        let k2 = -c1 * b1 - c2 * b2;
+        const k1neg = k1 < _0n$6;
+        const k2neg = k2 < _0n$6;
+        if (k1neg)
+            k1 = -k1;
+        if (k2neg)
+            k2 = -k2;
+        const MAX_NUM = bitMask$1(Math.ceil(bitLen(n) / 2)) + _1n$5;
+        if (k1 < _0n$6 || k1 >= MAX_NUM || k2 < _0n$6 || k2 >= MAX_NUM) {
+            throw new Error('splitScalar (endomorphism): failed, k=' + k);
+        }
+        return { k1neg, k1, k2neg, k2 };
+    }
+    function validateSigFormat(format) {
+        if (!['compact', 'recovered', 'der'].includes(format))
+            throw new Error('Signature format must be "compact", "recovered", or "der"');
+        return format;
+    }
+    function validateSigOpts(opts, def) {
+        const optsn = {};
+        for (let optName of Object.keys(def)) {
+            optsn[optName] = opts[optName] === undefined ? def[optName] : opts[optName];
+        }
+        _abool2(optsn.lowS, 'lowS');
+        _abool2(optsn.prehash, 'prehash');
+        if (optsn.format !== undefined)
+            validateSigFormat(optsn.format);
+        return optsn;
+    }
+    class DERErr extends Error {
+        constructor(m = '') {
+            super(m);
+        }
+    }
+    const DER = {
+        Err: DERErr,
+        _tlv: {
+            encode: (tag, data) => {
+                const { Err: E } = DER;
+                if (tag < 0 || tag > 256)
+                    throw new E('tlv.encode: wrong tag');
+                if (data.length & 1)
+                    throw new E('tlv.encode: unpadded data');
+                const dataLen = data.length / 2;
+                const len = numberToHexUnpadded(dataLen);
+                if ((len.length / 2) & 128)
+                    throw new E('tlv.encode: long form length too big');
+                const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 128) : '';
+                const t = numberToHexUnpadded(tag);
+                return t + lenLen + len + data;
+            },
+            decode(tag, data) {
+                const { Err: E } = DER;
+                let pos = 0;
+                if (tag < 0 || tag > 256)
+                    throw new E('tlv.encode: wrong tag');
+                if (data.length < 2 || data[pos++] !== tag)
+                    throw new E('tlv.decode: wrong tlv');
+                const first = data[pos++];
+                const isLong = !!(first & 128);
+                let length = 0;
+                if (!isLong)
+                    length = first;
+                else {
+                    const lenLen = first & 127;
+                    if (!lenLen)
+                        throw new E('tlv.decode(long): indefinite length not supported');
+                    if (lenLen > 4)
+                        throw new E('tlv.decode(long): byte length is too big');
+                    const lengthBytes = data.subarray(pos, pos + lenLen);
+                    if (lengthBytes.length !== lenLen)
+                        throw new E('tlv.decode: length bytes not complete');
+                    if (lengthBytes[0] === 0)
+                        throw new E('tlv.decode(long): zero leftmost byte');
+                    for (const b of lengthBytes)
+                        length = (length << 8) | b;
+                    pos += lenLen;
+                    if (length < 128)
+                        throw new E('tlv.decode(long): not minimal encoding');
+                }
+                const v = data.subarray(pos, pos + length);
+                if (v.length !== length)
+                    throw new E('tlv.decode: wrong value length');
+                return { v, l: data.subarray(pos + length) };
+            },
+        },
+        _int: {
+            encode(num) {
+                const { Err: E } = DER;
+                if (num < _0n$6)
+                    throw new E('integer: negative integers are not allowed');
+                let hex = numberToHexUnpadded(num);
+                if (Number.parseInt(hex[0], 16) & 0b1000)
+                    hex = '00' + hex;
+                if (hex.length & 1)
+                    throw new E('unexpected DER parsing assertion: unpadded hex');
+                return hex;
+            },
+            decode(data) {
+                const { Err: E } = DER;
+                if (data[0] & 128)
+                    throw new E('invalid signature integer: negative');
+                if (data[0] === 0x00 && !(data[1] & 128))
+                    throw new E('invalid signature integer: unnecessary leading zero');
+                return bytesToNumberBE(data);
+            },
+        },
+        toSig(hex) {
+            const { Err: E, _int: int, _tlv: tlv } = DER;
+            const data = ensureBytes('signature', hex);
+            const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
+            if (seqLeftBytes.length)
+                throw new E('invalid signature: left bytes after parsing');
+            const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
+            const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
+            if (sLeftBytes.length)
+                throw new E('invalid signature: left bytes after parsing');
+            return { r: int.decode(rBytes), s: int.decode(sBytes) };
+        },
+        hexFromSig(sig) {
+            const { _tlv: tlv, _int: int } = DER;
+            const rs = tlv.encode(0x02, int.encode(sig.r));
+            const ss = tlv.encode(0x02, int.encode(sig.s));
+            const seq = rs + ss;
+            return tlv.encode(0x30, seq);
+        },
+    };
+    const _0n$6 = BigInt(0), _1n$5 = BigInt(1), _2n$5 = BigInt(2), _3n$2 = BigInt(3), _4n = BigInt(4);
+    function _normFnElement(Fn, key) {
+        const { BYTES: expected } = Fn;
+        let num;
+        if (typeof key === 'bigint') {
+            num = key;
+        }
+        else {
+            let bytes = ensureBytes('private key', key);
+            try {
+                num = Fn.fromBytes(bytes);
+            }
+            catch (error) {
+                throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key}`);
+            }
+        }
+        if (!Fn.isValidNot0(num))
+            throw new Error('invalid private key: out of range [1..N-1]');
+        return num;
+    }
+    function weierstrassN(params, extraOpts = {}) {
+        const validated = _createCurveFields('weierstrass', params, extraOpts);
+        const { Fp, Fn } = validated;
+        let CURVE = validated.CURVE;
+        const { h: cofactor, n: CURVE_ORDER } = CURVE;
+        _validateObject(extraOpts, {}, {
+            allowInfinityPoint: 'boolean',
+            clearCofactor: 'function',
+            isTorsionFree: 'function',
+            fromBytes: 'function',
+            toBytes: 'function',
+            endo: 'object',
+            wrapPrivateKey: 'boolean',
+        });
+        const { endo } = extraOpts;
+        if (endo) {
+            if (!Fp.is0(CURVE.a) || typeof endo.beta !== 'bigint' || !Array.isArray(endo.basises)) {
+                throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+            }
+        }
+        const lengths = getWLengths(Fp, Fn);
+        function assertCompressionIsSupported() {
+            if (!Fp.isOdd)
+                throw new Error('compression is not supported: Field does not have .isOdd()');
+        }
+        function pointToBytes(_c, point, isCompressed) {
+            const { x, y } = point.toAffine();
+            const bx = Fp.toBytes(x);
+            _abool2(isCompressed, 'isCompressed');
+            if (isCompressed) {
+                assertCompressionIsSupported();
+                const hasEvenY = !Fp.isOdd(y);
+                return concatBytes(pprefix(hasEvenY), bx);
+            }
+            else {
+                return concatBytes(Uint8Array.of(0x04), bx, Fp.toBytes(y));
+            }
+        }
+        function pointFromBytes(bytes) {
+            _abytes2(bytes, undefined, 'Point');
+            const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths;
+            const length = bytes.length;
+            const head = bytes[0];
+            const tail = bytes.subarray(1);
+            if (length === comp && (head === 0x02 || head === 0x03)) {
+                const x = Fp.fromBytes(tail);
+                if (!Fp.isValid(x))
+                    throw new Error('bad point: is not on curve, wrong x');
+                const y2 = weierstrassEquation(x);
+                let y;
+                try {
+                    y = Fp.sqrt(y2);
+                }
+                catch (sqrtError) {
+                    const err = sqrtError instanceof Error ? ': ' + sqrtError.message : '';
+                    throw new Error('bad point: is not on curve, sqrt error' + err);
+                }
+                assertCompressionIsSupported();
+                const isYOdd = Fp.isOdd(y);
+                const isHeadOdd = (head & 1) === 1;
+                if (isHeadOdd !== isYOdd)
+                    y = Fp.neg(y);
+                return { x, y };
+            }
+            else if (length === uncomp && head === 0x04) {
+                const L = Fp.BYTES;
+                const x = Fp.fromBytes(tail.subarray(0, L));
+                const y = Fp.fromBytes(tail.subarray(L, L * 2));
+                if (!isValidXY(x, y))
+                    throw new Error('bad point: is not on curve');
+                return { x, y };
+            }
+            else {
+                throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
+            }
+        }
+        const encodePoint = extraOpts.toBytes || pointToBytes;
+        const decodePoint = extraOpts.fromBytes || pointFromBytes;
+        function weierstrassEquation(x) {
+            const x2 = Fp.sqr(x);
+            const x3 = Fp.mul(x2, x);
+            return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b);
+        }
+        function isValidXY(x, y) {
+            const left = Fp.sqr(y);
+            const right = weierstrassEquation(x);
+            return Fp.eql(left, right);
+        }
+        if (!isValidXY(CURVE.Gx, CURVE.Gy))
+            throw new Error('bad curve params: generator point');
+        const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n$2), _4n);
+        const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
+        if (Fp.is0(Fp.add(_4a3, _27b2)))
+            throw new Error('bad curve params: a or b');
+        function acoord(title, n, banZero = false) {
+            if (!Fp.isValid(n) || (banZero && Fp.is0(n)))
+                throw new Error(`bad point coordinate ${title}`);
+            return n;
+        }
+        function aprjpoint(other) {
+            if (!(other instanceof Point))
+                throw new Error('ProjectivePoint expected');
+        }
+        function splitEndoScalarN(k) {
+            if (!endo || !endo.basises)
+                throw new Error('no endo');
+            return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+        }
+        const toAffineMemo = memoized((p, iz) => {
+            const { X, Y, Z } = p;
+            if (Fp.eql(Z, Fp.ONE))
+                return { x: X, y: Y };
+            const is0 = p.is0();
+            if (iz == null)
+                iz = is0 ? Fp.ONE : Fp.inv(Z);
+            const x = Fp.mul(X, iz);
+            const y = Fp.mul(Y, iz);
+            const zz = Fp.mul(Z, iz);
+            if (is0)
+                return { x: Fp.ZERO, y: Fp.ZERO };
+            if (!Fp.eql(zz, Fp.ONE))
+                throw new Error('invZ was invalid');
+            return { x, y };
+        });
+        const assertValidMemo = memoized((p) => {
+            if (p.is0()) {
+                if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y))
+                    return;
+                throw new Error('bad point: ZERO');
+            }
+            const { x, y } = p.toAffine();
+            if (!Fp.isValid(x) || !Fp.isValid(y))
+                throw new Error('bad point: x or y not field elements');
+            if (!isValidXY(x, y))
+                throw new Error('bad point: equation left != right');
+            if (!p.isTorsionFree())
+                throw new Error('bad point: not in prime-order subgroup');
+            return true;
+        });
+        function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+            k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
+            k1p = negateCt(k1neg, k1p);
+            k2p = negateCt(k2neg, k2p);
+            return k1p.add(k2p);
+        }
+        class Point {
+            constructor(X, Y, Z) {
+                this.X = acoord('x', X);
+                this.Y = acoord('y', Y, true);
+                this.Z = acoord('z', Z);
+                Object.freeze(this);
+            }
+            static CURVE() {
+                return CURVE;
+            }
+            static fromAffine(p) {
+                const { x, y } = p || {};
+                if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+                    throw new Error('invalid affine point');
+                if (p instanceof Point)
+                    throw new Error('projective point not allowed');
+                if (Fp.is0(x) && Fp.is0(y))
+                    return Point.ZERO;
+                return new Point(x, y, Fp.ONE);
+            }
+            static fromBytes(bytes) {
+                const P = Point.fromAffine(decodePoint(_abytes2(bytes, undefined, 'point')));
+                P.assertValidity();
+                return P;
+            }
+            static fromHex(hex) {
+                return Point.fromBytes(ensureBytes('pointHex', hex));
+            }
+            get x() {
+                return this.toAffine().x;
+            }
+            get y() {
+                return this.toAffine().y;
+            }
+            precompute(windowSize = 8, isLazy = true) {
+                wnaf.createCache(this, windowSize);
+                if (!isLazy)
+                    this.multiply(_3n$2);
+                return this;
+            }
+            assertValidity() {
+                assertValidMemo(this);
+            }
+            hasEvenY() {
+                const { y } = this.toAffine();
+                if (!Fp.isOdd)
+                    throw new Error("Field doesn't support isOdd");
+                return !Fp.isOdd(y);
+            }
+            equals(other) {
+                aprjpoint(other);
+                const { X: X1, Y: Y1, Z: Z1 } = this;
+                const { X: X2, Y: Y2, Z: Z2 } = other;
+                const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+                const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+                return U1 && U2;
+            }
+            negate() {
+                return new Point(this.X, Fp.neg(this.Y), this.Z);
+            }
+            double() {
+                const { a, b } = CURVE;
+                const b3 = Fp.mul(b, _3n$2);
+                const { X: X1, Y: Y1, Z: Z1 } = this;
+                let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+                let t0 = Fp.mul(X1, X1);
+                let t1 = Fp.mul(Y1, Y1);
+                let t2 = Fp.mul(Z1, Z1);
+                let t3 = Fp.mul(X1, Y1);
+                t3 = Fp.add(t3, t3);
+                Z3 = Fp.mul(X1, Z1);
+                Z3 = Fp.add(Z3, Z3);
+                X3 = Fp.mul(a, Z3);
+                Y3 = Fp.mul(b3, t2);
+                Y3 = Fp.add(X3, Y3);
+                X3 = Fp.sub(t1, Y3);
+                Y3 = Fp.add(t1, Y3);
+                Y3 = Fp.mul(X3, Y3);
+                X3 = Fp.mul(t3, X3);
+                Z3 = Fp.mul(b3, Z3);
+                t2 = Fp.mul(a, t2);
+                t3 = Fp.sub(t0, t2);
+                t3 = Fp.mul(a, t3);
+                t3 = Fp.add(t3, Z3);
+                Z3 = Fp.add(t0, t0);
+                t0 = Fp.add(Z3, t0);
+                t0 = Fp.add(t0, t2);
+                t0 = Fp.mul(t0, t3);
+                Y3 = Fp.add(Y3, t0);
+                t2 = Fp.mul(Y1, Z1);
+                t2 = Fp.add(t2, t2);
+                t0 = Fp.mul(t2, t3);
+                X3 = Fp.sub(X3, t0);
+                Z3 = Fp.mul(t2, t1);
+                Z3 = Fp.add(Z3, Z3);
+                Z3 = Fp.add(Z3, Z3);
+                return new Point(X3, Y3, Z3);
+            }
+            add(other) {
+                aprjpoint(other);
+                const { X: X1, Y: Y1, Z: Z1 } = this;
+                const { X: X2, Y: Y2, Z: Z2 } = other;
+                let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+                const a = CURVE.a;
+                const b3 = Fp.mul(CURVE.b, _3n$2);
+                let t0 = Fp.mul(X1, X2);
+                let t1 = Fp.mul(Y1, Y2);
+                let t2 = Fp.mul(Z1, Z2);
+                let t3 = Fp.add(X1, Y1);
+                let t4 = Fp.add(X2, Y2);
+                t3 = Fp.mul(t3, t4);
+                t4 = Fp.add(t0, t1);
+                t3 = Fp.sub(t3, t4);
+                t4 = Fp.add(X1, Z1);
+                let t5 = Fp.add(X2, Z2);
+                t4 = Fp.mul(t4, t5);
+                t5 = Fp.add(t0, t2);
+                t4 = Fp.sub(t4, t5);
+                t5 = Fp.add(Y1, Z1);
+                X3 = Fp.add(Y2, Z2);
+                t5 = Fp.mul(t5, X3);
+                X3 = Fp.add(t1, t2);
+                t5 = Fp.sub(t5, X3);
+                Z3 = Fp.mul(a, t4);
+                X3 = Fp.mul(b3, t2);
+                Z3 = Fp.add(X3, Z3);
+                X3 = Fp.sub(t1, Z3);
+                Z3 = Fp.add(t1, Z3);
+                Y3 = Fp.mul(X3, Z3);
+                t1 = Fp.add(t0, t0);
+                t1 = Fp.add(t1, t0);
+                t2 = Fp.mul(a, t2);
+                t4 = Fp.mul(b3, t4);
+                t1 = Fp.add(t1, t2);
+                t2 = Fp.sub(t0, t2);
+                t2 = Fp.mul(a, t2);
+                t4 = Fp.add(t4, t2);
+                t0 = Fp.mul(t1, t4);
+                Y3 = Fp.add(Y3, t0);
+                t0 = Fp.mul(t5, t4);
+                X3 = Fp.mul(t3, X3);
+                X3 = Fp.sub(X3, t0);
+                t0 = Fp.mul(t3, t1);
+                Z3 = Fp.mul(t5, Z3);
+                Z3 = Fp.add(Z3, t0);
+                return new Point(X3, Y3, Z3);
+            }
+            subtract(other) {
+                return this.add(other.negate());
+            }
+            is0() {
+                return this.equals(Point.ZERO);
+            }
+            multiply(scalar) {
+                const { endo } = extraOpts;
+                if (!Fn.isValidNot0(scalar))
+                    throw new Error('invalid scalar: out of range');
+                let point, fake;
+                const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));
+                if (endo) {
+                    const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
+                    const { p: k1p, f: k1f } = mul(k1);
+                    const { p: k2p, f: k2f } = mul(k2);
+                    fake = k1f.add(k2f);
+                    point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);
+                }
+                else {
+                    const { p, f } = mul(scalar);
+                    point = p;
+                    fake = f;
+                }
+                return normalizeZ(Point, [point, fake])[0];
+            }
+            multiplyUnsafe(sc) {
+                const { endo } = extraOpts;
+                const p = this;
+                if (!Fn.isValid(sc))
+                    throw new Error('invalid scalar: out of range');
+                if (sc === _0n$6 || p.is0())
+                    return Point.ZERO;
+                if (sc === _1n$5)
+                    return p;
+                if (wnaf.hasCache(this))
+                    return this.multiply(sc);
+                if (endo) {
+                    const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+                    const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2);
+                    return finishEndo(endo.beta, p1, p2, k1neg, k2neg);
+                }
+                else {
+                    return wnaf.unsafe(p, sc);
+                }
+            }
+            multiplyAndAddUnsafe(Q, a, b) {
+                const sum = this.multiplyUnsafe(a).add(Q.multiplyUnsafe(b));
+                return sum.is0() ? undefined : sum;
+            }
+            toAffine(invertedZ) {
+                return toAffineMemo(this, invertedZ);
+            }
+            isTorsionFree() {
+                const { isTorsionFree } = extraOpts;
+                if (cofactor === _1n$5)
+                    return true;
+                if (isTorsionFree)
+                    return isTorsionFree(Point, this);
+                return wnaf.unsafe(this, CURVE_ORDER).is0();
+            }
+            clearCofactor() {
+                const { clearCofactor } = extraOpts;
+                if (cofactor === _1n$5)
+                    return this;
+                if (clearCofactor)
+                    return clearCofactor(Point, this);
+                return this.multiplyUnsafe(cofactor);
+            }
+            isSmallOrder() {
+                return this.multiplyUnsafe(cofactor).is0();
+            }
+            toBytes(isCompressed = true) {
+                _abool2(isCompressed, 'isCompressed');
+                this.assertValidity();
+                return encodePoint(Point, this, isCompressed);
+            }
+            toHex(isCompressed = true) {
+                return bytesToHex(this.toBytes(isCompressed));
+            }
+            toString() {
+                return `<Point ${this.is0() ? 'ZERO' : this.toHex()}>`;
+            }
+            get px() {
+                return this.X;
+            }
+            get py() {
+                return this.X;
+            }
+            get pz() {
+                return this.Z;
+            }
+            toRawBytes(isCompressed = true) {
+                return this.toBytes(isCompressed);
+            }
+            _setWindowSize(windowSize) {
+                this.precompute(windowSize);
+            }
+            static normalizeZ(points) {
+                return normalizeZ(Point, points);
+            }
+            static msm(points, scalars) {
+                return pippenger(Point, Fn, points, scalars);
+            }
+            static fromPrivateKey(privateKey) {
+                return Point.BASE.multiply(_normFnElement(Fn, privateKey));
+            }
+        }
+        Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+        Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+        Point.Fp = Fp;
+        Point.Fn = Fn;
+        const bits = Fn.BITS;
+        const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);
+        Point.BASE.precompute(8);
+        return Point;
+    }
+    function pprefix(hasEvenY) {
+        return Uint8Array.of(hasEvenY ? 0x02 : 0x03);
+    }
+    function SWUFpSqrtRatio(Fp, Z) {
+        const q = Fp.ORDER;
+        let l = _0n$6;
+        for (let o = q - _1n$5; o % _2n$5 === _0n$6; o /= _2n$5)
+            l += _1n$5;
+        const c1 = l;
+        const _2n_pow_c1_1 = _2n$5 << (c1 - _1n$5 - _1n$5);
+        const _2n_pow_c1 = _2n_pow_c1_1 * _2n$5;
+        const c2 = (q - _1n$5) / _2n_pow_c1;
+        const c3 = (c2 - _1n$5) / _2n$5;
+        const c4 = _2n_pow_c1 - _1n$5;
+        const c5 = _2n_pow_c1_1;
+        const c6 = Fp.pow(Z, c2);
+        const c7 = Fp.pow(Z, (c2 + _1n$5) / _2n$5);
+        let sqrtRatio = (u, v) => {
+            let tv1 = c6;
+            let tv2 = Fp.pow(v, c4);
+            let tv3 = Fp.sqr(tv2);
+            tv3 = Fp.mul(tv3, v);
+            let tv5 = Fp.mul(u, tv3);
+            tv5 = Fp.pow(tv5, c3);
+            tv5 = Fp.mul(tv5, tv2);
+            tv2 = Fp.mul(tv5, v);
+            tv3 = Fp.mul(tv5, u);
+            let tv4 = Fp.mul(tv3, tv2);
+            tv5 = Fp.pow(tv4, c5);
+            let isQR = Fp.eql(tv5, Fp.ONE);
+            tv2 = Fp.mul(tv3, c7);
+            tv5 = Fp.mul(tv4, tv1);
+            tv3 = Fp.cmov(tv2, tv3, isQR);
+            tv4 = Fp.cmov(tv5, tv4, isQR);
+            for (let i = c1; i > _1n$5; i--) {
+                let tv5 = i - _2n$5;
+                tv5 = _2n$5 << (tv5 - _1n$5);
+                let tvv5 = Fp.pow(tv4, tv5);
+                const e1 = Fp.eql(tvv5, Fp.ONE);
+                tv2 = Fp.mul(tv3, tv1);
+                tv1 = Fp.mul(tv1, tv1);
+                tvv5 = Fp.mul(tv4, tv1);
+                tv3 = Fp.cmov(tv2, tv3, e1);
+                tv4 = Fp.cmov(tvv5, tv4, e1);
+            }
+            return { isValid: isQR, value: tv3 };
+        };
+        if (Fp.ORDER % _4n === _3n$2) {
+            const c1 = (Fp.ORDER - _3n$2) / _4n;
+            const c2 = Fp.sqrt(Fp.neg(Z));
+            sqrtRatio = (u, v) => {
+                let tv1 = Fp.sqr(v);
+                const tv2 = Fp.mul(u, v);
+                tv1 = Fp.mul(tv1, tv2);
+                let y1 = Fp.pow(tv1, c1);
+                y1 = Fp.mul(y1, tv2);
+                const y2 = Fp.mul(y1, c2);
+                const tv3 = Fp.mul(Fp.sqr(y1), v);
+                const isQR = Fp.eql(tv3, u);
+                let y = Fp.cmov(y2, y1, isQR);
+                return { isValid: isQR, value: y };
+            };
+        }
+        return sqrtRatio;
+    }
+    function mapToCurveSimpleSWU(Fp, opts) {
+        validateField(Fp);
+        const { A, B, Z } = opts;
+        if (!Fp.isValid(A) || !Fp.isValid(B) || !Fp.isValid(Z))
+            throw new Error('mapToCurveSimpleSWU: invalid opts');
+        const sqrtRatio = SWUFpSqrtRatio(Fp, Z);
+        if (!Fp.isOdd)
+            throw new Error('Field does not have .isOdd()');
+        return (u) => {
+            let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
+            tv1 = Fp.sqr(u);
+            tv1 = Fp.mul(tv1, Z);
+            tv2 = Fp.sqr(tv1);
+            tv2 = Fp.add(tv2, tv1);
+            tv3 = Fp.add(tv2, Fp.ONE);
+            tv3 = Fp.mul(tv3, B);
+            tv4 = Fp.cmov(Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+            tv4 = Fp.mul(tv4, A);
+            tv2 = Fp.sqr(tv3);
+            tv6 = Fp.sqr(tv4);
+            tv5 = Fp.mul(tv6, A);
+            tv2 = Fp.add(tv2, tv5);
+            tv2 = Fp.mul(tv2, tv3);
+            tv6 = Fp.mul(tv6, tv4);
+            tv5 = Fp.mul(tv6, B);
+            tv2 = Fp.add(tv2, tv5);
+            x = Fp.mul(tv1, tv3);
+            const { isValid, value } = sqrtRatio(tv2, tv6);
+            y = Fp.mul(tv1, u);
+            y = Fp.mul(y, value);
+            x = Fp.cmov(x, tv3, isValid);
+            y = Fp.cmov(y, value, isValid);
+            const e1 = Fp.isOdd(u) === Fp.isOdd(y);
+            y = Fp.cmov(Fp.neg(y), y, e1);
+            const tv4_inv = FpInvertBatch(Fp, [tv4], true)[0];
+            x = Fp.mul(x, tv4_inv);
+            return { x, y };
+        };
+    }
+    function getWLengths(Fp, Fn) {
+        return {
+            secretKey: Fn.BYTES,
+            publicKey: 1 + Fp.BYTES,
+            publicKeyUncompressed: 1 + 2 * Fp.BYTES,
+            publicKeyHasPrefix: true,
+            signature: 2 * Fn.BYTES,
+        };
+    }
+    function ecdh(Point, ecdhOpts = {}) {
+        const { Fn } = Point;
+        const randomBytes_ = ecdhOpts.randomBytes || randomBytes;
+        const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });
+        function isValidSecretKey(secretKey) {
+            try {
+                return !!_normFnElement(Fn, secretKey);
+            }
+            catch (error) {
+                return false;
+            }
+        }
+        function isValidPublicKey(publicKey, isCompressed) {
+            const { publicKey: comp, publicKeyUncompressed } = lengths;
+            try {
+                const l = publicKey.length;
+                if (isCompressed === true && l !== comp)
+                    return false;
+                if (isCompressed === false && l !== publicKeyUncompressed)
+                    return false;
+                return !!Point.fromBytes(publicKey);
+            }
+            catch (error) {
+                return false;
+            }
+        }
+        function randomSecretKey(seed = randomBytes_(lengths.seed)) {
+            return mapHashToField(_abytes2(seed, lengths.seed, 'seed'), Fn.ORDER);
+        }
+        function getPublicKey(secretKey, isCompressed = true) {
+            return Point.BASE.multiply(_normFnElement(Fn, secretKey)).toBytes(isCompressed);
+        }
+        function keygen(seed) {
+            const secretKey = randomSecretKey(seed);
+            return { secretKey, publicKey: getPublicKey(secretKey) };
+        }
+        function isProbPub(item) {
+            if (typeof item === 'bigint')
+                return false;
+            if (item instanceof Point)
+                return true;
+            const { secretKey, publicKey, publicKeyUncompressed } = lengths;
+            if (Fn.allowedLengths || secretKey === publicKey)
+                return undefined;
+            const l = ensureBytes('key', item).length;
+            return l === publicKey || l === publicKeyUncompressed;
+        }
+        function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {
+            if (isProbPub(secretKeyA) === true)
+                throw new Error('first arg must be private key');
+            if (isProbPub(publicKeyB) === false)
+                throw new Error('second arg must be public key');
+            const s = _normFnElement(Fn, secretKeyA);
+            const b = Point.fromHex(publicKeyB);
+            return b.multiply(s).toBytes(isCompressed);
+        }
+        const utils = {
+            isValidSecretKey,
+            isValidPublicKey,
+            randomSecretKey,
+            isValidPrivateKey: isValidSecretKey,
+            randomPrivateKey: randomSecretKey,
+            normPrivateKeyToScalar: (key) => _normFnElement(Fn, key),
+            precompute(windowSize = 8, point = Point.BASE) {
+                return point.precompute(windowSize, false);
+            },
+        };
+        return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });
+    }
+    function ecdsa(Point, hash, ecdsaOpts = {}) {
+        ahash(hash);
+        _validateObject(ecdsaOpts, {}, {
+            hmac: 'function',
+            lowS: 'boolean',
+            randomBytes: 'function',
+            bits2int: 'function',
+            bits2int_modN: 'function',
+        });
+        const randomBytes$1 = ecdsaOpts.randomBytes || randomBytes;
+        const hmac$1 = ecdsaOpts.hmac ||
+            ((key, ...msgs) => hmac(hash, key, concatBytes(...msgs)));
+        const { Fp, Fn } = Point;
+        const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
+        const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
+        const defaultSigOpts = {
+            prehash: false,
+            lowS: typeof ecdsaOpts.lowS === 'boolean' ? ecdsaOpts.lowS : false,
+            format: undefined,
+            extraEntropy: false,
+        };
+        const defaultSigOpts_format = 'compact';
+        function isBiggerThanHalfOrder(number) {
+            const HALF = CURVE_ORDER >> _1n$5;
+            return number > HALF;
+        }
+        function validateRS(title, num) {
+            if (!Fn.isValidNot0(num))
+                throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
+            return num;
+        }
+        function validateSigLength(bytes, format) {
+            validateSigFormat(format);
+            const size = lengths.signature;
+            const sizer = format === 'compact' ? size : format === 'recovered' ? size + 1 : undefined;
+            return _abytes2(bytes, sizer, `${format} signature`);
+        }
+        class Signature {
+            constructor(r, s, recovery) {
+                this.r = validateRS('r', r);
+                this.s = validateRS('s', s);
+                if (recovery != null)
+                    this.recovery = recovery;
+                Object.freeze(this);
+            }
+            static fromBytes(bytes, format = defaultSigOpts_format) {
+                validateSigLength(bytes, format);
+                let recid;
+                if (format === 'der') {
+                    const { r, s } = DER.toSig(_abytes2(bytes));
+                    return new Signature(r, s);
+                }
+                if (format === 'recovered') {
+                    recid = bytes[0];
+                    format = 'compact';
+                    bytes = bytes.subarray(1);
+                }
+                const L = Fn.BYTES;
+                const r = bytes.subarray(0, L);
+                const s = bytes.subarray(L, L * 2);
+                return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);
+            }
+            static fromHex(hex, format) {
+                return this.fromBytes(hexToBytes(hex), format);
+            }
+            addRecoveryBit(recovery) {
+                return new Signature(this.r, this.s, recovery);
+            }
+            recoverPublicKey(messageHash) {
+                const FIELD_ORDER = Fp.ORDER;
+                const { r, s, recovery: rec } = this;
+                if (rec == null || ![0, 1, 2, 3].includes(rec))
+                    throw new Error('recovery id invalid');
+                const hasCofactor = CURVE_ORDER * _2n$5 < FIELD_ORDER;
+                if (hasCofactor && rec > 1)
+                    throw new Error('recovery id is ambiguous for h>1 curve');
+                const radj = rec === 2 || rec === 3 ? r + CURVE_ORDER : r;
+                if (!Fp.isValid(radj))
+                    throw new Error('recovery id 2 or 3 invalid');
+                const x = Fp.toBytes(radj);
+                const R = Point.fromBytes(concatBytes(pprefix((rec & 1) === 0), x));
+                const ir = Fn.inv(radj);
+                const h = bits2int_modN(ensureBytes('msgHash', messageHash));
+                const u1 = Fn.create(-h * ir);
+                const u2 = Fn.create(s * ir);
+                const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+                if (Q.is0())
+                    throw new Error('point at infinify');
+                Q.assertValidity();
+                return Q;
+            }
+            hasHighS() {
+                return isBiggerThanHalfOrder(this.s);
+            }
+            toBytes(format = defaultSigOpts_format) {
+                validateSigFormat(format);
+                if (format === 'der')
+                    return hexToBytes(DER.hexFromSig(this));
+                const r = Fn.toBytes(this.r);
+                const s = Fn.toBytes(this.s);
+                if (format === 'recovered') {
+                    if (this.recovery == null)
+                        throw new Error('recovery bit must be present');
+                    return concatBytes(Uint8Array.of(this.recovery), r, s);
+                }
+                return concatBytes(r, s);
+            }
+            toHex(format) {
+                return bytesToHex(this.toBytes(format));
+            }
+            assertValidity() { }
+            static fromCompact(hex) {
+                return Signature.fromBytes(ensureBytes('sig', hex), 'compact');
+            }
+            static fromDER(hex) {
+                return Signature.fromBytes(ensureBytes('sig', hex), 'der');
+            }
+            normalizeS() {
+                return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
+            }
+            toDERRawBytes() {
+                return this.toBytes('der');
+            }
+            toDERHex() {
+                return bytesToHex(this.toBytes('der'));
+            }
+            toCompactRawBytes() {
+                return this.toBytes('compact');
+            }
+            toCompactHex() {
+                return bytesToHex(this.toBytes('compact'));
+            }
+        }
+        const bits2int = ecdsaOpts.bits2int ||
+            function bits2int_def(bytes) {
+                if (bytes.length > 8192)
+                    throw new Error('input is too large');
+                const num = bytesToNumberBE(bytes);
+                const delta = bytes.length * 8 - fnBits;
+                return delta > 0 ? num >> BigInt(delta) : num;
+            };
+        const bits2int_modN = ecdsaOpts.bits2int_modN ||
+            function bits2int_modN_def(bytes) {
+                return Fn.create(bits2int(bytes));
+            };
+        const ORDER_MASK = bitMask$1(fnBits);
+        function int2octets(num) {
+            aInRange$1('num < 2^' + fnBits, num, _0n$6, ORDER_MASK);
+            return Fn.toBytes(num);
+        }
+        function validateMsgAndHash(message, prehash) {
+            _abytes2(message, undefined, 'message');
+            return prehash ? _abytes2(hash(message), undefined, 'prehashed message') : message;
+        }
+        function prepSig(message, privateKey, opts) {
+            if (['recovered', 'canonical'].some((k) => k in opts))
+                throw new Error('sign() legacy options not supported');
+            const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);
+            message = validateMsgAndHash(message, prehash);
+            const h1int = bits2int_modN(message);
+            const d = _normFnElement(Fn, privateKey);
+            const seedArgs = [int2octets(d), int2octets(h1int)];
+            if (extraEntropy != null && extraEntropy !== false) {
+                const e = extraEntropy === true ? randomBytes$1(lengths.secretKey) : extraEntropy;
+                seedArgs.push(ensureBytes('extraEntropy', e));
+            }
+            const seed = concatBytes(...seedArgs);
+            const m = h1int;
+            function k2sig(kBytes) {
+                const k = bits2int(kBytes);
+                if (!Fn.isValidNot0(k))
+                    return;
+                const ik = Fn.inv(k);
+                const q = Point.BASE.multiply(k).toAffine();
+                const r = Fn.create(q.x);
+                if (r === _0n$6)
+                    return;
+                const s = Fn.create(ik * Fn.create(m + r * d));
+                if (s === _0n$6)
+                    return;
+                let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n$5);
+                let normS = s;
+                if (lowS && isBiggerThanHalfOrder(s)) {
+                    normS = Fn.neg(s);
+                    recovery ^= 1;
+                }
+                return new Signature(r, normS, recovery);
+            }
+            return { seed, k2sig };
+        }
+        function sign(message, secretKey, opts = {}) {
+            message = ensureBytes('message', message);
+            const { seed, k2sig } = prepSig(message, secretKey, opts);
+            const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac$1);
+            const sig = drbg(seed, k2sig);
+            return sig;
+        }
+        function tryParsingSig(sg) {
+            let sig = undefined;
+            const isHex = typeof sg === 'string' || isBytes$1(sg);
+            const isObj = !isHex &&
+                sg !== null &&
+                typeof sg === 'object' &&
+                typeof sg.r === 'bigint' &&
+                typeof sg.s === 'bigint';
+            if (!isHex && !isObj)
+                throw new Error('invalid signature, expected Uint8Array, hex string or Signature instance');
+            if (isObj) {
+                sig = new Signature(sg.r, sg.s);
+            }
+            else if (isHex) {
+                try {
+                    sig = Signature.fromBytes(ensureBytes('sig', sg), 'der');
+                }
+                catch (derError) {
+                    if (!(derError instanceof DER.Err))
+                        throw derError;
+                }
+                if (!sig) {
+                    try {
+                        sig = Signature.fromBytes(ensureBytes('sig', sg), 'compact');
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                }
+            }
+            if (!sig)
+                return false;
+            return sig;
+        }
+        function verify(signature, message, publicKey, opts = {}) {
+            const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+            publicKey = ensureBytes('publicKey', publicKey);
+            message = validateMsgAndHash(ensureBytes('message', message), prehash);
+            if ('strict' in opts)
+                throw new Error('options.strict was renamed to lowS');
+            const sig = format === undefined
+                ? tryParsingSig(signature)
+                : Signature.fromBytes(ensureBytes('sig', signature), format);
+            if (sig === false)
+                return false;
+            try {
+                const P = Point.fromBytes(publicKey);
+                if (lowS && sig.hasHighS())
+                    return false;
+                const { r, s } = sig;
+                const h = bits2int_modN(message);
+                const is = Fn.inv(s);
+                const u1 = Fn.create(h * is);
+                const u2 = Fn.create(r * is);
+                const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
+                if (R.is0())
+                    return false;
+                const v = Fn.create(R.x);
+                return v === r;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        function recoverPublicKey(signature, message, opts = {}) {
+            const { prehash } = validateSigOpts(opts, defaultSigOpts);
+            message = validateMsgAndHash(message, prehash);
+            return Signature.fromBytes(signature, 'recovered').recoverPublicKey(message).toBytes();
+        }
+        return Object.freeze({
+            keygen,
+            getPublicKey,
+            getSharedSecret,
+            utils,
+            lengths,
+            Point,
+            sign,
+            verify,
+            recoverPublicKey,
+            Signature,
+            hash,
+        });
+    }
+    function _weierstrass_legacy_opts_to_new(c) {
+        const CURVE = {
+            a: c.a,
+            b: c.b,
+            p: c.Fp.ORDER,
+            n: c.n,
+            h: c.h,
+            Gx: c.Gx,
+            Gy: c.Gy,
+        };
+        const Fp = c.Fp;
+        let allowedLengths = c.allowedPrivateKeyLengths
+            ? Array.from(new Set(c.allowedPrivateKeyLengths.map((l) => Math.ceil(l / 2))))
+            : undefined;
+        const Fn = Field(CURVE.n, {
+            BITS: c.nBitLength,
+            allowedLengths: allowedLengths,
+            modFromBytes: c.wrapPrivateKey,
+        });
+        const curveOpts = {
+            Fp,
+            Fn,
+            allowInfinityPoint: c.allowInfinityPoint,
+            endo: c.endo,
+            isTorsionFree: c.isTorsionFree,
+            clearCofactor: c.clearCofactor,
+            fromBytes: c.fromBytes,
+            toBytes: c.toBytes,
+        };
+        return { CURVE, curveOpts };
+    }
+    function _ecdsa_legacy_opts_to_new(c) {
+        const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);
+        const ecdsaOpts = {
+            hmac: c.hmac,
+            randomBytes: c.randomBytes,
+            lowS: c.lowS,
+            bits2int: c.bits2int,
+            bits2int_modN: c.bits2int_modN,
+        };
+        return { CURVE, curveOpts, hash: c.hash, ecdsaOpts };
+    }
+    function _ecdsa_new_output_to_legacy(c, _ecdsa) {
+        const Point = _ecdsa.Point;
+        return Object.assign({}, _ecdsa, {
+            ProjectivePoint: Point,
+            CURVE: Object.assign({}, c, nLength(Point.Fn.ORDER, Point.Fn.BITS)),
+        });
+    }
+    function weierstrass(c) {
+        const { CURVE, curveOpts, hash, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c);
+        const Point = weierstrassN(CURVE, curveOpts);
+        const signs = ecdsa(Point, hash, ecdsaOpts);
+        return _ecdsa_new_output_to_legacy(c, signs);
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    function createCurve(curveDef, defHash) {
+        const create = (hash) => weierstrass({ ...curveDef, hash: hash });
+        return { ...create(defHash), create };
+    }
+
+    const os2ip = bytesToNumberBE;
+    function i2osp(value, length) {
+        anum(value);
+        anum(length);
+        if (value < 0 || value >= 1 << (8 * length))
+            throw new Error('invalid I2OSP input: ' + value);
+        const res = Array.from({ length }).fill(0);
+        for (let i = length - 1; i >= 0; i--) {
+            res[i] = value & 0xff;
+            value >>>= 8;
+        }
+        return new Uint8Array(res);
+    }
+    function strxor(a, b) {
+        const arr = new Uint8Array(a.length);
+        for (let i = 0; i < a.length; i++) {
+            arr[i] = a[i] ^ b[i];
+        }
+        return arr;
+    }
+    function anum(item) {
+        if (!Number.isSafeInteger(item))
+            throw new Error('number expected');
+    }
+    function normDST(DST) {
+        if (!isBytes$1(DST) && typeof DST !== 'string')
+            throw new Error('DST must be Uint8Array or string');
+        return typeof DST === 'string' ? utf8ToBytes(DST) : DST;
+    }
+    function expand_message_xmd(msg, DST, lenInBytes, H) {
+        abytes$1(msg);
+        anum(lenInBytes);
+        DST = normDST(DST);
+        if (DST.length > 255)
+            DST = H(concatBytes(utf8ToBytes('H2C-OVERSIZE-DST-'), DST));
+        const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
+        const ell = Math.ceil(lenInBytes / b_in_bytes);
+        if (lenInBytes > 65535 || ell > 255)
+            throw new Error('expand_message_xmd: invalid lenInBytes');
+        const DST_prime = concatBytes(DST, i2osp(DST.length, 1));
+        const Z_pad = i2osp(0, r_in_bytes);
+        const l_i_b_str = i2osp(lenInBytes, 2);
+        const b = new Array(ell);
+        const b_0 = H(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+        b[0] = H(concatBytes(b_0, i2osp(1, 1), DST_prime));
+        for (let i = 1; i <= ell; i++) {
+            const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
+            b[i] = H(concatBytes(...args));
+        }
+        const pseudo_random_bytes = concatBytes(...b);
+        return pseudo_random_bytes.slice(0, lenInBytes);
+    }
+    function expand_message_xof(msg, DST, lenInBytes, k, H) {
+        abytes$1(msg);
+        anum(lenInBytes);
+        DST = normDST(DST);
+        if (DST.length > 255) {
+            const dkLen = Math.ceil((2 * k) / 8);
+            DST = H.create({ dkLen }).update(utf8ToBytes('H2C-OVERSIZE-DST-')).update(DST).digest();
+        }
+        if (lenInBytes > 65535 || DST.length > 255)
+            throw new Error('expand_message_xof: invalid lenInBytes');
+        return (H.create({ dkLen: lenInBytes })
+            .update(msg)
+            .update(i2osp(lenInBytes, 2))
+            .update(DST)
+            .update(i2osp(DST.length, 1))
+            .digest());
+    }
+    function hash_to_field(msg, count, options) {
+        _validateObject(options, {
+            p: 'bigint',
+            m: 'number',
+            k: 'number',
+            hash: 'function',
+        });
+        const { p, k, m, hash, expand, DST } = options;
+        if (!isHash(options.hash))
+            throw new Error('expected valid hash');
+        abytes$1(msg);
+        anum(count);
+        const log2p = p.toString(2).length;
+        const L = Math.ceil((log2p + k) / 8);
+        const len_in_bytes = count * m * L;
+        let prb;
+        if (expand === 'xmd') {
+            prb = expand_message_xmd(msg, DST, len_in_bytes, hash);
+        }
+        else if (expand === 'xof') {
+            prb = expand_message_xof(msg, DST, len_in_bytes, k, hash);
+        }
+        else if (expand === '_internal_pass') {
+            prb = msg;
+        }
+        else {
+            throw new Error('expand must be "xmd" or "xof"');
+        }
+        const u = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const e = new Array(m);
+            for (let j = 0; j < m; j++) {
+                const elm_offset = L * (j + i * m);
+                const tv = prb.subarray(elm_offset, elm_offset + L);
+                e[j] = mod(os2ip(tv), p);
+            }
+            u[i] = e;
+        }
+        return u;
+    }
+    function isogenyMap(field, map) {
+        const coeff = map.map((i) => Array.from(i).reverse());
+        return (x, y) => {
+            const [xn, xd, yn, yd] = coeff.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
+            const [xd_inv, yd_inv] = FpInvertBatch(field, [xd, yd], true);
+            x = field.mul(xn, xd_inv);
+            y = field.mul(y, field.mul(yn, yd_inv));
+            return { x, y };
+        };
+    }
+    const _DST_scalar = utf8ToBytes('HashToScalar-');
+    function createHasher(Point, mapToCurve, defaults) {
+        if (typeof mapToCurve !== 'function')
+            throw new Error('mapToCurve() must be defined');
+        function map(num) {
+            return Point.fromAffine(mapToCurve(num));
+        }
+        function clear(initial) {
+            const P = initial.clearCofactor();
+            if (P.equals(Point.ZERO))
+                return Point.ZERO;
+            P.assertValidity();
+            return P;
+        }
+        return {
+            defaults,
+            hashToCurve(msg, options) {
+                const opts = Object.assign({}, defaults, options);
+                const u = hash_to_field(msg, 2, opts);
+                const u0 = map(u[0]);
+                const u1 = map(u[1]);
+                return clear(u0.add(u1));
+            },
+            encodeToCurve(msg, options) {
+                const optsDst = defaults.encodeDST ? { DST: defaults.encodeDST } : {};
+                const opts = Object.assign({}, defaults, optsDst, options);
+                const u = hash_to_field(msg, 1, opts);
+                const u0 = map(u[0]);
+                return clear(u0);
+            },
+            mapToCurve(scalars) {
+                if (!Array.isArray(scalars))
+                    throw new Error('expected array of bigints');
+                for (const i of scalars)
+                    if (typeof i !== 'bigint')
+                        throw new Error('expected array of bigints');
+                return clear(map(scalars));
+            },
+            hashToScalar(msg, options) {
+                const N = Point.Fn.ORDER;
+                const opts = Object.assign({}, defaults, { p: N, m: 1, DST: _DST_scalar }, options);
+                return hash_to_field(msg, 1, opts)[0][0];
+            },
+        };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const secp256k1_CURVE = {
+        p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
+        n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),
+        h: BigInt(1),
+        a: BigInt(0),
+        b: BigInt(7),
+        Gx: BigInt('0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+        Gy: BigInt('0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'),
+    };
+    const secp256k1_ENDO = {
+        beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
+        basises: [
+            [BigInt('0x3086d221a7d46bcde86c90e49284eb15'), -BigInt('0xe4437ed6010e88286f547fa90abfe4c3')],
+            [BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8'), BigInt('0x3086d221a7d46bcde86c90e49284eb15')],
+        ],
+    };
+    const _0n$5 =  BigInt(0);
+    const _1n$4 =  BigInt(1);
+    const _2n$4 =  BigInt(2);
+    function sqrtMod(y) {
+        const P = secp256k1_CURVE.p;
+        const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+        const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+        const b2 = (y * y * y) % P;
+        const b3 = (b2 * b2 * y) % P;
+        const b6 = (pow2(b3, _3n, P) * b3) % P;
+        const b9 = (pow2(b6, _3n, P) * b3) % P;
+        const b11 = (pow2(b9, _2n$4, P) * b2) % P;
+        const b22 = (pow2(b11, _11n, P) * b11) % P;
+        const b44 = (pow2(b22, _22n, P) * b22) % P;
+        const b88 = (pow2(b44, _44n, P) * b44) % P;
+        const b176 = (pow2(b88, _88n, P) * b88) % P;
+        const b220 = (pow2(b176, _44n, P) * b44) % P;
+        const b223 = (pow2(b220, _3n, P) * b3) % P;
+        const t1 = (pow2(b223, _23n, P) * b22) % P;
+        const t2 = (pow2(t1, _6n, P) * b2) % P;
+        const root = pow2(t2, _2n$4, P);
+        if (!Fpk1.eql(Fpk1.sqr(root), y))
+            throw new Error('Cannot find square root');
+        return root;
+    }
+    const Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+    const secp256k1 = createCurve({ ...secp256k1_CURVE, Fp: Fpk1, lowS: true, endo: secp256k1_ENDO }, sha256);
+    const TAGGED_HASH_PREFIXES = {};
+    function taggedHash(tag, ...messages) {
+        let tagP = TAGGED_HASH_PREFIXES[tag];
+        if (tagP === undefined) {
+            const tagH = sha256(utf8ToBytes(tag));
+            tagP = concatBytes(tagH, tagH);
+            TAGGED_HASH_PREFIXES[tag] = tagP;
+        }
+        return sha256(concatBytes(tagP, ...messages));
+    }
+    const pointToBytes = (point) => point.toBytes(true).slice(1);
+    const Pointk1 =  (() => secp256k1.Point)();
+    const hasEven = (y) => y % _2n$4 === _0n$5;
+    function schnorrGetExtPubKey(priv) {
+        const { Fn, BASE } = Pointk1;
+        const d_ = _normFnElement(Fn, priv);
+        const p = BASE.multiply(d_);
+        const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
+        return { scalar, bytes: pointToBytes(p) };
+    }
+    function lift_x(x) {
+        const Fp = Fpk1;
+        if (!Fp.isValidNot0(x))
+            throw new Error('invalid x: Fail if x ≥ p');
+        const xx = Fp.create(x * x);
+        const c = Fp.create(xx * x + BigInt(7));
+        let y = Fp.sqrt(c);
+        if (!hasEven(y))
+            y = Fp.neg(y);
+        const p = Pointk1.fromAffine({ x, y });
+        p.assertValidity();
+        return p;
+    }
+    const num = bytesToNumberBE;
+    function challenge(...args) {
+        return Pointk1.Fn.create(num(taggedHash('BIP0340/challenge', ...args)));
+    }
+    function schnorrGetPublicKey(secretKey) {
+        return schnorrGetExtPubKey(secretKey).bytes;
+    }
+    function schnorrSign(message, secretKey, auxRand = randomBytes(32)) {
+        const { Fn } = Pointk1;
+        const m = ensureBytes('message', message);
+        const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey);
+        const a = ensureBytes('auxRand', auxRand, 32);
+        const t = Fn.toBytes(d ^ num(taggedHash('BIP0340/aux', a)));
+        const rand = taggedHash('BIP0340/nonce', t, px, m);
+        const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand);
+        const e = challenge(rx, px, m);
+        const sig = new Uint8Array(64);
+        sig.set(rx, 0);
+        sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);
+        if (!schnorrVerify(sig, m, px))
+            throw new Error('sign: Invalid signature produced');
+        return sig;
+    }
+    function schnorrVerify(signature, message, publicKey) {
+        const { Fn, BASE } = Pointk1;
+        const sig = ensureBytes('signature', signature, 64);
+        const m = ensureBytes('message', message);
+        const pub = ensureBytes('publicKey', publicKey, 32);
+        try {
+            const P = lift_x(num(pub));
+            const r = num(sig.subarray(0, 32));
+            if (!inRange(r, _1n$4, secp256k1_CURVE.p))
+                return false;
+            const s = num(sig.subarray(32, 64));
+            if (!inRange(s, _1n$4, secp256k1_CURVE.n))
+                return false;
+            const e = challenge(Fn.toBytes(r), pointToBytes(P), m);
+            const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+            const { x, y } = R.toAffine();
+            if (R.is0() || !hasEven(y) || x !== r)
+                return false;
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    (() => {
+        const size = 32;
+        const seedLength = 48;
+        const randomSecretKey = (seed = randomBytes(seedLength)) => {
+            return mapHashToField(seed, secp256k1_CURVE.n);
+        };
+        secp256k1.utils.randomSecretKey;
+        function keygen(seed) {
+            const secretKey = randomSecretKey(seed);
+            return { secretKey, publicKey: schnorrGetPublicKey(secretKey) };
+        }
+        return {
+            keygen,
+            getPublicKey: schnorrGetPublicKey,
+            sign: schnorrSign,
+            verify: schnorrVerify,
+            Point: Pointk1,
+            utils: {
+                randomSecretKey: randomSecretKey,
+                randomPrivateKey: randomSecretKey,
+                taggedHash,
+                lift_x,
+                pointToBytes,
+                numberToBytesBE,
+                bytesToNumberBE,
+                mod,
+            },
+            lengths: {
+                secretKey: size,
+                publicKey: size,
+                publicKeyHasPrefix: false,
+                signature: size * 2,
+                seed: seedLength,
+            },
+        };
+    })();
+    const isoMap =  (() => isogenyMap(Fpk1, [
+        [
+            '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',
+            '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',
+            '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',
+            '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',
+        ],
+        [
+            '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',
+            '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+        ],
+        [
+            '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',
+            '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',
+            '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',
+            '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',
+        ],
+        [
+            '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',
+            '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',
+            '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+        ],
+    ].map((i) => i.map((j) => BigInt(j)))))();
+    const mapSWU =  (() => mapToCurveSimpleSWU(Fpk1, {
+        A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),
+        B: BigInt('1771'),
+        Z: Fpk1.create(BigInt('-11')),
+    }))();
+    (() => createHasher(secp256k1.Point, (scalars) => {
+        const { x, y } = mapSWU(Fpk1.create(scalars[0]));
+        return isoMap(x, y);
+    }, {
+        DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',
+        encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',
+        p: Fpk1.ORDER,
+        m: 1,
+        k: 128,
+        expand: 'xmd',
+        hash: sha256,
+    }))();
+
+    function secp256k1PairFromSeed(seed, onlyJs) {
+        if (seed.length !== 32) {
+            throw new Error('Expected valid 32-byte private key as a seed');
+        }
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            const full = secp256k1FromSeed(seed);
+            const publicKey = full.slice(32);
+            if (util.u8aEmpty(publicKey)) {
+                throw new Error('Invalid publicKey generated from WASM interface');
+            }
+            return {
+                publicKey,
+                secretKey: full.slice(0, 32)
+            };
+        }
+        return {
+            publicKey: secp256k1.getPublicKey(seed, true),
+            secretKey: seed
+        };
+    }
+
+    function createSeedDeriveFn(fromSeed, derive) {
+        return (keypair, { chainCode, isHard }) => {
+            if (!isHard) {
+                throw new Error('A soft key was found in the path and is not supported');
+            }
+            return fromSeed(derive(keypair.secretKey.subarray(0, 32), chainCode));
+        };
+    }
+
+    const keyHdkdEcdsa =  createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);
+
+    const HDKD$1 = util.compactAddLength(util.stringToU8a('Ed25519HDKD'));
+    function ed25519DeriveHard(seed, chainCode) {
+        if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        return blake2AsU8a(util.u8aConcat(HDKD$1, seed, chainCode));
+    }
+
+    function randomAsU8a(length = 32) {
+        return browser.getRandomValues(new Uint8Array(length));
+    }
+    const randomAsHex =  createAsHex(randomAsU8a);
+
+    const BN_53 = new util.BN(0b11111111111111111111111111111111111111111111111111111);
+    function randomAsNumber() {
+        return util.hexToBn(randomAsHex(8)).and(BN_53).toNumber();
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$4 = BigInt(0), _1n$3 = BigInt(1), _2n$3 = BigInt(2), _8n$1 = BigInt(8);
+    function isEdValidXY(Fp, CURVE, x, y) {
+        const x2 = Fp.sqr(x);
+        const y2 = Fp.sqr(y);
+        const left = Fp.add(Fp.mul(CURVE.a, x2), y2);
+        const right = Fp.add(Fp.ONE, Fp.mul(CURVE.d, Fp.mul(x2, y2)));
+        return Fp.eql(left, right);
+    }
+    function edwards(params, extraOpts = {}) {
+        const validated = _createCurveFields('edwards', params, extraOpts, extraOpts.FpFnLE);
+        const { Fp, Fn } = validated;
+        let CURVE = validated.CURVE;
+        const { h: cofactor } = CURVE;
+        _validateObject(extraOpts, {}, { uvRatio: 'function' });
+        const MASK = _2n$3 << (BigInt(Fn.BYTES * 8) - _1n$3);
+        const modP = (n) => Fp.create(n);
+        const uvRatio = extraOpts.uvRatio ||
+            ((u, v) => {
+                try {
+                    return { isValid: true, value: Fp.sqrt(Fp.div(u, v)) };
+                }
+                catch (e) {
+                    return { isValid: false, value: _0n$4 };
+                }
+            });
+        if (!isEdValidXY(Fp, CURVE, CURVE.Gx, CURVE.Gy))
+            throw new Error('bad curve params: generator point');
+        function acoord(title, n, banZero = false) {
+            const min = banZero ? _1n$3 : _0n$4;
+            aInRange$1('coordinate ' + title, n, min, MASK);
+            return n;
+        }
+        function aextpoint(other) {
+            if (!(other instanceof Point))
+                throw new Error('ExtendedPoint expected');
+        }
+        const toAffineMemo = memoized((p, iz) => {
+            const { X, Y, Z } = p;
+            const is0 = p.is0();
+            if (iz == null)
+                iz = is0 ? _8n$1 : Fp.inv(Z);
+            const x = modP(X * iz);
+            const y = modP(Y * iz);
+            const zz = Fp.mul(Z, iz);
+            if (is0)
+                return { x: _0n$4, y: _1n$3 };
+            if (zz !== _1n$3)
+                throw new Error('invZ was invalid');
+            return { x, y };
+        });
+        const assertValidMemo = memoized((p) => {
+            const { a, d } = CURVE;
+            if (p.is0())
+                throw new Error('bad point: ZERO');
+            const { X, Y, Z, T } = p;
+            const X2 = modP(X * X);
+            const Y2 = modP(Y * Y);
+            const Z2 = modP(Z * Z);
+            const Z4 = modP(Z2 * Z2);
+            const aX2 = modP(X2 * a);
+            const left = modP(Z2 * modP(aX2 + Y2));
+            const right = modP(Z4 + modP(d * modP(X2 * Y2)));
+            if (left !== right)
+                throw new Error('bad point: equation left != right (1)');
+            const XY = modP(X * Y);
+            const ZT = modP(Z * T);
+            if (XY !== ZT)
+                throw new Error('bad point: equation left != right (2)');
+            return true;
+        });
+        class Point {
+            constructor(X, Y, Z, T) {
+                this.X = acoord('x', X);
+                this.Y = acoord('y', Y);
+                this.Z = acoord('z', Z, true);
+                this.T = acoord('t', T);
+                Object.freeze(this);
+            }
+            static CURVE() {
+                return CURVE;
+            }
+            static fromAffine(p) {
+                if (p instanceof Point)
+                    throw new Error('extended point not allowed');
+                const { x, y } = p || {};
+                acoord('x', x);
+                acoord('y', y);
+                return new Point(x, y, _1n$3, modP(x * y));
+            }
+            static fromBytes(bytes, zip215 = false) {
+                const len = Fp.BYTES;
+                const { a, d } = CURVE;
+                bytes = copyBytes(_abytes2(bytes, len, 'point'));
+                _abool2(zip215, 'zip215');
+                const normed = copyBytes(bytes);
+                const lastByte = bytes[len - 1];
+                normed[len - 1] = lastByte & -129;
+                const y = bytesToNumberLE$1(normed);
+                const max = zip215 ? MASK : Fp.ORDER;
+                aInRange$1('point.y', y, _0n$4, max);
+                const y2 = modP(y * y);
+                const u = modP(y2 - _1n$3);
+                const v = modP(d * y2 - a);
+                let { isValid, value: x } = uvRatio(u, v);
+                if (!isValid)
+                    throw new Error('bad point: invalid y coordinate');
+                const isXOdd = (x & _1n$3) === _1n$3;
+                const isLastByteOdd = (lastByte & 0x80) !== 0;
+                if (!zip215 && x === _0n$4 && isLastByteOdd)
+                    throw new Error('bad point: x=0 and x_0=1');
+                if (isLastByteOdd !== isXOdd)
+                    x = modP(-x);
+                return Point.fromAffine({ x, y });
+            }
+            static fromHex(bytes, zip215 = false) {
+                return Point.fromBytes(ensureBytes('point', bytes), zip215);
+            }
+            get x() {
+                return this.toAffine().x;
+            }
+            get y() {
+                return this.toAffine().y;
+            }
+            precompute(windowSize = 8, isLazy = true) {
+                wnaf.createCache(this, windowSize);
+                if (!isLazy)
+                    this.multiply(_2n$3);
+                return this;
+            }
+            assertValidity() {
+                assertValidMemo(this);
+            }
+            equals(other) {
+                aextpoint(other);
+                const { X: X1, Y: Y1, Z: Z1 } = this;
+                const { X: X2, Y: Y2, Z: Z2 } = other;
+                const X1Z2 = modP(X1 * Z2);
+                const X2Z1 = modP(X2 * Z1);
+                const Y1Z2 = modP(Y1 * Z2);
+                const Y2Z1 = modP(Y2 * Z1);
+                return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+            }
+            is0() {
+                return this.equals(Point.ZERO);
+            }
+            negate() {
+                return new Point(modP(-this.X), this.Y, this.Z, modP(-this.T));
+            }
+            double() {
+                const { a } = CURVE;
+                const { X: X1, Y: Y1, Z: Z1 } = this;
+                const A = modP(X1 * X1);
+                const B = modP(Y1 * Y1);
+                const C = modP(_2n$3 * modP(Z1 * Z1));
+                const D = modP(a * A);
+                const x1y1 = X1 + Y1;
+                const E = modP(modP(x1y1 * x1y1) - A - B);
+                const G = D + B;
+                const F = G - C;
+                const H = D - B;
+                const X3 = modP(E * F);
+                const Y3 = modP(G * H);
+                const T3 = modP(E * H);
+                const Z3 = modP(F * G);
+                return new Point(X3, Y3, Z3, T3);
+            }
+            add(other) {
+                aextpoint(other);
+                const { a, d } = CURVE;
+                const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+                const { X: X2, Y: Y2, Z: Z2, T: T2 } = other;
+                const A = modP(X1 * X2);
+                const B = modP(Y1 * Y2);
+                const C = modP(T1 * d * T2);
+                const D = modP(Z1 * Z2);
+                const E = modP((X1 + Y1) * (X2 + Y2) - A - B);
+                const F = D - C;
+                const G = D + C;
+                const H = modP(B - a * A);
+                const X3 = modP(E * F);
+                const Y3 = modP(G * H);
+                const T3 = modP(E * H);
+                const Z3 = modP(F * G);
+                return new Point(X3, Y3, Z3, T3);
+            }
+            subtract(other) {
+                return this.add(other.negate());
+            }
+            multiply(scalar) {
+                if (!Fn.isValidNot0(scalar))
+                    throw new Error('invalid scalar: expected 1 <= sc < curve.n');
+                const { p, f } = wnaf.cached(this, scalar, (p) => normalizeZ(Point, p));
+                return normalizeZ(Point, [p, f])[0];
+            }
+            multiplyUnsafe(scalar, acc = Point.ZERO) {
+                if (!Fn.isValid(scalar))
+                    throw new Error('invalid scalar: expected 0 <= sc < curve.n');
+                if (scalar === _0n$4)
+                    return Point.ZERO;
+                if (this.is0() || scalar === _1n$3)
+                    return this;
+                return wnaf.unsafe(this, scalar, (p) => normalizeZ(Point, p), acc);
+            }
+            isSmallOrder() {
+                return this.multiplyUnsafe(cofactor).is0();
+            }
+            isTorsionFree() {
+                return wnaf.unsafe(this, CURVE.n).is0();
+            }
+            toAffine(invertedZ) {
+                return toAffineMemo(this, invertedZ);
+            }
+            clearCofactor() {
+                if (cofactor === _1n$3)
+                    return this;
+                return this.multiplyUnsafe(cofactor);
+            }
+            toBytes() {
+                const { x, y } = this.toAffine();
+                const bytes = Fp.toBytes(y);
+                bytes[bytes.length - 1] |= x & _1n$3 ? 0x80 : 0;
+                return bytes;
+            }
+            toHex() {
+                return bytesToHex(this.toBytes());
+            }
+            toString() {
+                return `<Point ${this.is0() ? 'ZERO' : this.toHex()}>`;
+            }
+            get ex() {
+                return this.X;
+            }
+            get ey() {
+                return this.Y;
+            }
+            get ez() {
+                return this.Z;
+            }
+            get et() {
+                return this.T;
+            }
+            static normalizeZ(points) {
+                return normalizeZ(Point, points);
+            }
+            static msm(points, scalars) {
+                return pippenger(Point, Fn, points, scalars);
+            }
+            _setWindowSize(windowSize) {
+                this.precompute(windowSize);
+            }
+            toRawBytes() {
+                return this.toBytes();
+            }
+        }
+        Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n$3, modP(CURVE.Gx * CURVE.Gy));
+        Point.ZERO = new Point(_0n$4, _1n$3, _1n$3, _0n$4);
+        Point.Fp = Fp;
+        Point.Fn = Fn;
+        const wnaf = new wNAF(Point, Fn.BITS);
+        Point.BASE.precompute(8);
+        return Point;
+    }
+    class PrimeEdwardsPoint {
+        constructor(ep) {
+            this.ep = ep;
+        }
+        static fromBytes(_bytes) {
+            notImplemented();
+        }
+        static fromHex(_hex) {
+            notImplemented();
+        }
+        get x() {
+            return this.toAffine().x;
+        }
+        get y() {
+            return this.toAffine().y;
+        }
+        clearCofactor() {
+            return this;
+        }
+        assertValidity() {
+            this.ep.assertValidity();
+        }
+        toAffine(invertedZ) {
+            return this.ep.toAffine(invertedZ);
+        }
+        toHex() {
+            return bytesToHex(this.toBytes());
+        }
+        toString() {
+            return this.toHex();
+        }
+        isTorsionFree() {
+            return true;
+        }
+        isSmallOrder() {
+            return false;
+        }
+        add(other) {
+            this.assertSame(other);
+            return this.init(this.ep.add(other.ep));
+        }
+        subtract(other) {
+            this.assertSame(other);
+            return this.init(this.ep.subtract(other.ep));
+        }
+        multiply(scalar) {
+            return this.init(this.ep.multiply(scalar));
+        }
+        multiplyUnsafe(scalar) {
+            return this.init(this.ep.multiplyUnsafe(scalar));
+        }
+        double() {
+            return this.init(this.ep.double());
+        }
+        negate() {
+            return this.init(this.ep.negate());
+        }
+        precompute(windowSize, isLazy) {
+            return this.init(this.ep.precompute(windowSize, isLazy));
+        }
+        toRawBytes() {
+            return this.toBytes();
+        }
+    }
+    function eddsa(Point, cHash, eddsaOpts = {}) {
+        if (typeof cHash !== 'function')
+            throw new Error('"hash" function param is required');
+        _validateObject(eddsaOpts, {}, {
+            adjustScalarBytes: 'function',
+            randomBytes: 'function',
+            domain: 'function',
+            prehash: 'function',
+            mapToCurve: 'function',
+        });
+        const { prehash } = eddsaOpts;
+        const { BASE, Fp, Fn } = Point;
+        const randomBytes$1 = eddsaOpts.randomBytes || randomBytes;
+        const adjustScalarBytes = eddsaOpts.adjustScalarBytes || ((bytes) => bytes);
+        const domain = eddsaOpts.domain ||
+            ((data, ctx, phflag) => {
+                _abool2(phflag, 'phflag');
+                if (ctx.length || phflag)
+                    throw new Error('Contexts/pre-hash are not supported');
+                return data;
+            });
+        function modN_LE(hash) {
+            return Fn.create(bytesToNumberLE$1(hash));
+        }
+        function getPrivateScalar(key) {
+            const len = lengths.secretKey;
+            key = ensureBytes('private key', key, len);
+            const hashed = ensureBytes('hashed private key', cHash(key), 2 * len);
+            const head = adjustScalarBytes(hashed.slice(0, len));
+            const prefix = hashed.slice(len, 2 * len);
+            const scalar = modN_LE(head);
+            return { head, prefix, scalar };
+        }
+        function getExtendedPublicKey(secretKey) {
+            const { head, prefix, scalar } = getPrivateScalar(secretKey);
+            const point = BASE.multiply(scalar);
+            const pointBytes = point.toBytes();
+            return { head, prefix, scalar, point, pointBytes };
+        }
+        function getPublicKey(secretKey) {
+            return getExtendedPublicKey(secretKey).pointBytes;
+        }
+        function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
+            const msg = concatBytes(...msgs);
+            return modN_LE(cHash(domain(msg, ensureBytes('context', context), !!prehash)));
+        }
+        function sign(msg, secretKey, options = {}) {
+            msg = ensureBytes('message', msg);
+            if (prehash)
+                msg = prehash(msg);
+            const { prefix, scalar, pointBytes } = getExtendedPublicKey(secretKey);
+            const r = hashDomainToScalar(options.context, prefix, msg);
+            const R = BASE.multiply(r).toBytes();
+            const k = hashDomainToScalar(options.context, R, pointBytes, msg);
+            const s = Fn.create(r + k * scalar);
+            if (!Fn.isValid(s))
+                throw new Error('sign failed: invalid s');
+            const rs = concatBytes(R, Fn.toBytes(s));
+            return _abytes2(rs, lengths.signature, 'result');
+        }
+        const verifyOpts = { zip215: true };
+        function verify(sig, msg, publicKey, options = verifyOpts) {
+            const { context, zip215 } = options;
+            const len = lengths.signature;
+            sig = ensureBytes('signature', sig, len);
+            msg = ensureBytes('message', msg);
+            publicKey = ensureBytes('publicKey', publicKey, lengths.publicKey);
+            if (zip215 !== undefined)
+                _abool2(zip215, 'zip215');
+            if (prehash)
+                msg = prehash(msg);
+            const mid = len / 2;
+            const r = sig.subarray(0, mid);
+            const s = bytesToNumberLE$1(sig.subarray(mid, len));
+            let A, R, SB;
+            try {
+                A = Point.fromBytes(publicKey, zip215);
+                R = Point.fromBytes(r, zip215);
+                SB = BASE.multiplyUnsafe(s);
+            }
+            catch (error) {
+                return false;
+            }
+            if (!zip215 && A.isSmallOrder())
+                return false;
+            const k = hashDomainToScalar(context, R.toBytes(), A.toBytes(), msg);
+            const RkA = R.add(A.multiplyUnsafe(k));
+            return RkA.subtract(SB).clearCofactor().is0();
+        }
+        const _size = Fp.BYTES;
+        const lengths = {
+            secretKey: _size,
+            publicKey: _size,
+            signature: 2 * _size,
+            seed: _size,
+        };
+        function randomSecretKey(seed = randomBytes$1(lengths.seed)) {
+            return _abytes2(seed, lengths.seed, 'seed');
+        }
+        function keygen(seed) {
+            const secretKey = utils.randomSecretKey(seed);
+            return { secretKey, publicKey: getPublicKey(secretKey) };
+        }
+        function isValidSecretKey(key) {
+            return isBytes$1(key) && key.length === Fn.BYTES;
+        }
+        function isValidPublicKey(key, zip215) {
+            try {
+                return !!Point.fromBytes(key, zip215);
+            }
+            catch (error) {
+                return false;
+            }
+        }
+        const utils = {
+            getExtendedPublicKey,
+            randomSecretKey,
+            isValidSecretKey,
+            isValidPublicKey,
+            toMontgomery(publicKey) {
+                const { y } = Point.fromBytes(publicKey);
+                const size = lengths.publicKey;
+                const is25519 = size === 32;
+                if (!is25519 && size !== 57)
+                    throw new Error('only defined for 25519 and 448');
+                const u = is25519 ? Fp.div(_1n$3 + y, _1n$3 - y) : Fp.div(y - _1n$3, y + _1n$3);
+                return Fp.toBytes(u);
+            },
+            toMontgomerySecret(secretKey) {
+                const size = lengths.secretKey;
+                _abytes2(secretKey, size);
+                const hashed = cHash(secretKey.subarray(0, size));
+                return adjustScalarBytes(hashed).subarray(0, size);
+            },
+            randomPrivateKey: randomSecretKey,
+            precompute(windowSize = 8, point = Point.BASE) {
+                return point.precompute(windowSize, false);
+            },
+        };
+        return Object.freeze({
+            keygen,
+            getPublicKey,
+            sign,
+            verify,
+            utils,
+            Point,
+            lengths,
+        });
+    }
+    function _eddsa_legacy_opts_to_new(c) {
+        const CURVE = {
+            a: c.a,
+            d: c.d,
+            p: c.Fp.ORDER,
+            n: c.n,
+            h: c.h,
+            Gx: c.Gx,
+            Gy: c.Gy,
+        };
+        const Fp = c.Fp;
+        const Fn = Field(CURVE.n, c.nBitLength, true);
+        const curveOpts = { Fp, Fn, uvRatio: c.uvRatio };
+        const eddsaOpts = {
+            randomBytes: c.randomBytes,
+            adjustScalarBytes: c.adjustScalarBytes,
+            domain: c.domain,
+            prehash: c.prehash,
+            mapToCurve: c.mapToCurve,
+        };
+        return { CURVE, curveOpts, hash: c.hash, eddsaOpts };
+    }
+    function _eddsa_new_output_to_legacy(c, eddsa) {
+        const Point = eddsa.Point;
+        const legacy = Object.assign({}, eddsa, {
+            ExtendedPoint: Point,
+            CURVE: c,
+            nBitLength: Point.Fn.BITS,
+            nByteLength: Point.Fn.BYTES,
+        });
+        return legacy;
+    }
+    function twistedEdwards(c) {
+        const { CURVE, curveOpts, hash, eddsaOpts } = _eddsa_legacy_opts_to_new(c);
+        const Point = edwards(CURVE, curveOpts);
+        const EDDSA = eddsa(Point, hash, eddsaOpts);
+        return _eddsa_new_output_to_legacy(c, EDDSA);
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$3 = BigInt(0);
+    const _1n$2 = BigInt(1);
+    const _2n$2 = BigInt(2);
+    function validateOpts(curve) {
+        _validateObject(curve, {
+            adjustScalarBytes: 'function',
+            powPminus2: 'function',
+        });
+        return Object.freeze({ ...curve });
+    }
+    function montgomery(curveDef) {
+        const CURVE = validateOpts(curveDef);
+        const { P, type, adjustScalarBytes, powPminus2, randomBytes: rand } = CURVE;
+        const is25519 = type === 'x25519';
+        if (!is25519 && type !== 'x448')
+            throw new Error('invalid type');
+        const randomBytes_ = rand || randomBytes;
+        const montgomeryBits = is25519 ? 255 : 448;
+        const fieldLen = is25519 ? 32 : 56;
+        const Gu = is25519 ? BigInt(9) : BigInt(5);
+        const a24 = is25519 ? BigInt(121665) : BigInt(39081);
+        const minScalar = is25519 ? _2n$2 ** BigInt(254) : _2n$2 ** BigInt(447);
+        const maxAdded = is25519
+            ? BigInt(8) * _2n$2 ** BigInt(251) - _1n$2
+            : BigInt(4) * _2n$2 ** BigInt(445) - _1n$2;
+        const maxScalar = minScalar + maxAdded + _1n$2;
+        const modP = (n) => mod(n, P);
+        const GuBytes = encodeU(Gu);
+        function encodeU(u) {
+            return numberToBytesLE$1(modP(u), fieldLen);
+        }
+        function decodeU(u) {
+            const _u = ensureBytes('u coordinate', u, fieldLen);
+            if (is25519)
+                _u[31] &= 127;
+            return modP(bytesToNumberLE$1(_u));
+        }
+        function decodeScalar(scalar) {
+            return bytesToNumberLE$1(adjustScalarBytes(ensureBytes('scalar', scalar, fieldLen)));
+        }
+        function scalarMult(scalar, u) {
+            const pu = montgomeryLadder(decodeU(u), decodeScalar(scalar));
+            if (pu === _0n$3)
+                throw new Error('invalid private or public key received');
+            return encodeU(pu);
+        }
+        function scalarMultBase(scalar) {
+            return scalarMult(scalar, GuBytes);
+        }
+        function cswap(swap, x_2, x_3) {
+            const dummy = modP(swap * (x_2 - x_3));
+            x_2 = modP(x_2 - dummy);
+            x_3 = modP(x_3 + dummy);
+            return { x_2, x_3 };
+        }
+        function montgomeryLadder(u, scalar) {
+            aInRange$1('u', u, _0n$3, P);
+            aInRange$1('scalar', scalar, minScalar, maxScalar);
+            const k = scalar;
+            const x_1 = u;
+            let x_2 = _1n$2;
+            let z_2 = _0n$3;
+            let x_3 = u;
+            let z_3 = _1n$2;
+            let swap = _0n$3;
+            for (let t = BigInt(montgomeryBits - 1); t >= _0n$3; t--) {
+                const k_t = (k >> t) & _1n$2;
+                swap ^= k_t;
+                ({ x_2, x_3 } = cswap(swap, x_2, x_3));
+                ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+                swap = k_t;
+                const A = x_2 + z_2;
+                const AA = modP(A * A);
+                const B = x_2 - z_2;
+                const BB = modP(B * B);
+                const E = AA - BB;
+                const C = x_3 + z_3;
+                const D = x_3 - z_3;
+                const DA = modP(D * A);
+                const CB = modP(C * B);
+                const dacb = DA + CB;
+                const da_cb = DA - CB;
+                x_3 = modP(dacb * dacb);
+                z_3 = modP(x_1 * modP(da_cb * da_cb));
+                x_2 = modP(AA * BB);
+                z_2 = modP(E * (AA + modP(a24 * E)));
+            }
+            ({ x_2, x_3 } = cswap(swap, x_2, x_3));
+            ({ x_2: z_2, x_3: z_3 } = cswap(swap, z_2, z_3));
+            const z2 = powPminus2(z_2);
+            return modP(x_2 * z2);
+        }
+        const lengths = {
+            secretKey: fieldLen,
+            publicKey: fieldLen,
+            seed: fieldLen,
+        };
+        const randomSecretKey = (seed = randomBytes_(fieldLen)) => {
+            abytes$1(seed, lengths.seed);
+            return seed;
+        };
+        function keygen(seed) {
+            const secretKey = randomSecretKey(seed);
+            return { secretKey, publicKey: scalarMultBase(secretKey) };
+        }
+        const utils = {
+            randomSecretKey,
+            randomPrivateKey: randomSecretKey,
+        };
+        return {
+            keygen,
+            getSharedSecret: (secretKey, publicKey) => scalarMult(secretKey, publicKey),
+            getPublicKey: (secretKey) => scalarMultBase(secretKey),
+            scalarMult,
+            scalarMultBase,
+            utils,
+            GuBytes: GuBytes.slice(),
+            lengths,
+        };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$2 =  BigInt(0), _1n$1 = BigInt(1), _2n$1 = BigInt(2), _3n$1 = BigInt(3);
+    const _5n = BigInt(5), _8n = BigInt(8);
+    const ed25519_CURVE_p = BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed');
+    const ed25519_CURVE =  (() => ({
+        p: ed25519_CURVE_p,
+        n: BigInt('0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed'),
+        h: _8n,
+        a: BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec'),
+        d: BigInt('0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3'),
+        Gx: BigInt('0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a'),
+        Gy: BigInt('0x6666666666666666666666666666666666666666666666666666666666666658'),
+    }))();
+    function ed25519_pow_2_252_3(x) {
+        const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+        const P = ed25519_CURVE_p;
+        const x2 = (x * x) % P;
+        const b2 = (x2 * x) % P;
+        const b4 = (pow2(b2, _2n$1, P) * b2) % P;
+        const b5 = (pow2(b4, _1n$1, P) * x) % P;
+        const b10 = (pow2(b5, _5n, P) * b5) % P;
+        const b20 = (pow2(b10, _10n, P) * b10) % P;
+        const b40 = (pow2(b20, _20n, P) * b20) % P;
+        const b80 = (pow2(b40, _40n, P) * b40) % P;
+        const b160 = (pow2(b80, _80n, P) * b80) % P;
+        const b240 = (pow2(b160, _80n, P) * b80) % P;
+        const b250 = (pow2(b240, _10n, P) * b10) % P;
+        const pow_p_5_8 = (pow2(b250, _2n$1, P) * x) % P;
+        return { pow_p_5_8, b2 };
+    }
+    function adjustScalarBytes(bytes) {
+        bytes[0] &= 248;
+        bytes[31] &= 127;
+        bytes[31] |= 64;
+        return bytes;
+    }
+    const ED25519_SQRT_M1 =  BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
+    function uvRatio(u, v) {
+        const P = ed25519_CURVE_p;
+        const v3 = mod(v * v * v, P);
+        const v7 = mod(v3 * v3 * v, P);
+        const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+        let x = mod(u * v3 * pow, P);
+        const vx2 = mod(v * x * x, P);
+        const root1 = x;
+        const root2 = mod(x * ED25519_SQRT_M1, P);
+        const useRoot1 = vx2 === u;
+        const useRoot2 = vx2 === mod(-u, P);
+        const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
+        if (useRoot1)
+            x = root1;
+        if (useRoot2 || noRoot)
+            x = root2;
+        if (isNegativeLE(x, P))
+            x = mod(-x, P);
+        return { isValid: useRoot1 || useRoot2, value: x };
+    }
+    const Fp =  (() => Field(ed25519_CURVE.p, { isLE: true }))();
+    const Fn =  (() => Field(ed25519_CURVE.n, { isLE: true }))();
+    const ed25519Defaults =  (() => ({
+        ...ed25519_CURVE,
+        Fp,
+        hash: sha512$1,
+        adjustScalarBytes,
+        uvRatio,
+    }))();
+    const ed25519 =  (() => twistedEdwards(ed25519Defaults))();
+    function ed25519_domain(data, ctx, phflag) {
+        if (ctx.length > 255)
+            throw new Error('Context is too big');
+        return concatBytes(utf8ToBytes('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
+    }
+    (() => twistedEdwards({
+        ...ed25519Defaults,
+        domain: ed25519_domain,
+    }))();
+    (() => twistedEdwards(Object.assign({}, ed25519Defaults, {
+        domain: ed25519_domain,
+        prehash: sha512$1,
+    })))();
+    (() => {
+        const P = Fp.ORDER;
+        return montgomery({
+            P,
+            type: 'x25519',
+            powPminus2: (x) => {
+                const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
+                return mod(pow2(pow_p_5_8, _3n$1, P) * b2, P);
+            },
+            adjustScalarBytes,
+        });
+    })();
+    const ELL2_C1 =  (() => (ed25519_CURVE_p + _3n$1) / _8n)();
+    const ELL2_C2 =  (() => Fp.pow(_2n$1, ELL2_C1))();
+    const ELL2_C3 =  (() => Fp.sqrt(Fp.neg(Fp.ONE)))();
+    function map_to_curve_elligator2_curve25519(u) {
+        const ELL2_C4 = (ed25519_CURVE_p - _5n) / _8n;
+        const ELL2_J = BigInt(486662);
+        let tv1 = Fp.sqr(u);
+        tv1 = Fp.mul(tv1, _2n$1);
+        let xd = Fp.add(tv1, Fp.ONE);
+        let x1n = Fp.neg(ELL2_J);
+        let tv2 = Fp.sqr(xd);
+        let gxd = Fp.mul(tv2, xd);
+        let gx1 = Fp.mul(tv1, ELL2_J);
+        gx1 = Fp.mul(gx1, x1n);
+        gx1 = Fp.add(gx1, tv2);
+        gx1 = Fp.mul(gx1, x1n);
+        let tv3 = Fp.sqr(gxd);
+        tv2 = Fp.sqr(tv3);
+        tv3 = Fp.mul(tv3, gxd);
+        tv3 = Fp.mul(tv3, gx1);
+        tv2 = Fp.mul(tv2, tv3);
+        let y11 = Fp.pow(tv2, ELL2_C4);
+        y11 = Fp.mul(y11, tv3);
+        let y12 = Fp.mul(y11, ELL2_C3);
+        tv2 = Fp.sqr(y11);
+        tv2 = Fp.mul(tv2, gxd);
+        let e1 = Fp.eql(tv2, gx1);
+        let y1 = Fp.cmov(y12, y11, e1);
+        let x2n = Fp.mul(x1n, tv1);
+        let y21 = Fp.mul(y11, u);
+        y21 = Fp.mul(y21, ELL2_C2);
+        let y22 = Fp.mul(y21, ELL2_C3);
+        let gx2 = Fp.mul(gx1, tv1);
+        tv2 = Fp.sqr(y21);
+        tv2 = Fp.mul(tv2, gxd);
+        let e2 = Fp.eql(tv2, gx2);
+        let y2 = Fp.cmov(y22, y21, e2);
+        tv2 = Fp.sqr(y1);
+        tv2 = Fp.mul(tv2, gxd);
+        let e3 = Fp.eql(tv2, gx1);
+        let xn = Fp.cmov(x2n, x1n, e3);
+        let y = Fp.cmov(y2, y1, e3);
+        let e4 = Fp.isOdd(y);
+        y = Fp.cmov(y, Fp.neg(y), e3 !== e4);
+        return { xMn: xn, xMd: xd, yMn: y, yMd: _1n$1 };
+    }
+    const ELL2_C1_EDWARDS =  (() => FpSqrtEven(Fp, Fp.neg(BigInt(486664))))();
+    function map_to_curve_elligator2_edwards25519(u) {
+        const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u);
+        let xn = Fp.mul(xMn, yMd);
+        xn = Fp.mul(xn, ELL2_C1_EDWARDS);
+        let xd = Fp.mul(xMd, yMn);
+        let yn = Fp.sub(xMn, xMd);
+        let yd = Fp.add(xMn, xMd);
+        let tv1 = Fp.mul(xd, yd);
+        let e = Fp.eql(tv1, Fp.ZERO);
+        xn = Fp.cmov(xn, Fp.ZERO, e);
+        xd = Fp.cmov(xd, Fp.ONE, e);
+        yn = Fp.cmov(yn, Fp.ONE, e);
+        yd = Fp.cmov(yd, Fp.ONE, e);
+        const [xd_inv, yd_inv] = FpInvertBatch(Fp, [xd, yd], true);
+        return { x: Fp.mul(xn, xd_inv), y: Fp.mul(yn, yd_inv) };
+    }
+    (() => createHasher(ed25519.Point, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {
+        DST: 'edwards25519_XMD:SHA-512_ELL2_RO_',
+        encodeDST: 'edwards25519_XMD:SHA-512_ELL2_NU_',
+        p: ed25519_CURVE_p,
+        m: 1,
+        k: 128,
+        expand: 'xmd',
+        hash: sha512$1,
+    }))();
+    const SQRT_M1 = ED25519_SQRT_M1;
+    const SQRT_AD_MINUS_ONE =  BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');
+    const INVSQRT_A_MINUS_D =  BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');
+    const ONE_MINUS_D_SQ =  BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');
+    const D_MINUS_ONE_SQ =  BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');
+    const invertSqrt = (number) => uvRatio(_1n$1, number);
+    const MAX_255B =  BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+    const bytes255ToNumberLE = (bytes) => ed25519.Point.Fp.create(bytesToNumberLE$1(bytes) & MAX_255B);
+    function calcElligatorRistrettoMap(r0) {
+        const { d } = ed25519_CURVE;
+        const P = ed25519_CURVE_p;
+        const mod = (n) => Fp.create(n);
+        const r = mod(SQRT_M1 * r0 * r0);
+        const Ns = mod((r + _1n$1) * ONE_MINUS_D_SQ);
+        let c = BigInt(-1);
+        const D = mod((c - d * r) * mod(r + d));
+        let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
+        let s_ = mod(s * r0);
+        if (!isNegativeLE(s_, P))
+            s_ = mod(-s_);
+        if (!Ns_D_is_sq)
+            s = s_;
+        if (!Ns_D_is_sq)
+            c = r;
+        const Nt = mod(c * (r - _1n$1) * D_MINUS_ONE_SQ - D);
+        const s2 = s * s;
+        const W0 = mod((s + s) * D);
+        const W1 = mod(Nt * SQRT_AD_MINUS_ONE);
+        const W2 = mod(_1n$1 - s2);
+        const W3 = mod(_1n$1 + s2);
+        return new ed25519.Point(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
+    }
+    function ristretto255_map(bytes) {
+        abytes$1(bytes, 64);
+        const r1 = bytes255ToNumberLE(bytes.subarray(0, 32));
+        const R1 = calcElligatorRistrettoMap(r1);
+        const r2 = bytes255ToNumberLE(bytes.subarray(32, 64));
+        const R2 = calcElligatorRistrettoMap(r2);
+        return new _RistrettoPoint(R1.add(R2));
+    }
+    class _RistrettoPoint extends PrimeEdwardsPoint {
+        constructor(ep) {
+            super(ep);
+        }
+        static fromAffine(ap) {
+            return new _RistrettoPoint(ed25519.Point.fromAffine(ap));
+        }
+        assertSame(other) {
+            if (!(other instanceof _RistrettoPoint))
+                throw new Error('RistrettoPoint expected');
+        }
+        init(ep) {
+            return new _RistrettoPoint(ep);
+        }
+        static hashToCurve(hex) {
+            return ristretto255_map(ensureBytes('ristrettoHash', hex, 64));
+        }
+        static fromBytes(bytes) {
+            abytes$1(bytes, 32);
+            const { a, d } = ed25519_CURVE;
+            const P = ed25519_CURVE_p;
+            const mod = (n) => Fp.create(n);
+            const s = bytes255ToNumberLE(bytes);
+            if (!equalBytes(Fp.toBytes(s), bytes) || isNegativeLE(s, P))
+                throw new Error('invalid ristretto255 encoding 1');
+            const s2 = mod(s * s);
+            const u1 = mod(_1n$1 + a * s2);
+            const u2 = mod(_1n$1 - a * s2);
+            const u1_2 = mod(u1 * u1);
+            const u2_2 = mod(u2 * u2);
+            const v = mod(a * d * u1_2 - u2_2);
+            const { isValid, value: I } = invertSqrt(mod(v * u2_2));
+            const Dx = mod(I * u2);
+            const Dy = mod(I * Dx * v);
+            let x = mod((s + s) * Dx);
+            if (isNegativeLE(x, P))
+                x = mod(-x);
+            const y = mod(u1 * Dy);
+            const t = mod(x * y);
+            if (!isValid || isNegativeLE(t, P) || y === _0n$2)
+                throw new Error('invalid ristretto255 encoding 2');
+            return new _RistrettoPoint(new ed25519.Point(x, y, _1n$1, t));
+        }
+        static fromHex(hex) {
+            return _RistrettoPoint.fromBytes(ensureBytes('ristrettoHex', hex, 32));
+        }
+        static msm(points, scalars) {
+            return pippenger(_RistrettoPoint, ed25519.Point.Fn, points, scalars);
+        }
+        toBytes() {
+            let { X, Y, Z, T } = this.ep;
+            const P = ed25519_CURVE_p;
+            const mod = (n) => Fp.create(n);
+            const u1 = mod(mod(Z + Y) * mod(Z - Y));
+            const u2 = mod(X * Y);
+            const u2sq = mod(u2 * u2);
+            const { value: invsqrt } = invertSqrt(mod(u1 * u2sq));
+            const D1 = mod(invsqrt * u1);
+            const D2 = mod(invsqrt * u2);
+            const zInv = mod(D1 * D2 * T);
+            let D;
+            if (isNegativeLE(T * zInv, P)) {
+                let _x = mod(Y * SQRT_M1);
+                let _y = mod(X * SQRT_M1);
+                X = _x;
+                Y = _y;
+                D = mod(D1 * INVSQRT_A_MINUS_D);
+            }
+            else {
+                D = D2;
+            }
+            if (isNegativeLE(X * zInv, P))
+                Y = mod(-Y);
+            let s = mod((Z - Y) * D);
+            if (isNegativeLE(s, P))
+                s = mod(-s);
+            return Fp.toBytes(s);
+        }
+        equals(other) {
+            this.assertSame(other);
+            const { X: X1, Y: Y1 } = this.ep;
+            const { X: X2, Y: Y2 } = other.ep;
+            const mod = (n) => Fp.create(n);
+            const one = mod(X1 * Y2) === mod(Y1 * X2);
+            const two = mod(Y1 * Y2) === mod(X1 * X2);
+            return one || two;
+        }
+        is0() {
+            return this.equals(_RistrettoPoint.ZERO);
+        }
+    }
+    _RistrettoPoint.BASE =
+     (() => new _RistrettoPoint(ed25519.Point.BASE))();
+    _RistrettoPoint.ZERO =
+     (() => new _RistrettoPoint(ed25519.Point.ZERO))();
+    _RistrettoPoint.Fp =
+     (() => Fp)();
+    _RistrettoPoint.Fn =
+     (() => Fn)();
+    const RistrettoPoint = _RistrettoPoint;
+
+    function ed25519PairFromSeed(seed, onlyJs) {
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            const full = ed25519KeypairFromSeed(seed);
+            return {
+                publicKey: full.slice(32),
+                secretKey: full.slice(0, 64)
+            };
+        }
+        const publicKey = ed25519.getPublicKey(seed);
+        return {
+            publicKey,
+            secretKey: util.u8aConcatStrict([seed, publicKey])
+        };
+    }
+
+    function ed25519PairFromRandom() {
+        return ed25519PairFromSeed(randomAsU8a());
+    }
+
+    function ed25519PairFromSecret(secretKey) {
+        if (secretKey.length !== 64) {
+            throw new Error('Invalid secretKey provided');
+        }
+        return {
+            publicKey: secretKey.slice(32),
+            secretKey
+        };
+    }
+
+    function ed25519PairFromString(value) {
+        return ed25519PairFromSeed(blake2AsU8a(util.stringToU8a(value)));
+    }
+
+    function ed25519Sign(message, { publicKey, secretKey }, onlyJs) {
+        if (!secretKey) {
+            throw new Error('Expected a valid secretKey');
+        }
+        else if (!publicKey) {
+            throw new Error('Expected a valid publicKey');
+        }
+        const messageU8a = util.u8aToU8a(message);
+        const privateU8a = secretKey.subarray(0, 32);
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? ed25519Sign$1(publicKey, privateU8a, messageU8a)
+            : ed25519.sign(messageU8a, privateU8a);
+    }
+
+    function ed25519Verify(message, signature, publicKey, onlyJs) {
+        const messageU8a = util.u8aToU8a(message);
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        const signatureU8a = util.u8aToU8a(signature);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+        }
+        else if (signatureU8a.length !== 64) {
+            throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+        }
+        try {
+            return !util.hasBigInt || (!onlyJs && isReady())
+                ? ed25519Verify$1(signatureU8a, messageU8a, publicKeyU8a)
+                : ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+        }
+        catch {
+            return false;
+        }
+    }
+
+    const keyHdkdEd25519 =  createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);
+
+    const isBytes = isBytes$1;
+    const bytesToNumberLE = bytesToNumberLE$1;
+    const numberToBytesLE = numberToBytesLE$1;
+    const aInRange = aInRange$1;
+    const bitMask = bitMask$1;
+
+    const _0n$1 = BigInt(0);
+    const _1n = BigInt(1);
+    const _2n = BigInt(2);
+    const _7n$1 = BigInt(7);
+    const _256n$1 = BigInt(256);
+    const _0x71n = BigInt(0x71);
+    const SHA3_PI = [];
+    const SHA3_ROTL = [];
+    const _SHA3_IOTA = [];
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+        [x, y] = [y, (2 * x + 3 * y) % 5];
+        SHA3_PI.push(2 * (5 * y + x));
+        SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+        let t = _0n$1;
+        for (let j = 0; j < 7; j++) {
+            R = ((R << _1n) ^ ((R >> _7n$1) * _0x71n)) % _256n$1;
+            if (R & _2n)
+                t ^= _1n << ((_1n <<  BigInt(j)) - _1n);
+        }
+        _SHA3_IOTA.push(t);
+    }
+    const IOTAS = split(_SHA3_IOTA, true);
+    const SHA3_IOTA_H = IOTAS[0];
+    const SHA3_IOTA_L = IOTAS[1];
+    const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
+    const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
+    function keccakP(s, rounds = 24) {
+        const B = new Uint32Array(5 * 2);
+        for (let round = 24 - rounds; round < 24; round++) {
+            for (let x = 0; x < 10; x++)
+                B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+            for (let x = 0; x < 10; x += 2) {
+                const idx1 = (x + 8) % 10;
+                const idx0 = (x + 2) % 10;
+                const B0 = B[idx0];
+                const B1 = B[idx0 + 1];
+                const Th = rotlH(B0, B1, 1) ^ B[idx1];
+                const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+                for (let y = 0; y < 50; y += 10) {
+                    s[x + y] ^= Th;
+                    s[x + y + 1] ^= Tl;
+                }
+            }
+            let curH = s[2];
+            let curL = s[3];
+            for (let t = 0; t < 24; t++) {
+                const shift = SHA3_ROTL[t];
+                const Th = rotlH(curH, curL, shift);
+                const Tl = rotlL(curH, curL, shift);
+                const PI = SHA3_PI[t];
+                curH = s[PI];
+                curL = s[PI + 1];
+                s[PI] = Th;
+                s[PI + 1] = Tl;
+            }
+            for (let y = 0; y < 50; y += 10) {
+                for (let x = 0; x < 10; x++)
+                    B[x] = s[y + x];
+                for (let x = 0; x < 10; x++)
+                    s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+            }
+            s[0] ^= SHA3_IOTA_H[round];
+            s[1] ^= SHA3_IOTA_L[round];
+        }
+        clean(B);
+    }
+    class Keccak extends Hash {
+        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+            super();
+            this.pos = 0;
+            this.posOut = 0;
+            this.finished = false;
+            this.destroyed = false;
+            this.enableXOF = false;
+            this.blockLen = blockLen;
+            this.suffix = suffix;
+            this.outputLen = outputLen;
+            this.enableXOF = enableXOF;
+            this.rounds = rounds;
+            anumber(outputLen);
+            if (!(0 < blockLen && blockLen < 200))
+                throw new Error('only keccak-f1600 function is supported');
+            this.state = new Uint8Array(200);
+            this.state32 = u32(this.state);
+        }
+        clone() {
+            return this._cloneInto();
+        }
+        keccak() {
+            swap32IfBE(this.state32);
+            keccakP(this.state32, this.rounds);
+            swap32IfBE(this.state32);
+            this.posOut = 0;
+            this.pos = 0;
+        }
+        update(data) {
+            aexists(this);
+            data = toBytes(data);
+            abytes$1(data);
+            const { blockLen, state } = this;
+            const len = data.length;
+            for (let pos = 0; pos < len;) {
+                const take = Math.min(blockLen - this.pos, len - pos);
+                for (let i = 0; i < take; i++)
+                    state[this.pos++] ^= data[pos++];
+                if (this.pos === blockLen)
+                    this.keccak();
+            }
+            return this;
+        }
+        finish() {
+            if (this.finished)
+                return;
+            this.finished = true;
+            const { state, suffix, pos, blockLen } = this;
+            state[pos] ^= suffix;
+            if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+                this.keccak();
+            state[blockLen - 1] ^= 0x80;
+            this.keccak();
+        }
+        writeInto(out) {
+            aexists(this, false);
+            abytes$1(out);
+            this.finish();
+            const bufferOut = this.state;
+            const { blockLen } = this;
+            for (let pos = 0, len = out.length; pos < len;) {
+                if (this.posOut >= blockLen)
+                    this.keccak();
+                const take = Math.min(blockLen - this.posOut, len - pos);
+                out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+                this.posOut += take;
+                pos += take;
+            }
+            return out;
+        }
+        xofInto(out) {
+            if (!this.enableXOF)
+                throw new Error('XOF is not possible for this instance');
+            return this.writeInto(out);
+        }
+        xof(bytes) {
+            anumber(bytes);
+            return this.xofInto(new Uint8Array(bytes));
+        }
+        digestInto(out) {
+            aoutput(out, this);
+            if (this.finished)
+                throw new Error('digest() was already called');
+            this.writeInto(out);
+            this.destroy();
+            return out;
+        }
+        digest() {
+            return this.digestInto(new Uint8Array(this.outputLen));
+        }
+        destroy() {
+            this.destroyed = true;
+            clean(this.state);
+        }
+        _cloneInto(to) {
+            const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+            to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+            to.state32.set(this.state32);
+            to.pos = this.pos;
+            to.posOut = this.posOut;
+            to.finished = this.finished;
+            to.rounds = rounds;
+            to.suffix = suffix;
+            to.outputLen = outputLen;
+            to.enableXOF = enableXOF;
+            to.destroyed = this.destroyed;
+            return to;
+        }
+    }
+    const gen = (suffix, blockLen, outputLen) => createHasher$1(() => new Keccak(blockLen, suffix, outputLen));
+    (() => gen(0x06, 144, 224 / 8))();
+    (() => gen(0x06, 136, 256 / 8))();
+    (() => gen(0x06, 104, 384 / 8))();
+    (() => gen(0x06, 72, 512 / 8))();
+    (() => gen(0x01, 144, 224 / 8))();
+    const keccak_256 =  (() => gen(0x01, 136, 256 / 8))();
+    (() => gen(0x01, 104, 384 / 8))();
+    const keccak_512 =  (() => gen(0x01, 72, 512 / 8))();
+    const genShake = (suffix, blockLen, outputLen) => createXOFer((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));
+    (() => genShake(0x1f, 168, 128 / 8))();
+    (() => genShake(0x1f, 136, 256 / 8))();
+
+    const sha512 = sha512$1;
+
+    const _0n = BigInt(0), _3n = BigInt(3);
+    function toData(d) {
+        if (typeof d === 'string')
+            return utf8ToBytes(d);
+        if (isBytes(d))
+            return d;
+        throw new Error('Wrong data');
+    }
+    function abytes(title, b, ...lengths) {
+        if (!isBytes(b))
+            throw new Error(`${title}: Uint8Array expected`);
+        if (lengths.length && !lengths.includes(b.length))
+            throw new Error(`${title}: Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+    }
+    function checkU32(title, n) {
+        if (!Number.isSafeInteger(n) || n < 0 || n > 4294967295)
+            throw new Error(`${title}: wrong u32 integer: ${n}`);
+        return n;
+    }
+    function cleanBytes(...list) {
+        for (const t of list)
+            t.fill(0);
+    }
+    const EMPTY = Uint8Array.of();
+    const CURVE_ORDER = ed25519.CURVE.n;
+    function parseScalar(title, bytes) {
+        abytes(title, bytes, 32);
+        const n = bytesToNumberLE(bytes);
+        aInRange(title, n, _0n, CURVE_ORDER);
+        return n;
+    }
+    const modN = (n) => mod(n, CURVE_ORDER);
+    const STROBE_R = 166;
+    const Flags = {
+        I: 1,
+        A: 1 << 1,
+        C: 1 << 2,
+        T: 1 << 3,
+        M: 1 << 4,
+        K: 1 << 5,
+    };
+    class Strobe128 {
+        constructor(protocolLabel) {
+            this.state = new Uint8Array(200);
+            this.pos = 0;
+            this.posBegin = 0;
+            this.curFlags = 0;
+            this.state.set([1, STROBE_R + 2, 1, 0, 1, 96], 0);
+            this.state.set(utf8ToBytes('STROBEv1.0.2'), 6);
+            this.state32 = u32(this.state);
+            this.keccakF1600();
+            this.metaAD(protocolLabel, false);
+        }
+        keccakF1600() {
+            keccakP(this.state32);
+        }
+        runF() {
+            this.state[this.pos] ^= this.posBegin;
+            this.state[this.pos + 1] ^= 0x04;
+            this.state[STROBE_R + 1] ^= 0x80;
+            this.keccakF1600();
+            this.pos = 0;
+            this.posBegin = 0;
+        }
+        absorb(data) {
+            for (let i = 0; i < data.length; i++) {
+                this.state[this.pos++] ^= data[i];
+                if (this.pos === STROBE_R)
+                    this.runF();
+            }
+        }
+        squeeze(len) {
+            const data = new Uint8Array(len);
+            for (let i = 0; i < data.length; i++) {
+                data[i] = this.state[this.pos];
+                this.state[this.pos++] = 0;
+                if (this.pos === STROBE_R)
+                    this.runF();
+            }
+            return data;
+        }
+        overwrite(data) {
+            for (let i = 0; i < data.length; i++) {
+                this.state[this.pos++] = data[i];
+                if (this.pos === STROBE_R)
+                    this.runF();
+            }
+        }
+        beginOp(flags, more) {
+            if (more) {
+                if (this.curFlags !== flags) {
+                    throw new Error(`Continued op with changed flags from ${this.curFlags.toString(2)} to ${flags.toString(2)}`);
+                }
+                return;
+            }
+            if ((flags & Flags.T) !== 0)
+                throw new Error('T flag is not supported');
+            const oldBegin = this.posBegin;
+            this.posBegin = this.pos + 1;
+            this.curFlags = flags;
+            this.absorb(new Uint8Array([oldBegin, flags]));
+            const forceF = (flags & (Flags.C | Flags.K)) !== 0;
+            if (forceF && this.pos !== 0)
+                this.runF();
+        }
+        metaAD(data, more) {
+            this.beginOp(Flags.M | Flags.A, more);
+            this.absorb(toData(data));
+        }
+        AD(data, more) {
+            this.beginOp(Flags.A, more);
+            this.absorb(toData(data));
+        }
+        PRF(len, more) {
+            this.beginOp(Flags.I | Flags.A | Flags.C, more);
+            return this.squeeze(len);
+        }
+        KEY(data, more) {
+            this.beginOp(Flags.A | Flags.C, more);
+            this.overwrite(toData(data));
+        }
+        clone() {
+            const n = new Strobe128('0');
+            n.pos = this.pos;
+            n.posBegin = this.posBegin;
+            n.state.set(this.state);
+            n.curFlags = this.curFlags;
+            return n;
+        }
+        clean() {
+            this.state.fill(0);
+            this.pos = 0;
+            this.curFlags = 0;
+            this.posBegin = 0;
+        }
+    }
+    class Merlin {
+        constructor(label) {
+            this.strobe = new Strobe128('Merlin v1.0');
+            this.appendMessage('dom-sep', label);
+        }
+        appendMessage(label, message) {
+            this.strobe.metaAD(label, false);
+            checkU32('Merlin.appendMessage', message.length);
+            this.strobe.metaAD(numberToBytesLE(message.length, 4), true);
+            this.strobe.AD(message, false);
+        }
+        challengeBytes(label, len) {
+            this.strobe.metaAD(label, false);
+            checkU32('Merlin.challengeBytes', len);
+            this.strobe.metaAD(numberToBytesLE(len, 4), true);
+            return this.strobe.PRF(len, false);
+        }
+        clean() {
+            this.strobe.clean();
+        }
+    }
+    class SigningContext extends Merlin {
+        constructor(name, rng = randomBytes) {
+            super(name);
+            this.rng = rng;
+        }
+        label(label) {
+            this.appendMessage('', label);
+        }
+        bytes(bytes) {
+            this.appendMessage('sign-bytes', bytes);
+            return this;
+        }
+        protoName(label) {
+            this.appendMessage('proto-name', label);
+        }
+        commitPoint(label, point) {
+            this.appendMessage(label, point.toRawBytes());
+        }
+        challengeScalar(label) {
+            return modN(bytesToNumberLE(this.challengeBytes(label, 64)));
+        }
+        witnessScalar(label, nonceSeeds = []) {
+            return modN(bytesToNumberLE(this.witnessBytes(label, 64, nonceSeeds)));
+        }
+        witnessBytes(label, len, nonceSeeds = []) {
+            checkU32('SigningContext.witnessBytes', len);
+            const strobeRng = this.strobe.clone();
+            for (const ns of nonceSeeds) {
+                strobeRng.metaAD(label, false);
+                checkU32('SigningContext.witnessBytes nonce length', ns.length);
+                strobeRng.metaAD(numberToBytesLE(ns.length, 4), true);
+                strobeRng.KEY(ns, false);
+            }
+            const random = this.rng(32);
+            strobeRng.metaAD('rng', false);
+            strobeRng.KEY(random, false);
+            strobeRng.metaAD(numberToBytesLE(len, 4), false);
+            return strobeRng.PRF(len, false);
+        }
+    }
+    const MASK = bitMask(256);
+    const encodeScalar = (n) => numberToBytesLE((n << _3n) & MASK, 32);
+    const decodeScalar = (n) => bytesToNumberLE(n) >> _3n;
+    function getPublicKey(secretKey) {
+        abytes('secretKey', secretKey, 64);
+        const scalar = decodeScalar(secretKey.subarray(0, 32));
+        return RistrettoPoint.BASE.multiply(scalar).toRawBytes();
+    }
+    function secretFromSeed(seed) {
+        abytes('seed', seed, 32);
+        const r = sha512(seed);
+        r[0] &= 248;
+        r[31] &= 63;
+        r[31] |= 64;
+        const key = encodeScalar(decodeScalar(r.subarray(0, 32)));
+        const nonce = r.subarray(32, 64);
+        const res = concatBytes(key, nonce);
+        cleanBytes(key, nonce, r);
+        return res;
+    }
+    const BIZINIKIWI_CONTEXT = utf8ToBytes('bizinikiwi');
+    function sign(secretKey, message, rng = randomBytes) {
+        abytes('message', message);
+        abytes('secretKey', secretKey, 64);
+        const t = new SigningContext('SigningContext', rng);
+        t.label(BIZINIKIWI_CONTEXT);
+        t.bytes(message);
+        const keyScalar = decodeScalar(secretKey.subarray(0, 32));
+        const nonce = secretKey.subarray(32, 64);
+        const pubPoint = RistrettoPoint.fromHex(getPublicKey(secretKey));
+        t.protoName('Schnorr-sig');
+        t.commitPoint('sign:pk', pubPoint);
+        const r = t.witnessScalar('signing', [nonce]);
+        const R = RistrettoPoint.BASE.multiply(r);
+        t.commitPoint('sign:R', R);
+        const k = t.challengeScalar('sign:c');
+        const s = modN(k * keyScalar + r);
+        const res = concatBytes(R.toRawBytes(), numberToBytesLE(s, 32));
+        res[63] |= 128;
+        t.clean();
+        return res;
+    }
+    function verify(message, signature, publicKey) {
+        abytes('message', message);
+        abytes('signature', signature, 64);
+        abytes('publicKey', publicKey, 32);
+        if ((signature[63] & 128) === 0)
+            throw new Error('Schnorrkel marker missing');
+        const sBytes = Uint8Array.from(signature.subarray(32, 64));
+        sBytes[31] &= 127;
+        const R = RistrettoPoint.fromHex(signature.subarray(0, 32));
+        const s = bytesToNumberLE(sBytes);
+        aInRange('s', s, _0n, CURVE_ORDER);
+        const t = new SigningContext('SigningContext');
+        t.label(BIZINIKIWI_CONTEXT);
+        t.bytes(message);
+        const pubPoint = RistrettoPoint.fromHex(publicKey);
+        if (pubPoint.equals(RistrettoPoint.ZERO))
+            return false;
+        t.protoName('Schnorr-sig');
+        t.commitPoint('sign:pk', pubPoint);
+        t.commitPoint('sign:R', R);
+        const k = t.challengeScalar('sign:c');
+        const sP = RistrettoPoint.BASE.multiply(s);
+        const RR = pubPoint.negate().multiply(k).add(sP);
+        t.clean();
+        cleanBytes(sBytes);
+        return RR.equals(R);
+    }
+    function getSharedSecret(secretKey, publicKey) {
+        abytes('secretKey', secretKey, 64);
+        abytes('publicKey', publicKey, 32);
+        const keyScalar = decodeScalar(secretKey.subarray(0, 32));
+        const pubPoint = RistrettoPoint.fromHex(publicKey);
+        if (pubPoint.equals(RistrettoPoint.ZERO))
+            throw new Error('wrong public key (infinity)');
+        return pubPoint.multiply(keyScalar).toRawBytes();
+    }
+    const HDKD = {
+        secretSoft(secretKey, chainCode, rng = randomBytes) {
+            abytes('secretKey', secretKey, 64);
+            abytes('chainCode', chainCode, 32);
+            const masterScalar = decodeScalar(secretKey.subarray(0, 32));
+            const masterNonce = secretKey.subarray(32, 64);
+            const pubPoint = RistrettoPoint.fromHex(getPublicKey(secretKey));
+            const t = new SigningContext('SchnorrRistrettoHDKD', rng);
+            t.bytes(EMPTY);
+            t.appendMessage('chain-code', chainCode);
+            t.commitPoint('public-key', pubPoint);
+            const scalar = t.challengeScalar('HDKD-scalar');
+            const hdkdChainCode = t.challengeBytes('HDKD-chaincode', 32);
+            const nonceSeed = concatBytes(numberToBytesLE(masterScalar, 32), masterNonce);
+            const nonce = t.witnessBytes('HDKD-nonce', 32, [masterNonce, nonceSeed]);
+            const key = encodeScalar(modN(masterScalar + scalar));
+            const res = concatBytes(key, nonce);
+            cleanBytes(key, nonce, nonceSeed, hdkdChainCode);
+            t.clean();
+            return res;
+        },
+        publicSoft(publicKey, chainCode) {
+            abytes('publicKey', publicKey, 32);
+            abytes('chainCode', chainCode, 32);
+            const pubPoint = RistrettoPoint.fromHex(publicKey);
+            const t = new SigningContext('SchnorrRistrettoHDKD');
+            t.bytes(EMPTY);
+            t.appendMessage('chain-code', chainCode);
+            t.commitPoint('public-key', pubPoint);
+            const scalar = t.challengeScalar('HDKD-scalar');
+            t.challengeBytes('HDKD-chaincode', 32);
+            t.clean();
+            return pubPoint.add(RistrettoPoint.BASE.multiply(scalar)).toRawBytes();
+        },
+        secretHard(secretKey, chainCode) {
+            abytes('secretKey', secretKey, 64);
+            abytes('chainCode', chainCode, 32);
+            const key = numberToBytesLE(decodeScalar(secretKey.subarray(0, 32)), 32);
+            const t = new SigningContext('SchnorrRistrettoHDKD');
+            t.bytes(EMPTY);
+            t.appendMessage('chain-code', chainCode);
+            t.appendMessage('secret-key', key);
+            const msk = t.challengeBytes('HDKD-hard', 32);
+            const hdkdChainCode = t.challengeBytes('HDKD-chaincode', 32);
+            t.clean();
+            const res = secretFromSeed(msk);
+            cleanBytes(key, msk, hdkdChainCode);
+            t.clean();
+            return res;
+        },
+    };
+    const dleq = {
+        proove(keyScalar, nonce, pubPoint, t, input, output) {
+            t.protoName('DLEQProof');
+            t.commitPoint('vrf:h', input);
+            const r = t.witnessScalar(`proving${'\0'}0`, [nonce]);
+            const R = RistrettoPoint.BASE.multiply(r);
+            t.commitPoint('vrf:R=g^r', R);
+            const Hr = input.multiply(r);
+            t.commitPoint('vrf:h^r', Hr);
+            t.commitPoint('vrf:pk', pubPoint);
+            t.commitPoint('vrf:h^sk', output);
+            const c = t.challengeScalar('prove');
+            const s = modN(r - c * keyScalar);
+            return { proof: { c, s }, proofBatchable: { R, Hr, s } };
+        },
+        verify(pubPoint, t, input, output, proof) {
+            if (pubPoint.equals(RistrettoPoint.ZERO))
+                return false;
+            t.protoName('DLEQProof');
+            t.commitPoint('vrf:h', input);
+            const R = pubPoint.multiply(proof.c).add(RistrettoPoint.BASE.multiply(proof.s));
+            t.commitPoint('vrf:R=g^r', R);
+            const Hr = output.multiply(proof.c).add(input.multiply(proof.s));
+            t.commitPoint('vrf:h^r', Hr);
+            t.commitPoint('vrf:pk', pubPoint);
+            t.commitPoint('vrf:h^sk', output);
+            const realC = t.challengeScalar('prove');
+            if (proof.c === realC)
+                return { R, Hr, s: proof.s };
+            return false;
+        },
+    };
+    function initVRF(ctx, msg, extra, pubPoint, rng = randomBytes) {
+        const t = new SigningContext('SigningContext', rng);
+        t.label(ctx);
+        t.bytes(msg);
+        t.commitPoint('vrf-nm-pk', pubPoint);
+        const hash = t.challengeBytes('VRFHash', 64);
+        const input = RistrettoPoint.hashToCurve(hash);
+        const transcript = new SigningContext('VRF', rng);
+        if (extra.length)
+            transcript.label(extra);
+        t.clean();
+        cleanBytes(hash);
+        return { input, t: transcript };
+    }
+    const vrf = {
+        sign(msg, secretKey, ctx = EMPTY, extra = EMPTY, rng = randomBytes) {
+            abytes('msg', msg);
+            abytes('secretKey', secretKey, 64);
+            abytes('ctx', ctx);
+            abytes('extra', extra);
+            const keyScalar = decodeScalar(secretKey.subarray(0, 32));
+            const nonce = secretKey.subarray(32, 64);
+            const pubPoint = RistrettoPoint.fromHex(getPublicKey(secretKey));
+            const { input, t } = initVRF(ctx, msg, extra, pubPoint, rng);
+            const output = input.multiply(keyScalar);
+            const p = { output };
+            const { proof } = dleq.proove(keyScalar, nonce, pubPoint, t, input, output);
+            const cBytes = numberToBytesLE(proof.c, 32);
+            const sBytes = numberToBytesLE(proof.s, 32);
+            const res = concatBytes(p.output.toRawBytes(), cBytes, sBytes);
+            cleanBytes(nonce, cBytes, sBytes);
+            return res;
+        },
+        verify(msg, signature, publicKey, ctx = EMPTY, extra = EMPTY, rng = randomBytes) {
+            abytes('msg', msg);
+            abytes('signature', signature, 96);
+            abytes('pubkey', publicKey, 32);
+            abytes('ctx', ctx);
+            abytes('extra', extra);
+            const pubPoint = RistrettoPoint.fromHex(publicKey);
+            if (pubPoint.equals(RistrettoPoint.ZERO))
+                return false;
+            const proof = {
+                c: parseScalar('signature.c', signature.subarray(32, 64)),
+                s: parseScalar('signature.s', signature.subarray(64, 96)),
+            };
+            const { input, t } = initVRF(ctx, msg, extra, pubPoint, rng);
+            const output = RistrettoPoint.fromHex(signature.subarray(0, 32));
+            if (output.equals(RistrettoPoint.ZERO))
+                throw new Error('vrf.verify: wrong output point (identity)');
+            const proofBatchable = dleq.verify(pubPoint, t, input, output, proof);
+            return proofBatchable === false ? false : true;
+        },
+    };
+
+    function createDeriveFn(derive) {
+        return (keypair, chainCode) => {
+            if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+                throw new Error('Invalid chainCode passed to derive');
+            }
+            const secretKey = derive(keypair.secretKey, chainCode);
+            const publicKey = getPublicKey(secretKey);
+            return { publicKey, secretKey };
+        };
+    }
+
+    const sr25519DeriveHard =  createDeriveFn(HDKD.secretHard);
+
+    const sr25519DeriveSoft =  createDeriveFn(HDKD.secretSoft);
+
+    function keyHdkdSr25519(keypair, { chainCode, isSoft }) {
+        return isSoft
+            ? sr25519DeriveSoft(keypair, chainCode)
+            : sr25519DeriveHard(keypair, chainCode);
+    }
+
+    const generators = {
+        ecdsa: keyHdkdEcdsa,
+        ed25519: keyHdkdEd25519,
+        ethereum: keyHdkdEcdsa,
+        sr25519: keyHdkdSr25519
+    };
+    function keyFromPath(pair, path, type) {
+        const keyHdkd = generators[type];
+        let result = pair;
+        for (const junction of path) {
+            result = keyHdkd(result, junction);
+        }
+        return result;
+    }
+
+    function sr25519Agreement(secretKey, publicKey) {
+        const secretKeyU8a = util.u8aToU8a(secretKey);
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+        }
+        else if (secretKeyU8a.length !== 64) {
+            throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+        }
+        return getSharedSecret(secretKeyU8a, publicKeyU8a);
+    }
+
+    function sr25519DerivePublic(publicKey, chainCode) {
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        else if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+        }
+        return HDKD.publicSoft(publicKeyU8a, chainCode);
+    }
+
+    function sr25519PairFromSeed(seed) {
+        const seedU8a = util.u8aToU8a(seed);
+        if (seedU8a.length !== 32) {
+            throw new Error(`Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+        }
+        const sec = secretFromSeed(seedU8a);
+        const pub = getPublicKey(sec);
+        return {
+            publicKey: pub,
+            secretKey: sec
+        };
+    }
+
+    function sr25519Sign(message, { publicKey, secretKey }) {
+        if (publicKey?.length !== 32) {
+            throw new Error('Expected a valid publicKey, 32-bytes');
+        }
+        else if (secretKey?.length !== 64) {
+            throw new Error('Expected a valid secretKey, 64-bytes');
+        }
+        return sign(secretKey, util.u8aToU8a(message));
+    }
+
+    function sr25519Verify(message, signature, publicKey) {
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        const signatureU8a = util.u8aToU8a(signature);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+        }
+        else if (signatureU8a.length !== 64) {
+            throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+        }
+        return verify(util.u8aToU8a(message), signatureU8a, publicKeyU8a);
+    }
+
+    const EMPTY_U8A$1 = new Uint8Array();
+    function sr25519VrfSign(message, { secretKey }, context = EMPTY_U8A$1, extra = EMPTY_U8A$1) {
+        if (secretKey?.length !== 64) {
+            throw new Error('Invalid secretKey, expected 64-bytes');
+        }
+        return vrf.sign(util.u8aToU8a(message), secretKey, util.u8aToU8a(context), util.u8aToU8a(extra), randomBytes);
+    }
+
+    const EMPTY_U8A = new Uint8Array();
+    function sr25519VrfVerify(message, signOutput, publicKey, context = EMPTY_U8A, extra = EMPTY_U8A) {
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        const proofU8a = util.u8aToU8a(signOutput);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error('Invalid publicKey, expected 32-bytes');
+        }
+        else if (proofU8a.length !== 96) {
+            throw new Error('Invalid vrfSign output, expected 96 bytes');
+        }
+        return vrf.verify(util.u8aToU8a(message), proofU8a, publicKeyU8a, util.u8aToU8a(context), util.u8aToU8a(extra));
+    }
+
+    function encodeAddress(key, ss58Format = defaults.prefix) {
+        const u8a = decodeAddress(key);
+        if ((ss58Format < 0) || (ss58Format > 16383 && !ss58Exceptions.includes(ss58Format)) || [46, 47].includes(ss58Format)) {
+            throw new Error('Out of range ss58Format specified');
+        }
+        else if (!defaults.allowedDecodedLengths.includes(u8a.length)) {
+            throw new Error(`Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
+        }
+        const input = util.u8aConcat(ss58Format < 64
+            ? [ss58Format]
+            : [
+                ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
+                (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
+            ], u8a);
+        return base58Encode(util.u8aConcat(input, sshash(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1)));
+    }
+    const ss58Exceptions = [29972];
+
+    function filterHard({ isHard }) {
+        return isHard;
+    }
+    function deriveAddress(who, suri, ss58Format) {
+        const { path } = keyExtractPath(suri);
+        if (!path.length || path.every(filterHard)) {
+            throw new Error('Expected suri to contain a combination of non-hard paths');
+        }
+        let publicKey = decodeAddress(who);
+        for (const { chainCode } of path) {
+            publicKey = sr25519DerivePublic(publicKey, chainCode);
+        }
+        return encodeAddress(publicKey, ss58Format);
+    }
+
+    const PREFIX$1 = util.stringToU8a('modlpy/utilisuba');
+    function createKeyDerived(who, index) {
+        return blake2AsU8a(util.u8aConcat(PREFIX$1, decodeAddress(who), util.bnToU8a(index, BN_LE_16_OPTS)));
+    }
+
+    function encodeDerivedAddress(who, index, ss58Format) {
+        return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
+    }
+
+    function addressToU8a(who) {
+        return decodeAddress(who);
+    }
+
+    const PREFIX = util.stringToU8a('modlpy/utilisuba');
+    function createKeyMulti(who, threshold) {
+        return blake2AsU8a(util.u8aConcat(PREFIX, util.compactToU8a(who.length), ...util.u8aSorted(who.map(addressToU8a)), util.bnToU8a(threshold, BN_LE_16_OPTS)));
+    }
+
+    function encodeMultiAddress(who, threshold, ss58Format) {
+        return encodeAddress(createKeyMulti(who, threshold), ss58Format);
+    }
+
+    function addressEq(a, b) {
+        return util.u8aEq(decodeAddress(a), decodeAddress(b));
+    }
+
+    const keccakAsU8a =  createDualHasher({ 256: keccak256, 512: keccak512 }, { 256: keccak_256, 512: keccak_512 });
+    const keccak256AsU8a =  createBitHasher(256, keccakAsU8a);
+    const keccak512AsU8a =  createBitHasher(512, keccakAsU8a);
+    const keccakAsHex =  createAsHex(keccakAsU8a);
+
+    function hasher(hashType, data, onlyJs) {
+        return hashType === 'keccak'
+            ? keccakAsU8a(data, undefined, onlyJs)
+            : blake2AsU8a(data, undefined, undefined, onlyJs);
+    }
+
+    function evmToAddress(evmAddress, ss58Format, hashType = 'blake2') {
+        const message = util.u8aConcat('evm:', evmAddress);
+        if (message.length !== 24) {
+            throw new Error(`Converting ${evmAddress}: Invalid evm address length`);
+        }
+        return encodeAddress(hasher(hashType, message), ss58Format);
+    }
+
+    function validateAddress(encoded, ignoreChecksum, ss58Format) {
+        return !!decodeAddress(encoded, ignoreChecksum, ss58Format);
+    }
+
+    function isAddress(address, ignoreChecksum, ss58Format) {
+        try {
+            return validateAddress(address, ignoreChecksum, ss58Format);
+        }
+        catch {
+            return false;
+        }
+    }
+
+    function sortAddresses(addresses, ss58Format) {
+        const u8aToAddress = (u8a) => encodeAddress(u8a, ss58Format);
+        return util.u8aSorted(addresses.map(addressToU8a)).map(u8aToAddress);
+    }
+
+    const l = util.logger('setSS58Format');
+    function setSS58Format(prefix) {
+        l.warn('Global setting of the ss58Format is deprecated and not recommended. Set format on the keyring (if used) or as part of the address encode function');
+        defaults.prefix = prefix;
+    }
+
+    const chars = 'abcdefghijklmnopqrstuvwxyz234567';
+    const config$1 = {
+        chars,
+        coder: utils.chain(
+        utils.radix2(5), utils.alphabet(chars), {
+            decode: (input) => input.split(''),
+            encode: (input) => input.join('')
+        }),
+        ipfs: 'b',
+        type: 'base32'
+    };
+    const base32Validate =  createValidate(config$1);
+    const isBase32 =  createIs(base32Validate);
+    const base32Decode =  createDecode(config$1, base32Validate);
+    const base32Encode =  createEncode(config$1);
+
+    const config = {
+        chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+        coder: base64,
+        type: 'base64',
+        withPadding: true
+    };
+    const base64Validate =  createValidate(config);
+    const isBase64 =  createIs(base64Validate);
+    const base64Decode =  createDecode(config, base64Validate);
+    const base64Encode =  createEncode(config);
+
+    function base64Pad(value) {
+        return value.padEnd(value.length + (value.length % 4), '=');
+    }
+
+    function base64Trim(value) {
+        while (value.length && value.endsWith('=')) {
+            value = value.slice(0, -1);
+        }
+        return value;
+    }
+
+    function secp256k1Compress(publicKey, onlyJs) {
+        if (![33, 65].includes(publicKey.length)) {
+            throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+        }
+        if (publicKey.length === 33) {
+            return publicKey;
+        }
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? secp256k1Compress$1(publicKey)
+            : secp256k1.Point.fromHex(publicKey).toBytes(true);
+    }
+
+    function secp256k1Expand(publicKey, onlyJs) {
+        if (![33, 65].includes(publicKey.length)) {
+            throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+        }
+        if (publicKey.length === 65) {
+            return publicKey.subarray(1);
+        }
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            return secp256k1Expand$1(publicKey).subarray(1);
+        }
+        const { x: px, y: py } = secp256k1.Point.fromHex(publicKey).toAffine();
+        return util.u8aConcat(util.bnToU8a(px, BN_BE_256_OPTS), util.bnToU8a(py, BN_BE_256_OPTS));
+    }
+
+    function secp256k1Recover(msgHash, signature, recovery, hashType = 'blake2', onlyJs) {
+        const sig = util.u8aToU8a(signature).subarray(0, 64);
+        const msg = util.u8aToU8a(msgHash);
+        const publicKey = !util.hasBigInt || (!onlyJs && isReady())
+            ? secp256k1Recover$1(msg, sig, recovery)
+            : secp256k1.Signature
+                .fromBytes(sig, 'compact')
+                .addRecoveryBit(recovery)
+                .recoverPublicKey(msg)
+                .toBytes();
+        if (!publicKey) {
+            throw new Error('Unable to recover publicKey from signature');
+        }
+        return hashType === 'keccak'
+            ? secp256k1Expand(publicKey, onlyJs)
+            : secp256k1Compress(publicKey, onlyJs);
+    }
+
+    function secp256k1Sign(message, { secretKey }, hashType = 'blake2', onlyJs) {
+        if (secretKey?.length !== 32) {
+            throw new Error('Expected valid secp256k1 secretKey, 32-bytes');
+        }
+        const data = hasher(hashType, message, onlyJs);
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            return secp256k1Sign$1(data, secretKey);
+        }
+        const signature = secp256k1.sign(data, secretKey, { lowS: true });
+        return util.u8aConcat(util.bnToU8a(signature.r, BN_BE_256_OPTS), util.bnToU8a(signature.s, BN_BE_256_OPTS), new Uint8Array([signature.recovery || 0]));
+    }
+
+    const N = 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141'.replace(/ /g, '');
+    const N_BI = BigInt$1(`0x${N}`);
+    const N_BN = new util.BN(N, 'hex');
+    function addBi(seckey, tweak) {
+        let res = util.u8aToBigInt(tweak, BN_BE_OPTS);
+        if (res >= N_BI) {
+            throw new Error('Tweak parameter is out of range');
+        }
+        res += util.u8aToBigInt(seckey, BN_BE_OPTS);
+        if (res >= N_BI) {
+            res -= N_BI;
+        }
+        if (res === util._0n) {
+            throw new Error('Invalid resulting private key');
+        }
+        return util.nToU8a(res, BN_BE_256_OPTS);
+    }
+    function addBn(seckey, tweak) {
+        const res = new util.BN(tweak);
+        if (res.cmp(N_BN) >= 0) {
+            throw new Error('Tweak parameter is out of range');
+        }
+        res.iadd(new util.BN(seckey));
+        if (res.cmp(N_BN) >= 0) {
+            res.isub(N_BN);
+        }
+        if (res.isZero()) {
+            throw new Error('Invalid resulting private key');
+        }
+        return util.bnToU8a(res, BN_BE_256_OPTS);
+    }
+    function secp256k1PrivateKeyTweakAdd(seckey, tweak, onlyBn) {
+        if (!util.isU8a(seckey) || seckey.length !== 32) {
+            throw new Error('Expected seckey to be an Uint8Array with length 32');
+        }
+        else if (!util.isU8a(tweak) || tweak.length !== 32) {
+            throw new Error('Expected tweak to be an Uint8Array with length 32');
+        }
+        return !util.hasBigInt || onlyBn
+            ? addBn(seckey, tweak)
+            : addBi(seckey, tweak);
+    }
+
+    function secp256k1Verify(msgHash, signature, address, hashType = 'blake2', onlyJs) {
+        const sig = util.u8aToU8a(signature);
+        if (sig.length !== 65) {
+            throw new Error(`Expected signature with 65 bytes, ${sig.length} found instead`);
+        }
+        const publicKey = secp256k1Recover(hasher(hashType, msgHash), sig, sig[64], hashType, onlyJs);
+        const signerAddr = hasher(hashType, publicKey, onlyJs);
+        const inputAddr = util.u8aToU8a(address);
+        return util.u8aEq(publicKey, inputAddr) || (hashType === 'keccak'
+            ? util.u8aEq(signerAddr.slice(-20), inputAddr.slice(-20))
+            : util.u8aEq(signerAddr, inputAddr));
+    }
+
+    function getH160(u8a) {
+        if ([33, 65].includes(u8a.length)) {
+            u8a = keccakAsU8a(secp256k1Expand(u8a));
+        }
+        return u8a.slice(-20);
+    }
+    function ethereumEncode(addressOrPublic) {
+        if (!addressOrPublic) {
+            return '0x';
+        }
+        const u8aAddress = util.u8aToU8a(addressOrPublic);
+        if (![20, 32, 33, 65].includes(u8aAddress.length)) {
+            throw new Error(`Invalid address or publicKey provided, received ${u8aAddress.length} bytes input`);
+        }
+        const address = util.u8aToHex(getH160(u8aAddress), -1, false);
+        const hash = util.u8aToHex(keccakAsU8a(address), -1, false);
+        let result = '';
+        for (let i = 0; i < 40; i++) {
+            result = `${result}${parseInt(hash[i], 16) > 7 ? address[i].toUpperCase() : address[i]}`;
+        }
+        return `0x${result}`;
+    }
+
+    function isInvalidChar(char, byte) {
+        return char !== (byte > 7
+            ? char.toUpperCase()
+            : char.toLowerCase());
+    }
+    function isEthereumChecksum(_address) {
+        const address = _address.replace('0x', '');
+        const hash = util.u8aToHex(keccakAsU8a(address.toLowerCase()), -1, false);
+        for (let i = 0; i < 40; i++) {
+            if (isInvalidChar(address[i], parseInt(hash[i], 16))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function isEthereumAddress(address) {
+        if (!address || address.length !== 42 || !util.isHex(address)) {
+            return false;
+        }
+        else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+            return true;
+        }
+        return isEthereumChecksum(address);
+    }
+
+    const JS_HASH = {
+        256: sha256,
+        512: sha512$1
+    };
+    const WA_MHAC = {
+        256: hmacSha256,
+        512: hmacSha512
+    };
+    function createSha(bitLength) {
+        return (key, data, onlyJs) => hmacShaAsU8a(key, data, bitLength, onlyJs);
+    }
+    function hmacShaAsU8a(key, data, bitLength = 256, onlyJs) {
+        const u8aKey = util.u8aToU8a(key);
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? WA_MHAC[bitLength](u8aKey, data)
+            : hmac(JS_HASH[bitLength], u8aKey, data);
+    }
+    const hmacSha256AsU8a =  createSha(256);
+    const hmacSha512AsU8a =  createSha(512);
+
+    const HARDENED = 0x80000000;
+    function hdValidatePath(path) {
+        if (!path.startsWith('m/')) {
+            return false;
+        }
+        const parts = path.split('/').slice(1);
+        for (const p of parts) {
+            const n = /^\d+'?$/.test(p)
+                ? parseInt(p.replace(/'$/, ''), 10)
+                : Number.NaN;
+            if (isNaN(n) || (n >= HARDENED) || (n < 0)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    const MASTER_SECRET = util.stringToU8a('Bitcoin seed');
+    function createCoded(secretKey, chainCode) {
+        return {
+            chainCode,
+            publicKey: secp256k1PairFromSeed(secretKey).publicKey,
+            secretKey
+        };
+    }
+    function deriveChild(hd, index) {
+        const indexBuffer = util.bnToU8a(index, BN_BE_32_OPTS);
+        const data = index >= HARDENED
+            ? util.u8aConcat(new Uint8Array(1), hd.secretKey, indexBuffer)
+            : util.u8aConcat(hd.publicKey, indexBuffer);
+        try {
+            const I = hmacShaAsU8a(hd.chainCode, data, 512);
+            return createCoded(secp256k1PrivateKeyTweakAdd(hd.secretKey, I.slice(0, 32)), I.slice(32));
+        }
+        catch {
+            return deriveChild(hd, index + 1);
+        }
+    }
+    function hdEthereum(seed, path = '') {
+        const I = hmacShaAsU8a(MASTER_SECRET, seed, 512);
+        let hd = createCoded(I.slice(0, 32), I.slice(32));
+        if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+            return hd;
+        }
+        if (!hdValidatePath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        const parts = path.split('/').slice(1);
+        for (const p of parts) {
+            hd = deriveChild(hd, parseInt(p, 10) + ((p.length > 1) && p.endsWith("'")
+                ? HARDENED
+                : 0));
+        }
+        return hd;
+    }
+
+    function pbkdf2Init(hash, _password, _salt, _opts) {
+        ahash(hash);
+        const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+        const { c, dkLen, asyncTick } = opts;
+        anumber(c);
+        anumber(dkLen);
+        anumber(asyncTick);
+        if (c < 1)
+            throw new Error('iterations (c) should be >= 1');
+        const password = kdfInputToBytes(_password);
+        const salt = kdfInputToBytes(_salt);
+        const DK = new Uint8Array(dkLen);
+        const PRF = hmac.create(hash, password);
+        const PRFSalt = PRF._cloneInto().update(salt);
+        return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+    }
+    function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+        PRF.destroy();
+        PRFSalt.destroy();
+        if (prfW)
+            prfW.destroy();
+        clean(u);
+        return DK;
+    }
+    function pbkdf2(hash, password, salt, opts) {
+        const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+        let prfW;
+        const arr = new Uint8Array(4);
+        const view = createView(arr);
+        const u = new Uint8Array(PRF.outputLen);
+        for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+            const Ti = DK.subarray(pos, pos + PRF.outputLen);
+            view.setInt32(0, ti, false);
+            (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+            Ti.set(u.subarray(0, Ti.length));
+            for (let ui = 1; ui < c; ui++) {
+                PRF._cloneInto(prfW).update(u).digestInto(u);
+                for (let i = 0; i < Ti.length; i++)
+                    Ti[i] ^= u[i];
+            }
+        }
+        return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+    }
+
+    function pbkdf2Encode(passphrase, salt = randomAsU8a(), rounds = 2048, onlyJs) {
+        const u8aPass = util.u8aToU8a(passphrase);
+        const u8aSalt = util.u8aToU8a(salt);
+        return {
+            password: !util.hasBigInt || (!onlyJs && isReady())
+                ? pbkdf2$1(u8aPass, u8aSalt, rounds)
+                : pbkdf2(sha512$1, u8aPass, u8aSalt, { c: rounds, dkLen: 64 }),
+            rounds,
+            salt
+        };
+    }
+
+    const shaAsU8a =  createDualHasher({ 256: sha256$1, 512: sha512$2 }, { 256: sha256, 512: sha512$1 });
+    const sha256AsU8a =  createBitHasher(256, shaAsU8a);
+    const sha512AsU8a =  createBitHasher(512, shaAsU8a);
+
+    const DEFAULT_WORDLIST = 'abandon|ability|able|about|above|absent|absorb|abstract|absurd|abuse|access|accident|account|accuse|achieve|acid|acoustic|acquire|across|act|action|actor|actress|actual|adapt|add|addict|address|adjust|admit|adult|advance|advice|aerobic|affair|afford|afraid|again|age|agent|agree|ahead|aim|air|airport|aisle|alarm|album|alcohol|alert|alien|all|alley|allow|almost|alone|alpha|already|also|alter|always|amateur|amazing|among|amount|amused|analyst|anchor|ancient|anger|angle|angry|animal|ankle|announce|annual|another|answer|antenna|antique|anxiety|any|apart|apology|appear|apple|approve|april|arch|arctic|area|arena|argue|arm|armed|armor|army|around|arrange|arrest|arrive|arrow|art|artefact|artist|artwork|ask|aspect|assault|asset|assist|assume|asthma|athlete|atom|attack|attend|attitude|attract|auction|audit|august|aunt|author|auto|autumn|average|avocado|avoid|awake|aware|away|awesome|awful|awkward|axis|baby|bachelor|bacon|badge|bag|balance|balcony|ball|bamboo|banana|banner|bar|barely|bargain|barrel|base|basic|basket|battle|beach|bean|beauty|because|become|beef|before|begin|behave|behind|believe|below|belt|bench|benefit|best|betray|better|between|beyond|bicycle|bid|bike|bind|biology|bird|birth|bitter|black|blade|blame|blanket|blast|bleak|bless|blind|blood|blossom|blouse|blue|blur|blush|board|boat|body|boil|bomb|bone|bonus|book|boost|border|boring|borrow|boss|bottom|bounce|box|boy|bracket|brain|brand|brass|brave|bread|breeze|brick|bridge|brief|bright|bring|brisk|broccoli|broken|bronze|broom|brother|brown|brush|bubble|buddy|budget|buffalo|build|bulb|bulk|bullet|bundle|bunker|burden|burger|burst|bus|business|busy|butter|buyer|buzz|cabbage|cabin|cable|cactus|cage|cake|call|calm|camera|camp|can|canal|cancel|candy|cannon|canoe|canvas|canyon|capable|capital|captain|car|carbon|card|cargo|carpet|carry|cart|case|cash|casino|castle|casual|cat|catalog|catch|category|cattle|caught|cause|caution|cave|ceiling|celery|cement|census|century|cereal|certain|chair|chalk|champion|change|chaos|chapter|charge|chase|chat|cheap|check|cheese|chef|cherry|chest|chicken|chief|child|chimney|choice|choose|chronic|chuckle|chunk|churn|cigar|cinnamon|circle|citizen|city|civil|claim|clap|clarify|claw|clay|clean|clerk|clever|click|client|cliff|climb|clinic|clip|clock|clog|close|cloth|cloud|clown|club|clump|cluster|clutch|coach|coast|coconut|code|coffee|coil|coin|collect|color|column|combine|come|comfort|comic|common|company|concert|conduct|confirm|congress|connect|consider|control|convince|cook|cool|copper|copy|coral|core|corn|correct|cost|cotton|couch|country|couple|course|cousin|cover|coyote|crack|cradle|craft|cram|crane|crash|crater|crawl|crazy|cream|credit|creek|crew|cricket|crime|crisp|critic|crop|cross|crouch|crowd|crucial|cruel|cruise|crumble|crunch|crush|cry|crystal|cube|culture|cup|cupboard|curious|current|curtain|curve|cushion|custom|cute|cycle|dad|damage|damp|dance|danger|daring|dash|daughter|dawn|day|deal|debate|debris|decade|december|decide|decline|decorate|decrease|deer|defense|define|defy|degree|delay|deliver|demand|demise|denial|dentist|deny|depart|depend|deposit|depth|deputy|derive|describe|desert|design|desk|despair|destroy|detail|detect|develop|device|devote|diagram|dial|diamond|diary|dice|diesel|diet|differ|digital|dignity|dilemma|dinner|dinosaur|direct|dirt|disagree|discover|disease|dish|dismiss|disorder|display|distance|divert|divide|divorce|dizzy|doctor|document|dog|doll|dolphin|domain|donate|donkey|donor|door|dose|double|dove|draft|dragon|drama|drastic|draw|dream|dress|drift|drill|drink|drip|drive|drop|drum|dry|duck|dumb|dune|during|dust|dutch|duty|dwarf|dynamic|eager|eagle|early|earn|earth|easily|east|easy|echo|ecology|economy|edge|edit|educate|effort|egg|eight|either|elbow|elder|electric|elegant|element|elephant|elevator|elite|else|embark|embody|embrace|emerge|emotion|employ|empower|empty|enable|enact|end|endless|endorse|enemy|energy|enforce|engage|engine|enhance|enjoy|enlist|enough|enrich|enroll|ensure|enter|entire|entry|envelope|episode|equal|equip|era|erase|erode|erosion|error|erupt|escape|essay|essence|estate|eternal|ethics|evidence|evil|evoke|evolve|exact|example|excess|exchange|excite|exclude|excuse|execute|exercise|exhaust|exhibit|exile|exist|exit|exotic|expand|expect|expire|explain|expose|express|extend|extra|eye|eyebrow|fabric|face|faculty|fade|faint|faith|fall|false|fame|family|famous|fan|fancy|fantasy|farm|fashion|fat|fatal|father|fatigue|fault|favorite|feature|february|federal|fee|feed|feel|female|fence|festival|fetch|fever|few|fiber|fiction|field|figure|file|film|filter|final|find|fine|finger|finish|fire|firm|first|fiscal|fish|fit|fitness|fix|flag|flame|flash|flat|flavor|flee|flight|flip|float|flock|floor|flower|fluid|flush|fly|foam|focus|fog|foil|fold|follow|food|foot|force|forest|forget|fork|fortune|forum|forward|fossil|foster|found|fox|fragile|frame|frequent|fresh|friend|fringe|frog|front|frost|frown|frozen|fruit|fuel|fun|funny|furnace|fury|future|gadget|gain|galaxy|gallery|game|gap|garage|garbage|garden|garlic|garment|gas|gasp|gate|gather|gauge|gaze|general|genius|genre|gentle|genuine|gesture|ghost|giant|gift|giggle|ginger|giraffe|girl|give|glad|glance|glare|glass|glide|glimpse|globe|gloom|glory|glove|glow|glue|goat|goddess|gold|good|goose|gorilla|gospel|gossip|govern|gown|grab|grace|grain|grant|grape|grass|gravity|great|green|grid|grief|grit|grocery|group|grow|grunt|guard|guess|guide|guilt|guitar|gun|gym|habit|hair|half|hammer|hamster|hand|happy|harbor|hard|harsh|harvest|hat|have|hawk|hazard|head|health|heart|heavy|hedgehog|height|hello|helmet|help|hen|hero|hidden|high|hill|hint|hip|hire|history|hobby|hockey|hold|hole|holiday|hollow|home|honey|hood|hope|horn|horror|horse|hospital|host|hotel|hour|hover|hub|huge|human|humble|humor|hundred|hungry|hunt|hurdle|hurry|hurt|husband|hybrid|ice|icon|idea|identify|idle|ignore|ill|illegal|illness|image|imitate|immense|immune|impact|impose|improve|impulse|inch|include|income|increase|index|indicate|indoor|industry|infant|inflict|inform|inhale|inherit|initial|inject|injury|inmate|inner|innocent|input|inquiry|insane|insect|inside|inspire|install|intact|interest|into|invest|invite|involve|iron|island|isolate|issue|item|ivory|jacket|jaguar|jar|jazz|jealous|jeans|jelly|jewel|job|join|joke|journey|joy|judge|juice|jump|jungle|junior|junk|just|kangaroo|keen|keep|ketchup|key|kick|kid|kidney|kind|kingdom|kiss|kit|kitchen|kite|kitten|kiwi|knee|knife|knock|know|lab|label|labor|ladder|lady|lake|lamp|language|laptop|large|later|latin|laugh|laundry|lava|law|lawn|lawsuit|layer|lazy|leader|leaf|learn|leave|lecture|left|leg|legal|legend|leisure|lemon|lend|length|lens|leopard|lesson|letter|level|liar|liberty|library|license|life|lift|light|like|limb|limit|link|lion|liquid|list|little|live|lizard|load|loan|lobster|local|lock|logic|lonely|long|loop|lottery|loud|lounge|love|loyal|lucky|luggage|lumber|lunar|lunch|luxury|lyrics|machine|mad|magic|magnet|maid|mail|main|major|make|mammal|man|manage|mandate|mango|mansion|manual|maple|marble|march|margin|marine|market|marriage|mask|mass|master|match|material|math|matrix|matter|maximum|maze|meadow|mean|measure|meat|mechanic|medal|media|melody|melt|member|memory|mention|menu|mercy|merge|merit|merry|mesh|message|metal|method|middle|midnight|milk|million|mimic|mind|minimum|minor|minute|miracle|mirror|misery|miss|mistake|mix|mixed|mixture|mobile|model|modify|mom|moment|monitor|monkey|monster|month|moon|moral|more|morning|mosquito|mother|motion|motor|mountain|mouse|move|movie|much|muffin|mule|multiply|muscle|museum|mushroom|music|must|mutual|myself|mystery|myth|naive|name|napkin|narrow|nasty|nation|nature|near|neck|need|negative|neglect|neither|nephew|nerve|nest|net|network|neutral|never|news|next|nice|night|noble|noise|nominee|noodle|normal|north|nose|notable|note|nothing|notice|novel|now|nuclear|number|nurse|nut|oak|obey|object|oblige|obscure|observe|obtain|obvious|occur|ocean|october|odor|off|offer|office|often|oil|okay|old|olive|olympic|omit|once|one|onion|online|only|open|opera|opinion|oppose|option|orange|orbit|orchard|order|ordinary|organ|orient|original|orphan|ostrich|other|outdoor|outer|output|outside|oval|oven|over|own|owner|oxygen|oyster|ozone|pact|paddle|page|pair|palace|palm|panda|panel|panic|panther|paper|parade|parent|park|parrot|party|pass|patch|path|patient|patrol|pattern|pause|pave|payment|peace|peanut|pear|peasant|pelican|pen|penalty|pencil|people|pepper|perfect|permit|person|pet|phone|photo|phrase|physical|piano|picnic|picture|piece|pig|pigeon|pill|pilot|pink|pioneer|pipe|pistol|pitch|pizza|place|planet|plastic|plate|play|please|pledge|pluck|plug|plunge|poem|poet|point|polar|pole|police|pond|pony|pool|popular|portion|position|possible|post|potato|pottery|poverty|powder|power|practice|praise|predict|prefer|prepare|present|pretty|prevent|price|pride|primary|print|priority|prison|private|prize|problem|process|produce|profit|program|project|promote|proof|property|prosper|protect|proud|provide|public|pudding|pull|pulp|pulse|pumpkin|punch|pupil|puppy|purchase|purity|purpose|purse|push|put|puzzle|pyramid|quality|quantum|quarter|question|quick|quit|quiz|quote|rabbit|raccoon|race|rack|radar|radio|rail|rain|raise|rally|ramp|ranch|random|range|rapid|rare|rate|rather|raven|raw|razor|ready|real|reason|rebel|rebuild|recall|receive|recipe|record|recycle|reduce|reflect|reform|refuse|region|regret|regular|reject|relax|release|relief|rely|remain|remember|remind|remove|render|renew|rent|reopen|repair|repeat|replace|report|require|rescue|resemble|resist|resource|response|result|retire|retreat|return|reunion|reveal|review|reward|rhythm|rib|ribbon|rice|rich|ride|ridge|rifle|right|rigid|ring|riot|ripple|risk|ritual|rival|river|road|roast|robot|robust|rocket|romance|roof|rookie|room|rose|rotate|rough|round|route|royal|rubber|rude|rug|rule|run|runway|rural|sad|saddle|sadness|safe|sail|salad|salmon|salon|salt|salute|same|sample|sand|satisfy|satoshi|sauce|sausage|save|say|scale|scan|scare|scatter|scene|scheme|school|science|scissors|scorpion|scout|scrap|screen|script|scrub|sea|search|season|seat|second|secret|section|security|seed|seek|segment|select|sell|seminar|senior|sense|sentence|series|service|session|settle|setup|seven|shadow|shaft|shallow|share|shed|shell|sheriff|shield|shift|shine|ship|shiver|shock|shoe|shoot|shop|short|shoulder|shove|shrimp|shrug|shuffle|shy|sibling|sick|side|siege|sight|sign|silent|silk|silly|silver|similar|simple|since|sing|siren|sister|situate|six|size|skate|sketch|ski|skill|skin|skirt|skull|slab|slam|sleep|slender|slice|slide|slight|slim|slogan|slot|slow|slush|small|smart|smile|smoke|smooth|snack|snake|snap|sniff|snow|soap|soccer|social|sock|soda|soft|solar|soldier|solid|solution|solve|someone|song|soon|sorry|sort|soul|sound|soup|source|south|space|spare|spatial|spawn|speak|special|speed|spell|spend|sphere|spice|spider|spike|spin|spirit|split|spoil|sponsor|spoon|sport|spot|spray|spread|spring|spy|square|squeeze|squirrel|stable|stadium|staff|stage|stairs|stamp|stand|start|state|stay|steak|steel|stem|step|stereo|stick|still|sting|stock|stomach|stone|stool|story|stove|strategy|street|strike|strong|struggle|student|stuff|stumble|style|subject|submit|subway|success|such|sudden|suffer|sugar|suggest|suit|summer|sun|sunny|sunset|super|supply|supreme|sure|surface|surge|surprise|surround|survey|suspect|sustain|swallow|swamp|swap|swarm|swear|sweet|swift|swim|swing|switch|sword|symbol|symptom|syrup|system|table|tackle|tag|tail|talent|talk|tank|tape|target|task|taste|tattoo|taxi|teach|team|tell|ten|tenant|tennis|tent|term|test|text|thank|that|theme|then|theory|there|they|thing|this|thought|three|thrive|throw|thumb|thunder|ticket|tide|tiger|tilt|timber|time|tiny|tip|tired|tissue|title|toast|tobacco|today|toddler|toe|together|toilet|token|tomato|tomorrow|tone|tongue|tonight|tool|tooth|top|topic|topple|torch|tornado|tortoise|toss|total|tourist|toward|tower|town|toy|track|trade|traffic|tragic|train|transfer|trap|trash|travel|tray|treat|tree|trend|trial|tribe|trick|trigger|trim|trip|trophy|trouble|truck|true|truly|trumpet|trust|truth|try|tube|tuition|tumble|tuna|tunnel|turkey|turn|turtle|twelve|twenty|twice|twin|twist|two|type|typical|ugly|umbrella|unable|unaware|uncle|uncover|under|undo|unfair|unfold|unhappy|uniform|unique|unit|universe|unknown|unlock|until|unusual|unveil|update|upgrade|uphold|upon|upper|upset|urban|urge|usage|use|used|useful|useless|usual|utility|vacant|vacuum|vague|valid|valley|valve|van|vanish|vapor|various|vast|vault|vehicle|velvet|vendor|venture|venue|verb|verify|version|very|vessel|veteran|viable|vibrant|vicious|victory|video|view|village|vintage|violin|virtual|virus|visa|visit|visual|vital|vivid|vocal|voice|void|volcano|volume|vote|voyage|wage|wagon|wait|walk|wall|walnut|want|warfare|warm|warrior|wash|wasp|waste|water|wave|way|wealth|weapon|wear|weasel|weather|web|wedding|weekend|weird|welcome|west|wet|whale|what|wheat|wheel|when|where|whip|whisper|wide|width|wife|wild|will|win|window|wine|wing|wink|winner|winter|wire|wisdom|wise|wish|witness|wolf|woman|wonder|wood|wool|word|work|world|worry|worth|wrap|wreck|wrestle|wrist|write|wrong|yard|year|yellow|you|young|youth|zebra|zero|zone|zoo'.split('|');
+
+    const INVALID_MNEMONIC = 'Invalid mnemonic';
+    const INVALID_ENTROPY = 'Invalid entropy';
+    const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
+    function normalize(str) {
+        return (str || '').normalize('NFKD');
+    }
+    function binaryToByte(bin) {
+        return parseInt(bin, 2);
+    }
+    function bytesToBinary(bytes) {
+        return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
+    }
+    function deriveChecksumBits(entropyBuffer) {
+        return bytesToBinary(Array.from(sha256AsU8a(entropyBuffer))).slice(0, (entropyBuffer.length * 8) / 32);
+    }
+    function mnemonicToSeedSync(mnemonic, password) {
+        return pbkdf2Encode(util.stringToU8a(normalize(mnemonic)), util.stringToU8a(`mnemonic${normalize(password)}`)).password;
+    }
+    function mnemonicToEntropy$1(mnemonic, wordlist = DEFAULT_WORDLIST) {
+        const words = normalize(mnemonic).split(' ');
+        if (words.length % 3 !== 0) {
+            throw new Error(INVALID_MNEMONIC);
+        }
+        const bits = words
+            .map((word) => {
+            const index = wordlist.indexOf(word);
+            if (index === -1) {
+                throw new Error(INVALID_MNEMONIC);
+            }
+            return index.toString(2).padStart(11, '0');
+        })
+            .join('');
+        const dividerIndex = Math.floor(bits.length / 33) * 32;
+        const entropyBits = bits.slice(0, dividerIndex);
+        const checksumBits = bits.slice(dividerIndex);
+        const matched = entropyBits.match(/(.{1,8})/g);
+        const entropyBytes = matched?.map(binaryToByte);
+        if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
+            throw new Error(INVALID_ENTROPY);
+        }
+        const entropy = util.u8aToU8a(entropyBytes);
+        if (deriveChecksumBits(entropy) !== checksumBits) {
+            throw new Error(INVALID_CHECKSUM);
+        }
+        return entropy;
+    }
+    function entropyToMnemonic(entropy, wordlist = DEFAULT_WORDLIST) {
+        if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
+            throw new Error(INVALID_ENTROPY);
+        }
+        const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
+        const mapped = matched?.map((b) => wordlist[binaryToByte(b)]);
+        if (!mapped || (mapped.length < 12)) {
+            throw new Error('Unable to map entropy to mnemonic');
+        }
+        return mapped.join(' ');
+    }
+    function generateMnemonic(numWords, wordlist) {
+        return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
+    }
+    function validateMnemonic(mnemonic, wordlist) {
+        try {
+            mnemonicToEntropy$1(mnemonic, wordlist);
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+
+    function mnemonicGenerate(numWords = 12, wordlist, onlyJs) {
+        return !util.hasBigInt || (!wordlist && !onlyJs && isReady())
+            ? bip39Generate(numWords)
+            : generateMnemonic(numWords, wordlist);
+    }
+
+    function mnemonicToEntropy(mnemonic, wordlist, onlyJs) {
+        return !util.hasBigInt || (!wordlist && !onlyJs && isReady())
+            ? bip39ToEntropy(mnemonic)
+            : mnemonicToEntropy$1(mnemonic, wordlist);
+    }
+
+    function mnemonicValidate(mnemonic, wordlist, onlyJs) {
+        return !util.hasBigInt || (!wordlist && !onlyJs && isReady())
+            ? bip39Validate(mnemonic)
+            : validateMnemonic(mnemonic, wordlist);
+    }
+
+    function mnemonicToLegacySeed(mnemonic, password = '', onlyJs, byteLength = 32) {
+        if (!mnemonicValidate(mnemonic)) {
+            throw new Error('Invalid bip39 mnemonic specified');
+        }
+        else if (![32, 64].includes(byteLength)) {
+            throw new Error(`Invalid seed length ${byteLength}, expected 32 or 64`);
+        }
+        return byteLength === 32
+            ? !util.hasBigInt || (!onlyJs && isReady())
+                ? bip39ToSeed(mnemonic, password)
+                : mnemonicToSeedSync(mnemonic, password).subarray(0, 32)
+            : mnemonicToSeedSync(mnemonic, password);
+    }
+
+    function mnemonicToMiniSecret(mnemonic, password = '', wordlist, onlyJs) {
+        if (!mnemonicValidate(mnemonic, wordlist, onlyJs)) {
+            throw new Error('Invalid bip39 mnemonic specified');
+        }
+        else if (!wordlist && !onlyJs && isReady()) {
+            return bip39ToMiniSecret(mnemonic, password);
+        }
+        const entropy = mnemonicToEntropy(mnemonic, wordlist);
+        const salt = util.stringToU8a(`mnemonic${password}`);
+        return pbkdf2Encode(entropy, salt).password.slice(0, 32);
+    }
+
+    function ledgerDerivePrivate(xprv, index) {
+        const kl = xprv.subarray(0, 32);
+        const kr = xprv.subarray(32, 64);
+        const cc = xprv.subarray(64, 96);
+        const data = util.u8aConcat([0], kl, kr, util.bnToU8a(index, BN_LE_32_OPTS));
+        const z = hmacShaAsU8a(cc, data, 512);
+        data[0] = 0x01;
+        return util.u8aConcat(util.bnToU8a(util.u8aToBn(kl, BN_LE_OPTS).iadd(util.u8aToBn(z.subarray(0, 28), BN_LE_OPTS).imul(util.BN_EIGHT)), BN_LE_512_OPTS).subarray(0, 32), util.bnToU8a(util.u8aToBn(kr, BN_LE_OPTS).iadd(util.u8aToBn(z.subarray(32, 64), BN_LE_OPTS)), BN_LE_512_OPTS).subarray(0, 32), hmacShaAsU8a(cc, data, 512).subarray(32, 64));
+    }
+
+    const ED25519_CRYPTO = 'ed25519 seed';
+    function ledgerMaster(mnemonic, password) {
+        const seed = mnemonicToSeedSync(mnemonic, password);
+        const chainCode = hmacShaAsU8a(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
+        let priv;
+        while (!priv || (priv[31] & 0b0010_0000)) {
+            priv = hmacShaAsU8a(ED25519_CRYPTO, priv || seed, 512);
+        }
+        priv[0] &= 0b1111_1000;
+        priv[31] &= 0b0111_1111;
+        priv[31] |= 0b0100_0000;
+        return util.u8aConcat(priv, chainCode);
+    }
+
+    function hdLedger(_mnemonic, path) {
+        const words = _mnemonic
+            .split(' ')
+            .map((s) => s.trim())
+            .filter((s) => s);
+        if (![12, 24, 25].includes(words.length)) {
+            throw new Error('Expected a mnemonic with 24 words (or 25 including a password)');
+        }
+        const [mnemonic, password] = words.length === 25
+            ? [words.slice(0, 24).join(' '), words[24]]
+            : [words.join(' '), ''];
+        if (!mnemonicValidate(mnemonic)) {
+            throw new Error('Invalid mnemonic passed to ledger derivation');
+        }
+        else if (!hdValidatePath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        const parts = path.split('/').slice(1);
+        let seed = ledgerMaster(mnemonic, password);
+        for (const p of parts) {
+            const n = parseInt(p.replace(/'$/, ''), 10);
+            seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
+        }
+        return ed25519PairFromSeed(seed.slice(0, 32));
+    }
+
+    function L32(x, c) { return (x << c) | (x >>> (32 - c)); }
+    function ld32(x, i) {
+        let u = x[i + 3] & 0xff;
+        u = (u << 8) | (x[i + 2] & 0xff);
+        u = (u << 8) | (x[i + 1] & 0xff);
+        return (u << 8) | (x[i + 0] & 0xff);
+    }
+    function st32(x, j, u) {
+        for (let i = 0; i < 4; i++) {
+            x[j + i] = u & 255;
+            u >>>= 8;
+        }
+    }
+    function vn(x, xi, y, yi, n) {
+        let d = 0;
+        for (let i = 0; i < n; i++)
+            d |= x[xi + i] ^ y[yi + i];
+        return (1 & ((d - 1) >>> 8)) - 1;
+    }
+    function core(out, inp, k, c, h) {
+        const w = new Uint32Array(16), x = new Uint32Array(16), y = new Uint32Array(16), t = new Uint32Array(4);
+        let i, j, m;
+        for (i = 0; i < 4; i++) {
+            x[5 * i] = ld32(c, 4 * i);
+            x[1 + i] = ld32(k, 4 * i);
+            x[6 + i] = ld32(inp, 4 * i);
+            x[11 + i] = ld32(k, 16 + 4 * i);
+        }
+        for (i = 0; i < 16; i++)
+            y[i] = x[i];
+        for (i = 0; i < 20; i++) {
+            for (j = 0; j < 4; j++) {
+                for (m = 0; m < 4; m++)
+                    t[m] = x[(5 * j + 4 * m) % 16];
+                t[1] ^= L32((t[0] + t[3]) | 0, 7);
+                t[2] ^= L32((t[1] + t[0]) | 0, 9);
+                t[3] ^= L32((t[2] + t[1]) | 0, 13);
+                t[0] ^= L32((t[3] + t[2]) | 0, 18);
+                for (m = 0; m < 4; m++)
+                    w[4 * j + (j + m) % 4] = t[m];
+            }
+            for (m = 0; m < 16; m++)
+                x[m] = w[m];
+        }
+        if (h) {
+            for (i = 0; i < 16; i++)
+                x[i] = (x[i] + y[i]) | 0;
+            for (i = 0; i < 4; i++) {
+                x[5 * i] = (x[5 * i] - ld32(c, 4 * i)) | 0;
+                x[6 + i] = (x[6 + i] - ld32(inp, 4 * i)) | 0;
+            }
+            for (i = 0; i < 4; i++) {
+                st32(out, 4 * i, x[5 * i]);
+                st32(out, 16 + 4 * i, x[6 + i]);
+            }
+        }
+        else {
+            for (i = 0; i < 16; i++)
+                st32(out, 4 * i, (x[i] + y[i]) | 0);
+        }
+    }
+    const sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
+    function crypto_stream_salsa20_xor(c, cpos, m, mpos, b, n, k) {
+        const z = new Uint8Array(16), x = new Uint8Array(64);
+        let u, i;
+        if (!b)
+            return 0;
+        for (i = 0; i < 16; i++)
+            z[i] = 0;
+        for (i = 0; i < 8; i++)
+            z[i] = n[i];
+        while (b >= 64) {
+            core(x, z, k, sigma, false);
+            for (i = 0; i < 64; i++)
+                c[cpos + i] = (m ? m[mpos + i] : 0) ^ x[i];
+            u = 1;
+            for (i = 8; i < 16; i++) {
+                u = u + (z[i] & 0xff) | 0;
+                z[i] = u & 0xff;
+                u >>>= 8;
+            }
+            b -= 64;
+            cpos += 64;
+            if (m)
+                mpos += 64;
+        }
+        if (b > 0) {
+            core(x, z, k, sigma, false);
+            for (i = 0; i < b; i++)
+                c[cpos + i] = (m ? m[mpos + i] : 0) ^ x[i];
+        }
+        return 0;
+    }
+    function crypto_stream_xor(c, cpos, m, mpos, d, n, k) {
+        const s = new Uint8Array(32);
+        core(s, n, k, sigma, true);
+        return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, n.subarray(16), s);
+    }
+    function add1305(h, c) {
+        let u = 0;
+        for (let j = 0; j < 17; j++) {
+            u = (u + ((h[j] + c[j]) | 0)) | 0;
+            h[j] = u & 255;
+            u >>>= 8;
+        }
+    }
+    const minusp = new Uint32Array([5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252]);
+    function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
+        let i, j, u;
+        const x = new Uint32Array(17), r = new Uint32Array(17), h = new Uint32Array(17), c = new Uint32Array(17), g = new Uint32Array(17);
+        for (j = 0; j < 17; j++)
+            r[j] = h[j] = 0;
+        for (j = 0; j < 16; j++)
+            r[j] = k[j];
+        r[3] &= 15;
+        r[4] &= 252;
+        r[7] &= 15;
+        r[8] &= 252;
+        r[11] &= 15;
+        r[12] &= 252;
+        r[15] &= 15;
+        while (n > 0) {
+            for (j = 0; j < 17; j++)
+                c[j] = 0;
+            for (j = 0; (j < 16) && (j < n); ++j)
+                c[j] = m[mpos + j];
+            c[j] = 1;
+            mpos += j;
+            n -= j;
+            add1305(h, c);
+            for (i = 0; i < 17; i++) {
+                x[i] = 0;
+                for (j = 0; j < 17; j++)
+                    x[i] = (x[i] + (h[j] * ((j <= i) ? r[i - j] : ((320 * r[i + 17 - j]) | 0))) | 0) | 0;
+            }
+            for (i = 0; i < 17; i++)
+                h[i] = x[i];
+            u = 0;
+            for (j = 0; j < 16; j++) {
+                u = (u + h[j]) | 0;
+                h[j] = u & 255;
+                u >>>= 8;
+            }
+            u = (u + h[16]) | 0;
+            h[16] = u & 3;
+            u = (5 * (u >>> 2)) | 0;
+            for (j = 0; j < 16; j++) {
+                u = (u + h[j]) | 0;
+                h[j] = u & 255;
+                u >>>= 8;
+            }
+            u = (u + h[16]) | 0;
+            h[16] = u;
+        }
+        for (j = 0; j < 17; j++)
+            g[j] = h[j];
+        add1305(h, minusp);
+        const s = (-(h[16] >>> 7) | 0);
+        for (j = 0; j < 17; j++)
+            h[j] ^= s & (g[j] ^ h[j]);
+        for (j = 0; j < 16; j++)
+            c[j] = k[j + 16];
+        c[16] = 0;
+        add1305(h, c);
+        for (j = 0; j < 16; j++)
+            out[outpos + j] = h[j];
+        return 0;
+    }
+    function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
+        const x = new Uint8Array(16);
+        crypto_onetimeauth(x, 0, m, mpos, n, k);
+        return vn(h, hpos, x, 0, 16);
+    }
+    function crypto_secretbox(c, m, d, n, k) {
+        if (d < 32)
+            return -1;
+        crypto_stream_xor(c, 0, m, 0, d, n, k);
+        crypto_onetimeauth(c, 16, c, 32, d - 32, c);
+        for (let i = 0; i < 16; i++)
+            c[i] = 0;
+        return 0;
+    }
+    function crypto_secretbox_open(m, c, d, n, k) {
+        const x = new Uint8Array(32);
+        if (d < 32)
+            return -1;
+        crypto_stream_xor(x, 0, null, 0, 32, n, k);
+        if (crypto_onetimeauth_verify(c, 16, c, 32, d - 32, x) !== 0)
+            return -1;
+        crypto_stream_xor(m, 0, c, 0, d, n, k);
+        for (let i = 0; i < 32; i++)
+            m[i] = 0;
+        return 0;
+    }
+    const crypto_secretbox_KEYBYTES = 32;
+    const crypto_secretbox_NONCEBYTES = 24;
+    const crypto_secretbox_ZEROBYTES = 32;
+    const crypto_secretbox_BOXZEROBYTES = 16;
+    function checkLengths(k, n) {
+        if (k.length !== crypto_secretbox_KEYBYTES)
+            throw new Error('bad key size');
+        if (n.length !== crypto_secretbox_NONCEBYTES)
+            throw new Error('bad nonce size');
+    }
+    function checkArrayTypes(...args) {
+        for (let i = 0, count = args.length; i < count; i++) {
+            if (!(args[i] instanceof Uint8Array))
+                throw new TypeError('unexpected type, use Uint8Array');
+        }
+    }
+    function naclSecretbox(msg, nonce, key) {
+        checkArrayTypes(msg, nonce, key);
+        checkLengths(key, nonce);
+        const m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
+        const c = new Uint8Array(m.length);
+        for (let i = 0; i < msg.length; i++)
+            m[i + crypto_secretbox_ZEROBYTES] = msg[i];
+        crypto_secretbox(c, m, m.length, nonce, key);
+        return c.subarray(crypto_secretbox_BOXZEROBYTES);
+    }
+    function naclSecretboxOpen(box, nonce, key) {
+        checkArrayTypes(box, nonce, key);
+        checkLengths(key, nonce);
+        const c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
+        const m = new Uint8Array(c.length);
+        for (let i = 0; i < box.length; i++)
+            c[i + crypto_secretbox_BOXZEROBYTES] = box[i];
+        if (c.length < 32)
+            return null;
+        if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0)
+            return null;
+        return m.subarray(crypto_secretbox_ZEROBYTES);
+    }
+
+    function naclDecrypt(encrypted, nonce, secret) {
+        return naclSecretboxOpen(encrypted, nonce, secret);
+    }
+
+    function naclEncrypt(message, secret, nonce = randomAsU8a(24)) {
+        return {
+            encrypted: naclSecretbox(message, nonce, secret),
+            nonce
+        };
+    }
+
+    function XorAndSalsa(prev, pi, input, ii, out, oi) {
+        let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
+        let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
+        let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
+        let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
+        let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
+        let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
+        let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
+        let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
+        let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+        for (let i = 0; i < 8; i += 2) {
+            x04 ^= rotl$1(x00 + x12 | 0, 7);
+            x08 ^= rotl$1(x04 + x00 | 0, 9);
+            x12 ^= rotl$1(x08 + x04 | 0, 13);
+            x00 ^= rotl$1(x12 + x08 | 0, 18);
+            x09 ^= rotl$1(x05 + x01 | 0, 7);
+            x13 ^= rotl$1(x09 + x05 | 0, 9);
+            x01 ^= rotl$1(x13 + x09 | 0, 13);
+            x05 ^= rotl$1(x01 + x13 | 0, 18);
+            x14 ^= rotl$1(x10 + x06 | 0, 7);
+            x02 ^= rotl$1(x14 + x10 | 0, 9);
+            x06 ^= rotl$1(x02 + x14 | 0, 13);
+            x10 ^= rotl$1(x06 + x02 | 0, 18);
+            x03 ^= rotl$1(x15 + x11 | 0, 7);
+            x07 ^= rotl$1(x03 + x15 | 0, 9);
+            x11 ^= rotl$1(x07 + x03 | 0, 13);
+            x15 ^= rotl$1(x11 + x07 | 0, 18);
+            x01 ^= rotl$1(x00 + x03 | 0, 7);
+            x02 ^= rotl$1(x01 + x00 | 0, 9);
+            x03 ^= rotl$1(x02 + x01 | 0, 13);
+            x00 ^= rotl$1(x03 + x02 | 0, 18);
+            x06 ^= rotl$1(x05 + x04 | 0, 7);
+            x07 ^= rotl$1(x06 + x05 | 0, 9);
+            x04 ^= rotl$1(x07 + x06 | 0, 13);
+            x05 ^= rotl$1(x04 + x07 | 0, 18);
+            x11 ^= rotl$1(x10 + x09 | 0, 7);
+            x08 ^= rotl$1(x11 + x10 | 0, 9);
+            x09 ^= rotl$1(x08 + x11 | 0, 13);
+            x10 ^= rotl$1(x09 + x08 | 0, 18);
+            x12 ^= rotl$1(x15 + x14 | 0, 7);
+            x13 ^= rotl$1(x12 + x15 | 0, 9);
+            x14 ^= rotl$1(x13 + x12 | 0, 13);
+            x15 ^= rotl$1(x14 + x13 | 0, 18);
+        }
+        out[oi++] = (y00 + x00) | 0;
+        out[oi++] = (y01 + x01) | 0;
+        out[oi++] = (y02 + x02) | 0;
+        out[oi++] = (y03 + x03) | 0;
+        out[oi++] = (y04 + x04) | 0;
+        out[oi++] = (y05 + x05) | 0;
+        out[oi++] = (y06 + x06) | 0;
+        out[oi++] = (y07 + x07) | 0;
+        out[oi++] = (y08 + x08) | 0;
+        out[oi++] = (y09 + x09) | 0;
+        out[oi++] = (y10 + x10) | 0;
+        out[oi++] = (y11 + x11) | 0;
+        out[oi++] = (y12 + x12) | 0;
+        out[oi++] = (y13 + x13) | 0;
+        out[oi++] = (y14 + x14) | 0;
+        out[oi++] = (y15 + x15) | 0;
+    }
+    function BlockMix(input, ii, out, oi, r) {
+        let head = oi + 0;
+        let tail = oi + 16 * r;
+        for (let i = 0; i < 16; i++)
+            out[tail + i] = input[ii + (2 * r - 1) * 16 + i];
+        for (let i = 0; i < r; i++, head += 16, ii += 16) {
+            XorAndSalsa(out, tail, input, ii, out, head);
+            if (i > 0)
+                tail += 16;
+            XorAndSalsa(out, head, input, (ii += 16), out, tail);
+        }
+    }
+    function scryptInit(password, salt, _opts) {
+        const opts = checkOpts({
+            dkLen: 32,
+            asyncTick: 10,
+            maxmem: 1024 ** 3 + 1024,
+        }, _opts);
+        const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
+        anumber(N);
+        anumber(r);
+        anumber(p);
+        anumber(dkLen);
+        anumber(asyncTick);
+        anumber(maxmem);
+        if (onProgress !== undefined && typeof onProgress !== 'function')
+            throw new Error('progressCb should be function');
+        const blockSize = 128 * r;
+        const blockSize32 = blockSize / 4;
+        const pow32 = Math.pow(2, 32);
+        if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32) {
+            throw new Error('Scrypt: N must be larger than 1, a power of 2, and less than 2^32');
+        }
+        if (p < 0 || p > ((pow32 - 1) * 32) / blockSize) {
+            throw new Error('Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)');
+        }
+        if (dkLen < 0 || dkLen > (pow32 - 1) * 32) {
+            throw new Error('Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32');
+        }
+        const memUsed = blockSize * (N + p);
+        if (memUsed > maxmem) {
+            throw new Error('Scrypt: memused is bigger than maxMem. Expected 128 * r * (N + p) > maxmem of ' + maxmem);
+        }
+        const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
+        const B32 = u32(B);
+        const V = u32(new Uint8Array(blockSize * N));
+        const tmp = u32(new Uint8Array(blockSize));
+        let blockMixCb = () => { };
+        if (onProgress) {
+            const totalBlockMix = 2 * N * p;
+            const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);
+            let blockMixCnt = 0;
+            blockMixCb = () => {
+                blockMixCnt++;
+                if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
+                    onProgress(blockMixCnt / totalBlockMix);
+            };
+        }
+        return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
+    }
+    function scryptOutput(password, dkLen, B, V, tmp) {
+        const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
+        clean(B, V, tmp);
+        return res;
+    }
+    function scrypt(password, salt, opts) {
+        const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
+        swap32IfBE(B32);
+        for (let pi = 0; pi < p; pi++) {
+            const Pi = blockSize32 * pi;
+            for (let i = 0; i < blockSize32; i++)
+                V[i] = B32[Pi + i];
+            for (let i = 0, pos = 0; i < N - 1; i++) {
+                BlockMix(V, pos, V, (pos += blockSize32), r);
+                blockMixCb();
+            }
+            BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
+            blockMixCb();
+            for (let i = 0; i < N; i++) {
+                const j = B32[Pi + blockSize32 - 16] % N;
+                for (let k = 0; k < blockSize32; k++)
+                    tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
+                BlockMix(tmp, 0, B32, Pi, r);
+                blockMixCb();
+            }
+        }
+        swap32IfBE(B32);
+        return scryptOutput(password, dkLen, B, V, tmp);
+    }
+
+    const ALLOWED_PARAMS = [
+        { N: 1 << 13, p: 10, r: 8 },
+        { N: 1 << 14, p: 5, r: 8 },
+        { N: 1 << 15, p: 3, r: 8 },
+        { N: 1 << 15, p: 1, r: 8 },
+        { N: 1 << 16, p: 2, r: 8 },
+        { N: 1 << 17, p: 1, r: 8 }
+    ];
+    const DEFAULT_PARAMS = {
+        N: 1 << 17,
+        p: 1,
+        r: 8
+    };
+
+    function scryptEncode(passphrase, salt = randomAsU8a(), params = DEFAULT_PARAMS, onlyJs) {
+        const u8a = util.u8aToU8a(passphrase);
+        return {
+            params,
+            password: !util.hasBigInt || (!onlyJs && isReady())
+                ? scrypt$1(u8a, salt, Math.log2(params.N), params.r, params.p)
+                : scrypt(u8a, salt, util.objectSpread({ dkLen: 64 }, params)),
+            salt
+        };
+    }
+
+    function scryptFromU8a(data) {
+        if (!(data instanceof Uint8Array)) {
+            throw new Error('Expected input to be a Uint8Array');
+        }
+        if (data.length < 32 + 12) {
+            throw new Error(`Invalid input length: expected 44 bytes, found ${data.length}`);
+        }
+        const salt = data.subarray(0, 32);
+        const N = util.u8aToBn(data.subarray(32, 36), BN_LE_OPTS).toNumber();
+        const p = util.u8aToBn(data.subarray(36, 40), BN_LE_OPTS).toNumber();
+        const r = util.u8aToBn(data.subarray(40, 44), BN_LE_OPTS).toNumber();
+        if (N > (1 << 20) || p > 4 || r > 16) {
+            throw new Error('Scrypt parameters exceed safe limits');
+        }
+        const isAllowed = ALLOWED_PARAMS.some((preset) => preset.N === N && preset.p === p && preset.r === r);
+        if (!isAllowed) {
+            throw new Error('Invalid injected scrypt params found');
+        }
+        return { params: { N, p, r }, salt };
+    }
+
+    function scryptToU8a(salt, { N, p, r }) {
+        return util.u8aConcat(salt, util.bnToU8a(N, BN_LE_32_OPTS), util.bnToU8a(p, BN_LE_32_OPTS), util.bnToU8a(r, BN_LE_32_OPTS));
+    }
+
+    const ENCODING = ['scrypt', 'xsalsa20-poly1305'];
+    const ENCODING_NONE = ['none'];
+    const ENCODING_VERSION = '3';
+    const NONCE_LENGTH = 24;
+    const SCRYPT_LENGTH = 32 + (3 * 4);
+
+    function jsonDecryptData(encrypted, passphrase, encType = ENCODING) {
+        if (!encrypted) {
+            throw new Error('No encrypted data available to decode');
+        }
+        else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
+            throw new Error('Password required to decode encrypted data');
+        }
+        let encoded = encrypted;
+        if (passphrase) {
+            let password;
+            if (encType.includes('scrypt')) {
+                const { params, salt } = scryptFromU8a(encrypted);
+                password = scryptEncode(passphrase, salt, params).password;
+                encrypted = encrypted.subarray(SCRYPT_LENGTH);
+            }
+            else {
+                password = util.stringToU8a(passphrase);
+            }
+            encoded = naclDecrypt(encrypted.subarray(NONCE_LENGTH), encrypted.subarray(0, NONCE_LENGTH), util.u8aFixLength(password, 256, true));
+        }
+        if (!encoded) {
+            throw new Error('Unable to decode using the supplied passphrase');
+        }
+        return encoded;
+    }
+
+    function jsonDecrypt({ encoded, encoding }, passphrase) {
+        if (!encoded) {
+            throw new Error('No encrypted data available to decode');
+        }
+        return jsonDecryptData(util.isHex(encoded)
+            ? util.hexToU8a(encoded)
+            : base64Decode(encoded), passphrase, Array.isArray(encoding.type)
+            ? encoding.type
+            : [encoding.type]);
+    }
+
+    function jsonEncryptFormat(encoded, contentType, isEncrypted) {
+        return {
+            encoded: base64Encode(encoded),
+            encoding: {
+                content: contentType,
+                type: isEncrypted
+                    ? ENCODING
+                    : ENCODING_NONE,
+                version: ENCODING_VERSION
+            }
+        };
+    }
+
+    function jsonEncrypt(data, contentType, passphrase) {
+        let isEncrypted = false;
+        let encoded = data;
+        if (passphrase) {
+            const { params, password, salt } = scryptEncode(passphrase);
+            const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
+            isEncrypted = true;
+            encoded = util.u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
+        }
+        return jsonEncryptFormat(encoded, contentType, isEncrypted);
+    }
+
+    const secp256k1VerifyHasher = (hashType) => (message, signature, publicKey) => secp256k1Verify(message, signature, publicKey, hashType, true);
+    const VERIFIERS_ECDSA = [
+        ['ecdsa', secp256k1VerifyHasher('blake2')],
+        ['ethereum', secp256k1VerifyHasher('keccak')]
+    ];
+    const VERIFIERS = [
+        ['ed25519', ed25519Verify],
+        ['sr25519', sr25519Verify]
+    ];
+    function verifyDetect(result, { message, publicKey, signature }, verifiers = [...VERIFIERS, ...VERIFIERS_ECDSA]) {
+        result.isValid = verifiers.some(([crypto, verify]) => {
+            try {
+                if (verify(message, signature, publicKey)) {
+                    result.crypto = crypto;
+                    return true;
+                }
+            }
+            catch {
+            }
+            return false;
+        });
+        return result;
+    }
+    function verifyMultisig(result, { message, publicKey, signature }) {
+        if (![0, 1, 2].includes(signature[0]) || ![65, 66].includes(signature.length)) {
+            throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+        }
+        if (signature.length === 66) {
+            result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS_ECDSA);
+        }
+        else {
+            result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS);
+            if (!result.isValid) {
+                result = verifyDetect(result, { message, publicKey, signature }, VERIFIERS_ECDSA);
+            }
+            if (!result.isValid) {
+                result.crypto = 'none';
+            }
+        }
+        return result;
+    }
+    function getVerifyFn(signature) {
+        return [0, 1, 2].includes(signature[0]) && [65, 66].includes(signature.length)
+            ? verifyMultisig
+            : verifyDetect;
+    }
+    function signatureVerify(message, signature, addressOrPublicKey) {
+        const signatureU8a = util.u8aToU8a(signature);
+        if (![64, 65, 66].includes(signatureU8a.length)) {
+            throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+        }
+        const publicKey = decodeAddress(addressOrPublicKey);
+        const input = { message: util.u8aToU8a(message), publicKey, signature: signatureU8a };
+        const result = { crypto: 'none', isValid: false, isWrapped: util.u8aIsWrapped(input.message, true), publicKey };
+        const isWrappedBytes = util.u8aIsWrapped(input.message, false);
+        const verifyFn = getVerifyFn(signatureU8a);
+        verifyFn(result, input);
+        if (result.crypto !== 'none' || (result.isWrapped && !isWrappedBytes)) {
+            return result;
+        }
+        input.message = isWrappedBytes
+            ? util.u8aUnwrapBytes(input.message)
+            : util.u8aWrapBytes(input.message);
+        return verifyFn(result, input);
+    }
+
+    const P64_1 = BigInt$1('11400714785074694791');
+    const P64_2 = BigInt$1('14029467366897019727');
+    const P64_3 = BigInt$1('1609587929392839161');
+    const P64_4 = BigInt$1('9650029242287828579');
+    const P64_5 = BigInt$1('2870177450012600261');
+    const U64 = BigInt$1('0xffffffffffffffff');
+    const _7n = BigInt$1(7);
+    const _11n = BigInt$1(11);
+    const _12n = BigInt$1(12);
+    const _16n = BigInt$1(16);
+    const _18n = BigInt$1(18);
+    const _23n = BigInt$1(23);
+    const _27n = BigInt$1(27);
+    const _29n = BigInt$1(29);
+    const _31n = BigInt$1(31);
+    const _32n = BigInt$1(32);
+    const _33n = BigInt$1(33);
+    const _64n = BigInt$1(64);
+    const _256n = BigInt$1(256);
+    function rotl(a, b) {
+        const c = a & U64;
+        return ((c << b) | (c >> (_64n - b))) & U64;
+    }
+    function fromU8a(u8a, p, count) {
+        const bigints = new Array(count);
+        let offset = 0;
+        for (let i = 0; i < count; i++, offset += 2) {
+            bigints[i] = BigInt$1(u8a[p + offset] | (u8a[p + 1 + offset] << 8));
+        }
+        let result = util._0n;
+        for (let i = count - 1; i >= 0; i--) {
+            result = (result << _16n) + bigints[i];
+        }
+        return result;
+    }
+    function init(seed, input) {
+        const state = {
+            seed,
+            u8a: new Uint8Array(32),
+            u8asize: 0,
+            v1: seed + P64_1 + P64_2,
+            v2: seed + P64_2,
+            v3: seed,
+            v4: seed - P64_1
+        };
+        if (input.length < 32) {
+            state.u8a.set(input);
+            state.u8asize = input.length;
+            return state;
+        }
+        const limit = input.length - 32;
+        let p = 0;
+        if (limit >= 0) {
+            const adjustV = (v) => P64_1 * rotl(v + P64_2 * fromU8a(input, p, 4), _31n);
+            do {
+                state.v1 = adjustV(state.v1);
+                p += 8;
+                state.v2 = adjustV(state.v2);
+                p += 8;
+                state.v3 = adjustV(state.v3);
+                p += 8;
+                state.v4 = adjustV(state.v4);
+                p += 8;
+            } while (p <= limit);
+        }
+        if (p < input.length) {
+            state.u8a.set(input.subarray(p, input.length));
+            state.u8asize = input.length - p;
+        }
+        return state;
+    }
+    function xxhash64(input, initSeed) {
+        const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(BigInt$1(initSeed), input);
+        let p = 0;
+        let h64 = U64 & (BigInt$1(input.length) + (input.length >= 32
+            ? (((((((((rotl(v1, util._1n) + rotl(v2, _7n) + rotl(v3, _12n) + rotl(v4, _18n)) ^ (P64_1 * rotl(v1 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v2 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v3 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v4 * P64_2, _31n))) * P64_1 + P64_4)
+            : (seed + P64_5)));
+        while (p <= (u8asize - 8)) {
+            h64 = U64 & (P64_4 + P64_1 * rotl(h64 ^ (P64_1 * rotl(P64_2 * fromU8a(u8a, p, 4), _31n)), _27n));
+            p += 8;
+        }
+        if ((p + 4) <= u8asize) {
+            h64 = U64 & (P64_3 + P64_2 * rotl(h64 ^ (P64_1 * fromU8a(u8a, p, 2)), _23n));
+            p += 4;
+        }
+        while (p < u8asize) {
+            h64 = U64 & (P64_1 * rotl(h64 ^ (P64_5 * BigInt$1(u8a[p++])), _11n));
+        }
+        h64 = U64 & (P64_2 * (h64 ^ (h64 >> _33n)));
+        h64 = U64 & (P64_3 * (h64 ^ (h64 >> _29n)));
+        h64 = U64 & (h64 ^ (h64 >> _32n));
+        const result = new Uint8Array(8);
+        for (let i = 7; i >= 0; i--) {
+            result[i] = Number(h64 % _256n);
+            h64 = h64 / _256n;
+        }
+        return result;
+    }
+
+    function xxhashAsU8a(data, bitLength = 64, onlyJs) {
+        const rounds = Math.ceil(bitLength / 64);
+        const u8a = util.u8aToU8a(data);
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            return twox(u8a, rounds);
+        }
+        const result = new Uint8Array(rounds * 8);
+        for (let seed = 0; seed < rounds; seed++) {
+            result.set(xxhash64(u8a, seed).reverse(), seed * 8);
+        }
+        return result;
+    }
+    const xxhashAsHex =  createAsHex(xxhashAsU8a);
+
+    exports.addressEq = addressEq;
+    exports.addressToEvm = addressToEvm;
+    exports.allNetworks = allNetworks;
+    exports.availableNetworks = availableNetworks;
+    exports.base32Decode = base32Decode;
+    exports.base32Encode = base32Encode;
+    exports.base32Validate = base32Validate;
+    exports.base58Decode = base58Decode;
+    exports.base58Encode = base58Encode;
+    exports.base58Validate = base58Validate;
+    exports.base64Decode = base64Decode;
+    exports.base64Encode = base64Encode;
+    exports.base64Pad = base64Pad;
+    exports.base64Trim = base64Trim;
+    exports.base64Validate = base64Validate;
+    exports.blake2AsHex = blake2AsHex;
+    exports.blake2AsU8a = blake2AsU8a;
+    exports.checkAddress = checkAddress;
+    exports.checkAddressChecksum = checkAddressChecksum;
+    exports.createKeyDerived = createKeyDerived;
+    exports.createKeyMulti = createKeyMulti;
+    exports.cryptoIsReady = cryptoIsReady;
+    exports.cryptoWaitReady = cryptoWaitReady;
+    exports.decodeAddress = decodeAddress;
+    exports.deriveAddress = deriveAddress;
+    exports.ed25519DeriveHard = ed25519DeriveHard;
+    exports.ed25519PairFromRandom = ed25519PairFromRandom;
+    exports.ed25519PairFromSecret = ed25519PairFromSecret;
+    exports.ed25519PairFromSeed = ed25519PairFromSeed;
+    exports.ed25519PairFromString = ed25519PairFromString;
+    exports.ed25519Sign = ed25519Sign;
+    exports.ed25519Verify = ed25519Verify;
+    exports.encodeAddress = encodeAddress;
+    exports.encodeDerivedAddress = encodeDerivedAddress;
+    exports.encodeMultiAddress = encodeMultiAddress;
+    exports.ethereumEncode = ethereumEncode;
+    exports.evmToAddress = evmToAddress;
+    exports.hdEthereum = hdEthereum;
+    exports.hdLedger = hdLedger;
+    exports.hdValidatePath = hdValidatePath;
+    exports.hmacSha256AsU8a = hmacSha256AsU8a;
+    exports.hmacSha512AsU8a = hmacSha512AsU8a;
+    exports.hmacShaAsU8a = hmacShaAsU8a;
+    exports.isAddress = isAddress;
+    exports.isBase32 = isBase32;
+    exports.isBase58 = isBase58;
+    exports.isBase64 = isBase64;
+    exports.isEthereumAddress = isEthereumAddress;
+    exports.isEthereumChecksum = isEthereumChecksum;
+    exports.jsonDecrypt = jsonDecrypt;
+    exports.jsonDecryptData = jsonDecryptData;
+    exports.jsonEncrypt = jsonEncrypt;
+    exports.jsonEncryptFormat = jsonEncryptFormat;
+    exports.keccak256AsU8a = keccak256AsU8a;
+    exports.keccak512AsU8a = keccak512AsU8a;
+    exports.keccakAsHex = keccakAsHex;
+    exports.keccakAsU8a = keccakAsU8a;
+    exports.keyExtractPath = keyExtractPath;
+    exports.keyExtractSuri = keyExtractSuri;
+    exports.keyFromPath = keyFromPath;
+    exports.keyHdkdEcdsa = keyHdkdEcdsa;
+    exports.keyHdkdEd25519 = keyHdkdEd25519;
+    exports.keyHdkdSr25519 = keyHdkdSr25519;
+    exports.mnemonicGenerate = mnemonicGenerate;
+    exports.mnemonicToEntropy = mnemonicToEntropy;
+    exports.mnemonicToLegacySeed = mnemonicToLegacySeed;
+    exports.mnemonicToMiniSecret = mnemonicToMiniSecret;
+    exports.mnemonicValidate = mnemonicValidate;
+    exports.naclDecrypt = naclDecrypt;
+    exports.naclEncrypt = naclEncrypt;
+    exports.packageInfo = packageInfo;
+    exports.pbkdf2Encode = pbkdf2Encode;
+    exports.randomAsHex = randomAsHex;
+    exports.randomAsNumber = randomAsNumber;
+    exports.randomAsU8a = randomAsU8a;
+    exports.scryptEncode = scryptEncode;
+    exports.scryptFromU8a = scryptFromU8a;
+    exports.scryptToU8a = scryptToU8a;
+    exports.secp256k1Compress = secp256k1Compress;
+    exports.secp256k1Expand = secp256k1Expand;
+    exports.secp256k1PairFromSeed = secp256k1PairFromSeed;
+    exports.secp256k1PrivateKeyTweakAdd = secp256k1PrivateKeyTweakAdd;
+    exports.secp256k1Recover = secp256k1Recover;
+    exports.secp256k1Sign = secp256k1Sign;
+    exports.secp256k1Verify = secp256k1Verify;
+    exports.selectableNetworks = selectableNetworks;
+    exports.setSS58Format = setSS58Format;
+    exports.sha256AsU8a = sha256AsU8a;
+    exports.sha512AsU8a = sha512AsU8a;
+    exports.shaAsU8a = shaAsU8a;
+    exports.signatureVerify = signatureVerify;
+    exports.sortAddresses = sortAddresses;
+    exports.sr25519Agreement = sr25519Agreement;
+    exports.sr25519DeriveHard = sr25519DeriveHard;
+    exports.sr25519DerivePublic = sr25519DerivePublic;
+    exports.sr25519DeriveSoft = sr25519DeriveSoft;
+    exports.sr25519PairFromSeed = sr25519PairFromSeed;
+    exports.sr25519Sign = sr25519Sign;
+    exports.sr25519Verify = sr25519Verify;
+    exports.sr25519VrfSign = sr25519VrfSign;
+    exports.sr25519VrfVerify = sr25519VrfVerify;
+    exports.validateAddress = validateAddress;
+    exports.xxhashAsHex = xxhashAsHex;
+    exports.xxhashAsU8a = xxhashAsU8a;
+
+}));
diff --git a/docs/root-signing/vendor/bundle-pezkuwi-util.js b/docs/root-signing/vendor/bundle-pezkuwi-util.js
new file mode 100644
index 0000000..6357ba7
--- /dev/null
+++ b/docs/root-signing/vendor/bundle-pezkuwi-util.js
@@ -0,0 +1,4863 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.pezkuwiUtil = {}));
+})(this, (function (exports) { 'use strict';
+
+    const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;
+
+    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+    const packageInfo$3 = { name: '@pezkuwi/util', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.26' };
+
+    function arrayChunk(array, chunkSize) {
+        const outputSize = Math.ceil(array.length / chunkSize);
+        if (outputSize === 1) {
+            return [array];
+        }
+        const output = Array(outputSize);
+        for (let i = 0; i < outputSize; i++) {
+            const offset = i * chunkSize;
+            output[i] = array.slice(offset, offset + chunkSize);
+        }
+        return output;
+    }
+
+    function arrayFilter(array, allowNulls = true) {
+        return array.filter((v) => v !== undefined &&
+            (allowNulls || v !== null));
+    }
+
+    function arrayFlatten(arrays) {
+        const num = arrays.length;
+        if (num === 0) {
+            return [];
+        }
+        else if (num === 1) {
+            return arrays[0];
+        }
+        let size = 0;
+        for (let i = 0; i < num; i++) {
+            size += arrays[i].length;
+        }
+        const output = new Array(size);
+        let i = -1;
+        for (let j = 0; j < num; j++) {
+            const a = arrays[j];
+            for (let e = 0, count = a.length; e < count; e++) {
+                output[++i] = a[e];
+            }
+        }
+        return output;
+    }
+
+    function arrayRange(size, startAt = 0) {
+        if (size <= 0) {
+            throw new Error('Expected non-zero, positive number as a range size');
+        }
+        const result = new Array(size);
+        for (let i = 0; i < size; i++) {
+            result[i] = i + startAt;
+        }
+        return result;
+    }
+
+    function arrayShuffle(input) {
+        const result = input.slice();
+        let curr = result.length;
+        if (curr === 1) {
+            return result;
+        }
+        while (curr !== 0) {
+            const rand = ~~(Math.random() * curr);
+            curr--;
+            [result[curr], result[rand]] = [result[rand], result[curr]];
+        }
+        return result;
+    }
+
+    function arrayUnzip(entries) {
+        const count = entries.length;
+        const keys = new Array(count);
+        const values = new Array(count);
+        for (let i = 0; i < count; i++) {
+            [keys[i], values[i]] = entries[i];
+        }
+        return [keys, values];
+    }
+
+    function arrayZip(keys, values) {
+        const count = keys.length;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
+            result[i] = [keys[i], values[i]];
+        }
+        return result;
+    }
+
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+
+    function assert(condition, message) {
+        if (!condition) {
+            throw new Error(isFunction(message)
+                ? message()
+                : message);
+        }
+    }
+    function assertReturn(value, message) {
+        assert(value !== undefined && value !== null, message);
+        return value;
+    }
+    function assertUnreachable(x) {
+        throw new Error(`This codepath should be unreachable. Unhandled input: ${x}`);
+    }
+
+    function createCmp(cmp) {
+        return (...items) => {
+            const count = items.length;
+            if (count === 0) {
+                throw new Error('Must provide one or more arguments');
+            }
+            let result = items[0];
+            for (let i = 1; i < count; i++) {
+                if (cmp(items[i], result)) {
+                    result = items[i];
+                }
+            }
+            return result;
+        };
+    }
+
+    const nMax =  createCmp((a, b) => a > b);
+    const nMin =  createCmp((a, b) => a < b);
+
+    const packageInfo$2 = { name: '@pezkuwi/x-global', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-pezkuwi-util.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.26' };
+
+    function evaluateThis(fn) {
+        return fn('return this');
+    }
+    const xglobal =  (typeof globalThis !== 'undefined'
+        ? globalThis
+        : typeof global !== 'undefined'
+            ? global
+            : typeof self !== 'undefined'
+                ? self
+                : typeof window !== 'undefined'
+                    ? window
+                    : evaluateThis(Function));
+    function extractGlobal(name, fallback) {
+        return typeof xglobal[name] === 'undefined'
+            ? fallback
+            : xglobal[name];
+    }
+    function exposeGlobal(name, fallback) {
+        if (typeof xglobal[name] === 'undefined') {
+            xglobal[name] = fallback;
+        }
+    }
+
+    const build = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exposeGlobal: exposeGlobal,
+        extractGlobal: extractGlobal,
+        packageInfo: packageInfo$2,
+        xglobal: xglobal
+    });
+
+    function invalidFallback() {
+        return Number.NaN;
+    }
+    const BigInt =  extractGlobal('BigInt', invalidFallback);
+
+    const _0n =  BigInt(0);
+    const _1n =  BigInt(1);
+    const _2n =  BigInt(2);
+    const _3n =  BigInt(3);
+    const _4n =  BigInt(4);
+    const _5n =  BigInt(5);
+    const _6n =  BigInt(6);
+    const _7n =  BigInt(7);
+    const _8n =  BigInt(8);
+    const _9n =  BigInt(9);
+    const _10n =  BigInt(10);
+    const _100n =  BigInt(100);
+    const _1000n =  BigInt(1_000);
+    const _1Mn =  BigInt(1_000_000);
+    const _1Bn =  BigInt(1_000_000_000);
+    const _1Qn = _1Bn * _1Bn;
+    const _2pow53n =  BigInt(Number.MAX_SAFE_INTEGER);
+    const _sqrt2pow53n =  BigInt(94906265);
+
+    const U8_MAX = BigInt(256);
+    const U16_MAX = BigInt(256 * 256);
+    const U64_MAX = BigInt('0x10000000000000000');
+    function u8aToBigInt(value, { isLe = true, isNegative = false } = {}) {
+        if (!isLe) {
+            value = value.slice().reverse();
+        }
+        const count = value.length;
+        if (isNegative && count && (value[count - 1] & 0x80)) {
+            switch (count) {
+                case 0:
+                    return BigInt(0);
+                case 1:
+                    return BigInt(((value[0] ^ 0x0000_00ff) * -1) - 1);
+                case 2:
+                    return BigInt((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+                case 4:
+                    return BigInt((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+            }
+            const dvI = new DataView(value.buffer, value.byteOffset);
+            if (count === 8) {
+                return dvI.getBigInt64(0, true);
+            }
+            let result = BigInt(0);
+            const mod = count % 2;
+            for (let i = count - 2; i >= mod; i -= 2) {
+                result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true) ^ 0xffff);
+            }
+            if (mod) {
+                result = (result * U8_MAX) + BigInt(value[0] ^ 0xff);
+            }
+            return (result * -_1n) - _1n;
+        }
+        switch (count) {
+            case 0:
+                return BigInt(0);
+            case 1:
+                return BigInt(value[0]);
+            case 2:
+                return BigInt(value[0] + (value[1] << 8));
+            case 4:
+                return BigInt(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+        }
+        const dvI = new DataView(value.buffer, value.byteOffset);
+        switch (count) {
+            case 8:
+                return dvI.getBigUint64(0, true);
+            case 16:
+                return (dvI.getBigUint64(8, true) * U64_MAX) + dvI.getBigUint64(0, true);
+            default: {
+                let result = BigInt(0);
+                const mod = count % 2;
+                for (let i = count - 2; i >= mod; i -= 2) {
+                    result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true));
+                }
+                if (mod) {
+                    result = (result * U8_MAX) + BigInt(value[0]);
+                }
+                return result;
+            }
+        }
+    }
+
+    const CHR = '0123456789abcdef';
+    const U8$1 = new Uint8Array(256);
+    const U16$1 = new Uint8Array(256 * 256);
+    for (let i = 0, count = CHR.length; i < count; i++) {
+        U8$1[CHR[i].charCodeAt(0) | 0] = i | 0;
+        if (i > 9) {
+            U8$1[CHR[i].toUpperCase().charCodeAt(0) | 0] = i | 0;
+        }
+    }
+    for (let i = 0; i < 256; i++) {
+        const s = i << 8;
+        for (let j = 0; j < 256; j++) {
+            U16$1[s | j] = (U8$1[i] << 4) | U8$1[j];
+        }
+    }
+    function hexToU8a(value, bitLength = -1) {
+        if (!value) {
+            return new Uint8Array();
+        }
+        let s = value.startsWith('0x')
+            ? 2
+            : 0;
+        const decLength = Math.ceil((value.length - s) / 2);
+        const endLength = Math.ceil(bitLength === -1
+            ? decLength
+            : bitLength / 8);
+        const result = new Uint8Array(endLength);
+        const offset = endLength > decLength
+            ? endLength - decLength
+            : 0;
+        for (let i = offset; i < endLength; i++, s += 2) {
+            result[i] = U16$1[(value.charCodeAt(s) << 8) | value.charCodeAt(s + 1)];
+        }
+        return result;
+    }
+
+    function hexToBigInt(value, { isLe = false, isNegative = false } = {}) {
+        return !value || value === '0x'
+            ? BigInt(0)
+            : u8aToBigInt(hexToU8a(value), { isLe, isNegative });
+    }
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    function getAugmentedNamespace(n) {
+      if (n.__esModule) return n;
+      var f = n.default;
+    	if (typeof f == "function") {
+    		var a = function a () {
+    			if (this instanceof a) {
+            return Reflect.construct(f, arguments, this.constructor);
+    			}
+    			return f.apply(this, arguments);
+    		};
+    		a.prototype = f.prototype;
+      } else a = {};
+      Object.defineProperty(a, '__esModule', {value: true});
+    	Object.keys(n).forEach(function (k) {
+    		var d = Object.getOwnPropertyDescriptor(n, k);
+    		Object.defineProperty(a, k, d.get ? d : {
+    			enumerable: true,
+    			get: function () {
+    				return n[k];
+    			}
+    		});
+    	});
+    	return a;
+    }
+
+    var bn = {exports: {}};
+
+    const _nodeResolve_empty = {};
+
+    const _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        default: _nodeResolve_empty
+    });
+
+    const require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
+
+    bn.exports;
+    (function (module) {
+    	(function (module, exports$1) {
+    	  function assert (val, msg) {
+    	    if (!val) throw new Error(msg || 'Assertion failed');
+    	  }
+    	  function inherits (ctor, superCtor) {
+    	    ctor.super_ = superCtor;
+    	    var TempCtor = function () {};
+    	    TempCtor.prototype = superCtor.prototype;
+    	    ctor.prototype = new TempCtor();
+    	    ctor.prototype.constructor = ctor;
+    	  }
+    	  function BN (number, base, endian) {
+    	    if (BN.isBN(number)) {
+    	      return number;
+    	    }
+    	    this.negative = 0;
+    	    this.words = null;
+    	    this.length = 0;
+    	    this.red = null;
+    	    if (number !== null) {
+    	      if (base === 'le' || base === 'be') {
+    	        endian = base;
+    	        base = 10;
+    	      }
+    	      this._init(number || 0, base || 10, endian || 'be');
+    	    }
+    	  }
+    	  if (typeof module === 'object') {
+    	    module.exports = BN;
+    	  } else {
+    	    exports$1.BN = BN;
+    	  }
+    	  BN.BN = BN;
+    	  BN.wordSize = 26;
+    	  var Buffer;
+    	  try {
+    	    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {
+    	      Buffer = window.Buffer;
+    	    } else {
+    	      Buffer = require$$0$1.Buffer;
+    	    }
+    	  } catch (e) {
+    	  }
+    	  BN.isBN = function isBN (num) {
+    	    if (num instanceof BN) {
+    	      return true;
+    	    }
+    	    return num !== null && typeof num === 'object' &&
+    	      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+    	  };
+    	  BN.max = function max (left, right) {
+    	    if (left.cmp(right) > 0) return left;
+    	    return right;
+    	  };
+    	  BN.min = function min (left, right) {
+    	    if (left.cmp(right) < 0) return left;
+    	    return right;
+    	  };
+    	  BN.prototype._init = function init (number, base, endian) {
+    	    if (typeof number === 'number') {
+    	      return this._initNumber(number, base, endian);
+    	    }
+    	    if (typeof number === 'object') {
+    	      return this._initArray(number, base, endian);
+    	    }
+    	    if (base === 'hex') {
+    	      base = 16;
+    	    }
+    	    assert(base === (base | 0) && base >= 2 && base <= 36);
+    	    number = number.toString().replace(/\s+/g, '');
+    	    var start = 0;
+    	    if (number[0] === '-') {
+    	      start++;
+    	      this.negative = 1;
+    	    }
+    	    if (start < number.length) {
+    	      if (base === 16) {
+    	        this._parseHex(number, start, endian);
+    	      } else {
+    	        this._parseBase(number, base, start);
+    	        if (endian === 'le') {
+    	          this._initArray(this.toArray(), base, endian);
+    	        }
+    	      }
+    	    }
+    	  };
+    	  BN.prototype._initNumber = function _initNumber (number, base, endian) {
+    	    if (number < 0) {
+    	      this.negative = 1;
+    	      number = -number;
+    	    }
+    	    if (number < 0x4000000) {
+    	      this.words = [number & 0x3ffffff];
+    	      this.length = 1;
+    	    } else if (number < 0x10000000000000) {
+    	      this.words = [
+    	        number & 0x3ffffff,
+    	        (number / 0x4000000) & 0x3ffffff
+    	      ];
+    	      this.length = 2;
+    	    } else {
+    	      assert(number < 0x20000000000000);
+    	      this.words = [
+    	        number & 0x3ffffff,
+    	        (number / 0x4000000) & 0x3ffffff,
+    	        1
+    	      ];
+    	      this.length = 3;
+    	    }
+    	    if (endian !== 'le') return;
+    	    this._initArray(this.toArray(), base, endian);
+    	  };
+    	  BN.prototype._initArray = function _initArray (number, base, endian) {
+    	    assert(typeof number.length === 'number');
+    	    if (number.length <= 0) {
+    	      this.words = [0];
+    	      this.length = 1;
+    	      return this;
+    	    }
+    	    this.length = Math.ceil(number.length / 3);
+    	    this.words = new Array(this.length);
+    	    for (var i = 0; i < this.length; i++) {
+    	      this.words[i] = 0;
+    	    }
+    	    var j, w;
+    	    var off = 0;
+    	    if (endian === 'be') {
+    	      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
+    	        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
+    	        this.words[j] |= (w << off) & 0x3ffffff;
+    	        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+    	        off += 24;
+    	        if (off >= 26) {
+    	          off -= 26;
+    	          j++;
+    	        }
+    	      }
+    	    } else if (endian === 'le') {
+    	      for (i = 0, j = 0; i < number.length; i += 3) {
+    	        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
+    	        this.words[j] |= (w << off) & 0x3ffffff;
+    	        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+    	        off += 24;
+    	        if (off >= 26) {
+    	          off -= 26;
+    	          j++;
+    	        }
+    	      }
+    	    }
+    	    return this._strip();
+    	  };
+    	  function parseHex4Bits (string, index) {
+    	    var c = string.charCodeAt(index);
+    	    if (c >= 48 && c <= 57) {
+    	      return c - 48;
+    	    } else if (c >= 65 && c <= 70) {
+    	      return c - 55;
+    	    } else if (c >= 97 && c <= 102) {
+    	      return c - 87;
+    	    } else {
+    	      assert(false, 'Invalid character in ' + string);
+    	    }
+    	  }
+    	  function parseHexByte (string, lowerBound, index) {
+    	    var r = parseHex4Bits(string, index);
+    	    if (index - 1 >= lowerBound) {
+    	      r |= parseHex4Bits(string, index - 1) << 4;
+    	    }
+    	    return r;
+    	  }
+    	  BN.prototype._parseHex = function _parseHex (number, start, endian) {
+    	    this.length = Math.ceil((number.length - start) / 6);
+    	    this.words = new Array(this.length);
+    	    for (var i = 0; i < this.length; i++) {
+    	      this.words[i] = 0;
+    	    }
+    	    var off = 0;
+    	    var j = 0;
+    	    var w;
+    	    if (endian === 'be') {
+    	      for (i = number.length - 1; i >= start; i -= 2) {
+    	        w = parseHexByte(number, start, i) << off;
+    	        this.words[j] |= w & 0x3ffffff;
+    	        if (off >= 18) {
+    	          off -= 18;
+    	          j += 1;
+    	          this.words[j] |= w >>> 26;
+    	        } else {
+    	          off += 8;
+    	        }
+    	      }
+    	    } else {
+    	      var parseLength = number.length - start;
+    	      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
+    	        w = parseHexByte(number, start, i) << off;
+    	        this.words[j] |= w & 0x3ffffff;
+    	        if (off >= 18) {
+    	          off -= 18;
+    	          j += 1;
+    	          this.words[j] |= w >>> 26;
+    	        } else {
+    	          off += 8;
+    	        }
+    	      }
+    	    }
+    	    this._strip();
+    	  };
+    	  function parseBase (str, start, end, mul) {
+    	    var r = 0;
+    	    var b = 0;
+    	    var len = Math.min(str.length, end);
+    	    for (var i = start; i < len; i++) {
+    	      var c = str.charCodeAt(i) - 48;
+    	      r *= mul;
+    	      if (c >= 49) {
+    	        b = c - 49 + 0xa;
+    	      } else if (c >= 17) {
+    	        b = c - 17 + 0xa;
+    	      } else {
+    	        b = c;
+    	      }
+    	      assert(c >= 0 && b < mul, 'Invalid character');
+    	      r += b;
+    	    }
+    	    return r;
+    	  }
+    	  BN.prototype._parseBase = function _parseBase (number, base, start) {
+    	    this.words = [0];
+    	    this.length = 1;
+    	    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
+    	      limbLen++;
+    	    }
+    	    limbLen--;
+    	    limbPow = (limbPow / base) | 0;
+    	    var total = number.length - start;
+    	    var mod = total % limbLen;
+    	    var end = Math.min(total, total - mod) + start;
+    	    var word = 0;
+    	    for (var i = start; i < end; i += limbLen) {
+    	      word = parseBase(number, i, i + limbLen, base);
+    	      this.imuln(limbPow);
+    	      if (this.words[0] + word < 0x4000000) {
+    	        this.words[0] += word;
+    	      } else {
+    	        this._iaddn(word);
+    	      }
+    	    }
+    	    if (mod !== 0) {
+    	      var pow = 1;
+    	      word = parseBase(number, i, number.length, base);
+    	      for (i = 0; i < mod; i++) {
+    	        pow *= base;
+    	      }
+    	      this.imuln(pow);
+    	      if (this.words[0] + word < 0x4000000) {
+    	        this.words[0] += word;
+    	      } else {
+    	        this._iaddn(word);
+    	      }
+    	    }
+    	    this._strip();
+    	  };
+    	  BN.prototype.copy = function copy (dest) {
+    	    dest.words = new Array(this.length);
+    	    for (var i = 0; i < this.length; i++) {
+    	      dest.words[i] = this.words[i];
+    	    }
+    	    dest.length = this.length;
+    	    dest.negative = this.negative;
+    	    dest.red = this.red;
+    	  };
+    	  function move (dest, src) {
+    	    dest.words = src.words;
+    	    dest.length = src.length;
+    	    dest.negative = src.negative;
+    	    dest.red = src.red;
+    	  }
+    	  BN.prototype._move = function _move (dest) {
+    	    move(dest, this);
+    	  };
+    	  BN.prototype.clone = function clone () {
+    	    var r = new BN(null);
+    	    this.copy(r);
+    	    return r;
+    	  };
+    	  BN.prototype._expand = function _expand (size) {
+    	    while (this.length < size) {
+    	      this.words[this.length++] = 0;
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype._strip = function strip () {
+    	    while (this.length > 1 && this.words[this.length - 1] === 0) {
+    	      this.length--;
+    	    }
+    	    return this._normSign();
+    	  };
+    	  BN.prototype._normSign = function _normSign () {
+    	    if (this.length === 1 && this.words[0] === 0) {
+    	      this.negative = 0;
+    	    }
+    	    return this;
+    	  };
+    	  if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {
+    	    try {
+    	      BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;
+    	    } catch (e) {
+    	      BN.prototype.inspect = inspect;
+    	    }
+    	  } else {
+    	    BN.prototype.inspect = inspect;
+    	  }
+    	  function inspect () {
+    	    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
+    	  }
+    	  var zeros = [
+    	    '',
+    	    '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'
+    	  ];
+    	  var groupSizes = [
+    	    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
+    	  ];
+    	  var groupBases = [
+    	    0, 0,
+    	    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
+    	    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
+    	    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
+    	    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
+    	    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
+    	  ];
+    	  BN.prototype.toString = function toString (base, padding) {
+    	    base = base || 10;
+    	    padding = padding | 0 || 1;
+    	    var out;
+    	    if (base === 16 || base === 'hex') {
+    	      out = '';
+    	      var off = 0;
+    	      var carry = 0;
+    	      for (var i = 0; i < this.length; i++) {
+    	        var w = this.words[i];
+    	        var word = (((w << off) | carry) & 0xffffff).toString(16);
+    	        carry = (w >>> (24 - off)) & 0xffffff;
+    	        off += 2;
+    	        if (off >= 26) {
+    	          off -= 26;
+    	          i--;
+    	        }
+    	        if (carry !== 0 || i !== this.length - 1) {
+    	          out = zeros[6 - word.length] + word + out;
+    	        } else {
+    	          out = word + out;
+    	        }
+    	      }
+    	      if (carry !== 0) {
+    	        out = carry.toString(16) + out;
+    	      }
+    	      while (out.length % padding !== 0) {
+    	        out = '0' + out;
+    	      }
+    	      if (this.negative !== 0) {
+    	        out = '-' + out;
+    	      }
+    	      return out;
+    	    }
+    	    if (base === (base | 0) && base >= 2 && base <= 36) {
+    	      var groupSize = groupSizes[base];
+    	      var groupBase = groupBases[base];
+    	      out = '';
+    	      var c = this.clone();
+    	      c.negative = 0;
+    	      while (!c.isZero()) {
+    	        var r = c.modrn(groupBase).toString(base);
+    	        c = c.idivn(groupBase);
+    	        if (!c.isZero()) {
+    	          out = zeros[groupSize - r.length] + r + out;
+    	        } else {
+    	          out = r + out;
+    	        }
+    	      }
+    	      if (this.isZero()) {
+    	        out = '0' + out;
+    	      }
+    	      while (out.length % padding !== 0) {
+    	        out = '0' + out;
+    	      }
+    	      if (this.negative !== 0) {
+    	        out = '-' + out;
+    	      }
+    	      return out;
+    	    }
+    	    assert(false, 'Base should be between 2 and 36');
+    	  };
+    	  BN.prototype.toNumber = function toNumber () {
+    	    var ret = this.words[0];
+    	    if (this.length === 2) {
+    	      ret += this.words[1] * 0x4000000;
+    	    } else if (this.length === 3 && this.words[2] === 0x01) {
+    	      ret += 0x10000000000000 + (this.words[1] * 0x4000000);
+    	    } else if (this.length > 2) {
+    	      assert(false, 'Number can only safely store up to 53 bits');
+    	    }
+    	    return (this.negative !== 0) ? -ret : ret;
+    	  };
+    	  BN.prototype.toJSON = function toJSON () {
+    	    return this.toString(16, 2);
+    	  };
+    	  if (Buffer) {
+    	    BN.prototype.toBuffer = function toBuffer (endian, length) {
+    	      return this.toArrayLike(Buffer, endian, length);
+    	    };
+    	  }
+    	  BN.prototype.toArray = function toArray (endian, length) {
+    	    return this.toArrayLike(Array, endian, length);
+    	  };
+    	  var allocate = function allocate (ArrayType, size) {
+    	    if (ArrayType.allocUnsafe) {
+    	      return ArrayType.allocUnsafe(size);
+    	    }
+    	    return new ArrayType(size);
+    	  };
+    	  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
+    	    this._strip();
+    	    var byteLength = this.byteLength();
+    	    var reqLength = length || Math.max(1, byteLength);
+    	    assert(byteLength <= reqLength, 'byte array longer than desired length');
+    	    assert(reqLength > 0, 'Requested array length <= 0');
+    	    var res = allocate(ArrayType, reqLength);
+    	    var postfix = endian === 'le' ? 'LE' : 'BE';
+    	    this['_toArrayLike' + postfix](res, byteLength);
+    	    return res;
+    	  };
+    	  BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {
+    	    var position = 0;
+    	    var carry = 0;
+    	    for (var i = 0, shift = 0; i < this.length; i++) {
+    	      var word = (this.words[i] << shift) | carry;
+    	      res[position++] = word & 0xff;
+    	      if (position < res.length) {
+    	        res[position++] = (word >> 8) & 0xff;
+    	      }
+    	      if (position < res.length) {
+    	        res[position++] = (word >> 16) & 0xff;
+    	      }
+    	      if (shift === 6) {
+    	        if (position < res.length) {
+    	          res[position++] = (word >> 24) & 0xff;
+    	        }
+    	        carry = 0;
+    	        shift = 0;
+    	      } else {
+    	        carry = word >>> 24;
+    	        shift += 2;
+    	      }
+    	    }
+    	    if (position < res.length) {
+    	      res[position++] = carry;
+    	      while (position < res.length) {
+    	        res[position++] = 0;
+    	      }
+    	    }
+    	  };
+    	  BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {
+    	    var position = res.length - 1;
+    	    var carry = 0;
+    	    for (var i = 0, shift = 0; i < this.length; i++) {
+    	      var word = (this.words[i] << shift) | carry;
+    	      res[position--] = word & 0xff;
+    	      if (position >= 0) {
+    	        res[position--] = (word >> 8) & 0xff;
+    	      }
+    	      if (position >= 0) {
+    	        res[position--] = (word >> 16) & 0xff;
+    	      }
+    	      if (shift === 6) {
+    	        if (position >= 0) {
+    	          res[position--] = (word >> 24) & 0xff;
+    	        }
+    	        carry = 0;
+    	        shift = 0;
+    	      } else {
+    	        carry = word >>> 24;
+    	        shift += 2;
+    	      }
+    	    }
+    	    if (position >= 0) {
+    	      res[position--] = carry;
+    	      while (position >= 0) {
+    	        res[position--] = 0;
+    	      }
+    	    }
+    	  };
+    	  if (Math.clz32) {
+    	    BN.prototype._countBits = function _countBits (w) {
+    	      return 32 - Math.clz32(w);
+    	    };
+    	  } else {
+    	    BN.prototype._countBits = function _countBits (w) {
+    	      var t = w;
+    	      var r = 0;
+    	      if (t >= 0x1000) {
+    	        r += 13;
+    	        t >>>= 13;
+    	      }
+    	      if (t >= 0x40) {
+    	        r += 7;
+    	        t >>>= 7;
+    	      }
+    	      if (t >= 0x8) {
+    	        r += 4;
+    	        t >>>= 4;
+    	      }
+    	      if (t >= 0x02) {
+    	        r += 2;
+    	        t >>>= 2;
+    	      }
+    	      return r + t;
+    	    };
+    	  }
+    	  BN.prototype._zeroBits = function _zeroBits (w) {
+    	    if (w === 0) return 26;
+    	    var t = w;
+    	    var r = 0;
+    	    if ((t & 0x1fff) === 0) {
+    	      r += 13;
+    	      t >>>= 13;
+    	    }
+    	    if ((t & 0x7f) === 0) {
+    	      r += 7;
+    	      t >>>= 7;
+    	    }
+    	    if ((t & 0xf) === 0) {
+    	      r += 4;
+    	      t >>>= 4;
+    	    }
+    	    if ((t & 0x3) === 0) {
+    	      r += 2;
+    	      t >>>= 2;
+    	    }
+    	    if ((t & 0x1) === 0) {
+    	      r++;
+    	    }
+    	    return r;
+    	  };
+    	  BN.prototype.bitLength = function bitLength () {
+    	    var w = this.words[this.length - 1];
+    	    var hi = this._countBits(w);
+    	    return (this.length - 1) * 26 + hi;
+    	  };
+    	  function toBitArray (num) {
+    	    var w = new Array(num.bitLength());
+    	    for (var bit = 0; bit < w.length; bit++) {
+    	      var off = (bit / 26) | 0;
+    	      var wbit = bit % 26;
+    	      w[bit] = (num.words[off] >>> wbit) & 0x01;
+    	    }
+    	    return w;
+    	  }
+    	  BN.prototype.zeroBits = function zeroBits () {
+    	    if (this.isZero()) return 0;
+    	    var r = 0;
+    	    for (var i = 0; i < this.length; i++) {
+    	      var b = this._zeroBits(this.words[i]);
+    	      r += b;
+    	      if (b !== 26) break;
+    	    }
+    	    return r;
+    	  };
+    	  BN.prototype.byteLength = function byteLength () {
+    	    return Math.ceil(this.bitLength() / 8);
+    	  };
+    	  BN.prototype.toTwos = function toTwos (width) {
+    	    if (this.negative !== 0) {
+    	      return this.abs().inotn(width).iaddn(1);
+    	    }
+    	    return this.clone();
+    	  };
+    	  BN.prototype.fromTwos = function fromTwos (width) {
+    	    if (this.testn(width - 1)) {
+    	      return this.notn(width).iaddn(1).ineg();
+    	    }
+    	    return this.clone();
+    	  };
+    	  BN.prototype.isNeg = function isNeg () {
+    	    return this.negative !== 0;
+    	  };
+    	  BN.prototype.neg = function neg () {
+    	    return this.clone().ineg();
+    	  };
+    	  BN.prototype.ineg = function ineg () {
+    	    if (!this.isZero()) {
+    	      this.negative ^= 1;
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype.iuor = function iuor (num) {
+    	    while (this.length < num.length) {
+    	      this.words[this.length++] = 0;
+    	    }
+    	    for (var i = 0; i < num.length; i++) {
+    	      this.words[i] = this.words[i] | num.words[i];
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ior = function ior (num) {
+    	    assert((this.negative | num.negative) === 0);
+    	    return this.iuor(num);
+    	  };
+    	  BN.prototype.or = function or (num) {
+    	    if (this.length > num.length) return this.clone().ior(num);
+    	    return num.clone().ior(this);
+    	  };
+    	  BN.prototype.uor = function uor (num) {
+    	    if (this.length > num.length) return this.clone().iuor(num);
+    	    return num.clone().iuor(this);
+    	  };
+    	  BN.prototype.iuand = function iuand (num) {
+    	    var b;
+    	    if (this.length > num.length) {
+    	      b = num;
+    	    } else {
+    	      b = this;
+    	    }
+    	    for (var i = 0; i < b.length; i++) {
+    	      this.words[i] = this.words[i] & num.words[i];
+    	    }
+    	    this.length = b.length;
+    	    return this._strip();
+    	  };
+    	  BN.prototype.iand = function iand (num) {
+    	    assert((this.negative | num.negative) === 0);
+    	    return this.iuand(num);
+    	  };
+    	  BN.prototype.and = function and (num) {
+    	    if (this.length > num.length) return this.clone().iand(num);
+    	    return num.clone().iand(this);
+    	  };
+    	  BN.prototype.uand = function uand (num) {
+    	    if (this.length > num.length) return this.clone().iuand(num);
+    	    return num.clone().iuand(this);
+    	  };
+    	  BN.prototype.iuxor = function iuxor (num) {
+    	    var a;
+    	    var b;
+    	    if (this.length > num.length) {
+    	      a = this;
+    	      b = num;
+    	    } else {
+    	      a = num;
+    	      b = this;
+    	    }
+    	    for (var i = 0; i < b.length; i++) {
+    	      this.words[i] = a.words[i] ^ b.words[i];
+    	    }
+    	    if (this !== a) {
+    	      for (; i < a.length; i++) {
+    	        this.words[i] = a.words[i];
+    	      }
+    	    }
+    	    this.length = a.length;
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ixor = function ixor (num) {
+    	    assert((this.negative | num.negative) === 0);
+    	    return this.iuxor(num);
+    	  };
+    	  BN.prototype.xor = function xor (num) {
+    	    if (this.length > num.length) return this.clone().ixor(num);
+    	    return num.clone().ixor(this);
+    	  };
+    	  BN.prototype.uxor = function uxor (num) {
+    	    if (this.length > num.length) return this.clone().iuxor(num);
+    	    return num.clone().iuxor(this);
+    	  };
+    	  BN.prototype.inotn = function inotn (width) {
+    	    assert(typeof width === 'number' && width >= 0);
+    	    var bytesNeeded = Math.ceil(width / 26) | 0;
+    	    var bitsLeft = width % 26;
+    	    this._expand(bytesNeeded);
+    	    if (bitsLeft > 0) {
+    	      bytesNeeded--;
+    	    }
+    	    for (var i = 0; i < bytesNeeded; i++) {
+    	      this.words[i] = ~this.words[i] & 0x3ffffff;
+    	    }
+    	    if (bitsLeft > 0) {
+    	      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.notn = function notn (width) {
+    	    return this.clone().inotn(width);
+    	  };
+    	  BN.prototype.setn = function setn (bit, val) {
+    	    assert(typeof bit === 'number' && bit >= 0);
+    	    var off = (bit / 26) | 0;
+    	    var wbit = bit % 26;
+    	    this._expand(off + 1);
+    	    if (val) {
+    	      this.words[off] = this.words[off] | (1 << wbit);
+    	    } else {
+    	      this.words[off] = this.words[off] & ~(1 << wbit);
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.iadd = function iadd (num) {
+    	    var r;
+    	    if (this.negative !== 0 && num.negative === 0) {
+    	      this.negative = 0;
+    	      r = this.isub(num);
+    	      this.negative ^= 1;
+    	      return this._normSign();
+    	    } else if (this.negative === 0 && num.negative !== 0) {
+    	      num.negative = 0;
+    	      r = this.isub(num);
+    	      num.negative = 1;
+    	      return r._normSign();
+    	    }
+    	    var a, b;
+    	    if (this.length > num.length) {
+    	      a = this;
+    	      b = num;
+    	    } else {
+    	      a = num;
+    	      b = this;
+    	    }
+    	    var carry = 0;
+    	    for (var i = 0; i < b.length; i++) {
+    	      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
+    	      this.words[i] = r & 0x3ffffff;
+    	      carry = r >>> 26;
+    	    }
+    	    for (; carry !== 0 && i < a.length; i++) {
+    	      r = (a.words[i] | 0) + carry;
+    	      this.words[i] = r & 0x3ffffff;
+    	      carry = r >>> 26;
+    	    }
+    	    this.length = a.length;
+    	    if (carry !== 0) {
+    	      this.words[this.length] = carry;
+    	      this.length++;
+    	    } else if (a !== this) {
+    	      for (; i < a.length; i++) {
+    	        this.words[i] = a.words[i];
+    	      }
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype.add = function add (num) {
+    	    var res;
+    	    if (num.negative !== 0 && this.negative === 0) {
+    	      num.negative = 0;
+    	      res = this.sub(num);
+    	      num.negative ^= 1;
+    	      return res;
+    	    } else if (num.negative === 0 && this.negative !== 0) {
+    	      this.negative = 0;
+    	      res = num.sub(this);
+    	      this.negative = 1;
+    	      return res;
+    	    }
+    	    if (this.length > num.length) return this.clone().iadd(num);
+    	    return num.clone().iadd(this);
+    	  };
+    	  BN.prototype.isub = function isub (num) {
+    	    if (num.negative !== 0) {
+    	      num.negative = 0;
+    	      var r = this.iadd(num);
+    	      num.negative = 1;
+    	      return r._normSign();
+    	    } else if (this.negative !== 0) {
+    	      this.negative = 0;
+    	      this.iadd(num);
+    	      this.negative = 1;
+    	      return this._normSign();
+    	    }
+    	    var cmp = this.cmp(num);
+    	    if (cmp === 0) {
+    	      this.negative = 0;
+    	      this.length = 1;
+    	      this.words[0] = 0;
+    	      return this;
+    	    }
+    	    var a, b;
+    	    if (cmp > 0) {
+    	      a = this;
+    	      b = num;
+    	    } else {
+    	      a = num;
+    	      b = this;
+    	    }
+    	    var carry = 0;
+    	    for (var i = 0; i < b.length; i++) {
+    	      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
+    	      carry = r >> 26;
+    	      this.words[i] = r & 0x3ffffff;
+    	    }
+    	    for (; carry !== 0 && i < a.length; i++) {
+    	      r = (a.words[i] | 0) + carry;
+    	      carry = r >> 26;
+    	      this.words[i] = r & 0x3ffffff;
+    	    }
+    	    if (carry === 0 && i < a.length && a !== this) {
+    	      for (; i < a.length; i++) {
+    	        this.words[i] = a.words[i];
+    	      }
+    	    }
+    	    this.length = Math.max(this.length, i);
+    	    if (a !== this) {
+    	      this.negative = 1;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.sub = function sub (num) {
+    	    return this.clone().isub(num);
+    	  };
+    	  function smallMulTo (self, num, out) {
+    	    out.negative = num.negative ^ self.negative;
+    	    var len = (self.length + num.length) | 0;
+    	    out.length = len;
+    	    len = (len - 1) | 0;
+    	    var a = self.words[0] | 0;
+    	    var b = num.words[0] | 0;
+    	    var r = a * b;
+    	    var lo = r & 0x3ffffff;
+    	    var carry = (r / 0x4000000) | 0;
+    	    out.words[0] = lo;
+    	    for (var k = 1; k < len; k++) {
+    	      var ncarry = carry >>> 26;
+    	      var rword = carry & 0x3ffffff;
+    	      var maxJ = Math.min(k, num.length - 1);
+    	      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+    	        var i = (k - j) | 0;
+    	        a = self.words[i] | 0;
+    	        b = num.words[j] | 0;
+    	        r = a * b + rword;
+    	        ncarry += (r / 0x4000000) | 0;
+    	        rword = r & 0x3ffffff;
+    	      }
+    	      out.words[k] = rword | 0;
+    	      carry = ncarry | 0;
+    	    }
+    	    if (carry !== 0) {
+    	      out.words[k] = carry | 0;
+    	    } else {
+    	      out.length--;
+    	    }
+    	    return out._strip();
+    	  }
+    	  var comb10MulTo = function comb10MulTo (self, num, out) {
+    	    var a = self.words;
+    	    var b = num.words;
+    	    var o = out.words;
+    	    var c = 0;
+    	    var lo;
+    	    var mid;
+    	    var hi;
+    	    var a0 = a[0] | 0;
+    	    var al0 = a0 & 0x1fff;
+    	    var ah0 = a0 >>> 13;
+    	    var a1 = a[1] | 0;
+    	    var al1 = a1 & 0x1fff;
+    	    var ah1 = a1 >>> 13;
+    	    var a2 = a[2] | 0;
+    	    var al2 = a2 & 0x1fff;
+    	    var ah2 = a2 >>> 13;
+    	    var a3 = a[3] | 0;
+    	    var al3 = a3 & 0x1fff;
+    	    var ah3 = a3 >>> 13;
+    	    var a4 = a[4] | 0;
+    	    var al4 = a4 & 0x1fff;
+    	    var ah4 = a4 >>> 13;
+    	    var a5 = a[5] | 0;
+    	    var al5 = a5 & 0x1fff;
+    	    var ah5 = a5 >>> 13;
+    	    var a6 = a[6] | 0;
+    	    var al6 = a6 & 0x1fff;
+    	    var ah6 = a6 >>> 13;
+    	    var a7 = a[7] | 0;
+    	    var al7 = a7 & 0x1fff;
+    	    var ah7 = a7 >>> 13;
+    	    var a8 = a[8] | 0;
+    	    var al8 = a8 & 0x1fff;
+    	    var ah8 = a8 >>> 13;
+    	    var a9 = a[9] | 0;
+    	    var al9 = a9 & 0x1fff;
+    	    var ah9 = a9 >>> 13;
+    	    var b0 = b[0] | 0;
+    	    var bl0 = b0 & 0x1fff;
+    	    var bh0 = b0 >>> 13;
+    	    var b1 = b[1] | 0;
+    	    var bl1 = b1 & 0x1fff;
+    	    var bh1 = b1 >>> 13;
+    	    var b2 = b[2] | 0;
+    	    var bl2 = b2 & 0x1fff;
+    	    var bh2 = b2 >>> 13;
+    	    var b3 = b[3] | 0;
+    	    var bl3 = b3 & 0x1fff;
+    	    var bh3 = b3 >>> 13;
+    	    var b4 = b[4] | 0;
+    	    var bl4 = b4 & 0x1fff;
+    	    var bh4 = b4 >>> 13;
+    	    var b5 = b[5] | 0;
+    	    var bl5 = b5 & 0x1fff;
+    	    var bh5 = b5 >>> 13;
+    	    var b6 = b[6] | 0;
+    	    var bl6 = b6 & 0x1fff;
+    	    var bh6 = b6 >>> 13;
+    	    var b7 = b[7] | 0;
+    	    var bl7 = b7 & 0x1fff;
+    	    var bh7 = b7 >>> 13;
+    	    var b8 = b[8] | 0;
+    	    var bl8 = b8 & 0x1fff;
+    	    var bh8 = b8 >>> 13;
+    	    var b9 = b[9] | 0;
+    	    var bl9 = b9 & 0x1fff;
+    	    var bh9 = b9 >>> 13;
+    	    out.negative = self.negative ^ num.negative;
+    	    out.length = 19;
+    	    lo = Math.imul(al0, bl0);
+    	    mid = Math.imul(al0, bh0);
+    	    mid = (mid + Math.imul(ah0, bl0)) | 0;
+    	    hi = Math.imul(ah0, bh0);
+    	    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
+    	    w0 &= 0x3ffffff;
+    	    lo = Math.imul(al1, bl0);
+    	    mid = Math.imul(al1, bh0);
+    	    mid = (mid + Math.imul(ah1, bl0)) | 0;
+    	    hi = Math.imul(ah1, bh0);
+    	    lo = (lo + Math.imul(al0, bl1)) | 0;
+    	    mid = (mid + Math.imul(al0, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh1)) | 0;
+    	    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
+    	    w1 &= 0x3ffffff;
+    	    lo = Math.imul(al2, bl0);
+    	    mid = Math.imul(al2, bh0);
+    	    mid = (mid + Math.imul(ah2, bl0)) | 0;
+    	    hi = Math.imul(ah2, bh0);
+    	    lo = (lo + Math.imul(al1, bl1)) | 0;
+    	    mid = (mid + Math.imul(al1, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh1)) | 0;
+    	    lo = (lo + Math.imul(al0, bl2)) | 0;
+    	    mid = (mid + Math.imul(al0, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh2)) | 0;
+    	    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
+    	    w2 &= 0x3ffffff;
+    	    lo = Math.imul(al3, bl0);
+    	    mid = Math.imul(al3, bh0);
+    	    mid = (mid + Math.imul(ah3, bl0)) | 0;
+    	    hi = Math.imul(ah3, bh0);
+    	    lo = (lo + Math.imul(al2, bl1)) | 0;
+    	    mid = (mid + Math.imul(al2, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh1)) | 0;
+    	    lo = (lo + Math.imul(al1, bl2)) | 0;
+    	    mid = (mid + Math.imul(al1, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh2)) | 0;
+    	    lo = (lo + Math.imul(al0, bl3)) | 0;
+    	    mid = (mid + Math.imul(al0, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh3)) | 0;
+    	    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
+    	    w3 &= 0x3ffffff;
+    	    lo = Math.imul(al4, bl0);
+    	    mid = Math.imul(al4, bh0);
+    	    mid = (mid + Math.imul(ah4, bl0)) | 0;
+    	    hi = Math.imul(ah4, bh0);
+    	    lo = (lo + Math.imul(al3, bl1)) | 0;
+    	    mid = (mid + Math.imul(al3, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh1)) | 0;
+    	    lo = (lo + Math.imul(al2, bl2)) | 0;
+    	    mid = (mid + Math.imul(al2, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh2)) | 0;
+    	    lo = (lo + Math.imul(al1, bl3)) | 0;
+    	    mid = (mid + Math.imul(al1, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh3)) | 0;
+    	    lo = (lo + Math.imul(al0, bl4)) | 0;
+    	    mid = (mid + Math.imul(al0, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh4)) | 0;
+    	    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
+    	    w4 &= 0x3ffffff;
+    	    lo = Math.imul(al5, bl0);
+    	    mid = Math.imul(al5, bh0);
+    	    mid = (mid + Math.imul(ah5, bl0)) | 0;
+    	    hi = Math.imul(ah5, bh0);
+    	    lo = (lo + Math.imul(al4, bl1)) | 0;
+    	    mid = (mid + Math.imul(al4, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh1)) | 0;
+    	    lo = (lo + Math.imul(al3, bl2)) | 0;
+    	    mid = (mid + Math.imul(al3, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh2)) | 0;
+    	    lo = (lo + Math.imul(al2, bl3)) | 0;
+    	    mid = (mid + Math.imul(al2, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh3)) | 0;
+    	    lo = (lo + Math.imul(al1, bl4)) | 0;
+    	    mid = (mid + Math.imul(al1, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh4)) | 0;
+    	    lo = (lo + Math.imul(al0, bl5)) | 0;
+    	    mid = (mid + Math.imul(al0, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh5)) | 0;
+    	    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
+    	    w5 &= 0x3ffffff;
+    	    lo = Math.imul(al6, bl0);
+    	    mid = Math.imul(al6, bh0);
+    	    mid = (mid + Math.imul(ah6, bl0)) | 0;
+    	    hi = Math.imul(ah6, bh0);
+    	    lo = (lo + Math.imul(al5, bl1)) | 0;
+    	    mid = (mid + Math.imul(al5, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh1)) | 0;
+    	    lo = (lo + Math.imul(al4, bl2)) | 0;
+    	    mid = (mid + Math.imul(al4, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh2)) | 0;
+    	    lo = (lo + Math.imul(al3, bl3)) | 0;
+    	    mid = (mid + Math.imul(al3, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh3)) | 0;
+    	    lo = (lo + Math.imul(al2, bl4)) | 0;
+    	    mid = (mid + Math.imul(al2, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh4)) | 0;
+    	    lo = (lo + Math.imul(al1, bl5)) | 0;
+    	    mid = (mid + Math.imul(al1, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh5)) | 0;
+    	    lo = (lo + Math.imul(al0, bl6)) | 0;
+    	    mid = (mid + Math.imul(al0, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh6)) | 0;
+    	    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
+    	    w6 &= 0x3ffffff;
+    	    lo = Math.imul(al7, bl0);
+    	    mid = Math.imul(al7, bh0);
+    	    mid = (mid + Math.imul(ah7, bl0)) | 0;
+    	    hi = Math.imul(ah7, bh0);
+    	    lo = (lo + Math.imul(al6, bl1)) | 0;
+    	    mid = (mid + Math.imul(al6, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh1)) | 0;
+    	    lo = (lo + Math.imul(al5, bl2)) | 0;
+    	    mid = (mid + Math.imul(al5, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh2)) | 0;
+    	    lo = (lo + Math.imul(al4, bl3)) | 0;
+    	    mid = (mid + Math.imul(al4, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh3)) | 0;
+    	    lo = (lo + Math.imul(al3, bl4)) | 0;
+    	    mid = (mid + Math.imul(al3, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh4)) | 0;
+    	    lo = (lo + Math.imul(al2, bl5)) | 0;
+    	    mid = (mid + Math.imul(al2, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh5)) | 0;
+    	    lo = (lo + Math.imul(al1, bl6)) | 0;
+    	    mid = (mid + Math.imul(al1, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh6)) | 0;
+    	    lo = (lo + Math.imul(al0, bl7)) | 0;
+    	    mid = (mid + Math.imul(al0, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh7)) | 0;
+    	    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
+    	    w7 &= 0x3ffffff;
+    	    lo = Math.imul(al8, bl0);
+    	    mid = Math.imul(al8, bh0);
+    	    mid = (mid + Math.imul(ah8, bl0)) | 0;
+    	    hi = Math.imul(ah8, bh0);
+    	    lo = (lo + Math.imul(al7, bl1)) | 0;
+    	    mid = (mid + Math.imul(al7, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh1)) | 0;
+    	    lo = (lo + Math.imul(al6, bl2)) | 0;
+    	    mid = (mid + Math.imul(al6, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh2)) | 0;
+    	    lo = (lo + Math.imul(al5, bl3)) | 0;
+    	    mid = (mid + Math.imul(al5, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh3)) | 0;
+    	    lo = (lo + Math.imul(al4, bl4)) | 0;
+    	    mid = (mid + Math.imul(al4, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh4)) | 0;
+    	    lo = (lo + Math.imul(al3, bl5)) | 0;
+    	    mid = (mid + Math.imul(al3, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh5)) | 0;
+    	    lo = (lo + Math.imul(al2, bl6)) | 0;
+    	    mid = (mid + Math.imul(al2, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh6)) | 0;
+    	    lo = (lo + Math.imul(al1, bl7)) | 0;
+    	    mid = (mid + Math.imul(al1, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh7)) | 0;
+    	    lo = (lo + Math.imul(al0, bl8)) | 0;
+    	    mid = (mid + Math.imul(al0, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh8)) | 0;
+    	    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
+    	    w8 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl0);
+    	    mid = Math.imul(al9, bh0);
+    	    mid = (mid + Math.imul(ah9, bl0)) | 0;
+    	    hi = Math.imul(ah9, bh0);
+    	    lo = (lo + Math.imul(al8, bl1)) | 0;
+    	    mid = (mid + Math.imul(al8, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh1)) | 0;
+    	    lo = (lo + Math.imul(al7, bl2)) | 0;
+    	    mid = (mid + Math.imul(al7, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh2)) | 0;
+    	    lo = (lo + Math.imul(al6, bl3)) | 0;
+    	    mid = (mid + Math.imul(al6, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh3)) | 0;
+    	    lo = (lo + Math.imul(al5, bl4)) | 0;
+    	    mid = (mid + Math.imul(al5, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh4)) | 0;
+    	    lo = (lo + Math.imul(al4, bl5)) | 0;
+    	    mid = (mid + Math.imul(al4, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh5)) | 0;
+    	    lo = (lo + Math.imul(al3, bl6)) | 0;
+    	    mid = (mid + Math.imul(al3, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh6)) | 0;
+    	    lo = (lo + Math.imul(al2, bl7)) | 0;
+    	    mid = (mid + Math.imul(al2, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh7)) | 0;
+    	    lo = (lo + Math.imul(al1, bl8)) | 0;
+    	    mid = (mid + Math.imul(al1, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh8)) | 0;
+    	    lo = (lo + Math.imul(al0, bl9)) | 0;
+    	    mid = (mid + Math.imul(al0, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh9)) | 0;
+    	    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
+    	    w9 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl1);
+    	    mid = Math.imul(al9, bh1);
+    	    mid = (mid + Math.imul(ah9, bl1)) | 0;
+    	    hi = Math.imul(ah9, bh1);
+    	    lo = (lo + Math.imul(al8, bl2)) | 0;
+    	    mid = (mid + Math.imul(al8, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh2)) | 0;
+    	    lo = (lo + Math.imul(al7, bl3)) | 0;
+    	    mid = (mid + Math.imul(al7, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh3)) | 0;
+    	    lo = (lo + Math.imul(al6, bl4)) | 0;
+    	    mid = (mid + Math.imul(al6, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh4)) | 0;
+    	    lo = (lo + Math.imul(al5, bl5)) | 0;
+    	    mid = (mid + Math.imul(al5, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh5)) | 0;
+    	    lo = (lo + Math.imul(al4, bl6)) | 0;
+    	    mid = (mid + Math.imul(al4, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh6)) | 0;
+    	    lo = (lo + Math.imul(al3, bl7)) | 0;
+    	    mid = (mid + Math.imul(al3, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh7)) | 0;
+    	    lo = (lo + Math.imul(al2, bl8)) | 0;
+    	    mid = (mid + Math.imul(al2, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh8)) | 0;
+    	    lo = (lo + Math.imul(al1, bl9)) | 0;
+    	    mid = (mid + Math.imul(al1, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh9)) | 0;
+    	    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
+    	    w10 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl2);
+    	    mid = Math.imul(al9, bh2);
+    	    mid = (mid + Math.imul(ah9, bl2)) | 0;
+    	    hi = Math.imul(ah9, bh2);
+    	    lo = (lo + Math.imul(al8, bl3)) | 0;
+    	    mid = (mid + Math.imul(al8, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh3)) | 0;
+    	    lo = (lo + Math.imul(al7, bl4)) | 0;
+    	    mid = (mid + Math.imul(al7, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh4)) | 0;
+    	    lo = (lo + Math.imul(al6, bl5)) | 0;
+    	    mid = (mid + Math.imul(al6, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh5)) | 0;
+    	    lo = (lo + Math.imul(al5, bl6)) | 0;
+    	    mid = (mid + Math.imul(al5, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh6)) | 0;
+    	    lo = (lo + Math.imul(al4, bl7)) | 0;
+    	    mid = (mid + Math.imul(al4, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh7)) | 0;
+    	    lo = (lo + Math.imul(al3, bl8)) | 0;
+    	    mid = (mid + Math.imul(al3, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh8)) | 0;
+    	    lo = (lo + Math.imul(al2, bl9)) | 0;
+    	    mid = (mid + Math.imul(al2, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh9)) | 0;
+    	    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
+    	    w11 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl3);
+    	    mid = Math.imul(al9, bh3);
+    	    mid = (mid + Math.imul(ah9, bl3)) | 0;
+    	    hi = Math.imul(ah9, bh3);
+    	    lo = (lo + Math.imul(al8, bl4)) | 0;
+    	    mid = (mid + Math.imul(al8, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh4)) | 0;
+    	    lo = (lo + Math.imul(al7, bl5)) | 0;
+    	    mid = (mid + Math.imul(al7, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh5)) | 0;
+    	    lo = (lo + Math.imul(al6, bl6)) | 0;
+    	    mid = (mid + Math.imul(al6, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh6)) | 0;
+    	    lo = (lo + Math.imul(al5, bl7)) | 0;
+    	    mid = (mid + Math.imul(al5, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh7)) | 0;
+    	    lo = (lo + Math.imul(al4, bl8)) | 0;
+    	    mid = (mid + Math.imul(al4, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh8)) | 0;
+    	    lo = (lo + Math.imul(al3, bl9)) | 0;
+    	    mid = (mid + Math.imul(al3, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh9)) | 0;
+    	    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
+    	    w12 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl4);
+    	    mid = Math.imul(al9, bh4);
+    	    mid = (mid + Math.imul(ah9, bl4)) | 0;
+    	    hi = Math.imul(ah9, bh4);
+    	    lo = (lo + Math.imul(al8, bl5)) | 0;
+    	    mid = (mid + Math.imul(al8, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh5)) | 0;
+    	    lo = (lo + Math.imul(al7, bl6)) | 0;
+    	    mid = (mid + Math.imul(al7, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh6)) | 0;
+    	    lo = (lo + Math.imul(al6, bl7)) | 0;
+    	    mid = (mid + Math.imul(al6, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh7)) | 0;
+    	    lo = (lo + Math.imul(al5, bl8)) | 0;
+    	    mid = (mid + Math.imul(al5, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh8)) | 0;
+    	    lo = (lo + Math.imul(al4, bl9)) | 0;
+    	    mid = (mid + Math.imul(al4, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh9)) | 0;
+    	    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
+    	    w13 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl5);
+    	    mid = Math.imul(al9, bh5);
+    	    mid = (mid + Math.imul(ah9, bl5)) | 0;
+    	    hi = Math.imul(ah9, bh5);
+    	    lo = (lo + Math.imul(al8, bl6)) | 0;
+    	    mid = (mid + Math.imul(al8, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh6)) | 0;
+    	    lo = (lo + Math.imul(al7, bl7)) | 0;
+    	    mid = (mid + Math.imul(al7, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh7)) | 0;
+    	    lo = (lo + Math.imul(al6, bl8)) | 0;
+    	    mid = (mid + Math.imul(al6, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh8)) | 0;
+    	    lo = (lo + Math.imul(al5, bl9)) | 0;
+    	    mid = (mid + Math.imul(al5, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh9)) | 0;
+    	    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
+    	    w14 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl6);
+    	    mid = Math.imul(al9, bh6);
+    	    mid = (mid + Math.imul(ah9, bl6)) | 0;
+    	    hi = Math.imul(ah9, bh6);
+    	    lo = (lo + Math.imul(al8, bl7)) | 0;
+    	    mid = (mid + Math.imul(al8, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh7)) | 0;
+    	    lo = (lo + Math.imul(al7, bl8)) | 0;
+    	    mid = (mid + Math.imul(al7, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh8)) | 0;
+    	    lo = (lo + Math.imul(al6, bl9)) | 0;
+    	    mid = (mid + Math.imul(al6, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh9)) | 0;
+    	    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
+    	    w15 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl7);
+    	    mid = Math.imul(al9, bh7);
+    	    mid = (mid + Math.imul(ah9, bl7)) | 0;
+    	    hi = Math.imul(ah9, bh7);
+    	    lo = (lo + Math.imul(al8, bl8)) | 0;
+    	    mid = (mid + Math.imul(al8, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh8)) | 0;
+    	    lo = (lo + Math.imul(al7, bl9)) | 0;
+    	    mid = (mid + Math.imul(al7, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh9)) | 0;
+    	    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
+    	    w16 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl8);
+    	    mid = Math.imul(al9, bh8);
+    	    mid = (mid + Math.imul(ah9, bl8)) | 0;
+    	    hi = Math.imul(ah9, bh8);
+    	    lo = (lo + Math.imul(al8, bl9)) | 0;
+    	    mid = (mid + Math.imul(al8, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh9)) | 0;
+    	    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
+    	    w17 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl9);
+    	    mid = Math.imul(al9, bh9);
+    	    mid = (mid + Math.imul(ah9, bl9)) | 0;
+    	    hi = Math.imul(ah9, bh9);
+    	    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
+    	    w18 &= 0x3ffffff;
+    	    o[0] = w0;
+    	    o[1] = w1;
+    	    o[2] = w2;
+    	    o[3] = w3;
+    	    o[4] = w4;
+    	    o[5] = w5;
+    	    o[6] = w6;
+    	    o[7] = w7;
+    	    o[8] = w8;
+    	    o[9] = w9;
+    	    o[10] = w10;
+    	    o[11] = w11;
+    	    o[12] = w12;
+    	    o[13] = w13;
+    	    o[14] = w14;
+    	    o[15] = w15;
+    	    o[16] = w16;
+    	    o[17] = w17;
+    	    o[18] = w18;
+    	    if (c !== 0) {
+    	      o[19] = c;
+    	      out.length++;
+    	    }
+    	    return out;
+    	  };
+    	  if (!Math.imul) {
+    	    comb10MulTo = smallMulTo;
+    	  }
+    	  function bigMulTo (self, num, out) {
+    	    out.negative = num.negative ^ self.negative;
+    	    out.length = self.length + num.length;
+    	    var carry = 0;
+    	    var hncarry = 0;
+    	    for (var k = 0; k < out.length - 1; k++) {
+    	      var ncarry = hncarry;
+    	      hncarry = 0;
+    	      var rword = carry & 0x3ffffff;
+    	      var maxJ = Math.min(k, num.length - 1);
+    	      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+    	        var i = k - j;
+    	        var a = self.words[i] | 0;
+    	        var b = num.words[j] | 0;
+    	        var r = a * b;
+    	        var lo = r & 0x3ffffff;
+    	        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
+    	        lo = (lo + rword) | 0;
+    	        rword = lo & 0x3ffffff;
+    	        ncarry = (ncarry + (lo >>> 26)) | 0;
+    	        hncarry += ncarry >>> 26;
+    	        ncarry &= 0x3ffffff;
+    	      }
+    	      out.words[k] = rword;
+    	      carry = ncarry;
+    	      ncarry = hncarry;
+    	    }
+    	    if (carry !== 0) {
+    	      out.words[k] = carry;
+    	    } else {
+    	      out.length--;
+    	    }
+    	    return out._strip();
+    	  }
+    	  function jumboMulTo (self, num, out) {
+    	    return bigMulTo(self, num, out);
+    	  }
+    	  BN.prototype.mulTo = function mulTo (num, out) {
+    	    var res;
+    	    var len = this.length + num.length;
+    	    if (this.length === 10 && num.length === 10) {
+    	      res = comb10MulTo(this, num, out);
+    	    } else if (len < 63) {
+    	      res = smallMulTo(this, num, out);
+    	    } else if (len < 1024) {
+    	      res = bigMulTo(this, num, out);
+    	    } else {
+    	      res = jumboMulTo(this, num, out);
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.mul = function mul (num) {
+    	    var out = new BN(null);
+    	    out.words = new Array(this.length + num.length);
+    	    return this.mulTo(num, out);
+    	  };
+    	  BN.prototype.mulf = function mulf (num) {
+    	    var out = new BN(null);
+    	    out.words = new Array(this.length + num.length);
+    	    return jumboMulTo(this, num, out);
+    	  };
+    	  BN.prototype.imul = function imul (num) {
+    	    return this.clone().mulTo(num, this);
+    	  };
+    	  BN.prototype.imuln = function imuln (num) {
+    	    var isNegNum = num < 0;
+    	    if (isNegNum) num = -num;
+    	    assert(typeof num === 'number');
+    	    assert(num < 0x4000000);
+    	    var carry = 0;
+    	    for (var i = 0; i < this.length; i++) {
+    	      var w = (this.words[i] | 0) * num;
+    	      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
+    	      carry >>= 26;
+    	      carry += (w / 0x4000000) | 0;
+    	      carry += lo >>> 26;
+    	      this.words[i] = lo & 0x3ffffff;
+    	    }
+    	    if (carry !== 0) {
+    	      this.words[i] = carry;
+    	      this.length++;
+    	    }
+    	    this.length = num === 0 ? 1 : this.length;
+    	    return isNegNum ? this.ineg() : this;
+    	  };
+    	  BN.prototype.muln = function muln (num) {
+    	    return this.clone().imuln(num);
+    	  };
+    	  BN.prototype.sqr = function sqr () {
+    	    return this.mul(this);
+    	  };
+    	  BN.prototype.isqr = function isqr () {
+    	    return this.imul(this.clone());
+    	  };
+    	  BN.prototype.pow = function pow (num) {
+    	    var w = toBitArray(num);
+    	    if (w.length === 0) return new BN(1);
+    	    var res = this;
+    	    for (var i = 0; i < w.length; i++, res = res.sqr()) {
+    	      if (w[i] !== 0) break;
+    	    }
+    	    if (++i < w.length) {
+    	      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
+    	        if (w[i] === 0) continue;
+    	        res = res.mul(q);
+    	      }
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.iushln = function iushln (bits) {
+    	    assert(typeof bits === 'number' && bits >= 0);
+    	    var r = bits % 26;
+    	    var s = (bits - r) / 26;
+    	    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
+    	    var i;
+    	    if (r !== 0) {
+    	      var carry = 0;
+    	      for (i = 0; i < this.length; i++) {
+    	        var newCarry = this.words[i] & carryMask;
+    	        var c = ((this.words[i] | 0) - newCarry) << r;
+    	        this.words[i] = c | carry;
+    	        carry = newCarry >>> (26 - r);
+    	      }
+    	      if (carry) {
+    	        this.words[i] = carry;
+    	        this.length++;
+    	      }
+    	    }
+    	    if (s !== 0) {
+    	      for (i = this.length - 1; i >= 0; i--) {
+    	        this.words[i + s] = this.words[i];
+    	      }
+    	      for (i = 0; i < s; i++) {
+    	        this.words[i] = 0;
+    	      }
+    	      this.length += s;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ishln = function ishln (bits) {
+    	    assert(this.negative === 0);
+    	    return this.iushln(bits);
+    	  };
+    	  BN.prototype.iushrn = function iushrn (bits, hint, extended) {
+    	    assert(typeof bits === 'number' && bits >= 0);
+    	    var h;
+    	    if (hint) {
+    	      h = (hint - (hint % 26)) / 26;
+    	    } else {
+    	      h = 0;
+    	    }
+    	    var r = bits % 26;
+    	    var s = Math.min((bits - r) / 26, this.length);
+    	    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+    	    var maskedWords = extended;
+    	    h -= s;
+    	    h = Math.max(0, h);
+    	    if (maskedWords) {
+    	      for (var i = 0; i < s; i++) {
+    	        maskedWords.words[i] = this.words[i];
+    	      }
+    	      maskedWords.length = s;
+    	    }
+    	    if (s === 0) ; else if (this.length > s) {
+    	      this.length -= s;
+    	      for (i = 0; i < this.length; i++) {
+    	        this.words[i] = this.words[i + s];
+    	      }
+    	    } else {
+    	      this.words[0] = 0;
+    	      this.length = 1;
+    	    }
+    	    var carry = 0;
+    	    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
+    	      var word = this.words[i] | 0;
+    	      this.words[i] = (carry << (26 - r)) | (word >>> r);
+    	      carry = word & mask;
+    	    }
+    	    if (maskedWords && carry !== 0) {
+    	      maskedWords.words[maskedWords.length++] = carry;
+    	    }
+    	    if (this.length === 0) {
+    	      this.words[0] = 0;
+    	      this.length = 1;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ishrn = function ishrn (bits, hint, extended) {
+    	    assert(this.negative === 0);
+    	    return this.iushrn(bits, hint, extended);
+    	  };
+    	  BN.prototype.shln = function shln (bits) {
+    	    return this.clone().ishln(bits);
+    	  };
+    	  BN.prototype.ushln = function ushln (bits) {
+    	    return this.clone().iushln(bits);
+    	  };
+    	  BN.prototype.shrn = function shrn (bits) {
+    	    return this.clone().ishrn(bits);
+    	  };
+    	  BN.prototype.ushrn = function ushrn (bits) {
+    	    return this.clone().iushrn(bits);
+    	  };
+    	  BN.prototype.testn = function testn (bit) {
+    	    assert(typeof bit === 'number' && bit >= 0);
+    	    var r = bit % 26;
+    	    var s = (bit - r) / 26;
+    	    var q = 1 << r;
+    	    if (this.length <= s) return false;
+    	    var w = this.words[s];
+    	    return !!(w & q);
+    	  };
+    	  BN.prototype.imaskn = function imaskn (bits) {
+    	    assert(typeof bits === 'number' && bits >= 0);
+    	    var r = bits % 26;
+    	    var s = (bits - r) / 26;
+    	    assert(this.negative === 0, 'imaskn works only with positive numbers');
+    	    if (this.length <= s) {
+    	      return this;
+    	    }
+    	    if (r !== 0) {
+    	      s++;
+    	    }
+    	    this.length = Math.min(s, this.length);
+    	    if (r !== 0) {
+    	      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+    	      this.words[this.length - 1] &= mask;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.maskn = function maskn (bits) {
+    	    return this.clone().imaskn(bits);
+    	  };
+    	  BN.prototype.iaddn = function iaddn (num) {
+    	    assert(typeof num === 'number');
+    	    assert(num < 0x4000000);
+    	    if (num < 0) return this.isubn(-num);
+    	    if (this.negative !== 0) {
+    	      if (this.length === 1 && (this.words[0] | 0) <= num) {
+    	        this.words[0] = num - (this.words[0] | 0);
+    	        this.negative = 0;
+    	        return this;
+    	      }
+    	      this.negative = 0;
+    	      this.isubn(num);
+    	      this.negative = 1;
+    	      return this;
+    	    }
+    	    return this._iaddn(num);
+    	  };
+    	  BN.prototype._iaddn = function _iaddn (num) {
+    	    this.words[0] += num;
+    	    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
+    	      this.words[i] -= 0x4000000;
+    	      if (i === this.length - 1) {
+    	        this.words[i + 1] = 1;
+    	      } else {
+    	        this.words[i + 1]++;
+    	      }
+    	    }
+    	    this.length = Math.max(this.length, i + 1);
+    	    return this;
+    	  };
+    	  BN.prototype.isubn = function isubn (num) {
+    	    assert(typeof num === 'number');
+    	    assert(num < 0x4000000);
+    	    if (num < 0) return this.iaddn(-num);
+    	    if (this.negative !== 0) {
+    	      this.negative = 0;
+    	      this.iaddn(num);
+    	      this.negative = 1;
+    	      return this;
+    	    }
+    	    this.words[0] -= num;
+    	    if (this.length === 1 && this.words[0] < 0) {
+    	      this.words[0] = -this.words[0];
+    	      this.negative = 1;
+    	    } else {
+    	      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
+    	        this.words[i] += 0x4000000;
+    	        this.words[i + 1] -= 1;
+    	      }
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.addn = function addn (num) {
+    	    return this.clone().iaddn(num);
+    	  };
+    	  BN.prototype.subn = function subn (num) {
+    	    return this.clone().isubn(num);
+    	  };
+    	  BN.prototype.iabs = function iabs () {
+    	    this.negative = 0;
+    	    return this;
+    	  };
+    	  BN.prototype.abs = function abs () {
+    	    return this.clone().iabs();
+    	  };
+    	  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
+    	    var len = num.length + shift;
+    	    var i;
+    	    this._expand(len);
+    	    var w;
+    	    var carry = 0;
+    	    for (i = 0; i < num.length; i++) {
+    	      w = (this.words[i + shift] | 0) + carry;
+    	      var right = (num.words[i] | 0) * mul;
+    	      w -= right & 0x3ffffff;
+    	      carry = (w >> 26) - ((right / 0x4000000) | 0);
+    	      this.words[i + shift] = w & 0x3ffffff;
+    	    }
+    	    for (; i < this.length - shift; i++) {
+    	      w = (this.words[i + shift] | 0) + carry;
+    	      carry = w >> 26;
+    	      this.words[i + shift] = w & 0x3ffffff;
+    	    }
+    	    if (carry === 0) return this._strip();
+    	    assert(carry === -1);
+    	    carry = 0;
+    	    for (i = 0; i < this.length; i++) {
+    	      w = -(this.words[i] | 0) + carry;
+    	      carry = w >> 26;
+    	      this.words[i] = w & 0x3ffffff;
+    	    }
+    	    this.negative = 1;
+    	    return this._strip();
+    	  };
+    	  BN.prototype._wordDiv = function _wordDiv (num, mode) {
+    	    var shift = this.length - num.length;
+    	    var a = this.clone();
+    	    var b = num;
+    	    var bhi = b.words[b.length - 1] | 0;
+    	    var bhiBits = this._countBits(bhi);
+    	    shift = 26 - bhiBits;
+    	    if (shift !== 0) {
+    	      b = b.ushln(shift);
+    	      a.iushln(shift);
+    	      bhi = b.words[b.length - 1] | 0;
+    	    }
+    	    var m = a.length - b.length;
+    	    var q;
+    	    if (mode !== 'mod') {
+    	      q = new BN(null);
+    	      q.length = m + 1;
+    	      q.words = new Array(q.length);
+    	      for (var i = 0; i < q.length; i++) {
+    	        q.words[i] = 0;
+    	      }
+    	    }
+    	    var diff = a.clone()._ishlnsubmul(b, 1, m);
+    	    if (diff.negative === 0) {
+    	      a = diff;
+    	      if (q) {
+    	        q.words[m] = 1;
+    	      }
+    	    }
+    	    for (var j = m - 1; j >= 0; j--) {
+    	      var qj = (a.words[b.length + j] | 0) * 0x4000000 +
+    	        (a.words[b.length + j - 1] | 0);
+    	      qj = Math.min((qj / bhi) | 0, 0x3ffffff);
+    	      a._ishlnsubmul(b, qj, j);
+    	      while (a.negative !== 0) {
+    	        qj--;
+    	        a.negative = 0;
+    	        a._ishlnsubmul(b, 1, j);
+    	        if (!a.isZero()) {
+    	          a.negative ^= 1;
+    	        }
+    	      }
+    	      if (q) {
+    	        q.words[j] = qj;
+    	      }
+    	    }
+    	    if (q) {
+    	      q._strip();
+    	    }
+    	    a._strip();
+    	    if (mode !== 'div' && shift !== 0) {
+    	      a.iushrn(shift);
+    	    }
+    	    return {
+    	      div: q || null,
+    	      mod: a
+    	    };
+    	  };
+    	  BN.prototype.divmod = function divmod (num, mode, positive) {
+    	    assert(!num.isZero());
+    	    if (this.isZero()) {
+    	      return {
+    	        div: new BN(0),
+    	        mod: new BN(0)
+    	      };
+    	    }
+    	    var div, mod, res;
+    	    if (this.negative !== 0 && num.negative === 0) {
+    	      res = this.neg().divmod(num, mode);
+    	      if (mode !== 'mod') {
+    	        div = res.div.neg();
+    	      }
+    	      if (mode !== 'div') {
+    	        mod = res.mod.neg();
+    	        if (positive && mod.negative !== 0) {
+    	          mod.iadd(num);
+    	        }
+    	      }
+    	      return {
+    	        div: div,
+    	        mod: mod
+    	      };
+    	    }
+    	    if (this.negative === 0 && num.negative !== 0) {
+    	      res = this.divmod(num.neg(), mode);
+    	      if (mode !== 'mod') {
+    	        div = res.div.neg();
+    	      }
+    	      return {
+    	        div: div,
+    	        mod: res.mod
+    	      };
+    	    }
+    	    if ((this.negative & num.negative) !== 0) {
+    	      res = this.neg().divmod(num.neg(), mode);
+    	      if (mode !== 'div') {
+    	        mod = res.mod.neg();
+    	        if (positive && mod.negative !== 0) {
+    	          mod.isub(num);
+    	        }
+    	      }
+    	      return {
+    	        div: res.div,
+    	        mod: mod
+    	      };
+    	    }
+    	    if (num.length > this.length || this.cmp(num) < 0) {
+    	      return {
+    	        div: new BN(0),
+    	        mod: this
+    	      };
+    	    }
+    	    if (num.length === 1) {
+    	      if (mode === 'div') {
+    	        return {
+    	          div: this.divn(num.words[0]),
+    	          mod: null
+    	        };
+    	      }
+    	      if (mode === 'mod') {
+    	        return {
+    	          div: null,
+    	          mod: new BN(this.modrn(num.words[0]))
+    	        };
+    	      }
+    	      return {
+    	        div: this.divn(num.words[0]),
+    	        mod: new BN(this.modrn(num.words[0]))
+    	      };
+    	    }
+    	    return this._wordDiv(num, mode);
+    	  };
+    	  BN.prototype.div = function div (num) {
+    	    return this.divmod(num, 'div', false).div;
+    	  };
+    	  BN.prototype.mod = function mod (num) {
+    	    return this.divmod(num, 'mod', false).mod;
+    	  };
+    	  BN.prototype.umod = function umod (num) {
+    	    return this.divmod(num, 'mod', true).mod;
+    	  };
+    	  BN.prototype.divRound = function divRound (num) {
+    	    var dm = this.divmod(num);
+    	    if (dm.mod.isZero()) return dm.div;
+    	    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+    	    var half = num.ushrn(1);
+    	    var r2 = num.andln(1);
+    	    var cmp = mod.cmp(half);
+    	    if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;
+    	    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+    	  };
+    	  BN.prototype.modrn = function modrn (num) {
+    	    var isNegNum = num < 0;
+    	    if (isNegNum) num = -num;
+    	    assert(num <= 0x3ffffff);
+    	    var p = (1 << 26) % num;
+    	    var acc = 0;
+    	    for (var i = this.length - 1; i >= 0; i--) {
+    	      acc = (p * acc + (this.words[i] | 0)) % num;
+    	    }
+    	    return isNegNum ? -acc : acc;
+    	  };
+    	  BN.prototype.modn = function modn (num) {
+    	    return this.modrn(num);
+    	  };
+    	  BN.prototype.idivn = function idivn (num) {
+    	    var isNegNum = num < 0;
+    	    if (isNegNum) num = -num;
+    	    assert(num <= 0x3ffffff);
+    	    var carry = 0;
+    	    for (var i = this.length - 1; i >= 0; i--) {
+    	      var w = (this.words[i] | 0) + carry * 0x4000000;
+    	      this.words[i] = (w / num) | 0;
+    	      carry = w % num;
+    	    }
+    	    this._strip();
+    	    return isNegNum ? this.ineg() : this;
+    	  };
+    	  BN.prototype.divn = function divn (num) {
+    	    return this.clone().idivn(num);
+    	  };
+    	  BN.prototype.egcd = function egcd (p) {
+    	    assert(p.negative === 0);
+    	    assert(!p.isZero());
+    	    var x = this;
+    	    var y = p.clone();
+    	    if (x.negative !== 0) {
+    	      x = x.umod(p);
+    	    } else {
+    	      x = x.clone();
+    	    }
+    	    var A = new BN(1);
+    	    var B = new BN(0);
+    	    var C = new BN(0);
+    	    var D = new BN(1);
+    	    var g = 0;
+    	    while (x.isEven() && y.isEven()) {
+    	      x.iushrn(1);
+    	      y.iushrn(1);
+    	      ++g;
+    	    }
+    	    var yp = y.clone();
+    	    var xp = x.clone();
+    	    while (!x.isZero()) {
+    	      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+    	      if (i > 0) {
+    	        x.iushrn(i);
+    	        while (i-- > 0) {
+    	          if (A.isOdd() || B.isOdd()) {
+    	            A.iadd(yp);
+    	            B.isub(xp);
+    	          }
+    	          A.iushrn(1);
+    	          B.iushrn(1);
+    	        }
+    	      }
+    	      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+    	      if (j > 0) {
+    	        y.iushrn(j);
+    	        while (j-- > 0) {
+    	          if (C.isOdd() || D.isOdd()) {
+    	            C.iadd(yp);
+    	            D.isub(xp);
+    	          }
+    	          C.iushrn(1);
+    	          D.iushrn(1);
+    	        }
+    	      }
+    	      if (x.cmp(y) >= 0) {
+    	        x.isub(y);
+    	        A.isub(C);
+    	        B.isub(D);
+    	      } else {
+    	        y.isub(x);
+    	        C.isub(A);
+    	        D.isub(B);
+    	      }
+    	    }
+    	    return {
+    	      a: C,
+    	      b: D,
+    	      gcd: y.iushln(g)
+    	    };
+    	  };
+    	  BN.prototype._invmp = function _invmp (p) {
+    	    assert(p.negative === 0);
+    	    assert(!p.isZero());
+    	    var a = this;
+    	    var b = p.clone();
+    	    if (a.negative !== 0) {
+    	      a = a.umod(p);
+    	    } else {
+    	      a = a.clone();
+    	    }
+    	    var x1 = new BN(1);
+    	    var x2 = new BN(0);
+    	    var delta = b.clone();
+    	    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
+    	      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+    	      if (i > 0) {
+    	        a.iushrn(i);
+    	        while (i-- > 0) {
+    	          if (x1.isOdd()) {
+    	            x1.iadd(delta);
+    	          }
+    	          x1.iushrn(1);
+    	        }
+    	      }
+    	      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+    	      if (j > 0) {
+    	        b.iushrn(j);
+    	        while (j-- > 0) {
+    	          if (x2.isOdd()) {
+    	            x2.iadd(delta);
+    	          }
+    	          x2.iushrn(1);
+    	        }
+    	      }
+    	      if (a.cmp(b) >= 0) {
+    	        a.isub(b);
+    	        x1.isub(x2);
+    	      } else {
+    	        b.isub(a);
+    	        x2.isub(x1);
+    	      }
+    	    }
+    	    var res;
+    	    if (a.cmpn(1) === 0) {
+    	      res = x1;
+    	    } else {
+    	      res = x2;
+    	    }
+    	    if (res.cmpn(0) < 0) {
+    	      res.iadd(p);
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.gcd = function gcd (num) {
+    	    if (this.isZero()) return num.abs();
+    	    if (num.isZero()) return this.abs();
+    	    var a = this.clone();
+    	    var b = num.clone();
+    	    a.negative = 0;
+    	    b.negative = 0;
+    	    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
+    	      a.iushrn(1);
+    	      b.iushrn(1);
+    	    }
+    	    do {
+    	      while (a.isEven()) {
+    	        a.iushrn(1);
+    	      }
+    	      while (b.isEven()) {
+    	        b.iushrn(1);
+    	      }
+    	      var r = a.cmp(b);
+    	      if (r < 0) {
+    	        var t = a;
+    	        a = b;
+    	        b = t;
+    	      } else if (r === 0 || b.cmpn(1) === 0) {
+    	        break;
+    	      }
+    	      a.isub(b);
+    	    } while (true);
+    	    return b.iushln(shift);
+    	  };
+    	  BN.prototype.invm = function invm (num) {
+    	    return this.egcd(num).a.umod(num);
+    	  };
+    	  BN.prototype.isEven = function isEven () {
+    	    return (this.words[0] & 1) === 0;
+    	  };
+    	  BN.prototype.isOdd = function isOdd () {
+    	    return (this.words[0] & 1) === 1;
+    	  };
+    	  BN.prototype.andln = function andln (num) {
+    	    return this.words[0] & num;
+    	  };
+    	  BN.prototype.bincn = function bincn (bit) {
+    	    assert(typeof bit === 'number');
+    	    var r = bit % 26;
+    	    var s = (bit - r) / 26;
+    	    var q = 1 << r;
+    	    if (this.length <= s) {
+    	      this._expand(s + 1);
+    	      this.words[s] |= q;
+    	      return this;
+    	    }
+    	    var carry = q;
+    	    for (var i = s; carry !== 0 && i < this.length; i++) {
+    	      var w = this.words[i] | 0;
+    	      w += carry;
+    	      carry = w >>> 26;
+    	      w &= 0x3ffffff;
+    	      this.words[i] = w;
+    	    }
+    	    if (carry !== 0) {
+    	      this.words[i] = carry;
+    	      this.length++;
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype.isZero = function isZero () {
+    	    return this.length === 1 && this.words[0] === 0;
+    	  };
+    	  BN.prototype.cmpn = function cmpn (num) {
+    	    var negative = num < 0;
+    	    if (this.negative !== 0 && !negative) return -1;
+    	    if (this.negative === 0 && negative) return 1;
+    	    this._strip();
+    	    var res;
+    	    if (this.length > 1) {
+    	      res = 1;
+    	    } else {
+    	      if (negative) {
+    	        num = -num;
+    	      }
+    	      assert(num <= 0x3ffffff, 'Number is too big');
+    	      var w = this.words[0] | 0;
+    	      res = w === num ? 0 : w < num ? -1 : 1;
+    	    }
+    	    if (this.negative !== 0) return -res | 0;
+    	    return res;
+    	  };
+    	  BN.prototype.cmp = function cmp (num) {
+    	    if (this.negative !== 0 && num.negative === 0) return -1;
+    	    if (this.negative === 0 && num.negative !== 0) return 1;
+    	    var res = this.ucmp(num);
+    	    if (this.negative !== 0) return -res | 0;
+    	    return res;
+    	  };
+    	  BN.prototype.ucmp = function ucmp (num) {
+    	    if (this.length > num.length) return 1;
+    	    if (this.length < num.length) return -1;
+    	    var res = 0;
+    	    for (var i = this.length - 1; i >= 0; i--) {
+    	      var a = this.words[i] | 0;
+    	      var b = num.words[i] | 0;
+    	      if (a === b) continue;
+    	      if (a < b) {
+    	        res = -1;
+    	      } else if (a > b) {
+    	        res = 1;
+    	      }
+    	      break;
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.gtn = function gtn (num) {
+    	    return this.cmpn(num) === 1;
+    	  };
+    	  BN.prototype.gt = function gt (num) {
+    	    return this.cmp(num) === 1;
+    	  };
+    	  BN.prototype.gten = function gten (num) {
+    	    return this.cmpn(num) >= 0;
+    	  };
+    	  BN.prototype.gte = function gte (num) {
+    	    return this.cmp(num) >= 0;
+    	  };
+    	  BN.prototype.ltn = function ltn (num) {
+    	    return this.cmpn(num) === -1;
+    	  };
+    	  BN.prototype.lt = function lt (num) {
+    	    return this.cmp(num) === -1;
+    	  };
+    	  BN.prototype.lten = function lten (num) {
+    	    return this.cmpn(num) <= 0;
+    	  };
+    	  BN.prototype.lte = function lte (num) {
+    	    return this.cmp(num) <= 0;
+    	  };
+    	  BN.prototype.eqn = function eqn (num) {
+    	    return this.cmpn(num) === 0;
+    	  };
+    	  BN.prototype.eq = function eq (num) {
+    	    return this.cmp(num) === 0;
+    	  };
+    	  BN.red = function red (num) {
+    	    return new Red(num);
+    	  };
+    	  BN.prototype.toRed = function toRed (ctx) {
+    	    assert(!this.red, 'Already a number in reduction context');
+    	    assert(this.negative === 0, 'red works only with positives');
+    	    return ctx.convertTo(this)._forceRed(ctx);
+    	  };
+    	  BN.prototype.fromRed = function fromRed () {
+    	    assert(this.red, 'fromRed works only with numbers in reduction context');
+    	    return this.red.convertFrom(this);
+    	  };
+    	  BN.prototype._forceRed = function _forceRed (ctx) {
+    	    this.red = ctx;
+    	    return this;
+    	  };
+    	  BN.prototype.forceRed = function forceRed (ctx) {
+    	    assert(!this.red, 'Already a number in reduction context');
+    	    return this._forceRed(ctx);
+    	  };
+    	  BN.prototype.redAdd = function redAdd (num) {
+    	    assert(this.red, 'redAdd works only with red numbers');
+    	    return this.red.add(this, num);
+    	  };
+    	  BN.prototype.redIAdd = function redIAdd (num) {
+    	    assert(this.red, 'redIAdd works only with red numbers');
+    	    return this.red.iadd(this, num);
+    	  };
+    	  BN.prototype.redSub = function redSub (num) {
+    	    assert(this.red, 'redSub works only with red numbers');
+    	    return this.red.sub(this, num);
+    	  };
+    	  BN.prototype.redISub = function redISub (num) {
+    	    assert(this.red, 'redISub works only with red numbers');
+    	    return this.red.isub(this, num);
+    	  };
+    	  BN.prototype.redShl = function redShl (num) {
+    	    assert(this.red, 'redShl works only with red numbers');
+    	    return this.red.shl(this, num);
+    	  };
+    	  BN.prototype.redMul = function redMul (num) {
+    	    assert(this.red, 'redMul works only with red numbers');
+    	    this.red._verify2(this, num);
+    	    return this.red.mul(this, num);
+    	  };
+    	  BN.prototype.redIMul = function redIMul (num) {
+    	    assert(this.red, 'redMul works only with red numbers');
+    	    this.red._verify2(this, num);
+    	    return this.red.imul(this, num);
+    	  };
+    	  BN.prototype.redSqr = function redSqr () {
+    	    assert(this.red, 'redSqr works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.sqr(this);
+    	  };
+    	  BN.prototype.redISqr = function redISqr () {
+    	    assert(this.red, 'redISqr works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.isqr(this);
+    	  };
+    	  BN.prototype.redSqrt = function redSqrt () {
+    	    assert(this.red, 'redSqrt works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.sqrt(this);
+    	  };
+    	  BN.prototype.redInvm = function redInvm () {
+    	    assert(this.red, 'redInvm works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.invm(this);
+    	  };
+    	  BN.prototype.redNeg = function redNeg () {
+    	    assert(this.red, 'redNeg works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.neg(this);
+    	  };
+    	  BN.prototype.redPow = function redPow (num) {
+    	    assert(this.red && !num.red, 'redPow(normalNum)');
+    	    this.red._verify1(this);
+    	    return this.red.pow(this, num);
+    	  };
+    	  var primes = {
+    	    k256: null,
+    	    p224: null,
+    	    p192: null,
+    	    p25519: null
+    	  };
+    	  function MPrime (name, p) {
+    	    this.name = name;
+    	    this.p = new BN(p, 16);
+    	    this.n = this.p.bitLength();
+    	    this.k = new BN(1).iushln(this.n).isub(this.p);
+    	    this.tmp = this._tmp();
+    	  }
+    	  MPrime.prototype._tmp = function _tmp () {
+    	    var tmp = new BN(null);
+    	    tmp.words = new Array(Math.ceil(this.n / 13));
+    	    return tmp;
+    	  };
+    	  MPrime.prototype.ireduce = function ireduce (num) {
+    	    var r = num;
+    	    var rlen;
+    	    do {
+    	      this.split(r, this.tmp);
+    	      r = this.imulK(r);
+    	      r = r.iadd(this.tmp);
+    	      rlen = r.bitLength();
+    	    } while (rlen > this.n);
+    	    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
+    	    if (cmp === 0) {
+    	      r.words[0] = 0;
+    	      r.length = 1;
+    	    } else if (cmp > 0) {
+    	      r.isub(this.p);
+    	    } else {
+    	      if (r.strip !== undefined) {
+    	        r.strip();
+    	      } else {
+    	        r._strip();
+    	      }
+    	    }
+    	    return r;
+    	  };
+    	  MPrime.prototype.split = function split (input, out) {
+    	    input.iushrn(this.n, 0, out);
+    	  };
+    	  MPrime.prototype.imulK = function imulK (num) {
+    	    return num.imul(this.k);
+    	  };
+    	  function K256 () {
+    	    MPrime.call(
+    	      this,
+    	      'k256',
+    	      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
+    	  }
+    	  inherits(K256, MPrime);
+    	  K256.prototype.split = function split (input, output) {
+    	    var mask = 0x3fffff;
+    	    var outLen = Math.min(input.length, 9);
+    	    for (var i = 0; i < outLen; i++) {
+    	      output.words[i] = input.words[i];
+    	    }
+    	    output.length = outLen;
+    	    if (input.length <= 9) {
+    	      input.words[0] = 0;
+    	      input.length = 1;
+    	      return;
+    	    }
+    	    var prev = input.words[9];
+    	    output.words[output.length++] = prev & mask;
+    	    for (i = 10; i < input.length; i++) {
+    	      var next = input.words[i] | 0;
+    	      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
+    	      prev = next;
+    	    }
+    	    prev >>>= 22;
+    	    input.words[i - 10] = prev;
+    	    if (prev === 0 && input.length > 10) {
+    	      input.length -= 10;
+    	    } else {
+    	      input.length -= 9;
+    	    }
+    	  };
+    	  K256.prototype.imulK = function imulK (num) {
+    	    num.words[num.length] = 0;
+    	    num.words[num.length + 1] = 0;
+    	    num.length += 2;
+    	    var lo = 0;
+    	    for (var i = 0; i < num.length; i++) {
+    	      var w = num.words[i] | 0;
+    	      lo += w * 0x3d1;
+    	      num.words[i] = lo & 0x3ffffff;
+    	      lo = w * 0x40 + ((lo / 0x4000000) | 0);
+    	    }
+    	    if (num.words[num.length - 1] === 0) {
+    	      num.length--;
+    	      if (num.words[num.length - 1] === 0) {
+    	        num.length--;
+    	      }
+    	    }
+    	    return num;
+    	  };
+    	  function P224 () {
+    	    MPrime.call(
+    	      this,
+    	      'p224',
+    	      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
+    	  }
+    	  inherits(P224, MPrime);
+    	  function P192 () {
+    	    MPrime.call(
+    	      this,
+    	      'p192',
+    	      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
+    	  }
+    	  inherits(P192, MPrime);
+    	  function P25519 () {
+    	    MPrime.call(
+    	      this,
+    	      '25519',
+    	      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
+    	  }
+    	  inherits(P25519, MPrime);
+    	  P25519.prototype.imulK = function imulK (num) {
+    	    var carry = 0;
+    	    for (var i = 0; i < num.length; i++) {
+    	      var hi = (num.words[i] | 0) * 0x13 + carry;
+    	      var lo = hi & 0x3ffffff;
+    	      hi >>>= 26;
+    	      num.words[i] = lo;
+    	      carry = hi;
+    	    }
+    	    if (carry !== 0) {
+    	      num.words[num.length++] = carry;
+    	    }
+    	    return num;
+    	  };
+    	  BN._prime = function prime (name) {
+    	    if (primes[name]) return primes[name];
+    	    var prime;
+    	    if (name === 'k256') {
+    	      prime = new K256();
+    	    } else if (name === 'p224') {
+    	      prime = new P224();
+    	    } else if (name === 'p192') {
+    	      prime = new P192();
+    	    } else if (name === 'p25519') {
+    	      prime = new P25519();
+    	    } else {
+    	      throw new Error('Unknown prime ' + name);
+    	    }
+    	    primes[name] = prime;
+    	    return prime;
+    	  };
+    	  function Red (m) {
+    	    if (typeof m === 'string') {
+    	      var prime = BN._prime(m);
+    	      this.m = prime.p;
+    	      this.prime = prime;
+    	    } else {
+    	      assert(m.gtn(1), 'modulus must be greater than 1');
+    	      this.m = m;
+    	      this.prime = null;
+    	    }
+    	  }
+    	  Red.prototype._verify1 = function _verify1 (a) {
+    	    assert(a.negative === 0, 'red works only with positives');
+    	    assert(a.red, 'red works only with red numbers');
+    	  };
+    	  Red.prototype._verify2 = function _verify2 (a, b) {
+    	    assert((a.negative | b.negative) === 0, 'red works only with positives');
+    	    assert(a.red && a.red === b.red,
+    	      'red works only with red numbers');
+    	  };
+    	  Red.prototype.imod = function imod (a) {
+    	    if (this.prime) return this.prime.ireduce(a)._forceRed(this);
+    	    move(a, a.umod(this.m)._forceRed(this));
+    	    return a;
+    	  };
+    	  Red.prototype.neg = function neg (a) {
+    	    if (a.isZero()) {
+    	      return a.clone();
+    	    }
+    	    return this.m.sub(a)._forceRed(this);
+    	  };
+    	  Red.prototype.add = function add (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.add(b);
+    	    if (res.cmp(this.m) >= 0) {
+    	      res.isub(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Red.prototype.iadd = function iadd (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.iadd(b);
+    	    if (res.cmp(this.m) >= 0) {
+    	      res.isub(this.m);
+    	    }
+    	    return res;
+    	  };
+    	  Red.prototype.sub = function sub (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.sub(b);
+    	    if (res.cmpn(0) < 0) {
+    	      res.iadd(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Red.prototype.isub = function isub (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.isub(b);
+    	    if (res.cmpn(0) < 0) {
+    	      res.iadd(this.m);
+    	    }
+    	    return res;
+    	  };
+    	  Red.prototype.shl = function shl (a, num) {
+    	    this._verify1(a);
+    	    return this.imod(a.ushln(num));
+    	  };
+    	  Red.prototype.imul = function imul (a, b) {
+    	    this._verify2(a, b);
+    	    return this.imod(a.imul(b));
+    	  };
+    	  Red.prototype.mul = function mul (a, b) {
+    	    this._verify2(a, b);
+    	    return this.imod(a.mul(b));
+    	  };
+    	  Red.prototype.isqr = function isqr (a) {
+    	    return this.imul(a, a.clone());
+    	  };
+    	  Red.prototype.sqr = function sqr (a) {
+    	    return this.mul(a, a);
+    	  };
+    	  Red.prototype.sqrt = function sqrt (a) {
+    	    if (a.isZero()) return a.clone();
+    	    var mod3 = this.m.andln(3);
+    	    assert(mod3 % 2 === 1);
+    	    if (mod3 === 3) {
+    	      var pow = this.m.add(new BN(1)).iushrn(2);
+    	      return this.pow(a, pow);
+    	    }
+    	    var q = this.m.subn(1);
+    	    var s = 0;
+    	    while (!q.isZero() && q.andln(1) === 0) {
+    	      s++;
+    	      q.iushrn(1);
+    	    }
+    	    assert(!q.isZero());
+    	    var one = new BN(1).toRed(this);
+    	    var nOne = one.redNeg();
+    	    var lpow = this.m.subn(1).iushrn(1);
+    	    var z = this.m.bitLength();
+    	    z = new BN(2 * z * z).toRed(this);
+    	    while (this.pow(z, lpow).cmp(nOne) !== 0) {
+    	      z.redIAdd(nOne);
+    	    }
+    	    var c = this.pow(z, q);
+    	    var r = this.pow(a, q.addn(1).iushrn(1));
+    	    var t = this.pow(a, q);
+    	    var m = s;
+    	    while (t.cmp(one) !== 0) {
+    	      var tmp = t;
+    	      for (var i = 0; tmp.cmp(one) !== 0; i++) {
+    	        tmp = tmp.redSqr();
+    	      }
+    	      assert(i < m);
+    	      var b = this.pow(c, new BN(1).iushln(m - i - 1));
+    	      r = r.redMul(b);
+    	      c = b.redSqr();
+    	      t = t.redMul(c);
+    	      m = i;
+    	    }
+    	    return r;
+    	  };
+    	  Red.prototype.invm = function invm (a) {
+    	    var inv = a._invmp(this.m);
+    	    if (inv.negative !== 0) {
+    	      inv.negative = 0;
+    	      return this.imod(inv).redNeg();
+    	    } else {
+    	      return this.imod(inv);
+    	    }
+    	  };
+    	  Red.prototype.pow = function pow (a, num) {
+    	    if (num.isZero()) return new BN(1).toRed(this);
+    	    if (num.cmpn(1) === 0) return a.clone();
+    	    var windowSize = 4;
+    	    var wnd = new Array(1 << windowSize);
+    	    wnd[0] = new BN(1).toRed(this);
+    	    wnd[1] = a;
+    	    for (var i = 2; i < wnd.length; i++) {
+    	      wnd[i] = this.mul(wnd[i - 1], a);
+    	    }
+    	    var res = wnd[0];
+    	    var current = 0;
+    	    var currentLen = 0;
+    	    var start = num.bitLength() % 26;
+    	    if (start === 0) {
+    	      start = 26;
+    	    }
+    	    for (i = num.length - 1; i >= 0; i--) {
+    	      var word = num.words[i];
+    	      for (var j = start - 1; j >= 0; j--) {
+    	        var bit = (word >> j) & 1;
+    	        if (res !== wnd[0]) {
+    	          res = this.sqr(res);
+    	        }
+    	        if (bit === 0 && current === 0) {
+    	          currentLen = 0;
+    	          continue;
+    	        }
+    	        current <<= 1;
+    	        current |= bit;
+    	        currentLen++;
+    	        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
+    	        res = this.mul(res, wnd[current]);
+    	        currentLen = 0;
+    	        current = 0;
+    	      }
+    	      start = 26;
+    	    }
+    	    return res;
+    	  };
+    	  Red.prototype.convertTo = function convertTo (num) {
+    	    var r = num.umod(this.m);
+    	    return r === num ? r.clone() : r;
+    	  };
+    	  Red.prototype.convertFrom = function convertFrom (num) {
+    	    var res = num.clone();
+    	    res.red = null;
+    	    return res;
+    	  };
+    	  BN.mont = function mont (num) {
+    	    return new Mont(num);
+    	  };
+    	  function Mont (m) {
+    	    Red.call(this, m);
+    	    this.shift = this.m.bitLength();
+    	    if (this.shift % 26 !== 0) {
+    	      this.shift += 26 - (this.shift % 26);
+    	    }
+    	    this.r = new BN(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);
+    	  }
+    	  inherits(Mont, Red);
+    	  Mont.prototype.convertTo = function convertTo (num) {
+    	    return this.imod(num.ushln(this.shift));
+    	  };
+    	  Mont.prototype.convertFrom = function convertFrom (num) {
+    	    var r = this.imod(num.mul(this.rinv));
+    	    r.red = null;
+    	    return r;
+    	  };
+    	  Mont.prototype.imul = function imul (a, b) {
+    	    if (a.isZero() || b.isZero()) {
+    	      a.words[0] = 0;
+    	      a.length = 1;
+    	      return a;
+    	    }
+    	    var t = a.imul(b);
+    	    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+    	    var u = t.isub(c).iushrn(this.shift);
+    	    var res = u;
+    	    if (u.cmp(this.m) >= 0) {
+    	      res = u.isub(this.m);
+    	    } else if (u.cmpn(0) < 0) {
+    	      res = u.iadd(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Mont.prototype.mul = function mul (a, b) {
+    	    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
+    	    var t = a.mul(b);
+    	    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+    	    var u = t.isub(c).iushrn(this.shift);
+    	    var res = u;
+    	    if (u.cmp(this.m) >= 0) {
+    	      res = u.isub(this.m);
+    	    } else if (u.cmpn(0) < 0) {
+    	      res = u.iadd(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Mont.prototype.invm = function invm (a) {
+    	    var res = this.imod(a._invmp(this.m).mul(this.r2));
+    	    return res._forceRed(this);
+    	  };
+    	})(module, commonjsGlobal);
+    } (bn));
+    var bnExports = bn.exports;
+    const BN = getDefaultExportFromCjs(bnExports);
+
+    function isBn(value) {
+        return BN.isBN(value);
+    }
+
+    const REGEX_HEX_PREFIXED = /^0x[\da-fA-F]+$/;
+    const REGEX_HEX_NOPREFIX = /^[\da-fA-F]+$/;
+    function isHex(value, bitLength = -1, ignoreLength) {
+        return (typeof value === 'string' && (value === '0x' ||
+            REGEX_HEX_PREFIXED.test(value))) && (bitLength === -1
+            ? (ignoreLength || (value.length % 2 === 0))
+            : (value.length === (2 + Math.ceil(bitLength / 4))));
+    }
+
+    function isObject(value) {
+        return !!value && typeof value === 'object';
+    }
+
+    function isOn(...fns) {
+        return (value) => (isObject(value) || isFunction(value)) &&
+            fns.every((f) => isFunction(value[f]));
+    }
+    function isOnFunction(...fns) {
+        return (value) => isFunction(value) &&
+            fns.every((f) => isFunction(value[f]));
+    }
+    function isOnObject(...fns) {
+        return (value) => isObject(value) &&
+            fns.every((f) => isFunction(value[f]));
+    }
+
+    const isToBigInt =  isOn('toBigInt');
+
+    const isToBn =  isOn('toBn');
+
+    function nToBigInt(value) {
+        return typeof value === 'bigint'
+            ? value
+            : !value
+                ? BigInt(0)
+                : isHex(value)
+                    ? hexToBigInt(value.toString())
+                    : isBn(value)
+                        ? BigInt(value.toString())
+                        : isToBigInt(value)
+                            ? value.toBigInt()
+                            : isToBn(value)
+                                ? BigInt(value.toBn().toString())
+                                : BigInt(value);
+    }
+
+    function nSqrt(value) {
+        const n = nToBigInt(value);
+        if (n < _0n) {
+            throw new Error('square root of negative numbers is not supported');
+        }
+        if (n <= _2pow53n) {
+            return BigInt(~~Math.sqrt(Number(n)));
+        }
+        let x0 = _sqrt2pow53n;
+        while (true) {
+            const x1 = ((n / x0) + x0) >> _1n;
+            if (x0 === x1 || (x0 === (x1 - _1n))) {
+                return x0;
+            }
+            x0 = x1;
+        }
+    }
+
+    const hasBigInt = typeof BigInt === 'function' && typeof BigInt.asIntN === 'function';
+    const hasCjs = typeof require === 'function' && typeof module !== 'undefined';
+    const hasDirname = typeof __dirname !== 'undefined';
+    const hasEsm = !hasCjs;
+    const hasWasm = typeof WebAssembly !== 'undefined';
+    const hasBuffer = typeof xglobal.Buffer === 'function' && typeof xglobal.Buffer.isBuffer === 'function';
+    const hasProcess = typeof xglobal.process === 'object';
+
+    function isBuffer(value) {
+        return hasBuffer && !!value && isFunction(value.readDoubleLE) && xglobal.Buffer.isBuffer(value);
+    }
+
+    function isU8a(value) {
+        return (((value && value.constructor) === Uint8Array) ||
+            value instanceof Uint8Array);
+    }
+
+    var browser$1 = {};
+
+    const require$$0 = /*@__PURE__*/getAugmentedNamespace(build);
+
+    var fallback$1 = {};
+
+    Object.defineProperty(fallback$1, "__esModule", { value: true });
+    fallback$1.TextEncoder = void 0;
+    class TextEncoder {
+        encode(value) {
+            const count = value.length;
+            const u8a = new Uint8Array(count);
+            for (let i = 0; i < count; i++) {
+                u8a[i] = value.charCodeAt(i);
+            }
+            return u8a;
+        }
+    }
+    fallback$1.TextEncoder = TextEncoder;
+
+    var packageInfo$1 = {};
+
+    Object.defineProperty(packageInfo$1, "__esModule", { value: true });
+    packageInfo$1.packageInfo = void 0;
+    packageInfo$1.packageInfo = { name: '@pezkuwi/x-textencoder', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.26' };
+
+    (function (exports$1) {
+    	Object.defineProperty(exports$1, "__esModule", { value: true });
+    	exports$1.TextEncoder = exports$1.packageInfo = void 0;
+    	const x_global_1 = require$$0;
+    	const fallback_js_1 = fallback$1;
+    	var packageInfo_js_1 = packageInfo$1;
+    	Object.defineProperty(exports$1, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+    	exports$1.TextEncoder = (0, x_global_1.extractGlobal)('TextEncoder', fallback_js_1.TextEncoder);
+    } (browser$1));
+    getDefaultExportFromCjs(browser$1);
+
+    const encoder = new browser$1.TextEncoder();
+    function stringToU8a(value) {
+        return value
+            ? encoder.encode(value.toString())
+            : new Uint8Array();
+    }
+
+    function u8aToU8a(value, strict = false) {
+        if (strict && (value === null || value === undefined)) {
+            throw new Error('u8aToU8a: Expected non-null, non-undefined value');
+        }
+        return isU8a(value)
+            ? isBuffer(value)
+                ? new Uint8Array(value)
+                : value
+            : isHex(value)
+                ? hexToU8a(value)
+                : Array.isArray(value)
+                    ? new Uint8Array(value)
+                    : stringToU8a(value);
+    }
+
+    function u8aCmp(a, b) {
+        const u8aa = u8aToU8a(a);
+        const u8ab = u8aToU8a(b);
+        let i = 0;
+        while (true) {
+            const overA = i >= u8aa.length;
+            const overB = i >= u8ab.length;
+            if (overA && overB) {
+                return 0;
+            }
+            else if (overA) {
+                return -1;
+            }
+            else if (overB) {
+                return 1;
+            }
+            else if (u8aa[i] !== u8ab[i]) {
+                return u8aa[i] > u8ab[i]
+                    ? 1
+                    : -1;
+            }
+            i++;
+        }
+    }
+
+    function u8aConcat(...list) {
+        const count = list.length;
+        const u8as = new Array(count);
+        let length = 0;
+        for (let i = 0; i < count; i++) {
+            u8as[i] = u8aToU8a(list[i]);
+            length += u8as[i].length;
+        }
+        return u8aConcatStrict(u8as, length);
+    }
+    function u8aConcatStrict(u8as, length = 0) {
+        const count = u8as.length;
+        let offset = 0;
+        if (!length) {
+            for (let i = 0; i < count; i++) {
+                length += u8as[i].length;
+            }
+        }
+        const result = new Uint8Array(length);
+        for (let i = 0; i < count; i++) {
+            result.set(u8as[i], offset);
+            offset += u8as[i].length;
+        }
+        return result;
+    }
+
+    function u8aEmpty(value) {
+        const len = value.length | 0;
+        for (let i = 0; i < len; i++) {
+            if (value[i] | 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function u8aEq(a, b) {
+        const u8aa = u8aToU8a(a);
+        const u8ab = u8aToU8a(b);
+        if (u8aa.length === u8ab.length) {
+            const dvA = new DataView(u8aa.buffer, u8aa.byteOffset);
+            const dvB = new DataView(u8ab.buffer, u8ab.byteOffset);
+            const mod = (u8aa.length % 4) | 0;
+            const length = (u8aa.length - mod) | 0;
+            for (let i = 0; i < length; i += 4) {
+                if (dvA.getUint32(i) !== dvB.getUint32(i)) {
+                    return false;
+                }
+            }
+            for (let i = length, count = u8aa.length; i < count; i++) {
+                if (u8aa[i] !== u8ab[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    function u8aFixLength(value, bitLength = -1, atStart = false) {
+        const byteLength = Math.ceil(bitLength / 8);
+        if (bitLength === -1 || value.length === byteLength) {
+            return value;
+        }
+        else if (value.length > byteLength) {
+            return value.subarray(0, byteLength);
+        }
+        const result = new Uint8Array(byteLength);
+        result.set(value, atStart ? 0 : (byteLength - value.length));
+        return result;
+    }
+
+    function u8aSorted(u8as) {
+        return u8as.sort(u8aCmp);
+    }
+
+    function u8aToBn(value, { isLe = true, isNegative = false } = {}) {
+        if (!isLe) {
+            value = value.slice().reverse();
+        }
+        const count = value.length;
+        if (isNegative && count && (value[count - 1] & 0x80)) {
+            switch (count) {
+                case 0:
+                    return new BN(0);
+                case 1:
+                    return new BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
+                case 2:
+                    return new BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+                case 3:
+                    return new BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
+                case 4:
+                    return new BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+                case 5:
+                    return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
+                case 6:
+                    return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
+                default:
+                    return new BN(value, 'le').fromTwos(count * 8);
+            }
+        }
+        switch (count) {
+            case 0:
+                return new BN(0);
+            case 1:
+                return new BN(value[0]);
+            case 2:
+                return new BN(value[0] + (value[1] << 8));
+            case 3:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16));
+            case 4:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+            case 5:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
+            case 6:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
+            default:
+                return new BN(value, 'le');
+        }
+    }
+
+    function u8aToBuffer(value) {
+        return hasBuffer
+            ? xglobal.Buffer.from(value || [])
+            : new Uint8Array(value || []);
+    }
+
+    function u8aToFloat(value, { bitLength = 32, isLe = true } = {}) {
+        if (bitLength !== 32 && bitLength !== 64) {
+            throw new Error('Invalid bitLength provided, expected 32 or 64');
+        }
+        else if (value.length < (bitLength / 8)) {
+            throw new Error(`Invalid input buffer provided, expected at least ${bitLength / 8} bytes, found ${value.length}`);
+        }
+        const dv = new DataView(value.buffer, value.byteOffset);
+        return bitLength === 32
+            ? dv.getFloat32(0, isLe)
+            : dv.getFloat64(0, isLe);
+    }
+
+    const U8 = new Array(256);
+    const U16 = new Array(256 * 256);
+    for (let n = 0; n < 256; n++) {
+        U8[n] = n.toString(16).padStart(2, '0');
+    }
+    for (let i = 0; i < 256; i++) {
+        const s = i << 8;
+        for (let j = 0; j < 256; j++) {
+            U16[s | j] = U8[i] + U8[j];
+        }
+    }
+    function hex(value, result) {
+        const mod = (value.length % 2) | 0;
+        const length = (value.length - mod) | 0;
+        for (let i = 0; i < length; i += 2) {
+            result += U16[(value[i] << 8) | value[i + 1]];
+        }
+        if (mod) {
+            result += U8[value[length] | 0];
+        }
+        return result;
+    }
+    function u8aToHex(value, bitLength = -1, isPrefixed = true) {
+        const empty = isPrefixed
+            ? '0x'
+            : '';
+        if (!value?.length) {
+            return empty;
+        }
+        else if (bitLength > 0) {
+            const length = Math.ceil(bitLength / 8);
+            if (value.length > length) {
+                return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), '')}`;
+            }
+        }
+        return hex(value, empty);
+    }
+
+    function u8aToNumber(value, { isLe = true, isNegative = false } = {}) {
+        if (!isLe) {
+            value = value.slice().reverse();
+        }
+        const count = value.length;
+        if (isNegative && count && (value[count - 1] & 0x80)) {
+            switch (count) {
+                case 0:
+                    return 0;
+                case 1:
+                    return (((value[0] ^ 0x0000_00ff) * -1) - 1);
+                case 2:
+                    return ((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+                case 3:
+                    return ((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
+                case 4:
+                    return ((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+                case 5:
+                    return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
+                case 6:
+                    return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
+                default:
+                    throw new Error('Value more than 48-bits cannot be reliably converted');
+            }
+        }
+        switch (count) {
+            case 0:
+                return 0;
+            case 1:
+                return value[0];
+            case 2:
+                return value[0] + (value[1] << 8);
+            case 3:
+                return value[0] + (value[1] << 8) + (value[2] << 16);
+            case 4:
+                return value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00);
+            case 5:
+                return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00);
+            case 6:
+                return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00);
+            default:
+                throw new Error('Value more than 48-bits cannot be reliably converted');
+        }
+    }
+
+    var browser = {};
+
+    var fallback = {};
+
+    Object.defineProperty(fallback, "__esModule", { value: true });
+    fallback.TextDecoder = void 0;
+    class TextDecoder {
+        __encoding;
+        constructor(encoding) {
+            this.__encoding = encoding;
+        }
+        decode(value) {
+            let result = '';
+            for (let i = 0, count = value.length; i < count; i++) {
+                result += String.fromCharCode(value[i]);
+            }
+            return result;
+        }
+    }
+    fallback.TextDecoder = TextDecoder;
+
+    var packageInfo = {};
+
+    Object.defineProperty(packageInfo, "__esModule", { value: true });
+    packageInfo.packageInfo = void 0;
+    packageInfo.packageInfo = { name: '@pezkuwi/x-textdecoder', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.26' };
+
+    (function (exports$1) {
+    	Object.defineProperty(exports$1, "__esModule", { value: true });
+    	exports$1.TextDecoder = exports$1.packageInfo = void 0;
+    	const x_global_1 = require$$0;
+    	const fallback_js_1 = fallback;
+    	var packageInfo_js_1 = packageInfo;
+    	Object.defineProperty(exports$1, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+    	exports$1.TextDecoder = (0, x_global_1.extractGlobal)('TextDecoder', fallback_js_1.TextDecoder);
+    } (browser));
+    getDefaultExportFromCjs(browser);
+
+    const decoder = new browser.TextDecoder('utf-8');
+    function u8aToString(value) {
+        return value
+            ? decoder.decode(value)
+            : '';
+    }
+
+    const U8A_WRAP_ETHEREUM =  u8aToU8a('\x19Ethereum Signed Message:\n');
+    const U8A_WRAP_PREFIX =  u8aToU8a('<Bytes>');
+    const U8A_WRAP_POSTFIX =  u8aToU8a('</Bytes>');
+    const WRAP_LEN = U8A_WRAP_PREFIX.length + U8A_WRAP_POSTFIX.length;
+    function u8aIsWrapped(u8a, withEthereum) {
+        return ((u8a.length >= WRAP_LEN &&
+            u8aEq(u8a.subarray(0, U8A_WRAP_PREFIX.length), U8A_WRAP_PREFIX) &&
+            u8aEq(u8a.slice(-U8A_WRAP_POSTFIX.length), U8A_WRAP_POSTFIX)) ||
+            (withEthereum &&
+                u8a.length >= U8A_WRAP_ETHEREUM.length &&
+                u8aEq(u8a.subarray(0, U8A_WRAP_ETHEREUM.length), U8A_WRAP_ETHEREUM)));
+    }
+    function u8aUnwrapBytes(bytes) {
+        const u8a = u8aToU8a(bytes);
+        return u8aIsWrapped(u8a, false)
+            ? u8a.subarray(U8A_WRAP_PREFIX.length, u8a.length - U8A_WRAP_POSTFIX.length)
+            : u8a;
+    }
+    function u8aWrapBytes(bytes) {
+        const u8a = u8aToU8a(bytes);
+        return u8aIsWrapped(u8a, true)
+            ? u8a
+            : u8aConcatStrict([U8A_WRAP_PREFIX, u8a, U8A_WRAP_POSTFIX]);
+    }
+
+    const DIV = BigInt(256);
+    const NEG_MASK = BigInt(0xff);
+    function toU8a(value, isLe, isNegative) {
+        const arr = [];
+        const withSigned = isNegative && (value < _0n);
+        if (withSigned) {
+            value = (value + _1n) * -_1n;
+        }
+        while (value !== _0n) {
+            const mod = value % DIV;
+            const val = Number(withSigned
+                ? mod ^ NEG_MASK
+                : mod);
+            if (isLe) {
+                arr.push(val);
+            }
+            else {
+                arr.unshift(val);
+            }
+            value = (value - mod) / DIV;
+        }
+        return Uint8Array.from(arr);
+    }
+    function nToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = {}) {
+        const valueBi = nToBigInt(value);
+        if (valueBi === _0n) {
+            return bitLength === -1
+                ? new Uint8Array(1)
+                : new Uint8Array(Math.ceil((bitLength || 0) / 8));
+        }
+        const u8a = toU8a(valueBi, isLe, isNegative);
+        if (bitLength === -1) {
+            return u8a;
+        }
+        const byteLength = Math.ceil((bitLength || 0) / 8);
+        const output = new Uint8Array(byteLength);
+        if (isNegative) {
+            output.fill(0xff);
+        }
+        output.set(u8a, isLe ? 0 : byteLength - u8a.length);
+        return output;
+    }
+
+    function nToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+        return u8aToHex(nToU8a(value || 0, { bitLength, isLe, isNegative }));
+    }
+
+    function hexStripPrefix(value) {
+        if (!value || value === '0x') {
+            return '';
+        }
+        else if (REGEX_HEX_PREFIXED.test(value)) {
+            return value.substring(2);
+        }
+        else if (REGEX_HEX_NOPREFIX.test(value)) {
+            return value;
+        }
+        throw new Error(`Expected hex value to convert, found '${value}'`);
+    }
+
+    function hexToBn(value, { isLe = false, isNegative = false } = {}) {
+        if (!value || value === '0x') {
+            return new BN(0);
+        }
+        const stripped = hexStripPrefix(value);
+        const bn = new BN(stripped, 16, isLe ? 'le' : 'be');
+        return isNegative
+            ? bn.fromTwos(stripped.length * 4)
+            : bn;
+    }
+
+    const bnMax =  createCmp((a, b) => a.gt(b));
+    const bnMin =  createCmp((a, b) => a.lt(b));
+
+    const BN_ZERO =  new BN(0);
+    const BN_ONE =  new BN(1);
+    const BN_TWO =  new BN(2);
+    const BN_THREE =  new BN(3);
+    const BN_FOUR =  new BN(4);
+    const BN_FIVE =  new BN(5);
+    const BN_SIX =  new BN(6);
+    const BN_SEVEN =  new BN(7);
+    const BN_EIGHT =  new BN(8);
+    const BN_NINE =  new BN(9);
+    const BN_TEN =  new BN(10);
+    const BN_HUNDRED =  new BN(100);
+    const BN_THOUSAND =  new BN(1_000);
+    const BN_MILLION =  new BN(1_000_000);
+    const BN_BILLION =  new BN(1_000_000_000);
+    const BN_QUINTILL = BN_BILLION.mul(BN_BILLION);
+    const BN_MAX_INTEGER =  new BN(Number.MAX_SAFE_INTEGER);
+    const BN_SQRT_MAX_INTEGER =  new BN(94906265);
+
+    function isBigInt(value) {
+        return typeof value === 'bigint';
+    }
+
+    function bnToBn(value) {
+        return value
+            ? BN.isBN(value)
+                ? value
+                : isHex(value)
+                    ? hexToBn(value.toString())
+                    : isBigInt(value)
+                        ? new BN(value.toString())
+                        : isToBn(value)
+                            ? value.toBn()
+                            : isToBigInt(value)
+                                ? new BN(value.toBigInt().toString())
+                                : new BN(value)
+            : new BN(0);
+    }
+
+    function bnSqrt(value) {
+        const n = bnToBn(value);
+        if (n.isNeg()) {
+            throw new Error('square root of negative numbers is not supported');
+        }
+        if (n.lte(BN_MAX_INTEGER)) {
+            return new BN(~~Math.sqrt(n.toNumber()));
+        }
+        let x0 = BN_SQRT_MAX_INTEGER.clone();
+        while (true) {
+            const x1 = n.div(x0).iadd(x0).ishrn(1);
+            if (x0.eq(x1) || x0.eq(x1.sub(BN_ONE))) {
+                return x0;
+            }
+            x0 = x1;
+        }
+    }
+
+    const DEFAULT_OPTS = { bitLength: -1, isLe: true, isNegative: false };
+    function bnToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS) {
+        const valueBn = bnToBn(value);
+        const byteLength = bitLength === -1
+            ? Math.ceil(valueBn.bitLength() / 8)
+            : Math.ceil((bitLength || 0) / 8);
+        if (!value) {
+            return bitLength === -1
+                ? new Uint8Array(1)
+                : new Uint8Array(byteLength);
+        }
+        const output = new Uint8Array(byteLength);
+        const bn = isNegative
+            ? valueBn.toTwos(byteLength * 8)
+            : valueBn;
+        output.set(bn.toArray(isLe ? 'le' : 'be', byteLength), 0);
+        return output;
+    }
+
+    function bnToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+        return u8aToHex(bnToU8a(value, { bitLength, isLe, isNegative }));
+    }
+
+    function bufferToU8a(buffer) {
+        return new Uint8Array(buffer || []);
+    }
+
+    const MAX_U8 = BN_TWO.pow(new BN(8 - 2)).isub(BN_ONE);
+    const MAX_U16 = BN_TWO.pow(new BN(16 - 2)).isub(BN_ONE);
+    const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(BN_ONE);
+    const BL_16 = { bitLength: 16 };
+    const BL_32 = { bitLength: 32 };
+    function compactToU8a(value) {
+        const bn = bnToBn(value);
+        if (bn.lte(MAX_U8)) {
+            return new Uint8Array([bn.toNumber() << 2]);
+        }
+        else if (bn.lte(MAX_U16)) {
+            return bnToU8a(bn.shln(2).iadd(BN_ONE), BL_16);
+        }
+        else if (bn.lte(MAX_U32)) {
+            return bnToU8a(bn.shln(2).iadd(BN_TWO), BL_32);
+        }
+        const u8a = bnToU8a(bn);
+        let length = u8a.length;
+        while (u8a[length - 1] === 0) {
+            length--;
+        }
+        if (length < 4) {
+            throw new Error('Invalid length, previous checks match anything less than 2^30');
+        }
+        return u8aConcatStrict([
+            new Uint8Array([((length - 4) << 2) + 0b11]),
+            u8a.subarray(0, length)
+        ]);
+    }
+
+    function compactAddLength(input) {
+        return u8aConcatStrict([
+            compactToU8a(input.length),
+            input
+        ]);
+    }
+
+    function compactFromU8a(input) {
+        const u8a = u8aToU8a(input);
+        switch (u8a[0] & 0b11) {
+            case 0b00:
+                return [1, new BN(u8a[0] >>> 2)];
+            case 0b01:
+                return [2, new BN((u8a[0] + (u8a[1] << 8)) >>> 2)];
+            case 0b10:
+                return [4, new BN((u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2)];
+            default: {
+                const offset = (u8a[0] >>> 2) + 5;
+                switch (offset) {
+                    case 5:
+                        return [5, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00))];
+                    case 6:
+                        return [6, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00))];
+                    case 7:
+                        return [7, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00))];
+                    default:
+                        return [offset, u8aToBn(u8a.subarray(1, offset))];
+                }
+            }
+        }
+    }
+    function compactFromU8aLim(u8a) {
+        switch (u8a[0] & 0b11) {
+            case 0b00:
+                return [1, u8a[0] >>> 2];
+            case 0b01:
+                return [2, (u8a[0] + (u8a[1] << 8)) >>> 2];
+            case 0b10:
+                return [4, (u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2];
+            default: {
+                switch ((u8a[0] >>> 2) + 5) {
+                    case 5:
+                        return [5, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00)];
+                    case 6:
+                        return [6, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00)];
+                    case 7:
+                        return [7, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00)];
+                    default:
+                        throw new Error('Compact input is > Number.MAX_SAFE_INTEGER');
+                }
+            }
+        }
+    }
+
+    function compactStripLength(input) {
+        const [offset, length] = compactFromU8a(input);
+        const total = offset + length.toNumber();
+        return [
+            total,
+            input.subarray(offset, total)
+        ];
+    }
+
+    const DEDUPE = 'Either remove and explicitly install matching versions or dedupe using your package manager.\nThe following conflicting packages were found:';
+    const POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = 'POLKADOTJS_DISABLE_ESM_CJS_WARNING';
+    function getEntry(name) {
+        const _global = xglobal;
+        if (!_global.__polkadotjs) {
+            _global.__polkadotjs = {};
+        }
+        if (!_global.__polkadotjs[name]) {
+            _global.__polkadotjs[name] = [];
+        }
+        return _global.__polkadotjs[name];
+    }
+    function formatDisplay(all, fmt) {
+        let max = 0;
+        for (let i = 0, count = all.length; i < count; i++) {
+            max = Math.max(max, all[i].version.length);
+        }
+        return all
+            .map((d) => `\t${fmt(d.version.padEnd(max), d).join('\t')}`)
+            .join('\n');
+    }
+    function formatInfo(version, { name }) {
+        return [
+            version,
+            name
+        ];
+    }
+    function formatVersion(version, { path, type }) {
+        let extracted;
+        if (path && path.length >= 5) {
+            const nmIndex = path.indexOf('node_modules');
+            extracted = nmIndex === -1
+                ? path
+                : path.substring(nmIndex);
+        }
+        else {
+            extracted = '<unknown>';
+        }
+        return [
+            `${`${type || ''}`.padStart(3)} ${version}`,
+            extracted
+        ];
+    }
+    function getPath(infoPath, pathOrFn) {
+        if (infoPath) {
+            return infoPath;
+        }
+        else if (isFunction(pathOrFn)) {
+            try {
+                return pathOrFn() || '';
+            }
+            catch {
+                return '';
+            }
+        }
+        return pathOrFn || '';
+    }
+    function warn(pre, all, fmt) {
+        console.warn(`${pre}\n${DEDUPE}\n${formatDisplay(all, fmt)}`);
+    }
+    function detectPackage({ name, path, type, version }, pathOrFn, deps = []) {
+        if (!name.startsWith('@pezkuwi')) {
+            throw new Error(`Invalid package descriptor ${name}`);
+        }
+        const entry = getEntry(name);
+        entry.push({ path: getPath(path, pathOrFn), type, version });
+        const entriesSameVersion = entry.every((e) => e.version === version);
+        const esmCjsWarningDisabled = xglobal.process?.env?.[POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG] === '1';
+        const multipleEntries = entry.length !== 1;
+        const disableWarnings = esmCjsWarningDisabled && entriesSameVersion;
+        if (multipleEntries && !disableWarnings) {
+            warn(`${name} has multiple versions, ensure that there is only one installed.`, entry, formatVersion);
+        }
+        else {
+            const mismatches = deps.filter((d) => d && d.version !== version);
+            if (mismatches.length) {
+                warn(`${name} requires direct dependencies exactly matching version ${version}.`, mismatches, formatInfo);
+            }
+        }
+    }
+
+    const MIN_MS = 60 * 1000;
+    const HR_MS = MIN_MS * 60;
+    const DAY_MS = HR_MS * 24;
+    const ZERO = { days: 0, hours: 0, milliseconds: 0, minutes: 0, seconds: 0 };
+    function add(a, b) {
+        return {
+            days: (a.days || 0) + b.days,
+            hours: (a.hours || 0) + b.hours,
+            milliseconds: (a.milliseconds || 0) + b.milliseconds,
+            minutes: (a.minutes || 0) + b.minutes,
+            seconds: (a.seconds || 0) + b.seconds
+        };
+    }
+    function extractSecs(ms) {
+        const s = ms / 1000;
+        if (s < 60) {
+            const seconds = ~~s;
+            return add({ seconds }, extractTime(ms - (seconds * 1000)));
+        }
+        const m = s / 60;
+        if (m < 60) {
+            const minutes = ~~m;
+            return add({ minutes }, extractTime(ms - (minutes * MIN_MS)));
+        }
+        const h = m / 60;
+        if (h < 24) {
+            const hours = ~~h;
+            return add({ hours }, extractTime(ms - (hours * HR_MS)));
+        }
+        const days = ~~(h / 24);
+        return add({ days }, extractTime(ms - (days * DAY_MS)));
+    }
+    function extractTime(milliseconds) {
+        return !milliseconds
+            ? ZERO
+            : milliseconds < 1000
+                ? add({ milliseconds }, ZERO)
+                : extractSecs(milliseconds);
+    }
+
+    function floatToU8a(value = 0.0, { bitLength = 32, isLe = true } = {}) {
+        if (bitLength !== 32 && bitLength !== 64) {
+            throw new Error('Invalid bitLength provided, expected 32 or 64');
+        }
+        const result = new Uint8Array(bitLength / 8);
+        const dv = new DataView(result.buffer, result.byteOffset);
+        if (bitLength === 32) {
+            dv.setFloat32(0, Number(value), isLe);
+        }
+        else {
+            dv.setFloat64(0, Number(value), isLe);
+        }
+        return result;
+    }
+
+    function isBoolean(value) {
+        return typeof value === 'boolean';
+    }
+
+    function isDigit(c) {
+        return c >= '0' && c <= '9';
+    }
+    function groups(value) {
+        const out = [];
+        const end = value.length;
+        let i = 0;
+        while (i < end) {
+            if (!isDigit(value[i])) {
+                i++;
+                continue;
+            }
+            let j = i;
+            while (j < end && isDigit(value[j])) {
+                j++;
+            }
+            let start = i;
+            while (start < j) {
+                let stop = -1;
+                for (let q = start + 1; q <= j; q++) {
+                    const left = j - q;
+                    if ((left > 0 && left % 3 === 0) || (left === 0 && j === end)) {
+                        stop = q;
+                        break;
+                    }
+                }
+                if (stop === -1) {
+                    break;
+                }
+                out.push(value.slice(start, stop));
+                start = stop;
+            }
+            i = j;
+        }
+        return out;
+    }
+    function formatDecimal(value, separator = ',') {
+        const isNegative = value[0].startsWith('-');
+        const matched = groups(isNegative ? value.substring(1) : value);
+        return matched.length
+            ? `${isNegative ? '-' : ''}${matched.join(separator)}`
+            : value;
+    }
+
+    function getSeparator(locale) {
+        return {
+            decimal: (0.1).toLocaleString(locale, { useGrouping: false }).charAt(1),
+            thousand: (1000).toLocaleString(locale, { useGrouping: true }).replace(/\d/g, '').charAt(0)
+        };
+    }
+
+    const SI_MID = 8;
+    const SI = [
+        { power: -24, text: 'yocto', value: 'y' },
+        { power: -21, text: 'zepto', value: 'z' },
+        { power: -18, text: 'atto', value: 'a' },
+        { power: -15, text: 'femto', value: 'f' },
+        { power: -12, text: 'pico', value: 'p' },
+        { power: -9, text: 'nano', value: 'n' },
+        { power: -6, text: 'micro', value: 'µ' },
+        { power: -3, text: 'milli', value: 'm' },
+        { power: 0, text: 'Unit', value: '-' },
+        { power: 3, text: 'Kilo', value: 'k' },
+        { power: 6, text: 'Mill', value: 'M' },
+        { power: 9, text: 'Bill', value: 'B' },
+        { power: 12, text: 'Tril', value: 'T' },
+        { power: 15, text: 'Peta', value: 'P' },
+        { power: 18, text: 'Exa', value: 'E' },
+        { power: 21, text: 'Zeta', value: 'Z' },
+        { power: 24, text: 'Yotta', value: 'Y' }
+    ];
+    function findSi(type) {
+        for (let i = 0, count = SI.length; i < count; i++) {
+            if (SI[i].value === type) {
+                return SI[i];
+            }
+        }
+        return SI[SI_MID];
+    }
+    function calcSi(text, decimals, forceUnit) {
+        if (forceUnit) {
+            return findSi(forceUnit);
+        }
+        const siDefIndex = (SI_MID - 1) + Math.ceil((text.length - decimals) / 3);
+        return SI[siDefIndex] || SI[siDefIndex < 0 ? 0 : SI.length - 1];
+    }
+
+    const DEFAULT_DECIMALS = 0;
+    const DEFAULT_UNIT = SI[SI_MID].text;
+    let defaultDecimals = DEFAULT_DECIMALS;
+    let defaultUnit = DEFAULT_UNIT;
+    function _formatBalance(input, { decimals = defaultDecimals, forceUnit, locale = 'en', withAll = false, withSi = true, withSiFull = false, withUnit = true, withZero = true } = {}) {
+        let text = bnToBn(input).toString();
+        if (text.length === 0 || text === '0') {
+            return '0';
+        }
+        let sign = '';
+        if (text[0].startsWith('-')) {
+            sign = '-';
+            text = text.substring(1);
+        }
+        const si = calcSi(text, decimals, forceUnit);
+        const mid = text.length - (decimals + si.power);
+        const pre = mid <= 0 ? '0' : text.substring(0, mid);
+        let post = text
+            .padStart(mid < 0 ? decimals : 1, '0')
+            .substring(mid < 0 ? 0 : mid)
+            .padEnd(withAll ? Math.max(decimals, 4) : 4, '0')
+            .substring(0, withAll ? Math.max(4, decimals + si.power) : 4);
+        if (!withZero) {
+            let end = post.length - 1;
+            do {
+                if (post[end] === '0') {
+                    end--;
+                }
+            } while (post[end] === '0');
+            post = post.substring(0, end + 1);
+        }
+        const unit = isBoolean(withUnit)
+            ? SI[SI_MID].text
+            : withUnit;
+        const units = withSi || withSiFull
+            ? si.value === '-'
+                ? withUnit
+                    ? ` ${unit}`
+                    : ''
+                : ` ${withSiFull ? `${si.text}${withUnit ? ' ' : ''}` : si.value}${withUnit ? unit : ''}`
+            : '';
+        const { decimal, thousand } = getSeparator(locale);
+        return `${sign}${formatDecimal(pre, thousand)}${post && `${decimal}${post}`}${units}`;
+    }
+    const formatBalance = _formatBalance;
+    formatBalance.calcSi = (text, decimals = defaultDecimals) => calcSi(text, decimals);
+    formatBalance.findSi = findSi;
+    formatBalance.getDefaults = () => {
+        return {
+            decimals: defaultDecimals,
+            unit: defaultUnit
+        };
+    };
+    formatBalance.getOptions = (decimals = defaultDecimals) => {
+        return SI.filter(({ power }) => power < 0
+            ? (decimals + power) >= 0
+            : true);
+    };
+    formatBalance.setDefaults = ({ decimals, unit }) => {
+        defaultDecimals = (Array.isArray(decimals)
+            ? decimals[0]
+            : decimals) ?? defaultDecimals;
+        defaultUnit = (Array.isArray(unit)
+            ? unit[0]
+            : unit) ?? defaultUnit;
+        SI[SI_MID].text = defaultUnit;
+    };
+
+    function zeroPad(value) {
+        return value.toString().padStart(2, '0');
+    }
+    function formatDate(date) {
+        const year = date.getFullYear().toString();
+        const month = zeroPad((date.getMonth() + 1));
+        const day = zeroPad(date.getDate());
+        const hour = zeroPad(date.getHours());
+        const minute = zeroPad(date.getMinutes());
+        const second = zeroPad(date.getSeconds());
+        return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+    }
+
+    function formatValue(elapsed) {
+        if (elapsed < 15) {
+            return `${elapsed.toFixed(1)}s`;
+        }
+        else if (elapsed < 60) {
+            return `${elapsed | 0}s`;
+        }
+        else if (elapsed < 3600) {
+            return `${elapsed / 60 | 0}m`;
+        }
+        return `${elapsed / 3600 | 0}h`;
+    }
+    function formatElapsed(now, value) {
+        const tsNow = now?.getTime() || 0;
+        const tsValue = value instanceof Date
+            ? value.getTime()
+            : bnToBn(value).toNumber();
+        return (tsNow && tsValue)
+            ? formatValue(Math.max(Math.abs(tsNow - tsValue), 0) / 1000)
+            : '0.0s';
+    }
+
+    function formatNumber(value, { locale = 'en' } = {}) {
+        const { thousand } = getSeparator(locale);
+        return formatDecimal(bnToBn(value).toString(), thousand);
+    }
+
+    function hexHasPrefix(value) {
+        return !!value && isHex(value, -1);
+    }
+
+    function hexAddPrefix(value) {
+        return value && hexHasPrefix(value)
+            ? value
+            : `0x${value && value.length % 2 === 1 ? '0' : ''}${value || ''}`;
+    }
+
+    function hexFixLength(value, bitLength = -1, withPadding = false) {
+        const strLength = Math.ceil(bitLength / 4);
+        const hexLength = strLength + 2;
+        return hexAddPrefix((bitLength === -1 || value.length === hexLength || (!withPadding && value.length < hexLength))
+            ? hexStripPrefix(value)
+            : (value.length > hexLength)
+                ? hexStripPrefix(value).slice(-1 * strLength)
+                : `${'0'.repeat(strLength)}${hexStripPrefix(value)}`.slice(-1 * strLength));
+    }
+
+    function hexToNumber(value) {
+        return value
+            ? hexToBn(value).toNumber()
+            : NaN;
+    }
+
+    function hexToString(_value) {
+        return u8aToString(hexToU8a(_value));
+    }
+
+    function isArray(value) {
+        return Array.isArray(value);
+    }
+
+    function isString(value) {
+        return typeof value === 'string' || value instanceof String;
+    }
+
+    function isAsciiStr(str) {
+        for (let i = 0, count = str.length; i < count; i++) {
+            const b = str.charCodeAt(i);
+            if (b < 32 || b > 126) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function isAsciiBytes(u8a) {
+        for (let i = 0, count = u8a.length; i < count; i++) {
+            const b = u8a[i] | 0;
+            if (b < 32 || b > 126) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function isAscii(value) {
+        return isString(value)
+            ? isHex(value)
+                ? isAsciiBytes(u8aToU8a(value))
+                : isAsciiStr(value)
+            : value
+                ? isAsciiBytes(value)
+                : false;
+    }
+
+    const isClass =  isOnFunction('isPrototypeOf', 'hasOwnProperty');
+
+    function isChildClass(Parent, Child) {
+        return isClass(Child) && isClass(Parent)
+            ? Parent === Child || Parent.isPrototypeOf(Child)
+            : false;
+    }
+
+    const checkCodec =  isOnObject('toHex', 'toHuman', 'toU8a');
+    const checkRegistry =  isOnObject('get');
+    function isCodec(value) {
+        return checkCodec(value) && checkRegistry(value.registry);
+    }
+
+    const isCompact =  isOnObject('toBigInt', 'toBn', 'toNumber', 'unwrap');
+
+    function isError(value) {
+        return (((value && value.constructor) === Error) ||
+            value instanceof Error);
+    }
+
+    function isInstanceOf(value, Clazz) {
+        return (((value && value.constructor) === Clazz) ||
+            value instanceof Clazz);
+    }
+
+    const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
+    const v6s = '[a-fA-F\\d]{1,4}';
+    const v6 = `
+(?:
+(?:${v6s}:){7}(?:${v6s}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6s}:){6}(?:${v4}|:${v6s}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6s}:){5}(?::${v4}|(?::${v6s}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6s}:){4}(?:(?::${v6s}){0,1}:${v4}|(?::${v6s}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6s}:){3}(?:(?::${v6s}){0,2}:${v4}|(?::${v6s}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6s}:){2}(?:(?::${v6s}){0,3}:${v4}|(?::${v6s}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6s}:){1}(?:(?::${v6s}){0,4}:${v4}|(?::${v6s}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6s}){0,5}:${v4}|(?::${v6s}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`.replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim();
+    const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+    const v4exact = new RegExp(`^${v4}$`);
+    const v6exact = new RegExp(`^${v6}$`);
+    function isIp(value, type) {
+        switch (type) {
+            case 'v4': return v4exact.test(value);
+            case 'v6': return v6exact.test(value);
+            default: return v46Exact.test(value);
+        }
+    }
+
+    function replacer(_, v) {
+        return isBigInt(v)
+            ? v.toString()
+            : v;
+    }
+    function stringify(value, space) {
+        return JSON.stringify(value, replacer, space);
+    }
+
+    function isJsonObject(value) {
+        const str = typeof value !== 'string'
+            ? stringify(value)
+            : value;
+        try {
+            const obj = JSON.parse(str);
+            return typeof obj === 'object' && obj !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+
+    function isNull(value) {
+        return value === null;
+    }
+
+    function isNumber(value) {
+        return typeof value === 'number';
+    }
+
+    const isObservable =  isOn('next');
+
+    const isPromise =  isOnObject('catch', 'then');
+
+    const ELF_MAGIC = new Uint8Array([0x7f, 0x45, 0x4c, 0x46]);
+    const PVM_MAGIC = new Uint8Array([0x50, 0x56, 0x4d, 0x00]);
+    function isRiscV(bytes) {
+        if (isU8a(bytes)) {
+            const start = bytes.subarray(0, 4);
+            return u8aEq(start, PVM_MAGIC) || u8aEq(start, ELF_MAGIC);
+        }
+        return false;
+    }
+
+    const REGEX_DEV = /(Development|Local Testnet)$/;
+    function isTestChain(chain) {
+        if (!chain) {
+            return false;
+        }
+        return !!REGEX_DEV.test(chain.toString());
+    }
+
+    function isUndefined(value) {
+        return value === undefined;
+    }
+
+    function isUtf8(value) {
+        if (!value) {
+            return isString(value);
+        }
+        const u8a = u8aToU8a(value);
+        const len = u8a.length;
+        let i = 0;
+        while (i < len) {
+            if (u8a[i] <= 0x7F)  {
+                i += 1;
+            }
+            else if (u8a[i] >= 0xC2 && u8a[i] <= 0xDF)  {
+                if (i + 1 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 2;
+            }
+            else if (u8a[i] === 0xE0)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0xA0 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] >= 0xE1 && u8a[i] <= 0xEC)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] === 0xED)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x9F) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] >= 0xEE && u8a[i] <= 0xEF)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] === 0xF0)  {
+                if (i + 3 < len)  {
+                    if (u8a[i + 1] < 0x90 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 4;
+            }
+            else if (u8a[i] >= 0xF1 && u8a[i] <= 0xF3)  {
+                if (i + 3 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 4;
+            }
+            else if (u8a[i] === 0xF4)  {
+                if (i + 3 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x8F) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 4;
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    const WASM_MAGIC = new Uint8Array([0, 97, 115, 109]);
+    function isWasm(value) {
+        return isU8a(value) && u8aEq(value.subarray(0, 4), WASM_MAGIC);
+    }
+
+    function lazyMethod(result, item, creator, getName, index = 0) {
+        const name = getName
+            ? getName(item, index)
+            : item.toString();
+        let value;
+        Object.defineProperty(result, name, {
+            configurable: true,
+            enumerable: true,
+            get: function () {
+                if (value === undefined) {
+                    value = creator(item, index, this);
+                    try {
+                        Object.defineProperty(this, name, { value });
+                    }
+                    catch {
+                    }
+                }
+                return value;
+            }
+        });
+    }
+    function lazyMethods(result, items, creator, getName) {
+        for (let i = 0, count = items.length; i < count; i++) {
+            lazyMethod(result, items[i], creator, getName, i);
+        }
+        return result;
+    }
+
+    function identity(value) {
+        return value;
+    }
+    function noop() {
+    }
+
+    const logTo = {
+        debug: 'log',
+        error: 'error',
+        log: 'log',
+        warn: 'warn'
+    };
+    function formatOther(value) {
+        if (value && isObject(value) && value.constructor === Object) {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = loggerFormat(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    function loggerFormat(value) {
+        if (Array.isArray(value)) {
+            return value.map(loggerFormat);
+        }
+        else if (isBn(value)) {
+            return value.toString();
+        }
+        else if (isU8a(value) || isBuffer(value)) {
+            return u8aToHex(u8aToU8a(value));
+        }
+        return formatOther(value);
+    }
+    function formatWithLength(maxLength) {
+        return (v) => {
+            if (maxLength <= 0) {
+                return v;
+            }
+            const r = `${v}`;
+            return r.length < maxLength
+                ? v
+                : `${r.substring(0, maxLength)} ...`;
+        };
+    }
+    function apply(log, type, values, maxSize = -1) {
+        if (values.length === 1 && isFunction(values[0])) {
+            const fnResult = values[0]();
+            return apply(log, type, Array.isArray(fnResult) ? fnResult : [fnResult], maxSize);
+        }
+        console[logTo[log]](formatDate(new Date()), type, ...values
+            .map(loggerFormat)
+            .map(formatWithLength(maxSize)));
+    }
+    function isDebugOn(e, type) {
+        return !!e && (e === '*' ||
+            type === e ||
+            (e.endsWith('*') &&
+                type.startsWith(e.slice(0, -1))));
+    }
+    function isDebugOff(e, type) {
+        return !!e && (e.startsWith('-') &&
+            (type === e.slice(1) ||
+                (e.endsWith('*') &&
+                    type.startsWith(e.slice(1, -1)))));
+    }
+    function getDebugFlag(env, type) {
+        let flag = false;
+        for (const e of env) {
+            if (isDebugOn(e, type)) {
+                flag = true;
+            }
+            else if (isDebugOff(e, type)) {
+                flag = false;
+            }
+        }
+        return flag;
+    }
+    function parseEnv(type) {
+        const maxSize = parseInt(xglobal.process?.env?.['DEBUG_MAX'] || '-1', 10);
+        return [
+            getDebugFlag((xglobal.process?.env?.['DEBUG'] || '').toLowerCase().split(','), type),
+            isNaN(maxSize)
+                ? -1
+                : maxSize
+        ];
+    }
+    function logger(origin) {
+        const type = `${origin.toUpperCase()}:`.padStart(16);
+        const [isDebug, maxSize] = parseEnv(origin.toLowerCase());
+        return {
+            debug: isDebug
+                ? (...values) => apply('debug', type, values, maxSize)
+                : noop,
+            error: (...values) => apply('error', type, values),
+            log: (...values) => apply('log', type, values),
+            noop,
+            warn: (...values) => apply('warn', type, values)
+        };
+    }
+
+    function defaultGetId() {
+        return 'none';
+    }
+    function memoize(fn, { getInstanceId = defaultGetId } = {}) {
+        const cache = {};
+        const memoized = (...args) => {
+            const stringParams = stringify(args);
+            const instanceId = getInstanceId();
+            if (!cache[instanceId]) {
+                cache[instanceId] = {};
+            }
+            if (cache[instanceId][stringParams] === undefined) {
+                cache[instanceId][stringParams] = fn(...args);
+            }
+            return cache[instanceId][stringParams];
+        };
+        memoized.unmemoize = (...args) => {
+            const stringParams = stringify(args);
+            const instanceId = getInstanceId();
+            if (cache[instanceId]?.[stringParams] !== undefined) {
+                delete cache[instanceId][stringParams];
+            }
+        };
+        return memoized;
+    }
+
+    function nextTick(onExec, onError) {
+        setTimeout(() => {
+            Promise
+                .resolve()
+                .then(() => {
+                onExec();
+            })
+                .catch((error) => {
+                if (onError) {
+                    onError(error);
+                }
+                else {
+                    console.error(error);
+                }
+            });
+        }, 0);
+    }
+
+    function numberToHex(value, bitLength = -1) {
+        const hex = (!value || Number.isNaN(value) ? 0 : value).toString(16);
+        return hexFixLength(hex.length % 2 ? `0${hex}` : hex, bitLength, true);
+    }
+
+    function numberToU8a(value, bitLength = -1) {
+        return hexToU8a(numberToHex(value, bitLength));
+    }
+
+    function objectClear(value) {
+        const keys = Object.keys(value);
+        for (let i = 0, count = keys.length; i < count; i++) {
+            delete value[keys[i]];
+        }
+        return value;
+    }
+
+    function objectSpread(dest, ...sources) {
+        const filterProps = new Set(['__proto__', 'constructor', 'prototype']);
+        for (let i = 0, count = sources.length; i < count; i++) {
+            const src = sources[i];
+            if (src) {
+                if (typeof src.entries === 'function') {
+                    for (const [key, value] of src.entries()) {
+                        if (!filterProps.has(key)) {
+                            dest[key] = value;
+                        }
+                    }
+                }
+                else {
+                    const sanitizedSrc = Object.create(null);
+                    for (const [key, value] of Object.entries(src)) {
+                        if (!filterProps.has(key)) {
+                            sanitizedSrc[key] = value;
+                        }
+                    }
+                    Object.assign(dest, sanitizedSrc);
+                }
+            }
+        }
+        return dest;
+    }
+
+    function objectCopy(source) {
+        return objectSpread({}, source);
+    }
+
+    function objectEntries(obj) {
+        return Object.entries(obj);
+    }
+
+    function objectKeys(value) {
+        return Object.keys(value);
+    }
+
+    function objectProperty(that, key, getter, getName, index = 0) {
+        const name = getName
+            ? getName(key, index)
+            : key;
+        if (!(name in that)) {
+            Object.defineProperty(that, name, {
+                enumerable: true,
+                get: function () {
+                    return getter(key, index, this);
+                }
+            });
+        }
+    }
+    function objectProperties(that, keys, getter, getName) {
+        for (let i = 0, count = keys.length; i < count; i++) {
+            objectProperty(that, keys[i], getter, getName, i);
+        }
+    }
+
+    function objectValues(obj) {
+        return Object.values(obj);
+    }
+
+    function promisify(self, fn, ...params) {
+        return new Promise((resolve, reject) => {
+            fn.apply(self, params.concat((error, result) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(result);
+                }
+            }));
+        });
+    }
+
+    const CC_TO_UP = new Array(256);
+    const CC_TO_LO = new Array(256);
+    for (let i = 0, count = CC_TO_UP.length; i < count; i++) {
+        CC_TO_LO[i] = String.fromCharCode(i).toLowerCase();
+        CC_TO_UP[i] = String.fromCharCode(i).toUpperCase();
+    }
+    function formatAllCaps(w) {
+        return w.slice(0, w.length - 1).toLowerCase() + CC_TO_UP[w.charCodeAt(w.length - 1)];
+    }
+    function converter$1(format) {
+        return (value) => {
+            const parts = value
+                .replace(/[-_., ]+/g, ' ')
+                .trim()
+                .split(' ');
+            let result = '';
+            for (let i = 0, count = parts.length; i < count; i++) {
+                const w = parts[i];
+                result += format(/^[\dA-Z]+$/.test(w)
+                    ? w.toLowerCase()
+                    : w.replace(/^[\dA-Z]{2,}[^a-z]/, formatAllCaps), i);
+            }
+            return result;
+        };
+    }
+    const stringCamelCase =  converter$1((w, i) =>
+    (i ? CC_TO_UP[w.charCodeAt(0)] : CC_TO_LO[w.charCodeAt(0)]) + w.slice(1));
+    const stringPascalCase =  converter$1((w) =>
+    CC_TO_UP[w.charCodeAt(0)] + w.slice(1));
+
+    function converter(map) {
+        return (value) => value
+            ? map[value.charCodeAt(0)] + value.slice(1)
+            : '';
+    }
+    const stringLowerFirst =  converter(CC_TO_LO);
+    const stringUpperFirst =  converter(CC_TO_UP);
+
+    function stringShorten(value, prefixLength = 6) {
+        return value.length <= 2 + 2 * prefixLength
+            ? value.toString()
+            : `${value.substring(0, prefixLength)}…${value.slice(-prefixLength)}`;
+    }
+
+    function stringToHex(value) {
+        return u8aToHex(stringToU8a(value));
+    }
+
+    exports.BN = BN;
+    exports.BN_BILLION = BN_BILLION;
+    exports.BN_EIGHT = BN_EIGHT;
+    exports.BN_FIVE = BN_FIVE;
+    exports.BN_FOUR = BN_FOUR;
+    exports.BN_HUNDRED = BN_HUNDRED;
+    exports.BN_MAX_INTEGER = BN_MAX_INTEGER;
+    exports.BN_MILLION = BN_MILLION;
+    exports.BN_NINE = BN_NINE;
+    exports.BN_ONE = BN_ONE;
+    exports.BN_QUINTILL = BN_QUINTILL;
+    exports.BN_SEVEN = BN_SEVEN;
+    exports.BN_SIX = BN_SIX;
+    exports.BN_SQRT_MAX_INTEGER = BN_SQRT_MAX_INTEGER;
+    exports.BN_TEN = BN_TEN;
+    exports.BN_THOUSAND = BN_THOUSAND;
+    exports.BN_THREE = BN_THREE;
+    exports.BN_TWO = BN_TWO;
+    exports.BN_ZERO = BN_ZERO;
+    exports.POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG;
+    exports.U8A_WRAP_ETHEREUM = U8A_WRAP_ETHEREUM;
+    exports.U8A_WRAP_POSTFIX = U8A_WRAP_POSTFIX;
+    exports.U8A_WRAP_PREFIX = U8A_WRAP_PREFIX;
+    exports._0n = _0n;
+    exports._1000n = _1000n;
+    exports._100n = _100n;
+    exports._10n = _10n;
+    exports._1Bn = _1Bn;
+    exports._1Mn = _1Mn;
+    exports._1Qn = _1Qn;
+    exports._1n = _1n;
+    exports._2n = _2n;
+    exports._2pow53n = _2pow53n;
+    exports._3n = _3n;
+    exports._4n = _4n;
+    exports._5n = _5n;
+    exports._6n = _6n;
+    exports._7n = _7n;
+    exports._8n = _8n;
+    exports._9n = _9n;
+    exports._sqrt2pow53n = _sqrt2pow53n;
+    exports.arrayChunk = arrayChunk;
+    exports.arrayFilter = arrayFilter;
+    exports.arrayFlatten = arrayFlatten;
+    exports.arrayRange = arrayRange;
+    exports.arrayShuffle = arrayShuffle;
+    exports.arrayUnzip = arrayUnzip;
+    exports.arrayZip = arrayZip;
+    exports.assert = assert;
+    exports.assertReturn = assertReturn;
+    exports.assertUnreachable = assertUnreachable;
+    exports.bnFromHex = hexToBn;
+    exports.bnMax = bnMax;
+    exports.bnMin = bnMin;
+    exports.bnSqrt = bnSqrt;
+    exports.bnToBn = bnToBn;
+    exports.bnToHex = bnToHex;
+    exports.bnToU8a = bnToU8a;
+    exports.bufferToU8a = bufferToU8a;
+    exports.calcSi = calcSi;
+    exports.compactAddLength = compactAddLength;
+    exports.compactFromU8a = compactFromU8a;
+    exports.compactFromU8aLim = compactFromU8aLim;
+    exports.compactStripLength = compactStripLength;
+    exports.compactToU8a = compactToU8a;
+    exports.detectPackage = detectPackage;
+    exports.extractTime = extractTime;
+    exports.findSi = findSi;
+    exports.floatToU8a = floatToU8a;
+    exports.formatBalance = formatBalance;
+    exports.formatDate = formatDate;
+    exports.formatDecimal = formatDecimal;
+    exports.formatElapsed = formatElapsed;
+    exports.formatNumber = formatNumber;
+    exports.hasBigInt = hasBigInt;
+    exports.hasBuffer = hasBuffer;
+    exports.hasCjs = hasCjs;
+    exports.hasDirname = hasDirname;
+    exports.hasEsm = hasEsm;
+    exports.hasProcess = hasProcess;
+    exports.hasWasm = hasWasm;
+    exports.hexAddPrefix = hexAddPrefix;
+    exports.hexFixLength = hexFixLength;
+    exports.hexHasPrefix = hexHasPrefix;
+    exports.hexStripPrefix = hexStripPrefix;
+    exports.hexToBigInt = hexToBigInt;
+    exports.hexToBn = hexToBn;
+    exports.hexToNumber = hexToNumber;
+    exports.hexToString = hexToString;
+    exports.hexToU8a = hexToU8a;
+    exports.identity = identity;
+    exports.isArray = isArray;
+    exports.isAscii = isAscii;
+    exports.isBigInt = isBigInt;
+    exports.isBn = isBn;
+    exports.isBoolean = isBoolean;
+    exports.isBuffer = isBuffer;
+    exports.isChildClass = isChildClass;
+    exports.isClass = isClass;
+    exports.isCodec = isCodec;
+    exports.isCompact = isCompact;
+    exports.isError = isError;
+    exports.isFunction = isFunction;
+    exports.isHex = isHex;
+    exports.isInstanceOf = isInstanceOf;
+    exports.isIp = isIp;
+    exports.isJsonObject = isJsonObject;
+    exports.isNull = isNull;
+    exports.isNumber = isNumber;
+    exports.isObject = isObject;
+    exports.isObservable = isObservable;
+    exports.isPromise = isPromise;
+    exports.isRiscV = isRiscV;
+    exports.isString = isString;
+    exports.isTestChain = isTestChain;
+    exports.isToBigInt = isToBigInt;
+    exports.isToBn = isToBn;
+    exports.isU8a = isU8a;
+    exports.isUndefined = isUndefined;
+    exports.isUtf8 = isUtf8;
+    exports.isWasm = isWasm;
+    exports.lazyMethod = lazyMethod;
+    exports.lazyMethods = lazyMethods;
+    exports.logger = logger;
+    exports.loggerFormat = loggerFormat;
+    exports.memoize = memoize;
+    exports.nMax = nMax;
+    exports.nMin = nMin;
+    exports.nSqrt = nSqrt;
+    exports.nToBigInt = nToBigInt;
+    exports.nToHex = nToHex;
+    exports.nToU8a = nToU8a;
+    exports.nextTick = nextTick;
+    exports.noop = noop;
+    exports.numberToHex = numberToHex;
+    exports.numberToU8a = numberToU8a;
+    exports.objectClear = objectClear;
+    exports.objectCopy = objectCopy;
+    exports.objectEntries = objectEntries;
+    exports.objectKeys = objectKeys;
+    exports.objectProperties = objectProperties;
+    exports.objectProperty = objectProperty;
+    exports.objectSpread = objectSpread;
+    exports.objectValues = objectValues;
+    exports.packageInfo = packageInfo$3;
+    exports.promisify = promisify;
+    exports.stringCamelCase = stringCamelCase;
+    exports.stringLowerFirst = stringLowerFirst;
+    exports.stringPascalCase = stringPascalCase;
+    exports.stringShorten = stringShorten;
+    exports.stringToHex = stringToHex;
+    exports.stringToU8a = stringToU8a;
+    exports.stringUpperFirst = stringUpperFirst;
+    exports.stringify = stringify;
+    exports.u8aCmp = u8aCmp;
+    exports.u8aConcat = u8aConcat;
+    exports.u8aConcatStrict = u8aConcatStrict;
+    exports.u8aEmpty = u8aEmpty;
+    exports.u8aEq = u8aEq;
+    exports.u8aFixLength = u8aFixLength;
+    exports.u8aIsWrapped = u8aIsWrapped;
+    exports.u8aSorted = u8aSorted;
+    exports.u8aToBigInt = u8aToBigInt;
+    exports.u8aToBn = u8aToBn;
+    exports.u8aToBuffer = u8aToBuffer;
+    exports.u8aToFloat = u8aToFloat;
+    exports.u8aToHex = u8aToHex;
+    exports.u8aToNumber = u8aToNumber;
+    exports.u8aToString = u8aToString;
+    exports.u8aToU8a = u8aToU8a;
+    exports.u8aUnwrapBytes = u8aUnwrapBytes;
+    exports.u8aWrapBytes = u8aWrapBytes;
+
+}));
diff --git a/docs/root-signing/vendor/bundle-polkadot-util-crypto.js b/docs/root-signing/vendor/bundle-polkadot-util-crypto.js
new file mode 100644
index 0000000..79aaa22
--- /dev/null
+++ b/docs/root-signing/vendor/bundle-polkadot-util-crypto.js
@@ -0,0 +1,8865 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@polkadot/util')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@polkadot/util'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.polkadotUtilCrypto = {}, global.polkadotUtil));
+})(this, (function (exports, util) { 'use strict';
+
+    const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;
+
+    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+    const packageInfo$2 = { name: '@polkadot/x-global', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '13.5.9' };
+
+    function evaluateThis(fn) {
+        return fn('return this');
+    }
+    const xglobal =  (typeof globalThis !== 'undefined'
+        ? globalThis
+        : typeof global !== 'undefined'
+            ? global
+            : typeof self !== 'undefined'
+                ? self
+                : typeof window !== 'undefined'
+                    ? window
+                    : evaluateThis(Function));
+    function extractGlobal(name, fallback) {
+        return typeof xglobal[name] === 'undefined'
+            ? fallback
+            : xglobal[name];
+    }
+    function exposeGlobal(name, fallback) {
+        if (typeof xglobal[name] === 'undefined') {
+            xglobal[name] = fallback;
+        }
+    }
+
+    const build = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exposeGlobal: exposeGlobal,
+        extractGlobal: extractGlobal,
+        packageInfo: packageInfo$2,
+        xglobal: xglobal
+    });
+
+    function invalidFallback() {
+        return Number.NaN;
+    }
+    const BigInt$1 =  extractGlobal('BigInt', invalidFallback);
+
+    exposeGlobal('BigInt', BigInt$1);
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    function getAugmentedNamespace(n) {
+      if (n.__esModule) return n;
+      var f = n.default;
+    	if (typeof f == "function") {
+    		var a = function a () {
+    			if (this instanceof a) {
+            return Reflect.construct(f, arguments, this.constructor);
+    			}
+    			return f.apply(this, arguments);
+    		};
+    		a.prototype = f.prototype;
+      } else a = {};
+      Object.defineProperty(a, '__esModule', {value: true});
+    	Object.keys(n).forEach(function (k) {
+    		var d = Object.getOwnPropertyDescriptor(n, k);
+    		Object.defineProperty(a, k, d.get ? d : {
+    			enumerable: true,
+    			get: function () {
+    				return n[k];
+    			}
+    		});
+    	});
+    	return a;
+    }
+
+    var browser = {};
+
+    const require$$0 = /*@__PURE__*/getAugmentedNamespace(build);
+
+    var packageInfo$1 = {};
+
+    Object.defineProperty(packageInfo$1, "__esModule", { value: true });
+    packageInfo$1.packageInfo = void 0;
+    packageInfo$1.packageInfo = { name: '@polkadot/x-randomvalues', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '13.5.9' };
+
+    (function (exports) {
+    	Object.defineProperty(exports, "__esModule", { value: true });
+    	exports.crypto = exports.packageInfo = void 0;
+    	exports.getRandomValues = getRandomValues;
+    	const x_global_1 = require$$0;
+    	var packageInfo_js_1 = packageInfo$1;
+    	Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+    	exports.crypto = x_global_1.xglobal.crypto;
+    	function getRandomValues(arr) {
+    	    return exports.crypto.getRandomValues(arr);
+    	}
+    } (browser));
+    getDefaultExportFromCjs(browser);
+
+    const DEFAULT_CRYPTO = { getRandomValues: browser.getRandomValues };
+    const DEFAULT_SELF = { crypto: DEFAULT_CRYPTO };
+    class Wbg {
+        #bridge;
+        constructor(bridge) {
+            this.#bridge = bridge;
+        }
+        abort = () => {
+            throw new Error('abort');
+        };
+        __wbindgen_is_undefined = (idx) => {
+            return this.#bridge.getObject(idx) === undefined;
+        };
+        __wbindgen_throw = (ptr, len) => {
+            throw new Error(this.#bridge.getString(ptr, len));
+        };
+        __wbg_self_1b7a39e3a92c949c = () => {
+            return this.#bridge.addObject(DEFAULT_SELF);
+        };
+        __wbg_require_604837428532a733 = (ptr, len) => {
+            throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+        };
+        __wbg_crypto_968f1772287e2df0 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO);
+        };
+        __wbg_getRandomValues_a3d34b4fee3c2869 = (_idx) => {
+            return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+        };
+        __wbg_getRandomValues_f5e14ab7ac8e995d = (_arg0, ptr, len) => {
+            DEFAULT_CRYPTO.getRandomValues(this.#bridge.getU8a(ptr, len));
+        };
+        __wbg_randomFillSync_d5bd2d655fdf256a = (_idx, _ptr, _len) => {
+            throw new Error('randomFillsync is not available');
+        };
+        __wbindgen_object_drop_ref = (idx) => {
+            this.#bridge.takeObject(idx);
+        };
+    }
+
+    class Bridge {
+        #createWasm;
+        #heap;
+        #wbg;
+        #cachegetInt32;
+        #cachegetUint8;
+        #heapNext;
+        #wasm;
+        #wasmError;
+        #wasmPromise;
+        #type;
+        constructor(createWasm) {
+            this.#createWasm = createWasm;
+            this.#cachegetInt32 = null;
+            this.#cachegetUint8 = null;
+            this.#heap = new Array(32)
+                .fill(undefined)
+                .concat(undefined, null, true, false);
+            this.#heapNext = this.#heap.length;
+            this.#type = 'none';
+            this.#wasm = null;
+            this.#wasmError = null;
+            this.#wasmPromise = null;
+            this.#wbg = { ...new Wbg(this) };
+        }
+        get error() {
+            return this.#wasmError;
+        }
+        get type() {
+            return this.#type;
+        }
+        get wasm() {
+            return this.#wasm;
+        }
+        async init(createWasm) {
+            if (!this.#wasmPromise || createWasm) {
+                this.#wasmPromise = (createWasm || this.#createWasm)(this.#wbg);
+            }
+            const { error, type, wasm } = await this.#wasmPromise;
+            this.#type = type;
+            this.#wasm = wasm;
+            this.#wasmError = error;
+            return this.#wasm;
+        }
+        getObject(idx) {
+            return this.#heap[idx];
+        }
+        dropObject(idx) {
+            if (idx < 36) {
+                return;
+            }
+            this.#heap[idx] = this.#heapNext;
+            this.#heapNext = idx;
+        }
+        takeObject(idx) {
+            const ret = this.getObject(idx);
+            this.dropObject(idx);
+            return ret;
+        }
+        addObject(obj) {
+            if (this.#heapNext === this.#heap.length) {
+                this.#heap.push(this.#heap.length + 1);
+            }
+            const idx = this.#heapNext;
+            this.#heapNext = this.#heap[idx];
+            this.#heap[idx] = obj;
+            return idx;
+        }
+        getInt32() {
+            if (this.#cachegetInt32 === null || this.#cachegetInt32.buffer !== this.#wasm.memory.buffer) {
+                this.#cachegetInt32 = new Int32Array(this.#wasm.memory.buffer);
+            }
+            return this.#cachegetInt32;
+        }
+        getUint8() {
+            if (this.#cachegetUint8 === null || this.#cachegetUint8.buffer !== this.#wasm.memory.buffer) {
+                this.#cachegetUint8 = new Uint8Array(this.#wasm.memory.buffer);
+            }
+            return this.#cachegetUint8;
+        }
+        getU8a(ptr, len) {
+            return this.getUint8().subarray(ptr / 1, ptr / 1 + len);
+        }
+        getString(ptr, len) {
+            return util.u8aToString(this.getU8a(ptr, len));
+        }
+        allocU8a(arg) {
+            const ptr = this.#wasm.__wbindgen_malloc(arg.length * 1);
+            this.getUint8().set(arg, ptr / 1);
+            return [ptr, arg.length];
+        }
+        allocString(arg) {
+            return this.allocU8a(util.stringToU8a(arg));
+        }
+        resultU8a() {
+            const r0 = this.getInt32()[8 / 4 + 0];
+            const r1 = this.getInt32()[8 / 4 + 1];
+            const ret = this.getU8a(r0, r1).slice();
+            this.#wasm.__wbindgen_free(r0, r1 * 1);
+            return ret;
+        }
+        resultString() {
+            return util.u8aToString(this.resultU8a());
+        }
+    }
+
+    function createWasmFn(root, wasmBytes, asmFn) {
+        return async (wbg) => {
+            const result = {
+                error: null,
+                type: 'none',
+                wasm: null
+            };
+            try {
+                if (!wasmBytes?.length) {
+                    throw new Error('No WebAssembly provided for initialization');
+                }
+                else if (typeof WebAssembly !== 'object' || typeof WebAssembly.instantiate !== 'function') {
+                    throw new Error('WebAssembly is not available in your environment');
+                }
+                const source = await WebAssembly.instantiate(wasmBytes, { wbg });
+                result.wasm = source.instance.exports;
+                result.type = 'wasm';
+            }
+            catch (error) {
+                if (typeof asmFn === 'function') {
+                    result.wasm = asmFn(wbg);
+                    result.type = 'asm';
+                }
+                else {
+                    result.error = `FATAL: Unable to initialize @polkadot/wasm-${root}:: ${error.message}`;
+                    console.error(result.error);
+                }
+            }
+            return result;
+        };
+    }
+
+    const CHR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const map = new Array(256);
+    for (let i = 0, count = CHR.length; i < count; i++) {
+        map[CHR.charCodeAt(i)] = i;
+    }
+    function base64Decode$1(data, out) {
+        let byte = 0;
+        let bits = 0;
+        let pos = -1;
+        for (let i = 0, last = out.length - 1; pos !== last; i++) {
+            byte = (byte << 6) | map[data.charCodeAt(i)];
+            if ((bits += 6) >= 8) {
+                out[++pos] = (byte >>> (bits -= 8)) & 0xff;
+            }
+        }
+        return out;
+    }
+
+    const u8 = Uint8Array, u16 = Uint16Array, u32$1 = Uint32Array;
+    const clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    const fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,  0, 0,  0]);
+    const fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,  0, 0]);
+    const freb = (eb, start) => {
+        const b = new u16(31);
+        for (let i = 0; i < 31; ++i) {
+            b[i] = start += 1 << eb[i - 1];
+        }
+        const r = new u32$1(b[30]);
+        for (let i = 1; i < 30; ++i) {
+            for (let j = b[i]; j < b[i + 1]; ++j) {
+                r[j] = ((j - b[i]) << 5) | i;
+            }
+        }
+        return [b, r];
+    };
+    const [fl, revfl] = freb(fleb, 2);
+    fl[28] = 258, revfl[258] = 28;
+    const [fd] = freb(fdeb, 0);
+    const rev = new u16(32768);
+    for (let i = 0; i < 32768; ++i) {
+        let x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
+        x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
+        x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
+        rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+    }
+    const hMap = ((cd, mb, r) => {
+        const s = cd.length;
+        let i = 0;
+        const l = new u16(mb);
+        for (; i < s; ++i) {
+            if (cd[i])
+                ++l[cd[i] - 1];
+        }
+        const le = new u16(mb);
+        for (i = 1; i < mb; ++i) {
+            le[i] = (le[i - 1] + l[i - 1]) << 1;
+        }
+        let co;
+        if (r) {
+            co = new u16(1 << mb);
+            const rvb = 15 - mb;
+            for (i = 0; i < s; ++i) {
+                if (cd[i]) {
+                    const sv = (i << 4) | cd[i];
+                    const r = mb - cd[i];
+                    let v = le[cd[i] - 1]++ << r;
+                    for (const m = v | ((1 << r) - 1); v <= m; ++v) {
+                        co[rev[v] >> rvb] = sv;
+                    }
+                }
+            }
+        }
+        else {
+            co = new u16(s);
+            for (i = 0; i < s; ++i) {
+                if (cd[i]) {
+                    co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+                }
+            }
+        }
+        return co;
+    });
+    const flt = new u8(288);
+    for (let i = 0; i < 144; ++i)
+        flt[i] = 8;
+    for (let i = 144; i < 256; ++i)
+        flt[i] = 9;
+    for (let i = 256; i < 280; ++i)
+        flt[i] = 7;
+    for (let i = 280; i < 288; ++i)
+        flt[i] = 8;
+    const fdt = new u8(32);
+    for (let i = 0; i < 32; ++i)
+        fdt[i] = 5;
+    const flrm = hMap(flt, 9, 1);
+    const fdrm = hMap(fdt, 5, 1);
+    const bits = (d, p, m) => {
+        const o = p >>> 3;
+        return ((d[o] | (d[o + 1] << 8)) >>> (p & 7)) & m;
+    };
+    const bits16 = (d, p) => {
+        const o = p >>> 3;
+        return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >>> (p & 7));
+    };
+    const shft = (p) => (p >>> 3) + (p & 7 && 1);
+    const slc = (v, s, e) => {
+        if (s == null || s < 0)
+            s = 0;
+        if (e == null || e > v.length)
+            e = v.length;
+        const n = new (v instanceof u16 ? u16 : v instanceof u32$1 ? u32$1 : u8)(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+    };
+    const max = (a) => {
+        let m = a[0];
+        for (let i = 1, count = a.length; i < count; ++i) {
+            if (a[i] > m)
+                m = a[i];
+        }
+        return m;
+    };
+    const inflt = (dat, buf, st) => {
+        const noSt = !st || st.i;
+        if (!st)
+            st = {};
+        const sl = dat.length;
+        const noBuf = !buf || !noSt;
+        if (!buf)
+            buf = new u8(sl * 3);
+        const cbuf = (l) => {
+            let bl = buf.length;
+            if (l > bl) {
+                const nbuf = new u8(Math.max(bl << 1, l));
+                nbuf.set(buf);
+                buf = nbuf;
+            }
+        };
+        let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+        if (final && !lm)
+            return buf;
+        const tbts = sl << 3;
+        do {
+            if (!lm) {
+                st.f = final = bits(dat, pos, 1);
+                const type = bits(dat, pos + 1, 3);
+                pos += 3;
+                if (!type) {
+                    const s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                    if (t > sl) {
+                        if (noSt)
+                            throw 'unexpected EOF';
+                        break;
+                    }
+                    if (noBuf)
+                        cbuf(bt + l);
+                    buf.set(dat.subarray(s, t), bt);
+                    st.b = bt += l, st.p = pos = t << 3;
+                    continue;
+                }
+                else if (type == 1)
+                    lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+                else if (type == 2) {
+                    const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                    const tl = hLit + bits(dat, pos + 5, 31) + 1;
+                    pos += 14;
+                    const ldt = new u8(tl);
+                    const clt = new u8(19);
+                    for (let i = 0; i < hcLen; ++i) {
+                        clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                    }
+                    pos += hcLen * 3;
+                    const clb = max(clt), clbmsk = (1 << clb) - 1;
+                    if (!noSt && pos + tl * (clb + 7) > tbts)
+                        break;
+                    const clm = hMap(clt, clb, 1);
+                    for (let i = 0; i < tl;) {
+                        const r = clm[bits(dat, pos, clbmsk)];
+                        pos += r & 15;
+                        const s = r >>> 4;
+                        if (s < 16) {
+                            ldt[i++] = s;
+                        }
+                        else {
+                            let c = 0, n = 0;
+                            if (s == 16)
+                                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                            else if (s == 17)
+                                n = 3 + bits(dat, pos, 7), pos += 3;
+                            else if (s == 18)
+                                n = 11 + bits(dat, pos, 127), pos += 7;
+                            while (n--)
+                                ldt[i++] = c;
+                        }
+                    }
+                    const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                    lbt = max(lt);
+                    dbt = max(dt);
+                    lm = hMap(lt, lbt, 1);
+                    dm = hMap(dt, dbt, 1);
+                }
+                else
+                    throw 'invalid block type';
+                if (pos > tbts)
+                    throw 'unexpected EOF';
+            }
+            if (noBuf)
+                cbuf(bt + 131072);
+            const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+            const mxa = lbt + dbt + 18;
+            while (noSt || pos + mxa < tbts) {
+                const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+                pos += c & 15;
+                if (pos > tbts)
+                    throw 'unexpected EOF';
+                if (!c)
+                    throw 'invalid length/literal';
+                if (sym < 256)
+                    buf[bt++] = sym;
+                else if (sym == 256) {
+                    lm = undefined;
+                    break;
+                }
+                else {
+                    let add = sym - 254;
+                    if (sym > 264) {
+                        const i = sym - 257, b = fleb[i];
+                        add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                        pos += b;
+                    }
+                    const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+                    if (!d)
+                        throw 'invalid distance';
+                    pos += d & 15;
+                    let dt = fd[dsym];
+                    if (dsym > 3) {
+                        const b = fdeb[dsym];
+                        dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;
+                    }
+                    if (pos > tbts)
+                        throw 'unexpected EOF';
+                    if (noBuf)
+                        cbuf(bt + 131072);
+                    const end = bt + add;
+                    for (; bt < end; bt += 4) {
+                        buf[bt] = buf[bt - dt];
+                        buf[bt + 1] = buf[bt + 1 - dt];
+                        buf[bt + 2] = buf[bt + 2 - dt];
+                        buf[bt + 3] = buf[bt + 3 - dt];
+                    }
+                    bt = end;
+                }
+            }
+            st.l = lm, st.p = pos, st.b = bt;
+            if (lm)
+                final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+        } while (!final);
+        return bt == buf.length ? buf : slc(buf, 0, bt);
+    };
+    const zlv = (d) => {
+        if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
+            throw 'invalid zlib data';
+        if (d[1] & 32)
+            throw 'invalid zlib data: preset dictionaries not supported';
+    };
+    function unzlibSync(data, out) {
+        return inflt((zlv(data), data.subarray(2, -4)), out);
+    }
+
+    var lenIn = 168782;
+    var lenOut = 335277;
+    var bytes_1 = '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';
+
+    const wasmBytes =  unzlibSync(base64Decode$1(bytes_1, new Uint8Array(lenIn)), new Uint8Array(lenOut));
+
+    const createWasm =  createWasmFn('crypto', wasmBytes, null);
+
+    const bridge = new Bridge(createWasm);
+    async function initBridge(createWasm) {
+        return bridge.init(createWasm);
+    }
+
+    function withWasm(fn) {
+        return (...params) => {
+            if (!bridge.wasm) {
+                throw new Error('The WASM interface has not been initialized. Ensure that you wait for the initialization Promise with waitReady() from @polkadot/wasm-crypto (or cryptoWaitReady() from @polkadot/util-crypto) before attempting to use WASM-only interfaces.');
+            }
+            return fn(bridge.wasm, ...params);
+        };
+    }
+    const bip39Generate =  withWasm((wasm, words) => {
+        wasm.ext_bip39_generate(8, words);
+        return bridge.resultString();
+    });
+    const bip39ToEntropy =  withWasm((wasm, phrase) => {
+        wasm.ext_bip39_to_entropy(8, ...bridge.allocString(phrase));
+        return bridge.resultU8a();
+    });
+    const bip39ToMiniSecret =  withWasm((wasm, phrase, password) => {
+        wasm.ext_bip39_to_mini_secret(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
+        return bridge.resultU8a();
+    });
+    const bip39ToSeed =  withWasm((wasm, phrase, password) => {
+        wasm.ext_bip39_to_seed(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
+        return bridge.resultU8a();
+    });
+    const bip39Validate =  withWasm((wasm, phrase) => {
+        const ret = wasm.ext_bip39_validate(...bridge.allocString(phrase));
+        return ret !== 0;
+    });
+    const ed25519KeypairFromSeed =  withWasm((wasm, seed) => {
+        wasm.ext_ed_from_seed(8, ...bridge.allocU8a(seed));
+        return bridge.resultU8a();
+    });
+    const ed25519Sign$1 =  withWasm((wasm, pubkey, seckey, message) => {
+        wasm.ext_ed_sign(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(seckey), ...bridge.allocU8a(message));
+        return bridge.resultU8a();
+    });
+    const ed25519Verify$1 =  withWasm((wasm, signature, message, pubkey) => {
+        const ret = wasm.ext_ed_verify(...bridge.allocU8a(signature), ...bridge.allocU8a(message), ...bridge.allocU8a(pubkey));
+        return ret !== 0;
+    });
+    const secp256k1FromSeed =  withWasm((wasm, seckey) => {
+        wasm.ext_secp_from_seed(8, ...bridge.allocU8a(seckey));
+        return bridge.resultU8a();
+    });
+    const secp256k1Compress$1 =  withWasm((wasm, pubkey) => {
+        wasm.ext_secp_pub_compress(8, ...bridge.allocU8a(pubkey));
+        return bridge.resultU8a();
+    });
+    const secp256k1Expand$1 =  withWasm((wasm, pubkey) => {
+        wasm.ext_secp_pub_expand(8, ...bridge.allocU8a(pubkey));
+        return bridge.resultU8a();
+    });
+    const secp256k1Recover$1 =  withWasm((wasm, msgHash, sig, recovery) => {
+        wasm.ext_secp_recover(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(sig), recovery);
+        return bridge.resultU8a();
+    });
+    const secp256k1Sign$1 =  withWasm((wasm, msgHash, seckey) => {
+        wasm.ext_secp_sign(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(seckey));
+        return bridge.resultU8a();
+    });
+    const sr25519DeriveKeypairHard =  withWasm((wasm, pair, cc) => {
+        wasm.ext_sr_derive_keypair_hard(8, ...bridge.allocU8a(pair), ...bridge.allocU8a(cc));
+        return bridge.resultU8a();
+    });
+    const sr25519DeriveKeypairSoft =  withWasm((wasm, pair, cc) => {
+        wasm.ext_sr_derive_keypair_soft(8, ...bridge.allocU8a(pair), ...bridge.allocU8a(cc));
+        return bridge.resultU8a();
+    });
+    const sr25519DerivePublicSoft =  withWasm((wasm, pubkey, cc) => {
+        wasm.ext_sr_derive_public_soft(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(cc));
+        return bridge.resultU8a();
+    });
+    const sr25519KeypairFromSeed =  withWasm((wasm, seed) => {
+        wasm.ext_sr_from_seed(8, ...bridge.allocU8a(seed));
+        return bridge.resultU8a();
+    });
+    const sr25519Sign$1 =  withWasm((wasm, pubkey, secret, message) => {
+        wasm.ext_sr_sign(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(secret), ...bridge.allocU8a(message));
+        return bridge.resultU8a();
+    });
+    const sr25519Verify$1 =  withWasm((wasm, signature, message, pubkey) => {
+        const ret = wasm.ext_sr_verify(...bridge.allocU8a(signature), ...bridge.allocU8a(message), ...bridge.allocU8a(pubkey));
+        return ret !== 0;
+    });
+    const sr25519Agree =  withWasm((wasm, pubkey, secret) => {
+        wasm.ext_sr_agree(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(secret));
+        return bridge.resultU8a();
+    });
+    const vrfSign =  withWasm((wasm, secret, context, message, extra) => {
+        wasm.ext_vrf_sign(8, ...bridge.allocU8a(secret), ...bridge.allocU8a(context), ...bridge.allocU8a(message), ...bridge.allocU8a(extra));
+        return bridge.resultU8a();
+    });
+    const vrfVerify =  withWasm((wasm, pubkey, context, message, extra, outAndProof) => {
+        const ret = wasm.ext_vrf_verify(...bridge.allocU8a(pubkey), ...bridge.allocU8a(context), ...bridge.allocU8a(message), ...bridge.allocU8a(extra), ...bridge.allocU8a(outAndProof));
+        return ret !== 0;
+    });
+    const blake2b$1 =  withWasm((wasm, data, key, size) => {
+        wasm.ext_blake2b(8, ...bridge.allocU8a(data), ...bridge.allocU8a(key), size);
+        return bridge.resultU8a();
+    });
+    const hmacSha256 =  withWasm((wasm, key, data) => {
+        wasm.ext_hmac_sha256(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const hmacSha512 =  withWasm((wasm, key, data) => {
+        wasm.ext_hmac_sha512(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const keccak256 =  withWasm((wasm, data) => {
+        wasm.ext_keccak256(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const keccak512 =  withWasm((wasm, data) => {
+        wasm.ext_keccak512(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const pbkdf2$1 =  withWasm((wasm, data, salt, rounds) => {
+        wasm.ext_pbkdf2(8, ...bridge.allocU8a(data), ...bridge.allocU8a(salt), rounds);
+        return bridge.resultU8a();
+    });
+    const scrypt$1 =  withWasm((wasm, password, salt, log2n, r, p) => {
+        wasm.ext_scrypt(8, ...bridge.allocU8a(password), ...bridge.allocU8a(salt), log2n, r, p);
+        return bridge.resultU8a();
+    });
+    const sha256$1 =  withWasm((wasm, data) => {
+        wasm.ext_sha256(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const sha512$1 =  withWasm((wasm, data) => {
+        wasm.ext_sha512(8, ...bridge.allocU8a(data));
+        return bridge.resultU8a();
+    });
+    const twox =  withWasm((wasm, data, rounds) => {
+        wasm.ext_twox(8, ...bridge.allocU8a(data), rounds);
+        return bridge.resultU8a();
+    });
+    function isReady() {
+        return !!bridge.wasm;
+    }
+    async function waitReady() {
+        try {
+            const wasm = await initBridge();
+            return !!wasm;
+        }
+        catch {
+            return false;
+        }
+    }
+
+    const cryptoIsReady = isReady;
+    function cryptoWaitReady() {
+        return waitReady()
+            .then(() => {
+            if (!isReady()) {
+                throw new Error('Unable to initialize @polkadot/util-crypto');
+            }
+            return true;
+        })
+            .catch(() => false);
+    }
+
+    cryptoWaitReady().catch(() => {
+    });
+
+    const packageInfo = { name: '@polkadot/util-crypto', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util-crypto.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '13.5.9' };
+
+    /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    function assertNumber(n) {
+        if (!Number.isSafeInteger(n))
+            throw new Error(`Wrong integer: ${n}`);
+    }
+    function isBytes$3(a) {
+        return (a instanceof Uint8Array ||
+            (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    }
+    function chain(...args) {
+        const id = (a) => a;
+        const wrap = (a, b) => (c) => a(b(c));
+        const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+        const decode = args.map((x) => x.decode).reduce(wrap, id);
+        return { encode, decode };
+    }
+    function alphabet(alphabet) {
+        return {
+            encode: (digits) => {
+                if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))
+                    throw new Error('alphabet.encode input should be an array of numbers');
+                return digits.map((i) => {
+                    assertNumber(i);
+                    if (i < 0 || i >= alphabet.length)
+                        throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`);
+                    return alphabet[i];
+                });
+            },
+            decode: (input) => {
+                if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string'))
+                    throw new Error('alphabet.decode input should be array of strings');
+                return input.map((letter) => {
+                    if (typeof letter !== 'string')
+                        throw new Error(`alphabet.decode: not string element=${letter}`);
+                    const index = alphabet.indexOf(letter);
+                    if (index === -1)
+                        throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`);
+                    return index;
+                });
+            },
+        };
+    }
+    function join(separator = '') {
+        if (typeof separator !== 'string')
+            throw new Error('join separator should be string');
+        return {
+            encode: (from) => {
+                if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string'))
+                    throw new Error('join.encode input should be array of strings');
+                for (let i of from)
+                    if (typeof i !== 'string')
+                        throw new Error(`join.encode: non-string input=${i}`);
+                return from.join(separator);
+            },
+            decode: (to) => {
+                if (typeof to !== 'string')
+                    throw new Error('join.decode input should be string');
+                return to.split(separator);
+            },
+        };
+    }
+    function padding(bits, chr = '=') {
+        assertNumber(bits);
+        if (typeof chr !== 'string')
+            throw new Error('padding chr should be string');
+        return {
+            encode(data) {
+                if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string'))
+                    throw new Error('padding.encode input should be array of strings');
+                for (let i of data)
+                    if (typeof i !== 'string')
+                        throw new Error(`padding.encode: non-string input=${i}`);
+                while ((data.length * bits) % 8)
+                    data.push(chr);
+                return data;
+            },
+            decode(input) {
+                if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string'))
+                    throw new Error('padding.encode input should be array of strings');
+                for (let i of input)
+                    if (typeof i !== 'string')
+                        throw new Error(`padding.decode: non-string input=${i}`);
+                let end = input.length;
+                if ((end * bits) % 8)
+                    throw new Error('Invalid padding: string should have whole number of bytes');
+                for (; end > 0 && input[end - 1] === chr; end--) {
+                    if (!(((end - 1) * bits) % 8))
+                        throw new Error('Invalid padding: string has too much padding');
+                }
+                return input.slice(0, end);
+            },
+        };
+    }
+    function normalize$1(fn) {
+        if (typeof fn !== 'function')
+            throw new Error('normalize fn should be function');
+        return { encode: (from) => from, decode: (to) => fn(to) };
+    }
+    function convertRadix(data, from, to) {
+        if (from < 2)
+            throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`);
+        if (to < 2)
+            throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`);
+        if (!Array.isArray(data))
+            throw new Error('convertRadix: data should be array');
+        if (!data.length)
+            return [];
+        let pos = 0;
+        const res = [];
+        const digits = Array.from(data);
+        digits.forEach((d) => {
+            assertNumber(d);
+            if (d < 0 || d >= from)
+                throw new Error(`Wrong integer: ${d}`);
+        });
+        while (true) {
+            let carry = 0;
+            let done = true;
+            for (let i = pos; i < digits.length; i++) {
+                const digit = digits[i];
+                const digitBase = from * carry + digit;
+                if (!Number.isSafeInteger(digitBase) ||
+                    (from * carry) / from !== carry ||
+                    digitBase - digit !== from * carry) {
+                    throw new Error('convertRadix: carry overflow');
+                }
+                carry = digitBase % to;
+                const rounded = Math.floor(digitBase / to);
+                digits[i] = rounded;
+                if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+                    throw new Error('convertRadix: carry overflow');
+                if (!done)
+                    continue;
+                else if (!rounded)
+                    pos = i;
+                else
+                    done = false;
+            }
+            res.push(carry);
+            if (done)
+                break;
+        }
+        for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+            res.push(0);
+        return res.reverse();
+    }
+    const gcd =  (a, b) => (!b ? a : gcd(b, a % b));
+    const radix2carry =  (from, to) => from + (to - gcd(from, to));
+    function convertRadix2(data, from, to, padding) {
+        if (!Array.isArray(data))
+            throw new Error('convertRadix2: data should be array');
+        if (from <= 0 || from > 32)
+            throw new Error(`convertRadix2: wrong from=${from}`);
+        if (to <= 0 || to > 32)
+            throw new Error(`convertRadix2: wrong to=${to}`);
+        if (radix2carry(from, to) > 32) {
+            throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+        }
+        let carry = 0;
+        let pos = 0;
+        const mask = 2 ** to - 1;
+        const res = [];
+        for (const n of data) {
+            assertNumber(n);
+            if (n >= 2 ** from)
+                throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+            carry = (carry << from) | n;
+            if (pos + from > 32)
+                throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+            pos += from;
+            for (; pos >= to; pos -= to)
+                res.push(((carry >> (pos - to)) & mask) >>> 0);
+            carry &= 2 ** pos - 1;
+        }
+        carry = (carry << (to - pos)) & mask;
+        if (!padding && pos >= from)
+            throw new Error('Excess padding');
+        if (!padding && carry)
+            throw new Error(`Non-zero padding: ${carry}`);
+        if (padding && pos > 0)
+            res.push(carry >>> 0);
+        return res;
+    }
+    function radix(num) {
+        assertNumber(num);
+        return {
+            encode: (bytes) => {
+                if (!isBytes$3(bytes))
+                    throw new Error('radix.encode input should be Uint8Array');
+                return convertRadix(Array.from(bytes), 2 ** 8, num);
+            },
+            decode: (digits) => {
+                if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))
+                    throw new Error('radix.decode input should be array of numbers');
+                return Uint8Array.from(convertRadix(digits, num, 2 ** 8));
+            },
+        };
+    }
+    function radix2(bits, revPadding = false) {
+        assertNumber(bits);
+        if (bits <= 0 || bits > 32)
+            throw new Error('radix2: bits should be in (0..32]');
+        if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+            throw new Error('radix2: carry overflow');
+        return {
+            encode: (bytes) => {
+                if (!isBytes$3(bytes))
+                    throw new Error('radix2.encode input should be Uint8Array');
+                return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+            },
+            decode: (digits) => {
+                if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))
+                    throw new Error('radix2.decode input should be array of numbers');
+                return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+            },
+        };
+    }
+    function unsafeWrapper(fn) {
+        if (typeof fn !== 'function')
+            throw new Error('unsafeWrapper fn should be function');
+        return function (...args) {
+            try {
+                return fn.apply(null, args);
+            }
+            catch (e) { }
+        };
+    }
+    function checksum(len, fn) {
+        assertNumber(len);
+        if (typeof fn !== 'function')
+            throw new Error('checksum fn should be function');
+        return {
+            encode(data) {
+                if (!isBytes$3(data))
+                    throw new Error('checksum.encode: input should be Uint8Array');
+                const checksum = fn(data).slice(0, len);
+                const res = new Uint8Array(data.length + len);
+                res.set(data);
+                res.set(checksum, data.length);
+                return res;
+            },
+            decode(data) {
+                if (!isBytes$3(data))
+                    throw new Error('checksum.decode: input should be Uint8Array');
+                const payload = data.slice(0, -len);
+                const newChecksum = fn(payload).slice(0, len);
+                const oldChecksum = data.slice(-len);
+                for (let i = 0; i < len; i++)
+                    if (newChecksum[i] !== oldChecksum[i])
+                        throw new Error('Invalid checksum');
+                return payload;
+            },
+        };
+    }
+    const utils = {
+        alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,
+    };
+    chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));
+    chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));
+    chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));
+    chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));
+    chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));
+    chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize$1((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));
+    const base64 =  chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));
+    chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));
+    chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));
+    chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), join(''));
+    const genBase58 = (abc) => chain(radix(58), alphabet(abc), join(''));
+    const base58 =  genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+    genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');
+    genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');
+    const BECH_ALPHABET =  chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));
+    const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+    function bech32Polymod(pre) {
+        const b = pre >> 25;
+        let chk = (pre & 0x1ffffff) << 5;
+        for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
+            if (((b >> i) & 1) === 1)
+                chk ^= POLYMOD_GENERATORS[i];
+        }
+        return chk;
+    }
+    function bechChecksum(prefix, words, encodingConst = 1) {
+        const len = prefix.length;
+        let chk = 1;
+        for (let i = 0; i < len; i++) {
+            const c = prefix.charCodeAt(i);
+            if (c < 33 || c > 126)
+                throw new Error(`Invalid prefix (${prefix})`);
+            chk = bech32Polymod(chk) ^ (c >> 5);
+        }
+        chk = bech32Polymod(chk);
+        for (let i = 0; i < len; i++)
+            chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);
+        for (let v of words)
+            chk = bech32Polymod(chk) ^ v;
+        for (let i = 0; i < 6; i++)
+            chk = bech32Polymod(chk);
+        chk ^= encodingConst;
+        return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false));
+    }
+    function genBech32(encoding) {
+        const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;
+        const _words = radix2(5);
+        const fromWords = _words.decode;
+        const toWords = _words.encode;
+        const fromWordsUnsafe = unsafeWrapper(fromWords);
+        function encode(prefix, words, limit = 90) {
+            if (typeof prefix !== 'string')
+                throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`);
+            if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number'))
+                throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`);
+            if (prefix.length === 0)
+                throw new TypeError(`Invalid prefix length ${prefix.length}`);
+            const actualLength = prefix.length + 7 + words.length;
+            if (limit !== false && actualLength > limit)
+                throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+            const lowered = prefix.toLowerCase();
+            const sum = bechChecksum(lowered, words, ENCODING_CONST);
+            return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+        }
+        function decode(str, limit = 90) {
+            if (typeof str !== 'string')
+                throw new Error(`bech32.decode input should be string, not ${typeof str}`);
+            if (str.length < 8 || (limit !== false && str.length > limit))
+                throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`);
+            const lowered = str.toLowerCase();
+            if (str !== lowered && str !== str.toUpperCase())
+                throw new Error(`String must be lowercase or uppercase`);
+            const sepIndex = lowered.lastIndexOf('1');
+            if (sepIndex === 0 || sepIndex === -1)
+                throw new Error(`Letter "1" must be present between prefix and data only`);
+            const prefix = lowered.slice(0, sepIndex);
+            const data = lowered.slice(sepIndex + 1);
+            if (data.length < 6)
+                throw new Error('Data must be at least 6 characters long');
+            const words = BECH_ALPHABET.decode(data).slice(0, -6);
+            const sum = bechChecksum(prefix, words, ENCODING_CONST);
+            if (!data.endsWith(sum))
+                throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+            return { prefix, words };
+        }
+        const decodeUnsafe = unsafeWrapper(decode);
+        function decodeToBytes(str) {
+            const { prefix, words } = decode(str, false);
+            return { prefix, words, bytes: fromWords(words) };
+        }
+        return { encode, decode, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords };
+    }
+    genBech32('bech32');
+    genBech32('bech32m');
+    chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize$1((s) => {
+        if (typeof s !== 'string' || s.length % 2)
+            throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+        return s.toLowerCase();
+    }));
+
+    function createDecode({ coder, ipfs }, validate) {
+        return (value, ipfsCompat) => {
+            validate(value, ipfsCompat);
+            return coder.decode(ipfs && ipfsCompat
+                ? value.substring(1)
+                : value);
+        };
+    }
+    function createEncode({ coder, ipfs }) {
+        return (value, ipfsCompat) => {
+            const out = coder.encode(util.u8aToU8a(value));
+            return ipfs && ipfsCompat
+                ? `${ipfs}${out}`
+                : out;
+        };
+    }
+    function createIs(validate) {
+        return (value, ipfsCompat) => {
+            try {
+                return validate(value, ipfsCompat);
+            }
+            catch {
+                return false;
+            }
+        };
+    }
+    function createValidate({ chars, ipfs, type, withPadding }) {
+        return (value, ipfsCompat) => {
+            if (typeof value !== 'string') {
+                throw new Error(`Expected ${type} string input`);
+            }
+            else if (ipfs && ipfsCompat && !value.startsWith(ipfs)) {
+                throw new Error(`Expected ipfs-compatible ${type} to start with '${ipfs}'`);
+            }
+            for (let i = (ipfsCompat ? 1 : 0), count = value.length; i < count; i++) {
+                if (chars.includes(value[i])) ;
+                else if (withPadding && value[i] === '=') {
+                    if (i === count - 1) ;
+                    else if (value[i + 1] === '=') ;
+                    else {
+                        throw new Error(`Invalid ${type} padding sequence "${value[i]}${value[i + 1]}" at index ${i}`);
+                    }
+                }
+                else {
+                    throw new Error(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+                }
+            }
+            return true;
+        };
+    }
+
+    const config$2 = {
+        chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+        coder: base58,
+        ipfs: 'z',
+        type: 'base58'
+    };
+    const base58Validate =  createValidate(config$2);
+    const base58Decode =  createDecode(config$2, base58Validate);
+    const base58Encode =  createEncode(config$2);
+    const isBase58 =  createIs(base58Validate);
+
+    function number(n) {
+        if (!Number.isSafeInteger(n) || n < 0)
+            throw new Error(`Wrong positive integer: ${n}`);
+    }
+    function isBytes$2(a) {
+        return (a instanceof Uint8Array ||
+            (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    }
+    function bytes(b, ...lengths) {
+        if (!isBytes$2(b))
+            throw new Error('Expected Uint8Array');
+        if (lengths.length > 0 && !lengths.includes(b.length))
+            throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+    }
+    function hash(hash) {
+        if (typeof hash !== 'function' || typeof hash.create !== 'function')
+            throw new Error('Hash should be wrapped by utils.wrapConstructor');
+        number(hash.outputLen);
+        number(hash.blockLen);
+    }
+    function exists(instance, checkFinished = true) {
+        if (instance.destroyed)
+            throw new Error('Hash instance has been destroyed');
+        if (checkFinished && instance.finished)
+            throw new Error('Hash#digest() has already been called');
+    }
+    function output(out, instance) {
+        bytes(out);
+        const min = instance.outputLen;
+        if (out.length < min) {
+            throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+        }
+    }
+
+    const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+
+    /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    function isBytes$1(a) {
+        return (a instanceof Uint8Array ||
+            (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    }
+    const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
+    const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+    if (!isLE)
+        throw new Error('Non little-endian hardware is not supported');
+    Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+    function utf8ToBytes$1(str) {
+        if (typeof str !== 'string')
+            throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+        return new Uint8Array(new TextEncoder().encode(str));
+    }
+    function toBytes(data) {
+        if (typeof data === 'string')
+            data = utf8ToBytes$1(data);
+        if (!isBytes$1(data))
+            throw new Error(`expected Uint8Array, got ${typeof data}`);
+        return data;
+    }
+    function concatBytes$1(...arrays) {
+        let sum = 0;
+        for (let i = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            if (!isBytes$1(a))
+                throw new Error('Uint8Array expected');
+            sum += a.length;
+        }
+        const res = new Uint8Array(sum);
+        for (let i = 0, pad = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            res.set(a, pad);
+            pad += a.length;
+        }
+        return res;
+    }
+    class Hash {
+        clone() {
+            return this._cloneInto();
+        }
+    }
+    const toStr = {}.toString;
+    function checkOpts(defaults, opts) {
+        if (opts !== undefined && toStr.call(opts) !== '[object Object]')
+            throw new Error('Options should be object or undefined');
+        const merged = Object.assign(defaults, opts);
+        return merged;
+    }
+    function wrapConstructor(hashCons) {
+        const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+        const tmp = hashCons();
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = () => hashCons();
+        return hashC;
+    }
+    function wrapConstructorWithOpts(hashCons) {
+        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+        const tmp = hashCons({});
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = (opts) => hashCons(opts);
+        return hashC;
+    }
+    function wrapXOFConstructorWithOpts(hashCons) {
+        const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+        const tmp = hashCons({});
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = (opts) => hashCons(opts);
+        return hashC;
+    }
+    function randomBytes(bytesLength = 32) {
+        if (crypto && typeof crypto.getRandomValues === 'function') {
+            return crypto.getRandomValues(new Uint8Array(bytesLength));
+        }
+        throw new Error('crypto.getRandomValues must be defined');
+    }
+
+    const SIGMA =  new Uint8Array([
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+        11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+        7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+        9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+        2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+        12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+        13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+        6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+        10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    ]);
+    class BLAKE2 extends Hash {
+        constructor(blockLen, outputLen, opts = {}, keyLen, saltLen, persLen) {
+            super();
+            this.blockLen = blockLen;
+            this.outputLen = outputLen;
+            this.length = 0;
+            this.pos = 0;
+            this.finished = false;
+            this.destroyed = false;
+            number(blockLen);
+            number(outputLen);
+            number(keyLen);
+            if (outputLen < 0 || outputLen > keyLen)
+                throw new Error('outputLen bigger than keyLen');
+            if (opts.key !== undefined && (opts.key.length < 1 || opts.key.length > keyLen))
+                throw new Error(`key must be up 1..${keyLen} byte long or undefined`);
+            if (opts.salt !== undefined && opts.salt.length !== saltLen)
+                throw new Error(`salt must be ${saltLen} byte long or undefined`);
+            if (opts.personalization !== undefined && opts.personalization.length !== persLen)
+                throw new Error(`personalization must be ${persLen} byte long or undefined`);
+            this.buffer32 = u32((this.buffer = new Uint8Array(blockLen)));
+        }
+        update(data) {
+            exists(this);
+            const { blockLen, buffer, buffer32 } = this;
+            data = toBytes(data);
+            const len = data.length;
+            const offset = data.byteOffset;
+            const buf = data.buffer;
+            for (let pos = 0; pos < len;) {
+                if (this.pos === blockLen) {
+                    this.compress(buffer32, 0, false);
+                    this.pos = 0;
+                }
+                const take = Math.min(blockLen - this.pos, len - pos);
+                const dataOffset = offset + pos;
+                if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+                    const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+                    for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+                        this.length += blockLen;
+                        this.compress(data32, pos32, false);
+                    }
+                    continue;
+                }
+                buffer.set(data.subarray(pos, pos + take), this.pos);
+                this.pos += take;
+                this.length += take;
+                pos += take;
+            }
+            return this;
+        }
+        digestInto(out) {
+            exists(this);
+            output(out, this);
+            const { pos, buffer32 } = this;
+            this.finished = true;
+            this.buffer.subarray(pos).fill(0);
+            this.compress(buffer32, 0, true);
+            const out32 = u32(out);
+            this.get().forEach((v, i) => (out32[i] = v));
+        }
+        digest() {
+            const { buffer, outputLen } = this;
+            this.digestInto(buffer);
+            const res = buffer.slice(0, outputLen);
+            this.destroy();
+            return res;
+        }
+        _cloneInto(to) {
+            const { buffer, length, finished, destroyed, outputLen, pos } = this;
+            to || (to = new this.constructor({ dkLen: outputLen }));
+            to.set(...this.get());
+            to.length = length;
+            to.finished = finished;
+            to.destroyed = destroyed;
+            to.outputLen = outputLen;
+            to.buffer.set(buffer);
+            to.pos = pos;
+            return to;
+        }
+    }
+
+    const U32_MASK64 =  BigInt(2 ** 32 - 1);
+    const _32n$1 =  BigInt(32);
+    function fromBig(n, le = false) {
+        if (le)
+            return { h: Number(n & U32_MASK64), l: Number((n >> _32n$1) & U32_MASK64) };
+        return { h: Number((n >> _32n$1) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+    }
+    function split(lst, le = false) {
+        let Ah = new Uint32Array(lst.length);
+        let Al = new Uint32Array(lst.length);
+        for (let i = 0; i < lst.length; i++) {
+            const { h, l } = fromBig(lst[i], le);
+            [Ah[i], Al[i]] = [h, l];
+        }
+        return [Ah, Al];
+    }
+    const toBig = (h, l) => (BigInt(h >>> 0) << _32n$1) | BigInt(l >>> 0);
+    const shrSH = (h, _l, s) => h >>> s;
+    const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+    const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+    const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+    const rotr32H = (_h, l) => l;
+    const rotr32L = (h, _l) => h;
+    const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+    const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+    const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+    const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+    function add(Ah, Al, Bh, Bl) {
+        const l = (Al >>> 0) + (Bl >>> 0);
+        return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+    }
+    const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+    const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+    const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+    const u64 = {
+        fromBig, split, toBig,
+        shrSH, shrSL,
+        rotrSH, rotrSL, rotrBH, rotrBL,
+        rotr32H, rotr32L,
+        rotlSH, rotlSL, rotlBH, rotlBL,
+        add, add3L, add3H, add4L, add4H, add5H, add5L,
+    };
+
+    const IV$1 =  new Uint32Array([
+        0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
+        0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19
+    ]);
+    const BUF =  new Uint32Array(32);
+    function G1(a, b, c, d, msg, x) {
+        const Xl = msg[x], Xh = msg[x + 1];
+        let Al = BUF[2 * a], Ah = BUF[2 * a + 1];
+        let Bl = BUF[2 * b], Bh = BUF[2 * b + 1];
+        let Cl = BUF[2 * c], Ch = BUF[2 * c + 1];
+        let Dl = BUF[2 * d], Dh = BUF[2 * d + 1];
+        let ll = u64.add3L(Al, Bl, Xl);
+        Ah = u64.add3H(ll, Ah, Bh, Xh);
+        Al = ll | 0;
+        ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+        ({ Dh, Dl } = { Dh: u64.rotr32H(Dh, Dl), Dl: u64.rotr32L(Dh, Dl) });
+        ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+        ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+        ({ Bh, Bl } = { Bh: u64.rotrSH(Bh, Bl, 24), Bl: u64.rotrSL(Bh, Bl, 24) });
+        (BUF[2 * a] = Al), (BUF[2 * a + 1] = Ah);
+        (BUF[2 * b] = Bl), (BUF[2 * b + 1] = Bh);
+        (BUF[2 * c] = Cl), (BUF[2 * c + 1] = Ch);
+        (BUF[2 * d] = Dl), (BUF[2 * d + 1] = Dh);
+    }
+    function G2(a, b, c, d, msg, x) {
+        const Xl = msg[x], Xh = msg[x + 1];
+        let Al = BUF[2 * a], Ah = BUF[2 * a + 1];
+        let Bl = BUF[2 * b], Bh = BUF[2 * b + 1];
+        let Cl = BUF[2 * c], Ch = BUF[2 * c + 1];
+        let Dl = BUF[2 * d], Dh = BUF[2 * d + 1];
+        let ll = u64.add3L(Al, Bl, Xl);
+        Ah = u64.add3H(ll, Ah, Bh, Xh);
+        Al = ll | 0;
+        ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
+        ({ Dh, Dl } = { Dh: u64.rotrSH(Dh, Dl, 16), Dl: u64.rotrSL(Dh, Dl, 16) });
+        ({ h: Ch, l: Cl } = u64.add(Ch, Cl, Dh, Dl));
+        ({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
+        ({ Bh, Bl } = { Bh: u64.rotrBH(Bh, Bl, 63), Bl: u64.rotrBL(Bh, Bl, 63) });
+        (BUF[2 * a] = Al), (BUF[2 * a + 1] = Ah);
+        (BUF[2 * b] = Bl), (BUF[2 * b + 1] = Bh);
+        (BUF[2 * c] = Cl), (BUF[2 * c + 1] = Ch);
+        (BUF[2 * d] = Dl), (BUF[2 * d + 1] = Dh);
+    }
+    class BLAKE2b extends BLAKE2 {
+        constructor(opts = {}) {
+            super(128, opts.dkLen === undefined ? 64 : opts.dkLen, opts, 64, 16, 16);
+            this.v0l = IV$1[0] | 0;
+            this.v0h = IV$1[1] | 0;
+            this.v1l = IV$1[2] | 0;
+            this.v1h = IV$1[3] | 0;
+            this.v2l = IV$1[4] | 0;
+            this.v2h = IV$1[5] | 0;
+            this.v3l = IV$1[6] | 0;
+            this.v3h = IV$1[7] | 0;
+            this.v4l = IV$1[8] | 0;
+            this.v4h = IV$1[9] | 0;
+            this.v5l = IV$1[10] | 0;
+            this.v5h = IV$1[11] | 0;
+            this.v6l = IV$1[12] | 0;
+            this.v6h = IV$1[13] | 0;
+            this.v7l = IV$1[14] | 0;
+            this.v7h = IV$1[15] | 0;
+            const keyLength = opts.key ? opts.key.length : 0;
+            this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+            if (opts.salt) {
+                const salt = u32(toBytes(opts.salt));
+                this.v4l ^= salt[0];
+                this.v4h ^= salt[1];
+                this.v5l ^= salt[2];
+                this.v5h ^= salt[3];
+            }
+            if (opts.personalization) {
+                const pers = u32(toBytes(opts.personalization));
+                this.v6l ^= pers[0];
+                this.v6h ^= pers[1];
+                this.v7l ^= pers[2];
+                this.v7h ^= pers[3];
+            }
+            if (opts.key) {
+                const tmp = new Uint8Array(this.blockLen);
+                tmp.set(toBytes(opts.key));
+                this.update(tmp);
+            }
+        }
+        get() {
+            let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+            return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+        }
+        set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+            this.v0l = v0l | 0;
+            this.v0h = v0h | 0;
+            this.v1l = v1l | 0;
+            this.v1h = v1h | 0;
+            this.v2l = v2l | 0;
+            this.v2h = v2h | 0;
+            this.v3l = v3l | 0;
+            this.v3h = v3h | 0;
+            this.v4l = v4l | 0;
+            this.v4h = v4h | 0;
+            this.v5l = v5l | 0;
+            this.v5h = v5h | 0;
+            this.v6l = v6l | 0;
+            this.v6h = v6h | 0;
+            this.v7l = v7l | 0;
+            this.v7h = v7h | 0;
+        }
+        compress(msg, offset, isLast) {
+            this.get().forEach((v, i) => (BUF[i] = v));
+            BUF.set(IV$1, 16);
+            let { h, l } = u64.fromBig(BigInt(this.length));
+            BUF[24] = IV$1[8] ^ l;
+            BUF[25] = IV$1[9] ^ h;
+            if (isLast) {
+                BUF[28] = ~BUF[28];
+                BUF[29] = ~BUF[29];
+            }
+            let j = 0;
+            const s = SIGMA;
+            for (let i = 0; i < 12; i++) {
+                G1(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+                G2(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+                G1(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+                G2(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+                G1(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+                G2(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+                G1(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+                G2(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+                G1(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+                G2(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+                G1(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+                G2(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+                G1(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+                G2(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+                G1(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+                G2(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+            }
+            this.v0l ^= BUF[0] ^ BUF[16];
+            this.v0h ^= BUF[1] ^ BUF[17];
+            this.v1l ^= BUF[2] ^ BUF[18];
+            this.v1h ^= BUF[3] ^ BUF[19];
+            this.v2l ^= BUF[4] ^ BUF[20];
+            this.v2h ^= BUF[5] ^ BUF[21];
+            this.v3l ^= BUF[6] ^ BUF[22];
+            this.v3h ^= BUF[7] ^ BUF[23];
+            this.v4l ^= BUF[8] ^ BUF[24];
+            this.v4h ^= BUF[9] ^ BUF[25];
+            this.v5l ^= BUF[10] ^ BUF[26];
+            this.v5h ^= BUF[11] ^ BUF[27];
+            this.v6l ^= BUF[12] ^ BUF[28];
+            this.v6h ^= BUF[13] ^ BUF[29];
+            this.v7l ^= BUF[14] ^ BUF[30];
+            this.v7h ^= BUF[15] ^ BUF[31];
+            BUF.fill(0);
+        }
+        destroy() {
+            this.destroyed = true;
+            this.buffer32.fill(0);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+    const blake2b =  wrapConstructorWithOpts((opts) => new BLAKE2b(opts));
+
+    function createAsHex(fn) {
+        return (...args) => util.u8aToHex(fn(...args));
+    }
+    function createBitHasher(bitLength, fn) {
+        return (data, onlyJs) => fn(data, bitLength, onlyJs);
+    }
+    function createDualHasher(wa, js) {
+        return (value, bitLength = 256, onlyJs) => {
+            const u8a = util.u8aToU8a(value);
+            return !util.hasBigInt || (!onlyJs && isReady())
+                ? wa[bitLength](u8a)
+                : js[bitLength](u8a);
+        };
+    }
+
+    function blake2AsU8a(data, bitLength = 256, key, onlyJs) {
+        const byteLength = Math.ceil(bitLength / 8);
+        const u8a = util.u8aToU8a(data);
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? blake2b$1(u8a, util.u8aToU8a(key), byteLength)
+            : key
+                ? blake2b(u8a, { dkLen: byteLength, key })
+                : blake2b(u8a, { dkLen: byteLength });
+    }
+    const blake2AsHex =  createAsHex(blake2AsU8a);
+
+    const SS58_PREFIX = util.stringToU8a('SS58PRE');
+    function sshash(key) {
+        return blake2AsU8a(util.u8aConcat(SS58_PREFIX, key), 512);
+    }
+
+    function checkAddressChecksum(decoded) {
+        const ss58Length = (decoded[0] & 0b0100_0000) ? 2 : 1;
+        const ss58Decoded = ss58Length === 1
+            ? decoded[0]
+            : ((decoded[0] & 0b0011_1111) << 2) | (decoded[1] >> 6) | ((decoded[1] & 0b0011_1111) << 8);
+        const isPublicKey = [34 + ss58Length, 35 + ss58Length].includes(decoded.length);
+        const length = decoded.length - (isPublicKey ? 2 : 1);
+        const hash = sshash(decoded.subarray(0, length));
+        const isValid = (decoded[0] & 0b1000_0000) === 0 && ![46, 47].includes(decoded[0]) && (isPublicKey
+            ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
+            : decoded[decoded.length - 1] === hash[0]);
+        return [isValid, length, ss58Length, ss58Decoded];
+    }
+
+    const knownSubstrate = [
+    	{
+    		"prefix": 0,
+    		"network": "polkadot",
+    		"displayName": "Polkadot Relay Chain",
+    		"symbols": [
+    			"DOT"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://polkadot.network"
+    	},
+    	{
+    		"prefix": 1,
+    		"network": "BareSr25519",
+    		"displayName": "Bare 32-bit Schnorr/Ristretto (S/R 25519) public key.",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "Sr25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 2,
+    		"network": "kusama",
+    		"displayName": "Kusama Relay Chain",
+    		"symbols": [
+    			"KSM"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://kusama.network"
+    	},
+    	{
+    		"prefix": 3,
+    		"network": "BareEd25519",
+    		"displayName": "Bare 32-bit Ed25519 public key.",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "Ed25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 4,
+    		"network": "katalchain",
+    		"displayName": "Katal Chain",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 5,
+    		"network": "astar",
+    		"displayName": "Astar Network",
+    		"symbols": [
+    			"ASTR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://astar.network"
+    	},
+    	{
+    		"prefix": 6,
+    		"network": "bifrost",
+    		"displayName": "Bifrost",
+    		"symbols": [
+    			"BNC"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://bifrost.finance/"
+    	},
+    	{
+    		"prefix": 7,
+    		"network": "edgeware",
+    		"displayName": "Edgeware",
+    		"symbols": [
+    			"EDG"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://edgewa.re"
+    	},
+    	{
+    		"prefix": 8,
+    		"network": "karura",
+    		"displayName": "Karura",
+    		"symbols": [
+    			"KAR"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://karura.network/"
+    	},
+    	{
+    		"prefix": 9,
+    		"network": "reynolds",
+    		"displayName": "Laminar Reynolds Canary",
+    		"symbols": [
+    			"REY"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "http://laminar.network/"
+    	},
+    	{
+    		"prefix": 10,
+    		"network": "acala",
+    		"displayName": "Acala",
+    		"symbols": [
+    			"ACA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://acala.network/"
+    	},
+    	{
+    		"prefix": 11,
+    		"network": "laminar",
+    		"displayName": "Laminar",
+    		"symbols": [
+    			"LAMI"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "http://laminar.network/"
+    	},
+    	{
+    		"prefix": 12,
+    		"network": "polymesh",
+    		"displayName": "Polymesh",
+    		"symbols": [
+    			"POLYX"
+    		],
+    		"decimals": [
+    			6
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://polymath.network/"
+    	},
+    	{
+    		"prefix": 13,
+    		"network": "integritee",
+    		"displayName": "Integritee",
+    		"symbols": [
+    			"TEER"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://integritee.network"
+    	},
+    	{
+    		"prefix": 14,
+    		"network": "totem",
+    		"displayName": "Totem",
+    		"symbols": [
+    			"TOTEM"
+    		],
+    		"decimals": [
+    			0
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://totemaccounting.com"
+    	},
+    	{
+    		"prefix": 15,
+    		"network": "synesthesia",
+    		"displayName": "Synesthesia",
+    		"symbols": [
+    			"SYN"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://synesthesia.network/"
+    	},
+    	{
+    		"prefix": 16,
+    		"network": "kulupu",
+    		"displayName": "Kulupu",
+    		"symbols": [
+    			"KLP"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://kulupu.network/"
+    	},
+    	{
+    		"prefix": 17,
+    		"network": "dark",
+    		"displayName": "Dark Mainnet",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 18,
+    		"network": "darwinia",
+    		"displayName": "Darwinia Network",
+    		"symbols": [
+    			"RING"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "secp256k1",
+    		"website": "https://darwinia.network"
+    	},
+    	{
+    		"prefix": 19,
+    		"network": "watr",
+    		"displayName": "Watr Protocol",
+    		"symbols": [
+    			"WATR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.watr.org"
+    	},
+    	{
+    		"prefix": 20,
+    		"network": "stafi",
+    		"displayName": "Stafi",
+    		"symbols": [
+    			"FIS"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://stafi.io"
+    	},
+    	{
+    		"prefix": 21,
+    		"network": "karmachain",
+    		"displayName": "Karmacoin",
+    		"symbols": [
+    			"KCOIN"
+    		],
+    		"decimals": [
+    			6
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://karmaco.in"
+    	},
+    	{
+    		"prefix": 22,
+    		"network": "dock-pos-mainnet",
+    		"displayName": "Dock Mainnet",
+    		"symbols": [
+    			"DCK"
+    		],
+    		"decimals": [
+    			6
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://dock.io"
+    	},
+    	{
+    		"prefix": 23,
+    		"network": "shift",
+    		"displayName": "ShiftNrg",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 24,
+    		"network": "zero",
+    		"displayName": "ZERO",
+    		"symbols": [
+    			"ZERO"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://zero.io"
+    	},
+    	{
+    		"prefix": 25,
+    		"network": "zero-alphaville",
+    		"displayName": "ZERO Alphaville",
+    		"symbols": [
+    			"ZERO"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://zero.io"
+    	},
+    	{
+    		"prefix": 26,
+    		"network": "jupiter",
+    		"displayName": "Jupiter",
+    		"symbols": [
+    			"jDOT"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://jupiter.patract.io"
+    	},
+    	{
+    		"prefix": 27,
+    		"network": "kabocha",
+    		"displayName": "Kabocha",
+    		"symbols": [
+    			"KAB"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://kabocha.network"
+    	},
+    	{
+    		"prefix": 28,
+    		"network": "subsocial",
+    		"displayName": "Subsocial",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 29,
+    		"network": "cord",
+    		"displayName": "CORD Network",
+    		"symbols": [
+    			"DHI",
+    			"WAY"
+    		],
+    		"decimals": [
+    			12,
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://cord.network/"
+    	},
+    	{
+    		"prefix": 30,
+    		"network": "phala",
+    		"displayName": "Phala Network",
+    		"symbols": [
+    			"PHA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://phala.network"
+    	},
+    	{
+    		"prefix": 31,
+    		"network": "litentry",
+    		"displayName": "Litentry Network",
+    		"symbols": [
+    			"LIT"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://litentry.com/"
+    	},
+    	{
+    		"prefix": 32,
+    		"network": "robonomics",
+    		"displayName": "Robonomics",
+    		"symbols": [
+    			"XRT"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://robonomics.network"
+    	},
+    	{
+    		"prefix": 33,
+    		"network": "datahighway",
+    		"displayName": "DataHighway",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": null
+    	},
+    	{
+    		"prefix": 34,
+    		"network": "ares",
+    		"displayName": "Ares Protocol",
+    		"symbols": [
+    			"ARES"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.aresprotocol.com/"
+    	},
+    	{
+    		"prefix": 35,
+    		"network": "vln",
+    		"displayName": "Valiu Liquidity Network",
+    		"symbols": [
+    			"USDv"
+    		],
+    		"decimals": [
+    			15
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://valiu.com/"
+    	},
+    	{
+    		"prefix": 36,
+    		"network": "centrifuge",
+    		"displayName": "Centrifuge Chain",
+    		"symbols": [
+    			"CFG"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://centrifuge.io/"
+    	},
+    	{
+    		"prefix": 37,
+    		"network": "nodle",
+    		"displayName": "Nodle Chain",
+    		"symbols": [
+    			"NODL"
+    		],
+    		"decimals": [
+    			11
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://nodle.io/"
+    	},
+    	{
+    		"prefix": 38,
+    		"network": "kilt",
+    		"displayName": "KILT Spiritnet",
+    		"symbols": [
+    			"KILT"
+    		],
+    		"decimals": [
+    			15
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://kilt.io/"
+    	},
+    	{
+    		"prefix": 39,
+    		"network": "mathchain",
+    		"displayName": "MathChain mainnet",
+    		"symbols": [
+    			"MATH"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://mathwallet.org"
+    	},
+    	{
+    		"prefix": 40,
+    		"network": "mathchain-testnet",
+    		"displayName": "MathChain testnet",
+    		"symbols": [
+    			"MATH"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://mathwallet.org"
+    	},
+    	{
+    		"prefix": 41,
+    		"network": "polimec",
+    		"displayName": "Polimec Protocol",
+    		"symbols": [
+    			"PLMC"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.polimec.org/"
+    	},
+    	{
+    		"prefix": 42,
+    		"network": "substrate",
+    		"displayName": "Substrate",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": "https://substrate.io/"
+    	},
+    	{
+    		"prefix": 43,
+    		"network": "BareSecp256k1",
+    		"displayName": "Bare 32-bit ECDSA SECP-256k1 public key.",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "secp256k1",
+    		"website": null
+    	},
+    	{
+    		"prefix": 44,
+    		"network": "chainx",
+    		"displayName": "ChainX",
+    		"symbols": [
+    			"PCX"
+    		],
+    		"decimals": [
+    			8
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://chainx.org/"
+    	},
+    	{
+    		"prefix": 45,
+    		"network": "uniarts",
+    		"displayName": "UniArts Network",
+    		"symbols": [
+    			"UART",
+    			"UINK"
+    		],
+    		"decimals": [
+    			12,
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://uniarts.me"
+    	},
+    	{
+    		"prefix": 46,
+    		"network": "reserved46",
+    		"displayName": "This prefix is reserved.",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": null,
+    		"website": null
+    	},
+    	{
+    		"prefix": 47,
+    		"network": "reserved47",
+    		"displayName": "This prefix is reserved.",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": null,
+    		"website": null
+    	},
+    	{
+    		"prefix": 48,
+    		"network": "neatcoin",
+    		"displayName": "Neatcoin Mainnet",
+    		"symbols": [
+    			"NEAT"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://neatcoin.org"
+    	},
+    	{
+    		"prefix": 49,
+    		"network": "picasso",
+    		"displayName": "Picasso",
+    		"symbols": [
+    			"PICA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://picasso.composable.finance"
+    	},
+    	{
+    		"prefix": 50,
+    		"network": "composable",
+    		"displayName": "Composable Finance",
+    		"symbols": [
+    			"LAYR"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://composable.finance"
+    	},
+    	{
+    		"prefix": 51,
+    		"network": "oak",
+    		"displayName": "OAK Network",
+    		"symbols": [
+    			"OAK",
+    			"TUR"
+    		],
+    		"decimals": [
+    			10,
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://oak.tech"
+    	},
+    	{
+    		"prefix": 52,
+    		"network": "KICO",
+    		"displayName": "KICO",
+    		"symbols": [
+    			"KICO"
+    		],
+    		"decimals": [
+    			14
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://dico.io"
+    	},
+    	{
+    		"prefix": 53,
+    		"network": "DICO",
+    		"displayName": "DICO",
+    		"symbols": [
+    			"DICO"
+    		],
+    		"decimals": [
+    			14
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://dico.io"
+    	},
+    	{
+    		"prefix": 54,
+    		"network": "cere",
+    		"displayName": "Cere Network",
+    		"symbols": [
+    			"CERE"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://cere.network"
+    	},
+    	{
+    		"prefix": 55,
+    		"network": "xxnetwork",
+    		"displayName": "xx network",
+    		"symbols": [
+    			"XX"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://xx.network"
+    	},
+    	{
+    		"prefix": 56,
+    		"network": "pendulum",
+    		"displayName": "Pendulum chain",
+    		"symbols": [
+    			"PEN"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://pendulumchain.org/"
+    	},
+    	{
+    		"prefix": 57,
+    		"network": "amplitude",
+    		"displayName": "Amplitude chain",
+    		"symbols": [
+    			"AMPE"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://pendulumchain.org/"
+    	},
+    	{
+    		"prefix": 58,
+    		"network": "eternal-civilization",
+    		"displayName": "Eternal Civilization",
+    		"symbols": [
+    			"ECC"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "http://www.ysknfr.cn/"
+    	},
+    	{
+    		"prefix": 63,
+    		"network": "hydradx",
+    		"displayName": "Hydration",
+    		"symbols": [
+    			"HDX"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://hydration.net"
+    	},
+    	{
+    		"prefix": 65,
+    		"network": "aventus",
+    		"displayName": "Aventus Mainnet",
+    		"symbols": [
+    			"AVT"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://aventus.io"
+    	},
+    	{
+    		"prefix": 66,
+    		"network": "crust",
+    		"displayName": "Crust Network",
+    		"symbols": [
+    			"CRU"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://crust.network"
+    	},
+    	{
+    		"prefix": 67,
+    		"network": "genshiro",
+    		"displayName": "Genshiro Network",
+    		"symbols": [
+    			"GENS",
+    			"EQD",
+    			"LPT0"
+    		],
+    		"decimals": [
+    			9,
+    			9,
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://genshiro.equilibrium.io"
+    	},
+    	{
+    		"prefix": 68,
+    		"network": "equilibrium",
+    		"displayName": "Equilibrium Network",
+    		"symbols": [
+    			"EQ"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://equilibrium.io"
+    	},
+    	{
+    		"prefix": 69,
+    		"network": "sora",
+    		"displayName": "SORA Network",
+    		"symbols": [
+    			"XOR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://sora.org"
+    	},
+    	{
+    		"prefix": 71,
+    		"network": "p3d",
+    		"displayName": "3DP network",
+    		"symbols": [
+    			"P3D"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://3dpass.org"
+    	},
+    	{
+    		"prefix": 72,
+    		"network": "p3dt",
+    		"displayName": "3DP test network",
+    		"symbols": [
+    			"P3Dt"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://3dpass.org"
+    	},
+    	{
+    		"prefix": 73,
+    		"network": "zeitgeist",
+    		"displayName": "Zeitgeist",
+    		"symbols": [
+    			"ZTG"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://zeitgeist.pm"
+    	},
+    	{
+    		"prefix": 77,
+    		"network": "manta",
+    		"displayName": "Manta network",
+    		"symbols": [
+    			"MANTA"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://manta.network"
+    	},
+    	{
+    		"prefix": 78,
+    		"network": "calamari",
+    		"displayName": "Calamari: Manta Canary Network",
+    		"symbols": [
+    			"KMA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://manta.network"
+    	},
+    	{
+    		"prefix": 81,
+    		"network": "sora_dot_para",
+    		"displayName": "SORA Polkadot Parachain",
+    		"symbols": [
+    			"XOR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://sora.org"
+    	},
+    	{
+    		"prefix": 88,
+    		"network": "polkadex",
+    		"displayName": "Polkadex Mainnet",
+    		"symbols": [
+    			"PDEX"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://polkadex.trade"
+    	},
+    	{
+    		"prefix": 89,
+    		"network": "polkadexparachain",
+    		"displayName": "Polkadex Parachain",
+    		"symbols": [
+    			"PDEX"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://polkadex.trade"
+    	},
+    	{
+    		"prefix": 90,
+    		"network": "frequency",
+    		"displayName": "Frequency",
+    		"symbols": [
+    			"FRQCY"
+    		],
+    		"decimals": [
+    			8
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.frequency.xyz"
+    	},
+    	{
+    		"prefix": 92,
+    		"network": "anmol",
+    		"displayName": "Anmol Network",
+    		"symbols": [
+    			"ANML"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://anmol.network/"
+    	},
+    	{
+    		"prefix": 93,
+    		"network": "fragnova",
+    		"displayName": "Fragnova Network",
+    		"symbols": [
+    			"NOVA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://fragnova.com"
+    	},
+    	{
+    		"prefix": 98,
+    		"network": "polkasmith",
+    		"displayName": "PolkaSmith Canary Network",
+    		"symbols": [
+    			"PKS"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://polkafoundry.com"
+    	},
+    	{
+    		"prefix": 99,
+    		"network": "polkafoundry",
+    		"displayName": "PolkaFoundry Network",
+    		"symbols": [
+    			"PKF"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://polkafoundry.com"
+    	},
+    	{
+    		"prefix": 100,
+    		"network": "ibtida",
+    		"displayName": "Anmol Network Ibtida Canary network",
+    		"symbols": [
+    			"IANML"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://anmol.network/"
+    	},
+    	{
+    		"prefix": 101,
+    		"network": "origintrail-parachain",
+    		"displayName": "OriginTrail Parachain",
+    		"symbols": [
+    			"OTP"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://parachain.origintrail.io/"
+    	},
+    	{
+    		"prefix": 105,
+    		"network": "pontem-network",
+    		"displayName": "Pontem Network",
+    		"symbols": [
+    			"PONT"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://pontem.network"
+    	},
+    	{
+    		"prefix": 110,
+    		"network": "heiko",
+    		"displayName": "Heiko",
+    		"symbols": [
+    			"HKO"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://parallel.fi/"
+    	},
+    	{
+    		"prefix": 113,
+    		"network": "integritee-incognito",
+    		"displayName": "Integritee Incognito",
+    		"symbols": [],
+    		"decimals": [],
+    		"standardAccount": "*25519",
+    		"website": "https://integritee.network"
+    	},
+    	{
+    		"prefix": 117,
+    		"network": "tinker",
+    		"displayName": "Tinker",
+    		"symbols": [
+    			"TNKR"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://invarch.network"
+    	},
+    	{
+    		"prefix": 126,
+    		"network": "joystream",
+    		"displayName": "Joystream",
+    		"symbols": [
+    			"JOY"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.joystream.org"
+    	},
+    	{
+    		"prefix": 128,
+    		"network": "clover",
+    		"displayName": "Clover Finance",
+    		"symbols": [
+    			"CLV"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://clover.finance"
+    	},
+    	{
+    		"prefix": 129,
+    		"network": "dorafactory-polkadot",
+    		"displayName": "Dorafactory Polkadot Network",
+    		"symbols": [
+    			"DORA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://dorafactory.org"
+    	},
+    	{
+    		"prefix": 131,
+    		"network": "litmus",
+    		"displayName": "Litmus Network",
+    		"symbols": [
+    			"LIT"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://litentry.com/"
+    	},
+    	{
+    		"prefix": 136,
+    		"network": "altair",
+    		"displayName": "Altair",
+    		"symbols": [
+    			"AIR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://centrifuge.io/"
+    	},
+    	{
+    		"prefix": 137,
+    		"network": "vara",
+    		"displayName": "Vara Network",
+    		"symbols": [
+    			"VARA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://vara.network/"
+    	},
+    	{
+    		"prefix": 172,
+    		"network": "parallel",
+    		"displayName": "Parallel",
+    		"symbols": [
+    			"PARA"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://parallel.fi/"
+    	},
+    	{
+    		"prefix": 252,
+    		"network": "social-network",
+    		"displayName": "Social Network",
+    		"symbols": [
+    			"NET"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://social.network"
+    	},
+    	{
+    		"prefix": 255,
+    		"network": "quartz_mainnet",
+    		"displayName": "QUARTZ by UNIQUE",
+    		"symbols": [
+    			"QTZ"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://unique.network"
+    	},
+    	{
+    		"prefix": 268,
+    		"network": "pioneer_network",
+    		"displayName": "Pioneer Network by Bit.Country",
+    		"symbols": [
+    			"NEER"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://bit.country"
+    	},
+    	{
+    		"prefix": 420,
+    		"network": "sora_kusama_para",
+    		"displayName": "SORA Kusama Parachain",
+    		"symbols": [
+    			"XOR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://sora.org"
+    	},
+    	{
+    		"prefix": 440,
+    		"network": "allfeat_network",
+    		"displayName": "Allfeat Network",
+    		"symbols": [
+    			"AFT"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://allfeat.network"
+    	},
+    	{
+    		"prefix": 666,
+    		"network": "metaquity_network",
+    		"displayName": "Metaquity Network",
+    		"symbols": [
+    			"MQTY"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://metaquity.xyz/"
+    	},
+    	{
+    		"prefix": 777,
+    		"network": "curio",
+    		"displayName": "Curio",
+    		"symbols": [
+    			"CGT"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://parachain.capitaldex.exchange/"
+    	},
+    	{
+    		"prefix": 789,
+    		"network": "geek",
+    		"displayName": "GEEK Network",
+    		"symbols": [
+    			"GEEK"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://geek.gl"
+    	},
+    	{
+    		"prefix": 995,
+    		"network": "ternoa",
+    		"displayName": "Ternoa",
+    		"symbols": [
+    			"CAPS"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.ternoa.network"
+    	},
+    	{
+    		"prefix": 1110,
+    		"network": "efinity",
+    		"displayName": "Efinity",
+    		"symbols": [
+    			"EFI"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://efinity.io/"
+    	},
+    	{
+    		"prefix": 1221,
+    		"network": "peaq",
+    		"displayName": "Peaq Network",
+    		"symbols": [
+    			"PEAQ"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "Sr25519",
+    		"website": "https://www.peaq.network/"
+    	},
+    	{
+    		"prefix": 1222,
+    		"network": "krest",
+    		"displayName": "Krest Network",
+    		"symbols": [
+    			"KREST"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "Sr25519",
+    		"website": "https://www.peaq.network/"
+    	},
+    	{
+    		"prefix": 1284,
+    		"network": "moonbeam",
+    		"displayName": "Moonbeam",
+    		"symbols": [
+    			"GLMR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "secp256k1",
+    		"website": "https://moonbeam.network"
+    	},
+    	{
+    		"prefix": 1285,
+    		"network": "moonriver",
+    		"displayName": "Moonriver",
+    		"symbols": [
+    			"MOVR"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "secp256k1",
+    		"website": "https://moonbeam.network"
+    	},
+    	{
+    		"prefix": 1328,
+    		"network": "ajuna",
+    		"displayName": "Ajuna Network",
+    		"symbols": [
+    			"AJUN"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://ajuna.io"
+    	},
+    	{
+    		"prefix": 1337,
+    		"network": "bajun",
+    		"displayName": "Bajun Network",
+    		"symbols": [
+    			"BAJU"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://ajuna.io"
+    	},
+    	{
+    		"prefix": 1516,
+    		"network": "societal",
+    		"displayName": "Societal",
+    		"symbols": [
+    			"SCTL"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.sctl.xyz"
+    	},
+    	{
+    		"prefix": 1985,
+    		"network": "seals",
+    		"displayName": "Seals Network",
+    		"symbols": [
+    			"SEAL"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://seals.app"
+    	},
+    	{
+    		"prefix": 2007,
+    		"network": "kapex",
+    		"displayName": "Kapex",
+    		"symbols": [
+    			"KAPEX"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://totemaccounting.com"
+    	},
+    	{
+    		"prefix": 2009,
+    		"network": "cloudwalk_mainnet",
+    		"displayName": "CloudWalk Network Mainnet",
+    		"symbols": [
+    			"CWN"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://explorer.mainnet.cloudwalk.io"
+    	},
+    	{
+    		"prefix": 2021,
+    		"network": "logion",
+    		"displayName": "logion network",
+    		"symbols": [
+    			"LGNT"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://logion.network"
+    	},
+    	{
+    		"prefix": 2024,
+    		"network": "vow-chain",
+    		"displayName": "Enigmatic Smile",
+    		"symbols": [
+    			"VOW"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.vow.foundation/"
+    	},
+    	{
+    		"prefix": 2032,
+    		"network": "interlay",
+    		"displayName": "Interlay",
+    		"symbols": [
+    			"INTR"
+    		],
+    		"decimals": [
+    			10
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://interlay.io/"
+    	},
+    	{
+    		"prefix": 2092,
+    		"network": "kintsugi",
+    		"displayName": "Kintsugi",
+    		"symbols": [
+    			"KINT"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://interlay.io/"
+    	},
+    	{
+    		"prefix": 2106,
+    		"network": "bitgreen",
+    		"displayName": "Bitgreen",
+    		"symbols": [
+    			"BBB"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://bitgreen.org/"
+    	},
+    	{
+    		"prefix": 2112,
+    		"network": "chainflip",
+    		"displayName": "Chainflip",
+    		"symbols": [
+    			"FLIP"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://chainflip.io/"
+    	},
+    	{
+    		"prefix": 2199,
+    		"network": "moonsama",
+    		"displayName": "Moonsama",
+    		"symbols": [
+    			"SAMA"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "secp256k1",
+    		"website": "https://moonsama.com"
+    	},
+    	{
+    		"prefix": 2206,
+    		"network": "ICE",
+    		"displayName": "ICE Network",
+    		"symbols": [
+    			"ICY"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://icenetwork.io"
+    	},
+    	{
+    		"prefix": 2207,
+    		"network": "SNOW",
+    		"displayName": "SNOW: ICE Canary Network",
+    		"symbols": [
+    			"ICZ"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://icenetwork.io"
+    	},
+    	{
+    		"prefix": 2254,
+    		"network": "subspace_testnet",
+    		"displayName": "Subspace testnet",
+    		"symbols": [
+    			"tSSC"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://subspace.network"
+    	},
+    	{
+    		"prefix": 3333,
+    		"network": "peerplays",
+    		"displayName": "Peerplays",
+    		"symbols": [
+    			"PPY"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "secp256k1",
+    		"website": "https://www.peerplays.com/"
+    	},
+    	{
+    		"prefix": 4450,
+    		"network": "g1",
+    		"displayName": "Ğ1",
+    		"symbols": [
+    			"G1"
+    		],
+    		"decimals": [
+    			2
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://duniter.org"
+    	},
+    	{
+    		"prefix": 5234,
+    		"network": "humanode",
+    		"displayName": "Humanode Network",
+    		"symbols": [
+    			"HMND"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://humanode.io"
+    	},
+    	{
+    		"prefix": 5845,
+    		"network": "tangle",
+    		"displayName": "Tangle Network",
+    		"symbols": [
+    			"TNT"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.tangle.tools/"
+    	},
+    	{
+    		"prefix": 6094,
+    		"network": "autonomys",
+    		"displayName": "Autonomys",
+    		"symbols": [
+    			"AI3"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://autonomys.xyz"
+    	},
+    	{
+    		"prefix": 7007,
+    		"network": "tidefi",
+    		"displayName": "Tidefi",
+    		"symbols": [
+    			"TDFY"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://tidefi.com"
+    	},
+    	{
+    		"prefix": 7013,
+    		"network": "gm",
+    		"displayName": "GM",
+    		"symbols": [
+    			"FREN",
+    			"GM",
+    			"GN"
+    		],
+    		"decimals": [
+    			12,
+    			0,
+    			0
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://gmordie.com"
+    	},
+    	{
+    		"prefix": 7306,
+    		"network": "krigan",
+    		"displayName": "Krigan Network",
+    		"symbols": [
+    			"KRGN"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://krigan.network"
+    	},
+    	{
+    		"prefix": 7391,
+    		"network": "unique_mainnet",
+    		"displayName": "Unique Network",
+    		"symbols": [
+    			"UNQ"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://unique.network"
+    	},
+    	{
+    		"prefix": 8866,
+    		"network": "golden_gate",
+    		"displayName": "Golden Gate",
+    		"symbols": [
+    			"GGX"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://ggxchain.io/"
+    	},
+    	{
+    		"prefix": 8883,
+    		"network": "sapphire_mainnet",
+    		"displayName": "Sapphire by Unique",
+    		"symbols": [
+    			"QTZ"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://unique.network"
+    	},
+    	{
+    		"prefix": 8886,
+    		"network": "golden_gate_sydney",
+    		"displayName": "Golden Gate Sydney",
+    		"symbols": [
+    			"GGXT"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://ggxchain.io/"
+    	},
+    	{
+    		"prefix": 9072,
+    		"network": "hashed",
+    		"displayName": "Hashed Network",
+    		"symbols": [
+    			"HASH"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://hashed.network"
+    	},
+    	{
+    		"prefix": 9807,
+    		"network": "dentnet",
+    		"displayName": "DENTNet",
+    		"symbols": [
+    			"DENTX"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://www.dentnet.io"
+    	},
+    	{
+    		"prefix": 9935,
+    		"network": "t3rn",
+    		"displayName": "t3rn",
+    		"symbols": [
+    			"TRN"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://t3rn.io/"
+    	},
+    	{
+    		"prefix": 10041,
+    		"network": "basilisk",
+    		"displayName": "Basilisk",
+    		"symbols": [
+    			"BSX"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://bsx.fi"
+    	},
+    	{
+    		"prefix": 11330,
+    		"network": "cess-testnet",
+    		"displayName": "CESS Testnet",
+    		"symbols": [
+    			"TCESS"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://cess.cloud"
+    	},
+    	{
+    		"prefix": 11331,
+    		"network": "cess",
+    		"displayName": "CESS",
+    		"symbols": [
+    			"CESS"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://cess.cloud"
+    	},
+    	{
+    		"prefix": 11486,
+    		"network": "luhn",
+    		"displayName": "Luhn Network",
+    		"symbols": [
+    			"LUHN"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://luhn.network"
+    	},
+    	{
+    		"prefix": 11820,
+    		"network": "contextfree",
+    		"displayName": "Automata ContextFree",
+    		"symbols": [
+    			"CTX"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://ata.network"
+    	},
+    	{
+    		"prefix": 12155,
+    		"network": "impact",
+    		"displayName": "Impact Protocol Network",
+    		"symbols": [
+    			"BSTY"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://impactprotocol.network/"
+    	},
+    	{
+    		"prefix": 12191,
+    		"network": "nftmart",
+    		"displayName": "NFTMart",
+    		"symbols": [
+    			"NMT"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://nftmart.io"
+    	},
+    	{
+    		"prefix": 12850,
+    		"network": "analog-timechain",
+    		"displayName": "Analog Timechain",
+    		"symbols": [
+    			"ANLOG"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://analog.one"
+    	},
+    	{
+    		"prefix": 13116,
+    		"network": "bittensor",
+    		"displayName": "Bittensor",
+    		"symbols": [
+    			"TAO"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://bittensor.com"
+    	},
+    	{
+    		"prefix": 14697,
+    		"network": "goro",
+    		"displayName": "GORO Network",
+    		"symbols": [
+    			"GORO"
+    		],
+    		"decimals": [
+    			9
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://goro.network"
+    	},
+    	{
+    		"prefix": 14998,
+    		"network": "mosaic-chain",
+    		"displayName": "Mosaic Chain",
+    		"symbols": [
+    			"MOS"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://mosaicchain.io"
+    	},
+    	{
+    		"prefix": 29972,
+    		"network": "mythos",
+    		"displayName": "Mythos",
+    		"symbols": [
+    			"MYTH"
+    		],
+    		"decimals": [
+    			18
+    		],
+    		"standardAccount": "secp256k1",
+    		"website": "https://mythos.foundation"
+    	},
+    	{
+    		"prefix": 8888,
+    		"network": "xcavate",
+    		"displayName": "Xcavate Protocol",
+    		"symbols": [
+    			"XCAV"
+    		],
+    		"decimals": [
+    			12
+    		],
+    		"standardAccount": "*25519",
+    		"website": "https://xcavate.io/"
+    	}
+    ];
+
+    const knownGenesis = {
+        acala: [
+            '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
+        ],
+        ajuna: [
+            '0xe358eb1d11b31255a286c12e44fe6780b7edb171d657905a97e39f71d9c6c3ee'
+        ],
+        'aleph-node': [
+            '0x70255b4d28de0fc4e1a193d7e175ad1ccef431598211c55538f1018651a0344e'
+        ],
+        astar: [
+            '0x9eb76c5184c4ab8679d2d5d819fdf90b9c001403e9e17da2e14b6d8aec4029c6'
+        ],
+        basilisk: [
+            '0xa85cfb9b9fd4d622a5b28289a02347af987d8f73fa3108450e2b4a11c1ce5755'
+        ],
+        bifrost: [
+            '0x262e1b2ad728475fd6fe88e62d34c200abe6fd693931ddad144059b1eb884e5b'
+        ],
+        'bifrost-kusama': [
+            '0x9f28c6a68e0fc9646eff64935684f6eeeece527e37bbe1f213d22caa1d9d6bed'
+        ],
+        bittensor: [
+            '0x2f0555cc76fc2840a25a6ea3b9637146806f1f44b090c175ffde2a7e5ab36c03'
+        ],
+        centrifuge: [
+            '0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82',
+            '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
+        ],
+        cere: [
+            '0x81443836a9a24caaa23f1241897d1235717535711d1d3fe24eae4fdc942c092c'
+        ],
+        composable: [
+            '0xdaab8df776eb52ec604a5df5d388bb62a050a0aaec4556a64265b9d42755552d'
+        ],
+        creditcoin3: [
+            '0x4436a7d64e363df85e065a894721002a86643283f9707338bf195d360ba2ee71',
+            '0xfc4ec97a1c1f119c4353aecb4a17c7c0cf7b40d5d660143d8bad9117e9866572',
+            '0xfc9df99a665f964aed6649f275055e54df5e3420489538ed31d7788f53d11ef6'
+        ],
+        darwinia: [
+            '0xe71578b37a7c799b0ab4ee87ffa6f059a6b98f71f06fb8c84a8d88013a548ad6'
+        ],
+        dentnet: [
+            '0x0313f6a011d128d22f996703cbab05162e2fdc9e031493314fe6db79979c5ca7'
+        ],
+        'dock-mainnet': [
+            '0x6bfe24dca2a3be10f22212678ac13a6446ec764103c0f3471c71609eac384aae',
+            '0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'
+        ],
+        edgeware: [
+            '0x742a2ca70c2fda6cee4f8df98d64c4c670a052d9568058982dad9d5a7a135c5b'
+        ],
+        encointer: [
+            '0x7dd99936c1e9e6d1ce7d90eb6f33bea8393b4bf87677d675aa63c9cb3e8c5b5b'
+        ],
+        enjin: [
+            '0xd8761d3c88f26dc12875c00d3165f7d67243d56fc85b4cf19937601a7916e5a9'
+        ],
+        equilibrium: [
+            '0x6f1a800de3daff7f5e037ddf66ab22ce03ab91874debeddb1086f5f7dbd48925'
+        ],
+        frequency: [
+            '0x4a587bf17a404e3572747add7aab7bbe56e805a5479c6c436f07f36fcc8d3ae1'
+        ],
+        genshiro: [
+            '0x9b8cefc0eb5c568b527998bdd76c184e2b76ae561be76e4667072230217ea243'
+        ],
+        hydradx: [
+            '0xafdc188f45c71dacbaa0b62e16a91f726c7b8699a9748cdf715459de6b7f366d',
+            '0xd2a620c27ec5cbc5621ff9a522689895074f7cca0d08e7134a7804e1a3ba86fc',
+            '0x10af6e84234477d84dc572bac0789813b254aa490767ed06fb9591191d1073f9',
+            '0x3d75507dd46301767e601265791da1d9cb47b6ebc94e87347b635e5bf58bd047',
+            '0x0ed32bfcab4a83517fac88f2aa7cbc2f88d3ab93be9a12b6188a036bf8a943c2'
+        ],
+        integritee: [
+            '0xcdedc8eadbfa209d3f207bba541e57c3c58a667b05a2e1d1e86353c9000758da',
+            '0xe13e7af377c64e83f95e0d70d5e5c3c01d697a84538776c5b9bbe0e7d7b6034c'
+        ],
+        'interlay-parachain': [
+            '0xbf88efe70e9e0e916416e8bed61f2b45717f517d7f3523e33c7b001e5ffcbc72'
+        ],
+        karura: [
+            '0xbaf5aabe40646d11f0ee8abbdc64f4a4b7674925cba08e4a05ff9ebed6e2126b'
+        ],
+        khala: [
+            '0xd43540ba6d3eb4897c28a77d48cb5b729fea37603cbbfc7a86a73b72adb3be8d'
+        ],
+        kulupu: [
+            '0xf7a99d3cb92853d00d5275c971c132c074636256583fee53b3bbe60d7b8769ba'
+        ],
+        kusama: [
+            '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe',
+            '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636',
+            '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf'
+        ],
+        liberland: [
+            '0x6bd89e052d67a45bb60a9a23e8581053d5e0d619f15cb9865946937e690c42d6'
+        ],
+        matrixchain: [
+            '0x3af4ff48ec76d2efc8476730f423ac07e25ad48f5f4c9dc39c778b164d808615'
+        ],
+        mythos: [
+            '0xf6ee56e9c5277df5b4ce6ae9983ee88f3cbed27d31beeb98f9f84f997a1ab0b9'
+        ],
+        nodle: [
+            '0x97da7ede98d7bad4e36b4d734b6055425a3be036da2a332ea5a7037656427a21'
+        ],
+        origintrail: [
+            '0xe7e0962324a3b86c83404dbea483f25fb5dab4c224791c81b756cfc948006174'
+        ],
+        p3d: [
+            '0x6c5894837ad89b6d92b114a2fb3eafa8fe3d26a54848e3447015442cd6ef4e66'
+        ],
+        parallel: [
+            '0xe61a41c53f5dcd0beb09df93b34402aada44cb05117b71059cce40a2723a4e97'
+        ],
+        peaq: [
+            '0xd2a5d385932d1f650dae03ef8e2748983779ee342c614f80854d32b8cd8fa48c'
+        ],
+        pendulum: [
+            '0x5d3c298622d5634ed019bf61ea4b71655030015bde9beb0d6a24743714462c86'
+        ],
+        phala: [
+            '0x1bb969d85965e4bb5a651abbedf21a54b6b31a21f66b5401cc3f1e286268d736'
+        ],
+        picasso: [
+            '0x6811a339673c9daa897944dcdac99c6e2939cc88245ed21951a0a3c9a2be75bc',
+            '0xe8e7f0f4c4f5a00720b4821dbfddefea7490bcf0b19009961cc46957984e2c1c'
+        ],
+        polimec: [
+            '0x7eb9354488318e7549c722669dcbdcdc526f1fef1420e7944667212f3601fdbd'
+        ],
+        polkadex: [
+            '0x3920bcb4960a1eef5580cd5367ff3f430eef052774f78468852f7b9cb39f8a3c'
+        ],
+        polkadot: [
+            '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+        ],
+        polymesh: [
+            '0x6fbd74e5e1d0a61d52ccfe9d4adaed16dd3a7caa37c6bc4d0c2fa12e8b2f4063'
+        ],
+        quartz: [
+            '0xcd4d732201ebe5d6b014edda071c4203e16867305332301dc8d092044b28e554'
+        ],
+        rococo: [
+            '0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e',
+            '0xaaf2cd1b74b5f726895921259421b534124726263982522174147046b8827897',
+            '0x037f5f3c8e67b314062025fc886fcd6238ea25a4a9b45dce8d246815c9ebe770',
+            '0xc196f81260cf1686172b47a79cf002120735d7cb0eb1474e8adce56618456fff',
+            '0xf6e9983c37baf68846fedafe21e56718790e39fb1c582abc408b81bc7b208f9a',
+            '0x5fce687da39305dfe682b117f0820b319348e8bb37eb16cf34acbf6a202de9d9',
+            '0xe7c3d5edde7db964317cd9b51a3a059d7cd99f81bdbce14990047354334c9779',
+            '0x1611e1dbf0405379b861e2e27daa90f480b2e6d3682414a80835a52e8cb8a215',
+            '0x343442f12fa715489a8714e79a7b264ea88c0d5b8c66b684a7788a516032f6b9',
+            '0x78bcd530c6b3a068bc17473cf5d2aff9c287102bed9af3ae3c41c33b9d6c6147',
+            '0x47381ee0697153d64404fc578392c8fd5cba9073391908f46c888498415647bd',
+            '0x19c0e4fa8ab75f5ac7865e0b8f74ff91eb9a100d336f423cd013a8befba40299'
+        ],
+        sora: [
+            '0x7e4e32d0feafd4f9c9414b0be86373f9a1efa904809b683453a9af6856d38ad5'
+        ],
+        stafi: [
+            '0x290a4149f09ea0e402c74c1c7e96ae4239588577fe78932f94f5404c68243d80'
+        ],
+        statemine: [
+            '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a'
+        ],
+        statemint: [
+            '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f'
+        ],
+        subsocial: [
+            '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
+        ],
+        ternoa: [
+            '0x6859c81ca95ef624c9dfe4dc6e3381c33e5d6509e35e147092bfbc780f777c4e'
+        ],
+        unique: [
+            '0x84322d9cddbf35088f1e54e9a85c967a41a56a4f43445768125e61af166c7d31'
+        ],
+        vara: [
+            '0xfe1b4c55fd4d668101126434206571a7838a8b6b93a6d1b95d607e78e6c53763'
+        ],
+        vtb: [
+            '0x286bc8414c7000ce1d6ee6a834e29a54c1784814b76243eb77ed0b2c5573c60f',
+            '0x7483b89572fb2bd687c7b9a93b242d0b237f9aba463aba07ec24503931038aaa'
+        ],
+        westend: [
+            '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e'
+        ],
+        xxnetwork: [
+            '0x50dd5d206917bf10502c68fb4d18a59fc8aa31586f4e8856b493e43544aa82aa'
+        ],
+        zeitgeist: [
+            '0x1bf2a2ecb4a868de66ea8610f2ce7c8c43706561b6476031315f6640fe38e060'
+        ]
+    };
+
+    const knownIcon = {
+        centrifuge: 'polkadot',
+        kusama: 'polkadot',
+        polkadot: 'polkadot',
+        sora: 'polkadot',
+        statemine: 'polkadot',
+        statemint: 'polkadot',
+        westmint: 'polkadot'
+    };
+
+    const knownLedger = {
+        acala: 0x00000313,
+        ajuna: 0x00000162,
+        'aleph-node': 0x00000283,
+        astar: 0x0000032a,
+        bifrost: 0x00000314,
+        'bifrost-kusama': 0x00000314,
+        bittensor: 0x00000162,
+        centrifuge: 0x000002eb,
+        composable: 0x00000162,
+        creditcoin3: 0x00000162,
+        darwinia: 0x00000162,
+        dentnet: 0x000002de,
+        'dock-mainnet': 0x00000252,
+        edgeware: 0x0000020b,
+        encointer: 0x000001b2,
+        enjin: 0x00000483,
+        equilibrium: 0x05f5e0fd,
+        frequency: 0x0000082b,
+        genshiro: 0x05f5e0fc,
+        hydradx: 0x00000162,
+        integritee: 0x000007df,
+        'interlay-parachain': 0x00000162,
+        karura: 0x000002ae,
+        khala: 0x000001b2,
+        kusama: 0x000001b2,
+        liberland: 0x000002ff,
+        matrixchain: 0x00000483,
+        mythos: 0x0000003c,
+        nodle: 0x000003eb,
+        origintrail: 0x00000162,
+        parallel: 0x00000162,
+        peaq: 0x00000d0a,
+        pendulum: 0x00000162,
+        phala: 0x00000162,
+        picasso: 0x000001b2,
+        polimec: 0x00000d10,
+        polkadex: 0x0000031f,
+        polkadot: 0x00000162,
+        polymesh: 0x00000253,
+        quartz: 0x00000277,
+        sora: 0x00000269,
+        stafi: 0x0000038b,
+        statemine: 0x000001b2,
+        statemint: 0x00000162,
+        ternoa: 0x00003e3,
+        unique: 0x00000295,
+        vara: 0x00001370,
+        vtb: 0x000002b6,
+        xxnetwork: 0x000007a3,
+        zeitgeist: 0x00000162
+    };
+
+    const knownTestnet = {
+        '': true,
+        'cess-testnet': true,
+        'dock-testnet': true,
+        jupiter: true,
+        'mathchain-testnet': true,
+        p3dt: true,
+        subspace_testnet: true,
+        'zero-alphaville': true
+    };
+
+    const UNSORTED = [0, 2, 42];
+    const TESTNETS = ['testnet'];
+    function toExpanded(o) {
+        const network = o.network || '';
+        const nameParts = network.replace(/_/g, '-').split('-');
+        const n = o;
+        n.slip44 = knownLedger[network];
+        n.hasLedgerSupport = !!n.slip44;
+        n.genesisHash = knownGenesis[network] || [];
+        n.icon = knownIcon[network] || 'substrate';
+        n.isTestnet = !!knownTestnet[network] || TESTNETS.includes(nameParts[nameParts.length - 1]);
+        n.isIgnored = n.isTestnet || (!(o.standardAccount &&
+            o.decimals?.length &&
+            o.symbols?.length) &&
+            o.prefix !== 42);
+        return n;
+    }
+    function filterSelectable({ genesisHash, prefix }) {
+        return !!genesisHash.length || prefix === 42;
+    }
+    function filterAvailable(n) {
+        return !n.isIgnored && !!n.network;
+    }
+    function sortNetworks(a, b) {
+        const isUnSortedA = UNSORTED.includes(a.prefix);
+        const isUnSortedB = UNSORTED.includes(b.prefix);
+        return isUnSortedA === isUnSortedB
+            ? isUnSortedA
+                ? 0
+                : a.displayName.localeCompare(b.displayName)
+            : isUnSortedA
+                ? -1
+                : 1;
+    }
+    const allNetworks = knownSubstrate.map(toExpanded);
+    const availableNetworks = allNetworks.filter(filterAvailable).sort(sortNetworks);
+    const selectableNetworks = availableNetworks.filter(filterSelectable);
+
+    const defaults = {
+        allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
+        allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
+        allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
+        prefix: 42
+    };
+
+    function decodeAddress(encoded, ignoreChecksum, ss58Format = -1) {
+        if (!encoded) {
+            throw new Error('Invalid empty address passed');
+        }
+        if (util.isU8a(encoded) || util.isHex(encoded)) {
+            return util.u8aToU8a(encoded);
+        }
+        try {
+            const decoded = base58Decode(encoded);
+            if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
+                throw new Error('Invalid decoded address length');
+            }
+            const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
+            if (!isValid && !ignoreChecksum) {
+                throw new Error('Invalid decoded address checksum');
+            }
+            else if (ss58Format !== -1 && ss58Format !== ss58Decoded) {
+                throw new Error(`Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
+            }
+            return decoded.slice(ss58Length, endPos);
+        }
+        catch (error) {
+            throw new Error(`Decoding ${encoded}: ${error.message}`);
+        }
+    }
+
+    function addressToEvm(address, ignoreChecksum) {
+        return decodeAddress(address, ignoreChecksum).subarray(0, 20);
+    }
+
+    function checkAddress(address, prefix) {
+        let decoded;
+        try {
+            decoded = base58Decode(address);
+        }
+        catch (error) {
+            return [false, error.message];
+        }
+        const [isValid, , , ss58Decoded] = checkAddressChecksum(decoded);
+        if (ss58Decoded !== prefix) {
+            return [false, `Prefix mismatch, expected ${prefix}, found ${ss58Decoded}`];
+        }
+        else if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
+            return [false, 'Invalid decoded address length'];
+        }
+        return [isValid, isValid ? null : 'Invalid decoded address checksum'];
+    }
+
+    const BN_BE_OPTS = { isLe: false };
+    const BN_LE_OPTS = { isLe: true };
+    const BN_LE_16_OPTS = { bitLength: 16, isLe: true };
+    const BN_BE_32_OPTS = { bitLength: 32, isLe: false };
+    const BN_LE_32_OPTS = { bitLength: 32, isLe: true };
+    const BN_BE_256_OPTS = { bitLength: 256, isLe: false };
+    const BN_LE_256_OPTS = { bitLength: 256, isLe: true };
+    const BN_LE_512_OPTS = { bitLength: 512, isLe: true };
+
+    const RE_NUMBER = /^\d+$/;
+    const JUNCTION_ID_LEN = 32;
+    class DeriveJunction {
+        #chainCode = new Uint8Array(32);
+        #isHard = false;
+        static from(value) {
+            const result = new DeriveJunction();
+            const [code, isHard] = value.startsWith('/')
+                ? [value.substring(1), true]
+                : [value, false];
+            result.soft(RE_NUMBER.test(code)
+                ? new util.BN(code, 10)
+                : code);
+            return isHard
+                ? result.harden()
+                : result;
+        }
+        get chainCode() {
+            return this.#chainCode;
+        }
+        get isHard() {
+            return this.#isHard;
+        }
+        get isSoft() {
+            return !this.#isHard;
+        }
+        hard(value) {
+            return this.soft(value).harden();
+        }
+        harden() {
+            this.#isHard = true;
+            return this;
+        }
+        soft(value) {
+            if (util.isNumber(value) || util.isBn(value) || util.isBigInt(value)) {
+                return this.soft(util.bnToU8a(value, BN_LE_256_OPTS));
+            }
+            else if (util.isHex(value)) {
+                return this.soft(util.hexToU8a(value));
+            }
+            else if (util.isString(value)) {
+                return this.soft(util.compactAddLength(util.stringToU8a(value)));
+            }
+            else if (value.length > JUNCTION_ID_LEN) {
+                return this.soft(blake2AsU8a(value));
+            }
+            this.#chainCode.fill(0);
+            this.#chainCode.set(value, 0);
+            return this;
+        }
+        soften() {
+            this.#isHard = false;
+            return this;
+        }
+    }
+
+    const RE_JUNCTION = /\/(\/?)([^/]+)/g;
+    function keyExtractPath(derivePath) {
+        const parts = derivePath.match(RE_JUNCTION);
+        const path = [];
+        let constructed = '';
+        if (parts) {
+            constructed = parts.join('');
+            for (const p of parts) {
+                path.push(DeriveJunction.from(p.substring(1)));
+            }
+        }
+        if (constructed !== derivePath) {
+            throw new Error(`Re-constructed path "${constructed}" does not match input`);
+        }
+        return {
+            parts,
+            path
+        };
+    }
+
+    const RE_CAPTURE = /^((0x[a-fA-F0-9]+|[\p{L}\d]+(?: [\p{L}\d]+)*))((\/\/?[^/]+)*)(\/\/\/(.*))?$/u;
+    function keyExtractSuri(suri) {
+        const normalizedSuri = suri.normalize('NFC');
+        const matches = normalizedSuri.match(RE_CAPTURE);
+        if (matches === null) {
+            throw new Error('Unable to match provided value to a secret URI');
+        }
+        const [, phrase, , derivePath, , , password] = matches;
+        const { path } = keyExtractPath(derivePath);
+        return {
+            derivePath,
+            password,
+            path,
+            phrase
+        };
+    }
+
+    const HDKD$1 = util.compactAddLength(util.stringToU8a('Secp256k1HDKD'));
+    function secp256k1DeriveHard(seed, chainCode) {
+        if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        return blake2AsU8a(util.u8aConcat(HDKD$1, seed, chainCode), 256);
+    }
+
+    function setBigUint64(view, byteOffset, value, isLE) {
+        if (typeof view.setBigUint64 === 'function')
+            return view.setBigUint64(byteOffset, value, isLE);
+        const _32n = BigInt(32);
+        const _u32_max = BigInt(0xffffffff);
+        const wh = Number((value >> _32n) & _u32_max);
+        const wl = Number(value & _u32_max);
+        const h = isLE ? 4 : 0;
+        const l = isLE ? 0 : 4;
+        view.setUint32(byteOffset + h, wh, isLE);
+        view.setUint32(byteOffset + l, wl, isLE);
+    }
+    class SHA2 extends Hash {
+        constructor(blockLen, outputLen, padOffset, isLE) {
+            super();
+            this.blockLen = blockLen;
+            this.outputLen = outputLen;
+            this.padOffset = padOffset;
+            this.isLE = isLE;
+            this.finished = false;
+            this.length = 0;
+            this.pos = 0;
+            this.destroyed = false;
+            this.buffer = new Uint8Array(blockLen);
+            this.view = createView(this.buffer);
+        }
+        update(data) {
+            exists(this);
+            const { view, buffer, blockLen } = this;
+            data = toBytes(data);
+            const len = data.length;
+            for (let pos = 0; pos < len;) {
+                const take = Math.min(blockLen - this.pos, len - pos);
+                if (take === blockLen) {
+                    const dataView = createView(data);
+                    for (; blockLen <= len - pos; pos += blockLen)
+                        this.process(dataView, pos);
+                    continue;
+                }
+                buffer.set(data.subarray(pos, pos + take), this.pos);
+                this.pos += take;
+                pos += take;
+                if (this.pos === blockLen) {
+                    this.process(view, 0);
+                    this.pos = 0;
+                }
+            }
+            this.length += data.length;
+            this.roundClean();
+            return this;
+        }
+        digestInto(out) {
+            exists(this);
+            output(out, this);
+            this.finished = true;
+            const { buffer, view, blockLen, isLE } = this;
+            let { pos } = this;
+            buffer[pos++] = 0b10000000;
+            this.buffer.subarray(pos).fill(0);
+            if (this.padOffset > blockLen - pos) {
+                this.process(view, 0);
+                pos = 0;
+            }
+            for (let i = pos; i < blockLen; i++)
+                buffer[i] = 0;
+            setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+            this.process(view, 0);
+            const oview = createView(out);
+            const len = this.outputLen;
+            if (len % 4)
+                throw new Error('_sha2: outputLen should be aligned to 32bit');
+            const outLen = len / 4;
+            const state = this.get();
+            if (outLen > state.length)
+                throw new Error('_sha2: outputLen bigger than state');
+            for (let i = 0; i < outLen; i++)
+                oview.setUint32(4 * i, state[i], isLE);
+        }
+        digest() {
+            const { buffer, outputLen } = this;
+            this.digestInto(buffer);
+            const res = buffer.slice(0, outputLen);
+            this.destroy();
+            return res;
+        }
+        _cloneInto(to) {
+            to || (to = new this.constructor());
+            to.set(...this.get());
+            const { blockLen, buffer, length, finished, destroyed, pos } = this;
+            to.length = length;
+            to.pos = pos;
+            to.finished = finished;
+            to.destroyed = destroyed;
+            if (length % blockLen)
+                to.buffer.set(buffer);
+            return to;
+        }
+    }
+
+    const Chi = (a, b, c) => (a & b) ^ (~a & c);
+    const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+    const SHA256_K =  new Uint32Array([
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    ]);
+    const IV =  new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ]);
+    const SHA256_W =  new Uint32Array(64);
+    class SHA256 extends SHA2 {
+        constructor() {
+            super(64, 32, 8, false);
+            this.A = IV[0] | 0;
+            this.B = IV[1] | 0;
+            this.C = IV[2] | 0;
+            this.D = IV[3] | 0;
+            this.E = IV[4] | 0;
+            this.F = IV[5] | 0;
+            this.G = IV[6] | 0;
+            this.H = IV[7] | 0;
+        }
+        get() {
+            const { A, B, C, D, E, F, G, H } = this;
+            return [A, B, C, D, E, F, G, H];
+        }
+        set(A, B, C, D, E, F, G, H) {
+            this.A = A | 0;
+            this.B = B | 0;
+            this.C = C | 0;
+            this.D = D | 0;
+            this.E = E | 0;
+            this.F = F | 0;
+            this.G = G | 0;
+            this.H = H | 0;
+        }
+        process(view, offset) {
+            for (let i = 0; i < 16; i++, offset += 4)
+                SHA256_W[i] = view.getUint32(offset, false);
+            for (let i = 16; i < 64; i++) {
+                const W15 = SHA256_W[i - 15];
+                const W2 = SHA256_W[i - 2];
+                const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+                const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+                SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+            }
+            let { A, B, C, D, E, F, G, H } = this;
+            for (let i = 0; i < 64; i++) {
+                const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+                const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+                const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+                const T2 = (sigma0 + Maj(A, B, C)) | 0;
+                H = G;
+                G = F;
+                F = E;
+                E = (D + T1) | 0;
+                D = C;
+                C = B;
+                B = A;
+                A = (T1 + T2) | 0;
+            }
+            A = (A + this.A) | 0;
+            B = (B + this.B) | 0;
+            C = (C + this.C) | 0;
+            D = (D + this.D) | 0;
+            E = (E + this.E) | 0;
+            F = (F + this.F) | 0;
+            G = (G + this.G) | 0;
+            H = (H + this.H) | 0;
+            this.set(A, B, C, D, E, F, G, H);
+        }
+        roundClean() {
+            SHA256_W.fill(0);
+        }
+        destroy() {
+            this.set(0, 0, 0, 0, 0, 0, 0, 0);
+            this.buffer.fill(0);
+        }
+    }
+    class SHA224 extends SHA256 {
+        constructor() {
+            super();
+            this.A = 0xc1059ed8 | 0;
+            this.B = 0x367cd507 | 0;
+            this.C = 0x3070dd17 | 0;
+            this.D = 0xf70e5939 | 0;
+            this.E = 0xffc00b31 | 0;
+            this.F = 0x68581511 | 0;
+            this.G = 0x64f98fa7 | 0;
+            this.H = 0xbefa4fa4 | 0;
+            this.outputLen = 28;
+        }
+    }
+    const sha256 =  wrapConstructor(() => new SHA256());
+    wrapConstructor(() => new SHA224());
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$8 = BigInt(0);
+    const _1n$8 = BigInt(1);
+    const _2n$6 = BigInt(2);
+    function isBytes(a) {
+        return (a instanceof Uint8Array ||
+            (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    }
+    const hexes =  Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+    function bytesToHex(bytes) {
+        if (!isBytes(bytes))
+            throw new Error('Uint8Array expected');
+        let hex = '';
+        for (let i = 0; i < bytes.length; i++) {
+            hex += hexes[bytes[i]];
+        }
+        return hex;
+    }
+    function numberToHexUnpadded(num) {
+        const hex = num.toString(16);
+        return hex.length & 1 ? `0${hex}` : hex;
+    }
+    function hexToNumber(hex) {
+        if (typeof hex !== 'string')
+            throw new Error('hex string expected, got ' + typeof hex);
+        return BigInt(hex === '' ? '0' : `0x${hex}`);
+    }
+    const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+    function asciiToBase16(char) {
+        if (char >= asciis._0 && char <= asciis._9)
+            return char - asciis._0;
+        if (char >= asciis._A && char <= asciis._F)
+            return char - (asciis._A - 10);
+        if (char >= asciis._a && char <= asciis._f)
+            return char - (asciis._a - 10);
+        return;
+    }
+    function hexToBytes(hex) {
+        if (typeof hex !== 'string')
+            throw new Error('hex string expected, got ' + typeof hex);
+        const hl = hex.length;
+        const al = hl / 2;
+        if (hl % 2)
+            throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+        const array = new Uint8Array(al);
+        for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+            const n1 = asciiToBase16(hex.charCodeAt(hi));
+            const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+            if (n1 === undefined || n2 === undefined) {
+                const char = hex[hi] + hex[hi + 1];
+                throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+            }
+            array[ai] = n1 * 16 + n2;
+        }
+        return array;
+    }
+    function bytesToNumberBE(bytes) {
+        return hexToNumber(bytesToHex(bytes));
+    }
+    function bytesToNumberLE(bytes) {
+        if (!isBytes(bytes))
+            throw new Error('Uint8Array expected');
+        return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+    }
+    function numberToBytesBE(n, len) {
+        return hexToBytes(n.toString(16).padStart(len * 2, '0'));
+    }
+    function numberToBytesLE(n, len) {
+        return numberToBytesBE(n, len).reverse();
+    }
+    function numberToVarBytesBE(n) {
+        return hexToBytes(numberToHexUnpadded(n));
+    }
+    function ensureBytes(title, hex, expectedLength) {
+        let res;
+        if (typeof hex === 'string') {
+            try {
+                res = hexToBytes(hex);
+            }
+            catch (e) {
+                throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+            }
+        }
+        else if (isBytes(hex)) {
+            res = Uint8Array.from(hex);
+        }
+        else {
+            throw new Error(`${title} must be hex string or Uint8Array`);
+        }
+        const len = res.length;
+        if (typeof expectedLength === 'number' && len !== expectedLength)
+            throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+        return res;
+    }
+    function concatBytes(...arrays) {
+        let sum = 0;
+        for (let i = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            if (!isBytes(a))
+                throw new Error('Uint8Array expected');
+            sum += a.length;
+        }
+        let res = new Uint8Array(sum);
+        let pad = 0;
+        for (let i = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            res.set(a, pad);
+            pad += a.length;
+        }
+        return res;
+    }
+    function equalBytes(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let diff = 0;
+        for (let i = 0; i < a.length; i++)
+            diff |= a[i] ^ b[i];
+        return diff === 0;
+    }
+    function utf8ToBytes(str) {
+        if (typeof str !== 'string')
+            throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+        return new Uint8Array(new TextEncoder().encode(str));
+    }
+    function bitLen(n) {
+        let len;
+        for (len = 0; n > _0n$8; n >>= _1n$8, len += 1)
+            ;
+        return len;
+    }
+    function bitGet(n, pos) {
+        return (n >> BigInt(pos)) & _1n$8;
+    }
+    const bitSet = (n, pos, value) => {
+        return n | ((value ? _1n$8 : _0n$8) << BigInt(pos));
+    };
+    const bitMask = (n) => (_2n$6 << BigInt(n - 1)) - _1n$8;
+    const u8n = (data) => new Uint8Array(data);
+    const u8fr = (arr) => Uint8Array.from(arr);
+    function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+        if (typeof hashLen !== 'number' || hashLen < 2)
+            throw new Error('hashLen must be a number');
+        if (typeof qByteLen !== 'number' || qByteLen < 2)
+            throw new Error('qByteLen must be a number');
+        if (typeof hmacFn !== 'function')
+            throw new Error('hmacFn must be a function');
+        let v = u8n(hashLen);
+        let k = u8n(hashLen);
+        let i = 0;
+        const reset = () => {
+            v.fill(1);
+            k.fill(0);
+            i = 0;
+        };
+        const h = (...b) => hmacFn(k, v, ...b);
+        const reseed = (seed = u8n()) => {
+            k = h(u8fr([0x00]), seed);
+            v = h();
+            if (seed.length === 0)
+                return;
+            k = h(u8fr([0x01]), seed);
+            v = h();
+        };
+        const gen = () => {
+            if (i++ >= 1000)
+                throw new Error('drbg: tried 1000 values');
+            let len = 0;
+            const out = [];
+            while (len < qByteLen) {
+                v = h();
+                const sl = v.slice();
+                out.push(sl);
+                len += v.length;
+            }
+            return concatBytes(...out);
+        };
+        const genUntil = (seed, pred) => {
+            reset();
+            reseed(seed);
+            let res = undefined;
+            while (!(res = pred(gen())))
+                reseed();
+            reset();
+            return res;
+        };
+        return genUntil;
+    }
+    const validatorFns = {
+        bigint: (val) => typeof val === 'bigint',
+        function: (val) => typeof val === 'function',
+        boolean: (val) => typeof val === 'boolean',
+        string: (val) => typeof val === 'string',
+        stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),
+        isSafeInteger: (val) => Number.isSafeInteger(val),
+        array: (val) => Array.isArray(val),
+        field: (val, object) => object.Fp.isValid(val),
+        hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),
+    };
+    function validateObject(object, validators, optValidators = {}) {
+        const checkField = (fieldName, type, isOptional) => {
+            const checkVal = validatorFns[type];
+            if (typeof checkVal !== 'function')
+                throw new Error(`Invalid validator "${type}", expected function`);
+            const val = object[fieldName];
+            if (isOptional && val === undefined)
+                return;
+            if (!checkVal(val, object)) {
+                throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
+            }
+        };
+        for (const [fieldName, type] of Object.entries(validators))
+            checkField(fieldName, type, false);
+        for (const [fieldName, type] of Object.entries(optValidators))
+            checkField(fieldName, type, true);
+        return object;
+    }
+
+    const ut = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        bitGet: bitGet,
+        bitLen: bitLen,
+        bitMask: bitMask,
+        bitSet: bitSet,
+        bytesToHex: bytesToHex,
+        bytesToNumberBE: bytesToNumberBE,
+        bytesToNumberLE: bytesToNumberLE,
+        concatBytes: concatBytes,
+        createHmacDrbg: createHmacDrbg,
+        ensureBytes: ensureBytes,
+        equalBytes: equalBytes,
+        hexToBytes: hexToBytes,
+        hexToNumber: hexToNumber,
+        isBytes: isBytes,
+        numberToBytesBE: numberToBytesBE,
+        numberToBytesLE: numberToBytesLE,
+        numberToHexUnpadded: numberToHexUnpadded,
+        numberToVarBytesBE: numberToVarBytesBE,
+        utf8ToBytes: utf8ToBytes,
+        validateObject: validateObject
+    });
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$7 = BigInt(0), _1n$7 = BigInt(1), _2n$5 = BigInt(2), _3n$1 = BigInt(3);
+    const _4n$1 = BigInt(4), _5n$1 = BigInt(5), _8n$1 = BigInt(8);
+    BigInt(9); BigInt(16);
+    function mod(a, b) {
+        const result = a % b;
+        return result >= _0n$7 ? result : b + result;
+    }
+    function pow(num, power, modulo) {
+        if (modulo <= _0n$7 || power < _0n$7)
+            throw new Error('Expected power/modulo > 0');
+        if (modulo === _1n$7)
+            return _0n$7;
+        let res = _1n$7;
+        while (power > _0n$7) {
+            if (power & _1n$7)
+                res = (res * num) % modulo;
+            num = (num * num) % modulo;
+            power >>= _1n$7;
+        }
+        return res;
+    }
+    function pow2(x, power, modulo) {
+        let res = x;
+        while (power-- > _0n$7) {
+            res *= res;
+            res %= modulo;
+        }
+        return res;
+    }
+    function invert(number, modulo) {
+        if (number === _0n$7 || modulo <= _0n$7) {
+            throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
+        }
+        let a = mod(number, modulo);
+        let b = modulo;
+        let x = _0n$7, u = _1n$7;
+        while (a !== _0n$7) {
+            const q = b / a;
+            const r = b % a;
+            const m = x - u * q;
+            b = a, a = r, x = u, u = m;
+        }
+        const gcd = b;
+        if (gcd !== _1n$7)
+            throw new Error('invert: does not exist');
+        return mod(x, modulo);
+    }
+    function tonelliShanks(P) {
+        const legendreC = (P - _1n$7) / _2n$5;
+        let Q, S, Z;
+        for (Q = P - _1n$7, S = 0; Q % _2n$5 === _0n$7; Q /= _2n$5, S++)
+            ;
+        for (Z = _2n$5; Z < P && pow(Z, legendreC, P) !== P - _1n$7; Z++)
+            ;
+        if (S === 1) {
+            const p1div4 = (P + _1n$7) / _4n$1;
+            return function tonelliFast(Fp, n) {
+                const root = Fp.pow(n, p1div4);
+                if (!Fp.eql(Fp.sqr(root), n))
+                    throw new Error('Cannot find square root');
+                return root;
+            };
+        }
+        const Q1div2 = (Q + _1n$7) / _2n$5;
+        return function tonelliSlow(Fp, n) {
+            if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
+                throw new Error('Cannot find square root');
+            let r = S;
+            let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
+            let x = Fp.pow(n, Q1div2);
+            let b = Fp.pow(n, Q);
+            while (!Fp.eql(b, Fp.ONE)) {
+                if (Fp.eql(b, Fp.ZERO))
+                    return Fp.ZERO;
+                let m = 1;
+                for (let t2 = Fp.sqr(b); m < r; m++) {
+                    if (Fp.eql(t2, Fp.ONE))
+                        break;
+                    t2 = Fp.sqr(t2);
+                }
+                const ge = Fp.pow(g, _1n$7 << BigInt(r - m - 1));
+                g = Fp.sqr(ge);
+                x = Fp.mul(x, ge);
+                b = Fp.mul(b, g);
+                r = m;
+            }
+            return x;
+        };
+    }
+    function FpSqrt(P) {
+        if (P % _4n$1 === _3n$1) {
+            const p1div4 = (P + _1n$7) / _4n$1;
+            return function sqrt3mod4(Fp, n) {
+                const root = Fp.pow(n, p1div4);
+                if (!Fp.eql(Fp.sqr(root), n))
+                    throw new Error('Cannot find square root');
+                return root;
+            };
+        }
+        if (P % _8n$1 === _5n$1) {
+            const c1 = (P - _5n$1) / _8n$1;
+            return function sqrt5mod8(Fp, n) {
+                const n2 = Fp.mul(n, _2n$5);
+                const v = Fp.pow(n2, c1);
+                const nv = Fp.mul(n, v);
+                const i = Fp.mul(Fp.mul(nv, _2n$5), v);
+                const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+                if (!Fp.eql(Fp.sqr(root), n))
+                    throw new Error('Cannot find square root');
+                return root;
+            };
+        }
+        return tonelliShanks(P);
+    }
+    const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n$7) === _1n$7;
+    const FIELD_FIELDS = [
+        'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',
+        'eql', 'add', 'sub', 'mul', 'pow', 'div',
+        'addN', 'subN', 'mulN', 'sqrN'
+    ];
+    function validateField(field) {
+        const initial = {
+            ORDER: 'bigint',
+            MASK: 'bigint',
+            BYTES: 'isSafeInteger',
+            BITS: 'isSafeInteger',
+        };
+        const opts = FIELD_FIELDS.reduce((map, val) => {
+            map[val] = 'function';
+            return map;
+        }, initial);
+        return validateObject(field, opts);
+    }
+    function FpPow(f, num, power) {
+        if (power < _0n$7)
+            throw new Error('Expected power > 0');
+        if (power === _0n$7)
+            return f.ONE;
+        if (power === _1n$7)
+            return num;
+        let p = f.ONE;
+        let d = num;
+        while (power > _0n$7) {
+            if (power & _1n$7)
+                p = f.mul(p, d);
+            d = f.sqr(d);
+            power >>= _1n$7;
+        }
+        return p;
+    }
+    function FpInvertBatch(f, nums) {
+        const tmp = new Array(nums.length);
+        const lastMultiplied = nums.reduce((acc, num, i) => {
+            if (f.is0(num))
+                return acc;
+            tmp[i] = acc;
+            return f.mul(acc, num);
+        }, f.ONE);
+        const inverted = f.inv(lastMultiplied);
+        nums.reduceRight((acc, num, i) => {
+            if (f.is0(num))
+                return acc;
+            tmp[i] = f.mul(acc, tmp[i]);
+            return f.mul(acc, num);
+        }, inverted);
+        return tmp;
+    }
+    function nLength(n, nBitLength) {
+        const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
+        const nByteLength = Math.ceil(_nBitLength / 8);
+        return { nBitLength: _nBitLength, nByteLength };
+    }
+    function Field(ORDER, bitLen, isLE = false, redef = {}) {
+        if (ORDER <= _0n$7)
+            throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
+        const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);
+        if (BYTES > 2048)
+            throw new Error('Field lengths over 2048 bytes are not supported');
+        const sqrtP = FpSqrt(ORDER);
+        const f = Object.freeze({
+            ORDER,
+            BITS,
+            BYTES,
+            MASK: bitMask(BITS),
+            ZERO: _0n$7,
+            ONE: _1n$7,
+            create: (num) => mod(num, ORDER),
+            isValid: (num) => {
+                if (typeof num !== 'bigint')
+                    throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
+                return _0n$7 <= num && num < ORDER;
+            },
+            is0: (num) => num === _0n$7,
+            isOdd: (num) => (num & _1n$7) === _1n$7,
+            neg: (num) => mod(-num, ORDER),
+            eql: (lhs, rhs) => lhs === rhs,
+            sqr: (num) => mod(num * num, ORDER),
+            add: (lhs, rhs) => mod(lhs + rhs, ORDER),
+            sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
+            mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
+            pow: (num, power) => FpPow(f, num, power),
+            div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
+            sqrN: (num) => num * num,
+            addN: (lhs, rhs) => lhs + rhs,
+            subN: (lhs, rhs) => lhs - rhs,
+            mulN: (lhs, rhs) => lhs * rhs,
+            inv: (num) => invert(num, ORDER),
+            sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
+            invertBatch: (lst) => FpInvertBatch(f, lst),
+            cmov: (a, b, c) => (c ? b : a),
+            toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),
+            fromBytes: (bytes) => {
+                if (bytes.length !== BYTES)
+                    throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);
+                return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+            },
+        });
+        return Object.freeze(f);
+    }
+    function FpSqrtEven(Fp, elm) {
+        if (!Fp.isOdd)
+            throw new Error(`Field doesn't have isOdd`);
+        const root = Fp.sqrt(elm);
+        return Fp.isOdd(root) ? Fp.neg(root) : root;
+    }
+    function getFieldBytesLength(fieldOrder) {
+        if (typeof fieldOrder !== 'bigint')
+            throw new Error('field order must be bigint');
+        const bitLength = fieldOrder.toString(2).length;
+        return Math.ceil(bitLength / 8);
+    }
+    function getMinHashLength(fieldOrder) {
+        const length = getFieldBytesLength(fieldOrder);
+        return length + Math.ceil(length / 2);
+    }
+    function mapHashToField(key, fieldOrder, isLE = false) {
+        const len = key.length;
+        const fieldLen = getFieldBytesLength(fieldOrder);
+        const minLen = getMinHashLength(fieldOrder);
+        if (len < 16 || len < minLen || len > 1024)
+            throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
+        const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);
+        const reduced = mod(num, fieldOrder - _1n$7) + _1n$7;
+        return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$6 = BigInt(0);
+    const _1n$6 = BigInt(1);
+    function wNAF(c, bits) {
+        const constTimeNegate = (condition, item) => {
+            const neg = item.negate();
+            return condition ? neg : item;
+        };
+        const opts = (W) => {
+            const windows = Math.ceil(bits / W) + 1;
+            const windowSize = 2 ** (W - 1);
+            return { windows, windowSize };
+        };
+        return {
+            constTimeNegate,
+            unsafeLadder(elm, n) {
+                let p = c.ZERO;
+                let d = elm;
+                while (n > _0n$6) {
+                    if (n & _1n$6)
+                        p = p.add(d);
+                    d = d.double();
+                    n >>= _1n$6;
+                }
+                return p;
+            },
+            precomputeWindow(elm, W) {
+                const { windows, windowSize } = opts(W);
+                const points = [];
+                let p = elm;
+                let base = p;
+                for (let window = 0; window < windows; window++) {
+                    base = p;
+                    points.push(base);
+                    for (let i = 1; i < windowSize; i++) {
+                        base = base.add(p);
+                        points.push(base);
+                    }
+                    p = base.double();
+                }
+                return points;
+            },
+            wNAF(W, precomputes, n) {
+                const { windows, windowSize } = opts(W);
+                let p = c.ZERO;
+                let f = c.BASE;
+                const mask = BigInt(2 ** W - 1);
+                const maxNumber = 2 ** W;
+                const shiftBy = BigInt(W);
+                for (let window = 0; window < windows; window++) {
+                    const offset = window * windowSize;
+                    let wbits = Number(n & mask);
+                    n >>= shiftBy;
+                    if (wbits > windowSize) {
+                        wbits -= maxNumber;
+                        n += _1n$6;
+                    }
+                    const offset1 = offset;
+                    const offset2 = offset + Math.abs(wbits) - 1;
+                    const cond1 = window % 2 !== 0;
+                    const cond2 = wbits < 0;
+                    if (wbits === 0) {
+                        f = f.add(constTimeNegate(cond1, precomputes[offset1]));
+                    }
+                    else {
+                        p = p.add(constTimeNegate(cond2, precomputes[offset2]));
+                    }
+                }
+                return { p, f };
+            },
+            wNAFCached(P, precomputesMap, n, transform) {
+                const W = P._WINDOW_SIZE || 1;
+                let comp = precomputesMap.get(P);
+                if (!comp) {
+                    comp = this.precomputeWindow(P, W);
+                    if (W !== 1) {
+                        precomputesMap.set(P, transform(comp));
+                    }
+                }
+                return this.wNAF(W, comp, n);
+            },
+        };
+    }
+    function validateBasic(curve) {
+        validateField(curve.Fp);
+        validateObject(curve, {
+            n: 'bigint',
+            h: 'bigint',
+            Gx: 'field',
+            Gy: 'field',
+        }, {
+            nBitLength: 'isSafeInteger',
+            nByteLength: 'isSafeInteger',
+        });
+        return Object.freeze({
+            ...nLength(curve.n, curve.nBitLength),
+            ...curve,
+            ...{ p: curve.Fp.ORDER },
+        });
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    function validatePointOpts(curve) {
+        const opts = validateBasic(curve);
+        validateObject(opts, {
+            a: 'field',
+            b: 'field',
+        }, {
+            allowedPrivateKeyLengths: 'array',
+            wrapPrivateKey: 'boolean',
+            isTorsionFree: 'function',
+            clearCofactor: 'function',
+            allowInfinityPoint: 'boolean',
+            fromBytes: 'function',
+            toBytes: 'function',
+        });
+        const { endo, Fp, a } = opts;
+        if (endo) {
+            if (!Fp.eql(a, Fp.ZERO)) {
+                throw new Error('Endomorphism can only be defined for Koblitz curves that have a=0');
+            }
+            if (typeof endo !== 'object' ||
+                typeof endo.beta !== 'bigint' ||
+                typeof endo.splitScalar !== 'function') {
+                throw new Error('Expected endomorphism with beta: bigint and splitScalar: function');
+            }
+        }
+        return Object.freeze({ ...opts });
+    }
+    const { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;
+    const DER = {
+        Err: class DERErr extends Error {
+            constructor(m = '') {
+                super(m);
+            }
+        },
+        _parseInt(data) {
+            const { Err: E } = DER;
+            if (data.length < 2 || data[0] !== 0x02)
+                throw new E('Invalid signature integer tag');
+            const len = data[1];
+            const res = data.subarray(2, len + 2);
+            if (!len || res.length !== len)
+                throw new E('Invalid signature integer: wrong length');
+            if (res[0] & 0b10000000)
+                throw new E('Invalid signature integer: negative');
+            if (res[0] === 0x00 && !(res[1] & 0b10000000))
+                throw new E('Invalid signature integer: unnecessary leading zero');
+            return { d: b2n(res), l: data.subarray(len + 2) };
+        },
+        toSig(hex) {
+            const { Err: E } = DER;
+            const data = typeof hex === 'string' ? h2b(hex) : hex;
+            if (!isBytes(data))
+                throw new Error('ui8a expected');
+            let l = data.length;
+            if (l < 2 || data[0] != 0x30)
+                throw new E('Invalid signature tag');
+            if (data[1] !== l - 2)
+                throw new E('Invalid signature: incorrect length');
+            const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
+            const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
+            if (rBytesLeft.length)
+                throw new E('Invalid signature: left bytes after parsing');
+            return { r, s };
+        },
+        hexFromSig(sig) {
+            const slice = (s) => (Number.parseInt(s[0], 16) & 0b1000 ? '00' + s : s);
+            const h = (num) => {
+                const hex = num.toString(16);
+                return hex.length & 1 ? `0${hex}` : hex;
+            };
+            const s = slice(h(sig.s));
+            const r = slice(h(sig.r));
+            const shl = s.length / 2;
+            const rhl = r.length / 2;
+            const sl = h(shl);
+            const rl = h(rhl);
+            return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
+        },
+    };
+    const _0n$5 = BigInt(0), _1n$5 = BigInt(1), _2n$4 = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);
+    function weierstrassPoints(opts) {
+        const CURVE = validatePointOpts(opts);
+        const { Fp } = CURVE;
+        const toBytes = CURVE.toBytes ||
+            ((_c, point, _isCompressed) => {
+                const a = point.toAffine();
+                return concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+            });
+        const fromBytes = CURVE.fromBytes ||
+            ((bytes) => {
+                const tail = bytes.subarray(1);
+                const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+                const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+                return { x, y };
+            });
+        function weierstrassEquation(x) {
+            const { a, b } = CURVE;
+            const x2 = Fp.sqr(x);
+            const x3 = Fp.mul(x2, x);
+            return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
+        }
+        if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
+            throw new Error('bad generator point: equation left != right');
+        function isWithinCurveOrder(num) {
+            return typeof num === 'bigint' && _0n$5 < num && num < CURVE.n;
+        }
+        function assertGE(num) {
+            if (!isWithinCurveOrder(num))
+                throw new Error('Expected valid bigint: 0 < bigint < curve.n');
+        }
+        function normPrivateKeyToScalar(key) {
+            const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
+            if (lengths && typeof key !== 'bigint') {
+                if (isBytes(key))
+                    key = bytesToHex(key);
+                if (typeof key !== 'string' || !lengths.includes(key.length))
+                    throw new Error('Invalid key');
+                key = key.padStart(nByteLength * 2, '0');
+            }
+            let num;
+            try {
+                num =
+                    typeof key === 'bigint'
+                        ? key
+                        : bytesToNumberBE(ensureBytes('private key', key, nByteLength));
+            }
+            catch (error) {
+                throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
+            }
+            if (wrapPrivateKey)
+                num = mod(num, n);
+            assertGE(num);
+            return num;
+        }
+        const pointPrecomputes = new Map();
+        function assertPrjPoint(other) {
+            if (!(other instanceof Point))
+                throw new Error('ProjectivePoint expected');
+        }
+        class Point {
+            constructor(px, py, pz) {
+                this.px = px;
+                this.py = py;
+                this.pz = pz;
+                if (px == null || !Fp.isValid(px))
+                    throw new Error('x required');
+                if (py == null || !Fp.isValid(py))
+                    throw new Error('y required');
+                if (pz == null || !Fp.isValid(pz))
+                    throw new Error('z required');
+            }
+            static fromAffine(p) {
+                const { x, y } = p || {};
+                if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+                    throw new Error('invalid affine point');
+                if (p instanceof Point)
+                    throw new Error('projective point not allowed');
+                const is0 = (i) => Fp.eql(i, Fp.ZERO);
+                if (is0(x) && is0(y))
+                    return Point.ZERO;
+                return new Point(x, y, Fp.ONE);
+            }
+            get x() {
+                return this.toAffine().x;
+            }
+            get y() {
+                return this.toAffine().y;
+            }
+            static normalizeZ(points) {
+                const toInv = Fp.invertBatch(points.map((p) => p.pz));
+                return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+            }
+            static fromHex(hex) {
+                const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));
+                P.assertValidity();
+                return P;
+            }
+            static fromPrivateKey(privateKey) {
+                return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
+            }
+            _setWindowSize(windowSize) {
+                this._WINDOW_SIZE = windowSize;
+                pointPrecomputes.delete(this);
+            }
+            assertValidity() {
+                if (this.is0()) {
+                    if (CURVE.allowInfinityPoint && !Fp.is0(this.py))
+                        return;
+                    throw new Error('bad point: ZERO');
+                }
+                const { x, y } = this.toAffine();
+                if (!Fp.isValid(x) || !Fp.isValid(y))
+                    throw new Error('bad point: x or y not FE');
+                const left = Fp.sqr(y);
+                const right = weierstrassEquation(x);
+                if (!Fp.eql(left, right))
+                    throw new Error('bad point: equation left != right');
+                if (!this.isTorsionFree())
+                    throw new Error('bad point: not in prime-order subgroup');
+            }
+            hasEvenY() {
+                const { y } = this.toAffine();
+                if (Fp.isOdd)
+                    return !Fp.isOdd(y);
+                throw new Error("Field doesn't support isOdd");
+            }
+            equals(other) {
+                assertPrjPoint(other);
+                const { px: X1, py: Y1, pz: Z1 } = this;
+                const { px: X2, py: Y2, pz: Z2 } = other;
+                const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+                const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+                return U1 && U2;
+            }
+            negate() {
+                return new Point(this.px, Fp.neg(this.py), this.pz);
+            }
+            double() {
+                const { a, b } = CURVE;
+                const b3 = Fp.mul(b, _3n);
+                const { px: X1, py: Y1, pz: Z1 } = this;
+                let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+                let t0 = Fp.mul(X1, X1);
+                let t1 = Fp.mul(Y1, Y1);
+                let t2 = Fp.mul(Z1, Z1);
+                let t3 = Fp.mul(X1, Y1);
+                t3 = Fp.add(t3, t3);
+                Z3 = Fp.mul(X1, Z1);
+                Z3 = Fp.add(Z3, Z3);
+                X3 = Fp.mul(a, Z3);
+                Y3 = Fp.mul(b3, t2);
+                Y3 = Fp.add(X3, Y3);
+                X3 = Fp.sub(t1, Y3);
+                Y3 = Fp.add(t1, Y3);
+                Y3 = Fp.mul(X3, Y3);
+                X3 = Fp.mul(t3, X3);
+                Z3 = Fp.mul(b3, Z3);
+                t2 = Fp.mul(a, t2);
+                t3 = Fp.sub(t0, t2);
+                t3 = Fp.mul(a, t3);
+                t3 = Fp.add(t3, Z3);
+                Z3 = Fp.add(t0, t0);
+                t0 = Fp.add(Z3, t0);
+                t0 = Fp.add(t0, t2);
+                t0 = Fp.mul(t0, t3);
+                Y3 = Fp.add(Y3, t0);
+                t2 = Fp.mul(Y1, Z1);
+                t2 = Fp.add(t2, t2);
+                t0 = Fp.mul(t2, t3);
+                X3 = Fp.sub(X3, t0);
+                Z3 = Fp.mul(t2, t1);
+                Z3 = Fp.add(Z3, Z3);
+                Z3 = Fp.add(Z3, Z3);
+                return new Point(X3, Y3, Z3);
+            }
+            add(other) {
+                assertPrjPoint(other);
+                const { px: X1, py: Y1, pz: Z1 } = this;
+                const { px: X2, py: Y2, pz: Z2 } = other;
+                let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+                const a = CURVE.a;
+                const b3 = Fp.mul(CURVE.b, _3n);
+                let t0 = Fp.mul(X1, X2);
+                let t1 = Fp.mul(Y1, Y2);
+                let t2 = Fp.mul(Z1, Z2);
+                let t3 = Fp.add(X1, Y1);
+                let t4 = Fp.add(X2, Y2);
+                t3 = Fp.mul(t3, t4);
+                t4 = Fp.add(t0, t1);
+                t3 = Fp.sub(t3, t4);
+                t4 = Fp.add(X1, Z1);
+                let t5 = Fp.add(X2, Z2);
+                t4 = Fp.mul(t4, t5);
+                t5 = Fp.add(t0, t2);
+                t4 = Fp.sub(t4, t5);
+                t5 = Fp.add(Y1, Z1);
+                X3 = Fp.add(Y2, Z2);
+                t5 = Fp.mul(t5, X3);
+                X3 = Fp.add(t1, t2);
+                t5 = Fp.sub(t5, X3);
+                Z3 = Fp.mul(a, t4);
+                X3 = Fp.mul(b3, t2);
+                Z3 = Fp.add(X3, Z3);
+                X3 = Fp.sub(t1, Z3);
+                Z3 = Fp.add(t1, Z3);
+                Y3 = Fp.mul(X3, Z3);
+                t1 = Fp.add(t0, t0);
+                t1 = Fp.add(t1, t0);
+                t2 = Fp.mul(a, t2);
+                t4 = Fp.mul(b3, t4);
+                t1 = Fp.add(t1, t2);
+                t2 = Fp.sub(t0, t2);
+                t2 = Fp.mul(a, t2);
+                t4 = Fp.add(t4, t2);
+                t0 = Fp.mul(t1, t4);
+                Y3 = Fp.add(Y3, t0);
+                t0 = Fp.mul(t5, t4);
+                X3 = Fp.mul(t3, X3);
+                X3 = Fp.sub(X3, t0);
+                t0 = Fp.mul(t3, t1);
+                Z3 = Fp.mul(t5, Z3);
+                Z3 = Fp.add(Z3, t0);
+                return new Point(X3, Y3, Z3);
+            }
+            subtract(other) {
+                return this.add(other.negate());
+            }
+            is0() {
+                return this.equals(Point.ZERO);
+            }
+            wNAF(n) {
+                return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
+                    const toInv = Fp.invertBatch(comp.map((p) => p.pz));
+                    return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+                });
+            }
+            multiplyUnsafe(n) {
+                const I = Point.ZERO;
+                if (n === _0n$5)
+                    return I;
+                assertGE(n);
+                if (n === _1n$5)
+                    return this;
+                const { endo } = CURVE;
+                if (!endo)
+                    return wnaf.unsafeLadder(this, n);
+                let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+                let k1p = I;
+                let k2p = I;
+                let d = this;
+                while (k1 > _0n$5 || k2 > _0n$5) {
+                    if (k1 & _1n$5)
+                        k1p = k1p.add(d);
+                    if (k2 & _1n$5)
+                        k2p = k2p.add(d);
+                    d = d.double();
+                    k1 >>= _1n$5;
+                    k2 >>= _1n$5;
+                }
+                if (k1neg)
+                    k1p = k1p.negate();
+                if (k2neg)
+                    k2p = k2p.negate();
+                k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+                return k1p.add(k2p);
+            }
+            multiply(scalar) {
+                assertGE(scalar);
+                let n = scalar;
+                let point, fake;
+                const { endo } = CURVE;
+                if (endo) {
+                    const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+                    let { p: k1p, f: f1p } = this.wNAF(k1);
+                    let { p: k2p, f: f2p } = this.wNAF(k2);
+                    k1p = wnaf.constTimeNegate(k1neg, k1p);
+                    k2p = wnaf.constTimeNegate(k2neg, k2p);
+                    k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+                    point = k1p.add(k2p);
+                    fake = f1p.add(f2p);
+                }
+                else {
+                    const { p, f } = this.wNAF(n);
+                    point = p;
+                    fake = f;
+                }
+                return Point.normalizeZ([point, fake])[0];
+            }
+            multiplyAndAddUnsafe(Q, a, b) {
+                const G = Point.BASE;
+                const mul = (P, a
+                ) => (a === _0n$5 || a === _1n$5 || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));
+                const sum = mul(this, a).add(mul(Q, b));
+                return sum.is0() ? undefined : sum;
+            }
+            toAffine(iz) {
+                const { px: x, py: y, pz: z } = this;
+                const is0 = this.is0();
+                if (iz == null)
+                    iz = is0 ? Fp.ONE : Fp.inv(z);
+                const ax = Fp.mul(x, iz);
+                const ay = Fp.mul(y, iz);
+                const zz = Fp.mul(z, iz);
+                if (is0)
+                    return { x: Fp.ZERO, y: Fp.ZERO };
+                if (!Fp.eql(zz, Fp.ONE))
+                    throw new Error('invZ was invalid');
+                return { x: ax, y: ay };
+            }
+            isTorsionFree() {
+                const { h: cofactor, isTorsionFree } = CURVE;
+                if (cofactor === _1n$5)
+                    return true;
+                if (isTorsionFree)
+                    return isTorsionFree(Point, this);
+                throw new Error('isTorsionFree() has not been declared for the elliptic curve');
+            }
+            clearCofactor() {
+                const { h: cofactor, clearCofactor } = CURVE;
+                if (cofactor === _1n$5)
+                    return this;
+                if (clearCofactor)
+                    return clearCofactor(Point, this);
+                return this.multiplyUnsafe(CURVE.h);
+            }
+            toRawBytes(isCompressed = true) {
+                this.assertValidity();
+                return toBytes(Point, this, isCompressed);
+            }
+            toHex(isCompressed = true) {
+                return bytesToHex(this.toRawBytes(isCompressed));
+            }
+        }
+        Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+        Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+        const _bits = CURVE.nBitLength;
+        const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
+        return {
+            CURVE,
+            ProjectivePoint: Point,
+            normPrivateKeyToScalar,
+            weierstrassEquation,
+            isWithinCurveOrder,
+        };
+    }
+    function validateOpts$2(curve) {
+        const opts = validateBasic(curve);
+        validateObject(opts, {
+            hash: 'hash',
+            hmac: 'function',
+            randomBytes: 'function',
+        }, {
+            bits2int: 'function',
+            bits2int_modN: 'function',
+            lowS: 'boolean',
+        });
+        return Object.freeze({ lowS: true, ...opts });
+    }
+    function weierstrass(curveDef) {
+        const CURVE = validateOpts$2(curveDef);
+        const { Fp, n: CURVE_ORDER } = CURVE;
+        const compressedLen = Fp.BYTES + 1;
+        const uncompressedLen = 2 * Fp.BYTES + 1;
+        function isValidFieldElement(num) {
+            return _0n$5 < num && num < Fp.ORDER;
+        }
+        function modN(a) {
+            return mod(a, CURVE_ORDER);
+        }
+        function invN(a) {
+            return invert(a, CURVE_ORDER);
+        }
+        const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder, } = weierstrassPoints({
+            ...CURVE,
+            toBytes(_c, point, isCompressed) {
+                const a = point.toAffine();
+                const x = Fp.toBytes(a.x);
+                const cat = concatBytes;
+                if (isCompressed) {
+                    return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);
+                }
+                else {
+                    return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));
+                }
+            },
+            fromBytes(bytes) {
+                const len = bytes.length;
+                const head = bytes[0];
+                const tail = bytes.subarray(1);
+                if (len === compressedLen && (head === 0x02 || head === 0x03)) {
+                    const x = bytesToNumberBE(tail);
+                    if (!isValidFieldElement(x))
+                        throw new Error('Point is not on curve');
+                    const y2 = weierstrassEquation(x);
+                    let y = Fp.sqrt(y2);
+                    const isYOdd = (y & _1n$5) === _1n$5;
+                    const isHeadOdd = (head & 1) === 1;
+                    if (isHeadOdd !== isYOdd)
+                        y = Fp.neg(y);
+                    return { x, y };
+                }
+                else if (len === uncompressedLen && head === 0x04) {
+                    const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+                    const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+                    return { x, y };
+                }
+                else {
+                    throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
+                }
+            },
+        });
+        const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
+        function isBiggerThanHalfOrder(number) {
+            const HALF = CURVE_ORDER >> _1n$5;
+            return number > HALF;
+        }
+        function normalizeS(s) {
+            return isBiggerThanHalfOrder(s) ? modN(-s) : s;
+        }
+        const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
+        class Signature {
+            constructor(r, s, recovery) {
+                this.r = r;
+                this.s = s;
+                this.recovery = recovery;
+                this.assertValidity();
+            }
+            static fromCompact(hex) {
+                const l = CURVE.nByteLength;
+                hex = ensureBytes('compactSignature', hex, l * 2);
+                return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
+            }
+            static fromDER(hex) {
+                const { r, s } = DER.toSig(ensureBytes('DER', hex));
+                return new Signature(r, s);
+            }
+            assertValidity() {
+                if (!isWithinCurveOrder(this.r))
+                    throw new Error('r must be 0 < r < CURVE.n');
+                if (!isWithinCurveOrder(this.s))
+                    throw new Error('s must be 0 < s < CURVE.n');
+            }
+            addRecoveryBit(recovery) {
+                return new Signature(this.r, this.s, recovery);
+            }
+            recoverPublicKey(msgHash) {
+                const { r, s, recovery: rec } = this;
+                const h = bits2int_modN(ensureBytes('msgHash', msgHash));
+                if (rec == null || ![0, 1, 2, 3].includes(rec))
+                    throw new Error('recovery id invalid');
+                const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
+                if (radj >= Fp.ORDER)
+                    throw new Error('recovery id 2 or 3 invalid');
+                const prefix = (rec & 1) === 0 ? '02' : '03';
+                const R = Point.fromHex(prefix + numToNByteStr(radj));
+                const ir = invN(radj);
+                const u1 = modN(-h * ir);
+                const u2 = modN(s * ir);
+                const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
+                if (!Q)
+                    throw new Error('point at infinify');
+                Q.assertValidity();
+                return Q;
+            }
+            hasHighS() {
+                return isBiggerThanHalfOrder(this.s);
+            }
+            normalizeS() {
+                return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
+            }
+            toDERRawBytes() {
+                return hexToBytes(this.toDERHex());
+            }
+            toDERHex() {
+                return DER.hexFromSig({ r: this.r, s: this.s });
+            }
+            toCompactRawBytes() {
+                return hexToBytes(this.toCompactHex());
+            }
+            toCompactHex() {
+                return numToNByteStr(this.r) + numToNByteStr(this.s);
+            }
+        }
+        const utils = {
+            isValidPrivateKey(privateKey) {
+                try {
+                    normPrivateKeyToScalar(privateKey);
+                    return true;
+                }
+                catch (error) {
+                    return false;
+                }
+            },
+            normPrivateKeyToScalar: normPrivateKeyToScalar,
+            randomPrivateKey: () => {
+                const length = getMinHashLength(CURVE.n);
+                return mapHashToField(CURVE.randomBytes(length), CURVE.n);
+            },
+            precompute(windowSize = 8, point = Point.BASE) {
+                point._setWindowSize(windowSize);
+                point.multiply(BigInt(3));
+                return point;
+            },
+        };
+        function getPublicKey(privateKey, isCompressed = true) {
+            return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
+        }
+        function isProbPub(item) {
+            const arr = isBytes(item);
+            const str = typeof item === 'string';
+            const len = (arr || str) && item.length;
+            if (arr)
+                return len === compressedLen || len === uncompressedLen;
+            if (str)
+                return len === 2 * compressedLen || len === 2 * uncompressedLen;
+            if (item instanceof Point)
+                return true;
+            return false;
+        }
+        function getSharedSecret(privateA, publicB, isCompressed = true) {
+            if (isProbPub(privateA))
+                throw new Error('first arg must be private key');
+            if (!isProbPub(publicB))
+                throw new Error('second arg must be public key');
+            const b = Point.fromHex(publicB);
+            return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
+        }
+        const bits2int = CURVE.bits2int ||
+            function (bytes) {
+                const num = bytesToNumberBE(bytes);
+                const delta = bytes.length * 8 - CURVE.nBitLength;
+                return delta > 0 ? num >> BigInt(delta) : num;
+            };
+        const bits2int_modN = CURVE.bits2int_modN ||
+            function (bytes) {
+                return modN(bits2int(bytes));
+            };
+        const ORDER_MASK = bitMask(CURVE.nBitLength);
+        function int2octets(num) {
+            if (typeof num !== 'bigint')
+                throw new Error('bigint expected');
+            if (!(_0n$5 <= num && num < ORDER_MASK))
+                throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);
+            return numberToBytesBE(num, CURVE.nByteLength);
+        }
+        function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
+            if (['recovered', 'canonical'].some((k) => k in opts))
+                throw new Error('sign() legacy options not supported');
+            const { hash, randomBytes } = CURVE;
+            let { lowS, prehash, extraEntropy: ent } = opts;
+            if (lowS == null)
+                lowS = true;
+            msgHash = ensureBytes('msgHash', msgHash);
+            if (prehash)
+                msgHash = ensureBytes('prehashed msgHash', hash(msgHash));
+            const h1int = bits2int_modN(msgHash);
+            const d = normPrivateKeyToScalar(privateKey);
+            const seedArgs = [int2octets(d), int2octets(h1int)];
+            if (ent != null) {
+                const e = ent === true ? randomBytes(Fp.BYTES) : ent;
+                seedArgs.push(ensureBytes('extraEntropy', e));
+            }
+            const seed = concatBytes(...seedArgs);
+            const m = h1int;
+            function k2sig(kBytes) {
+                const k = bits2int(kBytes);
+                if (!isWithinCurveOrder(k))
+                    return;
+                const ik = invN(k);
+                const q = Point.BASE.multiply(k).toAffine();
+                const r = modN(q.x);
+                if (r === _0n$5)
+                    return;
+                const s = modN(ik * modN(m + r * d));
+                if (s === _0n$5)
+                    return;
+                let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n$5);
+                let normS = s;
+                if (lowS && isBiggerThanHalfOrder(s)) {
+                    normS = normalizeS(s);
+                    recovery ^= 1;
+                }
+                return new Signature(r, normS, recovery);
+            }
+            return { seed, k2sig };
+        }
+        const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
+        const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
+        function sign(msgHash, privKey, opts = defaultSigOpts) {
+            const { seed, k2sig } = prepSig(msgHash, privKey, opts);
+            const C = CURVE;
+            const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
+            return drbg(seed, k2sig);
+        }
+        Point.BASE._setWindowSize(8);
+        function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
+            const sg = signature;
+            msgHash = ensureBytes('msgHash', msgHash);
+            publicKey = ensureBytes('publicKey', publicKey);
+            if ('strict' in opts)
+                throw new Error('options.strict was renamed to lowS');
+            const { lowS, prehash } = opts;
+            let _sig = undefined;
+            let P;
+            try {
+                if (typeof sg === 'string' || isBytes(sg)) {
+                    try {
+                        _sig = Signature.fromDER(sg);
+                    }
+                    catch (derError) {
+                        if (!(derError instanceof DER.Err))
+                            throw derError;
+                        _sig = Signature.fromCompact(sg);
+                    }
+                }
+                else if (typeof sg === 'object' && typeof sg.r === 'bigint' && typeof sg.s === 'bigint') {
+                    const { r, s } = sg;
+                    _sig = new Signature(r, s);
+                }
+                else {
+                    throw new Error('PARSE');
+                }
+                P = Point.fromHex(publicKey);
+            }
+            catch (error) {
+                if (error.message === 'PARSE')
+                    throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
+                return false;
+            }
+            if (lowS && _sig.hasHighS())
+                return false;
+            if (prehash)
+                msgHash = CURVE.hash(msgHash);
+            const { r, s } = _sig;
+            const h = bits2int_modN(msgHash);
+            const is = invN(s);
+            const u1 = modN(h * is);
+            const u2 = modN(r * is);
+            const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
+            if (!R)
+                return false;
+            const v = modN(R.x);
+            return v === r;
+        }
+        return {
+            CURVE,
+            getPublicKey,
+            getSharedSecret,
+            sign,
+            verify,
+            ProjectivePoint: Point,
+            Signature,
+            utils,
+        };
+    }
+    function SWUFpSqrtRatio(Fp, Z) {
+        const q = Fp.ORDER;
+        let l = _0n$5;
+        for (let o = q - _1n$5; o % _2n$4 === _0n$5; o /= _2n$4)
+            l += _1n$5;
+        const c1 = l;
+        const _2n_pow_c1_1 = _2n$4 << (c1 - _1n$5 - _1n$5);
+        const _2n_pow_c1 = _2n_pow_c1_1 * _2n$4;
+        const c2 = (q - _1n$5) / _2n_pow_c1;
+        const c3 = (c2 - _1n$5) / _2n$4;
+        const c4 = _2n_pow_c1 - _1n$5;
+        const c5 = _2n_pow_c1_1;
+        const c6 = Fp.pow(Z, c2);
+        const c7 = Fp.pow(Z, (c2 + _1n$5) / _2n$4);
+        let sqrtRatio = (u, v) => {
+            let tv1 = c6;
+            let tv2 = Fp.pow(v, c4);
+            let tv3 = Fp.sqr(tv2);
+            tv3 = Fp.mul(tv3, v);
+            let tv5 = Fp.mul(u, tv3);
+            tv5 = Fp.pow(tv5, c3);
+            tv5 = Fp.mul(tv5, tv2);
+            tv2 = Fp.mul(tv5, v);
+            tv3 = Fp.mul(tv5, u);
+            let tv4 = Fp.mul(tv3, tv2);
+            tv5 = Fp.pow(tv4, c5);
+            let isQR = Fp.eql(tv5, Fp.ONE);
+            tv2 = Fp.mul(tv3, c7);
+            tv5 = Fp.mul(tv4, tv1);
+            tv3 = Fp.cmov(tv2, tv3, isQR);
+            tv4 = Fp.cmov(tv5, tv4, isQR);
+            for (let i = c1; i > _1n$5; i--) {
+                let tv5 = i - _2n$4;
+                tv5 = _2n$4 << (tv5 - _1n$5);
+                let tvv5 = Fp.pow(tv4, tv5);
+                const e1 = Fp.eql(tvv5, Fp.ONE);
+                tv2 = Fp.mul(tv3, tv1);
+                tv1 = Fp.mul(tv1, tv1);
+                tvv5 = Fp.mul(tv4, tv1);
+                tv3 = Fp.cmov(tv2, tv3, e1);
+                tv4 = Fp.cmov(tvv5, tv4, e1);
+            }
+            return { isValid: isQR, value: tv3 };
+        };
+        if (Fp.ORDER % _4n === _3n) {
+            const c1 = (Fp.ORDER - _3n) / _4n;
+            const c2 = Fp.sqrt(Fp.neg(Z));
+            sqrtRatio = (u, v) => {
+                let tv1 = Fp.sqr(v);
+                const tv2 = Fp.mul(u, v);
+                tv1 = Fp.mul(tv1, tv2);
+                let y1 = Fp.pow(tv1, c1);
+                y1 = Fp.mul(y1, tv2);
+                const y2 = Fp.mul(y1, c2);
+                const tv3 = Fp.mul(Fp.sqr(y1), v);
+                const isQR = Fp.eql(tv3, u);
+                let y = Fp.cmov(y2, y1, isQR);
+                return { isValid: isQR, value: y };
+            };
+        }
+        return sqrtRatio;
+    }
+    function mapToCurveSimpleSWU(Fp, opts) {
+        validateField(Fp);
+        if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
+            throw new Error('mapToCurveSimpleSWU: invalid opts');
+        const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
+        if (!Fp.isOdd)
+            throw new Error('Fp.isOdd is not implemented!');
+        return (u) => {
+            let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
+            tv1 = Fp.sqr(u);
+            tv1 = Fp.mul(tv1, opts.Z);
+            tv2 = Fp.sqr(tv1);
+            tv2 = Fp.add(tv2, tv1);
+            tv3 = Fp.add(tv2, Fp.ONE);
+            tv3 = Fp.mul(tv3, opts.B);
+            tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+            tv4 = Fp.mul(tv4, opts.A);
+            tv2 = Fp.sqr(tv3);
+            tv6 = Fp.sqr(tv4);
+            tv5 = Fp.mul(tv6, opts.A);
+            tv2 = Fp.add(tv2, tv5);
+            tv2 = Fp.mul(tv2, tv3);
+            tv6 = Fp.mul(tv6, tv4);
+            tv5 = Fp.mul(tv6, opts.B);
+            tv2 = Fp.add(tv2, tv5);
+            x = Fp.mul(tv1, tv3);
+            const { isValid, value } = sqrtRatio(tv2, tv6);
+            y = Fp.mul(tv1, u);
+            y = Fp.mul(y, value);
+            x = Fp.cmov(x, tv3, isValid);
+            y = Fp.cmov(y, value, isValid);
+            const e1 = Fp.isOdd(u) === Fp.isOdd(y);
+            y = Fp.cmov(Fp.neg(y), y, e1);
+            x = Fp.div(x, tv4);
+            return { x, y };
+        };
+    }
+
+    function validateDST(dst) {
+        if (isBytes(dst))
+            return dst;
+        if (typeof dst === 'string')
+            return utf8ToBytes(dst);
+        throw new Error('DST must be Uint8Array or string');
+    }
+    const os2ip = bytesToNumberBE;
+    function i2osp(value, length) {
+        if (value < 0 || value >= 1 << (8 * length)) {
+            throw new Error(`bad I2OSP call: value=${value} length=${length}`);
+        }
+        const res = Array.from({ length }).fill(0);
+        for (let i = length - 1; i >= 0; i--) {
+            res[i] = value & 0xff;
+            value >>>= 8;
+        }
+        return new Uint8Array(res);
+    }
+    function strxor(a, b) {
+        const arr = new Uint8Array(a.length);
+        for (let i = 0; i < a.length; i++) {
+            arr[i] = a[i] ^ b[i];
+        }
+        return arr;
+    }
+    function abytes(item) {
+        if (!isBytes(item))
+            throw new Error('Uint8Array expected');
+    }
+    function isNum(item) {
+        if (!Number.isSafeInteger(item))
+            throw new Error('number expected');
+    }
+    function expand_message_xmd(msg, DST, lenInBytes, H) {
+        abytes(msg);
+        abytes(DST);
+        isNum(lenInBytes);
+        if (DST.length > 255)
+            DST = H(concatBytes(utf8ToBytes('H2C-OVERSIZE-DST-'), DST));
+        const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
+        const ell = Math.ceil(lenInBytes / b_in_bytes);
+        if (ell > 255)
+            throw new Error('Invalid xmd length');
+        const DST_prime = concatBytes(DST, i2osp(DST.length, 1));
+        const Z_pad = i2osp(0, r_in_bytes);
+        const l_i_b_str = i2osp(lenInBytes, 2);
+        const b = new Array(ell);
+        const b_0 = H(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+        b[0] = H(concatBytes(b_0, i2osp(1, 1), DST_prime));
+        for (let i = 1; i <= ell; i++) {
+            const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
+            b[i] = H(concatBytes(...args));
+        }
+        const pseudo_random_bytes = concatBytes(...b);
+        return pseudo_random_bytes.slice(0, lenInBytes);
+    }
+    function expand_message_xof(msg, DST, lenInBytes, k, H) {
+        abytes(msg);
+        abytes(DST);
+        isNum(lenInBytes);
+        if (DST.length > 255) {
+            const dkLen = Math.ceil((2 * k) / 8);
+            DST = H.create({ dkLen }).update(utf8ToBytes('H2C-OVERSIZE-DST-')).update(DST).digest();
+        }
+        if (lenInBytes > 65535 || DST.length > 255)
+            throw new Error('expand_message_xof: invalid lenInBytes');
+        return (H.create({ dkLen: lenInBytes })
+            .update(msg)
+            .update(i2osp(lenInBytes, 2))
+            .update(DST)
+            .update(i2osp(DST.length, 1))
+            .digest());
+    }
+    function hash_to_field(msg, count, options) {
+        validateObject(options, {
+            DST: 'stringOrUint8Array',
+            p: 'bigint',
+            m: 'isSafeInteger',
+            k: 'isSafeInteger',
+            hash: 'hash',
+        });
+        const { p, k, m, hash, expand, DST: _DST } = options;
+        abytes(msg);
+        isNum(count);
+        const DST = validateDST(_DST);
+        const log2p = p.toString(2).length;
+        const L = Math.ceil((log2p + k) / 8);
+        const len_in_bytes = count * m * L;
+        let prb;
+        if (expand === 'xmd') {
+            prb = expand_message_xmd(msg, DST, len_in_bytes, hash);
+        }
+        else if (expand === 'xof') {
+            prb = expand_message_xof(msg, DST, len_in_bytes, k, hash);
+        }
+        else if (expand === '_internal_pass') {
+            prb = msg;
+        }
+        else {
+            throw new Error('expand must be "xmd" or "xof"');
+        }
+        const u = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const e = new Array(m);
+            for (let j = 0; j < m; j++) {
+                const elm_offset = L * (j + i * m);
+                const tv = prb.subarray(elm_offset, elm_offset + L);
+                e[j] = mod(os2ip(tv), p);
+            }
+            u[i] = e;
+        }
+        return u;
+    }
+    function isogenyMap(field, map) {
+        const COEFF = map.map((i) => Array.from(i).reverse());
+        return (x, y) => {
+            const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
+            x = field.div(xNum, xDen);
+            y = field.mul(y, field.div(yNum, yDen));
+            return { x, y };
+        };
+    }
+    function createHasher(Point, mapToCurve, def) {
+        if (typeof mapToCurve !== 'function')
+            throw new Error('mapToCurve() must be defined');
+        return {
+            hashToCurve(msg, options) {
+                const u = hash_to_field(msg, 2, { ...def, DST: def.DST, ...options });
+                const u0 = Point.fromAffine(mapToCurve(u[0]));
+                const u1 = Point.fromAffine(mapToCurve(u[1]));
+                const P = u0.add(u1).clearCofactor();
+                P.assertValidity();
+                return P;
+            },
+            encodeToCurve(msg, options) {
+                const u = hash_to_field(msg, 1, { ...def, DST: def.encodeDST, ...options });
+                const P = Point.fromAffine(mapToCurve(u[0])).clearCofactor();
+                P.assertValidity();
+                return P;
+            },
+        };
+    }
+
+    class HMAC extends Hash {
+        constructor(hash$1, _key) {
+            super();
+            this.finished = false;
+            this.destroyed = false;
+            hash(hash$1);
+            const key = toBytes(_key);
+            this.iHash = hash$1.create();
+            if (typeof this.iHash.update !== 'function')
+                throw new Error('Expected instance of class which extends utils.Hash');
+            this.blockLen = this.iHash.blockLen;
+            this.outputLen = this.iHash.outputLen;
+            const blockLen = this.blockLen;
+            const pad = new Uint8Array(blockLen);
+            pad.set(key.length > blockLen ? hash$1.create().update(key).digest() : key);
+            for (let i = 0; i < pad.length; i++)
+                pad[i] ^= 0x36;
+            this.iHash.update(pad);
+            this.oHash = hash$1.create();
+            for (let i = 0; i < pad.length; i++)
+                pad[i] ^= 0x36 ^ 0x5c;
+            this.oHash.update(pad);
+            pad.fill(0);
+        }
+        update(buf) {
+            exists(this);
+            this.iHash.update(buf);
+            return this;
+        }
+        digestInto(out) {
+            exists(this);
+            bytes(out, this.outputLen);
+            this.finished = true;
+            this.iHash.digestInto(out);
+            this.oHash.update(out);
+            this.oHash.digestInto(out);
+            this.destroy();
+        }
+        digest() {
+            const out = new Uint8Array(this.oHash.outputLen);
+            this.digestInto(out);
+            return out;
+        }
+        _cloneInto(to) {
+            to || (to = Object.create(Object.getPrototypeOf(this), {}));
+            const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+            to = to;
+            to.finished = finished;
+            to.destroyed = destroyed;
+            to.blockLen = blockLen;
+            to.outputLen = outputLen;
+            to.oHash = oHash._cloneInto(to.oHash);
+            to.iHash = iHash._cloneInto(to.iHash);
+            return to;
+        }
+        destroy() {
+            this.destroyed = true;
+            this.oHash.destroy();
+            this.iHash.destroy();
+        }
+    }
+    const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+    hmac.create = (hash, key) => new HMAC(hash, key);
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    function getHash(hash) {
+        return {
+            hash,
+            hmac: (key, ...msgs) => hmac(hash, key, concatBytes$1(...msgs)),
+            randomBytes,
+        };
+    }
+    function createCurve(curveDef, defHash) {
+        const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });
+        return Object.freeze({ ...create(defHash), create });
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');
+    const secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
+    const _1n$4 = BigInt(1);
+    const _2n$3 = BigInt(2);
+    const divNearest = (a, b) => (a + b / _2n$3) / b;
+    function sqrtMod(y) {
+        const P = secp256k1P;
+        const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+        const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+        const b2 = (y * y * y) % P;
+        const b3 = (b2 * b2 * y) % P;
+        const b6 = (pow2(b3, _3n, P) * b3) % P;
+        const b9 = (pow2(b6, _3n, P) * b3) % P;
+        const b11 = (pow2(b9, _2n$3, P) * b2) % P;
+        const b22 = (pow2(b11, _11n, P) * b11) % P;
+        const b44 = (pow2(b22, _22n, P) * b22) % P;
+        const b88 = (pow2(b44, _44n, P) * b44) % P;
+        const b176 = (pow2(b88, _88n, P) * b88) % P;
+        const b220 = (pow2(b176, _44n, P) * b44) % P;
+        const b223 = (pow2(b220, _3n, P) * b3) % P;
+        const t1 = (pow2(b223, _23n, P) * b22) % P;
+        const t2 = (pow2(t1, _6n, P) * b2) % P;
+        const root = pow2(t2, _2n$3, P);
+        if (!Fp$1.eql(Fp$1.sqr(root), y))
+            throw new Error('Cannot find square root');
+        return root;
+    }
+    const Fp$1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
+    const secp256k1 = createCurve({
+        a: BigInt(0),
+        b: BigInt(7),
+        Fp: Fp$1,
+        n: secp256k1N,
+        Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),
+        Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),
+        h: BigInt(1),
+        lowS: true,
+        endo: {
+            beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
+            splitScalar: (k) => {
+                const n = secp256k1N;
+                const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');
+                const b1 = -_1n$4 * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');
+                const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');
+                const b2 = a1;
+                const POW_2_128 = BigInt('0x100000000000000000000000000000000');
+                const c1 = divNearest(b2 * k, n);
+                const c2 = divNearest(-b1 * k, n);
+                let k1 = mod(k - c1 * a1 - c2 * a2, n);
+                let k2 = mod(-c1 * b1 - c2 * b2, n);
+                const k1neg = k1 > POW_2_128;
+                const k2neg = k2 > POW_2_128;
+                if (k1neg)
+                    k1 = n - k1;
+                if (k2neg)
+                    k2 = n - k2;
+                if (k1 > POW_2_128 || k2 > POW_2_128) {
+                    throw new Error('splitScalar: Endomorphism failed, k=' + k);
+                }
+                return { k1neg, k1, k2neg, k2 };
+            },
+        },
+    }, sha256);
+    const _0n$4 = BigInt(0);
+    const fe = (x) => typeof x === 'bigint' && _0n$4 < x && x < secp256k1P;
+    const ge = (x) => typeof x === 'bigint' && _0n$4 < x && x < secp256k1N;
+    const TAGGED_HASH_PREFIXES = {};
+    function taggedHash(tag, ...messages) {
+        let tagP = TAGGED_HASH_PREFIXES[tag];
+        if (tagP === undefined) {
+            const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
+            tagP = concatBytes(tagH, tagH);
+            TAGGED_HASH_PREFIXES[tag] = tagP;
+        }
+        return sha256(concatBytes(tagP, ...messages));
+    }
+    const pointToBytes = (point) => point.toRawBytes(true).slice(1);
+    const numTo32b = (n) => numberToBytesBE(n, 32);
+    const modP = (x) => mod(x, secp256k1P);
+    const modN = (x) => mod(x, secp256k1N);
+    const Point = secp256k1.ProjectivePoint;
+    const GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
+    function schnorrGetExtPubKey(priv) {
+        let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
+        let p = Point.fromPrivateKey(d_);
+        const scalar = p.hasEvenY() ? d_ : modN(-d_);
+        return { scalar: scalar, bytes: pointToBytes(p) };
+    }
+    function lift_x(x) {
+        if (!fe(x))
+            throw new Error('bad x: need 0 < x < p');
+        const xx = modP(x * x);
+        const c = modP(xx * x + BigInt(7));
+        let y = sqrtMod(c);
+        if (y % _2n$3 !== _0n$4)
+            y = modP(-y);
+        const p = new Point(x, y, _1n$4);
+        p.assertValidity();
+        return p;
+    }
+    function challenge(...args) {
+        return modN(bytesToNumberBE(taggedHash('BIP0340/challenge', ...args)));
+    }
+    function schnorrGetPublicKey(privateKey) {
+        return schnorrGetExtPubKey(privateKey).bytes;
+    }
+    function schnorrSign(message, privateKey, auxRand = randomBytes(32)) {
+        const m = ensureBytes('message', message);
+        const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
+        const a = ensureBytes('auxRand', auxRand, 32);
+        const t = numTo32b(d ^ bytesToNumberBE(taggedHash('BIP0340/aux', a)));
+        const rand = taggedHash('BIP0340/nonce', t, px, m);
+        const k_ = modN(bytesToNumberBE(rand));
+        if (k_ === _0n$4)
+            throw new Error('sign failed: k is zero');
+        const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_);
+        const e = challenge(rx, px, m);
+        const sig = new Uint8Array(64);
+        sig.set(rx, 0);
+        sig.set(numTo32b(modN(k + e * d)), 32);
+        if (!schnorrVerify(sig, m, px))
+            throw new Error('sign: Invalid signature produced');
+        return sig;
+    }
+    function schnorrVerify(signature, message, publicKey) {
+        const sig = ensureBytes('signature', signature, 64);
+        const m = ensureBytes('message', message);
+        const pub = ensureBytes('publicKey', publicKey, 32);
+        try {
+            const P = lift_x(bytesToNumberBE(pub));
+            const r = bytesToNumberBE(sig.subarray(0, 32));
+            if (!fe(r))
+                return false;
+            const s = bytesToNumberBE(sig.subarray(32, 64));
+            if (!ge(s))
+                return false;
+            const e = challenge(numTo32b(r), pointToBytes(P), m);
+            const R = GmulAdd(P, s, modN(-e));
+            if (!R || !R.hasEvenY() || R.toAffine().x !== r)
+                return false;
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    (() => ({
+        getPublicKey: schnorrGetPublicKey,
+        sign: schnorrSign,
+        verify: schnorrVerify,
+        utils: {
+            randomPrivateKey: secp256k1.utils.randomPrivateKey,
+            lift_x,
+            pointToBytes,
+            numberToBytesBE,
+            bytesToNumberBE,
+            taggedHash,
+            mod,
+        },
+    }))();
+    const isoMap =  (() => isogenyMap(Fp$1, [
+        [
+            '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',
+            '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',
+            '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',
+            '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',
+        ],
+        [
+            '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',
+            '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+        ],
+        [
+            '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',
+            '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',
+            '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',
+            '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',
+        ],
+        [
+            '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',
+            '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',
+            '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',
+            '0x0000000000000000000000000000000000000000000000000000000000000001',
+        ],
+    ].map((i) => i.map((j) => BigInt(j)))))();
+    const mapSWU =  (() => mapToCurveSimpleSWU(Fp$1, {
+        A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),
+        B: BigInt('1771'),
+        Z: Fp$1.create(BigInt('-11')),
+    }))();
+    (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {
+        const { x, y } = mapSWU(Fp$1.create(scalars[0]));
+        return isoMap(x, y);
+    }, {
+        DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',
+        encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',
+        p: Fp$1.ORDER,
+        m: 1,
+        k: 128,
+        expand: 'xmd',
+        hash: sha256,
+    }))();
+
+    function secp256k1PairFromSeed(seed, onlyJs) {
+        if (seed.length !== 32) {
+            throw new Error('Expected valid 32-byte private key as a seed');
+        }
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            const full = secp256k1FromSeed(seed);
+            const publicKey = full.slice(32);
+            if (util.u8aEmpty(publicKey)) {
+                throw new Error('Invalid publicKey generated from WASM interface');
+            }
+            return {
+                publicKey,
+                secretKey: full.slice(0, 32)
+            };
+        }
+        return {
+            publicKey: secp256k1.getPublicKey(seed, true),
+            secretKey: seed
+        };
+    }
+
+    function createSeedDeriveFn(fromSeed, derive) {
+        return (keypair, { chainCode, isHard }) => {
+            if (!isHard) {
+                throw new Error('A soft key was found in the path and is not supported');
+            }
+            return fromSeed(derive(keypair.secretKey.subarray(0, 32), chainCode));
+        };
+    }
+
+    const keyHdkdEcdsa =  createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);
+
+    const HDKD = util.compactAddLength(util.stringToU8a('Ed25519HDKD'));
+    function ed25519DeriveHard(seed, chainCode) {
+        if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        return blake2AsU8a(util.u8aConcat(HDKD, seed, chainCode));
+    }
+
+    function randomAsU8a(length = 32) {
+        return browser.getRandomValues(new Uint8Array(length));
+    }
+    const randomAsHex =  createAsHex(randomAsU8a);
+
+    const BN_53 = new util.BN(0b11111111111111111111111111111111111111111111111111111);
+    function randomAsNumber() {
+        return util.hexToBn(randomAsHex(8)).and(BN_53).toNumber();
+    }
+
+    const [SHA512_Kh, SHA512_Kl] =  (() => u64.split([
+        '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+        '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+        '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+        '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+        '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+        '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+        '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+        '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+        '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+        '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+        '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+        '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+        '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+        '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+        '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+        '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+        '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+        '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+        '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+        '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+    ].map(n => BigInt(n))))();
+    const SHA512_W_H =  new Uint32Array(80);
+    const SHA512_W_L =  new Uint32Array(80);
+    class SHA512 extends SHA2 {
+        constructor() {
+            super(128, 64, 16, false);
+            this.Ah = 0x6a09e667 | 0;
+            this.Al = 0xf3bcc908 | 0;
+            this.Bh = 0xbb67ae85 | 0;
+            this.Bl = 0x84caa73b | 0;
+            this.Ch = 0x3c6ef372 | 0;
+            this.Cl = 0xfe94f82b | 0;
+            this.Dh = 0xa54ff53a | 0;
+            this.Dl = 0x5f1d36f1 | 0;
+            this.Eh = 0x510e527f | 0;
+            this.El = 0xade682d1 | 0;
+            this.Fh = 0x9b05688c | 0;
+            this.Fl = 0x2b3e6c1f | 0;
+            this.Gh = 0x1f83d9ab | 0;
+            this.Gl = 0xfb41bd6b | 0;
+            this.Hh = 0x5be0cd19 | 0;
+            this.Hl = 0x137e2179 | 0;
+        }
+        get() {
+            const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+        }
+        set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+            this.Ah = Ah | 0;
+            this.Al = Al | 0;
+            this.Bh = Bh | 0;
+            this.Bl = Bl | 0;
+            this.Ch = Ch | 0;
+            this.Cl = Cl | 0;
+            this.Dh = Dh | 0;
+            this.Dl = Dl | 0;
+            this.Eh = Eh | 0;
+            this.El = El | 0;
+            this.Fh = Fh | 0;
+            this.Fl = Fl | 0;
+            this.Gh = Gh | 0;
+            this.Gl = Gl | 0;
+            this.Hh = Hh | 0;
+            this.Hl = Hl | 0;
+        }
+        process(view, offset) {
+            for (let i = 0; i < 16; i++, offset += 4) {
+                SHA512_W_H[i] = view.getUint32(offset);
+                SHA512_W_L[i] = view.getUint32((offset += 4));
+            }
+            for (let i = 16; i < 80; i++) {
+                const W15h = SHA512_W_H[i - 15] | 0;
+                const W15l = SHA512_W_L[i - 15] | 0;
+                const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+                const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+                const W2h = SHA512_W_H[i - 2] | 0;
+                const W2l = SHA512_W_L[i - 2] | 0;
+                const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+                const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+                const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+                const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+                SHA512_W_H[i] = SUMh | 0;
+                SHA512_W_L[i] = SUMl | 0;
+            }
+            let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            for (let i = 0; i < 80; i++) {
+                const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+                const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+                const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+                const CHIl = (El & Fl) ^ (~El & Gl);
+                const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+                const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+                const T1l = T1ll | 0;
+                const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+                const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+                const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+                const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+                Hh = Gh | 0;
+                Hl = Gl | 0;
+                Gh = Fh | 0;
+                Gl = Fl | 0;
+                Fh = Eh | 0;
+                Fl = El | 0;
+                ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+                Dh = Ch | 0;
+                Dl = Cl | 0;
+                Ch = Bh | 0;
+                Cl = Bl | 0;
+                Bh = Ah | 0;
+                Bl = Al | 0;
+                const All = u64.add3L(T1l, sigma0l, MAJl);
+                Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+                Al = All | 0;
+            }
+            ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+            ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+            ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+            ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+            ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+            ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+            ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+            ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+            this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+        }
+        roundClean() {
+            SHA512_W_H.fill(0);
+            SHA512_W_L.fill(0);
+        }
+        destroy() {
+            this.buffer.fill(0);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+    class SHA512_224 extends SHA512 {
+        constructor() {
+            super();
+            this.Ah = 0x8c3d37c8 | 0;
+            this.Al = 0x19544da2 | 0;
+            this.Bh = 0x73e19966 | 0;
+            this.Bl = 0x89dcd4d6 | 0;
+            this.Ch = 0x1dfab7ae | 0;
+            this.Cl = 0x32ff9c82 | 0;
+            this.Dh = 0x679dd514 | 0;
+            this.Dl = 0x582f9fcf | 0;
+            this.Eh = 0x0f6d2b69 | 0;
+            this.El = 0x7bd44da8 | 0;
+            this.Fh = 0x77e36f73 | 0;
+            this.Fl = 0x04c48942 | 0;
+            this.Gh = 0x3f9d85a8 | 0;
+            this.Gl = 0x6a1d36c8 | 0;
+            this.Hh = 0x1112e6ad | 0;
+            this.Hl = 0x91d692a1 | 0;
+            this.outputLen = 28;
+        }
+    }
+    class SHA512_256 extends SHA512 {
+        constructor() {
+            super();
+            this.Ah = 0x22312194 | 0;
+            this.Al = 0xfc2bf72c | 0;
+            this.Bh = 0x9f555fa3 | 0;
+            this.Bl = 0xc84c64c2 | 0;
+            this.Ch = 0x2393b86b | 0;
+            this.Cl = 0x6f53b151 | 0;
+            this.Dh = 0x96387719 | 0;
+            this.Dl = 0x5940eabd | 0;
+            this.Eh = 0x96283ee2 | 0;
+            this.El = 0xa88effe3 | 0;
+            this.Fh = 0xbe5e1e25 | 0;
+            this.Fl = 0x53863992 | 0;
+            this.Gh = 0x2b0199fc | 0;
+            this.Gl = 0x2c85b8aa | 0;
+            this.Hh = 0x0eb72ddc | 0;
+            this.Hl = 0x81c52ca2 | 0;
+            this.outputLen = 32;
+        }
+    }
+    class SHA384 extends SHA512 {
+        constructor() {
+            super();
+            this.Ah = 0xcbbb9d5d | 0;
+            this.Al = 0xc1059ed8 | 0;
+            this.Bh = 0x629a292a | 0;
+            this.Bl = 0x367cd507 | 0;
+            this.Ch = 0x9159015a | 0;
+            this.Cl = 0x3070dd17 | 0;
+            this.Dh = 0x152fecd8 | 0;
+            this.Dl = 0xf70e5939 | 0;
+            this.Eh = 0x67332667 | 0;
+            this.El = 0xffc00b31 | 0;
+            this.Fh = 0x8eb44a87 | 0;
+            this.Fl = 0x68581511 | 0;
+            this.Gh = 0xdb0c2e0d | 0;
+            this.Gl = 0x64f98fa7 | 0;
+            this.Hh = 0x47b5481d | 0;
+            this.Hl = 0xbefa4fa4 | 0;
+            this.outputLen = 48;
+        }
+    }
+    const sha512 =  wrapConstructor(() => new SHA512());
+    wrapConstructor(() => new SHA512_224());
+    wrapConstructor(() => new SHA512_256());
+    wrapConstructor(() => new SHA384());
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$3 = BigInt(0), _1n$3 = BigInt(1), _2n$2 = BigInt(2), _8n = BigInt(8);
+    const VERIFY_DEFAULT = { zip215: true };
+    function validateOpts$1(curve) {
+        const opts = validateBasic(curve);
+        validateObject(curve, {
+            hash: 'function',
+            a: 'bigint',
+            d: 'bigint',
+            randomBytes: 'function',
+        }, {
+            adjustScalarBytes: 'function',
+            domain: 'function',
+            uvRatio: 'function',
+            mapToCurve: 'function',
+        });
+        return Object.freeze({ ...opts });
+    }
+    function twistedEdwards(curveDef) {
+        const CURVE = validateOpts$1(curveDef);
+        const { Fp, n: CURVE_ORDER, prehash: prehash, hash: cHash, randomBytes, nByteLength, h: cofactor, } = CURVE;
+        const MASK = _2n$2 << (BigInt(nByteLength * 8) - _1n$3);
+        const modP = Fp.create;
+        const uvRatio = CURVE.uvRatio ||
+            ((u, v) => {
+                try {
+                    return { isValid: true, value: Fp.sqrt(u * Fp.inv(v)) };
+                }
+                catch (e) {
+                    return { isValid: false, value: _0n$3 };
+                }
+            });
+        const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes);
+        const domain = CURVE.domain ||
+            ((data, ctx, phflag) => {
+                if (ctx.length || phflag)
+                    throw new Error('Contexts/pre-hash are not supported');
+                return data;
+            });
+        const inBig = (n) => typeof n === 'bigint' && _0n$3 < n;
+        const inRange = (n, max) => inBig(n) && inBig(max) && n < max;
+        const in0MaskRange = (n) => n === _0n$3 || inRange(n, MASK);
+        function assertInRange(n, max) {
+            if (inRange(n, max))
+                return n;
+            throw new Error(`Expected valid scalar < ${max}, got ${typeof n} ${n}`);
+        }
+        function assertGE0(n) {
+            return n === _0n$3 ? n : assertInRange(n, CURVE_ORDER);
+        }
+        const pointPrecomputes = new Map();
+        function isPoint(other) {
+            if (!(other instanceof Point))
+                throw new Error('ExtendedPoint expected');
+        }
+        class Point {
+            constructor(ex, ey, ez, et) {
+                this.ex = ex;
+                this.ey = ey;
+                this.ez = ez;
+                this.et = et;
+                if (!in0MaskRange(ex))
+                    throw new Error('x required');
+                if (!in0MaskRange(ey))
+                    throw new Error('y required');
+                if (!in0MaskRange(ez))
+                    throw new Error('z required');
+                if (!in0MaskRange(et))
+                    throw new Error('t required');
+            }
+            get x() {
+                return this.toAffine().x;
+            }
+            get y() {
+                return this.toAffine().y;
+            }
+            static fromAffine(p) {
+                if (p instanceof Point)
+                    throw new Error('extended point not allowed');
+                const { x, y } = p || {};
+                if (!in0MaskRange(x) || !in0MaskRange(y))
+                    throw new Error('invalid affine point');
+                return new Point(x, y, _1n$3, modP(x * y));
+            }
+            static normalizeZ(points) {
+                const toInv = Fp.invertBatch(points.map((p) => p.ez));
+                return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+            }
+            _setWindowSize(windowSize) {
+                this._WINDOW_SIZE = windowSize;
+                pointPrecomputes.delete(this);
+            }
+            assertValidity() {
+                const { a, d } = CURVE;
+                if (this.is0())
+                    throw new Error('bad point: ZERO');
+                const { ex: X, ey: Y, ez: Z, et: T } = this;
+                const X2 = modP(X * X);
+                const Y2 = modP(Y * Y);
+                const Z2 = modP(Z * Z);
+                const Z4 = modP(Z2 * Z2);
+                const aX2 = modP(X2 * a);
+                const left = modP(Z2 * modP(aX2 + Y2));
+                const right = modP(Z4 + modP(d * modP(X2 * Y2)));
+                if (left !== right)
+                    throw new Error('bad point: equation left != right (1)');
+                const XY = modP(X * Y);
+                const ZT = modP(Z * T);
+                if (XY !== ZT)
+                    throw new Error('bad point: equation left != right (2)');
+            }
+            equals(other) {
+                isPoint(other);
+                const { ex: X1, ey: Y1, ez: Z1 } = this;
+                const { ex: X2, ey: Y2, ez: Z2 } = other;
+                const X1Z2 = modP(X1 * Z2);
+                const X2Z1 = modP(X2 * Z1);
+                const Y1Z2 = modP(Y1 * Z2);
+                const Y2Z1 = modP(Y2 * Z1);
+                return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+            }
+            is0() {
+                return this.equals(Point.ZERO);
+            }
+            negate() {
+                return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));
+            }
+            double() {
+                const { a } = CURVE;
+                const { ex: X1, ey: Y1, ez: Z1 } = this;
+                const A = modP(X1 * X1);
+                const B = modP(Y1 * Y1);
+                const C = modP(_2n$2 * modP(Z1 * Z1));
+                const D = modP(a * A);
+                const x1y1 = X1 + Y1;
+                const E = modP(modP(x1y1 * x1y1) - A - B);
+                const G = D + B;
+                const F = G - C;
+                const H = D - B;
+                const X3 = modP(E * F);
+                const Y3 = modP(G * H);
+                const T3 = modP(E * H);
+                const Z3 = modP(F * G);
+                return new Point(X3, Y3, Z3, T3);
+            }
+            add(other) {
+                isPoint(other);
+                const { a, d } = CURVE;
+                const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+                const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
+                if (a === BigInt(-1)) {
+                    const A = modP((Y1 - X1) * (Y2 + X2));
+                    const B = modP((Y1 + X1) * (Y2 - X2));
+                    const F = modP(B - A);
+                    if (F === _0n$3)
+                        return this.double();
+                    const C = modP(Z1 * _2n$2 * T2);
+                    const D = modP(T1 * _2n$2 * Z2);
+                    const E = D + C;
+                    const G = B + A;
+                    const H = D - C;
+                    const X3 = modP(E * F);
+                    const Y3 = modP(G * H);
+                    const T3 = modP(E * H);
+                    const Z3 = modP(F * G);
+                    return new Point(X3, Y3, Z3, T3);
+                }
+                const A = modP(X1 * X2);
+                const B = modP(Y1 * Y2);
+                const C = modP(T1 * d * T2);
+                const D = modP(Z1 * Z2);
+                const E = modP((X1 + Y1) * (X2 + Y2) - A - B);
+                const F = D - C;
+                const G = D + C;
+                const H = modP(B - a * A);
+                const X3 = modP(E * F);
+                const Y3 = modP(G * H);
+                const T3 = modP(E * H);
+                const Z3 = modP(F * G);
+                return new Point(X3, Y3, Z3, T3);
+            }
+            subtract(other) {
+                return this.add(other.negate());
+            }
+            wNAF(n) {
+                return wnaf.wNAFCached(this, pointPrecomputes, n, Point.normalizeZ);
+            }
+            multiply(scalar) {
+                const { p, f } = this.wNAF(assertInRange(scalar, CURVE_ORDER));
+                return Point.normalizeZ([p, f])[0];
+            }
+            multiplyUnsafe(scalar) {
+                let n = assertGE0(scalar);
+                if (n === _0n$3)
+                    return I;
+                if (this.equals(I) || n === _1n$3)
+                    return this;
+                if (this.equals(G))
+                    return this.wNAF(n).p;
+                return wnaf.unsafeLadder(this, n);
+            }
+            isSmallOrder() {
+                return this.multiplyUnsafe(cofactor).is0();
+            }
+            isTorsionFree() {
+                return wnaf.unsafeLadder(this, CURVE_ORDER).is0();
+            }
+            toAffine(iz) {
+                const { ex: x, ey: y, ez: z } = this;
+                const is0 = this.is0();
+                if (iz == null)
+                    iz = is0 ? _8n : Fp.inv(z);
+                const ax = modP(x * iz);
+                const ay = modP(y * iz);
+                const zz = modP(z * iz);
+                if (is0)
+                    return { x: _0n$3, y: _1n$3 };
+                if (zz !== _1n$3)
+                    throw new Error('invZ was invalid');
+                return { x: ax, y: ay };
+            }
+            clearCofactor() {
+                const { h: cofactor } = CURVE;
+                if (cofactor === _1n$3)
+                    return this;
+                return this.multiplyUnsafe(cofactor);
+            }
+            static fromHex(hex, zip215 = false) {
+                const { d, a } = CURVE;
+                const len = Fp.BYTES;
+                hex = ensureBytes('pointHex', hex, len);
+                const normed = hex.slice();
+                const lastByte = hex[len - 1];
+                normed[len - 1] = lastByte & ~0x80;
+                const y = bytesToNumberLE(normed);
+                if (y === _0n$3) ;
+                else {
+                    if (zip215)
+                        assertInRange(y, MASK);
+                    else
+                        assertInRange(y, Fp.ORDER);
+                }
+                const y2 = modP(y * y);
+                const u = modP(y2 - _1n$3);
+                const v = modP(d * y2 - a);
+                let { isValid, value: x } = uvRatio(u, v);
+                if (!isValid)
+                    throw new Error('Point.fromHex: invalid y coordinate');
+                const isXOdd = (x & _1n$3) === _1n$3;
+                const isLastByteOdd = (lastByte & 0x80) !== 0;
+                if (!zip215 && x === _0n$3 && isLastByteOdd)
+                    throw new Error('Point.fromHex: x=0 and x_0=1');
+                if (isLastByteOdd !== isXOdd)
+                    x = modP(-x);
+                return Point.fromAffine({ x, y });
+            }
+            static fromPrivateKey(privKey) {
+                return getExtendedPublicKey(privKey).point;
+            }
+            toRawBytes() {
+                const { x, y } = this.toAffine();
+                const bytes = numberToBytesLE(y, Fp.BYTES);
+                bytes[bytes.length - 1] |= x & _1n$3 ? 0x80 : 0;
+                return bytes;
+            }
+            toHex() {
+                return bytesToHex(this.toRawBytes());
+            }
+        }
+        Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n$3, modP(CURVE.Gx * CURVE.Gy));
+        Point.ZERO = new Point(_0n$3, _1n$3, _1n$3, _0n$3);
+        const { BASE: G, ZERO: I } = Point;
+        const wnaf = wNAF(Point, nByteLength * 8);
+        function modN(a) {
+            return mod(a, CURVE_ORDER);
+        }
+        function modN_LE(hash) {
+            return modN(bytesToNumberLE(hash));
+        }
+        function getExtendedPublicKey(key) {
+            const len = nByteLength;
+            key = ensureBytes('private key', key, len);
+            const hashed = ensureBytes('hashed private key', cHash(key), 2 * len);
+            const head = adjustScalarBytes(hashed.slice(0, len));
+            const prefix = hashed.slice(len, 2 * len);
+            const scalar = modN_LE(head);
+            const point = G.multiply(scalar);
+            const pointBytes = point.toRawBytes();
+            return { head, prefix, scalar, point, pointBytes };
+        }
+        function getPublicKey(privKey) {
+            return getExtendedPublicKey(privKey).pointBytes;
+        }
+        function hashDomainToScalar(context = new Uint8Array(), ...msgs) {
+            const msg = concatBytes(...msgs);
+            return modN_LE(cHash(domain(msg, ensureBytes('context', context), !!prehash)));
+        }
+        function sign(msg, privKey, options = {}) {
+            msg = ensureBytes('message', msg);
+            if (prehash)
+                msg = prehash(msg);
+            const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
+            const r = hashDomainToScalar(options.context, prefix, msg);
+            const R = G.multiply(r).toRawBytes();
+            const k = hashDomainToScalar(options.context, R, pointBytes, msg);
+            const s = modN(r + k * scalar);
+            assertGE0(s);
+            const res = concatBytes(R, numberToBytesLE(s, Fp.BYTES));
+            return ensureBytes('result', res, nByteLength * 2);
+        }
+        const verifyOpts = VERIFY_DEFAULT;
+        function verify(sig, msg, publicKey, options = verifyOpts) {
+            const { context, zip215 } = options;
+            const len = Fp.BYTES;
+            sig = ensureBytes('signature', sig, 2 * len);
+            msg = ensureBytes('message', msg);
+            if (prehash)
+                msg = prehash(msg);
+            const s = bytesToNumberLE(sig.slice(len, 2 * len));
+            let A, R, SB;
+            try {
+                A = Point.fromHex(publicKey, zip215);
+                R = Point.fromHex(sig.slice(0, len), zip215);
+                SB = G.multiplyUnsafe(s);
+            }
+            catch (error) {
+                return false;
+            }
+            if (!zip215 && A.isSmallOrder())
+                return false;
+            const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);
+            const RkA = R.add(A.multiplyUnsafe(k));
+            return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);
+        }
+        G._setWindowSize(8);
+        const utils = {
+            getExtendedPublicKey,
+            randomPrivateKey: () => randomBytes(Fp.BYTES),
+            precompute(windowSize = 8, point = Point.BASE) {
+                point._setWindowSize(windowSize);
+                point.multiply(BigInt(3));
+                return point;
+            },
+        };
+        return {
+            CURVE,
+            getPublicKey,
+            sign,
+            verify,
+            ExtendedPoint: Point,
+            utils,
+        };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const _0n$2 = BigInt(0);
+    const _1n$2 = BigInt(1);
+    function validateOpts(curve) {
+        validateObject(curve, {
+            a: 'bigint',
+        }, {
+            montgomeryBits: 'isSafeInteger',
+            nByteLength: 'isSafeInteger',
+            adjustScalarBytes: 'function',
+            domain: 'function',
+            powPminus2: 'function',
+            Gu: 'bigint',
+        });
+        return Object.freeze({ ...curve });
+    }
+    function montgomery(curveDef) {
+        const CURVE = validateOpts(curveDef);
+        const { P } = CURVE;
+        const modP = (n) => mod(n, P);
+        const montgomeryBits = CURVE.montgomeryBits;
+        const montgomeryBytes = Math.ceil(montgomeryBits / 8);
+        const fieldLen = CURVE.nByteLength;
+        const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes);
+        const powPminus2 = CURVE.powPminus2 || ((x) => pow(x, P - BigInt(2), P));
+        function cswap(swap, x_2, x_3) {
+            const dummy = modP(swap * (x_2 - x_3));
+            x_2 = modP(x_2 - dummy);
+            x_3 = modP(x_3 + dummy);
+            return [x_2, x_3];
+        }
+        function assertFieldElement(n) {
+            if (typeof n === 'bigint' && _0n$2 <= n && n < P)
+                return n;
+            throw new Error('Expected valid scalar 0 < scalar < CURVE.P');
+        }
+        const a24 = (CURVE.a - BigInt(2)) / BigInt(4);
+        function montgomeryLadder(pointU, scalar) {
+            const u = assertFieldElement(pointU);
+            const k = assertFieldElement(scalar);
+            const x_1 = u;
+            let x_2 = _1n$2;
+            let z_2 = _0n$2;
+            let x_3 = u;
+            let z_3 = _1n$2;
+            let swap = _0n$2;
+            let sw;
+            for (let t = BigInt(montgomeryBits - 1); t >= _0n$2; t--) {
+                const k_t = (k >> t) & _1n$2;
+                swap ^= k_t;
+                sw = cswap(swap, x_2, x_3);
+                x_2 = sw[0];
+                x_3 = sw[1];
+                sw = cswap(swap, z_2, z_3);
+                z_2 = sw[0];
+                z_3 = sw[1];
+                swap = k_t;
+                const A = x_2 + z_2;
+                const AA = modP(A * A);
+                const B = x_2 - z_2;
+                const BB = modP(B * B);
+                const E = AA - BB;
+                const C = x_3 + z_3;
+                const D = x_3 - z_3;
+                const DA = modP(D * A);
+                const CB = modP(C * B);
+                const dacb = DA + CB;
+                const da_cb = DA - CB;
+                x_3 = modP(dacb * dacb);
+                z_3 = modP(x_1 * modP(da_cb * da_cb));
+                x_2 = modP(AA * BB);
+                z_2 = modP(E * (AA + modP(a24 * E)));
+            }
+            sw = cswap(swap, x_2, x_3);
+            x_2 = sw[0];
+            x_3 = sw[1];
+            sw = cswap(swap, z_2, z_3);
+            z_2 = sw[0];
+            z_3 = sw[1];
+            const z2 = powPminus2(z_2);
+            return modP(x_2 * z2);
+        }
+        function encodeUCoordinate(u) {
+            return numberToBytesLE(modP(u), montgomeryBytes);
+        }
+        function decodeUCoordinate(uEnc) {
+            const u = ensureBytes('u coordinate', uEnc, montgomeryBytes);
+            if (fieldLen === 32)
+                u[31] &= 127;
+            return bytesToNumberLE(u);
+        }
+        function decodeScalar(n) {
+            const bytes = ensureBytes('scalar', n);
+            const len = bytes.length;
+            if (len !== montgomeryBytes && len !== fieldLen)
+                throw new Error(`Expected ${montgomeryBytes} or ${fieldLen} bytes, got ${len}`);
+            return bytesToNumberLE(adjustScalarBytes(bytes));
+        }
+        function scalarMult(scalar, u) {
+            const pointU = decodeUCoordinate(u);
+            const _scalar = decodeScalar(scalar);
+            const pu = montgomeryLadder(pointU, _scalar);
+            if (pu === _0n$2)
+                throw new Error('Invalid private or public key received');
+            return encodeUCoordinate(pu);
+        }
+        const GuBytes = encodeUCoordinate(CURVE.Gu);
+        function scalarMultBase(scalar) {
+            return scalarMult(scalar, GuBytes);
+        }
+        return {
+            scalarMult,
+            scalarMultBase,
+            getSharedSecret: (privateKey, publicKey) => scalarMult(privateKey, publicKey),
+            getPublicKey: (privateKey) => scalarMultBase(privateKey),
+            utils: { randomPrivateKey: () => CURVE.randomBytes(CURVE.nByteLength) },
+            GuBytes: GuBytes,
+        };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    const ED25519_P = BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819949');
+    const ED25519_SQRT_M1 = BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
+    const _0n$1 = BigInt(0), _1n$1 = BigInt(1), _2n$1 = BigInt(2), _5n = BigInt(5);
+    const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+    function ed25519_pow_2_252_3(x) {
+        const P = ED25519_P;
+        const x2 = (x * x) % P;
+        const b2 = (x2 * x) % P;
+        const b4 = (pow2(b2, _2n$1, P) * b2) % P;
+        const b5 = (pow2(b4, _1n$1, P) * x) % P;
+        const b10 = (pow2(b5, _5n, P) * b5) % P;
+        const b20 = (pow2(b10, _10n, P) * b10) % P;
+        const b40 = (pow2(b20, _20n, P) * b20) % P;
+        const b80 = (pow2(b40, _40n, P) * b40) % P;
+        const b160 = (pow2(b80, _80n, P) * b80) % P;
+        const b240 = (pow2(b160, _80n, P) * b80) % P;
+        const b250 = (pow2(b240, _10n, P) * b10) % P;
+        const pow_p_5_8 = (pow2(b250, _2n$1, P) * x) % P;
+        return { pow_p_5_8, b2 };
+    }
+    function adjustScalarBytes(bytes) {
+        bytes[0] &= 248;
+        bytes[31] &= 127;
+        bytes[31] |= 64;
+        return bytes;
+    }
+    function uvRatio(u, v) {
+        const P = ED25519_P;
+        const v3 = mod(v * v * v, P);
+        const v7 = mod(v3 * v3 * v, P);
+        const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+        let x = mod(u * v3 * pow, P);
+        const vx2 = mod(v * x * x, P);
+        const root1 = x;
+        const root2 = mod(x * ED25519_SQRT_M1, P);
+        const useRoot1 = vx2 === u;
+        const useRoot2 = vx2 === mod(-u, P);
+        const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
+        if (useRoot1)
+            x = root1;
+        if (useRoot2 || noRoot)
+            x = root2;
+        if (isNegativeLE(x, P))
+            x = mod(-x, P);
+        return { isValid: useRoot1 || useRoot2, value: x };
+    }
+    const Fp = Field(ED25519_P, undefined, true);
+    const ed25519Defaults = {
+        a: BigInt(-1),
+        d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
+        Fp,
+        n: BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989'),
+        h: BigInt(8),
+        Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
+        Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
+        hash: sha512,
+        randomBytes,
+        adjustScalarBytes,
+        uvRatio,
+    };
+    const ed25519 =  twistedEdwards(ed25519Defaults);
+    function ed25519_domain(data, ctx, phflag) {
+        if (ctx.length > 255)
+            throw new Error('Context is too big');
+        return concatBytes$1(utf8ToBytes$1('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
+    }
+    twistedEdwards({
+        ...ed25519Defaults,
+        domain: ed25519_domain,
+    });
+    twistedEdwards({
+        ...ed25519Defaults,
+        domain: ed25519_domain,
+        prehash: sha512,
+    });
+    (() => montgomery({
+        P: ED25519_P,
+        a: BigInt(486662),
+        montgomeryBits: 255,
+        nByteLength: 32,
+        Gu: BigInt(9),
+        powPminus2: (x) => {
+            const P = ED25519_P;
+            const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
+            return mod(pow2(pow_p_5_8, BigInt(3), P) * b2, P);
+        },
+        adjustScalarBytes,
+        randomBytes,
+    }))();
+    const ELL2_C1 = (Fp.ORDER + BigInt(3)) / BigInt(8);
+    const ELL2_C2 = Fp.pow(_2n$1, ELL2_C1);
+    const ELL2_C3 = Fp.sqrt(Fp.neg(Fp.ONE));
+    const ELL2_C4 = (Fp.ORDER - BigInt(5)) / BigInt(8);
+    const ELL2_J = BigInt(486662);
+    function map_to_curve_elligator2_curve25519(u) {
+        let tv1 = Fp.sqr(u);
+        tv1 = Fp.mul(tv1, _2n$1);
+        let xd = Fp.add(tv1, Fp.ONE);
+        let x1n = Fp.neg(ELL2_J);
+        let tv2 = Fp.sqr(xd);
+        let gxd = Fp.mul(tv2, xd);
+        let gx1 = Fp.mul(tv1, ELL2_J);
+        gx1 = Fp.mul(gx1, x1n);
+        gx1 = Fp.add(gx1, tv2);
+        gx1 = Fp.mul(gx1, x1n);
+        let tv3 = Fp.sqr(gxd);
+        tv2 = Fp.sqr(tv3);
+        tv3 = Fp.mul(tv3, gxd);
+        tv3 = Fp.mul(tv3, gx1);
+        tv2 = Fp.mul(tv2, tv3);
+        let y11 = Fp.pow(tv2, ELL2_C4);
+        y11 = Fp.mul(y11, tv3);
+        let y12 = Fp.mul(y11, ELL2_C3);
+        tv2 = Fp.sqr(y11);
+        tv2 = Fp.mul(tv2, gxd);
+        let e1 = Fp.eql(tv2, gx1);
+        let y1 = Fp.cmov(y12, y11, e1);
+        let x2n = Fp.mul(x1n, tv1);
+        let y21 = Fp.mul(y11, u);
+        y21 = Fp.mul(y21, ELL2_C2);
+        let y22 = Fp.mul(y21, ELL2_C3);
+        let gx2 = Fp.mul(gx1, tv1);
+        tv2 = Fp.sqr(y21);
+        tv2 = Fp.mul(tv2, gxd);
+        let e2 = Fp.eql(tv2, gx2);
+        let y2 = Fp.cmov(y22, y21, e2);
+        tv2 = Fp.sqr(y1);
+        tv2 = Fp.mul(tv2, gxd);
+        let e3 = Fp.eql(tv2, gx1);
+        let xn = Fp.cmov(x2n, x1n, e3);
+        let y = Fp.cmov(y2, y1, e3);
+        let e4 = Fp.isOdd(y);
+        y = Fp.cmov(y, Fp.neg(y), e3 !== e4);
+        return { xMn: xn, xMd: xd, yMn: y, yMd: _1n$1 };
+    }
+    const ELL2_C1_EDWARDS = FpSqrtEven(Fp, Fp.neg(BigInt(486664)));
+    function map_to_curve_elligator2_edwards25519(u) {
+        const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u);
+        let xn = Fp.mul(xMn, yMd);
+        xn = Fp.mul(xn, ELL2_C1_EDWARDS);
+        let xd = Fp.mul(xMd, yMn);
+        let yn = Fp.sub(xMn, xMd);
+        let yd = Fp.add(xMn, xMd);
+        let tv1 = Fp.mul(xd, yd);
+        let e = Fp.eql(tv1, Fp.ZERO);
+        xn = Fp.cmov(xn, Fp.ZERO, e);
+        xd = Fp.cmov(xd, Fp.ONE, e);
+        yn = Fp.cmov(yn, Fp.ONE, e);
+        yd = Fp.cmov(yd, Fp.ONE, e);
+        const inv = Fp.invertBatch([xd, yd]);
+        return { x: Fp.mul(xn, inv[0]), y: Fp.mul(yn, inv[1]) };
+    }
+    (() => createHasher(ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {
+        DST: 'edwards25519_XMD:SHA-512_ELL2_RO_',
+        encodeDST: 'edwards25519_XMD:SHA-512_ELL2_NU_',
+        p: Fp.ORDER,
+        m: 1,
+        k: 128,
+        expand: 'xmd',
+        hash: sha512,
+    }))();
+    function assertRstPoint(other) {
+        if (!(other instanceof RistPoint))
+            throw new Error('RistrettoPoint expected');
+    }
+    const SQRT_M1 = ED25519_SQRT_M1;
+    const SQRT_AD_MINUS_ONE = BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');
+    const INVSQRT_A_MINUS_D = BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');
+    const ONE_MINUS_D_SQ = BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');
+    const D_MINUS_ONE_SQ = BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');
+    const invertSqrt = (number) => uvRatio(_1n$1, number);
+    const MAX_255B = BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+    const bytes255ToNumberLE = (bytes) => ed25519.CURVE.Fp.create(bytesToNumberLE(bytes) & MAX_255B);
+    function calcElligatorRistrettoMap(r0) {
+        const { d } = ed25519.CURVE;
+        const P = ed25519.CURVE.Fp.ORDER;
+        const mod = ed25519.CURVE.Fp.create;
+        const r = mod(SQRT_M1 * r0 * r0);
+        const Ns = mod((r + _1n$1) * ONE_MINUS_D_SQ);
+        let c = BigInt(-1);
+        const D = mod((c - d * r) * mod(r + d));
+        let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
+        let s_ = mod(s * r0);
+        if (!isNegativeLE(s_, P))
+            s_ = mod(-s_);
+        if (!Ns_D_is_sq)
+            s = s_;
+        if (!Ns_D_is_sq)
+            c = r;
+        const Nt = mod(c * (r - _1n$1) * D_MINUS_ONE_SQ - D);
+        const s2 = s * s;
+        const W0 = mod((s + s) * D);
+        const W1 = mod(Nt * SQRT_AD_MINUS_ONE);
+        const W2 = mod(_1n$1 - s2);
+        const W3 = mod(_1n$1 + s2);
+        return new ed25519.ExtendedPoint(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
+    }
+    class RistPoint {
+        constructor(ep) {
+            this.ep = ep;
+        }
+        static fromAffine(ap) {
+            return new RistPoint(ed25519.ExtendedPoint.fromAffine(ap));
+        }
+        static hashToCurve(hex) {
+            hex = ensureBytes('ristrettoHash', hex, 64);
+            const r1 = bytes255ToNumberLE(hex.slice(0, 32));
+            const R1 = calcElligatorRistrettoMap(r1);
+            const r2 = bytes255ToNumberLE(hex.slice(32, 64));
+            const R2 = calcElligatorRistrettoMap(r2);
+            return new RistPoint(R1.add(R2));
+        }
+        static fromHex(hex) {
+            hex = ensureBytes('ristrettoHex', hex, 32);
+            const { a, d } = ed25519.CURVE;
+            const P = ed25519.CURVE.Fp.ORDER;
+            const mod = ed25519.CURVE.Fp.create;
+            const emsg = 'RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint';
+            const s = bytes255ToNumberLE(hex);
+            if (!equalBytes(numberToBytesLE(s, 32), hex) || isNegativeLE(s, P))
+                throw new Error(emsg);
+            const s2 = mod(s * s);
+            const u1 = mod(_1n$1 + a * s2);
+            const u2 = mod(_1n$1 - a * s2);
+            const u1_2 = mod(u1 * u1);
+            const u2_2 = mod(u2 * u2);
+            const v = mod(a * d * u1_2 - u2_2);
+            const { isValid, value: I } = invertSqrt(mod(v * u2_2));
+            const Dx = mod(I * u2);
+            const Dy = mod(I * Dx * v);
+            let x = mod((s + s) * Dx);
+            if (isNegativeLE(x, P))
+                x = mod(-x);
+            const y = mod(u1 * Dy);
+            const t = mod(x * y);
+            if (!isValid || isNegativeLE(t, P) || y === _0n$1)
+                throw new Error(emsg);
+            return new RistPoint(new ed25519.ExtendedPoint(x, y, _1n$1, t));
+        }
+        toRawBytes() {
+            let { ex: x, ey: y, ez: z, et: t } = this.ep;
+            const P = ed25519.CURVE.Fp.ORDER;
+            const mod = ed25519.CURVE.Fp.create;
+            const u1 = mod(mod(z + y) * mod(z - y));
+            const u2 = mod(x * y);
+            const u2sq = mod(u2 * u2);
+            const { value: invsqrt } = invertSqrt(mod(u1 * u2sq));
+            const D1 = mod(invsqrt * u1);
+            const D2 = mod(invsqrt * u2);
+            const zInv = mod(D1 * D2 * t);
+            let D;
+            if (isNegativeLE(t * zInv, P)) {
+                let _x = mod(y * SQRT_M1);
+                let _y = mod(x * SQRT_M1);
+                x = _x;
+                y = _y;
+                D = mod(D1 * INVSQRT_A_MINUS_D);
+            }
+            else {
+                D = D2;
+            }
+            if (isNegativeLE(x * zInv, P))
+                y = mod(-y);
+            let s = mod((z - y) * D);
+            if (isNegativeLE(s, P))
+                s = mod(-s);
+            return numberToBytesLE(s, 32);
+        }
+        toHex() {
+            return bytesToHex(this.toRawBytes());
+        }
+        toString() {
+            return this.toHex();
+        }
+        equals(other) {
+            assertRstPoint(other);
+            const { ex: X1, ey: Y1 } = this.ep;
+            const { ex: X2, ey: Y2 } = other.ep;
+            const mod = ed25519.CURVE.Fp.create;
+            const one = mod(X1 * Y2) === mod(Y1 * X2);
+            const two = mod(Y1 * Y2) === mod(X1 * X2);
+            return one || two;
+        }
+        add(other) {
+            assertRstPoint(other);
+            return new RistPoint(this.ep.add(other.ep));
+        }
+        subtract(other) {
+            assertRstPoint(other);
+            return new RistPoint(this.ep.subtract(other.ep));
+        }
+        multiply(scalar) {
+            return new RistPoint(this.ep.multiply(scalar));
+        }
+        multiplyUnsafe(scalar) {
+            return new RistPoint(this.ep.multiplyUnsafe(scalar));
+        }
+        double() {
+            return new RistPoint(this.ep.double());
+        }
+        negate() {
+            return new RistPoint(this.ep.negate());
+        }
+    }
+    (() => {
+        if (!RistPoint.BASE)
+            RistPoint.BASE = new RistPoint(ed25519.ExtendedPoint.BASE);
+        if (!RistPoint.ZERO)
+            RistPoint.ZERO = new RistPoint(ed25519.ExtendedPoint.ZERO);
+        return RistPoint;
+    })();
+
+    function ed25519PairFromSeed(seed, onlyJs) {
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            const full = ed25519KeypairFromSeed(seed);
+            return {
+                publicKey: full.slice(32),
+                secretKey: full.slice(0, 64)
+            };
+        }
+        const publicKey = ed25519.getPublicKey(seed);
+        return {
+            publicKey,
+            secretKey: util.u8aConcatStrict([seed, publicKey])
+        };
+    }
+
+    function ed25519PairFromRandom() {
+        return ed25519PairFromSeed(randomAsU8a());
+    }
+
+    function ed25519PairFromSecret(secretKey) {
+        if (secretKey.length !== 64) {
+            throw new Error('Invalid secretKey provided');
+        }
+        return {
+            publicKey: secretKey.slice(32),
+            secretKey
+        };
+    }
+
+    function ed25519PairFromString(value) {
+        return ed25519PairFromSeed(blake2AsU8a(util.stringToU8a(value)));
+    }
+
+    function ed25519Sign(message, { publicKey, secretKey }, onlyJs) {
+        if (!secretKey) {
+            throw new Error('Expected a valid secretKey');
+        }
+        else if (!publicKey) {
+            throw new Error('Expected a valid publicKey');
+        }
+        const messageU8a = util.u8aToU8a(message);
+        const privateU8a = secretKey.subarray(0, 32);
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? ed25519Sign$1(publicKey, privateU8a, messageU8a)
+            : ed25519.sign(messageU8a, privateU8a);
+    }
+
+    function ed25519Verify(message, signature, publicKey, onlyJs) {
+        const messageU8a = util.u8aToU8a(message);
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        const signatureU8a = util.u8aToU8a(signature);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+        }
+        else if (signatureU8a.length !== 64) {
+            throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+        }
+        try {
+            return !util.hasBigInt || (!onlyJs && isReady())
+                ? ed25519Verify$1(signatureU8a, messageU8a, publicKeyU8a)
+                : ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+        }
+        catch {
+            return false;
+        }
+    }
+
+    const keyHdkdEd25519 =  createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);
+
+    const SEC_LEN = 64;
+    const PUB_LEN = 32;
+    const TOT_LEN = SEC_LEN + PUB_LEN;
+    function sr25519PairFromU8a(full) {
+        const fullU8a = util.u8aToU8a(full);
+        if (fullU8a.length !== TOT_LEN) {
+            throw new Error(`Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
+        }
+        return {
+            publicKey: fullU8a.slice(SEC_LEN, TOT_LEN),
+            secretKey: fullU8a.slice(0, SEC_LEN)
+        };
+    }
+
+    function sr25519KeypairToU8a({ publicKey, secretKey }) {
+        return util.u8aConcat(secretKey, publicKey).slice();
+    }
+
+    function createDeriveFn(derive) {
+        return (keypair, chainCode) => {
+            if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+                throw new Error('Invalid chainCode passed to derive');
+            }
+            return sr25519PairFromU8a(derive(sr25519KeypairToU8a(keypair), chainCode));
+        };
+    }
+
+    const sr25519DeriveHard =  createDeriveFn(sr25519DeriveKeypairHard);
+
+    const sr25519DeriveSoft =  createDeriveFn(sr25519DeriveKeypairSoft);
+
+    function keyHdkdSr25519(keypair, { chainCode, isSoft }) {
+        return isSoft
+            ? sr25519DeriveSoft(keypair, chainCode)
+            : sr25519DeriveHard(keypair, chainCode);
+    }
+
+    const generators = {
+        ecdsa: keyHdkdEcdsa,
+        ed25519: keyHdkdEd25519,
+        ethereum: keyHdkdEcdsa,
+        sr25519: keyHdkdSr25519
+    };
+    function keyFromPath(pair, path, type) {
+        const keyHdkd = generators[type];
+        let result = pair;
+        for (const junction of path) {
+            result = keyHdkd(result, junction);
+        }
+        return result;
+    }
+
+    function sr25519Agreement(secretKey, publicKey) {
+        const secretKeyU8a = util.u8aToU8a(secretKey);
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+        }
+        else if (secretKeyU8a.length !== 64) {
+            throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+        }
+        return sr25519Agree(publicKeyU8a, secretKeyU8a);
+    }
+
+    function sr25519DerivePublic(publicKey, chainCode) {
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        if (!util.isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        else if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+        }
+        return sr25519DerivePublicSoft(publicKeyU8a, chainCode);
+    }
+
+    function sr25519PairFromSeed(seed) {
+        const seedU8a = util.u8aToU8a(seed);
+        if (seedU8a.length !== 32) {
+            throw new Error(`Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+        }
+        return sr25519PairFromU8a(sr25519KeypairFromSeed(seedU8a));
+    }
+
+    function sr25519Sign(message, { publicKey, secretKey }) {
+        if (publicKey?.length !== 32) {
+            throw new Error('Expected a valid publicKey, 32-bytes');
+        }
+        else if (secretKey?.length !== 64) {
+            throw new Error('Expected a valid secretKey, 64-bytes');
+        }
+        return sr25519Sign$1(publicKey, secretKey, util.u8aToU8a(message));
+    }
+
+    function sr25519Verify(message, signature, publicKey) {
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        const signatureU8a = util.u8aToU8a(signature);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+        }
+        else if (signatureU8a.length !== 64) {
+            throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+        }
+        return sr25519Verify$1(signatureU8a, util.u8aToU8a(message), publicKeyU8a);
+    }
+
+    const EMPTY_U8A$1 = new Uint8Array();
+    function sr25519VrfSign(message, { secretKey }, context = EMPTY_U8A$1, extra = EMPTY_U8A$1) {
+        if (secretKey?.length !== 64) {
+            throw new Error('Invalid secretKey, expected 64-bytes');
+        }
+        return vrfSign(secretKey, util.u8aToU8a(context), util.u8aToU8a(message), util.u8aToU8a(extra));
+    }
+
+    const EMPTY_U8A = new Uint8Array();
+    function sr25519VrfVerify(message, signOutput, publicKey, context = EMPTY_U8A, extra = EMPTY_U8A) {
+        const publicKeyU8a = util.u8aToU8a(publicKey);
+        const proofU8a = util.u8aToU8a(signOutput);
+        if (publicKeyU8a.length !== 32) {
+            throw new Error('Invalid publicKey, expected 32-bytes');
+        }
+        else if (proofU8a.length !== 96) {
+            throw new Error('Invalid vrfSign output, expected 96 bytes');
+        }
+        return vrfVerify(publicKeyU8a, util.u8aToU8a(context), util.u8aToU8a(message), util.u8aToU8a(extra), proofU8a);
+    }
+
+    function encodeAddress(key, ss58Format = defaults.prefix) {
+        const u8a = decodeAddress(key);
+        if ((ss58Format < 0) || (ss58Format > 16383 && !ss58Exceptions.includes(ss58Format)) || [46, 47].includes(ss58Format)) {
+            throw new Error('Out of range ss58Format specified');
+        }
+        else if (!defaults.allowedDecodedLengths.includes(u8a.length)) {
+            throw new Error(`Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
+        }
+        const input = util.u8aConcat(ss58Format < 64
+            ? [ss58Format]
+            : [
+                ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
+                (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
+            ], u8a);
+        return base58Encode(util.u8aConcat(input, sshash(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1)));
+    }
+    const ss58Exceptions = [29972];
+
+    function filterHard({ isHard }) {
+        return isHard;
+    }
+    function deriveAddress(who, suri, ss58Format) {
+        const { path } = keyExtractPath(suri);
+        if (!path.length || path.every(filterHard)) {
+            throw new Error('Expected suri to contain a combination of non-hard paths');
+        }
+        let publicKey = decodeAddress(who);
+        for (const { chainCode } of path) {
+            publicKey = sr25519DerivePublic(publicKey, chainCode);
+        }
+        return encodeAddress(publicKey, ss58Format);
+    }
+
+    const PREFIX$1 = util.stringToU8a('modlpy/utilisuba');
+    function createKeyDerived(who, index) {
+        return blake2AsU8a(util.u8aConcat(PREFIX$1, decodeAddress(who), util.bnToU8a(index, BN_LE_16_OPTS)));
+    }
+
+    function encodeDerivedAddress(who, index, ss58Format) {
+        return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
+    }
+
+    function addressToU8a(who) {
+        return decodeAddress(who);
+    }
+
+    const PREFIX = util.stringToU8a('modlpy/utilisuba');
+    function createKeyMulti(who, threshold) {
+        return blake2AsU8a(util.u8aConcat(PREFIX, util.compactToU8a(who.length), ...util.u8aSorted(who.map(addressToU8a)), util.bnToU8a(threshold, BN_LE_16_OPTS)));
+    }
+
+    function encodeMultiAddress(who, threshold, ss58Format) {
+        return encodeAddress(createKeyMulti(who, threshold), ss58Format);
+    }
+
+    function addressEq(a, b) {
+        return util.u8aEq(decodeAddress(a), decodeAddress(b));
+    }
+
+    const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+    const _0n =  BigInt(0);
+    const _1n =  BigInt(1);
+    const _2n =  BigInt(2);
+    const _7n$1 =  BigInt(7);
+    const _256n$1 =  BigInt(256);
+    const _0x71n =  BigInt(0x71);
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+        [x, y] = [y, (2 * x + 3 * y) % 5];
+        SHA3_PI.push(2 * (5 * y + x));
+        SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+        let t = _0n;
+        for (let j = 0; j < 7; j++) {
+            R = ((R << _1n) ^ ((R >> _7n$1) * _0x71n)) % _256n$1;
+            if (R & _2n)
+                t ^= _1n << ((_1n <<  BigInt(j)) - _1n);
+        }
+        _SHA3_IOTA.push(t);
+    }
+    const [SHA3_IOTA_H, SHA3_IOTA_L] =  split(_SHA3_IOTA, true);
+    const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
+    const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
+    function keccakP(s, rounds = 24) {
+        const B = new Uint32Array(5 * 2);
+        for (let round = 24 - rounds; round < 24; round++) {
+            for (let x = 0; x < 10; x++)
+                B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+            for (let x = 0; x < 10; x += 2) {
+                const idx1 = (x + 8) % 10;
+                const idx0 = (x + 2) % 10;
+                const B0 = B[idx0];
+                const B1 = B[idx0 + 1];
+                const Th = rotlH(B0, B1, 1) ^ B[idx1];
+                const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+                for (let y = 0; y < 50; y += 10) {
+                    s[x + y] ^= Th;
+                    s[x + y + 1] ^= Tl;
+                }
+            }
+            let curH = s[2];
+            let curL = s[3];
+            for (let t = 0; t < 24; t++) {
+                const shift = SHA3_ROTL[t];
+                const Th = rotlH(curH, curL, shift);
+                const Tl = rotlL(curH, curL, shift);
+                const PI = SHA3_PI[t];
+                curH = s[PI];
+                curL = s[PI + 1];
+                s[PI] = Th;
+                s[PI + 1] = Tl;
+            }
+            for (let y = 0; y < 50; y += 10) {
+                for (let x = 0; x < 10; x++)
+                    B[x] = s[y + x];
+                for (let x = 0; x < 10; x++)
+                    s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+            }
+            s[0] ^= SHA3_IOTA_H[round];
+            s[1] ^= SHA3_IOTA_L[round];
+        }
+        B.fill(0);
+    }
+    class Keccak extends Hash {
+        constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+            super();
+            this.blockLen = blockLen;
+            this.suffix = suffix;
+            this.outputLen = outputLen;
+            this.enableXOF = enableXOF;
+            this.rounds = rounds;
+            this.pos = 0;
+            this.posOut = 0;
+            this.finished = false;
+            this.destroyed = false;
+            number(outputLen);
+            if (0 >= this.blockLen || this.blockLen >= 200)
+                throw new Error('Sha3 supports only keccak-f1600 function');
+            this.state = new Uint8Array(200);
+            this.state32 = u32(this.state);
+        }
+        keccak() {
+            keccakP(this.state32, this.rounds);
+            this.posOut = 0;
+            this.pos = 0;
+        }
+        update(data) {
+            exists(this);
+            const { blockLen, state } = this;
+            data = toBytes(data);
+            const len = data.length;
+            for (let pos = 0; pos < len;) {
+                const take = Math.min(blockLen - this.pos, len - pos);
+                for (let i = 0; i < take; i++)
+                    state[this.pos++] ^= data[pos++];
+                if (this.pos === blockLen)
+                    this.keccak();
+            }
+            return this;
+        }
+        finish() {
+            if (this.finished)
+                return;
+            this.finished = true;
+            const { state, suffix, pos, blockLen } = this;
+            state[pos] ^= suffix;
+            if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+                this.keccak();
+            state[blockLen - 1] ^= 0x80;
+            this.keccak();
+        }
+        writeInto(out) {
+            exists(this, false);
+            bytes(out);
+            this.finish();
+            const bufferOut = this.state;
+            const { blockLen } = this;
+            for (let pos = 0, len = out.length; pos < len;) {
+                if (this.posOut >= blockLen)
+                    this.keccak();
+                const take = Math.min(blockLen - this.posOut, len - pos);
+                out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+                this.posOut += take;
+                pos += take;
+            }
+            return out;
+        }
+        xofInto(out) {
+            if (!this.enableXOF)
+                throw new Error('XOF is not possible for this instance');
+            return this.writeInto(out);
+        }
+        xof(bytes) {
+            number(bytes);
+            return this.xofInto(new Uint8Array(bytes));
+        }
+        digestInto(out) {
+            output(out, this);
+            if (this.finished)
+                throw new Error('digest() was already called');
+            this.writeInto(out);
+            this.destroy();
+            return out;
+        }
+        digest() {
+            return this.digestInto(new Uint8Array(this.outputLen));
+        }
+        destroy() {
+            this.destroyed = true;
+            this.state.fill(0);
+        }
+        _cloneInto(to) {
+            const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+            to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+            to.state32.set(this.state32);
+            to.pos = this.pos;
+            to.posOut = this.posOut;
+            to.finished = this.finished;
+            to.rounds = rounds;
+            to.suffix = suffix;
+            to.outputLen = outputLen;
+            to.enableXOF = enableXOF;
+            to.destroyed = this.destroyed;
+            return to;
+        }
+    }
+    const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+    gen(0x06, 144, 224 / 8);
+    gen(0x06, 136, 256 / 8);
+    gen(0x06, 104, 384 / 8);
+    gen(0x06, 72, 512 / 8);
+    gen(0x01, 144, 224 / 8);
+    const keccak_256 =  gen(0x01, 136, 256 / 8);
+    gen(0x01, 104, 384 / 8);
+    const keccak_512 =  gen(0x01, 72, 512 / 8);
+    const genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));
+    genShake(0x1f, 168, 128 / 8);
+    genShake(0x1f, 136, 256 / 8);
+
+    const keccakAsU8a =  createDualHasher({ 256: keccak256, 512: keccak512 }, { 256: keccak_256, 512: keccak_512 });
+    const keccak256AsU8a =  createBitHasher(256, keccakAsU8a);
+    const keccak512AsU8a =  createBitHasher(512, keccakAsU8a);
+    const keccakAsHex =  createAsHex(keccakAsU8a);
+
+    function hasher(hashType, data, onlyJs) {
+        return hashType === 'keccak'
+            ? keccakAsU8a(data, undefined, onlyJs)
+            : blake2AsU8a(data, undefined, undefined, onlyJs);
+    }
+
+    function evmToAddress(evmAddress, ss58Format, hashType = 'blake2') {
+        const message = util.u8aConcat('evm:', evmAddress);
+        if (message.length !== 24) {
+            throw new Error(`Converting ${evmAddress}: Invalid evm address length`);
+        }
+        return encodeAddress(hasher(hashType, message), ss58Format);
+    }
+
+    function validateAddress(encoded, ignoreChecksum, ss58Format) {
+        return !!decodeAddress(encoded, ignoreChecksum, ss58Format);
+    }
+
+    function isAddress(address, ignoreChecksum, ss58Format) {
+        try {
+            return validateAddress(address, ignoreChecksum, ss58Format);
+        }
+        catch {
+            return false;
+        }
+    }
+
+    function sortAddresses(addresses, ss58Format) {
+        const u8aToAddress = (u8a) => encodeAddress(u8a, ss58Format);
+        return util.u8aSorted(addresses.map(addressToU8a)).map(u8aToAddress);
+    }
+
+    const l = util.logger('setSS58Format');
+    function setSS58Format(prefix) {
+        l.warn('Global setting of the ss58Format is deprecated and not recommended. Set format on the keyring (if used) or as part of the address encode function');
+        defaults.prefix = prefix;
+    }
+
+    const chars = 'abcdefghijklmnopqrstuvwxyz234567';
+    const config$1 = {
+        chars,
+        coder: utils.chain(
+        utils.radix2(5), utils.alphabet(chars), {
+            decode: (input) => input.split(''),
+            encode: (input) => input.join('')
+        }),
+        ipfs: 'b',
+        type: 'base32'
+    };
+    const base32Validate =  createValidate(config$1);
+    const isBase32 =  createIs(base32Validate);
+    const base32Decode =  createDecode(config$1, base32Validate);
+    const base32Encode =  createEncode(config$1);
+
+    const config = {
+        chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+        coder: base64,
+        type: 'base64',
+        withPadding: true
+    };
+    const base64Validate =  createValidate(config);
+    const isBase64 =  createIs(base64Validate);
+    const base64Decode =  createDecode(config, base64Validate);
+    const base64Encode =  createEncode(config);
+
+    function base64Pad(value) {
+        return value.padEnd(value.length + (value.length % 4), '=');
+    }
+
+    function base64Trim(value) {
+        while (value.length && value.endsWith('=')) {
+            value = value.slice(0, -1);
+        }
+        return value;
+    }
+
+    function secp256k1Compress(publicKey, onlyJs) {
+        if (![33, 65].includes(publicKey.length)) {
+            throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+        }
+        if (publicKey.length === 33) {
+            return publicKey;
+        }
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? secp256k1Compress$1(publicKey)
+            : secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(true);
+    }
+
+    function secp256k1Expand(publicKey, onlyJs) {
+        if (![33, 65].includes(publicKey.length)) {
+            throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+        }
+        if (publicKey.length === 65) {
+            return publicKey.subarray(1);
+        }
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            return secp256k1Expand$1(publicKey).subarray(1);
+        }
+        const { px, py } = secp256k1.ProjectivePoint.fromHex(publicKey);
+        return util.u8aConcat(util.bnToU8a(px, BN_BE_256_OPTS), util.bnToU8a(py, BN_BE_256_OPTS));
+    }
+
+    function secp256k1Recover(msgHash, signature, recovery, hashType = 'blake2', onlyJs) {
+        const sig = util.u8aToU8a(signature).subarray(0, 64);
+        const msg = util.u8aToU8a(msgHash);
+        const publicKey = !util.hasBigInt || (!onlyJs && isReady())
+            ? secp256k1Recover$1(msg, sig, recovery)
+            : secp256k1.Signature
+                .fromCompact(sig)
+                .addRecoveryBit(recovery)
+                .recoverPublicKey(msg)
+                .toRawBytes();
+        if (!publicKey) {
+            throw new Error('Unable to recover publicKey from signature');
+        }
+        return hashType === 'keccak'
+            ? secp256k1Expand(publicKey, onlyJs)
+            : secp256k1Compress(publicKey, onlyJs);
+    }
+
+    function secp256k1Sign(message, { secretKey }, hashType = 'blake2', onlyJs) {
+        if (secretKey?.length !== 32) {
+            throw new Error('Expected valid secp256k1 secretKey, 32-bytes');
+        }
+        const data = hasher(hashType, message, onlyJs);
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            return secp256k1Sign$1(data, secretKey);
+        }
+        const signature = secp256k1.sign(data, secretKey, { lowS: true });
+        return util.u8aConcat(util.bnToU8a(signature.r, BN_BE_256_OPTS), util.bnToU8a(signature.s, BN_BE_256_OPTS), new Uint8Array([signature.recovery || 0]));
+    }
+
+    const N = 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141'.replace(/ /g, '');
+    const N_BI = BigInt$1(`0x${N}`);
+    const N_BN = new util.BN(N, 'hex');
+    function addBi(seckey, tweak) {
+        let res = util.u8aToBigInt(tweak, BN_BE_OPTS);
+        if (res >= N_BI) {
+            throw new Error('Tweak parameter is out of range');
+        }
+        res += util.u8aToBigInt(seckey, BN_BE_OPTS);
+        if (res >= N_BI) {
+            res -= N_BI;
+        }
+        if (res === util._0n) {
+            throw new Error('Invalid resulting private key');
+        }
+        return util.nToU8a(res, BN_BE_256_OPTS);
+    }
+    function addBn(seckey, tweak) {
+        const res = new util.BN(tweak);
+        if (res.cmp(N_BN) >= 0) {
+            throw new Error('Tweak parameter is out of range');
+        }
+        res.iadd(new util.BN(seckey));
+        if (res.cmp(N_BN) >= 0) {
+            res.isub(N_BN);
+        }
+        if (res.isZero()) {
+            throw new Error('Invalid resulting private key');
+        }
+        return util.bnToU8a(res, BN_BE_256_OPTS);
+    }
+    function secp256k1PrivateKeyTweakAdd(seckey, tweak, onlyBn) {
+        if (!util.isU8a(seckey) || seckey.length !== 32) {
+            throw new Error('Expected seckey to be an Uint8Array with length 32');
+        }
+        else if (!util.isU8a(tweak) || tweak.length !== 32) {
+            throw new Error('Expected tweak to be an Uint8Array with length 32');
+        }
+        return !util.hasBigInt || onlyBn
+            ? addBn(seckey, tweak)
+            : addBi(seckey, tweak);
+    }
+
+    function secp256k1Verify(msgHash, signature, address, hashType = 'blake2', onlyJs) {
+        const sig = util.u8aToU8a(signature);
+        if (sig.length !== 65) {
+            throw new Error(`Expected signature with 65 bytes, ${sig.length} found instead`);
+        }
+        const publicKey = secp256k1Recover(hasher(hashType, msgHash), sig, sig[64], hashType, onlyJs);
+        const signerAddr = hasher(hashType, publicKey, onlyJs);
+        const inputAddr = util.u8aToU8a(address);
+        return util.u8aEq(publicKey, inputAddr) || (hashType === 'keccak'
+            ? util.u8aEq(signerAddr.slice(-20), inputAddr.slice(-20))
+            : util.u8aEq(signerAddr, inputAddr));
+    }
+
+    function getH160(u8a) {
+        if ([33, 65].includes(u8a.length)) {
+            u8a = keccakAsU8a(secp256k1Expand(u8a));
+        }
+        return u8a.slice(-20);
+    }
+    function ethereumEncode(addressOrPublic) {
+        if (!addressOrPublic) {
+            return '0x';
+        }
+        const u8aAddress = util.u8aToU8a(addressOrPublic);
+        if (![20, 32, 33, 65].includes(u8aAddress.length)) {
+            throw new Error(`Invalid address or publicKey provided, received ${u8aAddress.length} bytes input`);
+        }
+        const address = util.u8aToHex(getH160(u8aAddress), -1, false);
+        const hash = util.u8aToHex(keccakAsU8a(address), -1, false);
+        let result = '';
+        for (let i = 0; i < 40; i++) {
+            result = `${result}${parseInt(hash[i], 16) > 7 ? address[i].toUpperCase() : address[i]}`;
+        }
+        return `0x${result}`;
+    }
+
+    function isInvalidChar(char, byte) {
+        return char !== (byte > 7
+            ? char.toUpperCase()
+            : char.toLowerCase());
+    }
+    function isEthereumChecksum(_address) {
+        const address = _address.replace('0x', '');
+        const hash = util.u8aToHex(keccakAsU8a(address.toLowerCase()), -1, false);
+        for (let i = 0; i < 40; i++) {
+            if (isInvalidChar(address[i], parseInt(hash[i], 16))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function isEthereumAddress(address) {
+        if (!address || address.length !== 42 || !util.isHex(address)) {
+            return false;
+        }
+        else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+            return true;
+        }
+        return isEthereumChecksum(address);
+    }
+
+    const JS_HASH = {
+        256: sha256,
+        512: sha512
+    };
+    const WA_MHAC = {
+        256: hmacSha256,
+        512: hmacSha512
+    };
+    function createSha(bitLength) {
+        return (key, data, onlyJs) => hmacShaAsU8a(key, data, bitLength, onlyJs);
+    }
+    function hmacShaAsU8a(key, data, bitLength = 256, onlyJs) {
+        const u8aKey = util.u8aToU8a(key);
+        return !util.hasBigInt || (!onlyJs && isReady())
+            ? WA_MHAC[bitLength](u8aKey, data)
+            : hmac(JS_HASH[bitLength], u8aKey, data);
+    }
+    const hmacSha256AsU8a =  createSha(256);
+    const hmacSha512AsU8a =  createSha(512);
+
+    const HARDENED = 0x80000000;
+    function hdValidatePath(path) {
+        if (!path.startsWith('m/')) {
+            return false;
+        }
+        const parts = path.split('/').slice(1);
+        for (const p of parts) {
+            const n = /^\d+'?$/.test(p)
+                ? parseInt(p.replace(/'$/, ''), 10)
+                : Number.NaN;
+            if (isNaN(n) || (n >= HARDENED) || (n < 0)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    const MASTER_SECRET = util.stringToU8a('Bitcoin seed');
+    function createCoded(secretKey, chainCode) {
+        return {
+            chainCode,
+            publicKey: secp256k1PairFromSeed(secretKey).publicKey,
+            secretKey
+        };
+    }
+    function deriveChild(hd, index) {
+        const indexBuffer = util.bnToU8a(index, BN_BE_32_OPTS);
+        const data = index >= HARDENED
+            ? util.u8aConcat(new Uint8Array(1), hd.secretKey, indexBuffer)
+            : util.u8aConcat(hd.publicKey, indexBuffer);
+        try {
+            const I = hmacShaAsU8a(hd.chainCode, data, 512);
+            return createCoded(secp256k1PrivateKeyTweakAdd(hd.secretKey, I.slice(0, 32)), I.slice(32));
+        }
+        catch {
+            return deriveChild(hd, index + 1);
+        }
+    }
+    function hdEthereum(seed, path = '') {
+        const I = hmacShaAsU8a(MASTER_SECRET, seed, 512);
+        let hd = createCoded(I.slice(0, 32), I.slice(32));
+        if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+            return hd;
+        }
+        if (!hdValidatePath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        const parts = path.split('/').slice(1);
+        for (const p of parts) {
+            hd = deriveChild(hd, parseInt(p, 10) + ((p.length > 1) && p.endsWith("'")
+                ? HARDENED
+                : 0));
+        }
+        return hd;
+    }
+
+    function pbkdf2Init(hash$1, _password, _salt, _opts) {
+        hash(hash$1);
+        const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+        const { c, dkLen, asyncTick } = opts;
+        number(c);
+        number(dkLen);
+        number(asyncTick);
+        if (c < 1)
+            throw new Error('PBKDF2: iterations (c) should be >= 1');
+        const password = toBytes(_password);
+        const salt = toBytes(_salt);
+        const DK = new Uint8Array(dkLen);
+        const PRF = hmac.create(hash$1, password);
+        const PRFSalt = PRF._cloneInto().update(salt);
+        return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+    }
+    function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+        PRF.destroy();
+        PRFSalt.destroy();
+        if (prfW)
+            prfW.destroy();
+        u.fill(0);
+        return DK;
+    }
+    function pbkdf2(hash, password, salt, opts) {
+        const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+        let prfW;
+        const arr = new Uint8Array(4);
+        const view = createView(arr);
+        const u = new Uint8Array(PRF.outputLen);
+        for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+            const Ti = DK.subarray(pos, pos + PRF.outputLen);
+            view.setInt32(0, ti, false);
+            (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+            Ti.set(u.subarray(0, Ti.length));
+            for (let ui = 1; ui < c; ui++) {
+                PRF._cloneInto(prfW).update(u).digestInto(u);
+                for (let i = 0; i < Ti.length; i++)
+                    Ti[i] ^= u[i];
+            }
+        }
+        return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+    }
+
+    function pbkdf2Encode(passphrase, salt = randomAsU8a(), rounds = 2048, onlyJs) {
+        const u8aPass = util.u8aToU8a(passphrase);
+        const u8aSalt = util.u8aToU8a(salt);
+        return {
+            password: !util.hasBigInt || (!onlyJs && isReady())
+                ? pbkdf2$1(u8aPass, u8aSalt, rounds)
+                : pbkdf2(sha512, u8aPass, u8aSalt, { c: rounds, dkLen: 64 }),
+            rounds,
+            salt
+        };
+    }
+
+    const shaAsU8a =  createDualHasher({ 256: sha256$1, 512: sha512$1 }, { 256: sha256, 512: sha512 });
+    const sha256AsU8a =  createBitHasher(256, shaAsU8a);
+    const sha512AsU8a =  createBitHasher(512, shaAsU8a);
+
+    const DEFAULT_WORDLIST = 'abandon|ability|able|about|above|absent|absorb|abstract|absurd|abuse|access|accident|account|accuse|achieve|acid|acoustic|acquire|across|act|action|actor|actress|actual|adapt|add|addict|address|adjust|admit|adult|advance|advice|aerobic|affair|afford|afraid|again|age|agent|agree|ahead|aim|air|airport|aisle|alarm|album|alcohol|alert|alien|all|alley|allow|almost|alone|alpha|already|also|alter|always|amateur|amazing|among|amount|amused|analyst|anchor|ancient|anger|angle|angry|animal|ankle|announce|annual|another|answer|antenna|antique|anxiety|any|apart|apology|appear|apple|approve|april|arch|arctic|area|arena|argue|arm|armed|armor|army|around|arrange|arrest|arrive|arrow|art|artefact|artist|artwork|ask|aspect|assault|asset|assist|assume|asthma|athlete|atom|attack|attend|attitude|attract|auction|audit|august|aunt|author|auto|autumn|average|avocado|avoid|awake|aware|away|awesome|awful|awkward|axis|baby|bachelor|bacon|badge|bag|balance|balcony|ball|bamboo|banana|banner|bar|barely|bargain|barrel|base|basic|basket|battle|beach|bean|beauty|because|become|beef|before|begin|behave|behind|believe|below|belt|bench|benefit|best|betray|better|between|beyond|bicycle|bid|bike|bind|biology|bird|birth|bitter|black|blade|blame|blanket|blast|bleak|bless|blind|blood|blossom|blouse|blue|blur|blush|board|boat|body|boil|bomb|bone|bonus|book|boost|border|boring|borrow|boss|bottom|bounce|box|boy|bracket|brain|brand|brass|brave|bread|breeze|brick|bridge|brief|bright|bring|brisk|broccoli|broken|bronze|broom|brother|brown|brush|bubble|buddy|budget|buffalo|build|bulb|bulk|bullet|bundle|bunker|burden|burger|burst|bus|business|busy|butter|buyer|buzz|cabbage|cabin|cable|cactus|cage|cake|call|calm|camera|camp|can|canal|cancel|candy|cannon|canoe|canvas|canyon|capable|capital|captain|car|carbon|card|cargo|carpet|carry|cart|case|cash|casino|castle|casual|cat|catalog|catch|category|cattle|caught|cause|caution|cave|ceiling|celery|cement|census|century|cereal|certain|chair|chalk|champion|change|chaos|chapter|charge|chase|chat|cheap|check|cheese|chef|cherry|chest|chicken|chief|child|chimney|choice|choose|chronic|chuckle|chunk|churn|cigar|cinnamon|circle|citizen|city|civil|claim|clap|clarify|claw|clay|clean|clerk|clever|click|client|cliff|climb|clinic|clip|clock|clog|close|cloth|cloud|clown|club|clump|cluster|clutch|coach|coast|coconut|code|coffee|coil|coin|collect|color|column|combine|come|comfort|comic|common|company|concert|conduct|confirm|congress|connect|consider|control|convince|cook|cool|copper|copy|coral|core|corn|correct|cost|cotton|couch|country|couple|course|cousin|cover|coyote|crack|cradle|craft|cram|crane|crash|crater|crawl|crazy|cream|credit|creek|crew|cricket|crime|crisp|critic|crop|cross|crouch|crowd|crucial|cruel|cruise|crumble|crunch|crush|cry|crystal|cube|culture|cup|cupboard|curious|current|curtain|curve|cushion|custom|cute|cycle|dad|damage|damp|dance|danger|daring|dash|daughter|dawn|day|deal|debate|debris|decade|december|decide|decline|decorate|decrease|deer|defense|define|defy|degree|delay|deliver|demand|demise|denial|dentist|deny|depart|depend|deposit|depth|deputy|derive|describe|desert|design|desk|despair|destroy|detail|detect|develop|device|devote|diagram|dial|diamond|diary|dice|diesel|diet|differ|digital|dignity|dilemma|dinner|dinosaur|direct|dirt|disagree|discover|disease|dish|dismiss|disorder|display|distance|divert|divide|divorce|dizzy|doctor|document|dog|doll|dolphin|domain|donate|donkey|donor|door|dose|double|dove|draft|dragon|drama|drastic|draw|dream|dress|drift|drill|drink|drip|drive|drop|drum|dry|duck|dumb|dune|during|dust|dutch|duty|dwarf|dynamic|eager|eagle|early|earn|earth|easily|east|easy|echo|ecology|economy|edge|edit|educate|effort|egg|eight|either|elbow|elder|electric|elegant|element|elephant|elevator|elite|else|embark|embody|embrace|emerge|emotion|employ|empower|empty|enable|enact|end|endless|endorse|enemy|energy|enforce|engage|engine|enhance|enjoy|enlist|enough|enrich|enroll|ensure|enter|entire|entry|envelope|episode|equal|equip|era|erase|erode|erosion|error|erupt|escape|essay|essence|estate|eternal|ethics|evidence|evil|evoke|evolve|exact|example|excess|exchange|excite|exclude|excuse|execute|exercise|exhaust|exhibit|exile|exist|exit|exotic|expand|expect|expire|explain|expose|express|extend|extra|eye|eyebrow|fabric|face|faculty|fade|faint|faith|fall|false|fame|family|famous|fan|fancy|fantasy|farm|fashion|fat|fatal|father|fatigue|fault|favorite|feature|february|federal|fee|feed|feel|female|fence|festival|fetch|fever|few|fiber|fiction|field|figure|file|film|filter|final|find|fine|finger|finish|fire|firm|first|fiscal|fish|fit|fitness|fix|flag|flame|flash|flat|flavor|flee|flight|flip|float|flock|floor|flower|fluid|flush|fly|foam|focus|fog|foil|fold|follow|food|foot|force|forest|forget|fork|fortune|forum|forward|fossil|foster|found|fox|fragile|frame|frequent|fresh|friend|fringe|frog|front|frost|frown|frozen|fruit|fuel|fun|funny|furnace|fury|future|gadget|gain|galaxy|gallery|game|gap|garage|garbage|garden|garlic|garment|gas|gasp|gate|gather|gauge|gaze|general|genius|genre|gentle|genuine|gesture|ghost|giant|gift|giggle|ginger|giraffe|girl|give|glad|glance|glare|glass|glide|glimpse|globe|gloom|glory|glove|glow|glue|goat|goddess|gold|good|goose|gorilla|gospel|gossip|govern|gown|grab|grace|grain|grant|grape|grass|gravity|great|green|grid|grief|grit|grocery|group|grow|grunt|guard|guess|guide|guilt|guitar|gun|gym|habit|hair|half|hammer|hamster|hand|happy|harbor|hard|harsh|harvest|hat|have|hawk|hazard|head|health|heart|heavy|hedgehog|height|hello|helmet|help|hen|hero|hidden|high|hill|hint|hip|hire|history|hobby|hockey|hold|hole|holiday|hollow|home|honey|hood|hope|horn|horror|horse|hospital|host|hotel|hour|hover|hub|huge|human|humble|humor|hundred|hungry|hunt|hurdle|hurry|hurt|husband|hybrid|ice|icon|idea|identify|idle|ignore|ill|illegal|illness|image|imitate|immense|immune|impact|impose|improve|impulse|inch|include|income|increase|index|indicate|indoor|industry|infant|inflict|inform|inhale|inherit|initial|inject|injury|inmate|inner|innocent|input|inquiry|insane|insect|inside|inspire|install|intact|interest|into|invest|invite|involve|iron|island|isolate|issue|item|ivory|jacket|jaguar|jar|jazz|jealous|jeans|jelly|jewel|job|join|joke|journey|joy|judge|juice|jump|jungle|junior|junk|just|kangaroo|keen|keep|ketchup|key|kick|kid|kidney|kind|kingdom|kiss|kit|kitchen|kite|kitten|kiwi|knee|knife|knock|know|lab|label|labor|ladder|lady|lake|lamp|language|laptop|large|later|latin|laugh|laundry|lava|law|lawn|lawsuit|layer|lazy|leader|leaf|learn|leave|lecture|left|leg|legal|legend|leisure|lemon|lend|length|lens|leopard|lesson|letter|level|liar|liberty|library|license|life|lift|light|like|limb|limit|link|lion|liquid|list|little|live|lizard|load|loan|lobster|local|lock|logic|lonely|long|loop|lottery|loud|lounge|love|loyal|lucky|luggage|lumber|lunar|lunch|luxury|lyrics|machine|mad|magic|magnet|maid|mail|main|major|make|mammal|man|manage|mandate|mango|mansion|manual|maple|marble|march|margin|marine|market|marriage|mask|mass|master|match|material|math|matrix|matter|maximum|maze|meadow|mean|measure|meat|mechanic|medal|media|melody|melt|member|memory|mention|menu|mercy|merge|merit|merry|mesh|message|metal|method|middle|midnight|milk|million|mimic|mind|minimum|minor|minute|miracle|mirror|misery|miss|mistake|mix|mixed|mixture|mobile|model|modify|mom|moment|monitor|monkey|monster|month|moon|moral|more|morning|mosquito|mother|motion|motor|mountain|mouse|move|movie|much|muffin|mule|multiply|muscle|museum|mushroom|music|must|mutual|myself|mystery|myth|naive|name|napkin|narrow|nasty|nation|nature|near|neck|need|negative|neglect|neither|nephew|nerve|nest|net|network|neutral|never|news|next|nice|night|noble|noise|nominee|noodle|normal|north|nose|notable|note|nothing|notice|novel|now|nuclear|number|nurse|nut|oak|obey|object|oblige|obscure|observe|obtain|obvious|occur|ocean|october|odor|off|offer|office|often|oil|okay|old|olive|olympic|omit|once|one|onion|online|only|open|opera|opinion|oppose|option|orange|orbit|orchard|order|ordinary|organ|orient|original|orphan|ostrich|other|outdoor|outer|output|outside|oval|oven|over|own|owner|oxygen|oyster|ozone|pact|paddle|page|pair|palace|palm|panda|panel|panic|panther|paper|parade|parent|park|parrot|party|pass|patch|path|patient|patrol|pattern|pause|pave|payment|peace|peanut|pear|peasant|pelican|pen|penalty|pencil|people|pepper|perfect|permit|person|pet|phone|photo|phrase|physical|piano|picnic|picture|piece|pig|pigeon|pill|pilot|pink|pioneer|pipe|pistol|pitch|pizza|place|planet|plastic|plate|play|please|pledge|pluck|plug|plunge|poem|poet|point|polar|pole|police|pond|pony|pool|popular|portion|position|possible|post|potato|pottery|poverty|powder|power|practice|praise|predict|prefer|prepare|present|pretty|prevent|price|pride|primary|print|priority|prison|private|prize|problem|process|produce|profit|program|project|promote|proof|property|prosper|protect|proud|provide|public|pudding|pull|pulp|pulse|pumpkin|punch|pupil|puppy|purchase|purity|purpose|purse|push|put|puzzle|pyramid|quality|quantum|quarter|question|quick|quit|quiz|quote|rabbit|raccoon|race|rack|radar|radio|rail|rain|raise|rally|ramp|ranch|random|range|rapid|rare|rate|rather|raven|raw|razor|ready|real|reason|rebel|rebuild|recall|receive|recipe|record|recycle|reduce|reflect|reform|refuse|region|regret|regular|reject|relax|release|relief|rely|remain|remember|remind|remove|render|renew|rent|reopen|repair|repeat|replace|report|require|rescue|resemble|resist|resource|response|result|retire|retreat|return|reunion|reveal|review|reward|rhythm|rib|ribbon|rice|rich|ride|ridge|rifle|right|rigid|ring|riot|ripple|risk|ritual|rival|river|road|roast|robot|robust|rocket|romance|roof|rookie|room|rose|rotate|rough|round|route|royal|rubber|rude|rug|rule|run|runway|rural|sad|saddle|sadness|safe|sail|salad|salmon|salon|salt|salute|same|sample|sand|satisfy|satoshi|sauce|sausage|save|say|scale|scan|scare|scatter|scene|scheme|school|science|scissors|scorpion|scout|scrap|screen|script|scrub|sea|search|season|seat|second|secret|section|security|seed|seek|segment|select|sell|seminar|senior|sense|sentence|series|service|session|settle|setup|seven|shadow|shaft|shallow|share|shed|shell|sheriff|shield|shift|shine|ship|shiver|shock|shoe|shoot|shop|short|shoulder|shove|shrimp|shrug|shuffle|shy|sibling|sick|side|siege|sight|sign|silent|silk|silly|silver|similar|simple|since|sing|siren|sister|situate|six|size|skate|sketch|ski|skill|skin|skirt|skull|slab|slam|sleep|slender|slice|slide|slight|slim|slogan|slot|slow|slush|small|smart|smile|smoke|smooth|snack|snake|snap|sniff|snow|soap|soccer|social|sock|soda|soft|solar|soldier|solid|solution|solve|someone|song|soon|sorry|sort|soul|sound|soup|source|south|space|spare|spatial|spawn|speak|special|speed|spell|spend|sphere|spice|spider|spike|spin|spirit|split|spoil|sponsor|spoon|sport|spot|spray|spread|spring|spy|square|squeeze|squirrel|stable|stadium|staff|stage|stairs|stamp|stand|start|state|stay|steak|steel|stem|step|stereo|stick|still|sting|stock|stomach|stone|stool|story|stove|strategy|street|strike|strong|struggle|student|stuff|stumble|style|subject|submit|subway|success|such|sudden|suffer|sugar|suggest|suit|summer|sun|sunny|sunset|super|supply|supreme|sure|surface|surge|surprise|surround|survey|suspect|sustain|swallow|swamp|swap|swarm|swear|sweet|swift|swim|swing|switch|sword|symbol|symptom|syrup|system|table|tackle|tag|tail|talent|talk|tank|tape|target|task|taste|tattoo|taxi|teach|team|tell|ten|tenant|tennis|tent|term|test|text|thank|that|theme|then|theory|there|they|thing|this|thought|three|thrive|throw|thumb|thunder|ticket|tide|tiger|tilt|timber|time|tiny|tip|tired|tissue|title|toast|tobacco|today|toddler|toe|together|toilet|token|tomato|tomorrow|tone|tongue|tonight|tool|tooth|top|topic|topple|torch|tornado|tortoise|toss|total|tourist|toward|tower|town|toy|track|trade|traffic|tragic|train|transfer|trap|trash|travel|tray|treat|tree|trend|trial|tribe|trick|trigger|trim|trip|trophy|trouble|truck|true|truly|trumpet|trust|truth|try|tube|tuition|tumble|tuna|tunnel|turkey|turn|turtle|twelve|twenty|twice|twin|twist|two|type|typical|ugly|umbrella|unable|unaware|uncle|uncover|under|undo|unfair|unfold|unhappy|uniform|unique|unit|universe|unknown|unlock|until|unusual|unveil|update|upgrade|uphold|upon|upper|upset|urban|urge|usage|use|used|useful|useless|usual|utility|vacant|vacuum|vague|valid|valley|valve|van|vanish|vapor|various|vast|vault|vehicle|velvet|vendor|venture|venue|verb|verify|version|very|vessel|veteran|viable|vibrant|vicious|victory|video|view|village|vintage|violin|virtual|virus|visa|visit|visual|vital|vivid|vocal|voice|void|volcano|volume|vote|voyage|wage|wagon|wait|walk|wall|walnut|want|warfare|warm|warrior|wash|wasp|waste|water|wave|way|wealth|weapon|wear|weasel|weather|web|wedding|weekend|weird|welcome|west|wet|whale|what|wheat|wheel|when|where|whip|whisper|wide|width|wife|wild|will|win|window|wine|wing|wink|winner|winter|wire|wisdom|wise|wish|witness|wolf|woman|wonder|wood|wool|word|work|world|worry|worth|wrap|wreck|wrestle|wrist|write|wrong|yard|year|yellow|you|young|youth|zebra|zero|zone|zoo'.split('|');
+
+    const INVALID_MNEMONIC = 'Invalid mnemonic';
+    const INVALID_ENTROPY = 'Invalid entropy';
+    const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
+    function normalize(str) {
+        return (str || '').normalize('NFKD');
+    }
+    function binaryToByte(bin) {
+        return parseInt(bin, 2);
+    }
+    function bytesToBinary(bytes) {
+        return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
+    }
+    function deriveChecksumBits(entropyBuffer) {
+        return bytesToBinary(Array.from(sha256AsU8a(entropyBuffer))).slice(0, (entropyBuffer.length * 8) / 32);
+    }
+    function mnemonicToSeedSync(mnemonic, password) {
+        return pbkdf2Encode(util.stringToU8a(normalize(mnemonic)), util.stringToU8a(`mnemonic${normalize(password)}`)).password;
+    }
+    function mnemonicToEntropy$1(mnemonic, wordlist = DEFAULT_WORDLIST) {
+        const words = normalize(mnemonic).split(' ');
+        if (words.length % 3 !== 0) {
+            throw new Error(INVALID_MNEMONIC);
+        }
+        const bits = words
+            .map((word) => {
+            const index = wordlist.indexOf(word);
+            if (index === -1) {
+                throw new Error(INVALID_MNEMONIC);
+            }
+            return index.toString(2).padStart(11, '0');
+        })
+            .join('');
+        const dividerIndex = Math.floor(bits.length / 33) * 32;
+        const entropyBits = bits.slice(0, dividerIndex);
+        const checksumBits = bits.slice(dividerIndex);
+        const matched = entropyBits.match(/(.{1,8})/g);
+        const entropyBytes = matched?.map(binaryToByte);
+        if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
+            throw new Error(INVALID_ENTROPY);
+        }
+        const entropy = util.u8aToU8a(entropyBytes);
+        if (deriveChecksumBits(entropy) !== checksumBits) {
+            throw new Error(INVALID_CHECKSUM);
+        }
+        return entropy;
+    }
+    function entropyToMnemonic(entropy, wordlist = DEFAULT_WORDLIST) {
+        if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
+            throw new Error(INVALID_ENTROPY);
+        }
+        const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
+        const mapped = matched?.map((b) => wordlist[binaryToByte(b)]);
+        if (!mapped || (mapped.length < 12)) {
+            throw new Error('Unable to map entropy to mnemonic');
+        }
+        return mapped.join(' ');
+    }
+    function generateMnemonic(numWords, wordlist) {
+        return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
+    }
+    function validateMnemonic(mnemonic, wordlist) {
+        try {
+            mnemonicToEntropy$1(mnemonic, wordlist);
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+
+    function mnemonicGenerate(numWords = 12, wordlist, onlyJs) {
+        return !util.hasBigInt || (!wordlist && !onlyJs && isReady())
+            ? bip39Generate(numWords)
+            : generateMnemonic(numWords, wordlist);
+    }
+
+    function mnemonicToEntropy(mnemonic, wordlist, onlyJs) {
+        return !util.hasBigInt || (!wordlist && !onlyJs && isReady())
+            ? bip39ToEntropy(mnemonic)
+            : mnemonicToEntropy$1(mnemonic, wordlist);
+    }
+
+    function mnemonicValidate(mnemonic, wordlist, onlyJs) {
+        return !util.hasBigInt || (!wordlist && !onlyJs && isReady())
+            ? bip39Validate(mnemonic)
+            : validateMnemonic(mnemonic, wordlist);
+    }
+
+    function mnemonicToLegacySeed(mnemonic, password = '', onlyJs, byteLength = 32) {
+        if (!mnemonicValidate(mnemonic)) {
+            throw new Error('Invalid bip39 mnemonic specified');
+        }
+        else if (![32, 64].includes(byteLength)) {
+            throw new Error(`Invalid seed length ${byteLength}, expected 32 or 64`);
+        }
+        return byteLength === 32
+            ? !util.hasBigInt || (!onlyJs && isReady())
+                ? bip39ToSeed(mnemonic, password)
+                : mnemonicToSeedSync(mnemonic, password).subarray(0, 32)
+            : mnemonicToSeedSync(mnemonic, password);
+    }
+
+    function mnemonicToMiniSecret(mnemonic, password = '', wordlist, onlyJs) {
+        if (!mnemonicValidate(mnemonic, wordlist, onlyJs)) {
+            throw new Error('Invalid bip39 mnemonic specified');
+        }
+        else if (!wordlist && !onlyJs && isReady()) {
+            return bip39ToMiniSecret(mnemonic, password);
+        }
+        const entropy = mnemonicToEntropy(mnemonic, wordlist);
+        const salt = util.stringToU8a(`mnemonic${password}`);
+        return pbkdf2Encode(entropy, salt).password.slice(0, 32);
+    }
+
+    function ledgerDerivePrivate(xprv, index) {
+        const kl = xprv.subarray(0, 32);
+        const kr = xprv.subarray(32, 64);
+        const cc = xprv.subarray(64, 96);
+        const data = util.u8aConcat([0], kl, kr, util.bnToU8a(index, BN_LE_32_OPTS));
+        const z = hmacShaAsU8a(cc, data, 512);
+        data[0] = 0x01;
+        return util.u8aConcat(util.bnToU8a(util.u8aToBn(kl, BN_LE_OPTS).iadd(util.u8aToBn(z.subarray(0, 28), BN_LE_OPTS).imul(util.BN_EIGHT)), BN_LE_512_OPTS).subarray(0, 32), util.bnToU8a(util.u8aToBn(kr, BN_LE_OPTS).iadd(util.u8aToBn(z.subarray(32, 64), BN_LE_OPTS)), BN_LE_512_OPTS).subarray(0, 32), hmacShaAsU8a(cc, data, 512).subarray(32, 64));
+    }
+
+    const ED25519_CRYPTO = 'ed25519 seed';
+    function ledgerMaster(mnemonic, password) {
+        const seed = mnemonicToSeedSync(mnemonic, password);
+        const chainCode = hmacShaAsU8a(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
+        let priv;
+        while (!priv || (priv[31] & 0b0010_0000)) {
+            priv = hmacShaAsU8a(ED25519_CRYPTO, priv || seed, 512);
+        }
+        priv[0] &= 0b1111_1000;
+        priv[31] &= 0b0111_1111;
+        priv[31] |= 0b0100_0000;
+        return util.u8aConcat(priv, chainCode);
+    }
+
+    function hdLedger(_mnemonic, path) {
+        const words = _mnemonic
+            .split(' ')
+            .map((s) => s.trim())
+            .filter((s) => s);
+        if (![12, 24, 25].includes(words.length)) {
+            throw new Error('Expected a mnemonic with 24 words (or 25 including a password)');
+        }
+        const [mnemonic, password] = words.length === 25
+            ? [words.slice(0, 24).join(' '), words[24]]
+            : [words.join(' '), ''];
+        if (!mnemonicValidate(mnemonic)) {
+            throw new Error('Invalid mnemonic passed to ledger derivation');
+        }
+        else if (!hdValidatePath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        const parts = path.split('/').slice(1);
+        let seed = ledgerMaster(mnemonic, password);
+        for (const p of parts) {
+            const n = parseInt(p.replace(/'$/, ''), 10);
+            seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
+        }
+        return ed25519PairFromSeed(seed.slice(0, 32));
+    }
+
+    function L32(x, c) { return (x << c) | (x >>> (32 - c)); }
+    function ld32(x, i) {
+        let u = x[i + 3] & 0xff;
+        u = (u << 8) | (x[i + 2] & 0xff);
+        u = (u << 8) | (x[i + 1] & 0xff);
+        return (u << 8) | (x[i + 0] & 0xff);
+    }
+    function st32(x, j, u) {
+        for (let i = 0; i < 4; i++) {
+            x[j + i] = u & 255;
+            u >>>= 8;
+        }
+    }
+    function vn(x, xi, y, yi, n) {
+        let d = 0;
+        for (let i = 0; i < n; i++)
+            d |= x[xi + i] ^ y[yi + i];
+        return (1 & ((d - 1) >>> 8)) - 1;
+    }
+    function core(out, inp, k, c, h) {
+        const w = new Uint32Array(16), x = new Uint32Array(16), y = new Uint32Array(16), t = new Uint32Array(4);
+        let i, j, m;
+        for (i = 0; i < 4; i++) {
+            x[5 * i] = ld32(c, 4 * i);
+            x[1 + i] = ld32(k, 4 * i);
+            x[6 + i] = ld32(inp, 4 * i);
+            x[11 + i] = ld32(k, 16 + 4 * i);
+        }
+        for (i = 0; i < 16; i++)
+            y[i] = x[i];
+        for (i = 0; i < 20; i++) {
+            for (j = 0; j < 4; j++) {
+                for (m = 0; m < 4; m++)
+                    t[m] = x[(5 * j + 4 * m) % 16];
+                t[1] ^= L32((t[0] + t[3]) | 0, 7);
+                t[2] ^= L32((t[1] + t[0]) | 0, 9);
+                t[3] ^= L32((t[2] + t[1]) | 0, 13);
+                t[0] ^= L32((t[3] + t[2]) | 0, 18);
+                for (m = 0; m < 4; m++)
+                    w[4 * j + (j + m) % 4] = t[m];
+            }
+            for (m = 0; m < 16; m++)
+                x[m] = w[m];
+        }
+        if (h) {
+            for (i = 0; i < 16; i++)
+                x[i] = (x[i] + y[i]) | 0;
+            for (i = 0; i < 4; i++) {
+                x[5 * i] = (x[5 * i] - ld32(c, 4 * i)) | 0;
+                x[6 + i] = (x[6 + i] - ld32(inp, 4 * i)) | 0;
+            }
+            for (i = 0; i < 4; i++) {
+                st32(out, 4 * i, x[5 * i]);
+                st32(out, 16 + 4 * i, x[6 + i]);
+            }
+        }
+        else {
+            for (i = 0; i < 16; i++)
+                st32(out, 4 * i, (x[i] + y[i]) | 0);
+        }
+    }
+    const sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
+    function crypto_stream_salsa20_xor(c, cpos, m, mpos, b, n, k) {
+        const z = new Uint8Array(16), x = new Uint8Array(64);
+        let u, i;
+        if (!b)
+            return 0;
+        for (i = 0; i < 16; i++)
+            z[i] = 0;
+        for (i = 0; i < 8; i++)
+            z[i] = n[i];
+        while (b >= 64) {
+            core(x, z, k, sigma, false);
+            for (i = 0; i < 64; i++)
+                c[cpos + i] = (m ? m[mpos + i] : 0) ^ x[i];
+            u = 1;
+            for (i = 8; i < 16; i++) {
+                u = u + (z[i] & 0xff) | 0;
+                z[i] = u & 0xff;
+                u >>>= 8;
+            }
+            b -= 64;
+            cpos += 64;
+            if (m)
+                mpos += 64;
+        }
+        if (b > 0) {
+            core(x, z, k, sigma, false);
+            for (i = 0; i < b; i++)
+                c[cpos + i] = (m ? m[mpos + i] : 0) ^ x[i];
+        }
+        return 0;
+    }
+    function crypto_stream_xor(c, cpos, m, mpos, d, n, k) {
+        const s = new Uint8Array(32);
+        core(s, n, k, sigma, true);
+        return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, n.subarray(16), s);
+    }
+    function add1305(h, c) {
+        let u = 0;
+        for (let j = 0; j < 17; j++) {
+            u = (u + ((h[j] + c[j]) | 0)) | 0;
+            h[j] = u & 255;
+            u >>>= 8;
+        }
+    }
+    const minusp = new Uint32Array([5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252]);
+    function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
+        let i, j, u;
+        const x = new Uint32Array(17), r = new Uint32Array(17), h = new Uint32Array(17), c = new Uint32Array(17), g = new Uint32Array(17);
+        for (j = 0; j < 17; j++)
+            r[j] = h[j] = 0;
+        for (j = 0; j < 16; j++)
+            r[j] = k[j];
+        r[3] &= 15;
+        r[4] &= 252;
+        r[7] &= 15;
+        r[8] &= 252;
+        r[11] &= 15;
+        r[12] &= 252;
+        r[15] &= 15;
+        while (n > 0) {
+            for (j = 0; j < 17; j++)
+                c[j] = 0;
+            for (j = 0; (j < 16) && (j < n); ++j)
+                c[j] = m[mpos + j];
+            c[j] = 1;
+            mpos += j;
+            n -= j;
+            add1305(h, c);
+            for (i = 0; i < 17; i++) {
+                x[i] = 0;
+                for (j = 0; j < 17; j++)
+                    x[i] = (x[i] + (h[j] * ((j <= i) ? r[i - j] : ((320 * r[i + 17 - j]) | 0))) | 0) | 0;
+            }
+            for (i = 0; i < 17; i++)
+                h[i] = x[i];
+            u = 0;
+            for (j = 0; j < 16; j++) {
+                u = (u + h[j]) | 0;
+                h[j] = u & 255;
+                u >>>= 8;
+            }
+            u = (u + h[16]) | 0;
+            h[16] = u & 3;
+            u = (5 * (u >>> 2)) | 0;
+            for (j = 0; j < 16; j++) {
+                u = (u + h[j]) | 0;
+                h[j] = u & 255;
+                u >>>= 8;
+            }
+            u = (u + h[16]) | 0;
+            h[16] = u;
+        }
+        for (j = 0; j < 17; j++)
+            g[j] = h[j];
+        add1305(h, minusp);
+        const s = (-(h[16] >>> 7) | 0);
+        for (j = 0; j < 17; j++)
+            h[j] ^= s & (g[j] ^ h[j]);
+        for (j = 0; j < 16; j++)
+            c[j] = k[j + 16];
+        c[16] = 0;
+        add1305(h, c);
+        for (j = 0; j < 16; j++)
+            out[outpos + j] = h[j];
+        return 0;
+    }
+    function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
+        const x = new Uint8Array(16);
+        crypto_onetimeauth(x, 0, m, mpos, n, k);
+        return vn(h, hpos, x, 0, 16);
+    }
+    function crypto_secretbox(c, m, d, n, k) {
+        if (d < 32)
+            return -1;
+        crypto_stream_xor(c, 0, m, 0, d, n, k);
+        crypto_onetimeauth(c, 16, c, 32, d - 32, c);
+        for (let i = 0; i < 16; i++)
+            c[i] = 0;
+        return 0;
+    }
+    function crypto_secretbox_open(m, c, d, n, k) {
+        const x = new Uint8Array(32);
+        if (d < 32)
+            return -1;
+        crypto_stream_xor(x, 0, null, 0, 32, n, k);
+        if (crypto_onetimeauth_verify(c, 16, c, 32, d - 32, x) !== 0)
+            return -1;
+        crypto_stream_xor(m, 0, c, 0, d, n, k);
+        for (let i = 0; i < 32; i++)
+            m[i] = 0;
+        return 0;
+    }
+    const crypto_secretbox_KEYBYTES = 32;
+    const crypto_secretbox_NONCEBYTES = 24;
+    const crypto_secretbox_ZEROBYTES = 32;
+    const crypto_secretbox_BOXZEROBYTES = 16;
+    function checkLengths(k, n) {
+        if (k.length !== crypto_secretbox_KEYBYTES)
+            throw new Error('bad key size');
+        if (n.length !== crypto_secretbox_NONCEBYTES)
+            throw new Error('bad nonce size');
+    }
+    function checkArrayTypes(...args) {
+        for (let i = 0, count = args.length; i < count; i++) {
+            if (!(args[i] instanceof Uint8Array))
+                throw new TypeError('unexpected type, use Uint8Array');
+        }
+    }
+    function naclSecretbox(msg, nonce, key) {
+        checkArrayTypes(msg, nonce, key);
+        checkLengths(key, nonce);
+        const m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
+        const c = new Uint8Array(m.length);
+        for (let i = 0; i < msg.length; i++)
+            m[i + crypto_secretbox_ZEROBYTES] = msg[i];
+        crypto_secretbox(c, m, m.length, nonce, key);
+        return c.subarray(crypto_secretbox_BOXZEROBYTES);
+    }
+    function naclSecretboxOpen(box, nonce, key) {
+        checkArrayTypes(box, nonce, key);
+        checkLengths(key, nonce);
+        const c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
+        const m = new Uint8Array(c.length);
+        for (let i = 0; i < box.length; i++)
+            c[i + crypto_secretbox_BOXZEROBYTES] = box[i];
+        if (c.length < 32)
+            return null;
+        if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0)
+            return null;
+        return m.subarray(crypto_secretbox_ZEROBYTES);
+    }
+
+    function naclDecrypt(encrypted, nonce, secret) {
+        return naclSecretboxOpen(encrypted, nonce, secret);
+    }
+
+    function naclEncrypt(message, secret, nonce = randomAsU8a(24)) {
+        return {
+            encrypted: naclSecretbox(message, nonce, secret),
+            nonce
+        };
+    }
+
+    const rotl$1 = (a, b) => (a << b) | (a >>> (32 - b));
+    function XorAndSalsa(prev, pi, input, ii, out, oi) {
+        let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
+        let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
+        let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
+        let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
+        let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
+        let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
+        let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
+        let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
+        let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+        for (let i = 0; i < 8; i += 2) {
+            x04 ^= rotl$1(x00 + x12 | 0, 7);
+            x08 ^= rotl$1(x04 + x00 | 0, 9);
+            x12 ^= rotl$1(x08 + x04 | 0, 13);
+            x00 ^= rotl$1(x12 + x08 | 0, 18);
+            x09 ^= rotl$1(x05 + x01 | 0, 7);
+            x13 ^= rotl$1(x09 + x05 | 0, 9);
+            x01 ^= rotl$1(x13 + x09 | 0, 13);
+            x05 ^= rotl$1(x01 + x13 | 0, 18);
+            x14 ^= rotl$1(x10 + x06 | 0, 7);
+            x02 ^= rotl$1(x14 + x10 | 0, 9);
+            x06 ^= rotl$1(x02 + x14 | 0, 13);
+            x10 ^= rotl$1(x06 + x02 | 0, 18);
+            x03 ^= rotl$1(x15 + x11 | 0, 7);
+            x07 ^= rotl$1(x03 + x15 | 0, 9);
+            x11 ^= rotl$1(x07 + x03 | 0, 13);
+            x15 ^= rotl$1(x11 + x07 | 0, 18);
+            x01 ^= rotl$1(x00 + x03 | 0, 7);
+            x02 ^= rotl$1(x01 + x00 | 0, 9);
+            x03 ^= rotl$1(x02 + x01 | 0, 13);
+            x00 ^= rotl$1(x03 + x02 | 0, 18);
+            x06 ^= rotl$1(x05 + x04 | 0, 7);
+            x07 ^= rotl$1(x06 + x05 | 0, 9);
+            x04 ^= rotl$1(x07 + x06 | 0, 13);
+            x05 ^= rotl$1(x04 + x07 | 0, 18);
+            x11 ^= rotl$1(x10 + x09 | 0, 7);
+            x08 ^= rotl$1(x11 + x10 | 0, 9);
+            x09 ^= rotl$1(x08 + x11 | 0, 13);
+            x10 ^= rotl$1(x09 + x08 | 0, 18);
+            x12 ^= rotl$1(x15 + x14 | 0, 7);
+            x13 ^= rotl$1(x12 + x15 | 0, 9);
+            x14 ^= rotl$1(x13 + x12 | 0, 13);
+            x15 ^= rotl$1(x14 + x13 | 0, 18);
+        }
+        out[oi++] = (y00 + x00) | 0;
+        out[oi++] = (y01 + x01) | 0;
+        out[oi++] = (y02 + x02) | 0;
+        out[oi++] = (y03 + x03) | 0;
+        out[oi++] = (y04 + x04) | 0;
+        out[oi++] = (y05 + x05) | 0;
+        out[oi++] = (y06 + x06) | 0;
+        out[oi++] = (y07 + x07) | 0;
+        out[oi++] = (y08 + x08) | 0;
+        out[oi++] = (y09 + x09) | 0;
+        out[oi++] = (y10 + x10) | 0;
+        out[oi++] = (y11 + x11) | 0;
+        out[oi++] = (y12 + x12) | 0;
+        out[oi++] = (y13 + x13) | 0;
+        out[oi++] = (y14 + x14) | 0;
+        out[oi++] = (y15 + x15) | 0;
+    }
+    function BlockMix(input, ii, out, oi, r) {
+        let head = oi + 0;
+        let tail = oi + 16 * r;
+        for (let i = 0; i < 16; i++)
+            out[tail + i] = input[ii + (2 * r - 1) * 16 + i];
+        for (let i = 0; i < r; i++, head += 16, ii += 16) {
+            XorAndSalsa(out, tail, input, ii, out, head);
+            if (i > 0)
+                tail += 16;
+            XorAndSalsa(out, head, input, (ii += 16), out, tail);
+        }
+    }
+    function scryptInit(password, salt, _opts) {
+        const opts = checkOpts({
+            dkLen: 32,
+            asyncTick: 10,
+            maxmem: 1024 ** 3 + 1024,
+        }, _opts);
+        const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
+        number(N);
+        number(r);
+        number(p);
+        number(dkLen);
+        number(asyncTick);
+        number(maxmem);
+        if (onProgress !== undefined && typeof onProgress !== 'function')
+            throw new Error('progressCb should be function');
+        const blockSize = 128 * r;
+        const blockSize32 = blockSize / 4;
+        if (N <= 1 || (N & (N - 1)) !== 0 || N >= 2 ** (blockSize / 8) || N > 2 ** 32) {
+            throw new Error('Scrypt: N must be larger than 1, a power of 2, less than 2^(128 * r / 8) and less than 2^32');
+        }
+        if (p < 0 || p > ((2 ** 32 - 1) * 32) / blockSize) {
+            throw new Error('Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)');
+        }
+        if (dkLen < 0 || dkLen > (2 ** 32 - 1) * 32) {
+            throw new Error('Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32');
+        }
+        const memUsed = blockSize * (N + p);
+        if (memUsed > maxmem) {
+            throw new Error(`Scrypt: parameters too large, ${memUsed} (128 * r * (N + p)) > ${maxmem} (maxmem)`);
+        }
+        const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
+        const B32 = u32(B);
+        const V = u32(new Uint8Array(blockSize * N));
+        const tmp = u32(new Uint8Array(blockSize));
+        let blockMixCb = () => { };
+        if (onProgress) {
+            const totalBlockMix = 2 * N * p;
+            const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);
+            let blockMixCnt = 0;
+            blockMixCb = () => {
+                blockMixCnt++;
+                if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
+                    onProgress(blockMixCnt / totalBlockMix);
+            };
+        }
+        return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
+    }
+    function scryptOutput(password, dkLen, B, V, tmp) {
+        const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
+        B.fill(0);
+        V.fill(0);
+        tmp.fill(0);
+        return res;
+    }
+    function scrypt(password, salt, opts) {
+        const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
+        for (let pi = 0; pi < p; pi++) {
+            const Pi = blockSize32 * pi;
+            for (let i = 0; i < blockSize32; i++)
+                V[i] = B32[Pi + i];
+            for (let i = 0, pos = 0; i < N - 1; i++) {
+                BlockMix(V, pos, V, (pos += blockSize32), r);
+                blockMixCb();
+            }
+            BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
+            blockMixCb();
+            for (let i = 0; i < N; i++) {
+                const j = B32[Pi + blockSize32 - 16] % N;
+                for (let k = 0; k < blockSize32; k++)
+                    tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
+                BlockMix(tmp, 0, B32, Pi, r);
+                blockMixCb();
+            }
+        }
+        return scryptOutput(password, dkLen, B, V, tmp);
+    }
+
+    const ALLOWED_PARAMS = [
+        { N: 1 << 13, p: 10, r: 8 },
+        { N: 1 << 14, p: 5, r: 8 },
+        { N: 1 << 15, p: 3, r: 8 },
+        { N: 1 << 15, p: 1, r: 8 },
+        { N: 1 << 16, p: 2, r: 8 },
+        { N: 1 << 17, p: 1, r: 8 }
+    ];
+    const DEFAULT_PARAMS = {
+        N: 1 << 17,
+        p: 1,
+        r: 8
+    };
+
+    function scryptEncode(passphrase, salt = randomAsU8a(), params = DEFAULT_PARAMS, onlyJs) {
+        const u8a = util.u8aToU8a(passphrase);
+        return {
+            params,
+            password: !util.hasBigInt || (!onlyJs && isReady())
+                ? scrypt$1(u8a, salt, Math.log2(params.N), params.r, params.p)
+                : scrypt(u8a, salt, util.objectSpread({ dkLen: 64 }, params)),
+            salt
+        };
+    }
+
+    function scryptFromU8a(data) {
+        if (!(data instanceof Uint8Array)) {
+            throw new Error('Expected input to be a Uint8Array');
+        }
+        if (data.length < 32 + 12) {
+            throw new Error(`Invalid input length: expected 44 bytes, found ${data.length}`);
+        }
+        const salt = data.subarray(0, 32);
+        const N = util.u8aToBn(data.subarray(32, 36), BN_LE_OPTS).toNumber();
+        const p = util.u8aToBn(data.subarray(36, 40), BN_LE_OPTS).toNumber();
+        const r = util.u8aToBn(data.subarray(40, 44), BN_LE_OPTS).toNumber();
+        if (N > (1 << 20) || p > 4 || r > 16) {
+            throw new Error('Scrypt parameters exceed safe limits');
+        }
+        const isAllowed = ALLOWED_PARAMS.some((preset) => preset.N === N && preset.p === p && preset.r === r);
+        if (!isAllowed) {
+            throw new Error('Invalid injected scrypt params found');
+        }
+        return { params: { N, p, r }, salt };
+    }
+
+    function scryptToU8a(salt, { N, p, r }) {
+        return util.u8aConcat(salt, util.bnToU8a(N, BN_LE_32_OPTS), util.bnToU8a(p, BN_LE_32_OPTS), util.bnToU8a(r, BN_LE_32_OPTS));
+    }
+
+    const ENCODING = ['scrypt', 'xsalsa20-poly1305'];
+    const ENCODING_NONE = ['none'];
+    const ENCODING_VERSION = '3';
+    const NONCE_LENGTH = 24;
+    const SCRYPT_LENGTH = 32 + (3 * 4);
+
+    function jsonDecryptData(encrypted, passphrase, encType = ENCODING) {
+        if (!encrypted) {
+            throw new Error('No encrypted data available to decode');
+        }
+        else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
+            throw new Error('Password required to decode encrypted data');
+        }
+        let encoded = encrypted;
+        if (passphrase) {
+            let password;
+            if (encType.includes('scrypt')) {
+                const { params, salt } = scryptFromU8a(encrypted);
+                password = scryptEncode(passphrase, salt, params).password;
+                encrypted = encrypted.subarray(SCRYPT_LENGTH);
+            }
+            else {
+                password = util.stringToU8a(passphrase);
+            }
+            encoded = naclDecrypt(encrypted.subarray(NONCE_LENGTH), encrypted.subarray(0, NONCE_LENGTH), util.u8aFixLength(password, 256, true));
+        }
+        if (!encoded) {
+            throw new Error('Unable to decode using the supplied passphrase');
+        }
+        return encoded;
+    }
+
+    function jsonDecrypt({ encoded, encoding }, passphrase) {
+        if (!encoded) {
+            throw new Error('No encrypted data available to decode');
+        }
+        return jsonDecryptData(util.isHex(encoded)
+            ? util.hexToU8a(encoded)
+            : base64Decode(encoded), passphrase, Array.isArray(encoding.type)
+            ? encoding.type
+            : [encoding.type]);
+    }
+
+    function jsonEncryptFormat(encoded, contentType, isEncrypted) {
+        return {
+            encoded: base64Encode(encoded),
+            encoding: {
+                content: contentType,
+                type: isEncrypted
+                    ? ENCODING
+                    : ENCODING_NONE,
+                version: ENCODING_VERSION
+            }
+        };
+    }
+
+    function jsonEncrypt(data, contentType, passphrase) {
+        let isEncrypted = false;
+        let encoded = data;
+        if (passphrase) {
+            const { params, password, salt } = scryptEncode(passphrase);
+            const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
+            isEncrypted = true;
+            encoded = util.u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
+        }
+        return jsonEncryptFormat(encoded, contentType, isEncrypted);
+    }
+
+    const secp256k1VerifyHasher = (hashType) => (message, signature, publicKey) => secp256k1Verify(message, signature, publicKey, hashType, true);
+    const VERIFIERS_ECDSA = [
+        ['ecdsa', secp256k1VerifyHasher('blake2')],
+        ['ethereum', secp256k1VerifyHasher('keccak')]
+    ];
+    const VERIFIERS = [
+        ['ed25519', ed25519Verify],
+        ['sr25519', sr25519Verify]
+    ];
+    function verifyDetect(result, { message, publicKey, signature }, verifiers = [...VERIFIERS, ...VERIFIERS_ECDSA]) {
+        result.isValid = verifiers.some(([crypto, verify]) => {
+            try {
+                if (verify(message, signature, publicKey)) {
+                    result.crypto = crypto;
+                    return true;
+                }
+            }
+            catch {
+            }
+            return false;
+        });
+        return result;
+    }
+    function verifyMultisig(result, { message, publicKey, signature }) {
+        if (![0, 1, 2].includes(signature[0]) || ![65, 66].includes(signature.length)) {
+            throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+        }
+        if (signature.length === 66) {
+            result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS_ECDSA);
+        }
+        else {
+            result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS);
+            if (!result.isValid) {
+                result = verifyDetect(result, { message, publicKey, signature }, VERIFIERS_ECDSA);
+            }
+            if (!result.isValid) {
+                result.crypto = 'none';
+            }
+        }
+        return result;
+    }
+    function getVerifyFn(signature) {
+        return [0, 1, 2].includes(signature[0]) && [65, 66].includes(signature.length)
+            ? verifyMultisig
+            : verifyDetect;
+    }
+    function signatureVerify(message, signature, addressOrPublicKey) {
+        const signatureU8a = util.u8aToU8a(signature);
+        if (![64, 65, 66].includes(signatureU8a.length)) {
+            throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+        }
+        const publicKey = decodeAddress(addressOrPublicKey);
+        const input = { message: util.u8aToU8a(message), publicKey, signature: signatureU8a };
+        const result = { crypto: 'none', isValid: false, isWrapped: util.u8aIsWrapped(input.message, true), publicKey };
+        const isWrappedBytes = util.u8aIsWrapped(input.message, false);
+        const verifyFn = getVerifyFn(signatureU8a);
+        verifyFn(result, input);
+        if (result.crypto !== 'none' || (result.isWrapped && !isWrappedBytes)) {
+            return result;
+        }
+        input.message = isWrappedBytes
+            ? util.u8aUnwrapBytes(input.message)
+            : util.u8aWrapBytes(input.message);
+        return verifyFn(result, input);
+    }
+
+    const P64_1 = BigInt$1('11400714785074694791');
+    const P64_2 = BigInt$1('14029467366897019727');
+    const P64_3 = BigInt$1('1609587929392839161');
+    const P64_4 = BigInt$1('9650029242287828579');
+    const P64_5 = BigInt$1('2870177450012600261');
+    const U64 = BigInt$1('0xffffffffffffffff');
+    const _7n = BigInt$1(7);
+    const _11n = BigInt$1(11);
+    const _12n = BigInt$1(12);
+    const _16n = BigInt$1(16);
+    const _18n = BigInt$1(18);
+    const _23n = BigInt$1(23);
+    const _27n = BigInt$1(27);
+    const _29n = BigInt$1(29);
+    const _31n = BigInt$1(31);
+    const _32n = BigInt$1(32);
+    const _33n = BigInt$1(33);
+    const _64n = BigInt$1(64);
+    const _256n = BigInt$1(256);
+    function rotl(a, b) {
+        const c = a & U64;
+        return ((c << b) | (c >> (_64n - b))) & U64;
+    }
+    function fromU8a(u8a, p, count) {
+        const bigints = new Array(count);
+        let offset = 0;
+        for (let i = 0; i < count; i++, offset += 2) {
+            bigints[i] = BigInt$1(u8a[p + offset] | (u8a[p + 1 + offset] << 8));
+        }
+        let result = util._0n;
+        for (let i = count - 1; i >= 0; i--) {
+            result = (result << _16n) + bigints[i];
+        }
+        return result;
+    }
+    function init(seed, input) {
+        const state = {
+            seed,
+            u8a: new Uint8Array(32),
+            u8asize: 0,
+            v1: seed + P64_1 + P64_2,
+            v2: seed + P64_2,
+            v3: seed,
+            v4: seed - P64_1
+        };
+        if (input.length < 32) {
+            state.u8a.set(input);
+            state.u8asize = input.length;
+            return state;
+        }
+        const limit = input.length - 32;
+        let p = 0;
+        if (limit >= 0) {
+            const adjustV = (v) => P64_1 * rotl(v + P64_2 * fromU8a(input, p, 4), _31n);
+            do {
+                state.v1 = adjustV(state.v1);
+                p += 8;
+                state.v2 = adjustV(state.v2);
+                p += 8;
+                state.v3 = adjustV(state.v3);
+                p += 8;
+                state.v4 = adjustV(state.v4);
+                p += 8;
+            } while (p <= limit);
+        }
+        if (p < input.length) {
+            state.u8a.set(input.subarray(p, input.length));
+            state.u8asize = input.length - p;
+        }
+        return state;
+    }
+    function xxhash64(input, initSeed) {
+        const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(BigInt$1(initSeed), input);
+        let p = 0;
+        let h64 = U64 & (BigInt$1(input.length) + (input.length >= 32
+            ? (((((((((rotl(v1, util._1n) + rotl(v2, _7n) + rotl(v3, _12n) + rotl(v4, _18n)) ^ (P64_1 * rotl(v1 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v2 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v3 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v4 * P64_2, _31n))) * P64_1 + P64_4)
+            : (seed + P64_5)));
+        while (p <= (u8asize - 8)) {
+            h64 = U64 & (P64_4 + P64_1 * rotl(h64 ^ (P64_1 * rotl(P64_2 * fromU8a(u8a, p, 4), _31n)), _27n));
+            p += 8;
+        }
+        if ((p + 4) <= u8asize) {
+            h64 = U64 & (P64_3 + P64_2 * rotl(h64 ^ (P64_1 * fromU8a(u8a, p, 2)), _23n));
+            p += 4;
+        }
+        while (p < u8asize) {
+            h64 = U64 & (P64_1 * rotl(h64 ^ (P64_5 * BigInt$1(u8a[p++])), _11n));
+        }
+        h64 = U64 & (P64_2 * (h64 ^ (h64 >> _33n)));
+        h64 = U64 & (P64_3 * (h64 ^ (h64 >> _29n)));
+        h64 = U64 & (h64 ^ (h64 >> _32n));
+        const result = new Uint8Array(8);
+        for (let i = 7; i >= 0; i--) {
+            result[i] = Number(h64 % _256n);
+            h64 = h64 / _256n;
+        }
+        return result;
+    }
+
+    function xxhashAsU8a(data, bitLength = 64, onlyJs) {
+        const rounds = Math.ceil(bitLength / 64);
+        const u8a = util.u8aToU8a(data);
+        if (!util.hasBigInt || (!onlyJs && isReady())) {
+            return twox(u8a, rounds);
+        }
+        const result = new Uint8Array(rounds * 8);
+        for (let seed = 0; seed < rounds; seed++) {
+            result.set(xxhash64(u8a, seed).reverse(), seed * 8);
+        }
+        return result;
+    }
+    const xxhashAsHex =  createAsHex(xxhashAsU8a);
+
+    exports.addressEq = addressEq;
+    exports.addressToEvm = addressToEvm;
+    exports.allNetworks = allNetworks;
+    exports.availableNetworks = availableNetworks;
+    exports.base32Decode = base32Decode;
+    exports.base32Encode = base32Encode;
+    exports.base32Validate = base32Validate;
+    exports.base58Decode = base58Decode;
+    exports.base58Encode = base58Encode;
+    exports.base58Validate = base58Validate;
+    exports.base64Decode = base64Decode;
+    exports.base64Encode = base64Encode;
+    exports.base64Pad = base64Pad;
+    exports.base64Trim = base64Trim;
+    exports.base64Validate = base64Validate;
+    exports.blake2AsHex = blake2AsHex;
+    exports.blake2AsU8a = blake2AsU8a;
+    exports.checkAddress = checkAddress;
+    exports.checkAddressChecksum = checkAddressChecksum;
+    exports.createKeyDerived = createKeyDerived;
+    exports.createKeyMulti = createKeyMulti;
+    exports.cryptoIsReady = cryptoIsReady;
+    exports.cryptoWaitReady = cryptoWaitReady;
+    exports.decodeAddress = decodeAddress;
+    exports.deriveAddress = deriveAddress;
+    exports.ed25519DeriveHard = ed25519DeriveHard;
+    exports.ed25519PairFromRandom = ed25519PairFromRandom;
+    exports.ed25519PairFromSecret = ed25519PairFromSecret;
+    exports.ed25519PairFromSeed = ed25519PairFromSeed;
+    exports.ed25519PairFromString = ed25519PairFromString;
+    exports.ed25519Sign = ed25519Sign;
+    exports.ed25519Verify = ed25519Verify;
+    exports.encodeAddress = encodeAddress;
+    exports.encodeDerivedAddress = encodeDerivedAddress;
+    exports.encodeMultiAddress = encodeMultiAddress;
+    exports.ethereumEncode = ethereumEncode;
+    exports.evmToAddress = evmToAddress;
+    exports.hdEthereum = hdEthereum;
+    exports.hdLedger = hdLedger;
+    exports.hdValidatePath = hdValidatePath;
+    exports.hmacSha256AsU8a = hmacSha256AsU8a;
+    exports.hmacSha512AsU8a = hmacSha512AsU8a;
+    exports.hmacShaAsU8a = hmacShaAsU8a;
+    exports.isAddress = isAddress;
+    exports.isBase32 = isBase32;
+    exports.isBase58 = isBase58;
+    exports.isBase64 = isBase64;
+    exports.isEthereumAddress = isEthereumAddress;
+    exports.isEthereumChecksum = isEthereumChecksum;
+    exports.jsonDecrypt = jsonDecrypt;
+    exports.jsonDecryptData = jsonDecryptData;
+    exports.jsonEncrypt = jsonEncrypt;
+    exports.jsonEncryptFormat = jsonEncryptFormat;
+    exports.keccak256AsU8a = keccak256AsU8a;
+    exports.keccak512AsU8a = keccak512AsU8a;
+    exports.keccakAsHex = keccakAsHex;
+    exports.keccakAsU8a = keccakAsU8a;
+    exports.keyExtractPath = keyExtractPath;
+    exports.keyExtractSuri = keyExtractSuri;
+    exports.keyFromPath = keyFromPath;
+    exports.keyHdkdEcdsa = keyHdkdEcdsa;
+    exports.keyHdkdEd25519 = keyHdkdEd25519;
+    exports.keyHdkdSr25519 = keyHdkdSr25519;
+    exports.mnemonicGenerate = mnemonicGenerate;
+    exports.mnemonicToEntropy = mnemonicToEntropy;
+    exports.mnemonicToLegacySeed = mnemonicToLegacySeed;
+    exports.mnemonicToMiniSecret = mnemonicToMiniSecret;
+    exports.mnemonicValidate = mnemonicValidate;
+    exports.naclDecrypt = naclDecrypt;
+    exports.naclEncrypt = naclEncrypt;
+    exports.packageInfo = packageInfo;
+    exports.pbkdf2Encode = pbkdf2Encode;
+    exports.randomAsHex = randomAsHex;
+    exports.randomAsNumber = randomAsNumber;
+    exports.randomAsU8a = randomAsU8a;
+    exports.scryptEncode = scryptEncode;
+    exports.scryptFromU8a = scryptFromU8a;
+    exports.scryptToU8a = scryptToU8a;
+    exports.secp256k1Compress = secp256k1Compress;
+    exports.secp256k1Expand = secp256k1Expand;
+    exports.secp256k1PairFromSeed = secp256k1PairFromSeed;
+    exports.secp256k1PrivateKeyTweakAdd = secp256k1PrivateKeyTweakAdd;
+    exports.secp256k1Recover = secp256k1Recover;
+    exports.secp256k1Sign = secp256k1Sign;
+    exports.secp256k1Verify = secp256k1Verify;
+    exports.selectableNetworks = selectableNetworks;
+    exports.setSS58Format = setSS58Format;
+    exports.sha256AsU8a = sha256AsU8a;
+    exports.sha512AsU8a = sha512AsU8a;
+    exports.shaAsU8a = shaAsU8a;
+    exports.signatureVerify = signatureVerify;
+    exports.sortAddresses = sortAddresses;
+    exports.sr25519Agreement = sr25519Agreement;
+    exports.sr25519DeriveHard = sr25519DeriveHard;
+    exports.sr25519DerivePublic = sr25519DerivePublic;
+    exports.sr25519DeriveSoft = sr25519DeriveSoft;
+    exports.sr25519PairFromSeed = sr25519PairFromSeed;
+    exports.sr25519Sign = sr25519Sign;
+    exports.sr25519Verify = sr25519Verify;
+    exports.sr25519VrfSign = sr25519VrfSign;
+    exports.sr25519VrfVerify = sr25519VrfVerify;
+    exports.validateAddress = validateAddress;
+    exports.xxhashAsHex = xxhashAsHex;
+    exports.xxhashAsU8a = xxhashAsU8a;
+
+}));
diff --git a/docs/root-signing/vendor/bundle-polkadot-util.js b/docs/root-signing/vendor/bundle-polkadot-util.js
new file mode 100644
index 0000000..be35fce
--- /dev/null
+++ b/docs/root-signing/vendor/bundle-polkadot-util.js
@@ -0,0 +1,4829 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.polkadotUtil = {}));
+})(this, (function (exports) { 'use strict';
+
+    const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;
+
+    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+    const packageInfo$3 = { name: '@polkadot/util', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '13.5.9' };
+
+    function arrayChunk(array, chunkSize) {
+        const outputSize = Math.ceil(array.length / chunkSize);
+        if (outputSize === 1) {
+            return [array];
+        }
+        const output = Array(outputSize);
+        for (let i = 0; i < outputSize; i++) {
+            const offset = i * chunkSize;
+            output[i] = array.slice(offset, offset + chunkSize);
+        }
+        return output;
+    }
+
+    function arrayFilter(array, allowNulls = true) {
+        return array.filter((v) => v !== undefined &&
+            (allowNulls || v !== null));
+    }
+
+    function arrayFlatten(arrays) {
+        const num = arrays.length;
+        if (num === 0) {
+            return [];
+        }
+        else if (num === 1) {
+            return arrays[0];
+        }
+        let size = 0;
+        for (let i = 0; i < num; i++) {
+            size += arrays[i].length;
+        }
+        const output = new Array(size);
+        let i = -1;
+        for (let j = 0; j < num; j++) {
+            const a = arrays[j];
+            for (let e = 0, count = a.length; e < count; e++) {
+                output[++i] = a[e];
+            }
+        }
+        return output;
+    }
+
+    function arrayRange(size, startAt = 0) {
+        if (size <= 0) {
+            throw new Error('Expected non-zero, positive number as a range size');
+        }
+        const result = new Array(size);
+        for (let i = 0; i < size; i++) {
+            result[i] = i + startAt;
+        }
+        return result;
+    }
+
+    function arrayShuffle(input) {
+        const result = input.slice();
+        let curr = result.length;
+        if (curr === 1) {
+            return result;
+        }
+        while (curr !== 0) {
+            const rand = ~~(Math.random() * curr);
+            curr--;
+            [result[curr], result[rand]] = [result[rand], result[curr]];
+        }
+        return result;
+    }
+
+    function arrayUnzip(entries) {
+        const count = entries.length;
+        const keys = new Array(count);
+        const values = new Array(count);
+        for (let i = 0; i < count; i++) {
+            [keys[i], values[i]] = entries[i];
+        }
+        return [keys, values];
+    }
+
+    function arrayZip(keys, values) {
+        const count = keys.length;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
+            result[i] = [keys[i], values[i]];
+        }
+        return result;
+    }
+
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+
+    function assert(condition, message) {
+        if (!condition) {
+            throw new Error(isFunction(message)
+                ? message()
+                : message);
+        }
+    }
+    function assertReturn(value, message) {
+        assert(value !== undefined && value !== null, message);
+        return value;
+    }
+    function assertUnreachable(x) {
+        throw new Error(`This codepath should be unreachable. Unhandled input: ${x}`);
+    }
+
+    function createCmp(cmp) {
+        return (...items) => {
+            const count = items.length;
+            if (count === 0) {
+                throw new Error('Must provide one or more arguments');
+            }
+            let result = items[0];
+            for (let i = 1; i < count; i++) {
+                if (cmp(items[i], result)) {
+                    result = items[i];
+                }
+            }
+            return result;
+        };
+    }
+
+    const nMax =  createCmp((a, b) => a > b);
+    const nMin =  createCmp((a, b) => a < b);
+
+    const packageInfo$2 = { name: '@polkadot/x-global', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-util.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '13.5.9' };
+
+    function evaluateThis(fn) {
+        return fn('return this');
+    }
+    const xglobal =  (typeof globalThis !== 'undefined'
+        ? globalThis
+        : typeof global !== 'undefined'
+            ? global
+            : typeof self !== 'undefined'
+                ? self
+                : typeof window !== 'undefined'
+                    ? window
+                    : evaluateThis(Function));
+    function extractGlobal(name, fallback) {
+        return typeof xglobal[name] === 'undefined'
+            ? fallback
+            : xglobal[name];
+    }
+    function exposeGlobal(name, fallback) {
+        if (typeof xglobal[name] === 'undefined') {
+            xglobal[name] = fallback;
+        }
+    }
+
+    const build = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        exposeGlobal: exposeGlobal,
+        extractGlobal: extractGlobal,
+        packageInfo: packageInfo$2,
+        xglobal: xglobal
+    });
+
+    function invalidFallback() {
+        return Number.NaN;
+    }
+    const BigInt =  extractGlobal('BigInt', invalidFallback);
+
+    const _0n =  BigInt(0);
+    const _1n =  BigInt(1);
+    const _2n =  BigInt(2);
+    const _3n =  BigInt(3);
+    const _4n =  BigInt(4);
+    const _5n =  BigInt(5);
+    const _6n =  BigInt(6);
+    const _7n =  BigInt(7);
+    const _8n =  BigInt(8);
+    const _9n =  BigInt(9);
+    const _10n =  BigInt(10);
+    const _100n =  BigInt(100);
+    const _1000n =  BigInt(1_000);
+    const _1Mn =  BigInt(1_000_000);
+    const _1Bn =  BigInt(1_000_000_000);
+    const _1Qn = _1Bn * _1Bn;
+    const _2pow53n =  BigInt(Number.MAX_SAFE_INTEGER);
+    const _sqrt2pow53n =  BigInt(94906265);
+
+    const U8_MAX = BigInt(256);
+    const U16_MAX = BigInt(256 * 256);
+    const U64_MAX = BigInt('0x10000000000000000');
+    function u8aToBigInt(value, { isLe = true, isNegative = false } = {}) {
+        if (!isLe) {
+            value = value.slice().reverse();
+        }
+        const count = value.length;
+        if (isNegative && count && (value[count - 1] & 0x80)) {
+            switch (count) {
+                case 0:
+                    return BigInt(0);
+                case 1:
+                    return BigInt(((value[0] ^ 0x0000_00ff) * -1) - 1);
+                case 2:
+                    return BigInt((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+                case 4:
+                    return BigInt((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+            }
+            const dvI = new DataView(value.buffer, value.byteOffset);
+            if (count === 8) {
+                return dvI.getBigInt64(0, true);
+            }
+            let result = BigInt(0);
+            const mod = count % 2;
+            for (let i = count - 2; i >= mod; i -= 2) {
+                result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true) ^ 0xffff);
+            }
+            if (mod) {
+                result = (result * U8_MAX) + BigInt(value[0] ^ 0xff);
+            }
+            return (result * -_1n) - _1n;
+        }
+        switch (count) {
+            case 0:
+                return BigInt(0);
+            case 1:
+                return BigInt(value[0]);
+            case 2:
+                return BigInt(value[0] + (value[1] << 8));
+            case 4:
+                return BigInt(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+        }
+        const dvI = new DataView(value.buffer, value.byteOffset);
+        switch (count) {
+            case 8:
+                return dvI.getBigUint64(0, true);
+            case 16:
+                return (dvI.getBigUint64(8, true) * U64_MAX) + dvI.getBigUint64(0, true);
+            default: {
+                let result = BigInt(0);
+                const mod = count % 2;
+                for (let i = count - 2; i >= mod; i -= 2) {
+                    result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true));
+                }
+                if (mod) {
+                    result = (result * U8_MAX) + BigInt(value[0]);
+                }
+                return result;
+            }
+        }
+    }
+
+    const CHR = '0123456789abcdef';
+    const U8$1 = new Uint8Array(256);
+    const U16$1 = new Uint8Array(256 * 256);
+    for (let i = 0, count = CHR.length; i < count; i++) {
+        U8$1[CHR[i].charCodeAt(0) | 0] = i | 0;
+        if (i > 9) {
+            U8$1[CHR[i].toUpperCase().charCodeAt(0) | 0] = i | 0;
+        }
+    }
+    for (let i = 0; i < 256; i++) {
+        const s = i << 8;
+        for (let j = 0; j < 256; j++) {
+            U16$1[s | j] = (U8$1[i] << 4) | U8$1[j];
+        }
+    }
+    function hexToU8a(value, bitLength = -1) {
+        if (!value) {
+            return new Uint8Array();
+        }
+        let s = value.startsWith('0x')
+            ? 2
+            : 0;
+        const decLength = Math.ceil((value.length - s) / 2);
+        const endLength = Math.ceil(bitLength === -1
+            ? decLength
+            : bitLength / 8);
+        const result = new Uint8Array(endLength);
+        const offset = endLength > decLength
+            ? endLength - decLength
+            : 0;
+        for (let i = offset; i < endLength; i++, s += 2) {
+            result[i] = U16$1[(value.charCodeAt(s) << 8) | value.charCodeAt(s + 1)];
+        }
+        return result;
+    }
+
+    function hexToBigInt(value, { isLe = false, isNegative = false } = {}) {
+        return !value || value === '0x'
+            ? BigInt(0)
+            : u8aToBigInt(hexToU8a(value), { isLe, isNegative });
+    }
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    function getAugmentedNamespace(n) {
+      if (n.__esModule) return n;
+      var f = n.default;
+    	if (typeof f == "function") {
+    		var a = function a () {
+    			if (this instanceof a) {
+            return Reflect.construct(f, arguments, this.constructor);
+    			}
+    			return f.apply(this, arguments);
+    		};
+    		a.prototype = f.prototype;
+      } else a = {};
+      Object.defineProperty(a, '__esModule', {value: true});
+    	Object.keys(n).forEach(function (k) {
+    		var d = Object.getOwnPropertyDescriptor(n, k);
+    		Object.defineProperty(a, k, d.get ? d : {
+    			enumerable: true,
+    			get: function () {
+    				return n[k];
+    			}
+    		});
+    	});
+    	return a;
+    }
+
+    var bn = {exports: {}};
+
+    const _nodeResolve_empty = {};
+
+    const _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        default: _nodeResolve_empty
+    });
+
+    const require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
+
+    bn.exports;
+    (function (module) {
+    	(function (module, exports) {
+    	  function assert (val, msg) {
+    	    if (!val) throw new Error(msg || 'Assertion failed');
+    	  }
+    	  function inherits (ctor, superCtor) {
+    	    ctor.super_ = superCtor;
+    	    var TempCtor = function () {};
+    	    TempCtor.prototype = superCtor.prototype;
+    	    ctor.prototype = new TempCtor();
+    	    ctor.prototype.constructor = ctor;
+    	  }
+    	  function BN (number, base, endian) {
+    	    if (BN.isBN(number)) {
+    	      return number;
+    	    }
+    	    this.negative = 0;
+    	    this.words = null;
+    	    this.length = 0;
+    	    this.red = null;
+    	    if (number !== null) {
+    	      if (base === 'le' || base === 'be') {
+    	        endian = base;
+    	        base = 10;
+    	      }
+    	      this._init(number || 0, base || 10, endian || 'be');
+    	    }
+    	  }
+    	  if (typeof module === 'object') {
+    	    module.exports = BN;
+    	  } else {
+    	    exports.BN = BN;
+    	  }
+    	  BN.BN = BN;
+    	  BN.wordSize = 26;
+    	  var Buffer;
+    	  try {
+    	    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {
+    	      Buffer = window.Buffer;
+    	    } else {
+    	      Buffer = require$$0$1.Buffer;
+    	    }
+    	  } catch (e) {
+    	  }
+    	  BN.isBN = function isBN (num) {
+    	    if (num instanceof BN) {
+    	      return true;
+    	    }
+    	    return num !== null && typeof num === 'object' &&
+    	      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+    	  };
+    	  BN.max = function max (left, right) {
+    	    if (left.cmp(right) > 0) return left;
+    	    return right;
+    	  };
+    	  BN.min = function min (left, right) {
+    	    if (left.cmp(right) < 0) return left;
+    	    return right;
+    	  };
+    	  BN.prototype._init = function init (number, base, endian) {
+    	    if (typeof number === 'number') {
+    	      return this._initNumber(number, base, endian);
+    	    }
+    	    if (typeof number === 'object') {
+    	      return this._initArray(number, base, endian);
+    	    }
+    	    if (base === 'hex') {
+    	      base = 16;
+    	    }
+    	    assert(base === (base | 0) && base >= 2 && base <= 36);
+    	    number = number.toString().replace(/\s+/g, '');
+    	    var start = 0;
+    	    if (number[0] === '-') {
+    	      start++;
+    	      this.negative = 1;
+    	    }
+    	    if (start < number.length) {
+    	      if (base === 16) {
+    	        this._parseHex(number, start, endian);
+    	      } else {
+    	        this._parseBase(number, base, start);
+    	        if (endian === 'le') {
+    	          this._initArray(this.toArray(), base, endian);
+    	        }
+    	      }
+    	    }
+    	  };
+    	  BN.prototype._initNumber = function _initNumber (number, base, endian) {
+    	    if (number < 0) {
+    	      this.negative = 1;
+    	      number = -number;
+    	    }
+    	    if (number < 0x4000000) {
+    	      this.words = [number & 0x3ffffff];
+    	      this.length = 1;
+    	    } else if (number < 0x10000000000000) {
+    	      this.words = [
+    	        number & 0x3ffffff,
+    	        (number / 0x4000000) & 0x3ffffff
+    	      ];
+    	      this.length = 2;
+    	    } else {
+    	      assert(number < 0x20000000000000);
+    	      this.words = [
+    	        number & 0x3ffffff,
+    	        (number / 0x4000000) & 0x3ffffff,
+    	        1
+    	      ];
+    	      this.length = 3;
+    	    }
+    	    if (endian !== 'le') return;
+    	    this._initArray(this.toArray(), base, endian);
+    	  };
+    	  BN.prototype._initArray = function _initArray (number, base, endian) {
+    	    assert(typeof number.length === 'number');
+    	    if (number.length <= 0) {
+    	      this.words = [0];
+    	      this.length = 1;
+    	      return this;
+    	    }
+    	    this.length = Math.ceil(number.length / 3);
+    	    this.words = new Array(this.length);
+    	    for (var i = 0; i < this.length; i++) {
+    	      this.words[i] = 0;
+    	    }
+    	    var j, w;
+    	    var off = 0;
+    	    if (endian === 'be') {
+    	      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
+    	        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
+    	        this.words[j] |= (w << off) & 0x3ffffff;
+    	        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+    	        off += 24;
+    	        if (off >= 26) {
+    	          off -= 26;
+    	          j++;
+    	        }
+    	      }
+    	    } else if (endian === 'le') {
+    	      for (i = 0, j = 0; i < number.length; i += 3) {
+    	        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
+    	        this.words[j] |= (w << off) & 0x3ffffff;
+    	        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+    	        off += 24;
+    	        if (off >= 26) {
+    	          off -= 26;
+    	          j++;
+    	        }
+    	      }
+    	    }
+    	    return this._strip();
+    	  };
+    	  function parseHex4Bits (string, index) {
+    	    var c = string.charCodeAt(index);
+    	    if (c >= 48 && c <= 57) {
+    	      return c - 48;
+    	    } else if (c >= 65 && c <= 70) {
+    	      return c - 55;
+    	    } else if (c >= 97 && c <= 102) {
+    	      return c - 87;
+    	    } else {
+    	      assert(false, 'Invalid character in ' + string);
+    	    }
+    	  }
+    	  function parseHexByte (string, lowerBound, index) {
+    	    var r = parseHex4Bits(string, index);
+    	    if (index - 1 >= lowerBound) {
+    	      r |= parseHex4Bits(string, index - 1) << 4;
+    	    }
+    	    return r;
+    	  }
+    	  BN.prototype._parseHex = function _parseHex (number, start, endian) {
+    	    this.length = Math.ceil((number.length - start) / 6);
+    	    this.words = new Array(this.length);
+    	    for (var i = 0; i < this.length; i++) {
+    	      this.words[i] = 0;
+    	    }
+    	    var off = 0;
+    	    var j = 0;
+    	    var w;
+    	    if (endian === 'be') {
+    	      for (i = number.length - 1; i >= start; i -= 2) {
+    	        w = parseHexByte(number, start, i) << off;
+    	        this.words[j] |= w & 0x3ffffff;
+    	        if (off >= 18) {
+    	          off -= 18;
+    	          j += 1;
+    	          this.words[j] |= w >>> 26;
+    	        } else {
+    	          off += 8;
+    	        }
+    	      }
+    	    } else {
+    	      var parseLength = number.length - start;
+    	      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
+    	        w = parseHexByte(number, start, i) << off;
+    	        this.words[j] |= w & 0x3ffffff;
+    	        if (off >= 18) {
+    	          off -= 18;
+    	          j += 1;
+    	          this.words[j] |= w >>> 26;
+    	        } else {
+    	          off += 8;
+    	        }
+    	      }
+    	    }
+    	    this._strip();
+    	  };
+    	  function parseBase (str, start, end, mul) {
+    	    var r = 0;
+    	    var b = 0;
+    	    var len = Math.min(str.length, end);
+    	    for (var i = start; i < len; i++) {
+    	      var c = str.charCodeAt(i) - 48;
+    	      r *= mul;
+    	      if (c >= 49) {
+    	        b = c - 49 + 0xa;
+    	      } else if (c >= 17) {
+    	        b = c - 17 + 0xa;
+    	      } else {
+    	        b = c;
+    	      }
+    	      assert(c >= 0 && b < mul, 'Invalid character');
+    	      r += b;
+    	    }
+    	    return r;
+    	  }
+    	  BN.prototype._parseBase = function _parseBase (number, base, start) {
+    	    this.words = [0];
+    	    this.length = 1;
+    	    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
+    	      limbLen++;
+    	    }
+    	    limbLen--;
+    	    limbPow = (limbPow / base) | 0;
+    	    var total = number.length - start;
+    	    var mod = total % limbLen;
+    	    var end = Math.min(total, total - mod) + start;
+    	    var word = 0;
+    	    for (var i = start; i < end; i += limbLen) {
+    	      word = parseBase(number, i, i + limbLen, base);
+    	      this.imuln(limbPow);
+    	      if (this.words[0] + word < 0x4000000) {
+    	        this.words[0] += word;
+    	      } else {
+    	        this._iaddn(word);
+    	      }
+    	    }
+    	    if (mod !== 0) {
+    	      var pow = 1;
+    	      word = parseBase(number, i, number.length, base);
+    	      for (i = 0; i < mod; i++) {
+    	        pow *= base;
+    	      }
+    	      this.imuln(pow);
+    	      if (this.words[0] + word < 0x4000000) {
+    	        this.words[0] += word;
+    	      } else {
+    	        this._iaddn(word);
+    	      }
+    	    }
+    	    this._strip();
+    	  };
+    	  BN.prototype.copy = function copy (dest) {
+    	    dest.words = new Array(this.length);
+    	    for (var i = 0; i < this.length; i++) {
+    	      dest.words[i] = this.words[i];
+    	    }
+    	    dest.length = this.length;
+    	    dest.negative = this.negative;
+    	    dest.red = this.red;
+    	  };
+    	  function move (dest, src) {
+    	    dest.words = src.words;
+    	    dest.length = src.length;
+    	    dest.negative = src.negative;
+    	    dest.red = src.red;
+    	  }
+    	  BN.prototype._move = function _move (dest) {
+    	    move(dest, this);
+    	  };
+    	  BN.prototype.clone = function clone () {
+    	    var r = new BN(null);
+    	    this.copy(r);
+    	    return r;
+    	  };
+    	  BN.prototype._expand = function _expand (size) {
+    	    while (this.length < size) {
+    	      this.words[this.length++] = 0;
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype._strip = function strip () {
+    	    while (this.length > 1 && this.words[this.length - 1] === 0) {
+    	      this.length--;
+    	    }
+    	    return this._normSign();
+    	  };
+    	  BN.prototype._normSign = function _normSign () {
+    	    if (this.length === 1 && this.words[0] === 0) {
+    	      this.negative = 0;
+    	    }
+    	    return this;
+    	  };
+    	  if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {
+    	    try {
+    	      BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;
+    	    } catch (e) {
+    	      BN.prototype.inspect = inspect;
+    	    }
+    	  } else {
+    	    BN.prototype.inspect = inspect;
+    	  }
+    	  function inspect () {
+    	    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
+    	  }
+    	  var zeros = [
+    	    '',
+    	    '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'
+    	  ];
+    	  var groupSizes = [
+    	    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
+    	  ];
+    	  var groupBases = [
+    	    0, 0,
+    	    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
+    	    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
+    	    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
+    	    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
+    	    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
+    	  ];
+    	  BN.prototype.toString = function toString (base, padding) {
+    	    base = base || 10;
+    	    padding = padding | 0 || 1;
+    	    var out;
+    	    if (base === 16 || base === 'hex') {
+    	      out = '';
+    	      var off = 0;
+    	      var carry = 0;
+    	      for (var i = 0; i < this.length; i++) {
+    	        var w = this.words[i];
+    	        var word = (((w << off) | carry) & 0xffffff).toString(16);
+    	        carry = (w >>> (24 - off)) & 0xffffff;
+    	        off += 2;
+    	        if (off >= 26) {
+    	          off -= 26;
+    	          i--;
+    	        }
+    	        if (carry !== 0 || i !== this.length - 1) {
+    	          out = zeros[6 - word.length] + word + out;
+    	        } else {
+    	          out = word + out;
+    	        }
+    	      }
+    	      if (carry !== 0) {
+    	        out = carry.toString(16) + out;
+    	      }
+    	      while (out.length % padding !== 0) {
+    	        out = '0' + out;
+    	      }
+    	      if (this.negative !== 0) {
+    	        out = '-' + out;
+    	      }
+    	      return out;
+    	    }
+    	    if (base === (base | 0) && base >= 2 && base <= 36) {
+    	      var groupSize = groupSizes[base];
+    	      var groupBase = groupBases[base];
+    	      out = '';
+    	      var c = this.clone();
+    	      c.negative = 0;
+    	      while (!c.isZero()) {
+    	        var r = c.modrn(groupBase).toString(base);
+    	        c = c.idivn(groupBase);
+    	        if (!c.isZero()) {
+    	          out = zeros[groupSize - r.length] + r + out;
+    	        } else {
+    	          out = r + out;
+    	        }
+    	      }
+    	      if (this.isZero()) {
+    	        out = '0' + out;
+    	      }
+    	      while (out.length % padding !== 0) {
+    	        out = '0' + out;
+    	      }
+    	      if (this.negative !== 0) {
+    	        out = '-' + out;
+    	      }
+    	      return out;
+    	    }
+    	    assert(false, 'Base should be between 2 and 36');
+    	  };
+    	  BN.prototype.toNumber = function toNumber () {
+    	    var ret = this.words[0];
+    	    if (this.length === 2) {
+    	      ret += this.words[1] * 0x4000000;
+    	    } else if (this.length === 3 && this.words[2] === 0x01) {
+    	      ret += 0x10000000000000 + (this.words[1] * 0x4000000);
+    	    } else if (this.length > 2) {
+    	      assert(false, 'Number can only safely store up to 53 bits');
+    	    }
+    	    return (this.negative !== 0) ? -ret : ret;
+    	  };
+    	  BN.prototype.toJSON = function toJSON () {
+    	    return this.toString(16, 2);
+    	  };
+    	  if (Buffer) {
+    	    BN.prototype.toBuffer = function toBuffer (endian, length) {
+    	      return this.toArrayLike(Buffer, endian, length);
+    	    };
+    	  }
+    	  BN.prototype.toArray = function toArray (endian, length) {
+    	    return this.toArrayLike(Array, endian, length);
+    	  };
+    	  var allocate = function allocate (ArrayType, size) {
+    	    if (ArrayType.allocUnsafe) {
+    	      return ArrayType.allocUnsafe(size);
+    	    }
+    	    return new ArrayType(size);
+    	  };
+    	  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
+    	    this._strip();
+    	    var byteLength = this.byteLength();
+    	    var reqLength = length || Math.max(1, byteLength);
+    	    assert(byteLength <= reqLength, 'byte array longer than desired length');
+    	    assert(reqLength > 0, 'Requested array length <= 0');
+    	    var res = allocate(ArrayType, reqLength);
+    	    var postfix = endian === 'le' ? 'LE' : 'BE';
+    	    this['_toArrayLike' + postfix](res, byteLength);
+    	    return res;
+    	  };
+    	  BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {
+    	    var position = 0;
+    	    var carry = 0;
+    	    for (var i = 0, shift = 0; i < this.length; i++) {
+    	      var word = (this.words[i] << shift) | carry;
+    	      res[position++] = word & 0xff;
+    	      if (position < res.length) {
+    	        res[position++] = (word >> 8) & 0xff;
+    	      }
+    	      if (position < res.length) {
+    	        res[position++] = (word >> 16) & 0xff;
+    	      }
+    	      if (shift === 6) {
+    	        if (position < res.length) {
+    	          res[position++] = (word >> 24) & 0xff;
+    	        }
+    	        carry = 0;
+    	        shift = 0;
+    	      } else {
+    	        carry = word >>> 24;
+    	        shift += 2;
+    	      }
+    	    }
+    	    if (position < res.length) {
+    	      res[position++] = carry;
+    	      while (position < res.length) {
+    	        res[position++] = 0;
+    	      }
+    	    }
+    	  };
+    	  BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {
+    	    var position = res.length - 1;
+    	    var carry = 0;
+    	    for (var i = 0, shift = 0; i < this.length; i++) {
+    	      var word = (this.words[i] << shift) | carry;
+    	      res[position--] = word & 0xff;
+    	      if (position >= 0) {
+    	        res[position--] = (word >> 8) & 0xff;
+    	      }
+    	      if (position >= 0) {
+    	        res[position--] = (word >> 16) & 0xff;
+    	      }
+    	      if (shift === 6) {
+    	        if (position >= 0) {
+    	          res[position--] = (word >> 24) & 0xff;
+    	        }
+    	        carry = 0;
+    	        shift = 0;
+    	      } else {
+    	        carry = word >>> 24;
+    	        shift += 2;
+    	      }
+    	    }
+    	    if (position >= 0) {
+    	      res[position--] = carry;
+    	      while (position >= 0) {
+    	        res[position--] = 0;
+    	      }
+    	    }
+    	  };
+    	  if (Math.clz32) {
+    	    BN.prototype._countBits = function _countBits (w) {
+    	      return 32 - Math.clz32(w);
+    	    };
+    	  } else {
+    	    BN.prototype._countBits = function _countBits (w) {
+    	      var t = w;
+    	      var r = 0;
+    	      if (t >= 0x1000) {
+    	        r += 13;
+    	        t >>>= 13;
+    	      }
+    	      if (t >= 0x40) {
+    	        r += 7;
+    	        t >>>= 7;
+    	      }
+    	      if (t >= 0x8) {
+    	        r += 4;
+    	        t >>>= 4;
+    	      }
+    	      if (t >= 0x02) {
+    	        r += 2;
+    	        t >>>= 2;
+    	      }
+    	      return r + t;
+    	    };
+    	  }
+    	  BN.prototype._zeroBits = function _zeroBits (w) {
+    	    if (w === 0) return 26;
+    	    var t = w;
+    	    var r = 0;
+    	    if ((t & 0x1fff) === 0) {
+    	      r += 13;
+    	      t >>>= 13;
+    	    }
+    	    if ((t & 0x7f) === 0) {
+    	      r += 7;
+    	      t >>>= 7;
+    	    }
+    	    if ((t & 0xf) === 0) {
+    	      r += 4;
+    	      t >>>= 4;
+    	    }
+    	    if ((t & 0x3) === 0) {
+    	      r += 2;
+    	      t >>>= 2;
+    	    }
+    	    if ((t & 0x1) === 0) {
+    	      r++;
+    	    }
+    	    return r;
+    	  };
+    	  BN.prototype.bitLength = function bitLength () {
+    	    var w = this.words[this.length - 1];
+    	    var hi = this._countBits(w);
+    	    return (this.length - 1) * 26 + hi;
+    	  };
+    	  function toBitArray (num) {
+    	    var w = new Array(num.bitLength());
+    	    for (var bit = 0; bit < w.length; bit++) {
+    	      var off = (bit / 26) | 0;
+    	      var wbit = bit % 26;
+    	      w[bit] = (num.words[off] >>> wbit) & 0x01;
+    	    }
+    	    return w;
+    	  }
+    	  BN.prototype.zeroBits = function zeroBits () {
+    	    if (this.isZero()) return 0;
+    	    var r = 0;
+    	    for (var i = 0; i < this.length; i++) {
+    	      var b = this._zeroBits(this.words[i]);
+    	      r += b;
+    	      if (b !== 26) break;
+    	    }
+    	    return r;
+    	  };
+    	  BN.prototype.byteLength = function byteLength () {
+    	    return Math.ceil(this.bitLength() / 8);
+    	  };
+    	  BN.prototype.toTwos = function toTwos (width) {
+    	    if (this.negative !== 0) {
+    	      return this.abs().inotn(width).iaddn(1);
+    	    }
+    	    return this.clone();
+    	  };
+    	  BN.prototype.fromTwos = function fromTwos (width) {
+    	    if (this.testn(width - 1)) {
+    	      return this.notn(width).iaddn(1).ineg();
+    	    }
+    	    return this.clone();
+    	  };
+    	  BN.prototype.isNeg = function isNeg () {
+    	    return this.negative !== 0;
+    	  };
+    	  BN.prototype.neg = function neg () {
+    	    return this.clone().ineg();
+    	  };
+    	  BN.prototype.ineg = function ineg () {
+    	    if (!this.isZero()) {
+    	      this.negative ^= 1;
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype.iuor = function iuor (num) {
+    	    while (this.length < num.length) {
+    	      this.words[this.length++] = 0;
+    	    }
+    	    for (var i = 0; i < num.length; i++) {
+    	      this.words[i] = this.words[i] | num.words[i];
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ior = function ior (num) {
+    	    assert((this.negative | num.negative) === 0);
+    	    return this.iuor(num);
+    	  };
+    	  BN.prototype.or = function or (num) {
+    	    if (this.length > num.length) return this.clone().ior(num);
+    	    return num.clone().ior(this);
+    	  };
+    	  BN.prototype.uor = function uor (num) {
+    	    if (this.length > num.length) return this.clone().iuor(num);
+    	    return num.clone().iuor(this);
+    	  };
+    	  BN.prototype.iuand = function iuand (num) {
+    	    var b;
+    	    if (this.length > num.length) {
+    	      b = num;
+    	    } else {
+    	      b = this;
+    	    }
+    	    for (var i = 0; i < b.length; i++) {
+    	      this.words[i] = this.words[i] & num.words[i];
+    	    }
+    	    this.length = b.length;
+    	    return this._strip();
+    	  };
+    	  BN.prototype.iand = function iand (num) {
+    	    assert((this.negative | num.negative) === 0);
+    	    return this.iuand(num);
+    	  };
+    	  BN.prototype.and = function and (num) {
+    	    if (this.length > num.length) return this.clone().iand(num);
+    	    return num.clone().iand(this);
+    	  };
+    	  BN.prototype.uand = function uand (num) {
+    	    if (this.length > num.length) return this.clone().iuand(num);
+    	    return num.clone().iuand(this);
+    	  };
+    	  BN.prototype.iuxor = function iuxor (num) {
+    	    var a;
+    	    var b;
+    	    if (this.length > num.length) {
+    	      a = this;
+    	      b = num;
+    	    } else {
+    	      a = num;
+    	      b = this;
+    	    }
+    	    for (var i = 0; i < b.length; i++) {
+    	      this.words[i] = a.words[i] ^ b.words[i];
+    	    }
+    	    if (this !== a) {
+    	      for (; i < a.length; i++) {
+    	        this.words[i] = a.words[i];
+    	      }
+    	    }
+    	    this.length = a.length;
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ixor = function ixor (num) {
+    	    assert((this.negative | num.negative) === 0);
+    	    return this.iuxor(num);
+    	  };
+    	  BN.prototype.xor = function xor (num) {
+    	    if (this.length > num.length) return this.clone().ixor(num);
+    	    return num.clone().ixor(this);
+    	  };
+    	  BN.prototype.uxor = function uxor (num) {
+    	    if (this.length > num.length) return this.clone().iuxor(num);
+    	    return num.clone().iuxor(this);
+    	  };
+    	  BN.prototype.inotn = function inotn (width) {
+    	    assert(typeof width === 'number' && width >= 0);
+    	    var bytesNeeded = Math.ceil(width / 26) | 0;
+    	    var bitsLeft = width % 26;
+    	    this._expand(bytesNeeded);
+    	    if (bitsLeft > 0) {
+    	      bytesNeeded--;
+    	    }
+    	    for (var i = 0; i < bytesNeeded; i++) {
+    	      this.words[i] = ~this.words[i] & 0x3ffffff;
+    	    }
+    	    if (bitsLeft > 0) {
+    	      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.notn = function notn (width) {
+    	    return this.clone().inotn(width);
+    	  };
+    	  BN.prototype.setn = function setn (bit, val) {
+    	    assert(typeof bit === 'number' && bit >= 0);
+    	    var off = (bit / 26) | 0;
+    	    var wbit = bit % 26;
+    	    this._expand(off + 1);
+    	    if (val) {
+    	      this.words[off] = this.words[off] | (1 << wbit);
+    	    } else {
+    	      this.words[off] = this.words[off] & ~(1 << wbit);
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.iadd = function iadd (num) {
+    	    var r;
+    	    if (this.negative !== 0 && num.negative === 0) {
+    	      this.negative = 0;
+    	      r = this.isub(num);
+    	      this.negative ^= 1;
+    	      return this._normSign();
+    	    } else if (this.negative === 0 && num.negative !== 0) {
+    	      num.negative = 0;
+    	      r = this.isub(num);
+    	      num.negative = 1;
+    	      return r._normSign();
+    	    }
+    	    var a, b;
+    	    if (this.length > num.length) {
+    	      a = this;
+    	      b = num;
+    	    } else {
+    	      a = num;
+    	      b = this;
+    	    }
+    	    var carry = 0;
+    	    for (var i = 0; i < b.length; i++) {
+    	      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
+    	      this.words[i] = r & 0x3ffffff;
+    	      carry = r >>> 26;
+    	    }
+    	    for (; carry !== 0 && i < a.length; i++) {
+    	      r = (a.words[i] | 0) + carry;
+    	      this.words[i] = r & 0x3ffffff;
+    	      carry = r >>> 26;
+    	    }
+    	    this.length = a.length;
+    	    if (carry !== 0) {
+    	      this.words[this.length] = carry;
+    	      this.length++;
+    	    } else if (a !== this) {
+    	      for (; i < a.length; i++) {
+    	        this.words[i] = a.words[i];
+    	      }
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype.add = function add (num) {
+    	    var res;
+    	    if (num.negative !== 0 && this.negative === 0) {
+    	      num.negative = 0;
+    	      res = this.sub(num);
+    	      num.negative ^= 1;
+    	      return res;
+    	    } else if (num.negative === 0 && this.negative !== 0) {
+    	      this.negative = 0;
+    	      res = num.sub(this);
+    	      this.negative = 1;
+    	      return res;
+    	    }
+    	    if (this.length > num.length) return this.clone().iadd(num);
+    	    return num.clone().iadd(this);
+    	  };
+    	  BN.prototype.isub = function isub (num) {
+    	    if (num.negative !== 0) {
+    	      num.negative = 0;
+    	      var r = this.iadd(num);
+    	      num.negative = 1;
+    	      return r._normSign();
+    	    } else if (this.negative !== 0) {
+    	      this.negative = 0;
+    	      this.iadd(num);
+    	      this.negative = 1;
+    	      return this._normSign();
+    	    }
+    	    var cmp = this.cmp(num);
+    	    if (cmp === 0) {
+    	      this.negative = 0;
+    	      this.length = 1;
+    	      this.words[0] = 0;
+    	      return this;
+    	    }
+    	    var a, b;
+    	    if (cmp > 0) {
+    	      a = this;
+    	      b = num;
+    	    } else {
+    	      a = num;
+    	      b = this;
+    	    }
+    	    var carry = 0;
+    	    for (var i = 0; i < b.length; i++) {
+    	      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
+    	      carry = r >> 26;
+    	      this.words[i] = r & 0x3ffffff;
+    	    }
+    	    for (; carry !== 0 && i < a.length; i++) {
+    	      r = (a.words[i] | 0) + carry;
+    	      carry = r >> 26;
+    	      this.words[i] = r & 0x3ffffff;
+    	    }
+    	    if (carry === 0 && i < a.length && a !== this) {
+    	      for (; i < a.length; i++) {
+    	        this.words[i] = a.words[i];
+    	      }
+    	    }
+    	    this.length = Math.max(this.length, i);
+    	    if (a !== this) {
+    	      this.negative = 1;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.sub = function sub (num) {
+    	    return this.clone().isub(num);
+    	  };
+    	  function smallMulTo (self, num, out) {
+    	    out.negative = num.negative ^ self.negative;
+    	    var len = (self.length + num.length) | 0;
+    	    out.length = len;
+    	    len = (len - 1) | 0;
+    	    var a = self.words[0] | 0;
+    	    var b = num.words[0] | 0;
+    	    var r = a * b;
+    	    var lo = r & 0x3ffffff;
+    	    var carry = (r / 0x4000000) | 0;
+    	    out.words[0] = lo;
+    	    for (var k = 1; k < len; k++) {
+    	      var ncarry = carry >>> 26;
+    	      var rword = carry & 0x3ffffff;
+    	      var maxJ = Math.min(k, num.length - 1);
+    	      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+    	        var i = (k - j) | 0;
+    	        a = self.words[i] | 0;
+    	        b = num.words[j] | 0;
+    	        r = a * b + rword;
+    	        ncarry += (r / 0x4000000) | 0;
+    	        rword = r & 0x3ffffff;
+    	      }
+    	      out.words[k] = rword | 0;
+    	      carry = ncarry | 0;
+    	    }
+    	    if (carry !== 0) {
+    	      out.words[k] = carry | 0;
+    	    } else {
+    	      out.length--;
+    	    }
+    	    return out._strip();
+    	  }
+    	  var comb10MulTo = function comb10MulTo (self, num, out) {
+    	    var a = self.words;
+    	    var b = num.words;
+    	    var o = out.words;
+    	    var c = 0;
+    	    var lo;
+    	    var mid;
+    	    var hi;
+    	    var a0 = a[0] | 0;
+    	    var al0 = a0 & 0x1fff;
+    	    var ah0 = a0 >>> 13;
+    	    var a1 = a[1] | 0;
+    	    var al1 = a1 & 0x1fff;
+    	    var ah1 = a1 >>> 13;
+    	    var a2 = a[2] | 0;
+    	    var al2 = a2 & 0x1fff;
+    	    var ah2 = a2 >>> 13;
+    	    var a3 = a[3] | 0;
+    	    var al3 = a3 & 0x1fff;
+    	    var ah3 = a3 >>> 13;
+    	    var a4 = a[4] | 0;
+    	    var al4 = a4 & 0x1fff;
+    	    var ah4 = a4 >>> 13;
+    	    var a5 = a[5] | 0;
+    	    var al5 = a5 & 0x1fff;
+    	    var ah5 = a5 >>> 13;
+    	    var a6 = a[6] | 0;
+    	    var al6 = a6 & 0x1fff;
+    	    var ah6 = a6 >>> 13;
+    	    var a7 = a[7] | 0;
+    	    var al7 = a7 & 0x1fff;
+    	    var ah7 = a7 >>> 13;
+    	    var a8 = a[8] | 0;
+    	    var al8 = a8 & 0x1fff;
+    	    var ah8 = a8 >>> 13;
+    	    var a9 = a[9] | 0;
+    	    var al9 = a9 & 0x1fff;
+    	    var ah9 = a9 >>> 13;
+    	    var b0 = b[0] | 0;
+    	    var bl0 = b0 & 0x1fff;
+    	    var bh0 = b0 >>> 13;
+    	    var b1 = b[1] | 0;
+    	    var bl1 = b1 & 0x1fff;
+    	    var bh1 = b1 >>> 13;
+    	    var b2 = b[2] | 0;
+    	    var bl2 = b2 & 0x1fff;
+    	    var bh2 = b2 >>> 13;
+    	    var b3 = b[3] | 0;
+    	    var bl3 = b3 & 0x1fff;
+    	    var bh3 = b3 >>> 13;
+    	    var b4 = b[4] | 0;
+    	    var bl4 = b4 & 0x1fff;
+    	    var bh4 = b4 >>> 13;
+    	    var b5 = b[5] | 0;
+    	    var bl5 = b5 & 0x1fff;
+    	    var bh5 = b5 >>> 13;
+    	    var b6 = b[6] | 0;
+    	    var bl6 = b6 & 0x1fff;
+    	    var bh6 = b6 >>> 13;
+    	    var b7 = b[7] | 0;
+    	    var bl7 = b7 & 0x1fff;
+    	    var bh7 = b7 >>> 13;
+    	    var b8 = b[8] | 0;
+    	    var bl8 = b8 & 0x1fff;
+    	    var bh8 = b8 >>> 13;
+    	    var b9 = b[9] | 0;
+    	    var bl9 = b9 & 0x1fff;
+    	    var bh9 = b9 >>> 13;
+    	    out.negative = self.negative ^ num.negative;
+    	    out.length = 19;
+    	    lo = Math.imul(al0, bl0);
+    	    mid = Math.imul(al0, bh0);
+    	    mid = (mid + Math.imul(ah0, bl0)) | 0;
+    	    hi = Math.imul(ah0, bh0);
+    	    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
+    	    w0 &= 0x3ffffff;
+    	    lo = Math.imul(al1, bl0);
+    	    mid = Math.imul(al1, bh0);
+    	    mid = (mid + Math.imul(ah1, bl0)) | 0;
+    	    hi = Math.imul(ah1, bh0);
+    	    lo = (lo + Math.imul(al0, bl1)) | 0;
+    	    mid = (mid + Math.imul(al0, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh1)) | 0;
+    	    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
+    	    w1 &= 0x3ffffff;
+    	    lo = Math.imul(al2, bl0);
+    	    mid = Math.imul(al2, bh0);
+    	    mid = (mid + Math.imul(ah2, bl0)) | 0;
+    	    hi = Math.imul(ah2, bh0);
+    	    lo = (lo + Math.imul(al1, bl1)) | 0;
+    	    mid = (mid + Math.imul(al1, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh1)) | 0;
+    	    lo = (lo + Math.imul(al0, bl2)) | 0;
+    	    mid = (mid + Math.imul(al0, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh2)) | 0;
+    	    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
+    	    w2 &= 0x3ffffff;
+    	    lo = Math.imul(al3, bl0);
+    	    mid = Math.imul(al3, bh0);
+    	    mid = (mid + Math.imul(ah3, bl0)) | 0;
+    	    hi = Math.imul(ah3, bh0);
+    	    lo = (lo + Math.imul(al2, bl1)) | 0;
+    	    mid = (mid + Math.imul(al2, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh1)) | 0;
+    	    lo = (lo + Math.imul(al1, bl2)) | 0;
+    	    mid = (mid + Math.imul(al1, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh2)) | 0;
+    	    lo = (lo + Math.imul(al0, bl3)) | 0;
+    	    mid = (mid + Math.imul(al0, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh3)) | 0;
+    	    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
+    	    w3 &= 0x3ffffff;
+    	    lo = Math.imul(al4, bl0);
+    	    mid = Math.imul(al4, bh0);
+    	    mid = (mid + Math.imul(ah4, bl0)) | 0;
+    	    hi = Math.imul(ah4, bh0);
+    	    lo = (lo + Math.imul(al3, bl1)) | 0;
+    	    mid = (mid + Math.imul(al3, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh1)) | 0;
+    	    lo = (lo + Math.imul(al2, bl2)) | 0;
+    	    mid = (mid + Math.imul(al2, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh2)) | 0;
+    	    lo = (lo + Math.imul(al1, bl3)) | 0;
+    	    mid = (mid + Math.imul(al1, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh3)) | 0;
+    	    lo = (lo + Math.imul(al0, bl4)) | 0;
+    	    mid = (mid + Math.imul(al0, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh4)) | 0;
+    	    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
+    	    w4 &= 0x3ffffff;
+    	    lo = Math.imul(al5, bl0);
+    	    mid = Math.imul(al5, bh0);
+    	    mid = (mid + Math.imul(ah5, bl0)) | 0;
+    	    hi = Math.imul(ah5, bh0);
+    	    lo = (lo + Math.imul(al4, bl1)) | 0;
+    	    mid = (mid + Math.imul(al4, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh1)) | 0;
+    	    lo = (lo + Math.imul(al3, bl2)) | 0;
+    	    mid = (mid + Math.imul(al3, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh2)) | 0;
+    	    lo = (lo + Math.imul(al2, bl3)) | 0;
+    	    mid = (mid + Math.imul(al2, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh3)) | 0;
+    	    lo = (lo + Math.imul(al1, bl4)) | 0;
+    	    mid = (mid + Math.imul(al1, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh4)) | 0;
+    	    lo = (lo + Math.imul(al0, bl5)) | 0;
+    	    mid = (mid + Math.imul(al0, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh5)) | 0;
+    	    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
+    	    w5 &= 0x3ffffff;
+    	    lo = Math.imul(al6, bl0);
+    	    mid = Math.imul(al6, bh0);
+    	    mid = (mid + Math.imul(ah6, bl0)) | 0;
+    	    hi = Math.imul(ah6, bh0);
+    	    lo = (lo + Math.imul(al5, bl1)) | 0;
+    	    mid = (mid + Math.imul(al5, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh1)) | 0;
+    	    lo = (lo + Math.imul(al4, bl2)) | 0;
+    	    mid = (mid + Math.imul(al4, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh2)) | 0;
+    	    lo = (lo + Math.imul(al3, bl3)) | 0;
+    	    mid = (mid + Math.imul(al3, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh3)) | 0;
+    	    lo = (lo + Math.imul(al2, bl4)) | 0;
+    	    mid = (mid + Math.imul(al2, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh4)) | 0;
+    	    lo = (lo + Math.imul(al1, bl5)) | 0;
+    	    mid = (mid + Math.imul(al1, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh5)) | 0;
+    	    lo = (lo + Math.imul(al0, bl6)) | 0;
+    	    mid = (mid + Math.imul(al0, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh6)) | 0;
+    	    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
+    	    w6 &= 0x3ffffff;
+    	    lo = Math.imul(al7, bl0);
+    	    mid = Math.imul(al7, bh0);
+    	    mid = (mid + Math.imul(ah7, bl0)) | 0;
+    	    hi = Math.imul(ah7, bh0);
+    	    lo = (lo + Math.imul(al6, bl1)) | 0;
+    	    mid = (mid + Math.imul(al6, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh1)) | 0;
+    	    lo = (lo + Math.imul(al5, bl2)) | 0;
+    	    mid = (mid + Math.imul(al5, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh2)) | 0;
+    	    lo = (lo + Math.imul(al4, bl3)) | 0;
+    	    mid = (mid + Math.imul(al4, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh3)) | 0;
+    	    lo = (lo + Math.imul(al3, bl4)) | 0;
+    	    mid = (mid + Math.imul(al3, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh4)) | 0;
+    	    lo = (lo + Math.imul(al2, bl5)) | 0;
+    	    mid = (mid + Math.imul(al2, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh5)) | 0;
+    	    lo = (lo + Math.imul(al1, bl6)) | 0;
+    	    mid = (mid + Math.imul(al1, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh6)) | 0;
+    	    lo = (lo + Math.imul(al0, bl7)) | 0;
+    	    mid = (mid + Math.imul(al0, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh7)) | 0;
+    	    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
+    	    w7 &= 0x3ffffff;
+    	    lo = Math.imul(al8, bl0);
+    	    mid = Math.imul(al8, bh0);
+    	    mid = (mid + Math.imul(ah8, bl0)) | 0;
+    	    hi = Math.imul(ah8, bh0);
+    	    lo = (lo + Math.imul(al7, bl1)) | 0;
+    	    mid = (mid + Math.imul(al7, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh1)) | 0;
+    	    lo = (lo + Math.imul(al6, bl2)) | 0;
+    	    mid = (mid + Math.imul(al6, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh2)) | 0;
+    	    lo = (lo + Math.imul(al5, bl3)) | 0;
+    	    mid = (mid + Math.imul(al5, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh3)) | 0;
+    	    lo = (lo + Math.imul(al4, bl4)) | 0;
+    	    mid = (mid + Math.imul(al4, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh4)) | 0;
+    	    lo = (lo + Math.imul(al3, bl5)) | 0;
+    	    mid = (mid + Math.imul(al3, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh5)) | 0;
+    	    lo = (lo + Math.imul(al2, bl6)) | 0;
+    	    mid = (mid + Math.imul(al2, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh6)) | 0;
+    	    lo = (lo + Math.imul(al1, bl7)) | 0;
+    	    mid = (mid + Math.imul(al1, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh7)) | 0;
+    	    lo = (lo + Math.imul(al0, bl8)) | 0;
+    	    mid = (mid + Math.imul(al0, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh8)) | 0;
+    	    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
+    	    w8 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl0);
+    	    mid = Math.imul(al9, bh0);
+    	    mid = (mid + Math.imul(ah9, bl0)) | 0;
+    	    hi = Math.imul(ah9, bh0);
+    	    lo = (lo + Math.imul(al8, bl1)) | 0;
+    	    mid = (mid + Math.imul(al8, bh1)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl1)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh1)) | 0;
+    	    lo = (lo + Math.imul(al7, bl2)) | 0;
+    	    mid = (mid + Math.imul(al7, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh2)) | 0;
+    	    lo = (lo + Math.imul(al6, bl3)) | 0;
+    	    mid = (mid + Math.imul(al6, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh3)) | 0;
+    	    lo = (lo + Math.imul(al5, bl4)) | 0;
+    	    mid = (mid + Math.imul(al5, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh4)) | 0;
+    	    lo = (lo + Math.imul(al4, bl5)) | 0;
+    	    mid = (mid + Math.imul(al4, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh5)) | 0;
+    	    lo = (lo + Math.imul(al3, bl6)) | 0;
+    	    mid = (mid + Math.imul(al3, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh6)) | 0;
+    	    lo = (lo + Math.imul(al2, bl7)) | 0;
+    	    mid = (mid + Math.imul(al2, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh7)) | 0;
+    	    lo = (lo + Math.imul(al1, bl8)) | 0;
+    	    mid = (mid + Math.imul(al1, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh8)) | 0;
+    	    lo = (lo + Math.imul(al0, bl9)) | 0;
+    	    mid = (mid + Math.imul(al0, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah0, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah0, bh9)) | 0;
+    	    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
+    	    w9 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl1);
+    	    mid = Math.imul(al9, bh1);
+    	    mid = (mid + Math.imul(ah9, bl1)) | 0;
+    	    hi = Math.imul(ah9, bh1);
+    	    lo = (lo + Math.imul(al8, bl2)) | 0;
+    	    mid = (mid + Math.imul(al8, bh2)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl2)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh2)) | 0;
+    	    lo = (lo + Math.imul(al7, bl3)) | 0;
+    	    mid = (mid + Math.imul(al7, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh3)) | 0;
+    	    lo = (lo + Math.imul(al6, bl4)) | 0;
+    	    mid = (mid + Math.imul(al6, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh4)) | 0;
+    	    lo = (lo + Math.imul(al5, bl5)) | 0;
+    	    mid = (mid + Math.imul(al5, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh5)) | 0;
+    	    lo = (lo + Math.imul(al4, bl6)) | 0;
+    	    mid = (mid + Math.imul(al4, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh6)) | 0;
+    	    lo = (lo + Math.imul(al3, bl7)) | 0;
+    	    mid = (mid + Math.imul(al3, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh7)) | 0;
+    	    lo = (lo + Math.imul(al2, bl8)) | 0;
+    	    mid = (mid + Math.imul(al2, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh8)) | 0;
+    	    lo = (lo + Math.imul(al1, bl9)) | 0;
+    	    mid = (mid + Math.imul(al1, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah1, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah1, bh9)) | 0;
+    	    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
+    	    w10 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl2);
+    	    mid = Math.imul(al9, bh2);
+    	    mid = (mid + Math.imul(ah9, bl2)) | 0;
+    	    hi = Math.imul(ah9, bh2);
+    	    lo = (lo + Math.imul(al8, bl3)) | 0;
+    	    mid = (mid + Math.imul(al8, bh3)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl3)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh3)) | 0;
+    	    lo = (lo + Math.imul(al7, bl4)) | 0;
+    	    mid = (mid + Math.imul(al7, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh4)) | 0;
+    	    lo = (lo + Math.imul(al6, bl5)) | 0;
+    	    mid = (mid + Math.imul(al6, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh5)) | 0;
+    	    lo = (lo + Math.imul(al5, bl6)) | 0;
+    	    mid = (mid + Math.imul(al5, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh6)) | 0;
+    	    lo = (lo + Math.imul(al4, bl7)) | 0;
+    	    mid = (mid + Math.imul(al4, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh7)) | 0;
+    	    lo = (lo + Math.imul(al3, bl8)) | 0;
+    	    mid = (mid + Math.imul(al3, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh8)) | 0;
+    	    lo = (lo + Math.imul(al2, bl9)) | 0;
+    	    mid = (mid + Math.imul(al2, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah2, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah2, bh9)) | 0;
+    	    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
+    	    w11 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl3);
+    	    mid = Math.imul(al9, bh3);
+    	    mid = (mid + Math.imul(ah9, bl3)) | 0;
+    	    hi = Math.imul(ah9, bh3);
+    	    lo = (lo + Math.imul(al8, bl4)) | 0;
+    	    mid = (mid + Math.imul(al8, bh4)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl4)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh4)) | 0;
+    	    lo = (lo + Math.imul(al7, bl5)) | 0;
+    	    mid = (mid + Math.imul(al7, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh5)) | 0;
+    	    lo = (lo + Math.imul(al6, bl6)) | 0;
+    	    mid = (mid + Math.imul(al6, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh6)) | 0;
+    	    lo = (lo + Math.imul(al5, bl7)) | 0;
+    	    mid = (mid + Math.imul(al5, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh7)) | 0;
+    	    lo = (lo + Math.imul(al4, bl8)) | 0;
+    	    mid = (mid + Math.imul(al4, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh8)) | 0;
+    	    lo = (lo + Math.imul(al3, bl9)) | 0;
+    	    mid = (mid + Math.imul(al3, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah3, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah3, bh9)) | 0;
+    	    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
+    	    w12 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl4);
+    	    mid = Math.imul(al9, bh4);
+    	    mid = (mid + Math.imul(ah9, bl4)) | 0;
+    	    hi = Math.imul(ah9, bh4);
+    	    lo = (lo + Math.imul(al8, bl5)) | 0;
+    	    mid = (mid + Math.imul(al8, bh5)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl5)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh5)) | 0;
+    	    lo = (lo + Math.imul(al7, bl6)) | 0;
+    	    mid = (mid + Math.imul(al7, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh6)) | 0;
+    	    lo = (lo + Math.imul(al6, bl7)) | 0;
+    	    mid = (mid + Math.imul(al6, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh7)) | 0;
+    	    lo = (lo + Math.imul(al5, bl8)) | 0;
+    	    mid = (mid + Math.imul(al5, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh8)) | 0;
+    	    lo = (lo + Math.imul(al4, bl9)) | 0;
+    	    mid = (mid + Math.imul(al4, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah4, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah4, bh9)) | 0;
+    	    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
+    	    w13 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl5);
+    	    mid = Math.imul(al9, bh5);
+    	    mid = (mid + Math.imul(ah9, bl5)) | 0;
+    	    hi = Math.imul(ah9, bh5);
+    	    lo = (lo + Math.imul(al8, bl6)) | 0;
+    	    mid = (mid + Math.imul(al8, bh6)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl6)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh6)) | 0;
+    	    lo = (lo + Math.imul(al7, bl7)) | 0;
+    	    mid = (mid + Math.imul(al7, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh7)) | 0;
+    	    lo = (lo + Math.imul(al6, bl8)) | 0;
+    	    mid = (mid + Math.imul(al6, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh8)) | 0;
+    	    lo = (lo + Math.imul(al5, bl9)) | 0;
+    	    mid = (mid + Math.imul(al5, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah5, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah5, bh9)) | 0;
+    	    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
+    	    w14 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl6);
+    	    mid = Math.imul(al9, bh6);
+    	    mid = (mid + Math.imul(ah9, bl6)) | 0;
+    	    hi = Math.imul(ah9, bh6);
+    	    lo = (lo + Math.imul(al8, bl7)) | 0;
+    	    mid = (mid + Math.imul(al8, bh7)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl7)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh7)) | 0;
+    	    lo = (lo + Math.imul(al7, bl8)) | 0;
+    	    mid = (mid + Math.imul(al7, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh8)) | 0;
+    	    lo = (lo + Math.imul(al6, bl9)) | 0;
+    	    mid = (mid + Math.imul(al6, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah6, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah6, bh9)) | 0;
+    	    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
+    	    w15 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl7);
+    	    mid = Math.imul(al9, bh7);
+    	    mid = (mid + Math.imul(ah9, bl7)) | 0;
+    	    hi = Math.imul(ah9, bh7);
+    	    lo = (lo + Math.imul(al8, bl8)) | 0;
+    	    mid = (mid + Math.imul(al8, bh8)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl8)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh8)) | 0;
+    	    lo = (lo + Math.imul(al7, bl9)) | 0;
+    	    mid = (mid + Math.imul(al7, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah7, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah7, bh9)) | 0;
+    	    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
+    	    w16 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl8);
+    	    mid = Math.imul(al9, bh8);
+    	    mid = (mid + Math.imul(ah9, bl8)) | 0;
+    	    hi = Math.imul(ah9, bh8);
+    	    lo = (lo + Math.imul(al8, bl9)) | 0;
+    	    mid = (mid + Math.imul(al8, bh9)) | 0;
+    	    mid = (mid + Math.imul(ah8, bl9)) | 0;
+    	    hi = (hi + Math.imul(ah8, bh9)) | 0;
+    	    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
+    	    w17 &= 0x3ffffff;
+    	    lo = Math.imul(al9, bl9);
+    	    mid = Math.imul(al9, bh9);
+    	    mid = (mid + Math.imul(ah9, bl9)) | 0;
+    	    hi = Math.imul(ah9, bh9);
+    	    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+    	    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
+    	    w18 &= 0x3ffffff;
+    	    o[0] = w0;
+    	    o[1] = w1;
+    	    o[2] = w2;
+    	    o[3] = w3;
+    	    o[4] = w4;
+    	    o[5] = w5;
+    	    o[6] = w6;
+    	    o[7] = w7;
+    	    o[8] = w8;
+    	    o[9] = w9;
+    	    o[10] = w10;
+    	    o[11] = w11;
+    	    o[12] = w12;
+    	    o[13] = w13;
+    	    o[14] = w14;
+    	    o[15] = w15;
+    	    o[16] = w16;
+    	    o[17] = w17;
+    	    o[18] = w18;
+    	    if (c !== 0) {
+    	      o[19] = c;
+    	      out.length++;
+    	    }
+    	    return out;
+    	  };
+    	  if (!Math.imul) {
+    	    comb10MulTo = smallMulTo;
+    	  }
+    	  function bigMulTo (self, num, out) {
+    	    out.negative = num.negative ^ self.negative;
+    	    out.length = self.length + num.length;
+    	    var carry = 0;
+    	    var hncarry = 0;
+    	    for (var k = 0; k < out.length - 1; k++) {
+    	      var ncarry = hncarry;
+    	      hncarry = 0;
+    	      var rword = carry & 0x3ffffff;
+    	      var maxJ = Math.min(k, num.length - 1);
+    	      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+    	        var i = k - j;
+    	        var a = self.words[i] | 0;
+    	        var b = num.words[j] | 0;
+    	        var r = a * b;
+    	        var lo = r & 0x3ffffff;
+    	        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
+    	        lo = (lo + rword) | 0;
+    	        rword = lo & 0x3ffffff;
+    	        ncarry = (ncarry + (lo >>> 26)) | 0;
+    	        hncarry += ncarry >>> 26;
+    	        ncarry &= 0x3ffffff;
+    	      }
+    	      out.words[k] = rword;
+    	      carry = ncarry;
+    	      ncarry = hncarry;
+    	    }
+    	    if (carry !== 0) {
+    	      out.words[k] = carry;
+    	    } else {
+    	      out.length--;
+    	    }
+    	    return out._strip();
+    	  }
+    	  function jumboMulTo (self, num, out) {
+    	    return bigMulTo(self, num, out);
+    	  }
+    	  BN.prototype.mulTo = function mulTo (num, out) {
+    	    var res;
+    	    var len = this.length + num.length;
+    	    if (this.length === 10 && num.length === 10) {
+    	      res = comb10MulTo(this, num, out);
+    	    } else if (len < 63) {
+    	      res = smallMulTo(this, num, out);
+    	    } else if (len < 1024) {
+    	      res = bigMulTo(this, num, out);
+    	    } else {
+    	      res = jumboMulTo(this, num, out);
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.mul = function mul (num) {
+    	    var out = new BN(null);
+    	    out.words = new Array(this.length + num.length);
+    	    return this.mulTo(num, out);
+    	  };
+    	  BN.prototype.mulf = function mulf (num) {
+    	    var out = new BN(null);
+    	    out.words = new Array(this.length + num.length);
+    	    return jumboMulTo(this, num, out);
+    	  };
+    	  BN.prototype.imul = function imul (num) {
+    	    return this.clone().mulTo(num, this);
+    	  };
+    	  BN.prototype.imuln = function imuln (num) {
+    	    var isNegNum = num < 0;
+    	    if (isNegNum) num = -num;
+    	    assert(typeof num === 'number');
+    	    assert(num < 0x4000000);
+    	    var carry = 0;
+    	    for (var i = 0; i < this.length; i++) {
+    	      var w = (this.words[i] | 0) * num;
+    	      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
+    	      carry >>= 26;
+    	      carry += (w / 0x4000000) | 0;
+    	      carry += lo >>> 26;
+    	      this.words[i] = lo & 0x3ffffff;
+    	    }
+    	    if (carry !== 0) {
+    	      this.words[i] = carry;
+    	      this.length++;
+    	    }
+    	    return isNegNum ? this.ineg() : this;
+    	  };
+    	  BN.prototype.muln = function muln (num) {
+    	    return this.clone().imuln(num);
+    	  };
+    	  BN.prototype.sqr = function sqr () {
+    	    return this.mul(this);
+    	  };
+    	  BN.prototype.isqr = function isqr () {
+    	    return this.imul(this.clone());
+    	  };
+    	  BN.prototype.pow = function pow (num) {
+    	    var w = toBitArray(num);
+    	    if (w.length === 0) return new BN(1);
+    	    var res = this;
+    	    for (var i = 0; i < w.length; i++, res = res.sqr()) {
+    	      if (w[i] !== 0) break;
+    	    }
+    	    if (++i < w.length) {
+    	      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
+    	        if (w[i] === 0) continue;
+    	        res = res.mul(q);
+    	      }
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.iushln = function iushln (bits) {
+    	    assert(typeof bits === 'number' && bits >= 0);
+    	    var r = bits % 26;
+    	    var s = (bits - r) / 26;
+    	    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
+    	    var i;
+    	    if (r !== 0) {
+    	      var carry = 0;
+    	      for (i = 0; i < this.length; i++) {
+    	        var newCarry = this.words[i] & carryMask;
+    	        var c = ((this.words[i] | 0) - newCarry) << r;
+    	        this.words[i] = c | carry;
+    	        carry = newCarry >>> (26 - r);
+    	      }
+    	      if (carry) {
+    	        this.words[i] = carry;
+    	        this.length++;
+    	      }
+    	    }
+    	    if (s !== 0) {
+    	      for (i = this.length - 1; i >= 0; i--) {
+    	        this.words[i + s] = this.words[i];
+    	      }
+    	      for (i = 0; i < s; i++) {
+    	        this.words[i] = 0;
+    	      }
+    	      this.length += s;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ishln = function ishln (bits) {
+    	    assert(this.negative === 0);
+    	    return this.iushln(bits);
+    	  };
+    	  BN.prototype.iushrn = function iushrn (bits, hint, extended) {
+    	    assert(typeof bits === 'number' && bits >= 0);
+    	    var h;
+    	    if (hint) {
+    	      h = (hint - (hint % 26)) / 26;
+    	    } else {
+    	      h = 0;
+    	    }
+    	    var r = bits % 26;
+    	    var s = Math.min((bits - r) / 26, this.length);
+    	    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+    	    var maskedWords = extended;
+    	    h -= s;
+    	    h = Math.max(0, h);
+    	    if (maskedWords) {
+    	      for (var i = 0; i < s; i++) {
+    	        maskedWords.words[i] = this.words[i];
+    	      }
+    	      maskedWords.length = s;
+    	    }
+    	    if (s === 0) ; else if (this.length > s) {
+    	      this.length -= s;
+    	      for (i = 0; i < this.length; i++) {
+    	        this.words[i] = this.words[i + s];
+    	      }
+    	    } else {
+    	      this.words[0] = 0;
+    	      this.length = 1;
+    	    }
+    	    var carry = 0;
+    	    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
+    	      var word = this.words[i] | 0;
+    	      this.words[i] = (carry << (26 - r)) | (word >>> r);
+    	      carry = word & mask;
+    	    }
+    	    if (maskedWords && carry !== 0) {
+    	      maskedWords.words[maskedWords.length++] = carry;
+    	    }
+    	    if (this.length === 0) {
+    	      this.words[0] = 0;
+    	      this.length = 1;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.ishrn = function ishrn (bits, hint, extended) {
+    	    assert(this.negative === 0);
+    	    return this.iushrn(bits, hint, extended);
+    	  };
+    	  BN.prototype.shln = function shln (bits) {
+    	    return this.clone().ishln(bits);
+    	  };
+    	  BN.prototype.ushln = function ushln (bits) {
+    	    return this.clone().iushln(bits);
+    	  };
+    	  BN.prototype.shrn = function shrn (bits) {
+    	    return this.clone().ishrn(bits);
+    	  };
+    	  BN.prototype.ushrn = function ushrn (bits) {
+    	    return this.clone().iushrn(bits);
+    	  };
+    	  BN.prototype.testn = function testn (bit) {
+    	    assert(typeof bit === 'number' && bit >= 0);
+    	    var r = bit % 26;
+    	    var s = (bit - r) / 26;
+    	    var q = 1 << r;
+    	    if (this.length <= s) return false;
+    	    var w = this.words[s];
+    	    return !!(w & q);
+    	  };
+    	  BN.prototype.imaskn = function imaskn (bits) {
+    	    assert(typeof bits === 'number' && bits >= 0);
+    	    var r = bits % 26;
+    	    var s = (bits - r) / 26;
+    	    assert(this.negative === 0, 'imaskn works only with positive numbers');
+    	    if (this.length <= s) {
+    	      return this;
+    	    }
+    	    if (r !== 0) {
+    	      s++;
+    	    }
+    	    this.length = Math.min(s, this.length);
+    	    if (r !== 0) {
+    	      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+    	      this.words[this.length - 1] &= mask;
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.maskn = function maskn (bits) {
+    	    return this.clone().imaskn(bits);
+    	  };
+    	  BN.prototype.iaddn = function iaddn (num) {
+    	    assert(typeof num === 'number');
+    	    assert(num < 0x4000000);
+    	    if (num < 0) return this.isubn(-num);
+    	    if (this.negative !== 0) {
+    	      if (this.length === 1 && (this.words[0] | 0) <= num) {
+    	        this.words[0] = num - (this.words[0] | 0);
+    	        this.negative = 0;
+    	        return this;
+    	      }
+    	      this.negative = 0;
+    	      this.isubn(num);
+    	      this.negative = 1;
+    	      return this;
+    	    }
+    	    return this._iaddn(num);
+    	  };
+    	  BN.prototype._iaddn = function _iaddn (num) {
+    	    this.words[0] += num;
+    	    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
+    	      this.words[i] -= 0x4000000;
+    	      if (i === this.length - 1) {
+    	        this.words[i + 1] = 1;
+    	      } else {
+    	        this.words[i + 1]++;
+    	      }
+    	    }
+    	    this.length = Math.max(this.length, i + 1);
+    	    return this;
+    	  };
+    	  BN.prototype.isubn = function isubn (num) {
+    	    assert(typeof num === 'number');
+    	    assert(num < 0x4000000);
+    	    if (num < 0) return this.iaddn(-num);
+    	    if (this.negative !== 0) {
+    	      this.negative = 0;
+    	      this.iaddn(num);
+    	      this.negative = 1;
+    	      return this;
+    	    }
+    	    this.words[0] -= num;
+    	    if (this.length === 1 && this.words[0] < 0) {
+    	      this.words[0] = -this.words[0];
+    	      this.negative = 1;
+    	    } else {
+    	      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
+    	        this.words[i] += 0x4000000;
+    	        this.words[i + 1] -= 1;
+    	      }
+    	    }
+    	    return this._strip();
+    	  };
+    	  BN.prototype.addn = function addn (num) {
+    	    return this.clone().iaddn(num);
+    	  };
+    	  BN.prototype.subn = function subn (num) {
+    	    return this.clone().isubn(num);
+    	  };
+    	  BN.prototype.iabs = function iabs () {
+    	    this.negative = 0;
+    	    return this;
+    	  };
+    	  BN.prototype.abs = function abs () {
+    	    return this.clone().iabs();
+    	  };
+    	  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
+    	    var len = num.length + shift;
+    	    var i;
+    	    this._expand(len);
+    	    var w;
+    	    var carry = 0;
+    	    for (i = 0; i < num.length; i++) {
+    	      w = (this.words[i + shift] | 0) + carry;
+    	      var right = (num.words[i] | 0) * mul;
+    	      w -= right & 0x3ffffff;
+    	      carry = (w >> 26) - ((right / 0x4000000) | 0);
+    	      this.words[i + shift] = w & 0x3ffffff;
+    	    }
+    	    for (; i < this.length - shift; i++) {
+    	      w = (this.words[i + shift] | 0) + carry;
+    	      carry = w >> 26;
+    	      this.words[i + shift] = w & 0x3ffffff;
+    	    }
+    	    if (carry === 0) return this._strip();
+    	    assert(carry === -1);
+    	    carry = 0;
+    	    for (i = 0; i < this.length; i++) {
+    	      w = -(this.words[i] | 0) + carry;
+    	      carry = w >> 26;
+    	      this.words[i] = w & 0x3ffffff;
+    	    }
+    	    this.negative = 1;
+    	    return this._strip();
+    	  };
+    	  BN.prototype._wordDiv = function _wordDiv (num, mode) {
+    	    var shift = this.length - num.length;
+    	    var a = this.clone();
+    	    var b = num;
+    	    var bhi = b.words[b.length - 1] | 0;
+    	    var bhiBits = this._countBits(bhi);
+    	    shift = 26 - bhiBits;
+    	    if (shift !== 0) {
+    	      b = b.ushln(shift);
+    	      a.iushln(shift);
+    	      bhi = b.words[b.length - 1] | 0;
+    	    }
+    	    var m = a.length - b.length;
+    	    var q;
+    	    if (mode !== 'mod') {
+    	      q = new BN(null);
+    	      q.length = m + 1;
+    	      q.words = new Array(q.length);
+    	      for (var i = 0; i < q.length; i++) {
+    	        q.words[i] = 0;
+    	      }
+    	    }
+    	    var diff = a.clone()._ishlnsubmul(b, 1, m);
+    	    if (diff.negative === 0) {
+    	      a = diff;
+    	      if (q) {
+    	        q.words[m] = 1;
+    	      }
+    	    }
+    	    for (var j = m - 1; j >= 0; j--) {
+    	      var qj = (a.words[b.length + j] | 0) * 0x4000000 +
+    	        (a.words[b.length + j - 1] | 0);
+    	      qj = Math.min((qj / bhi) | 0, 0x3ffffff);
+    	      a._ishlnsubmul(b, qj, j);
+    	      while (a.negative !== 0) {
+    	        qj--;
+    	        a.negative = 0;
+    	        a._ishlnsubmul(b, 1, j);
+    	        if (!a.isZero()) {
+    	          a.negative ^= 1;
+    	        }
+    	      }
+    	      if (q) {
+    	        q.words[j] = qj;
+    	      }
+    	    }
+    	    if (q) {
+    	      q._strip();
+    	    }
+    	    a._strip();
+    	    if (mode !== 'div' && shift !== 0) {
+    	      a.iushrn(shift);
+    	    }
+    	    return {
+    	      div: q || null,
+    	      mod: a
+    	    };
+    	  };
+    	  BN.prototype.divmod = function divmod (num, mode, positive) {
+    	    assert(!num.isZero());
+    	    if (this.isZero()) {
+    	      return {
+    	        div: new BN(0),
+    	        mod: new BN(0)
+    	      };
+    	    }
+    	    var div, mod, res;
+    	    if (this.negative !== 0 && num.negative === 0) {
+    	      res = this.neg().divmod(num, mode);
+    	      if (mode !== 'mod') {
+    	        div = res.div.neg();
+    	      }
+    	      if (mode !== 'div') {
+    	        mod = res.mod.neg();
+    	        if (positive && mod.negative !== 0) {
+    	          mod.iadd(num);
+    	        }
+    	      }
+    	      return {
+    	        div: div,
+    	        mod: mod
+    	      };
+    	    }
+    	    if (this.negative === 0 && num.negative !== 0) {
+    	      res = this.divmod(num.neg(), mode);
+    	      if (mode !== 'mod') {
+    	        div = res.div.neg();
+    	      }
+    	      return {
+    	        div: div,
+    	        mod: res.mod
+    	      };
+    	    }
+    	    if ((this.negative & num.negative) !== 0) {
+    	      res = this.neg().divmod(num.neg(), mode);
+    	      if (mode !== 'div') {
+    	        mod = res.mod.neg();
+    	        if (positive && mod.negative !== 0) {
+    	          mod.isub(num);
+    	        }
+    	      }
+    	      return {
+    	        div: res.div,
+    	        mod: mod
+    	      };
+    	    }
+    	    if (num.length > this.length || this.cmp(num) < 0) {
+    	      return {
+    	        div: new BN(0),
+    	        mod: this
+    	      };
+    	    }
+    	    if (num.length === 1) {
+    	      if (mode === 'div') {
+    	        return {
+    	          div: this.divn(num.words[0]),
+    	          mod: null
+    	        };
+    	      }
+    	      if (mode === 'mod') {
+    	        return {
+    	          div: null,
+    	          mod: new BN(this.modrn(num.words[0]))
+    	        };
+    	      }
+    	      return {
+    	        div: this.divn(num.words[0]),
+    	        mod: new BN(this.modrn(num.words[0]))
+    	      };
+    	    }
+    	    return this._wordDiv(num, mode);
+    	  };
+    	  BN.prototype.div = function div (num) {
+    	    return this.divmod(num, 'div', false).div;
+    	  };
+    	  BN.prototype.mod = function mod (num) {
+    	    return this.divmod(num, 'mod', false).mod;
+    	  };
+    	  BN.prototype.umod = function umod (num) {
+    	    return this.divmod(num, 'mod', true).mod;
+    	  };
+    	  BN.prototype.divRound = function divRound (num) {
+    	    var dm = this.divmod(num);
+    	    if (dm.mod.isZero()) return dm.div;
+    	    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+    	    var half = num.ushrn(1);
+    	    var r2 = num.andln(1);
+    	    var cmp = mod.cmp(half);
+    	    if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;
+    	    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+    	  };
+    	  BN.prototype.modrn = function modrn (num) {
+    	    var isNegNum = num < 0;
+    	    if (isNegNum) num = -num;
+    	    assert(num <= 0x3ffffff);
+    	    var p = (1 << 26) % num;
+    	    var acc = 0;
+    	    for (var i = this.length - 1; i >= 0; i--) {
+    	      acc = (p * acc + (this.words[i] | 0)) % num;
+    	    }
+    	    return isNegNum ? -acc : acc;
+    	  };
+    	  BN.prototype.modn = function modn (num) {
+    	    return this.modrn(num);
+    	  };
+    	  BN.prototype.idivn = function idivn (num) {
+    	    var isNegNum = num < 0;
+    	    if (isNegNum) num = -num;
+    	    assert(num <= 0x3ffffff);
+    	    var carry = 0;
+    	    for (var i = this.length - 1; i >= 0; i--) {
+    	      var w = (this.words[i] | 0) + carry * 0x4000000;
+    	      this.words[i] = (w / num) | 0;
+    	      carry = w % num;
+    	    }
+    	    this._strip();
+    	    return isNegNum ? this.ineg() : this;
+    	  };
+    	  BN.prototype.divn = function divn (num) {
+    	    return this.clone().idivn(num);
+    	  };
+    	  BN.prototype.egcd = function egcd (p) {
+    	    assert(p.negative === 0);
+    	    assert(!p.isZero());
+    	    var x = this;
+    	    var y = p.clone();
+    	    if (x.negative !== 0) {
+    	      x = x.umod(p);
+    	    } else {
+    	      x = x.clone();
+    	    }
+    	    var A = new BN(1);
+    	    var B = new BN(0);
+    	    var C = new BN(0);
+    	    var D = new BN(1);
+    	    var g = 0;
+    	    while (x.isEven() && y.isEven()) {
+    	      x.iushrn(1);
+    	      y.iushrn(1);
+    	      ++g;
+    	    }
+    	    var yp = y.clone();
+    	    var xp = x.clone();
+    	    while (!x.isZero()) {
+    	      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+    	      if (i > 0) {
+    	        x.iushrn(i);
+    	        while (i-- > 0) {
+    	          if (A.isOdd() || B.isOdd()) {
+    	            A.iadd(yp);
+    	            B.isub(xp);
+    	          }
+    	          A.iushrn(1);
+    	          B.iushrn(1);
+    	        }
+    	      }
+    	      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+    	      if (j > 0) {
+    	        y.iushrn(j);
+    	        while (j-- > 0) {
+    	          if (C.isOdd() || D.isOdd()) {
+    	            C.iadd(yp);
+    	            D.isub(xp);
+    	          }
+    	          C.iushrn(1);
+    	          D.iushrn(1);
+    	        }
+    	      }
+    	      if (x.cmp(y) >= 0) {
+    	        x.isub(y);
+    	        A.isub(C);
+    	        B.isub(D);
+    	      } else {
+    	        y.isub(x);
+    	        C.isub(A);
+    	        D.isub(B);
+    	      }
+    	    }
+    	    return {
+    	      a: C,
+    	      b: D,
+    	      gcd: y.iushln(g)
+    	    };
+    	  };
+    	  BN.prototype._invmp = function _invmp (p) {
+    	    assert(p.negative === 0);
+    	    assert(!p.isZero());
+    	    var a = this;
+    	    var b = p.clone();
+    	    if (a.negative !== 0) {
+    	      a = a.umod(p);
+    	    } else {
+    	      a = a.clone();
+    	    }
+    	    var x1 = new BN(1);
+    	    var x2 = new BN(0);
+    	    var delta = b.clone();
+    	    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
+    	      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+    	      if (i > 0) {
+    	        a.iushrn(i);
+    	        while (i-- > 0) {
+    	          if (x1.isOdd()) {
+    	            x1.iadd(delta);
+    	          }
+    	          x1.iushrn(1);
+    	        }
+    	      }
+    	      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+    	      if (j > 0) {
+    	        b.iushrn(j);
+    	        while (j-- > 0) {
+    	          if (x2.isOdd()) {
+    	            x2.iadd(delta);
+    	          }
+    	          x2.iushrn(1);
+    	        }
+    	      }
+    	      if (a.cmp(b) >= 0) {
+    	        a.isub(b);
+    	        x1.isub(x2);
+    	      } else {
+    	        b.isub(a);
+    	        x2.isub(x1);
+    	      }
+    	    }
+    	    var res;
+    	    if (a.cmpn(1) === 0) {
+    	      res = x1;
+    	    } else {
+    	      res = x2;
+    	    }
+    	    if (res.cmpn(0) < 0) {
+    	      res.iadd(p);
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.gcd = function gcd (num) {
+    	    if (this.isZero()) return num.abs();
+    	    if (num.isZero()) return this.abs();
+    	    var a = this.clone();
+    	    var b = num.clone();
+    	    a.negative = 0;
+    	    b.negative = 0;
+    	    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
+    	      a.iushrn(1);
+    	      b.iushrn(1);
+    	    }
+    	    do {
+    	      while (a.isEven()) {
+    	        a.iushrn(1);
+    	      }
+    	      while (b.isEven()) {
+    	        b.iushrn(1);
+    	      }
+    	      var r = a.cmp(b);
+    	      if (r < 0) {
+    	        var t = a;
+    	        a = b;
+    	        b = t;
+    	      } else if (r === 0 || b.cmpn(1) === 0) {
+    	        break;
+    	      }
+    	      a.isub(b);
+    	    } while (true);
+    	    return b.iushln(shift);
+    	  };
+    	  BN.prototype.invm = function invm (num) {
+    	    return this.egcd(num).a.umod(num);
+    	  };
+    	  BN.prototype.isEven = function isEven () {
+    	    return (this.words[0] & 1) === 0;
+    	  };
+    	  BN.prototype.isOdd = function isOdd () {
+    	    return (this.words[0] & 1) === 1;
+    	  };
+    	  BN.prototype.andln = function andln (num) {
+    	    return this.words[0] & num;
+    	  };
+    	  BN.prototype.bincn = function bincn (bit) {
+    	    assert(typeof bit === 'number');
+    	    var r = bit % 26;
+    	    var s = (bit - r) / 26;
+    	    var q = 1 << r;
+    	    if (this.length <= s) {
+    	      this._expand(s + 1);
+    	      this.words[s] |= q;
+    	      return this;
+    	    }
+    	    var carry = q;
+    	    for (var i = s; carry !== 0 && i < this.length; i++) {
+    	      var w = this.words[i] | 0;
+    	      w += carry;
+    	      carry = w >>> 26;
+    	      w &= 0x3ffffff;
+    	      this.words[i] = w;
+    	    }
+    	    if (carry !== 0) {
+    	      this.words[i] = carry;
+    	      this.length++;
+    	    }
+    	    return this;
+    	  };
+    	  BN.prototype.isZero = function isZero () {
+    	    return this.length === 1 && this.words[0] === 0;
+    	  };
+    	  BN.prototype.cmpn = function cmpn (num) {
+    	    var negative = num < 0;
+    	    if (this.negative !== 0 && !negative) return -1;
+    	    if (this.negative === 0 && negative) return 1;
+    	    this._strip();
+    	    var res;
+    	    if (this.length > 1) {
+    	      res = 1;
+    	    } else {
+    	      if (negative) {
+    	        num = -num;
+    	      }
+    	      assert(num <= 0x3ffffff, 'Number is too big');
+    	      var w = this.words[0] | 0;
+    	      res = w === num ? 0 : w < num ? -1 : 1;
+    	    }
+    	    if (this.negative !== 0) return -res | 0;
+    	    return res;
+    	  };
+    	  BN.prototype.cmp = function cmp (num) {
+    	    if (this.negative !== 0 && num.negative === 0) return -1;
+    	    if (this.negative === 0 && num.negative !== 0) return 1;
+    	    var res = this.ucmp(num);
+    	    if (this.negative !== 0) return -res | 0;
+    	    return res;
+    	  };
+    	  BN.prototype.ucmp = function ucmp (num) {
+    	    if (this.length > num.length) return 1;
+    	    if (this.length < num.length) return -1;
+    	    var res = 0;
+    	    for (var i = this.length - 1; i >= 0; i--) {
+    	      var a = this.words[i] | 0;
+    	      var b = num.words[i] | 0;
+    	      if (a === b) continue;
+    	      if (a < b) {
+    	        res = -1;
+    	      } else if (a > b) {
+    	        res = 1;
+    	      }
+    	      break;
+    	    }
+    	    return res;
+    	  };
+    	  BN.prototype.gtn = function gtn (num) {
+    	    return this.cmpn(num) === 1;
+    	  };
+    	  BN.prototype.gt = function gt (num) {
+    	    return this.cmp(num) === 1;
+    	  };
+    	  BN.prototype.gten = function gten (num) {
+    	    return this.cmpn(num) >= 0;
+    	  };
+    	  BN.prototype.gte = function gte (num) {
+    	    return this.cmp(num) >= 0;
+    	  };
+    	  BN.prototype.ltn = function ltn (num) {
+    	    return this.cmpn(num) === -1;
+    	  };
+    	  BN.prototype.lt = function lt (num) {
+    	    return this.cmp(num) === -1;
+    	  };
+    	  BN.prototype.lten = function lten (num) {
+    	    return this.cmpn(num) <= 0;
+    	  };
+    	  BN.prototype.lte = function lte (num) {
+    	    return this.cmp(num) <= 0;
+    	  };
+    	  BN.prototype.eqn = function eqn (num) {
+    	    return this.cmpn(num) === 0;
+    	  };
+    	  BN.prototype.eq = function eq (num) {
+    	    return this.cmp(num) === 0;
+    	  };
+    	  BN.red = function red (num) {
+    	    return new Red(num);
+    	  };
+    	  BN.prototype.toRed = function toRed (ctx) {
+    	    assert(!this.red, 'Already a number in reduction context');
+    	    assert(this.negative === 0, 'red works only with positives');
+    	    return ctx.convertTo(this)._forceRed(ctx);
+    	  };
+    	  BN.prototype.fromRed = function fromRed () {
+    	    assert(this.red, 'fromRed works only with numbers in reduction context');
+    	    return this.red.convertFrom(this);
+    	  };
+    	  BN.prototype._forceRed = function _forceRed (ctx) {
+    	    this.red = ctx;
+    	    return this;
+    	  };
+    	  BN.prototype.forceRed = function forceRed (ctx) {
+    	    assert(!this.red, 'Already a number in reduction context');
+    	    return this._forceRed(ctx);
+    	  };
+    	  BN.prototype.redAdd = function redAdd (num) {
+    	    assert(this.red, 'redAdd works only with red numbers');
+    	    return this.red.add(this, num);
+    	  };
+    	  BN.prototype.redIAdd = function redIAdd (num) {
+    	    assert(this.red, 'redIAdd works only with red numbers');
+    	    return this.red.iadd(this, num);
+    	  };
+    	  BN.prototype.redSub = function redSub (num) {
+    	    assert(this.red, 'redSub works only with red numbers');
+    	    return this.red.sub(this, num);
+    	  };
+    	  BN.prototype.redISub = function redISub (num) {
+    	    assert(this.red, 'redISub works only with red numbers');
+    	    return this.red.isub(this, num);
+    	  };
+    	  BN.prototype.redShl = function redShl (num) {
+    	    assert(this.red, 'redShl works only with red numbers');
+    	    return this.red.shl(this, num);
+    	  };
+    	  BN.prototype.redMul = function redMul (num) {
+    	    assert(this.red, 'redMul works only with red numbers');
+    	    this.red._verify2(this, num);
+    	    return this.red.mul(this, num);
+    	  };
+    	  BN.prototype.redIMul = function redIMul (num) {
+    	    assert(this.red, 'redMul works only with red numbers');
+    	    this.red._verify2(this, num);
+    	    return this.red.imul(this, num);
+    	  };
+    	  BN.prototype.redSqr = function redSqr () {
+    	    assert(this.red, 'redSqr works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.sqr(this);
+    	  };
+    	  BN.prototype.redISqr = function redISqr () {
+    	    assert(this.red, 'redISqr works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.isqr(this);
+    	  };
+    	  BN.prototype.redSqrt = function redSqrt () {
+    	    assert(this.red, 'redSqrt works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.sqrt(this);
+    	  };
+    	  BN.prototype.redInvm = function redInvm () {
+    	    assert(this.red, 'redInvm works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.invm(this);
+    	  };
+    	  BN.prototype.redNeg = function redNeg () {
+    	    assert(this.red, 'redNeg works only with red numbers');
+    	    this.red._verify1(this);
+    	    return this.red.neg(this);
+    	  };
+    	  BN.prototype.redPow = function redPow (num) {
+    	    assert(this.red && !num.red, 'redPow(normalNum)');
+    	    this.red._verify1(this);
+    	    return this.red.pow(this, num);
+    	  };
+    	  var primes = {
+    	    k256: null,
+    	    p224: null,
+    	    p192: null,
+    	    p25519: null
+    	  };
+    	  function MPrime (name, p) {
+    	    this.name = name;
+    	    this.p = new BN(p, 16);
+    	    this.n = this.p.bitLength();
+    	    this.k = new BN(1).iushln(this.n).isub(this.p);
+    	    this.tmp = this._tmp();
+    	  }
+    	  MPrime.prototype._tmp = function _tmp () {
+    	    var tmp = new BN(null);
+    	    tmp.words = new Array(Math.ceil(this.n / 13));
+    	    return tmp;
+    	  };
+    	  MPrime.prototype.ireduce = function ireduce (num) {
+    	    var r = num;
+    	    var rlen;
+    	    do {
+    	      this.split(r, this.tmp);
+    	      r = this.imulK(r);
+    	      r = r.iadd(this.tmp);
+    	      rlen = r.bitLength();
+    	    } while (rlen > this.n);
+    	    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
+    	    if (cmp === 0) {
+    	      r.words[0] = 0;
+    	      r.length = 1;
+    	    } else if (cmp > 0) {
+    	      r.isub(this.p);
+    	    } else {
+    	      if (r.strip !== undefined) {
+    	        r.strip();
+    	      } else {
+    	        r._strip();
+    	      }
+    	    }
+    	    return r;
+    	  };
+    	  MPrime.prototype.split = function split (input, out) {
+    	    input.iushrn(this.n, 0, out);
+    	  };
+    	  MPrime.prototype.imulK = function imulK (num) {
+    	    return num.imul(this.k);
+    	  };
+    	  function K256 () {
+    	    MPrime.call(
+    	      this,
+    	      'k256',
+    	      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
+    	  }
+    	  inherits(K256, MPrime);
+    	  K256.prototype.split = function split (input, output) {
+    	    var mask = 0x3fffff;
+    	    var outLen = Math.min(input.length, 9);
+    	    for (var i = 0; i < outLen; i++) {
+    	      output.words[i] = input.words[i];
+    	    }
+    	    output.length = outLen;
+    	    if (input.length <= 9) {
+    	      input.words[0] = 0;
+    	      input.length = 1;
+    	      return;
+    	    }
+    	    var prev = input.words[9];
+    	    output.words[output.length++] = prev & mask;
+    	    for (i = 10; i < input.length; i++) {
+    	      var next = input.words[i] | 0;
+    	      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
+    	      prev = next;
+    	    }
+    	    prev >>>= 22;
+    	    input.words[i - 10] = prev;
+    	    if (prev === 0 && input.length > 10) {
+    	      input.length -= 10;
+    	    } else {
+    	      input.length -= 9;
+    	    }
+    	  };
+    	  K256.prototype.imulK = function imulK (num) {
+    	    num.words[num.length] = 0;
+    	    num.words[num.length + 1] = 0;
+    	    num.length += 2;
+    	    var lo = 0;
+    	    for (var i = 0; i < num.length; i++) {
+    	      var w = num.words[i] | 0;
+    	      lo += w * 0x3d1;
+    	      num.words[i] = lo & 0x3ffffff;
+    	      lo = w * 0x40 + ((lo / 0x4000000) | 0);
+    	    }
+    	    if (num.words[num.length - 1] === 0) {
+    	      num.length--;
+    	      if (num.words[num.length - 1] === 0) {
+    	        num.length--;
+    	      }
+    	    }
+    	    return num;
+    	  };
+    	  function P224 () {
+    	    MPrime.call(
+    	      this,
+    	      'p224',
+    	      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
+    	  }
+    	  inherits(P224, MPrime);
+    	  function P192 () {
+    	    MPrime.call(
+    	      this,
+    	      'p192',
+    	      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
+    	  }
+    	  inherits(P192, MPrime);
+    	  function P25519 () {
+    	    MPrime.call(
+    	      this,
+    	      '25519',
+    	      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
+    	  }
+    	  inherits(P25519, MPrime);
+    	  P25519.prototype.imulK = function imulK (num) {
+    	    var carry = 0;
+    	    for (var i = 0; i < num.length; i++) {
+    	      var hi = (num.words[i] | 0) * 0x13 + carry;
+    	      var lo = hi & 0x3ffffff;
+    	      hi >>>= 26;
+    	      num.words[i] = lo;
+    	      carry = hi;
+    	    }
+    	    if (carry !== 0) {
+    	      num.words[num.length++] = carry;
+    	    }
+    	    return num;
+    	  };
+    	  BN._prime = function prime (name) {
+    	    if (primes[name]) return primes[name];
+    	    var prime;
+    	    if (name === 'k256') {
+    	      prime = new K256();
+    	    } else if (name === 'p224') {
+    	      prime = new P224();
+    	    } else if (name === 'p192') {
+    	      prime = new P192();
+    	    } else if (name === 'p25519') {
+    	      prime = new P25519();
+    	    } else {
+    	      throw new Error('Unknown prime ' + name);
+    	    }
+    	    primes[name] = prime;
+    	    return prime;
+    	  };
+    	  function Red (m) {
+    	    if (typeof m === 'string') {
+    	      var prime = BN._prime(m);
+    	      this.m = prime.p;
+    	      this.prime = prime;
+    	    } else {
+    	      assert(m.gtn(1), 'modulus must be greater than 1');
+    	      this.m = m;
+    	      this.prime = null;
+    	    }
+    	  }
+    	  Red.prototype._verify1 = function _verify1 (a) {
+    	    assert(a.negative === 0, 'red works only with positives');
+    	    assert(a.red, 'red works only with red numbers');
+    	  };
+    	  Red.prototype._verify2 = function _verify2 (a, b) {
+    	    assert((a.negative | b.negative) === 0, 'red works only with positives');
+    	    assert(a.red && a.red === b.red,
+    	      'red works only with red numbers');
+    	  };
+    	  Red.prototype.imod = function imod (a) {
+    	    if (this.prime) return this.prime.ireduce(a)._forceRed(this);
+    	    move(a, a.umod(this.m)._forceRed(this));
+    	    return a;
+    	  };
+    	  Red.prototype.neg = function neg (a) {
+    	    if (a.isZero()) {
+    	      return a.clone();
+    	    }
+    	    return this.m.sub(a)._forceRed(this);
+    	  };
+    	  Red.prototype.add = function add (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.add(b);
+    	    if (res.cmp(this.m) >= 0) {
+    	      res.isub(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Red.prototype.iadd = function iadd (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.iadd(b);
+    	    if (res.cmp(this.m) >= 0) {
+    	      res.isub(this.m);
+    	    }
+    	    return res;
+    	  };
+    	  Red.prototype.sub = function sub (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.sub(b);
+    	    if (res.cmpn(0) < 0) {
+    	      res.iadd(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Red.prototype.isub = function isub (a, b) {
+    	    this._verify2(a, b);
+    	    var res = a.isub(b);
+    	    if (res.cmpn(0) < 0) {
+    	      res.iadd(this.m);
+    	    }
+    	    return res;
+    	  };
+    	  Red.prototype.shl = function shl (a, num) {
+    	    this._verify1(a);
+    	    return this.imod(a.ushln(num));
+    	  };
+    	  Red.prototype.imul = function imul (a, b) {
+    	    this._verify2(a, b);
+    	    return this.imod(a.imul(b));
+    	  };
+    	  Red.prototype.mul = function mul (a, b) {
+    	    this._verify2(a, b);
+    	    return this.imod(a.mul(b));
+    	  };
+    	  Red.prototype.isqr = function isqr (a) {
+    	    return this.imul(a, a.clone());
+    	  };
+    	  Red.prototype.sqr = function sqr (a) {
+    	    return this.mul(a, a);
+    	  };
+    	  Red.prototype.sqrt = function sqrt (a) {
+    	    if (a.isZero()) return a.clone();
+    	    var mod3 = this.m.andln(3);
+    	    assert(mod3 % 2 === 1);
+    	    if (mod3 === 3) {
+    	      var pow = this.m.add(new BN(1)).iushrn(2);
+    	      return this.pow(a, pow);
+    	    }
+    	    var q = this.m.subn(1);
+    	    var s = 0;
+    	    while (!q.isZero() && q.andln(1) === 0) {
+    	      s++;
+    	      q.iushrn(1);
+    	    }
+    	    assert(!q.isZero());
+    	    var one = new BN(1).toRed(this);
+    	    var nOne = one.redNeg();
+    	    var lpow = this.m.subn(1).iushrn(1);
+    	    var z = this.m.bitLength();
+    	    z = new BN(2 * z * z).toRed(this);
+    	    while (this.pow(z, lpow).cmp(nOne) !== 0) {
+    	      z.redIAdd(nOne);
+    	    }
+    	    var c = this.pow(z, q);
+    	    var r = this.pow(a, q.addn(1).iushrn(1));
+    	    var t = this.pow(a, q);
+    	    var m = s;
+    	    while (t.cmp(one) !== 0) {
+    	      var tmp = t;
+    	      for (var i = 0; tmp.cmp(one) !== 0; i++) {
+    	        tmp = tmp.redSqr();
+    	      }
+    	      assert(i < m);
+    	      var b = this.pow(c, new BN(1).iushln(m - i - 1));
+    	      r = r.redMul(b);
+    	      c = b.redSqr();
+    	      t = t.redMul(c);
+    	      m = i;
+    	    }
+    	    return r;
+    	  };
+    	  Red.prototype.invm = function invm (a) {
+    	    var inv = a._invmp(this.m);
+    	    if (inv.negative !== 0) {
+    	      inv.negative = 0;
+    	      return this.imod(inv).redNeg();
+    	    } else {
+    	      return this.imod(inv);
+    	    }
+    	  };
+    	  Red.prototype.pow = function pow (a, num) {
+    	    if (num.isZero()) return new BN(1).toRed(this);
+    	    if (num.cmpn(1) === 0) return a.clone();
+    	    var windowSize = 4;
+    	    var wnd = new Array(1 << windowSize);
+    	    wnd[0] = new BN(1).toRed(this);
+    	    wnd[1] = a;
+    	    for (var i = 2; i < wnd.length; i++) {
+    	      wnd[i] = this.mul(wnd[i - 1], a);
+    	    }
+    	    var res = wnd[0];
+    	    var current = 0;
+    	    var currentLen = 0;
+    	    var start = num.bitLength() % 26;
+    	    if (start === 0) {
+    	      start = 26;
+    	    }
+    	    for (i = num.length - 1; i >= 0; i--) {
+    	      var word = num.words[i];
+    	      for (var j = start - 1; j >= 0; j--) {
+    	        var bit = (word >> j) & 1;
+    	        if (res !== wnd[0]) {
+    	          res = this.sqr(res);
+    	        }
+    	        if (bit === 0 && current === 0) {
+    	          currentLen = 0;
+    	          continue;
+    	        }
+    	        current <<= 1;
+    	        current |= bit;
+    	        currentLen++;
+    	        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
+    	        res = this.mul(res, wnd[current]);
+    	        currentLen = 0;
+    	        current = 0;
+    	      }
+    	      start = 26;
+    	    }
+    	    return res;
+    	  };
+    	  Red.prototype.convertTo = function convertTo (num) {
+    	    var r = num.umod(this.m);
+    	    return r === num ? r.clone() : r;
+    	  };
+    	  Red.prototype.convertFrom = function convertFrom (num) {
+    	    var res = num.clone();
+    	    res.red = null;
+    	    return res;
+    	  };
+    	  BN.mont = function mont (num) {
+    	    return new Mont(num);
+    	  };
+    	  function Mont (m) {
+    	    Red.call(this, m);
+    	    this.shift = this.m.bitLength();
+    	    if (this.shift % 26 !== 0) {
+    	      this.shift += 26 - (this.shift % 26);
+    	    }
+    	    this.r = new BN(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);
+    	  }
+    	  inherits(Mont, Red);
+    	  Mont.prototype.convertTo = function convertTo (num) {
+    	    return this.imod(num.ushln(this.shift));
+    	  };
+    	  Mont.prototype.convertFrom = function convertFrom (num) {
+    	    var r = this.imod(num.mul(this.rinv));
+    	    r.red = null;
+    	    return r;
+    	  };
+    	  Mont.prototype.imul = function imul (a, b) {
+    	    if (a.isZero() || b.isZero()) {
+    	      a.words[0] = 0;
+    	      a.length = 1;
+    	      return a;
+    	    }
+    	    var t = a.imul(b);
+    	    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+    	    var u = t.isub(c).iushrn(this.shift);
+    	    var res = u;
+    	    if (u.cmp(this.m) >= 0) {
+    	      res = u.isub(this.m);
+    	    } else if (u.cmpn(0) < 0) {
+    	      res = u.iadd(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Mont.prototype.mul = function mul (a, b) {
+    	    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
+    	    var t = a.mul(b);
+    	    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+    	    var u = t.isub(c).iushrn(this.shift);
+    	    var res = u;
+    	    if (u.cmp(this.m) >= 0) {
+    	      res = u.isub(this.m);
+    	    } else if (u.cmpn(0) < 0) {
+    	      res = u.iadd(this.m);
+    	    }
+    	    return res._forceRed(this);
+    	  };
+    	  Mont.prototype.invm = function invm (a) {
+    	    var res = this.imod(a._invmp(this.m).mul(this.r2));
+    	    return res._forceRed(this);
+    	  };
+    	})(module, commonjsGlobal);
+    } (bn));
+    var bnExports = bn.exports;
+    const BN = getDefaultExportFromCjs(bnExports);
+
+    function isBn(value) {
+        return BN.isBN(value);
+    }
+
+    const REGEX_HEX_PREFIXED = /^0x[\da-fA-F]+$/;
+    const REGEX_HEX_NOPREFIX = /^[\da-fA-F]+$/;
+    function isHex(value, bitLength = -1, ignoreLength) {
+        return (typeof value === 'string' && (value === '0x' ||
+            REGEX_HEX_PREFIXED.test(value))) && (bitLength === -1
+            ? (ignoreLength || (value.length % 2 === 0))
+            : (value.length === (2 + Math.ceil(bitLength / 4))));
+    }
+
+    function isObject(value) {
+        return !!value && typeof value === 'object';
+    }
+
+    function isOn(...fns) {
+        return (value) => (isObject(value) || isFunction(value)) &&
+            fns.every((f) => isFunction(value[f]));
+    }
+    function isOnFunction(...fns) {
+        return (value) => isFunction(value) &&
+            fns.every((f) => isFunction(value[f]));
+    }
+    function isOnObject(...fns) {
+        return (value) => isObject(value) &&
+            fns.every((f) => isFunction(value[f]));
+    }
+
+    const isToBigInt =  isOn('toBigInt');
+
+    const isToBn =  isOn('toBn');
+
+    function nToBigInt(value) {
+        return typeof value === 'bigint'
+            ? value
+            : !value
+                ? BigInt(0)
+                : isHex(value)
+                    ? hexToBigInt(value.toString())
+                    : isBn(value)
+                        ? BigInt(value.toString())
+                        : isToBigInt(value)
+                            ? value.toBigInt()
+                            : isToBn(value)
+                                ? BigInt(value.toBn().toString())
+                                : BigInt(value);
+    }
+
+    function nSqrt(value) {
+        const n = nToBigInt(value);
+        if (n < _0n) {
+            throw new Error('square root of negative numbers is not supported');
+        }
+        if (n <= _2pow53n) {
+            return BigInt(~~Math.sqrt(Number(n)));
+        }
+        let x0 = _sqrt2pow53n;
+        while (true) {
+            const x1 = ((n / x0) + x0) >> _1n;
+            if (x0 === x1 || (x0 === (x1 - _1n))) {
+                return x0;
+            }
+            x0 = x1;
+        }
+    }
+
+    const hasBigInt = typeof BigInt === 'function' && typeof BigInt.asIntN === 'function';
+    const hasCjs = typeof require === 'function' && typeof module !== 'undefined';
+    const hasDirname = typeof __dirname !== 'undefined';
+    const hasEsm = !hasCjs;
+    const hasWasm = typeof WebAssembly !== 'undefined';
+    const hasBuffer = typeof xglobal.Buffer === 'function' && typeof xglobal.Buffer.isBuffer === 'function';
+    const hasProcess = typeof xglobal.process === 'object';
+
+    function isBuffer(value) {
+        return hasBuffer && !!value && isFunction(value.readDoubleLE) && xglobal.Buffer.isBuffer(value);
+    }
+
+    function isU8a(value) {
+        return (((value && value.constructor) === Uint8Array) ||
+            value instanceof Uint8Array);
+    }
+
+    var browser$1 = {};
+
+    const require$$0 = /*@__PURE__*/getAugmentedNamespace(build);
+
+    var fallback$1 = {};
+
+    Object.defineProperty(fallback$1, "__esModule", { value: true });
+    fallback$1.TextEncoder = void 0;
+    class TextEncoder {
+        encode(value) {
+            const count = value.length;
+            const u8a = new Uint8Array(count);
+            for (let i = 0; i < count; i++) {
+                u8a[i] = value.charCodeAt(i);
+            }
+            return u8a;
+        }
+    }
+    fallback$1.TextEncoder = TextEncoder;
+
+    var packageInfo$1 = {};
+
+    Object.defineProperty(packageInfo$1, "__esModule", { value: true });
+    packageInfo$1.packageInfo = void 0;
+    packageInfo$1.packageInfo = { name: '@polkadot/x-textencoder', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '13.5.9' };
+
+    (function (exports) {
+    	Object.defineProperty(exports, "__esModule", { value: true });
+    	exports.TextEncoder = exports.packageInfo = void 0;
+    	const x_global_1 = require$$0;
+    	const fallback_js_1 = fallback$1;
+    	var packageInfo_js_1 = packageInfo$1;
+    	Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+    	exports.TextEncoder = (0, x_global_1.extractGlobal)('TextEncoder', fallback_js_1.TextEncoder);
+    } (browser$1));
+    getDefaultExportFromCjs(browser$1);
+
+    const encoder = new browser$1.TextEncoder();
+    function stringToU8a(value) {
+        return value
+            ? encoder.encode(value.toString())
+            : new Uint8Array();
+    }
+
+    function u8aToU8a(value, strict = false) {
+        if (strict && (value === null || value === undefined)) {
+            throw new Error('u8aToU8a: Expected non-null, non-undefined value');
+        }
+        return isU8a(value)
+            ? isBuffer(value)
+                ? new Uint8Array(value)
+                : value
+            : isHex(value)
+                ? hexToU8a(value)
+                : Array.isArray(value)
+                    ? new Uint8Array(value)
+                    : stringToU8a(value);
+    }
+
+    function u8aCmp(a, b) {
+        const u8aa = u8aToU8a(a);
+        const u8ab = u8aToU8a(b);
+        let i = 0;
+        while (true) {
+            const overA = i >= u8aa.length;
+            const overB = i >= u8ab.length;
+            if (overA && overB) {
+                return 0;
+            }
+            else if (overA) {
+                return -1;
+            }
+            else if (overB) {
+                return 1;
+            }
+            else if (u8aa[i] !== u8ab[i]) {
+                return u8aa[i] > u8ab[i]
+                    ? 1
+                    : -1;
+            }
+            i++;
+        }
+    }
+
+    function u8aConcat(...list) {
+        const count = list.length;
+        const u8as = new Array(count);
+        let length = 0;
+        for (let i = 0; i < count; i++) {
+            u8as[i] = u8aToU8a(list[i]);
+            length += u8as[i].length;
+        }
+        return u8aConcatStrict(u8as, length);
+    }
+    function u8aConcatStrict(u8as, length = 0) {
+        const count = u8as.length;
+        let offset = 0;
+        if (!length) {
+            for (let i = 0; i < count; i++) {
+                length += u8as[i].length;
+            }
+        }
+        const result = new Uint8Array(length);
+        for (let i = 0; i < count; i++) {
+            result.set(u8as[i], offset);
+            offset += u8as[i].length;
+        }
+        return result;
+    }
+
+    function u8aEmpty(value) {
+        const len = value.length | 0;
+        for (let i = 0; i < len; i++) {
+            if (value[i] | 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function u8aEq(a, b) {
+        const u8aa = u8aToU8a(a);
+        const u8ab = u8aToU8a(b);
+        if (u8aa.length === u8ab.length) {
+            const dvA = new DataView(u8aa.buffer, u8aa.byteOffset);
+            const dvB = new DataView(u8ab.buffer, u8ab.byteOffset);
+            const mod = (u8aa.length % 4) | 0;
+            const length = (u8aa.length - mod) | 0;
+            for (let i = 0; i < length; i += 4) {
+                if (dvA.getUint32(i) !== dvB.getUint32(i)) {
+                    return false;
+                }
+            }
+            for (let i = length, count = u8aa.length; i < count; i++) {
+                if (u8aa[i] !== u8ab[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    function u8aFixLength(value, bitLength = -1, atStart = false) {
+        const byteLength = Math.ceil(bitLength / 8);
+        if (bitLength === -1 || value.length === byteLength) {
+            return value;
+        }
+        else if (value.length > byteLength) {
+            return value.subarray(0, byteLength);
+        }
+        const result = new Uint8Array(byteLength);
+        result.set(value, atStart ? 0 : (byteLength - value.length));
+        return result;
+    }
+
+    function u8aSorted(u8as) {
+        return u8as.sort(u8aCmp);
+    }
+
+    function u8aToBn(value, { isLe = true, isNegative = false } = {}) {
+        if (!isLe) {
+            value = value.slice().reverse();
+        }
+        const count = value.length;
+        if (isNegative && count && (value[count - 1] & 0x80)) {
+            switch (count) {
+                case 0:
+                    return new BN(0);
+                case 1:
+                    return new BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
+                case 2:
+                    return new BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+                case 3:
+                    return new BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
+                case 4:
+                    return new BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+                case 5:
+                    return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
+                case 6:
+                    return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
+                default:
+                    return new BN(value, 'le').fromTwos(count * 8);
+            }
+        }
+        switch (count) {
+            case 0:
+                return new BN(0);
+            case 1:
+                return new BN(value[0]);
+            case 2:
+                return new BN(value[0] + (value[1] << 8));
+            case 3:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16));
+            case 4:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+            case 5:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
+            case 6:
+                return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
+            default:
+                return new BN(value, 'le');
+        }
+    }
+
+    function u8aToBuffer(value) {
+        return hasBuffer
+            ? xglobal.Buffer.from(value || [])
+            : new Uint8Array(value || []);
+    }
+
+    function u8aToFloat(value, { bitLength = 32, isLe = true } = {}) {
+        if (bitLength !== 32 && bitLength !== 64) {
+            throw new Error('Invalid bitLength provided, expected 32 or 64');
+        }
+        else if (value.length < (bitLength / 8)) {
+            throw new Error(`Invalid input buffer provided, expected at least ${bitLength / 8} bytes, found ${value.length}`);
+        }
+        const dv = new DataView(value.buffer, value.byteOffset);
+        return bitLength === 32
+            ? dv.getFloat32(0, isLe)
+            : dv.getFloat64(0, isLe);
+    }
+
+    const U8 = new Array(256);
+    const U16 = new Array(256 * 256);
+    for (let n = 0; n < 256; n++) {
+        U8[n] = n.toString(16).padStart(2, '0');
+    }
+    for (let i = 0; i < 256; i++) {
+        const s = i << 8;
+        for (let j = 0; j < 256; j++) {
+            U16[s | j] = U8[i] + U8[j];
+        }
+    }
+    function hex(value, result) {
+        const mod = (value.length % 2) | 0;
+        const length = (value.length - mod) | 0;
+        for (let i = 0; i < length; i += 2) {
+            result += U16[(value[i] << 8) | value[i + 1]];
+        }
+        if (mod) {
+            result += U8[value[length] | 0];
+        }
+        return result;
+    }
+    function u8aToHex(value, bitLength = -1, isPrefixed = true) {
+        const empty = isPrefixed
+            ? '0x'
+            : '';
+        if (!value?.length) {
+            return empty;
+        }
+        else if (bitLength > 0) {
+            const length = Math.ceil(bitLength / 8);
+            if (value.length > length) {
+                return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), '')}`;
+            }
+        }
+        return hex(value, empty);
+    }
+
+    function u8aToNumber(value, { isLe = true, isNegative = false } = {}) {
+        if (!isLe) {
+            value = value.slice().reverse();
+        }
+        const count = value.length;
+        if (isNegative && count && (value[count - 1] & 0x80)) {
+            switch (count) {
+                case 0:
+                    return 0;
+                case 1:
+                    return (((value[0] ^ 0x0000_00ff) * -1) - 1);
+                case 2:
+                    return ((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+                case 3:
+                    return ((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
+                case 4:
+                    return ((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+                case 5:
+                    return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
+                case 6:
+                    return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
+                default:
+                    throw new Error('Value more than 48-bits cannot be reliably converted');
+            }
+        }
+        switch (count) {
+            case 0:
+                return 0;
+            case 1:
+                return value[0];
+            case 2:
+                return value[0] + (value[1] << 8);
+            case 3:
+                return value[0] + (value[1] << 8) + (value[2] << 16);
+            case 4:
+                return value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00);
+            case 5:
+                return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00);
+            case 6:
+                return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00);
+            default:
+                throw new Error('Value more than 48-bits cannot be reliably converted');
+        }
+    }
+
+    var browser = {};
+
+    var fallback = {};
+
+    Object.defineProperty(fallback, "__esModule", { value: true });
+    fallback.TextDecoder = void 0;
+    class TextDecoder {
+        __encoding;
+        constructor(encoding) {
+            this.__encoding = encoding;
+        }
+        decode(value) {
+            let result = '';
+            for (let i = 0, count = value.length; i < count; i++) {
+                result += String.fromCharCode(value[i]);
+            }
+            return result;
+        }
+    }
+    fallback.TextDecoder = TextDecoder;
+
+    var packageInfo = {};
+
+    Object.defineProperty(packageInfo, "__esModule", { value: true });
+    packageInfo.packageInfo = void 0;
+    packageInfo.packageInfo = { name: '@polkadot/x-textdecoder', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '13.5.9' };
+
+    (function (exports) {
+    	Object.defineProperty(exports, "__esModule", { value: true });
+    	exports.TextDecoder = exports.packageInfo = void 0;
+    	const x_global_1 = require$$0;
+    	const fallback_js_1 = fallback;
+    	var packageInfo_js_1 = packageInfo;
+    	Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+    	exports.TextDecoder = (0, x_global_1.extractGlobal)('TextDecoder', fallback_js_1.TextDecoder);
+    } (browser));
+    getDefaultExportFromCjs(browser);
+
+    const decoder = new browser.TextDecoder('utf-8');
+    function u8aToString(value) {
+        return value
+            ? decoder.decode(value)
+            : '';
+    }
+
+    const U8A_WRAP_ETHEREUM =  u8aToU8a('\x19Ethereum Signed Message:\n');
+    const U8A_WRAP_PREFIX =  u8aToU8a('<Bytes>');
+    const U8A_WRAP_POSTFIX =  u8aToU8a('</Bytes>');
+    const WRAP_LEN = U8A_WRAP_PREFIX.length + U8A_WRAP_POSTFIX.length;
+    function u8aIsWrapped(u8a, withEthereum) {
+        return ((u8a.length >= WRAP_LEN &&
+            u8aEq(u8a.subarray(0, U8A_WRAP_PREFIX.length), U8A_WRAP_PREFIX) &&
+            u8aEq(u8a.slice(-U8A_WRAP_POSTFIX.length), U8A_WRAP_POSTFIX)) ||
+            (withEthereum &&
+                u8a.length >= U8A_WRAP_ETHEREUM.length &&
+                u8aEq(u8a.subarray(0, U8A_WRAP_ETHEREUM.length), U8A_WRAP_ETHEREUM)));
+    }
+    function u8aUnwrapBytes(bytes) {
+        const u8a = u8aToU8a(bytes);
+        return u8aIsWrapped(u8a, false)
+            ? u8a.subarray(U8A_WRAP_PREFIX.length, u8a.length - U8A_WRAP_POSTFIX.length)
+            : u8a;
+    }
+    function u8aWrapBytes(bytes) {
+        const u8a = u8aToU8a(bytes);
+        return u8aIsWrapped(u8a, true)
+            ? u8a
+            : u8aConcatStrict([U8A_WRAP_PREFIX, u8a, U8A_WRAP_POSTFIX]);
+    }
+
+    const DIV = BigInt(256);
+    const NEG_MASK = BigInt(0xff);
+    function toU8a(value, isLe, isNegative) {
+        const arr = [];
+        const withSigned = isNegative && (value < _0n);
+        if (withSigned) {
+            value = (value + _1n) * -_1n;
+        }
+        while (value !== _0n) {
+            const mod = value % DIV;
+            const val = Number(withSigned
+                ? mod ^ NEG_MASK
+                : mod);
+            if (isLe) {
+                arr.push(val);
+            }
+            else {
+                arr.unshift(val);
+            }
+            value = (value - mod) / DIV;
+        }
+        return Uint8Array.from(arr);
+    }
+    function nToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = {}) {
+        const valueBi = nToBigInt(value);
+        if (valueBi === _0n) {
+            return bitLength === -1
+                ? new Uint8Array(1)
+                : new Uint8Array(Math.ceil((bitLength || 0) / 8));
+        }
+        const u8a = toU8a(valueBi, isLe, isNegative);
+        if (bitLength === -1) {
+            return u8a;
+        }
+        const byteLength = Math.ceil((bitLength || 0) / 8);
+        const output = new Uint8Array(byteLength);
+        if (isNegative) {
+            output.fill(0xff);
+        }
+        output.set(u8a, isLe ? 0 : byteLength - u8a.length);
+        return output;
+    }
+
+    function nToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+        return u8aToHex(nToU8a(value || 0, { bitLength, isLe, isNegative }));
+    }
+
+    function hexStripPrefix(value) {
+        if (!value || value === '0x') {
+            return '';
+        }
+        else if (REGEX_HEX_PREFIXED.test(value)) {
+            return value.substring(2);
+        }
+        else if (REGEX_HEX_NOPREFIX.test(value)) {
+            return value;
+        }
+        throw new Error(`Expected hex value to convert, found '${value}'`);
+    }
+
+    function hexToBn(value, { isLe = false, isNegative = false } = {}) {
+        if (!value || value === '0x') {
+            return new BN(0);
+        }
+        const stripped = hexStripPrefix(value);
+        const bn = new BN(stripped, 16, isLe ? 'le' : 'be');
+        return isNegative
+            ? bn.fromTwos(stripped.length * 4)
+            : bn;
+    }
+
+    const bnMax =  createCmp((a, b) => a.gt(b));
+    const bnMin =  createCmp((a, b) => a.lt(b));
+
+    const BN_ZERO =  new BN(0);
+    const BN_ONE =  new BN(1);
+    const BN_TWO =  new BN(2);
+    const BN_THREE =  new BN(3);
+    const BN_FOUR =  new BN(4);
+    const BN_FIVE =  new BN(5);
+    const BN_SIX =  new BN(6);
+    const BN_SEVEN =  new BN(7);
+    const BN_EIGHT =  new BN(8);
+    const BN_NINE =  new BN(9);
+    const BN_TEN =  new BN(10);
+    const BN_HUNDRED =  new BN(100);
+    const BN_THOUSAND =  new BN(1_000);
+    const BN_MILLION =  new BN(1_000_000);
+    const BN_BILLION =  new BN(1_000_000_000);
+    const BN_QUINTILL = BN_BILLION.mul(BN_BILLION);
+    const BN_MAX_INTEGER =  new BN(Number.MAX_SAFE_INTEGER);
+    const BN_SQRT_MAX_INTEGER =  new BN(94906265);
+
+    function isBigInt(value) {
+        return typeof value === 'bigint';
+    }
+
+    function bnToBn(value) {
+        return value
+            ? BN.isBN(value)
+                ? value
+                : isHex(value)
+                    ? hexToBn(value.toString())
+                    : isBigInt(value)
+                        ? new BN(value.toString())
+                        : isToBn(value)
+                            ? value.toBn()
+                            : isToBigInt(value)
+                                ? new BN(value.toBigInt().toString())
+                                : new BN(value)
+            : new BN(0);
+    }
+
+    function bnSqrt(value) {
+        const n = bnToBn(value);
+        if (n.isNeg()) {
+            throw new Error('square root of negative numbers is not supported');
+        }
+        if (n.lte(BN_MAX_INTEGER)) {
+            return new BN(~~Math.sqrt(n.toNumber()));
+        }
+        let x0 = BN_SQRT_MAX_INTEGER.clone();
+        while (true) {
+            const x1 = n.div(x0).iadd(x0).ishrn(1);
+            if (x0.eq(x1) || x0.eq(x1.sub(BN_ONE))) {
+                return x0;
+            }
+            x0 = x1;
+        }
+    }
+
+    const DEFAULT_OPTS = { bitLength: -1, isLe: true, isNegative: false };
+    function bnToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS) {
+        const valueBn = bnToBn(value);
+        const byteLength = bitLength === -1
+            ? Math.ceil(valueBn.bitLength() / 8)
+            : Math.ceil((bitLength || 0) / 8);
+        if (!value) {
+            return bitLength === -1
+                ? new Uint8Array(1)
+                : new Uint8Array(byteLength);
+        }
+        const output = new Uint8Array(byteLength);
+        const bn = isNegative
+            ? valueBn.toTwos(byteLength * 8)
+            : valueBn;
+        output.set(bn.toArray(isLe ? 'le' : 'be', byteLength), 0);
+        return output;
+    }
+
+    function bnToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+        return u8aToHex(bnToU8a(value, { bitLength, isLe, isNegative }));
+    }
+
+    function bufferToU8a(buffer) {
+        return new Uint8Array(buffer || []);
+    }
+
+    const MAX_U8 = BN_TWO.pow(new BN(8 - 2)).isub(BN_ONE);
+    const MAX_U16 = BN_TWO.pow(new BN(16 - 2)).isub(BN_ONE);
+    const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(BN_ONE);
+    const BL_16 = { bitLength: 16 };
+    const BL_32 = { bitLength: 32 };
+    function compactToU8a(value) {
+        const bn = bnToBn(value);
+        if (bn.lte(MAX_U8)) {
+            return new Uint8Array([bn.toNumber() << 2]);
+        }
+        else if (bn.lte(MAX_U16)) {
+            return bnToU8a(bn.shln(2).iadd(BN_ONE), BL_16);
+        }
+        else if (bn.lte(MAX_U32)) {
+            return bnToU8a(bn.shln(2).iadd(BN_TWO), BL_32);
+        }
+        const u8a = bnToU8a(bn);
+        let length = u8a.length;
+        while (u8a[length - 1] === 0) {
+            length--;
+        }
+        if (length < 4) {
+            throw new Error('Invalid length, previous checks match anything less than 2^30');
+        }
+        return u8aConcatStrict([
+            new Uint8Array([((length - 4) << 2) + 0b11]),
+            u8a.subarray(0, length)
+        ]);
+    }
+
+    function compactAddLength(input) {
+        return u8aConcatStrict([
+            compactToU8a(input.length),
+            input
+        ]);
+    }
+
+    function compactFromU8a(input) {
+        const u8a = u8aToU8a(input);
+        switch (u8a[0] & 0b11) {
+            case 0b00:
+                return [1, new BN(u8a[0] >>> 2)];
+            case 0b01:
+                return [2, new BN((u8a[0] + (u8a[1] << 8)) >>> 2)];
+            case 0b10:
+                return [4, new BN((u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2)];
+            default: {
+                const offset = (u8a[0] >>> 2) + 5;
+                switch (offset) {
+                    case 5:
+                        return [5, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00))];
+                    case 6:
+                        return [6, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00))];
+                    case 7:
+                        return [7, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00))];
+                    default:
+                        return [offset, u8aToBn(u8a.subarray(1, offset))];
+                }
+            }
+        }
+    }
+    function compactFromU8aLim(u8a) {
+        switch (u8a[0] & 0b11) {
+            case 0b00:
+                return [1, u8a[0] >>> 2];
+            case 0b01:
+                return [2, (u8a[0] + (u8a[1] << 8)) >>> 2];
+            case 0b10:
+                return [4, (u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2];
+            default: {
+                switch ((u8a[0] >>> 2) + 5) {
+                    case 5:
+                        return [5, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00)];
+                    case 6:
+                        return [6, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00)];
+                    case 7:
+                        return [7, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00)];
+                    default:
+                        throw new Error('Compact input is > Number.MAX_SAFE_INTEGER');
+                }
+            }
+        }
+    }
+
+    function compactStripLength(input) {
+        const [offset, length] = compactFromU8a(input);
+        const total = offset + length.toNumber();
+        return [
+            total,
+            input.subarray(offset, total)
+        ];
+    }
+
+    const DEDUPE = 'Either remove and explicitly install matching versions or dedupe using your package manager.\nThe following conflicting packages were found:';
+    const POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = 'POLKADOTJS_DISABLE_ESM_CJS_WARNING';
+    function getEntry(name) {
+        const _global = xglobal;
+        if (!_global.__polkadotjs) {
+            _global.__polkadotjs = {};
+        }
+        if (!_global.__polkadotjs[name]) {
+            _global.__polkadotjs[name] = [];
+        }
+        return _global.__polkadotjs[name];
+    }
+    function formatDisplay(all, fmt) {
+        let max = 0;
+        for (let i = 0, count = all.length; i < count; i++) {
+            max = Math.max(max, all[i].version.length);
+        }
+        return all
+            .map((d) => `\t${fmt(d.version.padEnd(max), d).join('\t')}`)
+            .join('\n');
+    }
+    function formatInfo(version, { name }) {
+        return [
+            version,
+            name
+        ];
+    }
+    function formatVersion(version, { path, type }) {
+        let extracted;
+        if (path && path.length >= 5) {
+            const nmIndex = path.indexOf('node_modules');
+            extracted = nmIndex === -1
+                ? path
+                : path.substring(nmIndex);
+        }
+        else {
+            extracted = '<unknown>';
+        }
+        return [
+            `${`${type || ''}`.padStart(3)} ${version}`,
+            extracted
+        ];
+    }
+    function getPath(infoPath, pathOrFn) {
+        if (infoPath) {
+            return infoPath;
+        }
+        else if (isFunction(pathOrFn)) {
+            try {
+                return pathOrFn() || '';
+            }
+            catch {
+                return '';
+            }
+        }
+        return pathOrFn || '';
+    }
+    function warn(pre, all, fmt) {
+        console.warn(`${pre}\n${DEDUPE}\n${formatDisplay(all, fmt)}`);
+    }
+    function detectPackage({ name, path, type, version }, pathOrFn, deps = []) {
+        if (!name.startsWith('@polkadot')) {
+            throw new Error(`Invalid package descriptor ${name}`);
+        }
+        const entry = getEntry(name);
+        entry.push({ path: getPath(path, pathOrFn), type, version });
+        const entriesSameVersion = entry.every((e) => e.version === version);
+        const esmCjsWarningDisabled = xglobal.process?.env?.[POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG] === '1';
+        const multipleEntries = entry.length !== 1;
+        const disableWarnings = esmCjsWarningDisabled && entriesSameVersion;
+        if (multipleEntries && !disableWarnings) {
+            warn(`${name} has multiple versions, ensure that there is only one installed.`, entry, formatVersion);
+        }
+        else {
+            const mismatches = deps.filter((d) => d && d.version !== version);
+            if (mismatches.length) {
+                warn(`${name} requires direct dependencies exactly matching version ${version}.`, mismatches, formatInfo);
+            }
+        }
+    }
+
+    const MIN_MS = 60 * 1000;
+    const HR_MS = MIN_MS * 60;
+    const DAY_MS = HR_MS * 24;
+    const ZERO = { days: 0, hours: 0, milliseconds: 0, minutes: 0, seconds: 0 };
+    function add(a, b) {
+        return {
+            days: (a.days || 0) + b.days,
+            hours: (a.hours || 0) + b.hours,
+            milliseconds: (a.milliseconds || 0) + b.milliseconds,
+            minutes: (a.minutes || 0) + b.minutes,
+            seconds: (a.seconds || 0) + b.seconds
+        };
+    }
+    function extractSecs(ms) {
+        const s = ms / 1000;
+        if (s < 60) {
+            const seconds = ~~s;
+            return add({ seconds }, extractTime(ms - (seconds * 1000)));
+        }
+        const m = s / 60;
+        if (m < 60) {
+            const minutes = ~~m;
+            return add({ minutes }, extractTime(ms - (minutes * MIN_MS)));
+        }
+        const h = m / 60;
+        if (h < 24) {
+            const hours = ~~h;
+            return add({ hours }, extractTime(ms - (hours * HR_MS)));
+        }
+        const days = ~~(h / 24);
+        return add({ days }, extractTime(ms - (days * DAY_MS)));
+    }
+    function extractTime(milliseconds) {
+        return !milliseconds
+            ? ZERO
+            : milliseconds < 1000
+                ? add({ milliseconds }, ZERO)
+                : extractSecs(milliseconds);
+    }
+
+    function floatToU8a(value = 0.0, { bitLength = 32, isLe = true } = {}) {
+        if (bitLength !== 32 && bitLength !== 64) {
+            throw new Error('Invalid bitLength provided, expected 32 or 64');
+        }
+        const result = new Uint8Array(bitLength / 8);
+        const dv = new DataView(result.buffer, result.byteOffset);
+        if (bitLength === 32) {
+            dv.setFloat32(0, Number(value), isLe);
+        }
+        else {
+            dv.setFloat64(0, Number(value), isLe);
+        }
+        return result;
+    }
+
+    function isBoolean(value) {
+        return typeof value === 'boolean';
+    }
+
+    const NUMBER_REGEX = new RegExp('(\\d+?)(?=(\\d{3})+(?!\\d)|$)', 'g');
+    function formatDecimal(value, separator = ',') {
+        const isNegative = value[0].startsWith('-');
+        const matched = isNegative
+            ? value.substring(1).match(NUMBER_REGEX)
+            : value.match(NUMBER_REGEX);
+        return matched
+            ? `${isNegative ? '-' : ''}${matched.join(separator)}`
+            : value;
+    }
+
+    function getSeparator(locale) {
+        return {
+            decimal: (0.1).toLocaleString(locale, { useGrouping: false }).charAt(1),
+            thousand: (1000).toLocaleString(locale, { useGrouping: true }).replace(/\d/g, '').charAt(0)
+        };
+    }
+
+    const SI_MID = 8;
+    const SI = [
+        { power: -24, text: 'yocto', value: 'y' },
+        { power: -21, text: 'zepto', value: 'z' },
+        { power: -18, text: 'atto', value: 'a' },
+        { power: -15, text: 'femto', value: 'f' },
+        { power: -12, text: 'pico', value: 'p' },
+        { power: -9, text: 'nano', value: 'n' },
+        { power: -6, text: 'micro', value: 'µ' },
+        { power: -3, text: 'milli', value: 'm' },
+        { power: 0, text: 'Unit', value: '-' },
+        { power: 3, text: 'Kilo', value: 'k' },
+        { power: 6, text: 'Mill', value: 'M' },
+        { power: 9, text: 'Bill', value: 'B' },
+        { power: 12, text: 'Tril', value: 'T' },
+        { power: 15, text: 'Peta', value: 'P' },
+        { power: 18, text: 'Exa', value: 'E' },
+        { power: 21, text: 'Zeta', value: 'Z' },
+        { power: 24, text: 'Yotta', value: 'Y' }
+    ];
+    function findSi(type) {
+        for (let i = 0, count = SI.length; i < count; i++) {
+            if (SI[i].value === type) {
+                return SI[i];
+            }
+        }
+        return SI[SI_MID];
+    }
+    function calcSi(text, decimals, forceUnit) {
+        if (forceUnit) {
+            return findSi(forceUnit);
+        }
+        const siDefIndex = (SI_MID - 1) + Math.ceil((text.length - decimals) / 3);
+        return SI[siDefIndex] || SI[siDefIndex < 0 ? 0 : SI.length - 1];
+    }
+
+    const DEFAULT_DECIMALS = 0;
+    const DEFAULT_UNIT = SI[SI_MID].text;
+    let defaultDecimals = DEFAULT_DECIMALS;
+    let defaultUnit = DEFAULT_UNIT;
+    function _formatBalance(input, { decimals = defaultDecimals, forceUnit, locale = 'en', withAll = false, withSi = true, withSiFull = false, withUnit = true, withZero = true } = {}) {
+        let text = bnToBn(input).toString();
+        if (text.length === 0 || text === '0') {
+            return '0';
+        }
+        let sign = '';
+        if (text[0].startsWith('-')) {
+            sign = '-';
+            text = text.substring(1);
+        }
+        const si = calcSi(text, decimals, forceUnit);
+        const mid = text.length - (decimals + si.power);
+        const pre = mid <= 0 ? '0' : text.substring(0, mid);
+        let post = text
+            .padStart(mid < 0 ? decimals : 1, '0')
+            .substring(mid < 0 ? 0 : mid)
+            .padEnd(withAll ? Math.max(decimals, 4) : 4, '0')
+            .substring(0, withAll ? Math.max(4, decimals + si.power) : 4);
+        if (!withZero) {
+            let end = post.length - 1;
+            do {
+                if (post[end] === '0') {
+                    end--;
+                }
+            } while (post[end] === '0');
+            post = post.substring(0, end + 1);
+        }
+        const unit = isBoolean(withUnit)
+            ? SI[SI_MID].text
+            : withUnit;
+        const units = withSi || withSiFull
+            ? si.value === '-'
+                ? withUnit
+                    ? ` ${unit}`
+                    : ''
+                : ` ${withSiFull ? `${si.text}${withUnit ? ' ' : ''}` : si.value}${withUnit ? unit : ''}`
+            : '';
+        const { decimal, thousand } = getSeparator(locale);
+        return `${sign}${formatDecimal(pre, thousand)}${post && `${decimal}${post}`}${units}`;
+    }
+    const formatBalance = _formatBalance;
+    formatBalance.calcSi = (text, decimals = defaultDecimals) => calcSi(text, decimals);
+    formatBalance.findSi = findSi;
+    formatBalance.getDefaults = () => {
+        return {
+            decimals: defaultDecimals,
+            unit: defaultUnit
+        };
+    };
+    formatBalance.getOptions = (decimals = defaultDecimals) => {
+        return SI.filter(({ power }) => power < 0
+            ? (decimals + power) >= 0
+            : true);
+    };
+    formatBalance.setDefaults = ({ decimals, unit }) => {
+        defaultDecimals = (Array.isArray(decimals)
+            ? decimals[0]
+            : decimals) ?? defaultDecimals;
+        defaultUnit = (Array.isArray(unit)
+            ? unit[0]
+            : unit) ?? defaultUnit;
+        SI[SI_MID].text = defaultUnit;
+    };
+
+    function zeroPad(value) {
+        return value.toString().padStart(2, '0');
+    }
+    function formatDate(date) {
+        const year = date.getFullYear().toString();
+        const month = zeroPad((date.getMonth() + 1));
+        const day = zeroPad(date.getDate());
+        const hour = zeroPad(date.getHours());
+        const minute = zeroPad(date.getMinutes());
+        const second = zeroPad(date.getSeconds());
+        return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+    }
+
+    function formatValue(elapsed) {
+        if (elapsed < 15) {
+            return `${elapsed.toFixed(1)}s`;
+        }
+        else if (elapsed < 60) {
+            return `${elapsed | 0}s`;
+        }
+        else if (elapsed < 3600) {
+            return `${elapsed / 60 | 0}m`;
+        }
+        return `${elapsed / 3600 | 0}h`;
+    }
+    function formatElapsed(now, value) {
+        const tsNow = now?.getTime() || 0;
+        const tsValue = value instanceof Date
+            ? value.getTime()
+            : bnToBn(value).toNumber();
+        return (tsNow && tsValue)
+            ? formatValue(Math.max(Math.abs(tsNow - tsValue), 0) / 1000)
+            : '0.0s';
+    }
+
+    function formatNumber(value, { locale = 'en' } = {}) {
+        const { thousand } = getSeparator(locale);
+        return formatDecimal(bnToBn(value).toString(), thousand);
+    }
+
+    function hexHasPrefix(value) {
+        return !!value && isHex(value, -1);
+    }
+
+    function hexAddPrefix(value) {
+        return value && hexHasPrefix(value)
+            ? value
+            : `0x${value && value.length % 2 === 1 ? '0' : ''}${value || ''}`;
+    }
+
+    function hexFixLength(value, bitLength = -1, withPadding = false) {
+        const strLength = Math.ceil(bitLength / 4);
+        const hexLength = strLength + 2;
+        return hexAddPrefix((bitLength === -1 || value.length === hexLength || (!withPadding && value.length < hexLength))
+            ? hexStripPrefix(value)
+            : (value.length > hexLength)
+                ? hexStripPrefix(value).slice(-1 * strLength)
+                : `${'0'.repeat(strLength)}${hexStripPrefix(value)}`.slice(-1 * strLength));
+    }
+
+    function hexToNumber(value) {
+        return value
+            ? hexToBn(value).toNumber()
+            : NaN;
+    }
+
+    function hexToString(_value) {
+        return u8aToString(hexToU8a(_value));
+    }
+
+    function isArray(value) {
+        return Array.isArray(value);
+    }
+
+    function isString(value) {
+        return typeof value === 'string' || value instanceof String;
+    }
+
+    function isAsciiStr(str) {
+        for (let i = 0, count = str.length; i < count; i++) {
+            const b = str.charCodeAt(i);
+            if (b < 32 || b > 126) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function isAsciiBytes(u8a) {
+        for (let i = 0, count = u8a.length; i < count; i++) {
+            const b = u8a[i] | 0;
+            if (b < 32 || b > 126) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function isAscii(value) {
+        return isString(value)
+            ? isHex(value)
+                ? isAsciiBytes(u8aToU8a(value))
+                : isAsciiStr(value)
+            : value
+                ? isAsciiBytes(value)
+                : false;
+    }
+
+    const isClass =  isOnFunction('isPrototypeOf', 'hasOwnProperty');
+
+    function isChildClass(Parent, Child) {
+        return isClass(Child) && isClass(Parent)
+            ? Parent === Child || Parent.isPrototypeOf(Child)
+            : false;
+    }
+
+    const checkCodec =  isOnObject('toHex', 'toHuman', 'toU8a');
+    const checkRegistry =  isOnObject('get');
+    function isCodec(value) {
+        return checkCodec(value) && checkRegistry(value.registry);
+    }
+
+    const isCompact =  isOnObject('toBigInt', 'toBn', 'toNumber', 'unwrap');
+
+    function isError(value) {
+        return (((value && value.constructor) === Error) ||
+            value instanceof Error);
+    }
+
+    function isInstanceOf(value, Clazz) {
+        return (((value && value.constructor) === Clazz) ||
+            value instanceof Clazz);
+    }
+
+    const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
+    const v6s = '[a-fA-F\\d]{1,4}';
+    const v6 = `
+(?:
+(?:${v6s}:){7}(?:${v6s}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6s}:){6}(?:${v4}|:${v6s}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6s}:){5}(?::${v4}|(?::${v6s}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6s}:){4}(?:(?::${v6s}){0,1}:${v4}|(?::${v6s}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6s}:){3}(?:(?::${v6s}){0,2}:${v4}|(?::${v6s}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6s}:){2}(?:(?::${v6s}){0,3}:${v4}|(?::${v6s}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6s}:){1}(?:(?::${v6s}){0,4}:${v4}|(?::${v6s}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6s}){0,5}:${v4}|(?::${v6s}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`.replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim();
+    const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+    const v4exact = new RegExp(`^${v4}$`);
+    const v6exact = new RegExp(`^${v6}$`);
+    function isIp(value, type) {
+        switch (type) {
+            case 'v4': return v4exact.test(value);
+            case 'v6': return v6exact.test(value);
+            default: return v46Exact.test(value);
+        }
+    }
+
+    function replacer(_, v) {
+        return isBigInt(v)
+            ? v.toString()
+            : v;
+    }
+    function stringify(value, space) {
+        return JSON.stringify(value, replacer, space);
+    }
+
+    function isJsonObject(value) {
+        const str = typeof value !== 'string'
+            ? stringify(value)
+            : value;
+        try {
+            const obj = JSON.parse(str);
+            return typeof obj === 'object' && obj !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+
+    function isNull(value) {
+        return value === null;
+    }
+
+    function isNumber(value) {
+        return typeof value === 'number';
+    }
+
+    const isObservable =  isOn('next');
+
+    const isPromise =  isOnObject('catch', 'then');
+
+    const ELF_MAGIC = new Uint8Array([0x7f, 0x45, 0x4c, 0x46]);
+    const PVM_MAGIC = new Uint8Array([0x50, 0x56, 0x4d, 0x00]);
+    function isRiscV(bytes) {
+        if (isU8a(bytes)) {
+            const start = bytes.subarray(0, 4);
+            return u8aEq(start, PVM_MAGIC) || u8aEq(start, ELF_MAGIC);
+        }
+        return false;
+    }
+
+    const REGEX_DEV = /(Development|Local Testnet)$/;
+    function isTestChain(chain) {
+        if (!chain) {
+            return false;
+        }
+        return !!REGEX_DEV.test(chain.toString());
+    }
+
+    function isUndefined(value) {
+        return value === undefined;
+    }
+
+    function isUtf8(value) {
+        if (!value) {
+            return isString(value);
+        }
+        const u8a = u8aToU8a(value);
+        const len = u8a.length;
+        let i = 0;
+        while (i < len) {
+            if (u8a[i] <= 0x7F)  {
+                i += 1;
+            }
+            else if (u8a[i] >= 0xC2 && u8a[i] <= 0xDF)  {
+                if (i + 1 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 2;
+            }
+            else if (u8a[i] === 0xE0)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0xA0 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] >= 0xE1 && u8a[i] <= 0xEC)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] === 0xED)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x9F) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] >= 0xEE && u8a[i] <= 0xEF)  {
+                if (i + 2 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 3;
+            }
+            else if (u8a[i] === 0xF0)  {
+                if (i + 3 < len)  {
+                    if (u8a[i + 1] < 0x90 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 4;
+            }
+            else if (u8a[i] >= 0xF1 && u8a[i] <= 0xF3)  {
+                if (i + 3 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 4;
+            }
+            else if (u8a[i] === 0xF4)  {
+                if (i + 3 < len)  {
+                    if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x8F) {
+                        return false;
+                    }
+                    if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                        return false;
+                    }
+                    if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+                i += 4;
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    const WASM_MAGIC = new Uint8Array([0, 97, 115, 109]);
+    function isWasm(value) {
+        return isU8a(value) && u8aEq(value.subarray(0, 4), WASM_MAGIC);
+    }
+
+    function lazyMethod(result, item, creator, getName, index = 0) {
+        const name = getName
+            ? getName(item, index)
+            : item.toString();
+        let value;
+        Object.defineProperty(result, name, {
+            configurable: true,
+            enumerable: true,
+            get: function () {
+                if (value === undefined) {
+                    value = creator(item, index, this);
+                    try {
+                        Object.defineProperty(this, name, { value });
+                    }
+                    catch {
+                    }
+                }
+                return value;
+            }
+        });
+    }
+    function lazyMethods(result, items, creator, getName) {
+        for (let i = 0, count = items.length; i < count; i++) {
+            lazyMethod(result, items[i], creator, getName, i);
+        }
+        return result;
+    }
+
+    function identity(value) {
+        return value;
+    }
+    function noop() {
+    }
+
+    const logTo = {
+        debug: 'log',
+        error: 'error',
+        log: 'log',
+        warn: 'warn'
+    };
+    function formatOther(value) {
+        if (value && isObject(value) && value.constructor === Object) {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = loggerFormat(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    function loggerFormat(value) {
+        if (Array.isArray(value)) {
+            return value.map(loggerFormat);
+        }
+        else if (isBn(value)) {
+            return value.toString();
+        }
+        else if (isU8a(value) || isBuffer(value)) {
+            return u8aToHex(u8aToU8a(value));
+        }
+        return formatOther(value);
+    }
+    function formatWithLength(maxLength) {
+        return (v) => {
+            if (maxLength <= 0) {
+                return v;
+            }
+            const r = `${v}`;
+            return r.length < maxLength
+                ? v
+                : `${r.substring(0, maxLength)} ...`;
+        };
+    }
+    function apply(log, type, values, maxSize = -1) {
+        if (values.length === 1 && isFunction(values[0])) {
+            const fnResult = values[0]();
+            return apply(log, type, Array.isArray(fnResult) ? fnResult : [fnResult], maxSize);
+        }
+        console[logTo[log]](formatDate(new Date()), type, ...values
+            .map(loggerFormat)
+            .map(formatWithLength(maxSize)));
+    }
+    function isDebugOn(e, type) {
+        return !!e && (e === '*' ||
+            type === e ||
+            (e.endsWith('*') &&
+                type.startsWith(e.slice(0, -1))));
+    }
+    function isDebugOff(e, type) {
+        return !!e && (e.startsWith('-') &&
+            (type === e.slice(1) ||
+                (e.endsWith('*') &&
+                    type.startsWith(e.slice(1, -1)))));
+    }
+    function getDebugFlag(env, type) {
+        let flag = false;
+        for (const e of env) {
+            if (isDebugOn(e, type)) {
+                flag = true;
+            }
+            else if (isDebugOff(e, type)) {
+                flag = false;
+            }
+        }
+        return flag;
+    }
+    function parseEnv(type) {
+        const maxSize = parseInt(xglobal.process?.env?.['DEBUG_MAX'] || '-1', 10);
+        return [
+            getDebugFlag((xglobal.process?.env?.['DEBUG'] || '').toLowerCase().split(','), type),
+            isNaN(maxSize)
+                ? -1
+                : maxSize
+        ];
+    }
+    function logger(origin) {
+        const type = `${origin.toUpperCase()}:`.padStart(16);
+        const [isDebug, maxSize] = parseEnv(origin.toLowerCase());
+        return {
+            debug: isDebug
+                ? (...values) => apply('debug', type, values, maxSize)
+                : noop,
+            error: (...values) => apply('error', type, values),
+            log: (...values) => apply('log', type, values),
+            noop,
+            warn: (...values) => apply('warn', type, values)
+        };
+    }
+
+    function defaultGetId() {
+        return 'none';
+    }
+    function memoize(fn, { getInstanceId = defaultGetId } = {}) {
+        const cache = {};
+        const memoized = (...args) => {
+            const stringParams = stringify(args);
+            const instanceId = getInstanceId();
+            if (!cache[instanceId]) {
+                cache[instanceId] = {};
+            }
+            if (cache[instanceId][stringParams] === undefined) {
+                cache[instanceId][stringParams] = fn(...args);
+            }
+            return cache[instanceId][stringParams];
+        };
+        memoized.unmemoize = (...args) => {
+            const stringParams = stringify(args);
+            const instanceId = getInstanceId();
+            if (cache[instanceId]?.[stringParams] !== undefined) {
+                delete cache[instanceId][stringParams];
+            }
+        };
+        return memoized;
+    }
+
+    function nextTick(onExec, onError) {
+        setTimeout(() => {
+            Promise
+                .resolve()
+                .then(() => {
+                onExec();
+            })
+                .catch((error) => {
+                if (onError) {
+                    onError(error);
+                }
+                else {
+                    console.error(error);
+                }
+            });
+        }, 0);
+    }
+
+    function numberToHex(value, bitLength = -1) {
+        const hex = (!value || Number.isNaN(value) ? 0 : value).toString(16);
+        return hexFixLength(hex.length % 2 ? `0${hex}` : hex, bitLength, true);
+    }
+
+    function numberToU8a(value, bitLength = -1) {
+        return hexToU8a(numberToHex(value, bitLength));
+    }
+
+    function objectClear(value) {
+        const keys = Object.keys(value);
+        for (let i = 0, count = keys.length; i < count; i++) {
+            delete value[keys[i]];
+        }
+        return value;
+    }
+
+    function objectSpread(dest, ...sources) {
+        const filterProps = new Set(['__proto__', 'constructor', 'prototype']);
+        for (let i = 0, count = sources.length; i < count; i++) {
+            const src = sources[i];
+            if (src) {
+                if (typeof src.entries === 'function') {
+                    for (const [key, value] of src.entries()) {
+                        if (!filterProps.has(key)) {
+                            dest[key] = value;
+                        }
+                    }
+                }
+                else {
+                    const sanitizedSrc = Object.create(null);
+                    for (const [key, value] of Object.entries(src)) {
+                        if (!filterProps.has(key)) {
+                            sanitizedSrc[key] = value;
+                        }
+                    }
+                    Object.assign(dest, sanitizedSrc);
+                }
+            }
+        }
+        return dest;
+    }
+
+    function objectCopy(source) {
+        return objectSpread({}, source);
+    }
+
+    function objectEntries(obj) {
+        return Object.entries(obj);
+    }
+
+    function objectKeys(value) {
+        return Object.keys(value);
+    }
+
+    function objectProperty(that, key, getter, getName, index = 0) {
+        const name = getName
+            ? getName(key, index)
+            : key;
+        if (!(name in that)) {
+            Object.defineProperty(that, name, {
+                enumerable: true,
+                get: function () {
+                    return getter(key, index, this);
+                }
+            });
+        }
+    }
+    function objectProperties(that, keys, getter, getName) {
+        for (let i = 0, count = keys.length; i < count; i++) {
+            objectProperty(that, keys[i], getter, getName, i);
+        }
+    }
+
+    function objectValues(obj) {
+        return Object.values(obj);
+    }
+
+    function promisify(self, fn, ...params) {
+        return new Promise((resolve, reject) => {
+            fn.apply(self, params.concat((error, result) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(result);
+                }
+            }));
+        });
+    }
+
+    const CC_TO_UP = new Array(256);
+    const CC_TO_LO = new Array(256);
+    for (let i = 0, count = CC_TO_UP.length; i < count; i++) {
+        CC_TO_LO[i] = String.fromCharCode(i).toLowerCase();
+        CC_TO_UP[i] = String.fromCharCode(i).toUpperCase();
+    }
+    function formatAllCaps(w) {
+        return w.slice(0, w.length - 1).toLowerCase() + CC_TO_UP[w.charCodeAt(w.length - 1)];
+    }
+    function converter$1(format) {
+        return (value) => {
+            const parts = value
+                .replace(/[-_., ]+/g, ' ')
+                .trim()
+                .split(' ');
+            let result = '';
+            for (let i = 0, count = parts.length; i < count; i++) {
+                const w = parts[i];
+                result += format(/^[\dA-Z]+$/.test(w)
+                    ? w.toLowerCase()
+                    : w.replace(/^[\dA-Z]{2,}[^a-z]/, formatAllCaps), i);
+            }
+            return result;
+        };
+    }
+    const stringCamelCase =  converter$1((w, i) =>
+    (i ? CC_TO_UP[w.charCodeAt(0)] : CC_TO_LO[w.charCodeAt(0)]) + w.slice(1));
+    const stringPascalCase =  converter$1((w) =>
+    CC_TO_UP[w.charCodeAt(0)] + w.slice(1));
+
+    function converter(map) {
+        return (value) => value
+            ? map[value.charCodeAt(0)] + value.slice(1)
+            : '';
+    }
+    const stringLowerFirst =  converter(CC_TO_LO);
+    const stringUpperFirst =  converter(CC_TO_UP);
+
+    function stringShorten(value, prefixLength = 6) {
+        return value.length <= 2 + 2 * prefixLength
+            ? value.toString()
+            : `${value.substring(0, prefixLength)}…${value.slice(-prefixLength)}`;
+    }
+
+    function stringToHex(value) {
+        return u8aToHex(stringToU8a(value));
+    }
+
+    exports.BN = BN;
+    exports.BN_BILLION = BN_BILLION;
+    exports.BN_EIGHT = BN_EIGHT;
+    exports.BN_FIVE = BN_FIVE;
+    exports.BN_FOUR = BN_FOUR;
+    exports.BN_HUNDRED = BN_HUNDRED;
+    exports.BN_MAX_INTEGER = BN_MAX_INTEGER;
+    exports.BN_MILLION = BN_MILLION;
+    exports.BN_NINE = BN_NINE;
+    exports.BN_ONE = BN_ONE;
+    exports.BN_QUINTILL = BN_QUINTILL;
+    exports.BN_SEVEN = BN_SEVEN;
+    exports.BN_SIX = BN_SIX;
+    exports.BN_SQRT_MAX_INTEGER = BN_SQRT_MAX_INTEGER;
+    exports.BN_TEN = BN_TEN;
+    exports.BN_THOUSAND = BN_THOUSAND;
+    exports.BN_THREE = BN_THREE;
+    exports.BN_TWO = BN_TWO;
+    exports.BN_ZERO = BN_ZERO;
+    exports.POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG;
+    exports.U8A_WRAP_ETHEREUM = U8A_WRAP_ETHEREUM;
+    exports.U8A_WRAP_POSTFIX = U8A_WRAP_POSTFIX;
+    exports.U8A_WRAP_PREFIX = U8A_WRAP_PREFIX;
+    exports._0n = _0n;
+    exports._1000n = _1000n;
+    exports._100n = _100n;
+    exports._10n = _10n;
+    exports._1Bn = _1Bn;
+    exports._1Mn = _1Mn;
+    exports._1Qn = _1Qn;
+    exports._1n = _1n;
+    exports._2n = _2n;
+    exports._2pow53n = _2pow53n;
+    exports._3n = _3n;
+    exports._4n = _4n;
+    exports._5n = _5n;
+    exports._6n = _6n;
+    exports._7n = _7n;
+    exports._8n = _8n;
+    exports._9n = _9n;
+    exports._sqrt2pow53n = _sqrt2pow53n;
+    exports.arrayChunk = arrayChunk;
+    exports.arrayFilter = arrayFilter;
+    exports.arrayFlatten = arrayFlatten;
+    exports.arrayRange = arrayRange;
+    exports.arrayShuffle = arrayShuffle;
+    exports.arrayUnzip = arrayUnzip;
+    exports.arrayZip = arrayZip;
+    exports.assert = assert;
+    exports.assertReturn = assertReturn;
+    exports.assertUnreachable = assertUnreachable;
+    exports.bnFromHex = hexToBn;
+    exports.bnMax = bnMax;
+    exports.bnMin = bnMin;
+    exports.bnSqrt = bnSqrt;
+    exports.bnToBn = bnToBn;
+    exports.bnToHex = bnToHex;
+    exports.bnToU8a = bnToU8a;
+    exports.bufferToU8a = bufferToU8a;
+    exports.calcSi = calcSi;
+    exports.compactAddLength = compactAddLength;
+    exports.compactFromU8a = compactFromU8a;
+    exports.compactFromU8aLim = compactFromU8aLim;
+    exports.compactStripLength = compactStripLength;
+    exports.compactToU8a = compactToU8a;
+    exports.detectPackage = detectPackage;
+    exports.extractTime = extractTime;
+    exports.findSi = findSi;
+    exports.floatToU8a = floatToU8a;
+    exports.formatBalance = formatBalance;
+    exports.formatDate = formatDate;
+    exports.formatDecimal = formatDecimal;
+    exports.formatElapsed = formatElapsed;
+    exports.formatNumber = formatNumber;
+    exports.hasBigInt = hasBigInt;
+    exports.hasBuffer = hasBuffer;
+    exports.hasCjs = hasCjs;
+    exports.hasDirname = hasDirname;
+    exports.hasEsm = hasEsm;
+    exports.hasProcess = hasProcess;
+    exports.hasWasm = hasWasm;
+    exports.hexAddPrefix = hexAddPrefix;
+    exports.hexFixLength = hexFixLength;
+    exports.hexHasPrefix = hexHasPrefix;
+    exports.hexStripPrefix = hexStripPrefix;
+    exports.hexToBigInt = hexToBigInt;
+    exports.hexToBn = hexToBn;
+    exports.hexToNumber = hexToNumber;
+    exports.hexToString = hexToString;
+    exports.hexToU8a = hexToU8a;
+    exports.identity = identity;
+    exports.isArray = isArray;
+    exports.isAscii = isAscii;
+    exports.isBigInt = isBigInt;
+    exports.isBn = isBn;
+    exports.isBoolean = isBoolean;
+    exports.isBuffer = isBuffer;
+    exports.isChildClass = isChildClass;
+    exports.isClass = isClass;
+    exports.isCodec = isCodec;
+    exports.isCompact = isCompact;
+    exports.isError = isError;
+    exports.isFunction = isFunction;
+    exports.isHex = isHex;
+    exports.isInstanceOf = isInstanceOf;
+    exports.isIp = isIp;
+    exports.isJsonObject = isJsonObject;
+    exports.isNull = isNull;
+    exports.isNumber = isNumber;
+    exports.isObject = isObject;
+    exports.isObservable = isObservable;
+    exports.isPromise = isPromise;
+    exports.isRiscV = isRiscV;
+    exports.isString = isString;
+    exports.isTestChain = isTestChain;
+    exports.isToBigInt = isToBigInt;
+    exports.isToBn = isToBn;
+    exports.isU8a = isU8a;
+    exports.isUndefined = isUndefined;
+    exports.isUtf8 = isUtf8;
+    exports.isWasm = isWasm;
+    exports.lazyMethod = lazyMethod;
+    exports.lazyMethods = lazyMethods;
+    exports.logger = logger;
+    exports.loggerFormat = loggerFormat;
+    exports.memoize = memoize;
+    exports.nMax = nMax;
+    exports.nMin = nMin;
+    exports.nSqrt = nSqrt;
+    exports.nToBigInt = nToBigInt;
+    exports.nToHex = nToHex;
+    exports.nToU8a = nToU8a;
+    exports.nextTick = nextTick;
+    exports.noop = noop;
+    exports.numberToHex = numberToHex;
+    exports.numberToU8a = numberToU8a;
+    exports.objectClear = objectClear;
+    exports.objectCopy = objectCopy;
+    exports.objectEntries = objectEntries;
+    exports.objectKeys = objectKeys;
+    exports.objectProperties = objectProperties;
+    exports.objectProperty = objectProperty;
+    exports.objectSpread = objectSpread;
+    exports.objectValues = objectValues;
+    exports.packageInfo = packageInfo$3;
+    exports.promisify = promisify;
+    exports.stringCamelCase = stringCamelCase;
+    exports.stringLowerFirst = stringLowerFirst;
+    exports.stringPascalCase = stringPascalCase;
+    exports.stringShorten = stringShorten;
+    exports.stringToHex = stringToHex;
+    exports.stringToU8a = stringToU8a;
+    exports.stringUpperFirst = stringUpperFirst;
+    exports.stringify = stringify;
+    exports.u8aCmp = u8aCmp;
+    exports.u8aConcat = u8aConcat;
+    exports.u8aConcatStrict = u8aConcatStrict;
+    exports.u8aEmpty = u8aEmpty;
+    exports.u8aEq = u8aEq;
+    exports.u8aFixLength = u8aFixLength;
+    exports.u8aIsWrapped = u8aIsWrapped;
+    exports.u8aSorted = u8aSorted;
+    exports.u8aToBigInt = u8aToBigInt;
+    exports.u8aToBn = u8aToBn;
+    exports.u8aToBuffer = u8aToBuffer;
+    exports.u8aToFloat = u8aToFloat;
+    exports.u8aToHex = u8aToHex;
+    exports.u8aToNumber = u8aToNumber;
+    exports.u8aToString = u8aToString;
+    exports.u8aToU8a = u8aToU8a;
+    exports.u8aUnwrapBytes = u8aUnwrapBytes;
+    exports.u8aWrapBytes = u8aWrapBytes;
+
+}));
diff --git a/scripts/root/package-lock.json b/scripts/root/package-lock.json
new file mode 100644
index 0000000..ced3db7
--- /dev/null
+++ b/scripts/root/package-lock.json
@@ -0,0 +1,562 @@
+{
+  "name": "pezkuwi-wallet-utils-root",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "pezkuwi-wallet-utils-root",
+      "dependencies": {
+        "@pezkuwi/util": "14.0.26",
+        "@pezkuwi/util-crypto": "14.0.26",
+        "@polkadot/util": "13.5.9",
+        "@polkadot/util-crypto": "13.5.9"
+      }
+    },
+    "node_modules/@noble/curves": {
+      "version": "1.9.7",
+      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.9.7.tgz",
+      "integrity": "sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw==",
+      "license": "MIT",
+      "dependencies": {
+        "@noble/hashes": "1.8.0"
+      },
+      "engines": {
+        "node": "^14.21.3 || >=16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@noble/hashes": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.21.3 || >=16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@pezkuwi/networks": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/networks/-/networks-14.0.26.tgz",
+      "integrity": "sha512-omDbJzFjDSm1FS32zebyNP1QGBk9/ZayM0YM0mUlOOwiLIP7iDVq3KQe2JdI7hm1dz01Lm68/hjerSoqiWEclA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/util": "14.0.26",
+        "@substrate/ss58-registry": "^1.51.0",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@pezkuwi/scure-sr25519": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/scure-sr25519/-/scure-sr25519-0.2.1.tgz",
+      "integrity": "sha512-KGxCR+fI4p8QyIpwmRNIj8fbq7O+yz0iZZ/O2HJBVE7O9D6ksBKwIILqODJfE6Qvrf3F8DyT6/3cPoR3e/s8iA==",
+      "license": "MIT",
+      "dependencies": {
+        "@noble/curves": "~1.9.2",
+        "@noble/hashes": "~1.8.0"
+      }
+    },
+    "node_modules/@pezkuwi/util": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/util/-/util-14.0.26.tgz",
+      "integrity": "sha512-xV7uct4jtIqf+9LixcCoTgYz8JEZ2eK6aosMD92Zu5DRPSW87QcCYBQuq8Phec0LdjGvC/l7DgiloQODhTtHWA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/x-bigint": "14.0.26",
+        "@pezkuwi/x-global": "14.0.26",
+        "@pezkuwi/x-textdecoder": "14.0.26",
+        "@pezkuwi/x-textencoder": "14.0.26",
+        "@types/bn.js": "^5.1.6",
+        "bn.js": "^5.2.1",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@pezkuwi/util-crypto": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/util-crypto/-/util-crypto-14.0.26.tgz",
+      "integrity": "sha512-YR+3N2FwKx3q9NF11q75O0lJ+SKpM9CNKPE7rLEoPvFt7wpHpB/GXOAekYhNtrotkcsI8v/WoyOi4RI9NiwYVQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@noble/curves": "^1.9.7",
+        "@noble/hashes": "^1.8.0",
+        "@pezkuwi/networks": "14.0.26",
+        "@pezkuwi/scure-sr25519": "^0.2.1",
+        "@pezkuwi/util": "14.0.26",
+        "@pezkuwi/wasm-crypto": "^7.5.20",
+        "@pezkuwi/wasm-util": "^7.5.20",
+        "@pezkuwi/x-bigint": "14.0.26",
+        "@pezkuwi/x-randomvalues": "14.0.26",
+        "@scure/base": "^1.1.7",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "14.0.26"
+      }
+    },
+    "node_modules/@pezkuwi/wasm-bridge": {
+      "version": "7.5.21",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/wasm-bridge/-/wasm-bridge-7.5.21.tgz",
+      "integrity": "sha512-KVWLXpmVHpYo1+woN+o8OK03Kk8+VwUtF/Dn5pnsVXbsGbXM22HWbx36ChzdkjpW35a5Ukfk92H0aCy8klfeDg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/wasm-util": "7.5.21",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "*",
+        "@pezkuwi/x-randomvalues": "*"
+      }
+    },
+    "node_modules/@pezkuwi/wasm-crypto": {
+      "version": "7.5.21",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/wasm-crypto/-/wasm-crypto-7.5.21.tgz",
+      "integrity": "sha512-gL771hQsC0NXPFTX4+yKTPEMfX1svRAM1lzep+LkniQcYqpqI4AAxzUaOGZYj5lQzXKSkgYpcaLuTZ441zPXAg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@noble/hashes": "^1.3.3",
+        "@pezkuwi/wasm-bridge": "7.5.21",
+        "@pezkuwi/wasm-crypto-asmjs": "7.5.21",
+        "@pezkuwi/wasm-crypto-init": "7.5.21",
+        "@pezkuwi/wasm-crypto-wasm": "7.5.21",
+        "@pezkuwi/wasm-util": "7.5.21",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "*",
+        "@pezkuwi/x-randomvalues": "*"
+      }
+    },
+    "node_modules/@pezkuwi/wasm-crypto-asmjs": {
+      "version": "7.5.21",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/wasm-crypto-asmjs/-/wasm-crypto-asmjs-7.5.21.tgz",
+      "integrity": "sha512-uqhAR3slp6qbn2Cf7g72v4Ko0hxWm/NuZL2ZDH65QBSGP9jkSnAoBjm5L7AO739quEVA8rFsR8CxN5gvzERspA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "*"
+      }
+    },
+    "node_modules/@pezkuwi/wasm-crypto-init": {
+      "version": "7.5.21",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/wasm-crypto-init/-/wasm-crypto-init-7.5.21.tgz",
+      "integrity": "sha512-pdgYqhsHIoxTdhwbxS8iacw4sFh3NLN9fJ3odzCAo4+QCr3xTU1FMjBiYJRkx6Q4BpthCjOWJPCwTEZnJ3lSCg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/wasm-bridge": "7.5.21",
+        "@pezkuwi/wasm-crypto-asmjs": "7.5.21",
+        "@pezkuwi/wasm-crypto-wasm": "7.5.21",
+        "@pezkuwi/wasm-util": "7.5.21",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "*",
+        "@pezkuwi/x-randomvalues": "*"
+      }
+    },
+    "node_modules/@pezkuwi/wasm-crypto-wasm": {
+      "version": "7.5.21",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/wasm-crypto-wasm/-/wasm-crypto-wasm-7.5.21.tgz",
+      "integrity": "sha512-TR8hHkjY6oga4aI9Irlv/y00+KwiCBMt+EyXi3mTUVNn7qKE4DwXbDc/az4rLK8p5Kno4/iyCF6YXuHbjEK4Ag==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/wasm-util": "7.5.21",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "*"
+      }
+    },
+    "node_modules/@pezkuwi/wasm-util": {
+      "version": "7.5.21",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/wasm-util/-/wasm-util-7.5.21.tgz",
+      "integrity": "sha512-KMiUHCEa6iFNLNWyw9GUf5/K2UP6RjCia2iSGjcazwBNofAQVpP6zfeLb9y5szpextKGkDsODxpcIFenJ3KcFQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "*"
+      }
+    },
+    "node_modules/@pezkuwi/x-bigint": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/x-bigint/-/x-bigint-14.0.26.tgz",
+      "integrity": "sha512-TiCUVJiW07KurXot79AuKsqdIKGCtysMVDKLGlUc7mxlDJ+BCNJVmi9D0vvbB/gboxfJqONFQKt8eOXHKFg1iw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/x-global": "14.0.26",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@pezkuwi/x-global": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/x-global/-/x-global-14.0.26.tgz",
+      "integrity": "sha512-3D/dgFUugJfJ59JETey2EPpWL7X7NOrSEgNj1Rt3Vu9zR74QNocc5HEcyapFKj2hNNp5gPPDOOWbrLkkDnbdXw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@pezkuwi/x-randomvalues": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/x-randomvalues/-/x-randomvalues-14.0.26.tgz",
+      "integrity": "sha512-9tQ5+e7b5sC6y7NWFojfkfKZNSmWBpB1dnuyMv5vJMPlBPlsscTYARfk8ln860XWLdemQBYBvYbibmEBtLFfSQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/x-global": "14.0.26",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@pezkuwi/util": "14.0.26",
+        "@pezkuwi/wasm-util": "*"
+      }
+    },
+    "node_modules/@pezkuwi/x-textdecoder": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/x-textdecoder/-/x-textdecoder-14.0.26.tgz",
+      "integrity": "sha512-O3l/pcT+7q89COMe+h+Gr+HLLym3k0RfWXWwEg6RYGBHxp77GfixwqAR/o6k6rBXNfxlAY60RcYUqu+DGkKSZw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/x-global": "14.0.26",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@pezkuwi/x-textencoder": {
+      "version": "14.0.26",
+      "resolved": "https://registry.npmjs.org/@pezkuwi/x-textencoder/-/x-textencoder-14.0.26.tgz",
+      "integrity": "sha512-aUk+h0g5iO+V3CZV1vdlRy4G9MbE0SbomB5Lw/8IkuQ+wNPK9JQ1FlArMhxVBfXM9JD8DPih/ViZsaNhWfjVVw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@pezkuwi/x-global": "14.0.26",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polkadot/networks": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/networks/-/networks-13.5.9.tgz",
+      "integrity": "sha512-nmKUKJjiLgcih0MkdlJNMnhEYdwEml2rv/h59ll2+rAvpsVWMTLCb6Cq6q7UC44+8kiWK2UUJMkFU+3PFFxndA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/util": "13.5.9",
+        "@substrate/ss58-registry": "^1.51.0",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polkadot/util": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/util/-/util-13.5.9.tgz",
+      "integrity": "sha512-pIK3XYXo7DKeFRkEBNYhf3GbCHg6dKQisSvdzZwuyzA6m7YxQq4DFw4IE464ve4Z7WsJFt3a6C9uII36hl9EWw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/x-bigint": "13.5.9",
+        "@polkadot/x-global": "13.5.9",
+        "@polkadot/x-textdecoder": "13.5.9",
+        "@polkadot/x-textencoder": "13.5.9",
+        "@types/bn.js": "^5.1.6",
+        "bn.js": "^5.2.1",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polkadot/util-crypto": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/util-crypto/-/util-crypto-13.5.9.tgz",
+      "integrity": "sha512-foUesMhxkTk8CZ0/XEcfvHk6I0O+aICqqVJllhOpyp/ZVnrTBKBf59T6RpsXx2pCtBlMsLRvg/6Mw7RND1HqDg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@noble/curves": "^1.3.0",
+        "@noble/hashes": "^1.3.3",
+        "@polkadot/networks": "13.5.9",
+        "@polkadot/util": "13.5.9",
+        "@polkadot/wasm-crypto": "^7.5.3",
+        "@polkadot/wasm-util": "^7.5.3",
+        "@polkadot/x-bigint": "13.5.9",
+        "@polkadot/x-randomvalues": "13.5.9",
+        "@scure/base": "^1.1.7",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "13.5.9"
+      }
+    },
+    "node_modules/@polkadot/wasm-bridge": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/@polkadot/wasm-bridge/-/wasm-bridge-7.5.4.tgz",
+      "integrity": "sha512-6xaJVvoZbnbgpQYXNw9OHVNWjXmtcoPcWh7hlwx3NpfiLkkjljj99YS+XGZQlq7ks2fVCg7FbfknkNb8PldDaA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/wasm-util": "7.5.4",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "*",
+        "@polkadot/x-randomvalues": "*"
+      }
+    },
+    "node_modules/@polkadot/wasm-crypto": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto/-/wasm-crypto-7.5.4.tgz",
+      "integrity": "sha512-1seyClxa7Jd7kQjfnCzTTTfYhTa/KUTDUaD3DMHBk5Q4ZUN1D1unJgX+v1aUeXSPxmzocdZETPJJRZjhVOqg9g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/wasm-bridge": "7.5.4",
+        "@polkadot/wasm-crypto-asmjs": "7.5.4",
+        "@polkadot/wasm-crypto-init": "7.5.4",
+        "@polkadot/wasm-crypto-wasm": "7.5.4",
+        "@polkadot/wasm-util": "7.5.4",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "*",
+        "@polkadot/x-randomvalues": "*"
+      }
+    },
+    "node_modules/@polkadot/wasm-crypto-asmjs": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto-asmjs/-/wasm-crypto-asmjs-7.5.4.tgz",
+      "integrity": "sha512-ZYwxQHAJ8pPt6kYk9XFmyuFuSS+yirJLonvP+DYbxOrARRUHfN4nzp4zcZNXUuaFhpbDobDSFn6gYzye6BUotA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "*"
+      }
+    },
+    "node_modules/@polkadot/wasm-crypto-init": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto-init/-/wasm-crypto-init-7.5.4.tgz",
+      "integrity": "sha512-U6s4Eo2rHs2n1iR01vTz/sOQ7eOnRPjaCsGWhPV+ZC/20hkVzwPAhiizu/IqMEol4tO2yiSheD4D6bn0KxUJhg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/wasm-bridge": "7.5.4",
+        "@polkadot/wasm-crypto-asmjs": "7.5.4",
+        "@polkadot/wasm-crypto-wasm": "7.5.4",
+        "@polkadot/wasm-util": "7.5.4",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "*",
+        "@polkadot/x-randomvalues": "*"
+      }
+    },
+    "node_modules/@polkadot/wasm-crypto-wasm": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/@polkadot/wasm-crypto-wasm/-/wasm-crypto-wasm-7.5.4.tgz",
+      "integrity": "sha512-PsHgLsVTu43eprwSvUGnxybtOEuHPES6AbApcs7y5ZbM2PiDMzYbAjNul098xJK/CPtrxZ0ePDFnaQBmIJyTFw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/wasm-util": "7.5.4",
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "*"
+      }
+    },
+    "node_modules/@polkadot/wasm-util": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/@polkadot/wasm-util/-/wasm-util-7.5.4.tgz",
+      "integrity": "sha512-hqPpfhCpRAqCIn/CYbBluhh0TXmwkJnDRjxrU9Bnqtw9nMNa97D8JuOjdd2pi0rxm+eeLQ/f1rQMp71RMM9t4w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "*"
+      }
+    },
+    "node_modules/@polkadot/x-bigint": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/x-bigint/-/x-bigint-13.5.9.tgz",
+      "integrity": "sha512-JVW6vw3e8fkcRyN9eoc6JIl63MRxNQCP/tuLdHWZts1tcAYao0hpWUzteqJY93AgvmQ91KPsC1Kf3iuuZCi74g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/x-global": "13.5.9",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polkadot/x-global": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/x-global/-/x-global-13.5.9.tgz",
+      "integrity": "sha512-zSRWvELHd3Q+bFkkI1h2cWIqLo1ETm+MxkNXLec3lB56iyq/MjWBxfXnAFFYFayvlEVneo7CLHcp+YTFd9aVSA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polkadot/x-randomvalues": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/x-randomvalues/-/x-randomvalues-13.5.9.tgz",
+      "integrity": "sha512-Uuuz3oubf1JCCK97fsnVUnHvk4BGp/W91mQWJlgl5TIOUSSTIRr+lb5GurCfl4kgnQq53Zi5fJV+qR9YumbnZw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/x-global": "13.5.9",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@polkadot/util": "13.5.9",
+        "@polkadot/wasm-util": "*"
+      }
+    },
+    "node_modules/@polkadot/x-textdecoder": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/x-textdecoder/-/x-textdecoder-13.5.9.tgz",
+      "integrity": "sha512-W2HhVNUbC/tuFdzNMbnXAWsIHSg9SC9QWDNmFD3nXdSzlXNgL8NmuiwN2fkYvCQBtp/XSoy0gDLx0C+Fo19cfw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/x-global": "13.5.9",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polkadot/x-textencoder": {
+      "version": "13.5.9",
+      "resolved": "https://registry.npmjs.org/@polkadot/x-textencoder/-/x-textencoder-13.5.9.tgz",
+      "integrity": "sha512-SG0MHnLUgn1ZxFdm0KzMdTHJ47SfqFhdIPMcGA0Mg/jt2rwrfrP3jtEIJMsHfQpHvfsNPfv55XOMmoPWuQnP/Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@polkadot/x-global": "13.5.9",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@scure/base": {
+      "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.2.6.tgz",
+      "integrity": "sha512-g/nm5FgUa//MCj1gV09zTJTaM6KBAHqLN907YVQqf7zC49+DcO4B1so4ZX07Ef10Twr6nuqYEH9GEggFXA4Fmg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@substrate/ss58-registry": {
+      "version": "1.51.0",
+      "resolved": "https://registry.npmjs.org/@substrate/ss58-registry/-/ss58-registry-1.51.0.tgz",
+      "integrity": "sha512-TWDurLiPxndFgKjVavCniytBIw+t4ViOi7TYp9h/D0NMmkEc9klFTo+827eyEJ0lELpqO207Ey7uGxUa+BS1jQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@types/bn.js": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.2.0.tgz",
+      "integrity": "sha512-DLbJ1BPqxvQhIGbeu8VbUC1DiAiahHtAYvA0ZEAa4P31F7IaArc8z3C3BRQdWX4mtLQuABG4yzp76ZrS02Ui1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "26.6.6",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.6.6.tgz",
+      "integrity": "sha512-MzQj+8Kx3XI40OmUAE6Qoh58ZMNstNNMwn2nfd3qWsfe7nDNSqJNzes4njhz6AHwrSHOffSLwXU6yb474Q4aog==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~8.9.0"
+      }
+    },
+    "node_modules/bn.js": {
+      "version": "5.2.5",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.5.tgz",
+      "integrity": "sha512-Vq886eXykuP5E6HcKSSStP3bJgrE6In5WKxVUvJ8XGpWWYs2xZHWqUwzCtGgEtBcxyd57KBFDPFoUfNzdaHCNg==",
+      "license": "MIT"
+    },
+    "node_modules/tslib": {
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.9.1.tgz",
+      "integrity": "sha512-a4Ux9VKuIMHsOS7ENbEq6hK2ZGYIT27Rtl0E4eD9KqwxhKiQeMZE/9xb3IdYwWaSOyIBQLExhQgXDTYoiCxnWA==",
+      "license": "0BSD"
+    },
+    "node_modules/undici-types": {
+      "version": "8.9.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.9.0.tgz",
+      "integrity": "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg==",
+      "license": "MIT"
+    }
+  }
+}
diff --git a/scripts/root/package.json b/scripts/root/package.json
new file mode 100644
index 0000000..dab3926
--- /dev/null
+++ b/scripts/root/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "pezkuwi-wallet-utils-root",
+  "private": true,
+  "type": "module",
+  "description": "Verifies the signed config root chain as the wallet does",
+  "dependencies": {
+    "@pezkuwi/util": "14.0.26",
+    "@pezkuwi/util-crypto": "14.0.26",
+    "@polkadot/util": "13.5.9",
+    "@polkadot/util-crypto": "13.5.9"
+  }
+}
diff --git a/scripts/root/verify_root.mjs b/scripts/root/verify_root.mjs
new file mode 100644
index 0000000..a29f003
--- /dev/null
+++ b/scripts/root/verify_root.mjs
@@ -0,0 +1,130 @@
+// Verifies the published root chain the way the wallet does, so a root that installed wallets would refuse
+// is never published: a root they cannot verify stops their config refresh.
+//
+// signed/root.json is the root the APK carries. Each signed/root.N.json after it must be the next version and
+// carry valid signatures from a threshold of the previous root's keys and of its own. An sr25519 key is a
+// wallet account and signs <Bytes>payload</Bytes>. Wallet 1.3.0 checks sr25519 under the "substrate" signing
+// context only, so that is what counts; a signature valid only under "bizinikiwi" is reported, not counted.
+//
+//   node scripts/root/verify_root.mjs              check the published chain
+//   node scripts/root/verify_root.mjs FILE...      also report the signatures on proposals
+
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { cryptoWaitReady as polkadotReady, sr25519Verify as substrateVerify } from '@polkadot/util-crypto';
+import { cryptoWaitReady as pezkuwiReady, sr25519Verify as bizinikiwiVerify, ed25519Verify } from '@pezkuwi/util-crypto';
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const SIGNED = join(REPO, 'signed');
+
+const sha256Hex = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const wrapBytes = (payload) => Buffer.concat([Buffer.from('<Bytes>'), payload, Buffer.from('</Bytes>')]);
+
+function readEnvelope(path) {
+  const envelope = JSON.parse(readFileSync(path, 'utf8'));
+  const payload = Buffer.from(envelope.signed, 'base64');
+  return { payload, root: JSON.parse(payload.toString('utf8')), signatures: envelope.signatures };
+}
+
+function parseRoot(root) {
+  if (root.type !== 'root') throw new Error(`type is ${root.type}, not root`);
+  const keys = {};
+  for (const [keyId, key] of Object.entries(root.keys)) {
+    const bytes = Buffer.from(key.public, 'base64');
+    if (bytes.length !== 32 || sha256Hex(bytes) !== keyId) throw new Error(`key ${keyId} does not match its id`);
+    if (key.scheme !== 'sr25519' && key.scheme !== 'ed25519') throw new Error(`key ${keyId} has unknown scheme ${key.scheme}`);
+    keys[keyId] = { scheme: key.scheme, bytes };
+  }
+  for (const role of ['root', 'targets']) {
+    const { keyids, threshold } = root[role];
+    if (threshold < 1 || threshold > keyids.length || !keyids.every((id) => id in keys)) throw new Error(`unusable ${role} role`);
+  }
+  return keys;
+}
+
+// keyId -> "substrate" | "bizinikiwi" | "ed25519" | null for each signature on payload
+function classify(payload, signatures, keys) {
+  const result = new Map();
+  for (const { keyid, sig } of signatures) {
+    const key = keys[keyid];
+    if (!key) continue;
+    const signature = Buffer.from(sig, 'base64');
+    let kind = null;
+    if (key.scheme === 'ed25519') {
+      if (ed25519Verify(payload, signature, key.bytes)) kind = 'ed25519';
+    } else if (substrateVerify(wrapBytes(payload), signature, key.bytes)) {
+      kind = 'substrate';
+    } else if (bizinikiwiVerify(wrapBytes(payload), signature, key.bytes)) {
+      kind = 'bizinikiwi';
+    }
+    if (!result.get(keyid)) result.set(keyid, kind);
+  }
+  return result;
+}
+
+function count(classified, keyIds) {
+  const accepted = keyIds.filter((id) => ['substrate', 'ed25519'].includes(classified.get(id)));
+  const contextOnly = keyIds.filter((id) => classified.get(id) === 'bizinikiwi');
+  return { accepted: accepted.length, contextOnly: contextOnly.length };
+}
+
+function checkNext(previous, path) {
+  const next = readEnvelope(path);
+  const nextKeys = parseRoot(next.root);
+  if (next.root.version !== previous.root.version + 1) {
+    throw new Error(`version ${next.root.version} does not follow ${previous.root.version}`);
+  }
+  const lines = [];
+  let ok = true;
+  for (const [label, keys, role] of [
+    ['previous root', previous.keys, previous.root.root],
+    ['its own root', nextKeys, next.root.root],
+  ]) {
+    const { accepted, contextOnly } = count(classify(next.payload, next.signatures, keys), role.keyids);
+    const met = accepted >= role.threshold;
+    ok &&= met;
+    lines.push(`  ${label}: ${accepted} of ${role.threshold} required${contextOnly ? `, ${contextOnly} valid only under bizinikiwi (not accepted by wallet 1.3.0)` : ''}${met ? '' : '  <- NOT MET'}`);
+  }
+  return { ok, lines, next: { root: next.root, keys: nextKeys } };
+}
+
+await polkadotReady();
+await pezkuwiReady();
+
+let failed = false;
+const first = readEnvelope(join(SIGNED, 'root.json'));
+let current = { root: first.root, keys: parseRoot(first.root) };
+console.log(`root ${current.root.version}: carried by the APK`);
+
+for (let version = current.root.version + 1; existsSync(join(SIGNED, `root.${version}.json`)); version++) {
+  const path = join(SIGNED, `root.${version}.json`);
+  try {
+    const { ok, lines, next } = checkNext(current, path);
+    console.log(`root ${version}: ${ok ? 'accepted' : 'REFUSED'}`);
+    lines.forEach((line) => console.log(line));
+    if (!ok) {
+      console.log(`::error::signed/root.${version}.json would be refused by installed wallets and stop their config refresh`);
+      failed = true;
+      break;
+    }
+    current = next;
+  } catch (e) {
+    console.log(`::error::signed/root.${version}.json: ${e.message}`);
+    failed = true;
+    break;
+  }
+}
+
+for (const proposal of process.argv.slice(2)) {
+  try {
+    const { ok, lines } = checkNext(current, proposal);
+    console.log(`proposal ${proposal}: ${ok ? 'ready to publish' : 'not ready'}`);
+    lines.forEach((line) => console.log(line));
+  } catch (e) {
+    console.log(`proposal ${proposal}: ${e.message}`);
+  }
+}
+
+process.exit(failed ? 1 : 0);
diff --git a/scripts/signed_config.py b/scripts/signed_config.py
index 41c5171..9297941 100644
--- a/scripts/signed_config.py
+++ b/scripts/signed_config.py
@@ -9,7 +9,7 @@ Every metadata file is an envelope {"signed": base64(payload), "signatures": [{"
 hex sha256 of the 32-byte public key. An ed25519 key signs the payload bytes. An sr25519 key is a person's
 wallet account and signs through the wallet's message signing, which wraps the bytes as <Bytes>payload</Bytes>.
 
-  signed_config.py root    --version N --expires-days D --root-threshold T --root ADDR... --targets-pub FILE
+  signed_config.py root    --version N --expires-days D --root-threshold T --root ADDR... [--targets-pub FILE]
   signed_config.py sign    --key SEED_FILE [--expires-days D]
   signed_config.py check   [--min-days D]
 """
@@ -33,10 +33,14 @@ from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
 REPO = Path(__file__).resolve().parent.parent
 ROOT_FILE = REPO / "signed" / "root.json"
 TARGETS_FILE = REPO / "signed" / "targets.json"
+# A root after the first is drafted here, where the wallet never looks, and signed with the root signing page
+# beside it. Only a root with all its signatures moves to signed/: wallets that find a root they cannot verify
+# stop refreshing their config.
+PROPOSALS = REPO / "docs" / "root-signing" / "proposals"
 
 # Everything the wallet may fetch from this repository is JSON outside these trees; the wallet
 # refuses any other JSON file from here, so a tree is only left out when nothing reads it.
-UNSERVED = ("nova-base/", "pezkuwi-overlay/", "docs/", "signed/")
+UNSERVED = ("nova-base/", "pezkuwi-overlay/", "docs/", "signed/", "scripts/")
 
 BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 DAY = 86400
@@ -117,7 +121,13 @@ def cmd_root(args):
             "public": base64.b64encode(public).decode(),
         }
         root_ids.append(key_id(public))
-    targets_public = base64.b64decode(Path(args.targets_pub).read_text().strip())
+    if args.targets_pub:
+        targets_public = base64.b64decode(Path(args.targets_pub).read_text().strip())
+    else:
+        # Rotating the root keys keeps the targets key unless a new one is given.
+        previous = current_root()
+        (targets_id,) = previous["targets"]["keyids"]
+        targets_public = base64.b64decode(previous["keys"][targets_id]["public"])
     if len(targets_public) != 32:
         sys.exit("targets public key must be 32 bytes")
     keys[key_id(targets_public)] = {
@@ -135,11 +145,15 @@ def cmd_root(args):
         "root": {"keyids": sorted(root_ids), "threshold": args.root_threshold},
         "targets": {"keyids": [key_id(targets_public)], "threshold": 1},
     }
-    path = root_file(args.version)
-    path.parent.mkdir(exist_ok=True)
     # The first root is trusted because the APK carries it; a later one needs the signatures of a threshold
-    # of the previous root keys and of its own, collected from the holders' wallets and added to this file
-    # before it is published.
+    # of the previous root keys and of its own, collected with the root signing page, before it is published.
+    if args.version == 1:
+        path = ROOT_FILE
+    else:
+        if args.version != current_root()["version"] + 1:
+            sys.exit(f"the next root is version {current_root()['version'] + 1}")
+        path = PROPOSALS / f"root.{args.version}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(envelope(canonical(payload), []))
     print(f"wrote {path.relative_to(REPO)} version {args.version}")
 
@@ -241,7 +255,7 @@ def main():
     root.add_argument("--expires-days", type=int, required=True)
     root.add_argument("--root-threshold", type=int, required=True)
     root.add_argument("--root", nargs="+", required=True)
-    root.add_argument("--targets-pub", required=True)
+    root.add_argument("--targets-pub")
     root.set_defaults(run=cmd_root)
 
     sign = sub.add_parser("sign")