!(function (GLOBAL) {
  "use strict";
  GLOBAL.cryptocoin =
    ("undefined" == typeof floGlobals ? null : floGlobals.blockchain) || "BTC";
  const getRandomBytes = (function () {
    if ("function" == typeof require) {
      const crypto = require("crypto");
      return function (buf) {
        var bytes = crypto.randomBytes(buf.length);
        return buf.set(bytes), buf;
      };
    }
    if (GLOBAL.crypto && GLOBAL.crypto.getRandomValues)
      return function (buf) {
        return GLOBAL.crypto.getRandomValues(buf);
      };
    throw Error("Unable to define getRandomBytes");
  })();
  var C, util, charenc, UTF8, Binary, workerUrl, ec, ellipticEncryption, coinjs;
  (GLOBAL.securedMathRandom = (function () {
    if ("function" == typeof require) {
      const crypto = require("crypto");
      return function () {
        return crypto.randomBytes(4).readUInt32LE() / 4294967295;
      };
    }
    if (GLOBAL.crypto && GLOBAL.crypto.getRandomValues)
      return function () {
        return (
          GLOBAL.crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295
        );
      };
    throw Error("Unable to define securedMathRandom");
  })()),
    (function () {
      var base64map,
        util,
        charenc,
        Binary,
        d,
        k,
        g,
        b,
        a,
        c,
        e,
        Crypto = (GLOBAL.Crypto = {});
      /*!
       * Crypto-JS v2.5.4  Crypto.js
       * http://code.google.com/p/crypto-js/
       * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
       * http://code.google.com/p/crypto-js/wiki/License
       */ (base64map =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),
        (util = Crypto.util =
          {
            rotl: function (n, b) {
              return (n << b) | (n >>> (32 - b));
            },
            rotr: function (n, b) {
              return (n << (32 - b)) | (n >>> b);
            },
            endian: function (n) {
              if (n.constructor == Number)
                return (
                  (16711935 & util.rotl(n, 8)) | (4278255360 & util.rotl(n, 24))
                );
              for (var i = 0; i < n.length; i++) n[i] = util.endian(n[i]);
              return n;
            },
            randomBytes: function (n) {
              for (var bytes = []; n > 0; n--)
                bytes.push(Math.floor(256 * securedMathRandom()));
              return bytes;
            },
            bytesToWords: function (bytes) {
              for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
                words[b >>> 5] |= (255 & bytes[i]) << (24 - (b % 32));
              return words;
            },
            wordsToBytes: function (words) {
              for (var bytes = [], b = 0; b < 32 * words.length; b += 8)
                bytes.push((words[b >>> 5] >>> (24 - (b % 32))) & 255);
              return bytes;
            },
            bytesToHex: function (bytes) {
              for (var hex = [], i = 0; i < bytes.length; i++)
                hex.push((bytes[i] >>> 4).toString(16)),
                  hex.push((15 & bytes[i]).toString(16));
              return hex.join("");
            },
            hexToBytes: function (hex) {
              for (var bytes = [], c = 0; c < hex.length; c += 2)
                bytes.push(parseInt(hex.substr(c, 2), 16));
              return bytes;
            },
            bytesToBase64: function (bytes) {
              for (var base64 = [], i = 0; i < bytes.length; i += 3)
                for (
                  var triplet =
                      (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2],
                    j = 0;
                  j < 4;
                  j++
                )
                  8 * i + 6 * j <= 8 * bytes.length
                    ? base64.push(
                        base64map.charAt((triplet >>> (6 * (3 - j))) & 63)
                      )
                    : base64.push("=");
              return base64.join("");
            },
            base64ToBytes: function (base64) {
              base64 = base64.replace(/[^A-Z0-9+\/]/gi, "");
              for (
                var bytes = [], i = 0, imod4 = 0;
                i < base64.length;
                imod4 = ++i % 4
              )
                0 != imod4 &&
                  bytes.push(
                    ((base64map.indexOf(base64.charAt(i - 1)) &
                      (Math.pow(2, -2 * imod4 + 8) - 1)) <<
                      (2 * imod4)) |
                      (base64map.indexOf(base64.charAt(i)) >>> (6 - 2 * imod4))
                  );
              return bytes;
            },
          }),
        ((charenc = Crypto.charenc = {}).UTF8 = {
          stringToBytes: function (str) {
            return Binary.stringToBytes(unescape(encodeURIComponent(str)));
          },
          bytesToString: function (bytes) {
            return decodeURIComponent(escape(Binary.bytesToString(bytes)));
          },
        }),
        (Binary = charenc.Binary =
          {
            stringToBytes: function (str) {
              for (var bytes = [], i = 0; i < str.length; i++)
                bytes.push(255 & str.charCodeAt(i));
              return bytes;
            },
            bytesToString: function (bytes) {
              for (var str = [], i = 0; i < bytes.length; i++)
                str.push(String.fromCharCode(bytes[i]));
              return str.join("");
            },
          }),
        (function () {
          var C = Crypto,
            util = C.util,
            charenc = C.charenc,
            UTF8 = charenc.UTF8,
            Binary = charenc.Binary,
            SHA1 = (C.SHA1 = function (message, options) {
              var digestbytes = util.wordsToBytes(SHA1._sha1(message));
              return options && options.asBytes
                ? digestbytes
                : options && options.asString
                ? Binary.bytesToString(digestbytes)
                : util.bytesToHex(digestbytes);
            });
          (SHA1._sha1 = function (message) {
            message.constructor == String &&
              (message = UTF8.stringToBytes(message));
            var m = util.bytesToWords(message),
              l = 8 * message.length,
              w = [],
              H0 = 1732584193,
              H1 = -271733879,
              H2 = -1732584194,
              H3 = 271733878,
              H4 = -1009589776;
            (m[l >> 5] |= 128 << (24 - (l % 32))),
              (m[15 + (((l + 64) >>> 9) << 4)] = l);
            for (var i = 0; i < m.length; i += 16) {
              for (
                var a = H0, b = H1, c = H2, d = H3, e = H4, j = 0;
                j < 80;
                j++
              ) {
                if (j < 16) w[j] = m[i + j];
                else {
                  var n = w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16];
                  w[j] = (n << 1) | (n >>> 31);
                }
                var t =
                  ((H0 << 5) | (H0 >>> 27)) +
                  H4 +
                  (w[j] >>> 0) +
                  (j < 20
                    ? 1518500249 + ((H1 & H2) | (~H1 & H3))
                    : j < 40
                    ? 1859775393 + (H1 ^ H2 ^ H3)
                    : j < 60
                    ? ((H1 & H2) | (H1 & H3) | (H2 & H3)) - 1894007588
                    : (H1 ^ H2 ^ H3) - 899497514);
                (H4 = H3),
                  (H3 = H2),
                  (H2 = (H1 << 30) | (H1 >>> 2)),
                  (H1 = H0),
                  (H0 = t);
              }
              (H0 += a), (H1 += b), (H2 += c), (H3 += d), (H4 += e);
            }
            return [H0, H1, H2, H3, H4];
          }),
            (SHA1._blocksize = 16),
            (SHA1._digestsize = 20);
        })(),
        (function () {
          var C = Crypto,
            util = C.util,
            charenc = C.charenc,
            UTF8 = charenc.UTF8,
            Binary = charenc.Binary;
          C.HMAC = function (hasher, message, key, options) {
            message.constructor == String &&
              (message = UTF8.stringToBytes(message)),
              key.constructor == String && (key = UTF8.stringToBytes(key)),
              key.length > 4 * hasher._blocksize &&
                (key = hasher(key, { asBytes: !0 }));
            for (
              var okey = key.slice(0), ikey = key.slice(0), i = 0;
              i < 4 * hasher._blocksize;
              i++
            )
              (okey[i] ^= 92), (ikey[i] ^= 54);
            var hmacbytes = hasher(
              okey.concat(hasher(ikey.concat(message), { asBytes: !0 })),
              { asBytes: !0 }
            );
            return options && options.asBytes
              ? hmacbytes
              : options && options.asString
              ? Binary.bytesToString(hmacbytes)
              : util.bytesToHex(hmacbytes);
          };
        })(),
        (k = (d = Crypto).util),
        (g = d.charenc),
        (b = g.UTF8),
        (a = g.Binary),
        (c = [
          1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993,
          2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987,
          1925078388, 2162078206, 2614888103, 3248222580, 3835390401,
          4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692,
          1996064986, 2554220882, 2821834349, 2952996808, 3210313671,
          3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912,
          1294757372, 1396182291, 1695183700, 1986661051, 2177026350,
          2456956037, 2730485921, 2820302411, 3259730800, 3345764771,
          3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616,
          659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779,
          1955562222, 2024104815, 2227730452, 2361852424, 2428436474,
          2756734187, 3204031479, 3329325298,
        ]),
        (e = d.SHA256 =
          function (b, c) {
            var f = k.wordsToBytes(e._sha256(b));
            return c && c.asBytes
              ? f
              : c && c.asString
              ? a.bytesToString(f)
              : k.bytesToHex(f);
          }),
        (e._sha256 = function (a) {
          a.constructor == String && (a = b.stringToBytes(a));
          var g,
            m,
            r,
            i,
            n,
            o,
            s,
            t,
            h,
            l,
            j,
            e = k.bytesToWords(a),
            f = 8 * a.length,
            d =
              ((a = [
                1779033703, 3144134277, 1013904242, 2773480762, 1359893119,
                2600822924, 528734635, 1541459225,
              ]),
              []);
          for (
            e[f >> 5] |= 128 << (24 - (f % 32)),
              e[15 + (((f + 64) >> 9) << 4)] = f,
              t = 0;
            t < e.length;
            t += 16
          ) {
            for (
              f = a[0],
                g = a[1],
                m = a[2],
                r = a[3],
                i = a[4],
                n = a[5],
                o = a[6],
                s = a[7],
                h = 0;
              h < 64;
              h++
            ) {
              h < 16
                ? (d[h] = e[h + t])
                : ((l = d[h - 15]),
                  (j = d[h - 2]),
                  (d[h] =
                    (((l << 25) | (l >>> 7)) ^
                      ((l << 14) | (l >>> 18)) ^
                      (l >>> 3)) +
                    (d[h - 7] >>> 0) +
                    (((j << 15) | (j >>> 17)) ^
                      ((j << 13) | (j >>> 19)) ^
                      (j >>> 10)) +
                    (d[h - 16] >>> 0))),
                (j = (f & g) ^ (f & m) ^ (g & m));
              var u =
                ((f << 30) | (f >>> 2)) ^
                ((f << 19) | (f >>> 13)) ^
                ((f << 10) | (f >>> 22));
              (l =
                (s >>> 0) +
                (((i << 26) | (i >>> 6)) ^
                  ((i << 21) | (i >>> 11)) ^
                  ((i << 7) | (i >>> 25))) +
                ((i & n) ^ (~i & o)) +
                c[h] +
                (d[h] >>> 0)),
                (s = o),
                (o = n),
                (n = i),
                (i = (r + l) >>> 0),
                (r = m),
                (m = g),
                (g = f),
                (f = (l + (j = u + j)) >>> 0);
            }
            (a[0] += f),
              (a[1] += g),
              (a[2] += m),
              (a[3] += r),
              (a[4] += i),
              (a[5] += n),
              (a[6] += o),
              (a[7] += s);
          }
          return a;
        }),
        (e._blocksize = 16),
        (e._digestsize = 32),
        (function () {
          var d = Crypto,
            k = d.util,
            g = d.charenc,
            b = g.UTF8,
            a = g.Binary;
          d.HMAC = function (c, e, d, g) {
            e.constructor == String && (e = b.stringToBytes(e)),
              d.constructor == String && (d = b.stringToBytes(d)),
              d.length > 4 * c._blocksize && (d = c(d, { asBytes: !0 }));
            for (
              var f = d.slice(0), q = ((d = d.slice(0)), 0);
              q < 4 * c._blocksize;
              q++
            )
              (f[q] ^= 92), (d[q] ^= 54);
            return (
              (c = c(f.concat(c(d.concat(e), { asBytes: !0 })), {
                asBytes: !0,
              })),
              g && g.asBytes
                ? c
                : g && g.asString
                ? a.bytesToString(c)
                : k.bytesToHex(c)
            );
          };
        })();
    })(),
    (function () {
      /*!
       * Random number generator with ArcFour PRNG
       *
       * NOTE: For best results, put code like
       * <body onclick='SecureRandom.seedTime();' onkeypress='SecureRandom.seedTime();'>
       * in your main HTML document.
       *
       * Copyright Tom Wu, bitaddress.org  BSD License.
       * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
       */
      var sr = (GLOBAL.SecureRandom = function () {});
      if (
        (sr.state,
        sr.pool,
        sr.pptr,
        sr.poolCopyOnInit,
        (sr.poolSize = 256),
        (sr.prototype.nextBytes = function (ba) {
          var i;
          if (getRandomBytes && GLOBAL.Uint8Array)
            try {
              var rvBytes = new Uint8Array(ba.length);
              for (getRandomBytes(rvBytes), i = 0; i < ba.length; ++i)
                ba[i] = sr.getByte() ^ rvBytes[i];
              return;
            } catch (e) {
              alert(e);
            }
          for (i = 0; i < ba.length; ++i) ba[i] = sr.getByte();
        }),
        (sr.seedTime = function () {
          sr.seedInt(new Date().getTime());
        }),
        (sr.getByte = function () {
          if (null == sr.state) {
            for (
              sr.seedTime(),
                sr.state = sr.ArcFour(),
                sr.state.init(sr.pool),
                sr.poolCopyOnInit = [],
                sr.pptr = 0;
              sr.pptr < sr.pool.length;
              ++sr.pptr
            )
              sr.poolCopyOnInit[sr.pptr] = sr.pool[sr.pptr];
            sr.pptr = 0;
          }
          return sr.state.next();
        }),
        (sr.seedInt = function (x) {
          sr.seedInt8(x),
            sr.seedInt8(x >> 8),
            sr.seedInt8(x >> 16),
            sr.seedInt8(x >> 24);
        }),
        (sr.seedInt16 = function (x) {
          sr.seedInt8(x), sr.seedInt8(x >> 8);
        }),
        (sr.seedInt8 = function (x) {
          (sr.pool[sr.pptr++] ^= 255 & x),
            sr.pptr >= sr.poolSize && (sr.pptr -= sr.poolSize);
        }),
        (sr.ArcFour = function () {
          function Arcfour() {
            (this.i = 0), (this.j = 0), (this.S = new Array());
          }
          return (
            (Arcfour.prototype.init = function (key) {
              var i, j, t;
              for (i = 0; i < 256; ++i) this.S[i] = i;
              for (j = 0, i = 0; i < 256; ++i)
                (j = (j + this.S[i] + key[i % key.length]) & 255),
                  (t = this.S[i]),
                  (this.S[i] = this.S[j]),
                  (this.S[j] = t);
              (this.i = 0), (this.j = 0);
            }),
            (Arcfour.prototype.next = function () {
              var t;
              return (
                (this.i = (this.i + 1) & 255),
                (this.j = (this.j + this.S[this.i]) & 255),
                (t = this.S[this.i]),
                (this.S[this.i] = this.S[this.j]),
                (this.S[this.j] = t),
                this.S[(t + this.S[this.i]) & 255]
              );
            }),
            new Arcfour()
          );
        }),
        null == sr.pool)
      ) {
        var t;
        if (
          ((sr.pool = new Array()),
          (sr.pptr = 0),
          getRandomBytes && GLOBAL.Uint8Array)
        )
          try {
            var ua = new Uint8Array(sr.poolSize);
            for (getRandomBytes(ua), t = 0; t < sr.poolSize; ++t)
              sr.pool[sr.pptr++] = ua[t];
          } catch (e) {
            alert(e);
          }
        for (; sr.pptr < sr.poolSize; )
          (t = Math.floor(65536 * securedMathRandom())),
            (sr.pool[sr.pptr++] = t >>> 8),
            (sr.pool[sr.pptr++] = 255 & t);
        (sr.pptr = Math.floor(sr.poolSize * securedMathRandom())),
          sr.seedTime();
        var entropyStr = "";
        (entropyStr +=
          GLOBAL.screen.height *
          GLOBAL.screen.width *
          GLOBAL.screen.colorDepth),
          (entropyStr +=
            GLOBAL.screen.availHeight *
            GLOBAL.screen.availWidth *
            GLOBAL.screen.pixelDepth),
          (entropyStr += new Date().getTimezoneOffset()),
          (entropyStr += navigator.userAgent);
        for (var pluginsStr = "", i = 0; i < navigator.plugins.length; i++)
          pluginsStr +=
            navigator.plugins[i].name +
            " " +
            navigator.plugins[i].filename +
            " " +
            navigator.plugins[i].description +
            " " +
            navigator.plugins[i].version +
            ", ";
        var mimeTypesStr = "";
        for (i = 0; i < navigator.mimeTypes.length; i++)
          mimeTypesStr +=
            navigator.mimeTypes[i].description +
            " " +
            navigator.mimeTypes[i].type +
            " " +
            navigator.mimeTypes[i].suffixes +
            ", ";
        (entropyStr += pluginsStr + mimeTypesStr),
          (entropyStr +=
            navigator.cookieEnabled +
            typeof sessionStorage +
            typeof localStorage),
          (entropyStr += navigator.language),
          (entropyStr += GLOBAL.history.length),
          (entropyStr += GLOBAL.location);
        var entropyBytes = Crypto.SHA256(entropyStr, { asBytes: !0 });
        for (i = 0; i < entropyBytes.length; i++) sr.seedInt8(entropyBytes[i]);
      }
    })(),
    (function () {
      /** @preserve
        (c) 2012 by Cédric Mesnil. All rights reserved.
        Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
            - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
            - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
        */
      var zl = [
          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10,
          6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7,
          0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5,
          6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13,
        ],
        zr = [
          5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0,
          13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8,
          12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10,
          14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11,
        ],
        sl = [
          11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13,
          11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13,
          15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5,
          6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5,
          6,
        ],
        sr = [
          8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7,
          12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14,
          12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9,
          12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11,
        ],
        hl = [0, 1518500249, 1859775393, 2400959708, 2840853838],
        hr = [1352829926, 1548603684, 1836072691, 2053994217, 0],
        processBlock = function (H, M, offset) {
          for (var i = 0; i < 16; i++) {
            var offset_i = offset + i,
              M_offset_i = M[offset_i];
            M[offset_i] =
              (16711935 & ((M_offset_i << 8) | (M_offset_i >>> 24))) |
              (4278255360 & ((M_offset_i << 24) | (M_offset_i >>> 8)));
          }
          var al, bl, cl, dl, el, ar, br, cr, dr, er, t;
          (ar = al = H[0]),
            (br = bl = H[1]),
            (cr = cl = H[2]),
            (dr = dl = H[3]),
            (er = el = H[4]);
          for (i = 0; i < 80; i += 1)
            (t = (al + M[offset + zl[i]]) | 0),
              (t +=
                i < 16
                  ? f1(bl, cl, dl) + hl[0]
                  : i < 32
                  ? f2(bl, cl, dl) + hl[1]
                  : i < 48
                  ? f3(bl, cl, dl) + hl[2]
                  : i < 64
                  ? f4(bl, cl, dl) + hl[3]
                  : f5(bl, cl, dl) + hl[4]),
              (t = ((t = rotl((t |= 0), sl[i])) + el) | 0),
              (al = el),
              (el = dl),
              (dl = rotl(cl, 10)),
              (cl = bl),
              (bl = t),
              (t = (ar + M[offset + zr[i]]) | 0),
              (t +=
                i < 16
                  ? f5(br, cr, dr) + hr[0]
                  : i < 32
                  ? f4(br, cr, dr) + hr[1]
                  : i < 48
                  ? f3(br, cr, dr) + hr[2]
                  : i < 64
                  ? f2(br, cr, dr) + hr[3]
                  : f1(br, cr, dr) + hr[4]),
              (t = ((t = rotl((t |= 0), sr[i])) + er) | 0),
              (ar = er),
              (er = dr),
              (dr = rotl(cr, 10)),
              (cr = br),
              (br = t);
          (t = (H[1] + cl + dr) | 0),
            (H[1] = (H[2] + dl + er) | 0),
            (H[2] = (H[3] + el + ar) | 0),
            (H[3] = (H[4] + al + br) | 0),
            (H[4] = (H[0] + bl + cr) | 0),
            (H[0] = t);
        };
      function f1(x, y, z) {
        return x ^ y ^ z;
      }
      function f2(x, y, z) {
        return (x & y) | (~x & z);
      }
      function f3(x, y, z) {
        return (x | ~y) ^ z;
      }
      function f4(x, y, z) {
        return (x & z) | (y & ~z);
      }
      function f5(x, y, z) {
        return x ^ (y | ~z);
      }
      function rotl(x, n) {
        return (x << n) | (x >>> (32 - n));
      }
      GLOBAL.ripemd160 = function (message) {
        var H = [1732584193, 4023233417, 2562383102, 271733878, 3285377520],
          m = (function (bytes) {
            for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
              words[b >>> 5] |= bytes[i] << (24 - (b % 32));
            return words;
          })(message),
          nBitsLeft = 8 * message.length,
          nBitsTotal = 8 * message.length;
        (m[nBitsLeft >>> 5] |= 128 << (24 - (nBitsLeft % 32))),
          (m[14 + (((nBitsLeft + 64) >>> 9) << 4)] =
            (16711935 & ((nBitsTotal << 8) | (nBitsTotal >>> 24))) |
            (4278255360 & ((nBitsTotal << 24) | (nBitsTotal >>> 8))));
        for (var i = 0; i < m.length; i += 16) processBlock(H, m, i);
        for (i = 0; i < 5; i++) {
          var H_i = H[i];
          H[i] =
            (16711935 & ((H_i << 8) | (H_i >>> 24))) |
            (4278255360 & ((H_i << 24) | (H_i >>> 8)));
        }
        return (function (words) {
          for (var bytes = [], b = 0; b < 32 * words.length; b += 8)
            bytes.push((words[b >>> 5] >>> (24 - (b % 32))) & 255);
          return bytes;
        })(H);
      };
    })(),
    (function () {
      /*!
       * Basic JavaScript BN library - subset useful for RSA encryption. v1.4
       *
       * Copyright (c) 2005  Tom Wu
       * All Rights Reserved.
       * BSD License
       * http://www-cs-students.stanford.edu/~tjw/jsbn/LICENSE
       *
       * Copyright Stephan Thomas
       * Copyright pointbiz
       */
      var dbits,
        BigInteger = (GLOBAL.BigInteger = function BigInteger(a, b, c) {
          if (!(this instanceof BigInteger)) return new BigInteger(a, b, c);
          null != a &&
            ("number" == typeof a
              ? this.fromNumber(a, b, c)
              : null == b && "string" != typeof a
              ? this.fromString(a, 256)
              : this.fromString(a, b));
        });
      function nbi() {
        return new BigInteger(null);
      }
      "Microsoft Internet Explorer" == navigator.appName
        ? ((BigInteger.prototype.am = function (i, x, w, j, c, n) {
            for (var xl = 32767 & x, xh = x >> 15; --n >= 0; ) {
              var l = 32767 & this[i],
                h = this[i++] >> 15,
                m = xh * l + h * xl;
              (c =
                ((l =
                  xl * l + ((32767 & m) << 15) + w[j] + (1073741823 & c)) >>>
                  30) +
                (m >>> 15) +
                xh * h +
                (c >>> 30)),
                (w[j++] = 1073741823 & l);
            }
            return c;
          }),
          (dbits = 30))
        : "Netscape" != navigator.appName
        ? ((BigInteger.prototype.am = function (i, x, w, j, c, n) {
            for (; --n >= 0; ) {
              var v = x * this[i++] + w[j] + c;
              (c = Math.floor(v / 67108864)), (w[j++] = 67108863 & v);
            }
            return c;
          }),
          (dbits = 26))
        : ((BigInteger.prototype.am = function (i, x, w, j, c, n) {
            for (var xl = 16383 & x, xh = x >> 14; --n >= 0; ) {
              var l = 16383 & this[i],
                h = this[i++] >> 14,
                m = xh * l + h * xl;
              (c =
                ((l = xl * l + ((16383 & m) << 14) + w[j] + c) >> 28) +
                (m >> 14) +
                xh * h),
                (w[j++] = 268435455 & l);
            }
            return c;
          }),
          (dbits = 28)),
        (BigInteger.prototype.DB = dbits),
        (BigInteger.prototype.DM = (1 << dbits) - 1),
        (BigInteger.prototype.DV = 1 << dbits);
      (BigInteger.prototype.FV = Math.pow(2, 52)),
        (BigInteger.prototype.F1 = 52 - dbits),
        (BigInteger.prototype.F2 = 2 * dbits - 52);
      var rr,
        vv,
        BI_RC = new Array();
      for (rr = "0".charCodeAt(0), vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
      for (rr = "a".charCodeAt(0), vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
      for (rr = "A".charCodeAt(0), vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
      function int2char(n) {
        return "0123456789abcdefghijklmnopqrstuvwxyz".charAt(n);
      }
      function intAt(s, i) {
        var c = BI_RC[s.charCodeAt(i)];
        return null == c ? -1 : c;
      }
      function nbv(i) {
        var r = nbi();
        return r.fromInt(i), r;
      }
      function nbits(x) {
        var t,
          r = 1;
        return (
          0 != (t = x >>> 16) && ((x = t), (r += 16)),
          0 != (t = x >> 8) && ((x = t), (r += 8)),
          0 != (t = x >> 4) && ((x = t), (r += 4)),
          0 != (t = x >> 2) && ((x = t), (r += 2)),
          0 != (t = x >> 1) && ((x = t), (r += 1)),
          r
        );
      }
      function lbit(x) {
        if (0 == x) return -1;
        var r = 0;
        return (
          0 == (65535 & x) && ((x >>= 16), (r += 16)),
          0 == (255 & x) && ((x >>= 8), (r += 8)),
          0 == (15 & x) && ((x >>= 4), (r += 4)),
          0 == (3 & x) && ((x >>= 2), (r += 2)),
          0 == (1 & x) && ++r,
          r
        );
      }
      function cbit(x) {
        for (var r = 0; 0 != x; ) (x &= x - 1), ++r;
        return r;
      }
      (BigInteger.prototype.copyTo = function (r) {
        for (var i = this.t - 1; i >= 0; --i) r[i] = this[i];
        (r.t = this.t), (r.s = this.s);
      }),
        (BigInteger.prototype.fromInt = function (x) {
          (this.t = 1),
            (this.s = x < 0 ? -1 : 0),
            x > 0
              ? (this[0] = x)
              : x < -1
              ? (this[0] = x + this.DV)
              : (this.t = 0);
        }),
        (BigInteger.prototype.fromString = function (s, b) {
          var k;
          if (16 == b) k = 4;
          else if (8 == b) k = 3;
          else if (256 == b) k = 8;
          else if (2 == b) k = 1;
          else if (32 == b) k = 5;
          else {
            if (4 != b) return void this.fromRadix(s, b);
            k = 2;
          }
          (this.t = 0), (this.s = 0);
          for (var i = s.length, mi = !1, sh = 0; --i >= 0; ) {
            var x = 8 == k ? 255 & s[i] : intAt(s, i);
            x < 0
              ? "-" == s.charAt(i) && (mi = !0)
              : ((mi = !1),
                0 == sh
                  ? (this[this.t++] = x)
                  : sh + k > this.DB
                  ? ((this[this.t - 1] |=
                      (x & ((1 << (this.DB - sh)) - 1)) << sh),
                    (this[this.t++] = x >> (this.DB - sh)))
                  : (this[this.t - 1] |= x << sh),
                (sh += k) >= this.DB && (sh -= this.DB));
          }
          8 == k &&
            0 != (128 & s[0]) &&
            ((this.s = -1),
            sh > 0 && (this[this.t - 1] |= ((1 << (this.DB - sh)) - 1) << sh)),
            this.clamp(),
            mi && BigInteger.ZERO.subTo(this, this);
        }),
        (BigInteger.prototype.clamp = function () {
          for (var c = this.s & this.DM; this.t > 0 && this[this.t - 1] == c; )
            --this.t;
        }),
        (BigInteger.prototype.dlShiftTo = function (n, r) {
          var i;
          for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i];
          for (i = n - 1; i >= 0; --i) r[i] = 0;
          (r.t = this.t + n), (r.s = this.s);
        }),
        (BigInteger.prototype.drShiftTo = function (n, r) {
          for (var i = n; i < this.t; ++i) r[i - n] = this[i];
          (r.t = Math.max(this.t - n, 0)), (r.s = this.s);
        }),
        (BigInteger.prototype.lShiftTo = function (n, r) {
          var i,
            bs = n % this.DB,
            cbs = this.DB - bs,
            bm = (1 << cbs) - 1,
            ds = Math.floor(n / this.DB),
            c = (this.s << bs) & this.DM;
          for (i = this.t - 1; i >= 0; --i)
            (r[i + ds + 1] = (this[i] >> cbs) | c), (c = (this[i] & bm) << bs);
          for (i = ds - 1; i >= 0; --i) r[i] = 0;
          (r[ds] = c), (r.t = this.t + ds + 1), (r.s = this.s), r.clamp();
        }),
        (BigInteger.prototype.rShiftTo = function (n, r) {
          r.s = this.s;
          var ds = Math.floor(n / this.DB);
          if (ds >= this.t) r.t = 0;
          else {
            var bs = n % this.DB,
              cbs = this.DB - bs,
              bm = (1 << bs) - 1;
            r[0] = this[ds] >> bs;
            for (var i = ds + 1; i < this.t; ++i)
              (r[i - ds - 1] |= (this[i] & bm) << cbs),
                (r[i - ds] = this[i] >> bs);
            bs > 0 && (r[this.t - ds - 1] |= (this.s & bm) << cbs),
              (r.t = this.t - ds),
              r.clamp();
          }
        }),
        (BigInteger.prototype.subTo = function (a, r) {
          for (var i = 0, c = 0, m = Math.min(a.t, this.t); i < m; )
            (c += this[i] - a[i]), (r[i++] = c & this.DM), (c >>= this.DB);
          if (a.t < this.t) {
            for (c -= a.s; i < this.t; )
              (c += this[i]), (r[i++] = c & this.DM), (c >>= this.DB);
            c += this.s;
          } else {
            for (c += this.s; i < a.t; )
              (c -= a[i]), (r[i++] = c & this.DM), (c >>= this.DB);
            c -= a.s;
          }
          (r.s = c < 0 ? -1 : 0),
            c < -1 ? (r[i++] = this.DV + c) : c > 0 && (r[i++] = c),
            (r.t = i),
            r.clamp();
        }),
        (BigInteger.prototype.multiplyTo = function (a, r) {
          var x = this.abs(),
            y = a.abs(),
            i = x.t;
          for (r.t = i + y.t; --i >= 0; ) r[i] = 0;
          for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);
          (r.s = 0), r.clamp(), this.s != a.s && BigInteger.ZERO.subTo(r, r);
        }),
        (BigInteger.prototype.squareTo = function (r) {
          for (var x = this.abs(), i = (r.t = 2 * x.t); --i >= 0; ) r[i] = 0;
          for (i = 0; i < x.t - 1; ++i) {
            var c = x.am(i, x[i], r, 2 * i, 0, 1);
            (r[i + x.t] += x.am(
              i + 1,
              2 * x[i],
              r,
              2 * i + 1,
              c,
              x.t - i - 1
            )) >= x.DV && ((r[i + x.t] -= x.DV), (r[i + x.t + 1] = 1));
          }
          r.t > 0 && (r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)),
            (r.s = 0),
            r.clamp();
        }),
        (BigInteger.prototype.divRemTo = function (m, q, r) {
          var pm = m.abs();
          if (!(pm.t <= 0)) {
            var pt = this.abs();
            if (pt.t < pm.t)
              return (
                null != q && q.fromInt(0), void (null != r && this.copyTo(r))
              );
            null == r && (r = nbi());
            var y = nbi(),
              ts = this.s,
              ms = m.s,
              nsh = this.DB - nbits(pm[pm.t - 1]);
            nsh > 0
              ? (pm.lShiftTo(nsh, y), pt.lShiftTo(nsh, r))
              : (pm.copyTo(y), pt.copyTo(r));
            var ys = y.t,
              y0 = y[ys - 1];
            if (0 != y0) {
              var yt =
                  y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0),
                d1 = this.FV / yt,
                d2 = (1 << this.F1) / yt,
                e = 1 << this.F2,
                i = r.t,
                j = i - ys,
                t = null == q ? nbi() : q;
              for (
                y.dlShiftTo(j, t),
                  r.compareTo(t) >= 0 && ((r[r.t++] = 1), r.subTo(t, r)),
                  BigInteger.ONE.dlShiftTo(ys, t),
                  t.subTo(y, y);
                y.t < ys;

              )
                y[y.t++] = 0;
              for (; --j >= 0; ) {
                var qd =
                  r[--i] == y0
                    ? this.DM
                    : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);
                if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd)
                  for (y.dlShiftTo(j, t), r.subTo(t, r); r[i] < --qd; )
                    r.subTo(t, r);
              }
              null != q &&
                (r.drShiftTo(ys, q), ts != ms && BigInteger.ZERO.subTo(q, q)),
                (r.t = ys),
                r.clamp(),
                nsh > 0 && r.rShiftTo(nsh, r),
                ts < 0 && BigInteger.ZERO.subTo(r, r);
            }
          }
        }),
        (BigInteger.prototype.invDigit = function () {
          if (this.t < 1) return 0;
          var x = this[0];
          if (0 == (1 & x)) return 0;
          var y = 3 & x;
          return (y =
            ((y =
              ((y =
                ((y = (y * (2 - (15 & x) * y)) & 15) * (2 - (255 & x) * y)) &
                255) *
                (2 - (((65535 & x) * y) & 65535))) &
              65535) *
              (2 - ((x * y) % this.DV))) %
            this.DV) > 0
            ? this.DV - y
            : -y;
        }),
        (BigInteger.prototype.isEven = function () {
          return 0 == (this.t > 0 ? 1 & this[0] : this.s);
        }),
        (BigInteger.prototype.exp = function (e, z) {
          if (e > 4294967295 || e < 1) return BigInteger.ONE;
          var r = nbi(),
            r2 = nbi(),
            g = z.convert(this),
            i = nbits(e) - 1;
          for (g.copyTo(r); --i >= 0; )
            if ((z.sqrTo(r, r2), (e & (1 << i)) > 0)) z.mulTo(r2, g, r);
            else {
              var t = r;
              (r = r2), (r2 = t);
            }
          return z.revert(r);
        }),
        (BigInteger.prototype.toString = function (b) {
          if (this.s < 0) return "-" + this.negate().toString(b);
          var k;
          if (16 == b) k = 4;
          else if (8 == b) k = 3;
          else if (2 == b) k = 1;
          else if (32 == b) k = 5;
          else {
            if (4 != b) return this.toRadix(b);
            k = 2;
          }
          var d,
            km = (1 << k) - 1,
            m = !1,
            r = "",
            i = this.t,
            p = this.DB - ((i * this.DB) % k);
          if (i-- > 0)
            for (
              p < this.DB &&
              (d = this[i] >> p) > 0 &&
              ((m = !0), (r = int2char(d)));
              i >= 0;

            )
              p < k
                ? ((d = (this[i] & ((1 << p) - 1)) << (k - p)),
                  (d |= this[--i] >> (p += this.DB - k)))
                : ((d = (this[i] >> (p -= k)) & km),
                  p <= 0 && ((p += this.DB), --i)),
                d > 0 && (m = !0),
                m && (r += int2char(d));
          return m ? r : "0";
        }),
        (BigInteger.prototype.negate = function () {
          var r = nbi();
          return BigInteger.ZERO.subTo(this, r), r;
        }),
        (BigInteger.prototype.abs = function () {
          return this.s < 0 ? this.negate() : this;
        }),
        (BigInteger.prototype.compareTo = function (a) {
          var r = this.s - a.s;
          if (0 != r) return r;
          var i = this.t;
          if (0 != (r = i - a.t)) return this.s < 0 ? -r : r;
          for (; --i >= 0; ) if (0 != (r = this[i] - a[i])) return r;
          return 0;
        }),
        (BigInteger.prototype.bitLength = function () {
          return this.t <= 0
            ? 0
            : this.DB * (this.t - 1) +
                nbits(this[this.t - 1] ^ (this.s & this.DM));
        }),
        (BigInteger.prototype.mod = function (a) {
          var r = nbi();
          return (
            this.abs().divRemTo(a, null, r),
            this.s < 0 && r.compareTo(BigInteger.ZERO) > 0 && a.subTo(r, r),
            r
          );
        }),
        (BigInteger.prototype.modPowInt = function (e, m) {
          var z;
          return (
            (z = e < 256 || m.isEven() ? new Classic(m) : new Montgomery(m)),
            this.exp(e, z)
          );
        }),
        (BigInteger.ZERO = nbv(0)),
        (BigInteger.ONE = nbv(1));
      var lowprimes = [
          2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
          67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137,
          139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
          223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
          293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379,
          383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461,
          463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
          569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643,
          647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
          743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829,
          839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937,
          941, 947, 953, 967, 971, 977, 983, 991, 997,
        ],
        lplim = (1 << 26) / lowprimes[lowprimes.length - 1];
      function op_and(x, y) {
        return x & y;
      }
      function op_or(x, y) {
        return x | y;
      }
      function op_xor(x, y) {
        return x ^ y;
      }
      function op_andnot(x, y) {
        return x & ~y;
      }
      (BigInteger.prototype.chunkSize = function (r) {
        return Math.floor((Math.LN2 * this.DB) / Math.log(r));
      }),
        (BigInteger.prototype.toRadix = function (b) {
          if ((null == b && (b = 10), 0 == this.signum() || b < 2 || b > 36))
            return "0";
          var cs = this.chunkSize(b),
            a = Math.pow(b, cs),
            d = nbv(a),
            y = nbi(),
            z = nbi(),
            r = "";
          for (this.divRemTo(d, y, z); y.signum() > 0; )
            (r = (a + z.intValue()).toString(b).substr(1) + r),
              y.divRemTo(d, y, z);
          return z.intValue().toString(b) + r;
        }),
        (BigInteger.prototype.fromRadix = function (s, b) {
          this.fromInt(0), null == b && (b = 10);
          for (
            var cs = this.chunkSize(b),
              d = Math.pow(b, cs),
              mi = !1,
              j = 0,
              w = 0,
              i = 0;
            i < s.length;
            ++i
          ) {
            var x = intAt(s, i);
            x < 0
              ? "-" == s.charAt(i) && 0 == this.signum() && (mi = !0)
              : ((w = b * w + x),
                ++j >= cs &&
                  (this.dMultiply(d), this.dAddOffset(w, 0), (j = 0), (w = 0)));
          }
          j > 0 && (this.dMultiply(Math.pow(b, j)), this.dAddOffset(w, 0)),
            mi && BigInteger.ZERO.subTo(this, this);
        }),
        (BigInteger.prototype.fromNumber = function (a, b, c) {
          if ("number" == typeof b)
            if (a < 2) this.fromInt(1);
            else
              for (
                this.fromNumber(a, c),
                  this.testBit(a - 1) ||
                    this.bitwiseTo(
                      BigInteger.ONE.shiftLeft(a - 1),
                      op_or,
                      this
                    ),
                  this.isEven() && this.dAddOffset(1, 0);
                !this.isProbablePrime(b);

              )
                this.dAddOffset(2, 0),
                  this.bitLength() > a &&
                    this.subTo(BigInteger.ONE.shiftLeft(a - 1), this);
          else {
            var x = new Array(),
              t = 7 & a;
            (x.length = 1 + (a >> 3)),
              b.nextBytes(x),
              t > 0 ? (x[0] &= (1 << t) - 1) : (x[0] = 0),
              this.fromString(x, 256);
          }
        }),
        (BigInteger.prototype.bitwiseTo = function (a, op, r) {
          var i,
            f,
            m = Math.min(a.t, this.t);
          for (i = 0; i < m; ++i) r[i] = op(this[i], a[i]);
          if (a.t < this.t) {
            for (f = a.s & this.DM, i = m; i < this.t; ++i)
              r[i] = op(this[i], f);
            r.t = this.t;
          } else {
            for (f = this.s & this.DM, i = m; i < a.t; ++i) r[i] = op(f, a[i]);
            r.t = a.t;
          }
          (r.s = op(this.s, a.s)), r.clamp();
        }),
        (BigInteger.prototype.changeBit = function (n, op) {
          var r = BigInteger.ONE.shiftLeft(n);
          return this.bitwiseTo(r, op, r), r;
        }),
        (BigInteger.prototype.addTo = function (a, r) {
          for (var i = 0, c = 0, m = Math.min(a.t, this.t); i < m; )
            (c += this[i] + a[i]), (r[i++] = c & this.DM), (c >>= this.DB);
          if (a.t < this.t) {
            for (c += a.s; i < this.t; )
              (c += this[i]), (r[i++] = c & this.DM), (c >>= this.DB);
            c += this.s;
          } else {
            for (c += this.s; i < a.t; )
              (c += a[i]), (r[i++] = c & this.DM), (c >>= this.DB);
            c += a.s;
          }
          (r.s = c < 0 ? -1 : 0),
            c > 0 ? (r[i++] = c) : c < -1 && (r[i++] = this.DV + c),
            (r.t = i),
            r.clamp();
        }),
        (BigInteger.prototype.dMultiply = function (n) {
          (this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)),
            ++this.t,
            this.clamp();
        }),
        (BigInteger.prototype.dAddOffset = function (n, w) {
          if (0 != n) {
            for (; this.t <= w; ) this[this.t++] = 0;
            for (this[w] += n; this[w] >= this.DV; )
              (this[w] -= this.DV),
                ++w >= this.t && (this[this.t++] = 0),
                ++this[w];
          }
        }),
        (BigInteger.prototype.multiplyLowerTo = function (a, n, r) {
          var j,
            i = Math.min(this.t + a.t, n);
          for (r.s = 0, r.t = i; i > 0; ) r[--i] = 0;
          for (j = r.t - this.t; i < j; ++i)
            r[i + this.t] = this.am(0, a[i], r, i, 0, this.t);
          for (j = Math.min(a.t, n); i < j; ++i)
            this.am(0, a[i], r, i, 0, n - i);
          r.clamp();
        }),
        (BigInteger.prototype.multiplyUpperTo = function (a, n, r) {
          --n;
          var i = (r.t = this.t + a.t - n);
          for (r.s = 0; --i >= 0; ) r[i] = 0;
          for (i = Math.max(n - this.t, 0); i < a.t; ++i)
            r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n);
          r.clamp(), r.drShiftTo(1, r);
        }),
        (BigInteger.prototype.modInt = function (n) {
          if (n <= 0) return 0;
          var d = this.DV % n,
            r = this.s < 0 ? n - 1 : 0;
          if (this.t > 0)
            if (0 == d) r = this[0] % n;
            else
              for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n;
          return r;
        }),
        (BigInteger.prototype.millerRabin = function (t) {
          var n1 = this.subtract(BigInteger.ONE),
            k = n1.getLowestSetBit();
          if (k <= 0) return !1;
          var r = n1.shiftRight(k);
          (t = (t + 1) >> 1) > lowprimes.length && (t = lowprimes.length);
          for (var a = nbi(), i = 0; i < t; ++i) {
            a.fromInt(
              lowprimes[Math.floor(securedMathRandom() * lowprimes.length)]
            );
            var y = a.modPow(r, this);
            if (0 != y.compareTo(BigInteger.ONE) && 0 != y.compareTo(n1)) {
              for (var j = 1; j++ < k && 0 != y.compareTo(n1); )
                if (0 == (y = y.modPowInt(2, this)).compareTo(BigInteger.ONE))
                  return !1;
              if (0 != y.compareTo(n1)) return !1;
            }
          }
          return !0;
        }),
        (BigInteger.prototype.clone = function () {
          var r = nbi();
          return this.copyTo(r), r;
        }),
        (BigInteger.prototype.intValue = function () {
          if (this.s < 0) {
            if (1 == this.t) return this[0] - this.DV;
            if (0 == this.t) return -1;
          } else {
            if (1 == this.t) return this[0];
            if (0 == this.t) return 0;
          }
          return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0];
        }),
        (BigInteger.prototype.byteValue = function () {
          return 0 == this.t ? this.s : (this[0] << 24) >> 24;
        }),
        (BigInteger.prototype.shortValue = function () {
          return 0 == this.t ? this.s : (this[0] << 16) >> 16;
        }),
        (BigInteger.prototype.signum = function () {
          return this.s < 0
            ? -1
            : this.t <= 0 || (1 == this.t && this[0] <= 0)
            ? 0
            : 1;
        }),
        (BigInteger.prototype.toByteArray = function () {
          var i = this.t,
            r = new Array();
          r[0] = this.s;
          var d,
            p = this.DB - ((i * this.DB) % 8),
            k = 0;
          if (i-- > 0)
            for (
              p < this.DB &&
              (d = this[i] >> p) != (this.s & this.DM) >> p &&
              (r[k++] = d | (this.s << (this.DB - p)));
              i >= 0;

            )
              p < 8
                ? ((d = (this[i] & ((1 << p) - 1)) << (8 - p)),
                  (d |= this[--i] >> (p += this.DB - 8)))
                : ((d = (this[i] >> (p -= 8)) & 255),
                  p <= 0 && ((p += this.DB), --i)),
                0 != (128 & d) && (d |= -256),
                0 == k && (128 & this.s) != (128 & d) && ++k,
                (k > 0 || d != this.s) && (r[k++] = d);
          return r;
        }),
        (BigInteger.prototype.equals = function (a) {
          return 0 == this.compareTo(a);
        }),
        (BigInteger.prototype.min = function (a) {
          return this.compareTo(a) < 0 ? this : a;
        }),
        (BigInteger.prototype.max = function (a) {
          return this.compareTo(a) > 0 ? this : a;
        }),
        (BigInteger.prototype.and = function (a) {
          var r = nbi();
          return this.bitwiseTo(a, op_and, r), r;
        }),
        (BigInteger.prototype.or = function (a) {
          var r = nbi();
          return this.bitwiseTo(a, op_or, r), r;
        }),
        (BigInteger.prototype.xor = function (a) {
          var r = nbi();
          return this.bitwiseTo(a, op_xor, r), r;
        }),
        (BigInteger.prototype.andNot = function (a) {
          var r = nbi();
          return this.bitwiseTo(a, op_andnot, r), r;
        }),
        (BigInteger.prototype.not = function () {
          for (var r = nbi(), i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i];
          return (r.t = this.t), (r.s = ~this.s), r;
        }),
        (BigInteger.prototype.shiftLeft = function (n) {
          var r = nbi();
          return n < 0 ? this.rShiftTo(-n, r) : this.lShiftTo(n, r), r;
        }),
        (BigInteger.prototype.shiftRight = function (n) {
          var r = nbi();
          return n < 0 ? this.lShiftTo(-n, r) : this.rShiftTo(n, r), r;
        }),
        (BigInteger.prototype.getLowestSetBit = function () {
          for (var i = 0; i < this.t; ++i)
            if (0 != this[i]) return i * this.DB + lbit(this[i]);
          return this.s < 0 ? this.t * this.DB : -1;
        }),
        (BigInteger.prototype.bitCount = function () {
          for (var r = 0, x = this.s & this.DM, i = 0; i < this.t; ++i)
            r += cbit(this[i] ^ x);
          return r;
        }),
        (BigInteger.prototype.testBit = function (n) {
          var j = Math.floor(n / this.DB);
          return j >= this.t
            ? 0 != this.s
            : 0 != (this[j] & (1 << n % this.DB));
        }),
        (BigInteger.prototype.setBit = function (n) {
          return this.changeBit(n, op_or);
        }),
        (BigInteger.prototype.clearBit = function (n) {
          return this.changeBit(n, op_andnot);
        }),
        (BigInteger.prototype.flipBit = function (n) {
          return this.changeBit(n, op_xor);
        }),
        (BigInteger.prototype.add = function (a) {
          var r = nbi();
          return this.addTo(a, r), r;
        }),
        (BigInteger.prototype.subtract = function (a) {
          var r = nbi();
          return this.subTo(a, r), r;
        }),
        (BigInteger.prototype.multiply = function (a) {
          var r = nbi();
          return this.multiplyTo(a, r), r;
        }),
        (BigInteger.prototype.divide = function (a) {
          var r = nbi();
          return this.divRemTo(a, r, null), r;
        }),
        (BigInteger.prototype.remainder = function (a) {
          var r = nbi();
          return this.divRemTo(a, null, r), r;
        }),
        (BigInteger.prototype.divideAndRemainder = function (a) {
          var q = nbi(),
            r = nbi();
          return this.divRemTo(a, q, r), new Array(q, r);
        }),
        (BigInteger.prototype.modPow = function (e, m) {
          var k,
            z,
            i = e.bitLength(),
            r = nbv(1);
          if (i <= 0) return r;
          (k = i < 18 ? 1 : i < 48 ? 3 : i < 144 ? 4 : i < 768 ? 5 : 6),
            (z =
              i < 8
                ? new Classic(m)
                : m.isEven()
                ? new Barrett(m)
                : new Montgomery(m));
          var g = new Array(),
            n = 3,
            k1 = k - 1,
            km = (1 << k) - 1;
          if (((g[1] = z.convert(this)), k > 1)) {
            var g2 = nbi();
            for (z.sqrTo(g[1], g2); n <= km; )
              (g[n] = nbi()), z.mulTo(g2, g[n - 2], g[n]), (n += 2);
          }
          var w,
            t,
            j = e.t - 1,
            is1 = !0,
            r2 = nbi();
          for (i = nbits(e[j]) - 1; j >= 0; ) {
            for (
              i >= k1
                ? (w = (e[j] >> (i - k1)) & km)
                : ((w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)),
                  j > 0 && (w |= e[j - 1] >> (this.DB + i - k1))),
                n = k;
              0 == (1 & w);

            )
              (w >>= 1), --n;
            if (((i -= n) < 0 && ((i += this.DB), --j), is1))
              g[w].copyTo(r), (is1 = !1);
            else {
              for (; n > 1; ) z.sqrTo(r, r2), z.sqrTo(r2, r), (n -= 2);
              n > 0 ? z.sqrTo(r, r2) : ((t = r), (r = r2), (r2 = t)),
                z.mulTo(r2, g[w], r);
            }
            for (; j >= 0 && 0 == (e[j] & (1 << i)); )
              z.sqrTo(r, r2),
                (t = r),
                (r = r2),
                (r2 = t),
                --i < 0 && ((i = this.DB - 1), --j);
          }
          return z.revert(r);
        }),
        (BigInteger.prototype.modInverse = function (m) {
          var ac = m.isEven();
          if (0 === this.signum()) throw new Error("division by zero");
          if ((this.isEven() && ac) || 0 == m.signum()) return BigInteger.ZERO;
          for (
            var u = m.clone(),
              v = this.clone(),
              a = nbv(1),
              b = nbv(0),
              c = nbv(0),
              d = nbv(1);
            0 != u.signum();

          ) {
            for (; u.isEven(); )
              u.rShiftTo(1, u),
                ac
                  ? ((a.isEven() && b.isEven()) ||
                      (a.addTo(this, a), b.subTo(m, b)),
                    a.rShiftTo(1, a))
                  : b.isEven() || b.subTo(m, b),
                b.rShiftTo(1, b);
            for (; v.isEven(); )
              v.rShiftTo(1, v),
                ac
                  ? ((c.isEven() && d.isEven()) ||
                      (c.addTo(this, c), d.subTo(m, d)),
                    c.rShiftTo(1, c))
                  : d.isEven() || d.subTo(m, d),
                d.rShiftTo(1, d);
            u.compareTo(v) >= 0
              ? (u.subTo(v, u), ac && a.subTo(c, a), b.subTo(d, b))
              : (v.subTo(u, v), ac && c.subTo(a, c), d.subTo(b, d));
          }
          if (0 != v.compareTo(BigInteger.ONE)) return BigInteger.ZERO;
          for (; d.compareTo(m) >= 0; ) d.subTo(m, d);
          for (; d.signum() < 0; ) d.addTo(m, d);
          return d;
        }),
        (BigInteger.prototype.pow = function (e) {
          return this.exp(e, new NullExp());
        }),
        (BigInteger.prototype.gcd = function (a) {
          var x = this.s < 0 ? this.negate() : this.clone(),
            y = a.s < 0 ? a.negate() : a.clone();
          if (x.compareTo(y) < 0) {
            var t = x;
            (x = y), (y = t);
          }
          var i = x.getLowestSetBit(),
            g = y.getLowestSetBit();
          if (g < 0) return x;
          for (
            i < g && (g = i), g > 0 && (x.rShiftTo(g, x), y.rShiftTo(g, y));
            x.signum() > 0;

          )
            (i = x.getLowestSetBit()) > 0 && x.rShiftTo(i, x),
              (i = y.getLowestSetBit()) > 0 && y.rShiftTo(i, y),
              x.compareTo(y) >= 0
                ? (x.subTo(y, x), x.rShiftTo(1, x))
                : (y.subTo(x, y), y.rShiftTo(1, y));
          return g > 0 && y.lShiftTo(g, y), y;
        }),
        (BigInteger.prototype.isProbablePrime = function (t) {
          var i,
            x = this.abs();
          if (1 == x.t && x[0] <= lowprimes[lowprimes.length - 1]) {
            for (i = 0; i < lowprimes.length; ++i)
              if (x[0] == lowprimes[i]) return !0;
            return !1;
          }
          if (x.isEven()) return !1;
          for (i = 1; i < lowprimes.length; ) {
            for (
              var m = lowprimes[i], j = i + 1;
              j < lowprimes.length && m < lplim;

            )
              m *= lowprimes[j++];
            for (m = x.modInt(m); i < j; )
              if (m % lowprimes[i++] == 0) return !1;
          }
          return x.millerRabin(t);
        }),
        (BigInteger.prototype.square = function () {
          var r = nbi();
          return this.squareTo(r), r;
        }),
        (BigInteger.valueOf = nbv),
        (BigInteger.prototype.toByteArrayUnsigned = function () {
          var ba = this.abs().toByteArray();
          return ba.length
            ? (0 == ba[0] && (ba = ba.slice(1)),
              ba.map(function (v) {
                return v < 0 ? v + 256 : v;
              }))
            : ba;
        }),
        (BigInteger.fromByteArrayUnsigned = function (ba) {
          return ba.length
            ? 128 & ba[0]
              ? new BigInteger([0].concat(ba))
              : new BigInteger(ba)
            : ba.valueOf(0);
        }),
        (BigInteger.prototype.toByteArraySigned = function () {
          var val = this.abs().toByteArrayUnsigned();
          return (
            this.compareTo(BigInteger.ZERO) < 0
              ? 128 & val[0]
                ? val.unshift(128)
                : (val[0] |= 128)
              : 128 & val[0] && val.unshift(0),
            val
          );
        }),
        (BigInteger.fromByteArraySigned = function (ba) {
          return 128 & ba[0]
            ? ((ba[0] &= 127), BigInteger.fromByteArrayUnsigned(ba).negate())
            : BigInteger.fromByteArrayUnsigned(ba);
        });
      var Classic = (GLOBAL.Classic = function (m) {
        this.m = m;
      });
      (Classic.prototype.convert = function (x) {
        return x.s < 0 || x.compareTo(this.m) >= 0 ? x.mod(this.m) : x;
      }),
        (Classic.prototype.revert = function (x) {
          return x;
        }),
        (Classic.prototype.reduce = function (x) {
          x.divRemTo(this.m, null, x);
        }),
        (Classic.prototype.mulTo = function (x, y, r) {
          x.multiplyTo(y, r), this.reduce(r);
        }),
        (Classic.prototype.sqrTo = function (x, r) {
          x.squareTo(r), this.reduce(r);
        });
      var Montgomery = (GLOBAL.Montgomery = function (m) {
        (this.m = m),
          (this.mp = m.invDigit()),
          (this.mpl = 32767 & this.mp),
          (this.mph = this.mp >> 15),
          (this.um = (1 << (m.DB - 15)) - 1),
          (this.mt2 = 2 * m.t);
      });
      (Montgomery.prototype.convert = function (x) {
        var r = nbi();
        return (
          x.abs().dlShiftTo(this.m.t, r),
          r.divRemTo(this.m, null, r),
          x.s < 0 && r.compareTo(BigInteger.ZERO) > 0 && this.m.subTo(r, r),
          r
        );
      }),
        (Montgomery.prototype.revert = function (x) {
          var r = nbi();
          return x.copyTo(r), this.reduce(r), r;
        }),
        (Montgomery.prototype.reduce = function (x) {
          for (; x.t <= this.mt2; ) x[x.t++] = 0;
          for (var i = 0; i < this.m.t; ++i) {
            var j = 32767 & x[i],
              u0 =
                (j * this.mpl +
                  (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) <<
                    15)) &
                x.DM;
            for (
              x[(j = i + this.m.t)] += this.m.am(0, u0, x, i, 0, this.m.t);
              x[j] >= x.DV;

            )
              (x[j] -= x.DV), x[++j]++;
          }
          x.clamp(),
            x.drShiftTo(this.m.t, x),
            x.compareTo(this.m) >= 0 && x.subTo(this.m, x);
        }),
        (Montgomery.prototype.mulTo = function (x, y, r) {
          x.multiplyTo(y, r), this.reduce(r);
        }),
        (Montgomery.prototype.sqrTo = function (x, r) {
          x.squareTo(r), this.reduce(r);
        });
      var NullExp = (GLOBAL.NullExp = function () {});
      (NullExp.prototype.convert = function (x) {
        return x;
      }),
        (NullExp.prototype.revert = function (x) {
          return x;
        }),
        (NullExp.prototype.mulTo = function (x, y, r) {
          x.multiplyTo(y, r);
        }),
        (NullExp.prototype.sqrTo = function (x, r) {
          x.squareTo(r);
        });
      var Barrett = (GLOBAL.Barrett = function (m) {
        (this.r2 = nbi()),
          (this.q3 = nbi()),
          BigInteger.ONE.dlShiftTo(2 * m.t, this.r2),
          (this.mu = this.r2.divide(m)),
          (this.m = m);
      });
      (Barrett.prototype.convert = function (x) {
        if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m);
        if (x.compareTo(this.m) < 0) return x;
        var r = nbi();
        return x.copyTo(r), this.reduce(r), r;
      }),
        (Barrett.prototype.revert = function (x) {
          return x;
        }),
        (Barrett.prototype.reduce = function (x) {
          for (
            x.drShiftTo(this.m.t - 1, this.r2),
              x.t > this.m.t + 1 && ((x.t = this.m.t + 1), x.clamp()),
              this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3),
              this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);
            x.compareTo(this.r2) < 0;

          )
            x.dAddOffset(1, this.m.t + 1);
          for (x.subTo(this.r2, x); x.compareTo(this.m) >= 0; )
            x.subTo(this.m, x);
        }),
        (Barrett.prototype.mulTo = function (x, y, r) {
          x.multiplyTo(y, r), this.reduce(r);
        }),
        (Barrett.prototype.sqrTo = function (x, r) {
          x.squareTo(r), this.reduce(r);
        });
    })(),
    ((ec = GLOBAL.EllipticCurve = function () {}).FieldElementFp = function (
      q,
      x
    ) {
      (this.x = x), (this.q = q);
    }),
    (ec.FieldElementFp.prototype.equals = function (other) {
      return (
        other == this || (this.q.equals(other.q) && this.x.equals(other.x))
      );
    }),
    (ec.FieldElementFp.prototype.toBigInteger = function () {
      return this.x;
    }),
    (ec.FieldElementFp.prototype.negate = function () {
      return new ec.FieldElementFp(this.q, this.x.negate().mod(this.q));
    }),
    (ec.FieldElementFp.prototype.add = function (b) {
      return new ec.FieldElementFp(
        this.q,
        this.x.add(b.toBigInteger()).mod(this.q)
      );
    }),
    (ec.FieldElementFp.prototype.subtract = function (b) {
      return new ec.FieldElementFp(
        this.q,
        this.x.subtract(b.toBigInteger()).mod(this.q)
      );
    }),
    (ec.FieldElementFp.prototype.multiply = function (b) {
      return new ec.FieldElementFp(
        this.q,
        this.x.multiply(b.toBigInteger()).mod(this.q)
      );
    }),
    (ec.FieldElementFp.prototype.square = function () {
      return new ec.FieldElementFp(this.q, this.x.square().mod(this.q));
    }),
    (ec.FieldElementFp.prototype.divide = function (b) {
      return new ec.FieldElementFp(
        this.q,
        this.x.multiply(b.toBigInteger().modInverse(this.q)).mod(this.q)
      );
    }),
    (ec.FieldElementFp.prototype.getByteLength = function () {
      return Math.floor((this.toBigInteger().bitLength() + 7) / 8);
    }),
    (ec.FieldElementFp.prototype.sqrt = function () {
      if (!this.q.testBit(0)) throw new Error("even value of q");
      if (this.q.testBit(1)) {
        var z = new ec.FieldElementFp(
          this.q,
          this.x.modPow(this.q.shiftRight(2).add(BigInteger.ONE), this.q)
        );
        return z.square().equals(this) ? z : null;
      }
      var qMinusOne = this.q.subtract(BigInteger.ONE),
        legendreExponent = qMinusOne.shiftRight(1);
      if (!this.x.modPow(legendreExponent, this.q).equals(BigInteger.ONE))
        return null;
      var U,
        V,
        k = qMinusOne.shiftRight(2).shiftLeft(1).add(BigInteger.ONE),
        Q = this.x,
        fourQ = Q.shiftLeft(2).mod(this.q);
      do {
        var P,
          rand = new SecureRandom();
        do {
          P = new BigInteger(this.q.bitLength(), rand);
        } while (
          P.compareTo(this.q) >= 0 ||
          !P.multiply(P)
            .subtract(fourQ)
            .modPow(legendreExponent, this.q)
            .equals(qMinusOne)
        );
        var result = ec.FieldElementFp.fastLucasSequence(this.q, P, Q, k);
        if (
          ((U = result[0]),
          (V = result[1]).multiply(V).mod(this.q).equals(fourQ))
        )
          return (
            V.testBit(0) && (V = V.add(this.q)),
            (V = V.shiftRight(1)),
            new ec.FieldElementFp(this.q, V)
          );
      } while (U.equals(BigInteger.ONE) || U.equals(qMinusOne));
      return null;
    }),
    /*!
     * Crypto-JS 2.5.4 BlockModes.js
     * contribution from Simon Greatrix
     */
    (function (C) {
      var C_pad = (C.pad = {});
      function _requiredPadding(cipher, message) {
        var blockSizeInBytes = 4 * cipher._blocksize;
        return blockSizeInBytes - (message.length % blockSizeInBytes);
      }
      var _unpadLength = function (cipher, message, alg, padding) {
        var pad = message.pop();
        if (0 == pad)
          throw new Error(
            "Invalid zero-length padding specified for " +
              alg +
              ". Wrong cipher specification or key used?"
          );
        if (pad > 4 * cipher._blocksize)
          throw new Error(
            "Invalid padding length of " +
              pad +
              " specified for " +
              alg +
              ". Wrong cipher specification or key used?"
          );
        for (var i = 1; i < pad; i++) {
          var b = message.pop();
          if (null != padding && padding != b)
            throw new Error(
              "Invalid padding byte of 0x" +
                b.toString(16) +
                " specified for " +
                alg +
                ". Wrong cipher specification or key used?"
            );
        }
      };
      (C_pad.NoPadding = {
        pad: function (cipher, message) {},
        unpad: function (cipher, message) {},
      }),
        (C_pad.ZeroPadding = {
          pad: function (cipher, message) {
            var blockSizeInBytes = 4 * cipher._blocksize,
              reqd = message.length % blockSizeInBytes;
            if (0 != reqd)
              for (reqd = blockSizeInBytes - reqd; reqd > 0; reqd--)
                message.push(0);
          },
          unpad: function (cipher, message) {
            for (; 0 == message[message.length - 1]; ) message.pop();
          },
        }),
        (C_pad.iso7816 = {
          pad: function (cipher, message) {
            var reqd = _requiredPadding(cipher, message);
            for (message.push(128); reqd > 1; reqd--) message.push(0);
          },
          unpad: function (cipher, message) {
            var padLength;
            for (
              padLength = 4 * cipher._blocksize;
              padLength > 0;
              padLength--
            ) {
              var b = message.pop();
              if (128 == b) return;
              if (0 != b)
                throw new Error(
                  "ISO-7816 padding byte must be 0, not 0x" +
                    b.toString(16) +
                    ". Wrong cipher specification or key used?"
                );
            }
            throw new Error(
              "ISO-7816 padded beyond cipher block size. Wrong cipher specification or key used?"
            );
          },
        }),
        (C_pad.ansix923 = {
          pad: function (cipher, message) {
            for (
              var reqd = _requiredPadding(cipher, message), i = 1;
              i < reqd;
              i++
            )
              message.push(0);
            message.push(reqd);
          },
          unpad: function (cipher, message) {
            _unpadLength(cipher, message, "ANSI X.923", 0);
          },
        }),
        (C_pad.iso10126 = {
          pad: function (cipher, message) {
            for (
              var reqd = _requiredPadding(cipher, message), i = 1;
              i < reqd;
              i++
            )
              message.push(Math.floor(256 * securedMathRandom()));
            message.push(reqd);
          },
          unpad: function (cipher, message) {
            _unpadLength(cipher, message, "ISO 10126", void 0);
          },
        }),
        (C_pad.pkcs7 = {
          pad: function (cipher, message) {
            for (
              var reqd = _requiredPadding(cipher, message), i = 0;
              i < reqd;
              i++
            )
              message.push(reqd);
          },
          unpad: function (cipher, message) {
            _unpadLength(
              cipher,
              message,
              "PKCS 7",
              message[message.length - 1]
            );
          },
        });
      var C_mode = (C.mode = {}),
        Mode = (C_mode.Mode = function (padding) {
          padding && (this._padding = padding);
        });
      Mode.prototype = {
        encrypt: function (cipher, m, iv) {
          this._padding.pad(cipher, m), this._doEncrypt(cipher, m, iv);
        },
        decrypt: function (cipher, m, iv) {
          this._doDecrypt(cipher, m, iv), this._padding.unpad(cipher, m);
        },
        _padding: C_pad.iso7816,
      };
      var ECB = (C_mode.ECB = function () {
          Mode.apply(this, arguments);
        }),
        ECB_prototype = (ECB.prototype = new Mode());
      (ECB_prototype._doEncrypt = function (cipher, m, iv) {
        for (
          var blockSizeInBytes = 4 * cipher._blocksize, offset = 0;
          offset < m.length;
          offset += blockSizeInBytes
        )
          cipher._encryptblock(m, offset);
      }),
        (ECB_prototype._doDecrypt = function (cipher, c, iv) {
          for (
            var blockSizeInBytes = 4 * cipher._blocksize, offset = 0;
            offset < c.length;
            offset += blockSizeInBytes
          )
            cipher._decryptblock(c, offset);
        }),
        (ECB_prototype.fixOptions = function (options) {
          options.iv = [];
        });
      var CBC = (C_mode.CBC = function () {
          Mode.apply(this, arguments);
        }),
        CBC_prototype = (CBC.prototype = new Mode());
      (CBC_prototype._doEncrypt = function (cipher, m, iv) {
        for (
          var blockSizeInBytes = 4 * cipher._blocksize, offset = 0;
          offset < m.length;
          offset += blockSizeInBytes
        ) {
          if (0 == offset)
            for (var i = 0; i < blockSizeInBytes; i++) m[i] ^= iv[i];
          else
            for (i = 0; i < blockSizeInBytes; i++)
              m[offset + i] ^= m[offset + i - blockSizeInBytes];
          cipher._encryptblock(m, offset);
        }
      }),
        (CBC_prototype._doDecrypt = function (cipher, c, iv) {
          for (
            var blockSizeInBytes = 4 * cipher._blocksize,
              prevCryptedBlock = iv,
              offset = 0;
            offset < c.length;
            offset += blockSizeInBytes
          ) {
            var thisCryptedBlock = c.slice(offset, offset + blockSizeInBytes);
            cipher._decryptblock(c, offset);
            for (var i = 0; i < blockSizeInBytes; i++)
              c[offset + i] ^= prevCryptedBlock[i];
            prevCryptedBlock = thisCryptedBlock;
          }
        });
      var CFB = (C_mode.CFB = function () {
          Mode.apply(this, arguments);
        }),
        CFB_prototype = (CFB.prototype = new Mode());
      (CFB_prototype._padding = C_pad.NoPadding),
        (CFB_prototype._doEncrypt = function (cipher, m, iv) {
          for (
            var blockSizeInBytes = 4 * cipher._blocksize,
              keystream = iv.slice(0),
              i = 0;
            i < m.length;
            i++
          ) {
            var j = i % blockSizeInBytes;
            0 == j && cipher._encryptblock(keystream, 0),
              (m[i] ^= keystream[j]),
              (keystream[j] = m[i]);
          }
        }),
        (CFB_prototype._doDecrypt = function (cipher, c, iv) {
          for (
            var blockSizeInBytes = 4 * cipher._blocksize,
              keystream = iv.slice(0),
              i = 0;
            i < c.length;
            i++
          ) {
            var j = i % blockSizeInBytes;
            0 == j && cipher._encryptblock(keystream, 0);
            var b = c[i];
            (c[i] ^= keystream[j]), (keystream[j] = b);
          }
        });
      var OFB = (C_mode.OFB = function () {
          Mode.apply(this, arguments);
        }),
        OFB_prototype = (OFB.prototype = new Mode());
      (OFB_prototype._padding = C_pad.NoPadding),
        (OFB_prototype._doEncrypt = function (cipher, m, iv) {
          for (
            var blockSizeInBytes = 4 * cipher._blocksize,
              keystream = iv.slice(0),
              i = 0;
            i < m.length;
            i++
          )
            i % blockSizeInBytes == 0 && cipher._encryptblock(keystream, 0),
              (m[i] ^= keystream[i % blockSizeInBytes]);
        }),
        (OFB_prototype._doDecrypt = OFB_prototype._doEncrypt);
      var CTR = (C_mode.CTR = function () {
          Mode.apply(this, arguments);
        }),
        CTR_prototype = (CTR.prototype = new Mode());
      (CTR_prototype._padding = C_pad.NoPadding),
        (CTR_prototype._doEncrypt = function (cipher, m, iv) {
          for (
            var blockSizeInBytes = 4 * cipher._blocksize,
              counter = iv.slice(0),
              i = 0;
            i < m.length;

          ) {
            var keystream = counter.slice(0);
            cipher._encryptblock(keystream, 0);
            for (var j = 0; i < m.length && j < blockSizeInBytes; j++, i++)
              m[i] ^= keystream[j];
            256 == ++counter[blockSizeInBytes - 1] &&
              ((counter[blockSizeInBytes - 1] = 0),
              256 == ++counter[blockSizeInBytes - 2] &&
                ((counter[blockSizeInBytes - 2] = 0),
                256 == ++counter[blockSizeInBytes - 3] &&
                  ((counter[blockSizeInBytes - 3] = 0),
                  ++counter[blockSizeInBytes - 4])));
          }
        }),
        (CTR_prototype._doDecrypt = CTR_prototype._doEncrypt);
    })(Crypto),
    /*!
     * Crypto-JS v2.5.4  PBKDF2.js
     * http://code.google.com/p/crypto-js/
     * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
     * http://code.google.com/p/crypto-js/wiki/License
     */
    (C = Crypto),
    (util = C.util),
    (charenc = C.charenc),
    (UTF8 = charenc.UTF8),
    (Binary = charenc.Binary),
    (C.PBKDF2 = function (password, salt, keylen, options) {
      password.constructor == String &&
        (password = UTF8.stringToBytes(password)),
        salt.constructor == String && (salt = UTF8.stringToBytes(salt));
      var hasher = (options && options.hasher) || C.SHA1,
        iterations = (options && options.iterations) || 1;
      function PRF(password, salt) {
        return C.HMAC(hasher, salt, password, { asBytes: !0 });
      }
      for (
        var derivedKeyBytes = [], blockindex = 1;
        derivedKeyBytes.length < keylen;

      ) {
        for (
          var block = PRF(
              password,
              salt.concat(util.wordsToBytes([blockindex]))
            ),
            u = block,
            i = 1;
          i < iterations;
          i++
        ) {
          u = PRF(password, u);
          for (var j = 0; j < block.length; j++) block[j] ^= u[j];
        }
        (derivedKeyBytes = derivedKeyBytes.concat(block)), blockindex++;
      }
      return (
        (derivedKeyBytes.length = keylen),
        options && options.asBytes
          ? derivedKeyBytes
          : options && options.asString
          ? Binary.bytesToString(derivedKeyBytes)
          : util.bytesToHex(derivedKeyBytes)
      );
    }),
    (workerUrl = null),
    (GLOBAL.Crypto_scrypt = function (passwd, salt, N, r, p, dkLen, callback) {
      if (0 == N || 0 != (N & (N - 1)))
        throw Error("N must be > 0 and a power of 2");
      if (N > 2147483647 / 128 / r) throw Error("Parameter N is too large");
      if (r > 2147483647 / 128 / p) throw Error("Parameter r is too large");
      var PBKDF2_opts = { iterations: 1, hasher: Crypto.SHA256, asBytes: !0 },
        B = Crypto.PBKDF2(passwd, salt, 128 * p * r, PBKDF2_opts);
      try {
        var i = 0,
          worksDone = 0,
          makeWorker = function () {
            if (!workerUrl) {
              var blob,
                code = "(" + scryptCore.toString() + ")()";
              try {
                blob = new Blob([code], { type: "text/javascript" });
              } catch (e) {
                (GLOBAL.BlobBuilder =
                  GLOBAL.BlobBuilder ||
                  GLOBAL.WebKitBlobBuilder ||
                  GLOBAL.MozBlobBuilder ||
                  GLOBAL.MSBlobBuilder),
                  (blob = new BlobBuilder()).append(code),
                  (blob = blob.getBlob("text/javascript"));
              }
              workerUrl = URL.createObjectURL(blob);
            }
            var worker = new Worker(workerUrl);
            return (
              (worker.onmessage = function (event) {
                var Bi = event.data[0],
                  Bslice = event.data[1];
                worksDone++, i < p && worker.postMessage([N, r, p, B, i++]);
                for (
                  var length = Bslice.length,
                    destPos = 128 * Bi * r,
                    srcPos = 0;
                  length--;

                )
                  B[destPos++] = Bslice[srcPos++];
                worksDone == p &&
                  callback(Crypto.PBKDF2(passwd, B, dkLen, PBKDF2_opts));
              }),
              worker
            );
          },
          workers = [makeWorker(), makeWorker()];
        workers[0].postMessage([N, r, p, B, i++]),
          p > 1 && workers[1].postMessage([N, r, p, B, i++]);
      } catch (e) {
        GLOBAL.setTimeout(function () {
          scryptCore(), callback(Crypto.PBKDF2(passwd, B, dkLen, PBKDF2_opts));
        }, 0);
      }
      function scryptCore() {
        var XY = [],
          V = [];
        if (void 0 === B)
          onmessage = function (event) {
            var data = event.data,
              N = data[0],
              r = data[1],
              B = (data[2], data[3]),
              i = data[4],
              Bslice = [];
            arraycopy32(B, 128 * i * r, Bslice, 0, 128 * r),
              smix(Bslice, 0, r, N, V, XY),
              postMessage([i, Bslice]);
          };
        else for (var i = 0; i < p; i++) smix(B, 128 * i * r, r, N, V, XY);
        function smix(B, Bi, r, N, V, XY) {
          var i,
            Yi = 128 * r;
          for (arraycopy32(B, Bi, XY, 0, Yi), i = 0; i < N; i++)
            arraycopy32(XY, 0, V, i * Yi, Yi), blockmix_salsa8(XY, 0, Yi, r);
          for (i = 0; i < N; i++)
            blockxor(V, (integerify(XY, 0, r) & (N - 1)) * Yi, XY, 0, Yi),
              blockmix_salsa8(XY, 0, Yi, r);
          arraycopy32(XY, 0, B, Bi, Yi);
        }
        function blockmix_salsa8(BY, Bi, Yi, r) {
          var i,
            X = [];
          for (
            arraycopy32(BY, Bi + 64 * (2 * r - 1), X, 0, 64), i = 0;
            i < 2 * r;
            i++
          )
            blockxor(BY, 64 * i, X, 0, 64),
              salsa20_8(X),
              arraycopy32(X, 0, BY, Yi + 64 * i, 64);
          for (i = 0; i < r; i++)
            arraycopy32(BY, Yi + 2 * i * 64, BY, Bi + 64 * i, 64);
          for (i = 0; i < r; i++)
            arraycopy32(BY, Yi + 64 * (2 * i + 1), BY, Bi + 64 * (i + r), 64);
        }
        function R(a, b) {
          return (a << b) | (a >>> (32 - b));
        }
        function salsa20_8(B) {
          var i,
            B32 = new Array(32),
            x = new Array(32);
          for (i = 0; i < 16; i++)
            (B32[i] = (255 & B[4 * i + 0]) << 0),
              (B32[i] |= (255 & B[4 * i + 1]) << 8),
              (B32[i] |= (255 & B[4 * i + 2]) << 16),
              (B32[i] |= (255 & B[4 * i + 3]) << 24);
          for (
            (function (src, srcPos, dest, destPos, length) {
              for (; length--; ) dest[destPos++] = src[srcPos++];
            })(B32, 0, x, 0, 16),
              i = 8;
            i > 0;
            i -= 2
          )
            (x[4] ^= R(x[0] + x[12], 7)),
              (x[8] ^= R(x[4] + x[0], 9)),
              (x[12] ^= R(x[8] + x[4], 13)),
              (x[0] ^= R(x[12] + x[8], 18)),
              (x[9] ^= R(x[5] + x[1], 7)),
              (x[13] ^= R(x[9] + x[5], 9)),
              (x[1] ^= R(x[13] + x[9], 13)),
              (x[5] ^= R(x[1] + x[13], 18)),
              (x[14] ^= R(x[10] + x[6], 7)),
              (x[2] ^= R(x[14] + x[10], 9)),
              (x[6] ^= R(x[2] + x[14], 13)),
              (x[10] ^= R(x[6] + x[2], 18)),
              (x[3] ^= R(x[15] + x[11], 7)),
              (x[7] ^= R(x[3] + x[15], 9)),
              (x[11] ^= R(x[7] + x[3], 13)),
              (x[15] ^= R(x[11] + x[7], 18)),
              (x[1] ^= R(x[0] + x[3], 7)),
              (x[2] ^= R(x[1] + x[0], 9)),
              (x[3] ^= R(x[2] + x[1], 13)),
              (x[0] ^= R(x[3] + x[2], 18)),
              (x[6] ^= R(x[5] + x[4], 7)),
              (x[7] ^= R(x[6] + x[5], 9)),
              (x[4] ^= R(x[7] + x[6], 13)),
              (x[5] ^= R(x[4] + x[7], 18)),
              (x[11] ^= R(x[10] + x[9], 7)),
              (x[8] ^= R(x[11] + x[10], 9)),
              (x[9] ^= R(x[8] + x[11], 13)),
              (x[10] ^= R(x[9] + x[8], 18)),
              (x[12] ^= R(x[15] + x[14], 7)),
              (x[13] ^= R(x[12] + x[15], 9)),
              (x[14] ^= R(x[13] + x[12], 13)),
              (x[15] ^= R(x[14] + x[13], 18));
          for (i = 0; i < 16; ++i) B32[i] = x[i] + B32[i];
          for (i = 0; i < 16; i++) {
            var bi = 4 * i;
            (B[bi + 0] = (B32[i] >> 0) & 255),
              (B[bi + 1] = (B32[i] >> 8) & 255),
              (B[bi + 2] = (B32[i] >> 16) & 255),
              (B[bi + 3] = (B32[i] >> 24) & 255);
          }
        }
        function blockxor(S, Si, D, Di, len) {
          for (var i = len >> 6; i--; )
            (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]),
              (D[Di++] ^= S[Si++]);
        }
        function integerify(B, bi, r) {
          var n;
          return (
            (n = (255 & B[(bi += 64 * (2 * r - 1)) + 0]) << 0),
            (n |= (255 & B[bi + 1]) << 8),
            (n |= (255 & B[bi + 2]) << 16),
            (n |= (255 & B[bi + 3]) << 24)
          );
        }
        function arraycopy32(src, srcPos, dest, destPos, length) {
          for (var i = length >> 5; i--; )
            (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]),
              (dest[destPos++] = src[srcPos++]);
        }
      }
    }),
    /*!
     * Crypto-JS v2.5.4  AES.js
     * http://code.google.com/p/crypto-js/
     * Copyright (c) 2009-2013, Jeff Mott. All rights reserved.
     * http://code.google.com/p/crypto-js/wiki/License
     */
    (function () {
      for (
        var C = Crypto,
          util = C.util,
          UTF8 = C.charenc.UTF8,
          SBOX = [
            99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215,
            171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175,
            156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165,
            229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18,
            128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82,
            59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91,
            106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51,
            133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157,
            56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95,
            151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220,
            34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58,
            10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200,
            55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8,
            186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189,
            139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134,
            193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135,
            233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65,
            153, 45, 15, 176, 84, 187, 22,
          ],
          INVSBOX = [],
          i = 0;
        i < 256;
        i++
      )
        INVSBOX[SBOX[i]] = i;
      var MULT2 = [],
        MULT3 = [],
        MULT9 = [],
        MULTB = [],
        MULTD = [],
        MULTE = [];
      function xtime(a, b) {
        for (var result = 0, i = 0; i < 8; i++) {
          1 & b && (result ^= a);
          var hiBitSet = 128 & a;
          (a = (a << 1) & 255), hiBitSet && (a ^= 27), (b >>>= 1);
        }
        return result;
      }
      for (i = 0; i < 256; i++)
        (MULT2[i] = xtime(i, 2)),
          (MULT3[i] = xtime(i, 3)),
          (MULT9[i] = xtime(i, 9)),
          (MULTB[i] = xtime(i, 11)),
          (MULTD[i] = xtime(i, 13)),
          (MULTE[i] = xtime(i, 14));
      var keylength,
        nrounds,
        keyschedule,
        RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54],
        state = [[], [], [], []],
        AES = (C.AES = {
          encrypt: function (message, password, options) {
            var mode = (options = options || {}).mode || new C.mode.OFB();
            mode.fixOptions && mode.fixOptions(options);
            var m =
                message.constructor == String
                  ? UTF8.stringToBytes(message)
                  : message,
              iv = options.iv || util.randomBytes(4 * AES._blocksize),
              k =
                password.constructor == String
                  ? C.PBKDF2(password, iv, 32, { asBytes: !0 })
                  : password;
            return (
              AES._init(k),
              mode.encrypt(AES, m, iv),
              (m = options.iv ? m : iv.concat(m)),
              options && options.asBytes ? m : util.bytesToBase64(m)
            );
          },
          decrypt: function (ciphertext, password, options) {
            var mode = (options = options || {}).mode || new C.mode.OFB();
            mode.fixOptions && mode.fixOptions(options);
            var c =
                ciphertext.constructor == String
                  ? util.base64ToBytes(ciphertext)
                  : ciphertext,
              iv = options.iv || c.splice(0, 4 * AES._blocksize),
              k =
                password.constructor == String
                  ? C.PBKDF2(password, iv, 32, { asBytes: !0 })
                  : password;
            return (
              AES._init(k),
              mode.decrypt(AES, c, iv),
              options && options.asBytes ? c : UTF8.bytesToString(c)
            );
          },
          _blocksize: 4,
          _encryptblock: function (m, offset) {
            for (var row = 0; row < AES._blocksize; row++)
              for (var col = 0; col < 4; col++)
                state[row][col] = m[offset + 4 * col + row];
            for (row = 0; row < 4; row++)
              for (col = 0; col < 4; col++)
                state[row][col] ^= keyschedule[col][row];
            for (var round = 1; round < nrounds; round++) {
              for (row = 0; row < 4; row++)
                for (col = 0; col < 4; col++)
                  state[row][col] = SBOX[state[row][col]];
              for (
                state[1].push(state[1].shift()),
                  state[2].push(state[2].shift()),
                  state[2].push(state[2].shift()),
                  state[3].unshift(state[3].pop()),
                  col = 0;
                col < 4;
                col++
              ) {
                var s0 = state[0][col],
                  s1 = state[1][col],
                  s2 = state[2][col],
                  s3 = state[3][col];
                (state[0][col] = MULT2[s0] ^ MULT3[s1] ^ s2 ^ s3),
                  (state[1][col] = s0 ^ MULT2[s1] ^ MULT3[s2] ^ s3),
                  (state[2][col] = s0 ^ s1 ^ MULT2[s2] ^ MULT3[s3]),
                  (state[3][col] = MULT3[s0] ^ s1 ^ s2 ^ MULT2[s3]);
              }
              for (row = 0; row < 4; row++)
                for (col = 0; col < 4; col++)
                  state[row][col] ^= keyschedule[4 * round + col][row];
            }
            for (row = 0; row < 4; row++)
              for (col = 0; col < 4; col++)
                state[row][col] = SBOX[state[row][col]];
            for (
              state[1].push(state[1].shift()),
                state[2].push(state[2].shift()),
                state[2].push(state[2].shift()),
                state[3].unshift(state[3].pop()),
                row = 0;
              row < 4;
              row++
            )
              for (col = 0; col < 4; col++)
                state[row][col] ^= keyschedule[4 * nrounds + col][row];
            for (row = 0; row < AES._blocksize; row++)
              for (col = 0; col < 4; col++)
                m[offset + 4 * col + row] = state[row][col];
          },
          _decryptblock: function (c, offset) {
            for (var row = 0; row < AES._blocksize; row++)
              for (var col = 0; col < 4; col++)
                state[row][col] = c[offset + 4 * col + row];
            for (row = 0; row < 4; row++)
              for (col = 0; col < 4; col++)
                state[row][col] ^= keyschedule[4 * nrounds + col][row];
            for (var round = 1; round < nrounds; round++) {
              for (
                state[1].unshift(state[1].pop()),
                  state[2].push(state[2].shift()),
                  state[2].push(state[2].shift()),
                  state[3].push(state[3].shift()),
                  row = 0;
                row < 4;
                row++
              )
                for (col = 0; col < 4; col++)
                  state[row][col] = INVSBOX[state[row][col]];
              for (row = 0; row < 4; row++)
                for (col = 0; col < 4; col++)
                  state[row][col] ^=
                    keyschedule[4 * (nrounds - round) + col][row];
              for (col = 0; col < 4; col++) {
                var s0 = state[0][col],
                  s1 = state[1][col],
                  s2 = state[2][col],
                  s3 = state[3][col];
                (state[0][col] = MULTE[s0] ^ MULTB[s1] ^ MULTD[s2] ^ MULT9[s3]),
                  (state[1][col] =
                    MULT9[s0] ^ MULTE[s1] ^ MULTB[s2] ^ MULTD[s3]),
                  (state[2][col] =
                    MULTD[s0] ^ MULT9[s1] ^ MULTE[s2] ^ MULTB[s3]),
                  (state[3][col] =
                    MULTB[s0] ^ MULTD[s1] ^ MULT9[s2] ^ MULTE[s3]);
              }
            }
            for (
              state[1].unshift(state[1].pop()),
                state[2].push(state[2].shift()),
                state[2].push(state[2].shift()),
                state[3].push(state[3].shift()),
                row = 0;
              row < 4;
              row++
            )
              for (col = 0; col < 4; col++)
                state[row][col] = INVSBOX[state[row][col]];
            for (row = 0; row < 4; row++)
              for (col = 0; col < 4; col++)
                state[row][col] ^= keyschedule[col][row];
            for (row = 0; row < AES._blocksize; row++)
              for (col = 0; col < 4; col++)
                c[offset + 4 * col + row] = state[row][col];
          },
          _init: function (k) {
            (keylength = k.length / 4),
              (nrounds = keylength + 6),
              AES._keyexpansion(k);
          },
          _keyexpansion: function (k) {
            keyschedule = [];
            for (var row = 0; row < keylength; row++)
              keyschedule[row] = [
                k[4 * row],
                k[4 * row + 1],
                k[4 * row + 2],
                k[4 * row + 3],
              ];
            for (row = keylength; row < AES._blocksize * (nrounds + 1); row++) {
              var temp = [
                keyschedule[row - 1][0],
                keyschedule[row - 1][1],
                keyschedule[row - 1][2],
                keyschedule[row - 1][3],
              ];
              row % keylength == 0
                ? (temp.push(temp.shift()),
                  (temp[0] = SBOX[temp[0]]),
                  (temp[1] = SBOX[temp[1]]),
                  (temp[2] = SBOX[temp[2]]),
                  (temp[3] = SBOX[temp[3]]),
                  (temp[0] ^= RCON[row / keylength]))
                : keylength > 6 &&
                  row % keylength == 4 &&
                  ((temp[0] = SBOX[temp[0]]),
                  (temp[1] = SBOX[temp[1]]),
                  (temp[2] = SBOX[temp[2]]),
                  (temp[3] = SBOX[temp[3]])),
                (keyschedule[row] = [
                  keyschedule[row - keylength][0] ^ temp[0],
                  keyschedule[row - keylength][1] ^ temp[1],
                  keyschedule[row - keylength][2] ^ temp[2],
                  keyschedule[row - keylength][3] ^ temp[3],
                ]);
            }
          },
        });
    })(),
    (ec.FieldElementFp.fastLucasSequence = function (p, P, Q, k) {
      for (
        var n = k.bitLength(),
          s = k.getLowestSetBit(),
          Uh = BigInteger.ONE,
          Vl = BigInteger.TWO,
          Vh = P,
          Ql = BigInteger.ONE,
          Qh = BigInteger.ONE,
          j = n - 1;
        j >= s + 1;
        --j
      )
        (Ql = Ql.multiply(Qh).mod(p)),
          k.testBit(j)
            ? ((Qh = Ql.multiply(Q).mod(p)),
              (Uh = Uh.multiply(Vh).mod(p)),
              (Vl = Vh.multiply(Vl).subtract(P.multiply(Ql)).mod(p)),
              (Vh = Vh.multiply(Vh).subtract(Qh.shiftLeft(1)).mod(p)))
            : ((Qh = Ql),
              (Uh = Uh.multiply(Vl).subtract(Ql).mod(p)),
              (Vh = Vh.multiply(Vl).subtract(P.multiply(Ql)).mod(p)),
              (Vl = Vl.multiply(Vl).subtract(Ql.shiftLeft(1)).mod(p)));
      for (
        Qh = (Ql = Ql.multiply(Qh).mod(p)).multiply(Q).mod(p),
          Uh = Uh.multiply(Vl).subtract(Ql).mod(p),
          Vl = Vh.multiply(Vl).subtract(P.multiply(Ql)).mod(p),
          Ql = Ql.multiply(Qh).mod(p),
          j = 1;
        j <= s;
        ++j
      )
        (Uh = Uh.multiply(Vl).mod(p)),
          (Vl = Vl.multiply(Vl).subtract(Ql.shiftLeft(1)).mod(p)),
          (Ql = Ql.multiply(Ql).mod(p));
      return [Uh, Vl];
    }),
    (ec.PointFp = function (curve, x, y, z, compressed) {
      (this.curve = curve),
        (this.x = x),
        (this.y = y),
        (this.z = null == z ? BigInteger.ONE : z),
        (this.zinv = null),
        (this.compressed = !!compressed);
    }),
    (ec.PointFp.prototype.getX = function () {
      null == this.zinv && (this.zinv = this.z.modInverse(this.curve.q));
      var r = this.x.toBigInteger().multiply(this.zinv);
      return this.curve.reduce(r), this.curve.fromBigInteger(r);
    }),
    (ec.PointFp.prototype.getY = function () {
      null == this.zinv && (this.zinv = this.z.modInverse(this.curve.q));
      var r = this.y.toBigInteger().multiply(this.zinv);
      return this.curve.reduce(r), this.curve.fromBigInteger(r);
    }),
    (ec.PointFp.prototype.equals = function (other) {
      return (
        other == this ||
        (this.isInfinity()
          ? other.isInfinity()
          : other.isInfinity()
          ? this.isInfinity()
          : !!other.y
              .toBigInteger()
              .multiply(this.z)
              .subtract(this.y.toBigInteger().multiply(other.z))
              .mod(this.curve.q)
              .equals(BigInteger.ZERO) &&
            other.x
              .toBigInteger()
              .multiply(this.z)
              .subtract(this.x.toBigInteger().multiply(other.z))
              .mod(this.curve.q)
              .equals(BigInteger.ZERO))
      );
    }),
    (ec.PointFp.prototype.isInfinity = function () {
      return (
        (null == this.x && null == this.y) ||
        (this.z.equals(BigInteger.ZERO) &&
          !this.y.toBigInteger().equals(BigInteger.ZERO))
      );
    }),
    (ec.PointFp.prototype.negate = function () {
      return new ec.PointFp(this.curve, this.x, this.y.negate(), this.z);
    }),
    (ec.PointFp.prototype.add = function (b) {
      if (this.isInfinity()) return b;
      if (b.isInfinity()) return this;
      var u = b.y
          .toBigInteger()
          .multiply(this.z)
          .subtract(this.y.toBigInteger().multiply(b.z))
          .mod(this.curve.q),
        v = b.x
          .toBigInteger()
          .multiply(this.z)
          .subtract(this.x.toBigInteger().multiply(b.z))
          .mod(this.curve.q);
      if (BigInteger.ZERO.equals(v))
        return BigInteger.ZERO.equals(u)
          ? this.twice()
          : this.curve.getInfinity();
      var THREE = new BigInteger("3"),
        x1 = this.x.toBigInteger(),
        y1 = this.y.toBigInteger(),
        v2 = (b.x.toBigInteger(), b.y.toBigInteger(), v.square()),
        v3 = v2.multiply(v),
        x1v2 = x1.multiply(v2),
        zu2 = u.square().multiply(this.z),
        x3 = zu2
          .subtract(x1v2.shiftLeft(1))
          .multiply(b.z)
          .subtract(v3)
          .multiply(v)
          .mod(this.curve.q),
        y3 = x1v2
          .multiply(THREE)
          .multiply(u)
          .subtract(y1.multiply(v3))
          .subtract(zu2.multiply(u))
          .multiply(b.z)
          .add(u.multiply(v3))
          .mod(this.curve.q),
        z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.q);
      return new ec.PointFp(
        this.curve,
        this.curve.fromBigInteger(x3),
        this.curve.fromBigInteger(y3),
        z3
      );
    }),
    (ec.PointFp.prototype.twice = function () {
      if (this.isInfinity()) return this;
      if (0 == this.y.toBigInteger().signum()) return this.curve.getInfinity();
      var THREE = new BigInteger("3"),
        x1 = this.x.toBigInteger(),
        y1 = this.y.toBigInteger(),
        y1z1 = y1.multiply(this.z),
        y1sqz1 = y1z1.multiply(y1).mod(this.curve.q),
        a = this.curve.a.toBigInteger(),
        w = x1.square().multiply(THREE);
      BigInteger.ZERO.equals(a) || (w = w.add(this.z.square().multiply(a)));
      var x3 = (w = w.mod(this.curve.q))
          .square()
          .subtract(x1.shiftLeft(3).multiply(y1sqz1))
          .shiftLeft(1)
          .multiply(y1z1)
          .mod(this.curve.q),
        y3 = w
          .multiply(THREE)
          .multiply(x1)
          .subtract(y1sqz1.shiftLeft(1))
          .shiftLeft(2)
          .multiply(y1sqz1)
          .subtract(w.square().multiply(w))
          .mod(this.curve.q),
        z3 = y1z1.square().multiply(y1z1).shiftLeft(3).mod(this.curve.q);
      return new ec.PointFp(
        this.curve,
        this.curve.fromBigInteger(x3),
        this.curve.fromBigInteger(y3),
        z3
      );
    }),
    (ec.PointFp.prototype.multiply = function (k) {
      if (this.isInfinity()) return this;
      if (0 == k.signum()) return this.curve.getInfinity();
      var i,
        e = k,
        h = e.multiply(new BigInteger("3")),
        neg = this.negate(),
        R = this;
      for (i = h.bitLength() - 2; i > 0; --i) {
        R = R.twice();
        var hBit = h.testBit(i);
        hBit != e.testBit(i) && (R = R.add(hBit ? this : neg));
      }
      return R;
    }),
    (ec.PointFp.prototype.multiplyTwo = function (j, x, k) {
      var i;
      i = j.bitLength() > k.bitLength() ? j.bitLength() - 1 : k.bitLength() - 1;
      for (var R = this.curve.getInfinity(), both = this.add(x); i >= 0; )
        (R = R.twice()),
          j.testBit(i)
            ? (R = k.testBit(i) ? R.add(both) : R.add(this))
            : k.testBit(i) && (R = R.add(x)),
          --i;
      return R;
    }),
    (ec.PointFp.prototype.getEncoded = function (compressed) {
      var x = this.getX().toBigInteger(),
        y = this.getY().toBigInteger(),
        enc = ec.integerToBytes(x, 32);
      return (
        compressed
          ? y.isEven()
            ? enc.unshift(2)
            : enc.unshift(3)
          : (enc.unshift(4), (enc = enc.concat(ec.integerToBytes(y, 32)))),
        enc
      );
    }),
    (ec.PointFp.decodeFrom = function (curve, enc) {
      enc[0];
      var dataLen = enc.length - 1,
        xBa = enc.slice(1, 1 + dataLen / 2),
        yBa = enc.slice(1 + dataLen / 2, 1 + dataLen);
      xBa.unshift(0), yBa.unshift(0);
      var x = new BigInteger(xBa),
        y = new BigInteger(yBa);
      return new ec.PointFp(
        curve,
        curve.fromBigInteger(x),
        curve.fromBigInteger(y)
      );
    }),
    (ec.PointFp.prototype.add2D = function (b) {
      if (this.isInfinity()) return b;
      if (b.isInfinity()) return this;
      if (this.x.equals(b.x))
        return this.y.equals(b.y) ? this.twice() : this.curve.getInfinity();
      var x_x = b.x.subtract(this.x),
        gamma = b.y.subtract(this.y).divide(x_x),
        x3 = gamma.square().subtract(this.x).subtract(b.x),
        y3 = gamma.multiply(this.x.subtract(x3)).subtract(this.y);
      return new ec.PointFp(this.curve, x3, y3);
    }),
    (ec.PointFp.prototype.twice2D = function () {
      if (this.isInfinity()) return this;
      if (0 == this.y.toBigInteger().signum()) return this.curve.getInfinity();
      var TWO = this.curve.fromBigInteger(BigInteger.valueOf(2)),
        THREE = this.curve.fromBigInteger(BigInteger.valueOf(3)),
        gamma = this.x
          .square()
          .multiply(THREE)
          .add(this.curve.a)
          .divide(this.y.multiply(TWO)),
        x3 = gamma.square().subtract(this.x.multiply(TWO)),
        y3 = gamma.multiply(this.x.subtract(x3)).subtract(this.y);
      return new ec.PointFp(this.curve, x3, y3);
    }),
    (ec.PointFp.prototype.multiply2D = function (k) {
      if (this.isInfinity()) return this;
      if (0 == k.signum()) return this.curve.getInfinity();
      var i,
        e = k,
        h = e.multiply(new BigInteger("3")),
        neg = this.negate(),
        R = this;
      for (i = h.bitLength() - 2; i > 0; --i) {
        R = R.twice();
        var hBit = h.testBit(i);
        hBit != e.testBit(i) && (R = R.add2D(hBit ? this : neg));
      }
      return R;
    }),
    (ec.PointFp.prototype.isOnCurve = function () {
      var x = this.getX().toBigInteger(),
        y = this.getY().toBigInteger(),
        a = this.curve.getA().toBigInteger(),
        b = this.curve.getB().toBigInteger(),
        n = this.curve.getQ(),
        lhs = y.multiply(y).mod(n),
        rhs = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).mod(n);
      return lhs.equals(rhs);
    }),
    (ec.PointFp.prototype.toString = function () {
      return (
        "(" +
        this.getX().toBigInteger().toString() +
        "," +
        this.getY().toBigInteger().toString() +
        ")"
      );
    }),
    (ec.PointFp.prototype.validate = function () {
      var n = this.curve.getQ();
      if (this.isInfinity()) throw new Error("Point is at infinity.");
      var x = this.getX().toBigInteger(),
        y = this.getY().toBigInteger();
      if (
        x.compareTo(BigInteger.ONE) < 0 ||
        x.compareTo(n.subtract(BigInteger.ONE)) > 0
      )
        throw new Error("x coordinate out of bounds");
      if (
        y.compareTo(BigInteger.ONE) < 0 ||
        y.compareTo(n.subtract(BigInteger.ONE)) > 0
      )
        throw new Error("y coordinate out of bounds");
      if (!this.isOnCurve()) throw new Error("Point is not on the curve.");
      if (this.multiply(n).isInfinity())
        throw new Error("Point is not a scalar multiple of G.");
      return !0;
    }),
    (ec.CurveFp = function (q, a, b) {
      (this.q = q),
        (this.a = this.fromBigInteger(a)),
        (this.b = this.fromBigInteger(b)),
        (this.infinity = new ec.PointFp(this, null, null)),
        (this.reducer = new Barrett(this.q));
    }),
    (ec.CurveFp.prototype.getQ = function () {
      return this.q;
    }),
    (ec.CurveFp.prototype.getA = function () {
      return this.a;
    }),
    (ec.CurveFp.prototype.getB = function () {
      return this.b;
    }),
    (ec.CurveFp.prototype.equals = function (other) {
      return (
        other == this ||
        (this.q.equals(other.q) &&
          this.a.equals(other.a) &&
          this.b.equals(other.b))
      );
    }),
    (ec.CurveFp.prototype.getInfinity = function () {
      return this.infinity;
    }),
    (ec.CurveFp.prototype.fromBigInteger = function (x) {
      return new ec.FieldElementFp(this.q, x);
    }),
    (ec.CurveFp.prototype.reduce = function (x) {
      this.reducer.reduce(x);
    }),
    (ec.CurveFp.prototype.decodePointHex = function (s) {
      var firstByte = parseInt(s.substr(0, 2), 16);
      switch (firstByte) {
        case 0:
          return this.infinity;
        case 2:
        case 3:
          var yTilde = 1 & firstByte,
            xHex = s.substr(2, s.length - 2),
            X1 = new BigInteger(xHex, 16);
          return this.decompressPoint(yTilde, X1);
        case 4:
        case 6:
        case 7:
          var len = (s.length - 2) / 2,
            yHex = ((xHex = s.substr(2, len)), s.substr(len + 2, len));
          return new ec.PointFp(
            this,
            this.fromBigInteger(new BigInteger(xHex, 16)),
            this.fromBigInteger(new BigInteger(yHex, 16))
          );
        default:
          return null;
      }
    }),
    (ec.CurveFp.prototype.encodePointHex = function (p) {
      if (p.isInfinity()) return "00";
      var xHex = p.getX().toBigInteger().toString(16),
        yHex = p.getY().toBigInteger().toString(16),
        oLen = this.getQ().toString(16).length;
      for (oLen % 2 != 0 && oLen++; xHex.length < oLen; ) xHex = "0" + xHex;
      for (; yHex.length < oLen; ) yHex = "0" + yHex;
      return "04" + xHex + yHex;
    }),
    (ec.CurveFp.prototype.decompressPoint = function (yTilde, X1) {
      var x = this.fromBigInteger(X1),
        beta = x.multiply(x.square().add(this.getA())).add(this.getB()).sqrt();
      if (null == beta) throw new Error("Invalid point compression");
      var betaValue = beta.toBigInteger();
      return (
        (betaValue.testBit(0) ? 1 : 0) != yTilde &&
          (beta = this.fromBigInteger(this.getQ().subtract(betaValue))),
        new ec.PointFp(this, x, beta, null, !0)
      );
    }),
    (ec.fromHex = function (s) {
      return new BigInteger(s, 16);
    }),
    (ec.integerToBytes = function (i, len) {
      var bytes = i.toByteArrayUnsigned();
      if (len < bytes.length) bytes = bytes.slice(bytes.length - len);
      else for (; len > bytes.length; ) bytes.unshift(0);
      return bytes;
    }),
    (ec.X9Parameters = function (curve, g, n, h) {
      (this.curve = curve), (this.g = g), (this.n = n), (this.h = h);
    }),
    (ec.X9Parameters.prototype.getCurve = function () {
      return this.curve;
    }),
    (ec.X9Parameters.prototype.getG = function () {
      return this.g;
    }),
    (ec.X9Parameters.prototype.getN = function () {
      return this.n;
    }),
    (ec.X9Parameters.prototype.getH = function () {
      return this.h;
    }),
    (ec.secNamedCurves = {
      secp256k1: function () {
        var p = ec.fromHex(
            "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F"
          ),
          a = BigInteger.ZERO,
          b = ec.fromHex("7"),
          n = ec.fromHex(
            "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
          ),
          h = BigInteger.ONE,
          curve = new ec.CurveFp(p, a, b),
          G = curve.decodePointHex(
            "0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8"
          );
        return new ec.X9Parameters(curve, G, n, h);
      },
    }),
    (ec.getSECCurveByName = function (name) {
      return null == ec.secNamedCurves[name] ? null : ec.secNamedCurves[name]();
    }),
    (function () {
      var bitjs = (GLOBAL.bitjs = function () {});
      "FLO" == GLOBAL.cryptocoin &&
        ((bitjs.pub = 35),
        (bitjs.priv = 163),
        (bitjs.multisig = 8),
        (bitjs.compressed = !1)),
        "FLO_TEST" == GLOBAL.cryptocoin &&
          ((bitjs.pub = 115), (bitjs.priv = 239), (bitjs.multisig = 198)),
        "BTC" == GLOBAL.cryptocoin &&
          ((bitjs.pub = 0), (bitjs.priv = 128), (bitjs.multisig = 5)),
        "BTC_TESTNET" == GLOBAL.cryptocoin &&
          ((bitjs.pub = 111), (bitjs.priv = 239), (bitjs.multisig = 196)),
        (bitjs.privkey2wif = function (h) {
          var r = Crypto.util.hexToBytes(h);
          1 == bitjs.compressed && r.push(1), r.unshift(bitjs.priv);
          var checksum = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
            asBytes: !0,
          }).slice(0, 4);
          return B58.encode(r.concat(checksum));
        }),
        (bitjs.wif2privkey = function (wif) {
          var compressed = !1,
            decode = B58.decode(wif),
            key = decode.slice(0, decode.length - 4);
          return (
            (key = key.slice(1, key.length)).length >= 33 &&
              1 == key[key.length - 1] &&
              ((key = key.slice(0, key.length - 1)), (compressed = !0)),
            { privkey: Crypto.util.bytesToHex(key), compressed: compressed }
          );
        }),
        (bitjs.wif2pubkey = function (wif) {
          var compressed = bitjs.compressed,
            r = bitjs.wif2privkey(wif);
          bitjs.compressed = r.compressed;
          var pubkey = bitjs.newPubkey(r.privkey);
          return (
            (bitjs.compressed = compressed),
            { pubkey: pubkey, compressed: r.compressed }
          );
        }),
        (bitjs.wif2address = function (wif) {
          var r = bitjs.wif2pubkey(wif);
          return {
            address: bitjs.pubkey2address(r.pubkey),
            compressed: r.compressed,
          };
        }),
        (bitjs.newPubkey = function (hash) {
          var privateKeyBigInt = BigInteger.fromByteArrayUnsigned(
              Crypto.util.hexToBytes(hash)
            ),
            curvePt = EllipticCurve.getSECCurveByName("secp256k1")
              .getG()
              .multiply(privateKeyBigInt),
            x = curvePt.getX().toBigInteger(),
            y = curvePt.getY().toBigInteger(),
            publicKeyBytes = EllipticCurve.integerToBytes(x, 32);
          if (
            ((publicKeyBytes = publicKeyBytes.concat(
              EllipticCurve.integerToBytes(y, 32)
            )).unshift(4),
            1 == bitjs.compressed)
          ) {
            var publicKeyBytesCompressed = EllipticCurve.integerToBytes(x, 32);
            return (
              y.isEven()
                ? publicKeyBytesCompressed.unshift(2)
                : publicKeyBytesCompressed.unshift(3),
              Crypto.util.bytesToHex(publicKeyBytesCompressed)
            );
          }
          return Crypto.util.bytesToHex(publicKeyBytes);
        }),
        (bitjs.pubkey2address = function (h, byte) {
          var r = ripemd160(
            Crypto.SHA256(Crypto.util.hexToBytes(h), { asBytes: !0 })
          );
          r.unshift(byte || bitjs.pub);
          var checksum = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
            asBytes: !0,
          }).slice(0, 4);
          return B58.encode(r.concat(checksum));
        }),
        (bitjs.pubkeys2multisig = function (pubkeys, required) {
          var s = [];
          s.push(80 + required);
          for (var i = 0; i < pubkeys.length; ++i) {
            let bytes = Crypto.util.hexToBytes(pubkeys[i]);
            s.push(bytes.length), (s = s.concat(bytes));
          }
          if ((s.push(80 + pubkeys.length), s.push(174), s.length > 520))
            throw Error(`redeemScript size(=${s.length}) too large`);
          var x = ripemd160(Crypto.SHA256(s, { asBytes: !0 }), { asBytes: !0 });
          x.unshift(bitjs.multisig);
          var r = x,
            checksum = (r = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
              asBytes: !0,
            })).slice(0, 4),
            redeemScript = Crypto.util.bytesToHex(s);
          return {
            address: B58.encode(x.concat(checksum)),
            redeemScript: redeemScript,
            size: s.length,
          };
        }),
        (bitjs.transaction = function (tx_data = void 0) {
          var btrx = {};
          return (
            (btrx.version = 2),
            (btrx.inputs = []),
            (btrx.outputs = []),
            (btrx.locktime = 0),
            (btrx.floData = ""),
            (btrx.addinput = function (txid, index, scriptPubKey, sequence) {
              var o = {};
              return (
                (o.outpoint = { hash: txid, index: index }),
                (o.script = Crypto.util.hexToBytes(scriptPubKey)),
                (o.sequence =
                  sequence || (0 == btrx.locktime ? 4294967295 : 0)),
                this.inputs.push(o)
              );
            }),
            (btrx.addoutput = function (address, value) {
              var o = {},
                buf = [],
                addr = this.addressDecode(address);
              return (
                (o.value = new BigInteger(
                  "" + Math.round(1 * value * 1e8),
                  10
                )),
                addr.version === bitjs.pub
                  ? (buf.push(118),
                    buf.push(169),
                    (buf = this.writeBytesToScriptBuffer(buf, addr.bytes)).push(
                      136
                    ),
                    buf.push(172))
                  : addr.version === bitjs.multisig &&
                    (buf.push(169),
                    (buf = this.writeBytesToScriptBuffer(buf, addr.bytes)).push(
                      135
                    )),
                (o.script = buf),
                this.outputs.push(o)
              );
            }),
            (btrx.addflodata = function (data) {
              if ("string" != typeof data)
                throw Error("floData should be String");
              if (data.length > 1040)
                throw Error("floData Character Limit Exceeded");
              if (bitjs.strToBytes(data).some((c) => c < 32 || c > 127))
                throw Error(
                  "floData contains Invalid characters (only ASCII characters allowed"
                );
              return (this.floData = data), this.floData;
            }),
            (btrx.addressDecode = function (address) {
              var bytes = B58.decode(address),
                front = bytes.slice(0, bytes.length - 4),
                back = bytes.slice(bytes.length - 4);
              if (
                Crypto.SHA256(Crypto.SHA256(front, { asBytes: !0 }), {
                  asBytes: !0,
                }).slice(0, 4) +
                  "" ==
                back + ""
              )
                return { version: front[0], bytes: front.slice(1) };
            }),
            (btrx.transactionHash = function (index, sigHashType) {
              for (
                var clone = bitjs.clone(this), shType = sigHashType || 1, i = 0;
                i < clone.inputs.length;
                i++
              )
                index != i && (clone.inputs[i].script = []);
              if (clone.inputs && clone.inputs[index]) {
                if (1 == shType);
                else if (2 == shType) {
                  clone.outputs = [];
                  for (i = 0; i < clone.inputs.length; i++)
                    index != i && (clone.inputs[i].sequence = 0);
                } else if (3 == shType) {
                  clone.outputs.length = index + 1;
                  for (i = 0; i < index; i++)
                    (clone.outputs[i].value = -1),
                      (clone.outputs[i].script = []);
                  for (i = 0; i < clone.inputs.length; i++)
                    index != i && (clone.inputs[i].sequence = 0);
                } else if (shType >= 128)
                  if (((clone.inputs = [clone.inputs[index]]), 129 == shType));
                  else if (130 == shType) clone.outputs = [];
                  else if (131 == shType) {
                    clone.outputs.length = index + 1;
                    for (i = 0; i < index; i++)
                      (clone.outputs[i].value = -1),
                        (clone.outputs[i].script = []);
                  }
                var buffer = Crypto.util.hexToBytes(clone.serialize());
                buffer = buffer.concat(bitjs.numToBytes(parseInt(shType), 4));
                var hash = Crypto.SHA256(buffer, { asBytes: !0 });
                return Crypto.util.bytesToHex(
                  Crypto.SHA256(hash, { asBytes: !0 })
                );
              }
              return !1;
            }),
            (btrx.transactionSig = function (index, wif, sigHashType, txhash) {
              var shType = sigHashType || 1,
                hash =
                  txhash ||
                  Crypto.util.hexToBytes(this.transactionHash(index, shType));
              if (hash) {
                var curve = EllipticCurve.getSECCurveByName("secp256k1"),
                  key = bitjs.wif2privkey(wif),
                  priv = BigInteger.fromByteArrayUnsigned(
                    Crypto.util.hexToBytes(key.privkey)
                  ),
                  n = curve.getN(),
                  e = BigInteger.fromByteArrayUnsigned(hash),
                  badrs = 0;
                do {
                  var k = this.deterministicK(wif, hash, badrs),
                    r = curve.getG().multiply(k).getX().toBigInteger().mod(n),
                    s = k
                      .modInverse(n)
                      .multiply(e.add(priv.multiply(r)))
                      .mod(n);
                  badrs++;
                } while (
                  r.compareTo(BigInteger.ZERO) <= 0 ||
                  s.compareTo(BigInteger.ZERO) <= 0
                );
                var halfn = n.shiftRight(1);
                s.compareTo(halfn) > 0 && (s = n.subtract(s));
                var sig = (function (r, s) {
                  var rBa = r.toByteArraySigned(),
                    sBa = s.toByteArraySigned(),
                    sequence = [];
                  return (
                    sequence.push(2),
                    sequence.push(rBa.length),
                    (sequence = sequence.concat(rBa)).push(2),
                    sequence.push(sBa.length),
                    (sequence = sequence.concat(sBa)).unshift(sequence.length),
                    sequence.unshift(48),
                    sequence
                  );
                })(r, s);
                return (
                  sig.push(parseInt(shType, 10)), Crypto.util.bytesToHex(sig)
                );
              }
              return !1;
            }),
            (btrx.deterministicK = function (wif, hash, badrs) {
              badrs = badrs || 0;
              var key = bitjs.wif2privkey(wif),
                x = Crypto.util.hexToBytes(key.privkey),
                N = EllipticCurve.getSECCurveByName("secp256k1").getN(),
                v = [
                  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                ],
                k = [
                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                ];
              (k = Crypto.HMAC(
                Crypto.SHA256,
                v.concat([0]).concat(x).concat(hash),
                k,
                { asBytes: !0 }
              )),
                (v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 })),
                (k = Crypto.HMAC(
                  Crypto.SHA256,
                  v.concat([1]).concat(x).concat(hash),
                  k,
                  { asBytes: !0 }
                )),
                (v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 }));
              var T = [];
              T = v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 });
              for (
                var KBigInt = BigInteger.fromByteArrayUnsigned(T), i = 0;
                KBigInt.compareTo(N) >= 0 ||
                KBigInt.compareTo(BigInteger.ZERO) <= 0 ||
                i < badrs;

              )
                (k = Crypto.HMAC(Crypto.SHA256, v.concat([0]), k, {
                  asBytes: !0,
                })),
                  (v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 })),
                  (T = v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 })),
                  (KBigInt = BigInteger.fromByteArrayUnsigned(T)),
                  i++;
              return KBigInt;
            }),
            (btrx.writeBytesToScriptBuffer = function (buf, bytes) {
              return (
                bytes.length < 76
                  ? buf.push(bytes.length)
                  : bytes.length <= 255
                  ? (buf.push(76), buf.push(bytes.length))
                  : bytes.length <= 65535
                  ? (buf.push(77),
                    buf.push(255 & bytes.length),
                    buf.push((bytes.length >>> 8) & 255))
                  : (buf.push(78),
                    buf.push(255 & bytes.length),
                    buf.push((bytes.length >>> 8) & 255),
                    buf.push((bytes.length >>> 16) & 255),
                    buf.push((bytes.length >>> 24) & 255)),
                (buf = buf.concat(bytes))
              );
            }),
            (btrx.parseScript = function (script) {
              var chunks = [],
                i = 0;
              function readChunk(n) {
                chunks.push(script.slice(i, i + n)), (i += n);
              }
              for (; i < script.length; ) {
                var opcode = script[i++];
                if (
                  (opcode >= 240 && (opcode = (opcode << 8) | script[i++]),
                  opcode > 0 && opcode < 76
                    ? readChunk(opcode)
                    : 76 == opcode
                    ? readChunk(script[i++])
                    : 77 == opcode
                    ? readChunk((script[i++] << 8) | script[i++])
                    : 78 == opcode
                    ? readChunk(
                        (script[i++] << 24) |
                          (script[i++] << 16) |
                          (script[i++] << 8) |
                          script[i++]
                      )
                    : chunks.push(opcode),
                  i < 0)
                )
                  break;
              }
              return chunks;
            }),
            (btrx.decodeRedeemScript = function (rs) {
              "string" == typeof rs && (rs = Crypto.util.hexToBytes(rs));
              var script = this.parseScript(rs);
              if (
                !(
                  script[0] > 80 &&
                  script[script.length - 2] > 80 &&
                  174 == script[script.length - 1]
                )
              )
                throw "Invalid RedeemScript";
              var r = {};
              (r.required = script[0] - 80), (r.pubkeys = []);
              for (var i = 1; i < script.length - 2; i++)
                r.pubkeys.push(Crypto.util.bytesToHex(script[i]));
              return (
                (r.address = bitjs.pubkeys2multisig(
                  r.pubkeys,
                  r.required
                ).address),
                (r.redeemscript = Crypto.util.bytesToHex(rs)),
                r
              );
            }),
            (btrx.signinput = function (index, wif, sigHashType) {
              var key = bitjs.wif2pubkey(wif),
                shType = sigHashType || 1,
                signature = this.transactionSig(index, wif, shType),
                buf = [],
                sigBytes = Crypto.util.hexToBytes(signature);
              buf = this.writeBytesToScriptBuffer(buf, sigBytes);
              var pubKeyBytes = Crypto.util.hexToBytes(key.pubkey);
              return (
                buf.push(pubKeyBytes.length),
                (buf = buf.concat(pubKeyBytes)),
                (this.inputs[index].script = buf),
                !0
              );
            }),
            (btrx.signmultisig = function (index, wif, sigHashType) {
              var redeemScript,
                script = Array.from(this.inputs[index].script),
                sigsList = [];
              if (0 == script[0]) {
                script = this.parseScript(script);
                for (var i = 0; i < script.length; i++)
                  Array.isArray(script[i]) &&
                    (48 == script[i][0]
                      ? sigsList.push(script[i])
                      : script[i][0] >= 80 &&
                        174 == script[i][script[i].length - 1] &&
                        (redeemScript = script[i]));
              } else redeemScript = script;
              var pubkeyList = this.decodeRedeemScript(redeemScript).pubkeys,
                pubkey = bitjs.wif2pubkey(wif).pubkey;
              if (!pubkeyList.includes(pubkey)) return !1;
              pubkeyList = pubkeyList.map((pub) =>
                Crypto.util.hexToBytes(bitjs.pubkeydecompress(pub))
              );
              var shType = sigHashType || 1;
              this.inputs[index].script = redeemScript;
              var signature = Crypto.util.hexToBytes(
                this.transactionSig(index, wif, shType)
              );
              sigsList.push(signature);
              var buf = [];
              buf.push(0);
              for (let x in pubkeyList)
                for (let y in sigsList) {
                  var sighash = Crypto.util.hexToBytes(
                    this.transactionHash(index, 1 * sigsList[y].slice(-1)[0])
                  );
                  if (
                    bitjs.verifySignature(sighash, sigsList[y], pubkeyList[x])
                  ) {
                    buf = this.writeBytesToScriptBuffer(buf, sigsList[y]);
                    break;
                  }
                }
              return (
                (buf = this.writeBytesToScriptBuffer(buf, redeemScript)),
                (this.inputs[index].script = buf),
                !0
              );
            }),
            (btrx.sign = function (wif, sigHashType) {
              for (
                var shType = sigHashType || 1, i = 0;
                i < this.inputs.length;
                i++
              ) {
                var decodedScript = this.scriptDecode(i);
                if (
                  "scriptpubkey" == decodedScript.type &&
                  0 == decodedScript.signed
                ) {
                  var addr = bitjs.wif2address(wif).address;
                  decodedScript.pubhash ==
                    Crypto.util.bytesToHex(this.addressDecode(addr).bytes) &&
                    this.signinput(i, wif, shType);
                } else
                  "multisig" == decodedScript.type &&
                    this.signmultisig(i, wif, shType);
              }
              return this.serialize();
            }),
            (btrx.scriptDecode = function (index) {
              var script = this.parseScript(this.inputs[index].script);
              return 5 == script.length && 172 == script[script.length - 1]
                ? {
                    type: "scriptpubkey",
                    signed: !1,
                    pubhash: Crypto.util.bytesToHex(script[2]),
                  }
                : 2 == script.length && 48 == script[0][0]
                ? { type: "scriptpubkey", signed: !0 }
                : 0 == script[0] &&
                  174 ==
                    script[script.length - 1][
                      script[script.length - 1].length - 1
                    ]
                ? { type: "multisig", rs: script[script.length - 1] }
                : script[0] >= 80 && 174 == script[script.length - 1]
                ? {
                    type: "multisig",
                    rs: Array.from(this.inputs[index].script),
                  }
                : void 0;
            }),
            (btrx.serialize = function () {
              var buffer = [];
              buffer = (buffer = buffer.concat(
                bitjs.numToBytes(parseInt(this.version), 4)
              )).concat(bitjs.numToVarInt(this.inputs.length));
              for (var i = 0; i < this.inputs.length; i++) {
                var txin = this.inputs[i];
                buffer = (buffer = buffer.concat(
                  Crypto.util.hexToBytes(txin.outpoint.hash).reverse()
                )).concat(bitjs.numToBytes(parseInt(txin.outpoint.index), 4));
                var scriptBytes = txin.script;
                buffer = (buffer = (buffer = buffer.concat(
                  bitjs.numToVarInt(scriptBytes.length)
                )).concat(scriptBytes)).concat(
                  bitjs.numToBytes(parseInt(txin.sequence), 4)
                );
              }
              buffer = buffer.concat(bitjs.numToVarInt(this.outputs.length));
              for (i = 0; i < this.outputs.length; i++) {
                var txout = this.outputs[i];
                buffer = buffer.concat(bitjs.numToBytes(txout.value, 8));
                scriptBytes = txout.script;
                buffer = (buffer = buffer.concat(
                  bitjs.numToVarInt(scriptBytes.length)
                )).concat(scriptBytes);
              }
              return (
                (buffer = (buffer = (buffer = buffer.concat(
                  bitjs.numToBytes(parseInt(this.locktime), 4)
                )).concat(bitjs.numToVarInt(this.floData.length))).concat(
                  bitjs.strToBytes(this.floData)
                )),
                Crypto.util.bytesToHex(buffer)
              );
            }),
            tx_data &&
              (function (buffer) {
                "string" == typeof buffer &&
                  (buffer = Crypto.util.hexToBytes(buffer));
                var pos = 0,
                  readAsInt = function (bytes) {
                    return 0 == bytes
                      ? 0
                      : (pos++, buffer[pos - 1] + 256 * readAsInt(bytes - 1));
                  },
                  readVarInt = function () {
                    return (
                      pos++,
                      buffer[pos - 1] < 253
                        ? buffer[pos - 1]
                        : readAsInt(buffer[pos - 1] - 251)
                    );
                  },
                  readBytes = function (bytes) {
                    return (pos += bytes), buffer.slice(pos - bytes, pos);
                  },
                  readVarString = function () {
                    var size = readVarInt();
                    return readBytes(size);
                  };
                const self = btrx;
                self.version = readAsInt(4);
                for (var ins = readVarInt(), i = 0; i < ins; i++)
                  self.inputs.push({
                    outpoint: {
                      hash: Crypto.util.bytesToHex(readBytes(32).reverse()),
                      index: readAsInt(4),
                    },
                    script: readVarString(),
                    sequence: readAsInt(4),
                  });
                var outs = readVarInt();
                for (i = 0; i < outs; i++)
                  self.outputs.push({
                    value: bitjs.bytesToNum(readBytes(8)),
                    script: readVarString(),
                  });
                (self.lock_time = readAsInt(4)),
                  (self.floData = readVarString()
                    .map((b) => String.fromCharCode(b))
                    .join(""));
              })(tx_data),
            btrx
          );
        }),
        (bitjs.numToBytes = function (num, bytes) {
          return (
            void 0 === bytes && (bytes = 8),
            0 == bytes
              ? []
              : -1 == num
              ? Crypto.util.hexToBytes("ffffffffffffffff")
              : [num % 256].concat(
                  bitjs.numToBytes(Math.floor(num / 256), bytes - 1)
                )
          );
        }),
        (bitjs.numToByteArray = function (num) {
          return num <= 256
            ? [num]
            : [num % 256].concat(bitjs.numToByteArray(Math.floor(num / 256)));
        }),
        (bitjs.numToVarInt = function (num) {
          return num < 253
            ? [num]
            : num < 65536
            ? [253].concat(bitjs.numToBytes(num, 2))
            : num < 4294967296
            ? [254].concat(bitjs.numToBytes(num, 4))
            : [255].concat(bitjs.numToBytes(num, 8));
        }),
        (bitjs.bytesToNum = function (bytes) {
          return 0 == bytes.length
            ? 0
            : bytes[0] + 256 * bitjs.bytesToNum(bytes.slice(1));
        }),
        (bitjs.strToBytes = function (str) {
          return str.split("").map((c) => c.charCodeAt(0));
        }),
        (bitjs.pubkeydecompress = function (pubkey) {
          if ("string" == typeof pubkey && pubkey.match(/^[a-f0-9]+$/i)) {
            var curve = EllipticCurve.getSECCurveByName("secp256k1");
            try {
              var pt = curve.curve.decodePointHex(pubkey),
                x = pt.getX().toBigInteger(),
                y = pt.getY().toBigInteger(),
                publicKeyBytes = EllipticCurve.integerToBytes(x, 32);
              return (
                (publicKeyBytes = publicKeyBytes.concat(
                  EllipticCurve.integerToBytes(y, 32)
                )).unshift(4),
                Crypto.util.bytesToHex(publicKeyBytes)
              );
            } catch (e) {
              return !1;
            }
          }
          return !1;
        }),
        (bitjs.verifySignature = function (hash, sig, pubkey) {
          return Bitcoin.ECDSA.verify(hash, sig, pubkey);
        }),
        (bitjs.clone = function (obj) {
          if (null == obj || "object" != typeof obj) return obj;
          var temp = new obj.constructor();
          for (var key in obj)
            obj.hasOwnProperty(key) && (temp[key] = bitjs.clone(obj[key]));
          return temp;
        });
      var B58 = (bitjs.Base58 = {
        alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
        validRegex: /^[1-9A-HJ-NP-Za-km-z]+$/,
        base: BigInteger.valueOf(58),
        encode: function (input) {
          for (
            var bi = BigInteger.fromByteArrayUnsigned(input), chars = [];
            bi.compareTo(B58.base) >= 0;

          ) {
            var mod = bi.mod(B58.base);
            chars.unshift(B58.alphabet[mod.intValue()]),
              (bi = bi.subtract(mod).divide(B58.base));
          }
          chars.unshift(B58.alphabet[bi.intValue()]);
          for (var i = 0; i < input.length && 0 == input[i]; i++)
            chars.unshift(B58.alphabet[0]);
          return chars.join("");
        },
        decode: function (input) {
          for (
            var bi = BigInteger.valueOf(0),
              leadingZerosNum = 0,
              i = input.length - 1;
            i >= 0;
            i--
          ) {
            var alphaIndex = B58.alphabet.indexOf(input[i]);
            if (alphaIndex < 0) throw "Invalid character";
            (bi = bi.add(
              BigInteger.valueOf(alphaIndex).multiply(
                B58.base.pow(input.length - 1 - i)
              )
            )),
              "1" == input[i] ? leadingZerosNum++ : (leadingZerosNum = 0);
          }
          for (var bytes = bi.toByteArrayUnsigned(); leadingZerosNum-- > 0; )
            bytes.unshift(0);
          return bytes;
        },
      });
    })(),
    (function () {
      var ecparams,
        rng,
        P_OVER_FOUR,
        ECDSA,
        Bip38,
        Bitcoin = (GLOBAL.Bitcoin = {}),
        B58 = (Bitcoin.Base58 = {
          alphabet:
            "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
          validRegex: /^[1-9A-HJ-NP-Za-km-z]+$/,
          base: BigInteger.valueOf(58),
          encode: function (input) {
            for (
              var bi = BigInteger.fromByteArrayUnsigned(input), chars = [];
              bi.compareTo(B58.base) >= 0;

            ) {
              var mod = bi.mod(B58.base);
              chars.unshift(B58.alphabet[mod.intValue()]),
                (bi = bi.subtract(mod).divide(B58.base));
            }
            chars.unshift(B58.alphabet[bi.intValue()]);
            for (var i = 0; i < input.length && 0 == input[i]; i++)
              chars.unshift(B58.alphabet[0]);
            return chars.join("");
          },
          decode: function (input) {
            for (
              var bi = BigInteger.valueOf(0),
                leadingZerosNum = 0,
                i = input.length - 1;
              i >= 0;
              i--
            ) {
              var alphaIndex = B58.alphabet.indexOf(input[i]);
              if (alphaIndex < 0) throw "Invalid character";
              (bi = bi.add(
                BigInteger.valueOf(alphaIndex).multiply(
                  B58.base.pow(input.length - 1 - i)
                )
              )),
                "1" == input[i] ? leadingZerosNum++ : (leadingZerosNum = 0);
            }
            for (var bytes = bi.toByteArrayUnsigned(); leadingZerosNum-- > 0; )
              bytes.unshift(0);
            return bytes;
          },
        });
      (Bitcoin.Address = function (bytes) {
        if ("string" == typeof bytes) {
          var d = Bitcoin.Address.decodeString(bytes);
          if (
            ((bytes = d.hash),
            d.version != Bitcoin.Address.standardVersion &&
              d.version != Bitcoin.Address.multisigVersion)
          )
            throw "Version (prefix) " + d.version + " not supported!";
          this.version = d.version;
        } else this.version = Bitcoin.Address.standardVersion;
        this.hash = bytes;
      }),
        (Bitcoin.Address.standardVersion = 35),
        (Bitcoin.Address.multisigVersion = 94),
        "FLO_TEST" == GLOBAL.cryptocoin &&
          ((Bitcoin.Address.standardVersion = 115),
          (Bitcoin.Address.multisigVersion = 198)),
        (Bitcoin.Address.prototype.toString = function (version = null) {
          var hash = this.hash.slice(0);
          hash.unshift(null !== version ? version : this.version);
          var checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: !0 }), {
              asBytes: !0,
            }),
            bytes = hash.concat(checksum.slice(0, 4));
          return Bitcoin.Base58.encode(bytes);
        }),
        (Bitcoin.Address.prototype.getHashBase64 = function () {
          return Crypto.util.bytesToBase64(this.hash);
        }),
        (Bitcoin.Address.decodeString = function (string) {
          var bytes = Bitcoin.Base58.decode(string),
            hash = bytes.slice(0, 21),
            checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: !0 }), {
              asBytes: !0,
            });
          if (
            checksum[0] != bytes[21] ||
            checksum[1] != bytes[22] ||
            checksum[2] != bytes[23] ||
            checksum[3] != bytes[24]
          )
            throw "Checksum validation failed!";
          return { version: hash.shift(), hash: hash };
        }),
        (Bitcoin.ECDSA =
          ((ecparams = EllipticCurve.getSECCurveByName("secp256k1")),
          (rng = new SecureRandom()),
          (P_OVER_FOUR = null),
          (ECDSA = {
            getBigRandom: function (limit) {
              return new BigInteger(limit.bitLength(), rng)
                .mod(limit.subtract(BigInteger.ONE))
                .add(BigInteger.ONE);
            },
            sign: function (hash, priv) {
              var d = priv,
                n = ecparams.getN(),
                e = BigInteger.fromByteArrayUnsigned(hash);
              do {
                var k = ECDSA.getBigRandom(n),
                  r = ecparams.getG().multiply(k).getX().toBigInteger().mod(n);
              } while (r.compareTo(BigInteger.ZERO) <= 0);
              var s = k
                .modInverse(n)
                .multiply(e.add(d.multiply(r)))
                .mod(n);
              return ECDSA.serializeSig(r, s);
            },
            verify: function (hash, sig, pubkey) {
              var r, s, Q;
              if (Bitcoin.Util.isArray(sig)) {
                var obj = ECDSA.parseSig(sig);
                (r = obj.r), (s = obj.s);
              } else {
                if ("object" != typeof sig || !sig.r || !sig.s)
                  throw "Invalid value for signature";
                (r = sig.r), (s = sig.s);
              }
              if (pubkey instanceof EllipticCurve.PointFp) Q = pubkey;
              else {
                if (!Bitcoin.Util.isArray(pubkey))
                  throw "Invalid format for pubkey value, must be byte array or ec.PointFp";
                Q = EllipticCurve.PointFp.decodeFrom(
                  ecparams.getCurve(),
                  pubkey
                );
              }
              var e = BigInteger.fromByteArrayUnsigned(hash);
              return ECDSA.verifyRaw(e, r, s, Q);
            },
            verifyRaw: function (e, r, s, Q) {
              var n = ecparams.getN(),
                G = ecparams.getG();
              if (r.compareTo(BigInteger.ONE) < 0 || r.compareTo(n) >= 0)
                return !1;
              if (s.compareTo(BigInteger.ONE) < 0 || s.compareTo(n) >= 0)
                return !1;
              var c = s.modInverse(n),
                u1 = e.multiply(c).mod(n),
                u2 = r.multiply(c).mod(n);
              return G.multiply(u1)
                .add(Q.multiply(u2))
                .getX()
                .toBigInteger()
                .mod(n)
                .equals(r);
            },
            serializeSig: function (r, s) {
              var rBa = r.toByteArraySigned(),
                sBa = s.toByteArraySigned(),
                sequence = [];
              return (
                sequence.push(2),
                sequence.push(rBa.length),
                (sequence = sequence.concat(rBa)).push(2),
                sequence.push(sBa.length),
                (sequence = sequence.concat(sBa)).unshift(sequence.length),
                sequence.unshift(48),
                sequence
              );
            },
            parseSig: function (sig) {
              var cursor;
              if (48 != sig[0])
                throw new Error("Signature not a valid DERSequence");
              if (2 != sig[(cursor = 2)])
                throw new Error(
                  "First element in signature must be a DERInteger"
                );
              var rBa = sig.slice(cursor + 2, cursor + 2 + sig[cursor + 1]);
              if (2 != sig[(cursor += 2 + sig[cursor + 1])])
                throw new Error(
                  "Second element in signature must be a DERInteger"
                );
              var sBa = sig.slice(cursor + 2, cursor + 2 + sig[cursor + 1]);
              return (
                (cursor += 2 + sig[cursor + 1]),
                {
                  r: BigInteger.fromByteArrayUnsigned(rBa),
                  s: BigInteger.fromByteArrayUnsigned(sBa),
                }
              );
            },
            parseSigCompact: function (sig) {
              if (65 !== sig.length) throw "Signature has the wrong length";
              var i = sig[0] - 27;
              if (i < 0 || i > 7) throw "Invalid signature type";
              var n = ecparams.getN();
              return {
                r: BigInteger.fromByteArrayUnsigned(sig.slice(1, 33)).mod(n),
                s: BigInteger.fromByteArrayUnsigned(sig.slice(33, 65)).mod(n),
                i: i,
              };
            },
            recoverPubKey: function (r, s, hash, i) {
              var isYEven = 1 & (i &= 3),
                isSecondKey = i >> 1,
                n = ecparams.getN(),
                G = ecparams.getG(),
                curve = ecparams.getCurve(),
                p = curve.getQ(),
                a = curve.getA().toBigInteger(),
                b = curve.getB().toBigInteger();
              P_OVER_FOUR ||
                (P_OVER_FOUR = p
                  .add(BigInteger.ONE)
                  .divide(BigInteger.valueOf(4)));
              var x = isSecondKey ? r.add(n) : r,
                beta = x
                  .multiply(x)
                  .multiply(x)
                  .add(a.multiply(x))
                  .add(b)
                  .mod(p)
                  .modPow(P_OVER_FOUR, p),
                y =
                  (beta.isEven(),
                  (beta.isEven() ? !isYEven : isYEven)
                    ? beta
                    : p.subtract(beta)),
                R = new EllipticCurve.PointFp(
                  curve,
                  curve.fromBigInteger(x),
                  curve.fromBigInteger(y)
                );
              R.validate();
              var e = BigInteger.fromByteArrayUnsigned(hash),
                eNeg = BigInteger.ZERO.subtract(e).mod(n),
                rInv = r.modInverse(n),
                Q = (function (P, k, Q, l) {
                  for (
                    var m = Math.max(k.bitLength(), l.bitLength()),
                      Z = P.add2D(Q),
                      R = P.curve.getInfinity(),
                      i = m - 1;
                    i >= 0;
                    --i
                  )
                    ((R = R.twice2D()).z = BigInteger.ONE),
                      k.testBit(i)
                        ? (R = l.testBit(i) ? R.add2D(Z) : R.add2D(P))
                        : l.testBit(i) && (R = R.add2D(Q));
                  return R;
                })(R, s, G, eNeg).multiply(rInv);
              if ((Q.validate(), !ECDSA.verifyRaw(e, r, s, Q)))
                throw "Pubkey recovery unsuccessful";
              var pubKey = new Bitcoin.ECKey();
              return (pubKey.pub = Q), pubKey;
            },
            calcPubkeyRecoveryParam: function (address, r, s, hash) {
              for (var i = 0; i < 4; i++)
                try {
                  if (
                    Bitcoin.ECDSA.recoverPubKey(r, s, hash, i)
                      .getBitcoinAddress()
                      .toString() == address
                  )
                    return i;
                } catch (e) {}
              throw "Unable to find valid recovery factor";
            },
          }))),
        (Bitcoin.KeyPool = new (function () {
          return (
            (this.keyArray = []),
            (this.push = function (item) {
              if (null != item && null != item.priv) {
                var doAdd = !0;
                for (var index in this.keyArray) {
                  var currentItem = this.keyArray[index];
                  if (
                    null != currentItem &&
                    null != currentItem.priv &&
                    item.getBitcoinAddress() == currentItem.getBitcoinAddress()
                  ) {
                    doAdd = !1;
                    break;
                  }
                }
                doAdd && this.keyArray.push(item);
              }
            }),
            (this.reset = function () {
              this.keyArray = [];
            }),
            (this.getArray = function () {
              return this.keyArray.slice(0);
            }),
            (this.setArray = function (ka) {
              this.keyArray = ka;
            }),
            (this.length = function () {
              return this.keyArray.length;
            }),
            (this.toString = function () {
              var keyPoolString = "# = " + this.length() + "\n",
                pool = this.getArray();
              for (var index in pool) {
                var item = pool[index];
                Bitcoin.Util.hasMethods(
                  item,
                  "getBitcoinAddress",
                  "toString"
                ) &&
                  null != item &&
                  (keyPoolString +=
                    '"' +
                    item.getBitcoinAddress() +
                    '", "' +
                    item.toString("wif") +
                    '"\n');
              }
              return keyPoolString;
            }),
            this
          );
        })()),
        (Bitcoin.Bip38Key =
          (((Bip38 = function (address, encryptedKey) {
            (this.address = address), (this.priv = encryptedKey);
          }).prototype.getBitcoinAddress = function () {
            return this.address;
          }),
          (Bip38.prototype.toString = function () {
            return this.priv;
          }),
          Bip38)),
        (Bitcoin.ECKey = (function () {
          var ECDSA = Bitcoin.ECDSA,
            KeyPool = Bitcoin.KeyPool,
            ecparams = EllipticCurve.getSECCurveByName("secp256k1"),
            ECKey = function (input) {
              if (input) {
                if (input instanceof BigInteger) this.priv = input;
                else if (Bitcoin.Util.isArray(input))
                  this.priv = BigInteger.fromByteArrayUnsigned(input);
                else if ("string" == typeof input) {
                  var bytes = null;
                  try {
                    /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{52}$/.test(
                      input
                    )
                      ? ((bytes =
                          ECKey.decodeCompressedWalletImportFormat(input)),
                        (this.compressed = !0))
                      : ECKey.isHexFormat(input) &&
                        (bytes = Crypto.util.hexToBytes(input));
                  } catch (exc1) {
                    this.setError(exc1);
                  }
                  ECKey.isBase6Format(input)
                    ? (this.priv = new BigInteger(input, 6))
                    : null == bytes || 32 != bytes.length
                    ? (this.priv = null)
                    : (this.priv = BigInteger.fromByteArrayUnsigned(bytes));
                }
              } else {
                var n = ecparams.getN();
                this.priv = ECDSA.getBigRandom(n);
              }
              this.compressed =
                null == this.compressed
                  ? !!ECKey.compressByDefault
                  : this.compressed;
              try {
                null != this.priv &&
                  0 == BigInteger.ZERO.compareTo(this.priv) &&
                  this.setError("Error: BigInteger equal to zero.");
                var rangeLimitBytes = Crypto.util.hexToBytes(
                    "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140"
                  ),
                  limitBigInt =
                    BigInteger.fromByteArrayUnsigned(rangeLimitBytes);
                null != this.priv &&
                  limitBigInt.compareTo(this.priv) < 0 &&
                  this.setError("Error: BigInteger outside of curve range."),
                  null != this.priv && KeyPool.push(this);
              } catch (exc2) {
                this.setError(exc2);
              }
            };
          return (
            "FLO" == GLOBAL.cryptocoin
              ? (ECKey.privateKeyPrefix = 163)
              : "FLO_TEST" == GLOBAL.cryptocoin
              ? (ECKey.privateKeyPrefix = 239)
              : "BTC" == GLOBAL.cryptocoin
              ? (ECKey.privateKeyPrefix = 128)
              : "BTC_TEST" == GLOBAL.cryptocoin &&
                (ECKey.privateKeyPrefix = 239),
            (ECKey.compressByDefault = !1),
            (ECKey.prototype.setError = function (err) {
              return (this.error = err), (this.priv = null), this;
            }),
            (ECKey.prototype.setCompressed = function (v) {
              return (
                (this.compressed = !!v),
                this.pubPoint && (this.pubPoint.compressed = this.compressed),
                this
              );
            }),
            (ECKey.prototype.getPub = function () {
              return this.compressed
                ? this.pubComp
                  ? this.pubComp
                  : (this.pubComp = this.getPubPoint().getEncoded(1))
                : this.pubUncomp
                ? this.pubUncomp
                : (this.pubUncomp = this.getPubPoint().getEncoded(0));
            }),
            (ECKey.prototype.getPubPoint = function () {
              return (
                this.pubPoint ||
                  ((this.pubPoint = ecparams.getG().multiply(this.priv)),
                  (this.pubPoint.compressed = this.compressed)),
                this.pubPoint
              );
            }),
            (ECKey.prototype.getPubKeyHex = function () {
              return this.compressed
                ? this.pubKeyHexComp
                  ? this.pubKeyHexComp
                  : (this.pubKeyHexComp = Crypto.util
                      .bytesToHex(this.getPub())
                      .toString()
                      .toUpperCase())
                : this.pubKeyHexUncomp
                ? this.pubKeyHexUncomp
                : (this.pubKeyHexUncomp = Crypto.util
                    .bytesToHex(this.getPub())
                    .toString()
                    .toUpperCase());
            }),
            (ECKey.prototype.getPubKeyHash = function () {
              return this.compressed
                ? this.pubKeyHashComp
                  ? this.pubKeyHashComp
                  : (this.pubKeyHashComp = Bitcoin.Util.sha256ripe160(
                      this.getPub()
                    ))
                : this.pubKeyHashUncomp
                ? this.pubKeyHashUncomp
                : (this.pubKeyHashUncomp = Bitcoin.Util.sha256ripe160(
                    this.getPub()
                  ));
            }),
            (ECKey.prototype.getBitcoinAddress = function () {
              var hash = this.getPubKeyHash();
              return new Bitcoin.Address(hash).toString();
            }),
            (ECKey.prototype.setPub = function (pub) {
              Bitcoin.Util.isArray(pub) &&
                (pub = Crypto.util.bytesToHex(pub).toString().toUpperCase());
              var ecPoint = ecparams.getCurve().decodePointHex(pub);
              return (
                this.setCompressed(ecPoint.compressed),
                (this.pubPoint = ecPoint),
                this
              );
            }),
            (ECKey.prototype.getBitcoinWalletImportFormat = function () {
              var bytes = this.getBitcoinPrivateKeyByteArray();
              if (null == bytes) return "";
              bytes.unshift(ECKey.privateKeyPrefix),
                this.compressed && bytes.push(1);
              var checksum = Crypto.SHA256(
                Crypto.SHA256(bytes, { asBytes: !0 }),
                { asBytes: !0 }
              );
              return (
                (bytes = bytes.concat(checksum.slice(0, 4))),
                Bitcoin.Base58.encode(bytes)
              );
            }),
            (ECKey.prototype.getBitcoinHexFormat = function () {
              return Crypto.util
                .bytesToHex(this.getBitcoinPrivateKeyByteArray())
                .toString()
                .toUpperCase();
            }),
            (ECKey.prototype.getBitcoinBase64Format = function () {
              return Crypto.util.bytesToBase64(
                this.getBitcoinPrivateKeyByteArray()
              );
            }),
            (ECKey.prototype.getBitcoinPrivateKeyByteArray = function () {
              if (null == this.priv) return null;
              for (
                var bytes = this.priv.toByteArrayUnsigned();
                bytes.length < 32;

              )
                bytes.unshift(0);
              return bytes;
            }),
            (ECKey.prototype.toString = function (format) {
              return "base64" ==
                (format = format || "").toString().toLowerCase() ||
                "b64" == format.toString().toLowerCase()
                ? this.getBitcoinBase64Format()
                : "wif" == format.toString().toLowerCase()
                ? this.getBitcoinWalletImportFormat()
                : this.getBitcoinHexFormat();
            }),
            (ECKey.prototype.sign = function (hash) {
              return ECDSA.sign(hash, this.priv);
            }),
            (ECKey.prototype.verify = function (hash, sig) {
              return ECDSA.verify(hash, sig, this.getPub());
            }),
            (ECKey.decodeWalletImportFormat = function (privStr) {
              var bytes = Bitcoin.Base58.decode(privStr),
                hash = bytes.slice(0, 33),
                checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: !0 }), {
                  asBytes: !0,
                });
              if (
                checksum[0] != bytes[33] ||
                checksum[1] != bytes[34] ||
                checksum[2] != bytes[35] ||
                checksum[3] != bytes[36]
              )
                throw "Checksum validation failed!";
              hash.shift();
              return hash;
            }),
            (ECKey.decodeCompressedWalletImportFormat = function (privStr) {
              var bytes = Bitcoin.Base58.decode(privStr),
                hash = bytes.slice(0, 34),
                checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: !0 }), {
                  asBytes: !0,
                });
              if (
                checksum[0] != bytes[34] ||
                checksum[1] != bytes[35] ||
                checksum[2] != bytes[36] ||
                checksum[3] != bytes[37]
              )
                throw "Checksum validation failed!";
              hash.shift();
              return hash.pop(), hash;
            }),
            (ECKey.isHexFormat = function (key) {
              return (key = key.toString()), /^[A-Fa-f0-9]{64}$/.test(key);
            }),
            (ECKey.isWalletImportFormat = function (key) {
              return (
                (key = key.toString()),
                128 == ECKey.privateKeyPrefix
                  ? /^5[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{50}$/.test(
                      key
                    )
                  : /^R[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{50}$/.test(
                      key
                    )
              );
            }),
            (ECKey.isCompressedWalletImportFormat = function (key) {
              return (
                (key = key.toString()),
                128 == ECKey.privateKeyPrefix
                  ? /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
                      key
                    )
                  : /^R[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
                      key
                    )
              );
            }),
            (ECKey.isBase64Format = function (key) {
              return (
                (key = key.toString()),
                /^[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789=+\/]{44}$/.test(
                  key
                )
              );
            }),
            (ECKey.isBase6Format = function (key) {
              return (key = key.toString()), /^[012345]{99}$/.test(key);
            }),
            (ECKey.isMiniFormat = function (key) {
              key = key.toString();
              var validChars22 =
                  /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{21}$/.test(
                    key
                  ),
                validChars26 =
                  /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{25}$/.test(
                    key
                  ),
                validChars30 =
                  /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{29}$/.test(
                    key
                  ),
                testBytes = Crypto.SHA256(key + "?", { asBytes: !0 });
              return (
                (0 === testBytes[0] || 1 === testBytes[0]) &&
                (validChars22 || validChars26 || validChars30)
              );
            }),
            ECKey
          );
        })()),
        (Bitcoin.Util = {
          isArray:
            Array.isArray ||
            function (o) {
              return "[object Array]" === Object.prototype.toString.call(o);
            },
          makeFilledArray: function (len, val) {
            for (var array = [], i = 0; i < len; ) array[i++] = val;
            return array;
          },
          numToVarInt: function (i) {
            return i < 253
              ? [i]
              : i <= 65536
              ? [253, i >>> 8, 255 & i]
              : i <= 1
              ? [254].concat(Crypto.util.wordsToBytes([i]))
              : [255].concat(Crypto.util.wordsToBytes([i >>> 32, i]));
          },
          valueToBigInt: function (valueBuffer) {
            return valueBuffer instanceof BigInteger
              ? valueBuffer
              : BigInteger.fromByteArrayUnsigned(valueBuffer);
          },
          formatValue: function (valueBuffer) {
            for (
              var value = this.valueToBigInt(valueBuffer).toString(),
                integerPart =
                  value.length > 8 ? value.substr(0, value.length - 8) : "0",
                decimalPart =
                  value.length > 8 ? value.substr(value.length - 8) : value;
              decimalPart.length < 8;

            )
              decimalPart = "0" + decimalPart;
            for (
              decimalPart = decimalPart.replace(/0*$/, "");
              decimalPart.length < 2;

            )
              decimalPart += "0";
            return integerPart + "." + decimalPart;
          },
          parseValue: function (valueString) {
            for (
              var valueComp = valueString.split("."),
                integralPart = valueComp[0],
                fractionalPart = valueComp[1] || "0";
              fractionalPart.length < 8;

            )
              fractionalPart += "0";
            fractionalPart = fractionalPart.replace(/^0+/g, "");
            var value = BigInteger.valueOf(parseInt(integralPart));
            return (value = (value = value.multiply(
              BigInteger.valueOf(1e8)
            )).add(BigInteger.valueOf(parseInt(fractionalPart))));
          },
          sha256ripe160: function (data) {
            return ripemd160(Crypto.SHA256(data, { asBytes: !0 }), {
              asBytes: !0,
            });
          },
          dsha256: function (data) {
            return Crypto.SHA256(Crypto.SHA256(data, { asBytes: !0 }), {
              asBytes: !0,
            });
          },
          hasMethods: function (obj) {
            for (var methodName, i = 1; (methodName = arguments[i++]); )
              if ("function" != typeof obj[methodName]) return !1;
            return !0;
          },
        });
    })(),
    ((ellipticEncryption = GLOBAL.ellipticCurveEncryption =
      function () {}).rng = new SecureRandom()),
    (ellipticEncryption.getCurveParameters = function (curveName) {
      curveName = void 0 !== curveName ? curveName : "secp256k1";
      var c = EllipticCurve.getSECCurveByName(curveName),
        curveDetails = { Q: "", A: "", B: "", GX: "", GY: "", N: "" };
      return (
        (curveDetails.Q = c.getCurve().getQ().toString()),
        (curveDetails.A = c.getCurve().getA().toBigInteger().toString()),
        (curveDetails.B = c.getCurve().getB().toBigInteger().toString()),
        (curveDetails.GX = c.getG().getX().toBigInteger().toString()),
        (curveDetails.GY = c.getG().getY().toBigInteger().toString()),
        (curveDetails.N = c.getN().toString()),
        curveDetails
      );
    }),
    (ellipticEncryption.selectedCurve =
      ellipticEncryption.getCurveParameters("secp256k1")),
    (ellipticEncryption.get_curve = function () {
      return new EllipticCurve.CurveFp(
        new BigInteger(this.selectedCurve.Q),
        new BigInteger(this.selectedCurve.A),
        new BigInteger(this.selectedCurve.B)
      );
    }),
    (ellipticEncryption.get_G = function (curve) {
      return new EllipticCurve.PointFp(
        curve,
        curve.fromBigInteger(new BigInteger(this.selectedCurve.GX)),
        curve.fromBigInteger(new BigInteger(this.selectedCurve.GY))
      );
    }),
    (ellipticEncryption.pick_rand = function () {
      var n = new BigInteger(this.selectedCurve.N),
        n1 = n.subtract(BigInteger.ONE);
      return new BigInteger(n.bitLength(), this.rng)
        .mod(n1)
        .add(BigInteger.ONE);
    }),
    (ellipticEncryption.senderRandom = function () {
      return this.pick_rand().toString();
    }),
    (ellipticEncryption.receiverRandom = function () {
      return this.pick_rand().toString();
    }),
    (ellipticEncryption.senderPublicString = function (senderPrivateKey) {
      var senderKeyECData = {},
        curve = this.get_curve(),
        G = this.get_G(curve),
        a = new BigInteger(senderPrivateKey),
        P = G.multiply(a);
      return (
        (senderKeyECData.XValuePublicString = P.getX()
          .toBigInteger()
          .toString()),
        (senderKeyECData.YValuePublicString = P.getY()
          .toBigInteger()
          .toString()),
        senderKeyECData
      );
    }),
    (ellipticEncryption.receiverPublicString = function (receiverPublicKey) {
      var receiverKeyECData = {},
        curve = this.get_curve(),
        G = this.get_G(curve),
        a = new BigInteger(receiverPublicKey),
        P = G.multiply(a);
      return (
        (receiverKeyECData.XValuePublicString = P.getX()
          .toBigInteger()
          .toString()),
        (receiverKeyECData.YValuePublicString = P.getY()
          .toBigInteger()
          .toString()),
        receiverKeyECData
      );
    }),
    (ellipticEncryption.senderSharedKeyDerivation = function (
      receiverPublicStringXValue,
      receiverPublicStringYValue,
      senderPrivateKey
    ) {
      var senderDerivedKey = {},
        curve = this.get_curve(),
        P = new EllipticCurve.PointFp(
          curve,
          curve.fromBigInteger(new BigInteger(receiverPublicStringXValue)),
          curve.fromBigInteger(new BigInteger(receiverPublicStringYValue))
        ),
        a = new BigInteger(senderPrivateKey),
        S = P.multiply(a);
      return (
        (senderDerivedKey.XValue = S.getX().toBigInteger().toString()),
        (senderDerivedKey.YValue = S.getY().toBigInteger().toString()),
        senderDerivedKey
      );
    }),
    (ellipticEncryption.receiverSharedKeyDerivation = function (
      senderPublicStringXValue,
      senderPublicStringYValue,
      receiverPrivateKey
    ) {
      var receiverDerivedKey = {},
        curve = this.get_curve(),
        P = new EllipticCurve.PointFp(
          curve,
          curve.fromBigInteger(new BigInteger(senderPublicStringXValue)),
          curve.fromBigInteger(new BigInteger(senderPublicStringYValue))
        ),
        a = new BigInteger(receiverPrivateKey),
        S = P.multiply(a);
      return (
        (receiverDerivedKey.XValue = S.getX().toBigInteger().toString()),
        (receiverDerivedKey.YValue = S.getY().toBigInteger().toString()),
        receiverDerivedKey
      );
    }),
    (function () {
      function n(a) {
        throw a;
      }
      var q = null;
      function s(a, b) {
        (this.a = a), (this.b = b);
      }
      function u(a, b) {
        var g,
          d = [],
          h = (1 << b) - 1,
          f = a.length * b;
        for (g = 0; g < f; g += b)
          d[g >>> 5] |= (a.charCodeAt(g / b) & h) << (32 - b - (g % 32));
        return { value: d, binLen: f };
      }
      function x(a) {
        var h,
          f,
          b = [],
          d = a.length;
        for (
          0 != d % 2 && n("String of HEX type must be in byte increments"),
            h = 0;
          h < d;
          h += 2
        )
          (f = parseInt(a.substr(h, 2), 16)),
            isNaN(f) && n("String of HEX type contains invalid characters"),
            (b[h >>> 3] |= f << (24 - (h % 8) * 4));
        return { value: b, binLen: 4 * d };
      }
      function B(a) {
        var h,
          f,
          g,
          k,
          m,
          b = [],
          d = 0;
        for (
          -1 === a.search(/^[a-zA-Z0-9=+\/]+$/) &&
            n("Invalid character in base-64 string"),
            h = a.indexOf("="),
            a = a.replace(/\=/g, ""),
            -1 !== h &&
              h < a.length &&
              n("Invalid '=' found in base-64 string"),
            f = 0;
          f < a.length;
          f += 4
        ) {
          for (m = a.substr(f, 4), g = k = 0; g < m.length; g += 1)
            k |=
              (h =
                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(
                  m[g]
                )) <<
              (18 - 6 * g);
          for (g = 0; g < m.length - 1; g += 1)
            (b[d >> 2] |= ((k >>> (16 - 8 * g)) & 255) << (24 - (d % 4) * 8)),
              (d += 1);
        }
        return { value: b, binLen: 8 * d };
      }
      function E(a, b) {
        var f,
          g,
          d = "",
          h = 4 * a.length;
        for (f = 0; f < h; f += 1)
          (g = a[f >>> 2] >>> (8 * (3 - (f % 4)))),
            (d +=
              "0123456789abcdef".charAt((g >>> 4) & 15) +
              "0123456789abcdef".charAt(15 & g));
        return b.outputUpper ? d.toUpperCase() : d;
      }
      function F(a, b) {
        var f,
          g,
          k,
          d = "",
          h = 4 * a.length;
        for (f = 0; f < h; f += 3)
          for (
            k =
              (((a[f >>> 2] >>> (8 * (3 - (f % 4)))) & 255) << 16) |
              (((a[(f + 1) >>> 2] >>> (8 * (3 - ((f + 1) % 4)))) & 255) << 8) |
              ((a[(f + 2) >>> 2] >>> (8 * (3 - ((f + 2) % 4)))) & 255),
              g = 0;
            4 > g;
            g += 1
          )
            d =
              8 * f + 6 * g <= 32 * a.length
                ? d +
                  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(
                    (k >>> (6 * (3 - g))) & 63
                  )
                : d + b.b64Pad;
        return d;
      }
      function G(a) {
        var b = { outputUpper: !1, b64Pad: "=" };
        try {
          a.hasOwnProperty("outputUpper") && (b.outputUpper = a.outputUpper),
            a.hasOwnProperty("b64Pad") && (b.b64Pad = a.b64Pad);
        } catch (d) {}
        return (
          "boolean" != typeof b.outputUpper &&
            n("Invalid outputUpper formatting option"),
          "string" != typeof b.b64Pad && n("Invalid b64Pad formatting option"),
          b
        );
      }
      function H(a, b) {
        var d = q;
        d = new s(a.a, a.b);
        return 32 >= b
          ? new s(
              (d.a >>> b) | ((d.b << (32 - b)) & 4294967295),
              (d.b >>> b) | ((d.a << (32 - b)) & 4294967295)
            )
          : new s(
              (d.b >>> (b - 32)) | ((d.a << (64 - b)) & 4294967295),
              (d.a >>> (b - 32)) | ((d.b << (64 - b)) & 4294967295)
            );
      }
      function I(a, b) {
        return 32 >= b
          ? new s(a.a >>> b, (a.b >>> b) | ((a.a << (32 - b)) & 4294967295))
          : new s(0, a.a >>> (b - 32));
      }
      function J(a, b, d) {
        return new s((a.a & b.a) ^ (~a.a & d.a), (a.b & b.b) ^ (~a.b & d.b));
      }
      function U(a, b, d) {
        return new s(
          (a.a & b.a) ^ (a.a & d.a) ^ (b.a & d.a),
          (a.b & b.b) ^ (a.b & d.b) ^ (b.b & d.b)
        );
      }
      function V(a) {
        var b = H(a, 28),
          d = H(a, 34);
        return (a = H(a, 39)), new s(b.a ^ d.a ^ a.a, b.b ^ d.b ^ a.b);
      }
      function W(a) {
        var b = H(a, 14),
          d = H(a, 18);
        return (a = H(a, 41)), new s(b.a ^ d.a ^ a.a, b.b ^ d.b ^ a.b);
      }
      function X(a) {
        var b = H(a, 1),
          d = H(a, 8);
        return (a = I(a, 7)), new s(b.a ^ d.a ^ a.a, b.b ^ d.b ^ a.b);
      }
      function Y(a) {
        var b = H(a, 19),
          d = H(a, 61);
        return (a = I(a, 6)), new s(b.a ^ d.a ^ a.a, b.b ^ d.b ^ a.b);
      }
      function Z(a, b) {
        var d, h, f;
        return (
          (d = (65535 & a.b) + (65535 & b.b)),
          (f =
            ((65535 & (h = (a.b >>> 16) + (b.b >>> 16) + (d >>> 16))) << 16) |
            (65535 & d)),
          (d = (65535 & a.a) + (65535 & b.a) + (h >>> 16)),
          new s(
            ((65535 & (h = (a.a >>> 16) + (b.a >>> 16) + (d >>> 16))) << 16) |
              (65535 & d),
            f
          )
        );
      }
      function aa(a, b, d, h) {
        var f, g, k;
        return (
          (f = (65535 & a.b) + (65535 & b.b) + (65535 & d.b) + (65535 & h.b)),
          (k =
            ((65535 &
              (g =
                (a.b >>> 16) +
                (b.b >>> 16) +
                (d.b >>> 16) +
                (h.b >>> 16) +
                (f >>> 16))) <<
              16) |
            (65535 & f)),
          (f =
            (65535 & a.a) +
            (65535 & b.a) +
            (65535 & d.a) +
            (65535 & h.a) +
            (g >>> 16)),
          new s(
            ((65535 &
              (g =
                (a.a >>> 16) +
                (b.a >>> 16) +
                (d.a >>> 16) +
                (h.a >>> 16) +
                (f >>> 16))) <<
              16) |
              (65535 & f),
            k
          )
        );
      }
      function ba(a, b, d, h, f) {
        var g, k, m;
        return (
          (g =
            (65535 & a.b) +
            (65535 & b.b) +
            (65535 & d.b) +
            (65535 & h.b) +
            (65535 & f.b)),
          (m =
            ((65535 &
              (k =
                (a.b >>> 16) +
                (b.b >>> 16) +
                (d.b >>> 16) +
                (h.b >>> 16) +
                (f.b >>> 16) +
                (g >>> 16))) <<
              16) |
            (65535 & g)),
          (g =
            (65535 & a.a) +
            (65535 & b.a) +
            (65535 & d.a) +
            (65535 & h.a) +
            (65535 & f.a) +
            (k >>> 16)),
          new s(
            ((65535 &
              (k =
                (a.a >>> 16) +
                (b.a >>> 16) +
                (d.a >>> 16) +
                (h.a >>> 16) +
                (f.a >>> 16) +
                (g >>> 16))) <<
              16) |
              (65535 & g),
            m
          )
        );
      }
      function $(a, b, d) {
        var h,
          f,
          g,
          k,
          m,
          j,
          A,
          C,
          K,
          e,
          L,
          v,
          l,
          M,
          t,
          p,
          y,
          z,
          r,
          N,
          O,
          P,
          Q,
          R,
          c,
          S,
          T,
          D,
          w = [];
        for (
          "SHA-384" === d || "SHA-512" === d
            ? ((L = 80),
              (h = 31 + (((b + 128) >>> 10) << 5)),
              (M = 32),
              (t = 2),
              (p = Z),
              (y = aa),
              (z = ba),
              (r = X),
              (N = Y),
              (O = V),
              (P = W),
              (R = U),
              (Q = J),
              (S = [
                new (c = s)(1116352408, 3609767458),
                new c(1899447441, 602891725),
                new c(3049323471, 3964484399),
                new c(3921009573, 2173295548),
                new c(961987163, 4081628472),
                new c(1508970993, 3053834265),
                new c(2453635748, 2937671579),
                new c(2870763221, 3664609560),
                new c(3624381080, 2734883394),
                new c(310598401, 1164996542),
                new c(607225278, 1323610764),
                new c(1426881987, 3590304994),
                new c(1925078388, 4068182383),
                new c(2162078206, 991336113),
                new c(2614888103, 633803317),
                new c(3248222580, 3479774868),
                new c(3835390401, 2666613458),
                new c(4022224774, 944711139),
                new c(264347078, 2341262773),
                new c(604807628, 2007800933),
                new c(770255983, 1495990901),
                new c(1249150122, 1856431235),
                new c(1555081692, 3175218132),
                new c(1996064986, 2198950837),
                new c(2554220882, 3999719339),
                new c(2821834349, 766784016),
                new c(2952996808, 2566594879),
                new c(3210313671, 3203337956),
                new c(3336571891, 1034457026),
                new c(3584528711, 2466948901),
                new c(113926993, 3758326383),
                new c(338241895, 168717936),
                new c(666307205, 1188179964),
                new c(773529912, 1546045734),
                new c(1294757372, 1522805485),
                new c(1396182291, 2643833823),
                new c(1695183700, 2343527390),
                new c(1986661051, 1014477480),
                new c(2177026350, 1206759142),
                new c(2456956037, 344077627),
                new c(2730485921, 1290863460),
                new c(2820302411, 3158454273),
                new c(3259730800, 3505952657),
                new c(3345764771, 106217008),
                new c(3516065817, 3606008344),
                new c(3600352804, 1432725776),
                new c(4094571909, 1467031594),
                new c(275423344, 851169720),
                new c(430227734, 3100823752),
                new c(506948616, 1363258195),
                new c(659060556, 3750685593),
                new c(883997877, 3785050280),
                new c(958139571, 3318307427),
                new c(1322822218, 3812723403),
                new c(1537002063, 2003034995),
                new c(1747873779, 3602036899),
                new c(1955562222, 1575990012),
                new c(2024104815, 1125592928),
                new c(2227730452, 2716904306),
                new c(2361852424, 442776044),
                new c(2428436474, 593698344),
                new c(2756734187, 3733110249),
                new c(3204031479, 2999351573),
                new c(3329325298, 3815920427),
                new c(3391569614, 3928383900),
                new c(3515267271, 566280711),
                new c(3940187606, 3454069534),
                new c(4118630271, 4000239992),
                new c(116418474, 1914138554),
                new c(174292421, 2731055270),
                new c(289380356, 3203993006),
                new c(460393269, 320620315),
                new c(685471733, 587496836),
                new c(852142971, 1086792851),
                new c(1017036298, 365543100),
                new c(1126000580, 2618297676),
                new c(1288033470, 3409855158),
                new c(1501505948, 4234509866),
                new c(1607167915, 987167468),
                new c(1816402316, 1246189591),
              ]),
              (e =
                "SHA-384" === d
                  ? [
                      new c(3418070365, 3238371032),
                      new c(1654270250, 914150663),
                      new c(2438529370, 812702999),
                      new c(355462360, 4144912697),
                      new c(1731405415, 4290775857),
                      new c(41048885895, 1750603025),
                      new c(3675008525, 1694076839),
                      new c(1203062813, 3204075428),
                    ]
                  : [
                      new c(1779033703, 4089235720),
                      new c(3144134277, 2227873595),
                      new c(1013904242, 4271175723),
                      new c(2773480762, 1595750129),
                      new c(1359893119, 2917565137),
                      new c(2600822924, 725511199),
                      new c(528734635, 4215389547),
                      new c(1541459225, 327033209),
                    ]))
            : n("Unexpected error in SHA-2 implementation"),
            a[b >>> 5] |= 128 << (24 - (b % 32)),
            a[h] = b,
            T = a.length,
            v = 0;
          v < T;
          v += M
        ) {
          for (
            b = e[0],
              h = e[1],
              f = e[2],
              g = e[3],
              k = e[4],
              m = e[5],
              j = e[6],
              A = e[7],
              l = 0;
            l < L;
            l += 1
          )
            (w[l] =
              16 > l
                ? new c(a[l * t + v], a[l * t + v + 1])
                : y(N(w[l - 2]), w[l - 7], r(w[l - 15]), w[l - 16])),
              (C = z(A, P(k), Q(k, m, j), S[l], w[l])),
              (K = p(O(b), R(b, h, f))),
              (A = j),
              (j = m),
              (m = k),
              (k = p(g, C)),
              (g = f),
              (f = h),
              (h = b),
              (b = p(C, K));
          (e[0] = p(b, e[0])),
            (e[1] = p(h, e[1])),
            (e[2] = p(f, e[2])),
            (e[3] = p(g, e[3])),
            (e[4] = p(k, e[4])),
            (e[5] = p(m, e[5])),
            (e[6] = p(j, e[6])),
            (e[7] = p(A, e[7]));
        }
        return (
          "SHA-384" === d
            ? (D = [
                e[0].a,
                e[0].b,
                e[1].a,
                e[1].b,
                e[2].a,
                e[2].b,
                e[3].a,
                e[3].b,
                e[4].a,
                e[4].b,
                e[5].a,
                e[5].b,
              ])
            : "SHA-512" === d
            ? (D = [
                e[0].a,
                e[0].b,
                e[1].a,
                e[1].b,
                e[2].a,
                e[2].b,
                e[3].a,
                e[3].b,
                e[4].a,
                e[4].b,
                e[5].a,
                e[5].b,
                e[6].a,
                e[6].b,
                e[7].a,
                e[7].b,
              ])
            : n("Unexpected error in SHA-2 implementation"),
          D
        );
      }
      GLOBAL.jsSHA = function (a, b, d) {
        var h = q,
          f = q,
          g = 0,
          k = [0],
          m = 0,
          j = q;
        8 === (m = void 0 !== d ? d : 8) ||
          16 === m ||
          n("charSize must be 8 or 16"),
          "HEX" === b
            ? (0 != a.length % 2 &&
                n("srcString of HEX type must be in byte increments"),
              (j = x(a)),
              (g = j.binLen),
              (k = j.value))
            : "ASCII" === b || "TEXT" === b
            ? ((j = u(a, m)), (g = j.binLen), (k = j.value))
            : "B64" === b
            ? ((j = B(a)), (g = j.binLen), (k = j.value))
            : n("inputFormat must be HEX, TEXT, ASCII, or B64"),
          (this.getHash = function (a, b, d) {
            var e = q,
              m = k.slice(),
              j = "";
            switch (b) {
              case "HEX":
                e = E;
                break;
              case "B64":
                e = F;
                break;
              default:
                n("format must be HEX or B64");
            }
            return (
              "SHA-384" === a
                ? (q === h && (h = $(m, g, a)), (j = e(h, G(d))))
                : "SHA-512" === a
                ? (q === f && (f = $(m, g, a)), (j = e(f, G(d))))
                : n("Chosen SHA variant is not supported"),
              j
            );
          }),
          (this.getHMAC = function (a, b, d, e, f) {
            var h,
              l,
              j,
              t,
              p,
              y = [],
              z = [],
              r = q;
            switch (e) {
              case "HEX":
                h = E;
                break;
              case "B64":
                h = F;
                break;
              default:
                n("outputFormat must be HEX or B64");
            }
            for (
              "SHA-384" === d
                ? ((j = 128), (p = 384))
                : "SHA-512" === d
                ? ((j = 128), (p = 512))
                : n("Chosen SHA variant is not supported"),
                "HEX" === b
                  ? ((t = (r = x(a)).binLen), (l = r.value))
                  : "ASCII" === b || "TEXT" === b
                  ? ((t = (r = u(a, m)).binLen), (l = r.value))
                  : "B64" === b
                  ? ((t = (r = B(a)).binLen), (l = r.value))
                  : n("inputFormat must be HEX, TEXT, ASCII, or B64"),
                a = 8 * j,
                b = j / 4 - 1,
                j < t / 8
                  ? ((l = $(l, t, d))[b] &= 4294967040)
                  : j > t / 8 && (l[b] &= 4294967040),
                j = 0;
              j <= b;
              j += 1
            )
              (y[j] = 909522486 ^ l[j]), (z[j] = 1549556828 ^ l[j]);
            return h(
              (d = $(z.concat($(y.concat(k), a + g, d)), a + p, d)),
              G(f)
            );
          });
      };
    })(),
    (function () {
      var bech32 = (GLOBAL.bech32 = {}),
        segwit_addr = (GLOBAL.segwit_addr = {}),
        CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l",
        GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
      function getEncodingConst(enc) {
        return enc == bech32.encodings.BECH32
          ? 1
          : enc == bech32.encodings.BECH32M
          ? 734539939
          : null;
      }
      function polymod(values) {
        for (var chk = 1, p = 0; p < values.length; ++p) {
          var top = chk >> 25;
          chk = ((33554431 & chk) << 5) ^ values[p];
          for (var i = 0; i < 5; ++i) (top >> i) & 1 && (chk ^= GENERATOR[i]);
        }
        return chk;
      }
      function hrpExpand(hrp) {
        var p,
          ret = [];
        for (p = 0; p < hrp.length; ++p) ret.push(hrp.charCodeAt(p) >> 5);
        for (ret.push(0), p = 0; p < hrp.length; ++p)
          ret.push(31 & hrp.charCodeAt(p));
        return ret;
      }
      function convertbits(data, frombits, tobits, pad) {
        for (
          var acc = 0, bits = 0, ret = [], maxv = (1 << tobits) - 1, p = 0;
          p < data.length;
          ++p
        ) {
          var value = data[p];
          if (value < 0 || value >> frombits != 0) return null;
          for (
            acc = (acc << frombits) | value, bits += frombits;
            bits >= tobits;

          )
            (bits -= tobits), ret.push((acc >> bits) & maxv);
        }
        if (pad) bits > 0 && ret.push((acc << (tobits - bits)) & maxv);
        else if (bits >= frombits || (acc << (tobits - bits)) & maxv)
          return null;
        return ret;
      }
      function segwit_addr_decode(hrp, addr) {
        var bech32m = !1,
          dec = bech32.decode(addr, bech32.encodings.BECH32);
        if (
          (null === dec &&
            ((dec = bech32.decode(addr, bech32.encodings.BECH32M)),
            (bech32m = !0)),
          null === dec ||
            dec.hrp !== hrp ||
            dec.data.length < 1 ||
            dec.data[0] > 16)
        )
          return null;
        var res = convertbits(dec.data.slice(1), 5, 8, !1);
        return null === res ||
          res.length < 2 ||
          res.length > 40 ||
          (0 === dec.data[0] && 20 !== res.length && 32 !== res.length) ||
          (0 === dec.data[0] && bech32m)
          ? null
          : 0 === dec.data[0] || bech32m
          ? { version: dec.data[0], program: res }
          : null;
      }
      (bech32.encodings = { BECH32: "bech32", BECH32M: "bech32m" }),
        (bech32.encode = function (hrp, data, enc) {
          for (
            var combined = data.concat(
                (function (hrp, data, enc) {
                  for (
                    var mod =
                        polymod(
                          hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0])
                        ) ^ getEncodingConst(enc),
                      ret = [],
                      p = 0;
                    p < 6;
                    ++p
                  )
                    ret.push((mod >> (5 * (5 - p))) & 31);
                  return ret;
                })(hrp, data, enc)
              ),
              ret = hrp + "1",
              p = 0;
            p < combined.length;
            ++p
          )
            ret += CHARSET.charAt(combined[p]);
          return ret;
        }),
        (bech32.decode = function (bechString, enc) {
          var p,
            has_lower = !1,
            has_upper = !1;
          for (p = 0; p < bechString.length; ++p) {
            if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126)
              return null;
            bechString.charCodeAt(p) >= 97 &&
              bechString.charCodeAt(p) <= 122 &&
              (has_lower = !0),
              bechString.charCodeAt(p) >= 65 &&
                bechString.charCodeAt(p) <= 90 &&
                (has_upper = !0);
          }
          if (has_lower && has_upper) return null;
          var pos = (bechString = bechString.toLowerCase()).lastIndexOf("1");
          if (pos < 1 || pos + 7 > bechString.length || bechString.length > 90)
            return null;
          var hrp = bechString.substring(0, pos),
            data = [];
          for (p = pos + 1; p < bechString.length; ++p) {
            var d = CHARSET.indexOf(bechString.charAt(p));
            if (-1 === d) return null;
            data.push(d);
          }
          return (function (hrp, data, enc) {
            return (
              polymod(hrpExpand(hrp).concat(data)) === getEncodingConst(enc)
            );
          })(hrp, data, enc)
            ? { hrp: hrp, data: data.slice(0, data.length - 6) }
            : null;
        }),
        (segwit_addr.convertbits = convertbits),
        (segwit_addr.decode = segwit_addr_decode),
        (segwit_addr.encode = function (hrp, version, program) {
          var enc = bech32.encodings.BECH32;
          version > 0 && (enc = bech32.encodings.BECH32M);
          var ret = bech32.encode(
            hrp,
            [version].concat(convertbits(program, 8, 5, !0)),
            enc
          );
          return null === segwit_addr_decode(hrp, ret) ? null : ret;
        }),
        (segwit_addr.isTaprootAddress = function (address) {
          try {
            const taprootDecoded = segwit_addr.decode("bc", address);
            return null !== taprootDecoded && 1 === taprootDecoded.version;
          } catch (error) {
            return !1;
          }
        });
    })(),
    ((coinjs = GLOBAL.coinjs = function () {}).pub = 0),
    (coinjs.priv = 128),
    (coinjs.multisig = 5),
    (coinjs.hdkey = { prv: 76066276, pub: 76067358 }),
    (coinjs.bech32 = {
      charset: "qpzry9x8gf2tvdw0s3jn54khce6mua7l",
      version: 0,
      hrp: "bc",
    }),
    (coinjs.compressed = !0),
    (coinjs.developer = "33tht1bKDgZVxb39MnZsWa8oxHXHvUYE4G"),
    (coinjs.newKeys = function (input) {
      var privkey = input ? Crypto.SHA256(input) : this.newPrivkey(),
        pubkey = this.newPubkey(privkey);
      return {
        privkey: privkey,
        pubkey: pubkey,
        address: this.pubkey2address(pubkey),
        wif: this.privkey2wif(privkey),
        compressed: this.compressed,
      };
    }),
    (coinjs.newPrivkey = function () {
      var x = GLOBAL.location;
      (x +=
        GLOBAL.screen.height * GLOBAL.screen.width * GLOBAL.screen.colorDepth),
        (x += coinjs.random(64)),
        (x +=
          GLOBAL.screen.availHeight *
          GLOBAL.screen.availWidth *
          GLOBAL.screen.pixelDepth),
        (x += navigator.language),
        (x += GLOBAL.history.length),
        (x += coinjs.random(64)),
        (x += navigator.userAgent),
        (x += "coinb.in"),
        (x += Crypto.util.randomBytes(64).join("")),
        (x += x.length),
        (x += new Date().getTimezoneOffset()),
        (x += coinjs.random(64)),
        (x += document.getElementById("entropybucket")
          ? document.getElementById("entropybucket").innerHTML
          : "");
      var r = (x += x + "" + x);
      for (let i = 0; i < x.length / 25; i++) r = Crypto.SHA256(r.concat(x));
      for (
        var checkrBigInt = new BigInteger(r),
          orderBigInt = new BigInteger(
            "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
          );
        checkrBigInt.compareTo(orderBigInt) >= 0 ||
        checkrBigInt.equals(BigInteger.ZERO) ||
        checkrBigInt.equals(BigInteger.ONE);

      )
        (r = Crypto.SHA256(r.concat(x))), (checkrBigInt = new BigInteger(r));
      return r;
    }),
    (coinjs.newPubkey = function (hash) {
      var privateKeyBigInt = BigInteger.fromByteArrayUnsigned(
          Crypto.util.hexToBytes(hash)
        ),
        curvePt = EllipticCurve.getSECCurveByName("secp256k1")
          .getG()
          .multiply(privateKeyBigInt),
        x = curvePt.getX().toBigInteger(),
        y = curvePt.getY().toBigInteger(),
        publicKeyBytes = EllipticCurve.integerToBytes(x, 32);
      if (
        ((publicKeyBytes = publicKeyBytes.concat(
          EllipticCurve.integerToBytes(y, 32)
        )).unshift(4),
        1 == coinjs.compressed)
      ) {
        var publicKeyBytesCompressed = EllipticCurve.integerToBytes(x, 32);
        return (
          y.isEven()
            ? publicKeyBytesCompressed.unshift(2)
            : publicKeyBytesCompressed.unshift(3),
          Crypto.util.bytesToHex(publicKeyBytesCompressed)
        );
      }
      return Crypto.util.bytesToHex(publicKeyBytes);
    }),
    (coinjs.pubkey2address = function (h, byte) {
      var r = ripemd160(
        Crypto.SHA256(Crypto.util.hexToBytes(h), { asBytes: !0 })
      );
      r.unshift(byte || coinjs.pub);
      var checksum = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
        asBytes: !0,
      }).slice(0, 4);
      return coinjs.base58encode(r.concat(checksum));
    }),
    (coinjs.scripthash2address = function (h) {
      var x = Crypto.util.hexToBytes(h);
      x.unshift(coinjs.pub);
      var r = x,
        checksum = (r = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
          asBytes: !0,
        })).slice(0, 4);
      return coinjs.base58encode(x.concat(checksum));
    }),
    (coinjs.pubkeys2MultisigAddress = function (pubkeys, required) {
      var s = coinjs.script();
      s.writeOp(81 + 1 * required - 1);
      for (var i = 0; i < pubkeys.length; ++i)
        s.writeBytes(Crypto.util.hexToBytes(pubkeys[i]));
      s.writeOp(81 + pubkeys.length - 1), s.writeOp(174);
      var x = ripemd160(Crypto.SHA256(s.buffer, { asBytes: !0 }), {
        asBytes: !0,
      });
      x.unshift(coinjs.multisig);
      var r = x,
        checksum = (r = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
          asBytes: !0,
        })).slice(0, 4),
        redeemScript = Crypto.util.bytesToHex(s.buffer),
        address = coinjs.base58encode(x.concat(checksum));
      return (
        s.buffer.length > 520 &&
          ((address = "invalid"), (redeemScript = "invalid")),
        { address: address, redeemScript: redeemScript, size: s.buffer.length }
      );
    }),
    (coinjs.pubkeys2MultisigAddressBech32 = function (pubkeys, required) {
      var r = coinjs.pubkeys2MultisigAddress(pubkeys, required),
        program = Crypto.SHA256(Crypto.util.hexToBytes(r.redeemScript), {
          asBytes: !0,
        });
      return {
        address: coinjs.bech32_encode(
          coinjs.bech32.hrp,
          [coinjs.bech32.version].concat(
            coinjs.bech32_convert(program, 8, 5, !0)
          )
        ),
        redeemScript: r.redeemScript,
        scripthash: Crypto.util.bytesToHex(program),
        size: r.size,
      };
    }),
    (coinjs.simpleHodlAddress = function (pubkey, checklocktimeverify) {
      if (checklocktimeverify < 0)
        throw "Parameter for OP_CHECKLOCKTIMEVERIFY is negative.";
      var s = coinjs.script();
      checklocktimeverify <= 16 && checklocktimeverify >= 1
        ? s.writeOp(80 + checklocktimeverify)
        : s.writeBytes(coinjs.numToScriptNumBytes(checklocktimeverify)),
        s.writeOp(177),
        s.writeOp(117),
        s.writeBytes(Crypto.util.hexToBytes(pubkey)),
        s.writeOp(172);
      var x = ripemd160(Crypto.SHA256(s.buffer, { asBytes: !0 }), {
        asBytes: !0,
      });
      x.unshift(coinjs.multisig);
      var r = x,
        checksum = (r = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
          asBytes: !0,
        })).slice(0, 4),
        redeemScript = Crypto.util.bytesToHex(s.buffer);
      return {
        address: coinjs.base58encode(x.concat(checksum)),
        redeemScript: redeemScript,
      };
    }),
    (coinjs.segwitAddress = function (pubkey) {
      var keyhash = [0, 20].concat(
          ripemd160(
            Crypto.SHA256(Crypto.util.hexToBytes(pubkey), { asBytes: !0 }),
            { asBytes: !0 }
          )
        ),
        x = ripemd160(Crypto.SHA256(keyhash, { asBytes: !0 }), { asBytes: !0 });
      x.unshift(coinjs.multisig);
      var r = x,
        checksum = (r = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
          asBytes: !0,
        })).slice(0, 4);
      return {
        address: coinjs.base58encode(x.concat(checksum)),
        type: "segwit",
        redeemscript: Crypto.util.bytesToHex(keyhash),
      };
    }),
    (coinjs.bech32Address = function (pubkey) {
      var program = ripemd160(
        Crypto.SHA256(Crypto.util.hexToBytes(pubkey), { asBytes: !0 }),
        { asBytes: !0 }
      );
      return {
        address: coinjs.bech32_encode(
          coinjs.bech32.hrp,
          [coinjs.bech32.version].concat(
            coinjs.bech32_convert(program, 8, 5, !0)
          )
        ),
        type: "bech32",
        redeemscript: Crypto.util.bytesToHex(program),
      };
    }),
    (coinjs.multisigBech32Address = function (redeemscript) {
      var program = Crypto.SHA256(Crypto.util.hexToBytes(redeemscript), {
        asBytes: !0,
      });
      return {
        address: coinjs.bech32_encode(
          coinjs.bech32.hrp,
          [coinjs.bech32.version].concat(
            coinjs.bech32_convert(program, 8, 5, !0)
          )
        ),
        type: "multisigBech32",
        redeemScript: redeemscript,
        scripthash: Crypto.util.bytesToHex(program),
      };
    }),
    (coinjs.bech32redeemscript = function (address) {
      var decode = coinjs.bech32_decode(address);
      return (
        !!decode &&
        (decode.data.shift(),
        Crypto.util.bytesToHex(coinjs.bech32_convert(decode.data, 5, 8, !1)))
      );
    }),
    (coinjs.privkey2wif = function (h) {
      var r = Crypto.util.hexToBytes(h);
      1 == coinjs.compressed && r.push(1), r.unshift(coinjs.priv);
      var checksum = Crypto.SHA256(Crypto.SHA256(r, { asBytes: !0 }), {
        asBytes: !0,
      }).slice(0, 4);
      return coinjs.base58encode(r.concat(checksum));
    }),
    (coinjs.wif2privkey = function (wif) {
      var compressed = !1,
        decode = coinjs.base58decode(wif),
        key = decode.slice(0, decode.length - 4);
      return (
        (key = key.slice(1, key.length)).length >= 33 &&
          1 == key[key.length - 1] &&
          ((key = key.slice(0, key.length - 1)), (compressed = !0)),
        { privkey: Crypto.util.bytesToHex(key), compressed: compressed }
      );
    }),
    (coinjs.wif2pubkey = function (wif) {
      var compressed = coinjs.compressed,
        r = coinjs.wif2privkey(wif);
      coinjs.compressed = r.compressed;
      var pubkey = coinjs.newPubkey(r.privkey);
      return (
        (coinjs.compressed = compressed),
        { pubkey: pubkey, compressed: r.compressed }
      );
    }),
    (coinjs.wif2address = function (wif) {
      var r = coinjs.wif2pubkey(wif);
      return {
        address: coinjs.pubkey2address(r.pubkey),
        compressed: r.compressed,
      };
    }),
    (coinjs.addressDecode = function (addr) {
      try {
        if (segwit_addr.isTaprootAddress(addr)) {
          var data = segwit_addr.decode("bc", addr);
          return (
            (data.type = "bech32m"),
            (data.outstring = "5120" + Crypto.util.bytesToHex(data.program)),
            data
          );
        }
        var bytes = coinjs.base58decode(addr),
          front = bytes.slice(0, bytes.length - 4),
          back = bytes.slice(bytes.length - 4);
        if (
          Crypto.SHA256(Crypto.SHA256(front, { asBytes: !0 }), {
            asBytes: !0,
          }).slice(0, 4) +
            "" ==
          back + ""
        ) {
          var o = {};
          if (
            ((o.bytes = front.slice(1)),
            (o.version = front[0]),
            o.version == coinjs.pub)
          )
            o.type = "standard";
          else if (o.version == coinjs.multisig) o.type = "multisig";
          else if (o.version == coinjs.multisigBech32)
            o.type = "multisigBech32";
          else if (o.version == coinjs.priv) o.type = "wifkey";
          else if (42 == o.version) {
            if (((o.type = "stealth"), (o.option = front[1]), 0 != o.option))
              return (
                alert(
                  "Stealth Address option other than 0 is currently not supported!"
                ),
                !1
              );
            if (
              ((o.scankey = Crypto.util.bytesToHex(front.slice(2, 35))),
              (o.n = front[35]),
              o.n > 1)
            )
              return alert("Stealth Multisig is currently not supported!"), !1;
            if (
              ((o.spendkey = Crypto.util.bytesToHex(front.slice(36, 69))),
              (o.m = front[69]),
              (o.prefixlen = front[70]),
              o.prefixlen > 0)
            )
              return (
                alert("Stealth Address Prefixes are currently not supported!"),
                !1
              );
            o.prefix = front.slice(71);
          } else o.type = "other";
          return o;
        }
        throw "Invalid checksum";
      } catch (e) {
        let bech32rs = coinjs.bech32redeemscript(addr);
        return bech32rs && 40 == bech32rs.length
          ? { type: "bech32", redeemscript: bech32rs }
          : !(!bech32rs || 64 != bech32rs.length) && {
              type: "multisigBech32",
              redeemscript: bech32rs,
            };
      }
    }),
    (coinjs.addressBalance = function (address, callback) {
      coinjs.ajax(
        coinjs.host +
          "?uid=" +
          coinjs.uid +
          "&key=" +
          coinjs.key +
          "&setmodule=addresses&request=bal&address=" +
          address +
          "&r=" +
          Math.random(),
        callback,
        "GET"
      );
    }),
    (coinjs.pubkeydecompress = function (pubkey) {
      if ("string" == typeof pubkey && pubkey.match(/^[a-f0-9]+$/i)) {
        var curve = EllipticCurve.getSECCurveByName("secp256k1");
        try {
          var pt = curve.curve.decodePointHex(pubkey),
            x = pt.getX().toBigInteger(),
            y = pt.getY().toBigInteger(),
            publicKeyBytes = EllipticCurve.integerToBytes(x, 32);
          return (
            (publicKeyBytes = publicKeyBytes.concat(
              EllipticCurve.integerToBytes(y, 32)
            )).unshift(4),
            Crypto.util.bytesToHex(publicKeyBytes)
          );
        } catch (e) {
          return !1;
        }
      }
      return !1;
    }),
    (coinjs.bech32_polymod = function (values) {
      for (
        var chk = 1,
          BECH32_GENERATOR = [
            996825010, 642813549, 513874426, 1027748829, 705979059,
          ],
          p = 0;
        p < values.length;
        ++p
      ) {
        var top = chk >> 25;
        chk = ((33554431 & chk) << 5) ^ values[p];
        for (var i = 0; i < 5; ++i)
          (top >> i) & 1 && (chk ^= BECH32_GENERATOR[i]);
      }
      return chk;
    }),
    (coinjs.bech32_hrpExpand = function (hrp) {
      var p,
        ret = [];
      for (p = 0; p < hrp.length; ++p) ret.push(hrp.charCodeAt(p) >> 5);
      for (ret.push(0), p = 0; p < hrp.length; ++p)
        ret.push(31 & hrp.charCodeAt(p));
      return ret;
    }),
    (coinjs.bech32_verifyChecksum = function (hrp, data) {
      return (
        1 === coinjs.bech32_polymod(coinjs.bech32_hrpExpand(hrp).concat(data))
      );
    }),
    (coinjs.bech32_createChecksum = function (hrp, data) {
      for (
        var values = coinjs
            .bech32_hrpExpand(hrp)
            .concat(data)
            .concat([0, 0, 0, 0, 0, 0]),
          mod = 1 ^ coinjs.bech32_polymod(values),
          ret = [],
          p = 0;
        p < 6;
        ++p
      )
        ret.push((mod >> (5 * (5 - p))) & 31);
      return ret;
    }),
    (coinjs.bech32_encode = function (hrp, data) {
      for (
        var combined = data.concat(coinjs.bech32_createChecksum(hrp, data)),
          ret = hrp + "1",
          p = 0;
        p < combined.length;
        ++p
      )
        ret += coinjs.bech32.charset.charAt(combined[p]);
      return ret;
    }),
    (coinjs.bech32_decode = function (bechString) {
      var p,
        has_lower = !1,
        has_upper = !1;
      for (p = 0; p < bechString.length; ++p) {
        if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126)
          return null;
        bechString.charCodeAt(p) >= 97 &&
          bechString.charCodeAt(p) <= 122 &&
          (has_lower = !0),
          bechString.charCodeAt(p) >= 65 &&
            bechString.charCodeAt(p) <= 90 &&
            (has_upper = !0);
      }
      if (has_lower && has_upper) return null;
      var pos = (bechString = bechString.toLowerCase()).lastIndexOf("1");
      if (pos < 1 || pos + 7 > bechString.length || bechString.length > 90)
        return null;
      var hrp = bechString.substring(0, pos),
        data = [];
      for (p = pos + 1; p < bechString.length; ++p) {
        var d = coinjs.bech32.charset.indexOf(bechString.charAt(p));
        if (-1 === d) return null;
        data.push(d);
      }
      return coinjs.bech32_verifyChecksum(hrp, data)
        ? { hrp: hrp, data: data.slice(0, data.length - 6) }
        : null;
    }),
    (coinjs.bech32_convert = function (data, inBits, outBits, pad) {
      for (
        var value = 0, bits = 0, maxV = (1 << outBits) - 1, result = [], i = 0;
        i < data.length;
        ++i
      )
        for (
          value = (value << inBits) | data[i], bits += inBits;
          bits >= outBits;

        )
          (bits -= outBits), result.push((value >> bits) & maxV);
      if (pad) bits > 0 && result.push((value << (outBits - bits)) & maxV);
      else {
        if (bits >= inBits) throw new Error("Excess padding");
        if ((value << (outBits - bits)) & maxV)
          throw new Error("Non-zero padding");
      }
      return result;
    }),
    (coinjs.testdeterministicK = function () {
      var tx = coinjs.transaction(),
        test_vectors = [
          {
            message: "test data",
            privkey:
              "fee0a1f7afebf9d2a5a80c0c98a31c709681cce195cbcd06342b517970c0be1e",
            k_bad00:
              "fcce1de7a9bcd6b2d3defade6afa1913fb9229e3b7ddf4749b55c4848b2a196e",
            k_bad01:
              "727fbcb59eb48b1d7d46f95a04991fc512eb9dbf9105628e3aec87428df28fd8",
            k_bad15:
              "398f0e2c9f79728f7b3d84d447ac3a86d8b2083c8f234a0ffa9c4043d68bd258",
          },
          {
            message:
              "Everything should be made as simple as possible, but not simpler.",
            privkey:
              "0000000000000000000000000000000000000000000000000000000000000001",
            k_bad00:
              "ec633bd56a5774a0940cb97e27a9e4e51dc94af737596a0c5cbb3d30332d92a5",
            k_bad01:
              "df55b6d1b5c48184622b0ead41a0e02bfa5ac3ebdb4c34701454e80aabf36f56",
            k_bad15:
              "def007a9a3c2f7c769c75da9d47f2af84075af95cadd1407393dc1e26086ef87",
          },
          {
            message: "Satoshi Nakamoto",
            privkey:
              "0000000000000000000000000000000000000000000000000000000000000002",
            k_bad00:
              "d3edc1b8224e953f6ee05c8bbf7ae228f461030e47caf97cde91430b4607405e",
            k_bad01:
              "f86d8e43c09a6a83953f0ab6d0af59fb7446b4660119902e9967067596b58374",
            k_bad15:
              "241d1f57d6cfd2f73b1ada7907b199951f95ef5ad362b13aed84009656e0254a",
          },
          {
            message: "Diffie Hellman",
            privkey:
              "7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
            k_bad00:
              "c378a41cb17dce12340788dd3503635f54f894c306d52f6e9bc4b8f18d27afcc",
            k_bad01:
              "90756c96fef41152ac9abe08819c4e95f16da2af472880192c69a2b7bac29114",
            k_bad15:
              "7b3f53300ab0ccd0f698f4d67db87c44cf3e9e513d9df61137256652b2e94e7c",
          },
          {
            message: "Japan",
            privkey:
              "8080808080808080808080808080808080808080808080808080808080808080",
            k_bad00:
              "f471e61b51d2d8db78f3dae19d973616f57cdc54caaa81c269394b8c34edcf59",
            k_bad01:
              "6819d85b9730acc876fdf59e162bf309e9f63dd35550edf20869d23c2f3e6d17",
            k_bad15:
              "d8e8bae3ee330a198d1f5e00ad7c5f9ed7c24c357c0a004322abca5d9cd17847",
          },
          {
            message: "Bitcoin",
            privkey:
              "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
            k_bad00:
              "36c848ffb2cbecc5422c33a994955b807665317c1ce2a0f59c689321aaa631cc",
            k_bad01:
              "4ed8de1ec952a4f5b3bd79d1ff96446bcd45cabb00fc6ca127183e14671bcb85",
            k_bad15:
              "56b6f47babc1662c011d3b1f93aa51a6e9b5f6512e9f2e16821a238d450a31f8",
          },
          {
            message: "i2FLPP8WEus5WPjpoHwheXOMSobUJVaZM1JPMQZq",
            privkey:
              "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
            k_bad00:
              "6e9b434fcc6bbb081a0463c094356b47d62d7efae7da9c518ed7bac23f4e2ed6",
            k_bad01:
              "ae5323ae338d6117ce8520a43b92eacd2ea1312ae514d53d8e34010154c593bb",
            k_bad15:
              "3eaa1b61d1b8ab2f1ca71219c399f2b8b3defa624719f1e96fe3957628c2c4ea",
          },
          {
            message: "lEE55EJNP7aLrMtjkeJKKux4Yg0E8E1SAJnWTCEh",
            privkey:
              "3881e5286abc580bb6139fe8e83d7c8271c6fe5e5c2d640c1f0ed0e1ee37edc9",
            k_bad00:
              "5b606665a16da29cc1c5411d744ab554640479dd8abd3c04ff23bd6b302e7034",
            k_bad01:
              "f8b25263152c042807c992eacd2ac2cc5790d1e9957c394f77ea368e3d9923bd",
            k_bad15:
              "ea624578f7e7964ac1d84adb5b5087dd14f0ee78b49072aa19051cc15dab6f33",
          },
          {
            message: "2SaVPvhxkAPrayIVKcsoQO5DKA8Uv5X/esZFlf+y",
            privkey:
              "7259dff07922de7f9c4c5720d68c9745e230b32508c497dd24cb95ef18856631",
            k_bad00:
              "3ab6c19ab5d3aea6aa0c6da37516b1d6e28e3985019b3adb388714e8f536686b",
            k_bad01:
              "19af21b05004b0ce9cdca82458a371a9d2cf0dc35a813108c557b551c08eb52e",
            k_bad15:
              "117a32665fca1b7137a91c4739ac5719fec0cf2e146f40f8e7c21b45a07ebc6a",
          },
          {
            message: "00A0OwO2THi7j5Z/jp0FmN6nn7N/DQd6eBnCS+/b",
            privkey:
              "0d6ea45d62b334777d6995052965c795a4f8506044b4fd7dc59c15656a28f7aa",
            k_bad00:
              "79487de0c8799158294d94c0eb92ee4b567e4dc7ca18addc86e49d31ce1d2db6",
            k_bad01:
              "9561d2401164a48a8f600882753b3105ebdd35e2358f4f808c4f549c91490009",
            k_bad15:
              "b0d273634129ff4dbdf0df317d4062a1dbc58818f88878ffdb4ec511c77976c0",
          },
        ],
        result_txt =
          "\n----------------------\nResults\n----------------------\n\n";
      for (i = 0; i < test_vectors.length; i++) {
        var hash = Crypto.SHA256(
            test_vectors[i].message.split("").map(function (c) {
              return c.charCodeAt(0);
            }),
            { asBytes: !0 }
          ),
          wif = coinjs.privkey2wif(test_vectors[i].privkey),
          KBigInt = tx.deterministicK(wif, hash),
          KBigInt0 = tx.deterministicK(wif, hash, 0),
          KBigInt1 = tx.deterministicK(wif, hash, 1),
          KBigInt15 = tx.deterministicK(wif, hash, 15),
          K = Crypto.util.bytesToHex(KBigInt.toByteArrayUnsigned()),
          K0 = Crypto.util.bytesToHex(KBigInt0.toByteArrayUnsigned()),
          K1 = Crypto.util.bytesToHex(KBigInt1.toByteArrayUnsigned()),
          K15 = Crypto.util.bytesToHex(KBigInt15.toByteArrayUnsigned());
        K != test_vectors[i].k_bad00
          ? (result_txt +=
              "Failed Test #" +
              (i + 1) +
              "\n       K = " +
              K +
              "\nExpected = " +
              test_vectors[i].k_bad00 +
              "\n\n")
          : K0 != test_vectors[i].k_bad00
          ? (result_txt +=
              "Failed Test #" +
              (i + 1) +
              "\n      K0 = " +
              K0 +
              "\nExpected = " +
              test_vectors[i].k_bad00 +
              "\n\n")
          : K1 != test_vectors[i].k_bad01
          ? (result_txt +=
              "Failed Test #" +
              (i + 1) +
              "\n      K1 = " +
              K1 +
              "\nExpected = " +
              test_vectors[i].k_bad01 +
              "\n\n")
          : K15 != test_vectors[i].k_bad15 &&
            (result_txt +=
              "Failed Test #" +
              (i + 1) +
              "\n     K15 = " +
              K15 +
              "\nExpected = " +
              test_vectors[i].k_bad15 +
              "\n\n");
      }
      return (
        result_txt.length < 60 && (result_txt = "All Tests OK!"), result_txt
      );
    }),
    (coinjs.hd = function (data) {
      var r = {
        parse: function () {
          var bytes = [];
          if ("string" == typeof data) {
            var decoded = coinjs.base58decode(data);
            if (82 == decoded.length) {
              var checksum = decoded.slice(78, 82),
                hash = Crypto.SHA256(
                  Crypto.SHA256(decoded.slice(0, 78), { asBytes: !0 }),
                  { asBytes: !0 }
                );
              checksum[0] == hash[0] &&
                checksum[1] == hash[1] &&
                checksum[2] == hash[2] &&
                checksum[3] == hash[3] &&
                (bytes = decoded.slice(0, 78));
            }
          }
          if (bytes && bytes.length > 0) {
            (r.version = coinjs.uint(bytes.slice(0, 4), 4)),
              (r.depth = coinjs.uint(bytes.slice(4, 5), 1)),
              (r.parent_fingerprint = bytes.slice(5, 9)),
              (r.child_index = coinjs.uint(bytes.slice(9, 13), 4)),
              (r.chain_code = bytes.slice(13, 45)),
              (r.key_bytes = bytes.slice(45, 78));
            var c = coinjs.compressed;
            if (((coinjs.compressed = !0), 0 == r.key_bytes[0])) {
              r.type = "private";
              var privkey = r.key_bytes.slice(1, 33),
                privkeyHex = Crypto.util.bytesToHex(privkey),
                pubkey = coinjs.newPubkey(privkeyHex);
              r.keys = {
                privkey: privkeyHex,
                pubkey: pubkey,
                address: coinjs.pubkey2address(pubkey),
                wif: coinjs.privkey2wif(privkeyHex),
              };
            } else if (2 == r.key_bytes[0] || 3 == r.key_bytes[0]) {
              r.type = "public";
              var pubkeyHex = Crypto.util.bytesToHex(r.key_bytes);
              r.keys = {
                pubkey: pubkeyHex,
                address: coinjs.pubkey2address(pubkeyHex),
              };
            } else r.type = "invalid";
            (r.keys_extended = r.extend()), (coinjs.compressed = c);
          }
          return r;
        },
        extend: function () {
          return coinjs
            .hd()
            .make({
              depth: 1 * this.depth + 1,
              parent_fingerprint: this.parent_fingerprint,
              child_index: this.child_index,
              chain_code: this.chain_code,
              privkey: this.keys.privkey,
              pubkey: this.keys.pubkey,
            });
        },
        derive_path: function (path) {
          if ("m" == path || "M" == path || "m'" == path || "M'" == path)
            return this;
          var p = path.split("/"),
            hdp = coinjs.clone(this);
          for (var i in p)
            if ((0 != i || "m" == c) && "remove" != i) {
              var c = p[i],
                use_private = c.length > 1 && "'" == c[c.length - 1],
                child_index =
                  2147483647 &
                  parseInt(use_private ? c.slice(0, c.length - 1) : c);
              use_private && (child_index += 2147483648);
              var key =
                (hdp = hdp.derive(child_index)).keys_extended.privkey &&
                "" != hdp.keys_extended.privkey
                  ? hdp.keys_extended.privkey
                  : hdp.keys_extended.pubkey;
              hdp = coinjs.hd(key);
            }
          return hdp;
        },
        derive: function (i) {
          i = i || 0;
          var k,
            key,
            pubkey,
            o,
            blob = Crypto.util
              .hexToBytes(this.keys.pubkey)
              .concat(coinjs.numToBytes(i, 4).reverse()),
            hash = new jsSHA(Crypto.util.bytesToHex(blob), "HEX").getHMAC(
              Crypto.util.bytesToHex(r.chain_code),
              "HEX",
              "SHA-512",
              "HEX"
            ),
            il = new BigInteger(hash.slice(0, 64), 16),
            ir = Crypto.util.hexToBytes(hash.slice(64, 128)),
            ecparams = EllipticCurve.getSECCurveByName("secp256k1");
          if (
            (ecparams.getCurve(),
            ((o = coinjs.clone(this)).chain_code = ir),
            (o.child_index = i),
            "private" == this.type)
          )
            (k = il
              .add(
                new BigInteger(
                  [0].concat(Crypto.util.hexToBytes(this.keys.privkey))
                )
              )
              .mod(ecparams.getN())),
              (key = Crypto.util.bytesToHex(k.toByteArrayUnsigned())),
              (pubkey = coinjs.newPubkey(key)),
              (o.keys = {
                privkey: key,
                pubkey: pubkey,
                wif: coinjs.privkey2wif(key),
                address: coinjs.pubkey2address(pubkey),
              });
          else if ("public" == this.type) {
            q = ecparams.curve.decodePointHex(this.keys.pubkey);
            var curvePt = ecparams.getG().multiply(il).add(q),
              x = curvePt.getX().toBigInteger(),
              y = curvePt.getY().toBigInteger(),
              publicKeyBytesCompressed = EllipticCurve.integerToBytes(x, 32);
            y.isEven()
              ? publicKeyBytesCompressed.unshift(2)
              : publicKeyBytesCompressed.unshift(3),
              (pubkey = Crypto.util.bytesToHex(publicKeyBytesCompressed)),
              (o.keys = {
                pubkey: pubkey,
                address: coinjs.pubkey2address(pubkey),
              });
          }
          return (
            (o.parent_fingerprint = ripemd160(
              Crypto.SHA256(Crypto.util.hexToBytes(r.keys.pubkey), {
                asBytes: !0,
              }),
              { asBytes: !0 }
            ).slice(0, 4)),
            (o.keys_extended = o.extend()),
            o
          );
        },
        master: function (pass) {
          var seed = pass ? Crypto.SHA256(pass) : coinjs.newPrivkey(),
            I = new jsSHA(seed, "HEX").getHMAC(
              "Bitcoin seed",
              "TEXT",
              "SHA-512",
              "HEX"
            ),
            chain =
              (Crypto.util.hexToBytes(I.slice(0, 64)),
              Crypto.util.hexToBytes(I.slice(64, 128)));
          return coinjs
            .hd()
            .make({
              depth: 0,
              parent_fingerprint: [0, 0, 0, 0],
              child_index: 0,
              chain_code: chain,
              privkey: I.slice(0, 64),
              pubkey: coinjs.newPubkey(I.slice(0, 64)),
            });
        },
        make: function (data) {
          var k = [];
          k.push(1 * data.depth),
            (k = (k = (k = k.concat(data.parent_fingerprint)).concat(
              coinjs.numToBytes(data.child_index, 4).reverse()
            )).concat(data.chain_code));
          var o = {};
          if (data.privkey) {
            var prv = coinjs.numToBytes(coinjs.hdkey.prv, 4).reverse();
            (prv = prv.concat(k)).push(0),
              (prv = prv.concat(Crypto.util.hexToBytes(data.privkey)));
            var checksum = Crypto.SHA256(Crypto.SHA256(prv, { asBytes: !0 }), {
                asBytes: !0,
              }).slice(0, 4),
              ret = prv.concat(checksum);
            o.privkey = coinjs.base58encode(ret);
          }
          if (data.pubkey) {
            var pub = coinjs.numToBytes(coinjs.hdkey.pub, 4).reverse();
            (pub = (pub = pub.concat(k)).concat(
              Crypto.util.hexToBytes(data.pubkey)
            )),
              (checksum = Crypto.SHA256(Crypto.SHA256(pub, { asBytes: !0 }), {
                asBytes: !0,
              }).slice(0, 4)),
              (ret = pub.concat(checksum)),
              (o.pubkey = coinjs.base58encode(ret));
          }
          return o;
        },
      };
      return r.parse();
    }),
    (coinjs.script = function (data) {
      var r = {};
      return (
        data
          ? "string" == typeof data
            ? (r.buffer = Crypto.util.hexToBytes(data))
            : coinjs.isArray(data)
            ? (r.buffer = data)
            : data instanceof coinjs.script
            ? (r.buffer = data.buffer)
            : (r.buffer = data)
          : (r.buffer = []),
        (r.parse = function () {
          var self = this;
          r.chunks = [];
          var i = 0;
          function readChunk(n) {
            self.chunks.push(self.buffer.slice(i, i + n)), (i += n);
          }
          for (; i < this.buffer.length; ) {
            var opcode = this.buffer[i++];
            if (
              (opcode >= 240 && (opcode = (opcode << 8) | this.buffer[i++]),
              opcode > 0 && opcode < 76
                ? readChunk(opcode)
                : 76 == opcode
                ? readChunk(this.buffer[i++])
                : 77 == opcode
                ? readChunk((this.buffer[i++] << 8) | this.buffer[i++])
                : 78 == opcode
                ? readChunk(
                    (this.buffer[i++] << 24) |
                      (this.buffer[i++] << 16) |
                      (this.buffer[i++] << 8) |
                      this.buffer[i++]
                  )
                : this.chunks.push(opcode),
              i < 0)
            )
              break;
          }
          return !0;
        }),
        (r.decodeRedeemScript = function (script) {
          var r = !1;
          try {
            var s = coinjs.script(Crypto.util.hexToBytes(script));
            if (s.chunks.length >= 3 && 174 == s.chunks[s.chunks.length - 1]) {
              (r = {}).signaturesRequired = s.chunks[0] - 80;
              for (var pubkeys = [], i = 1; i < s.chunks.length - 2; i++)
                pubkeys.push(Crypto.util.bytesToHex(s.chunks[i]));
              r.pubkeys = pubkeys;
              var multi = coinjs.pubkeys2MultisigAddress(
                pubkeys,
                r.signaturesRequired
              );
              (r.address = multi.address), (r.type = "multisig__");
              var rs = Crypto.util.bytesToHex(s.buffer);
              r.redeemscript = rs;
            } else
              2 == s.chunks.length && 0 == s.buffer[0] && 20 == s.buffer[1]
                ? (((r = {}).type = "segwit__"),
                  (rs = Crypto.util.bytesToHex(s.buffer)),
                  (r.address = coinjs.pubkey2address(rs, coinjs.multisig)),
                  (r.redeemscript = rs))
                : 5 == s.chunks.length &&
                  177 == s.chunks[1] &&
                  117 == s.chunks[2] &&
                  172 == s.chunks[4] &&
                  (((r = {}).pubkey = Crypto.util.bytesToHex(s.chunks[3])),
                  (r.checklocktimeverify = coinjs.bytesToNum(
                    s.chunks[0].slice()
                  )),
                  (r.address = coinjs.simpleHodlAddress(
                    r.pubkey,
                    r.checklocktimeverify
                  ).address),
                  (rs = Crypto.util.bytesToHex(s.buffer)),
                  (r.redeemscript = rs),
                  (r.type = "hodl__"));
          } catch (e) {
            r = !1;
          }
          return r;
        }),
        (r.decodeRedeemScriptBech32 = function (script) {
          var r = !1;
          try {
            var s = coinjs.script(Crypto.util.hexToBytes(script));
            if (s.chunks.length >= 3 && 174 == s.chunks[s.chunks.length - 1]) {
              (r = {}).signaturesRequired = s.chunks[0] - 80;
              for (var pubkeys = [], i = 1; i < s.chunks.length - 2; i++)
                pubkeys.push(Crypto.util.bytesToHex(s.chunks[i]));
              r.pubkeys = pubkeys;
              var multi = coinjs.pubkeys2MultisigAddressBech32(
                pubkeys,
                r.signaturesRequired
              );
              (r.address = multi.address), (r.type = "multisig__");
              var rs = Crypto.util.bytesToHex(s.buffer);
              r.redeemscript = rs;
            }
          } catch (e) {
            r = !1;
          }
          return r;
        }),
        (r.spendToScript = function (address) {
          var addr = coinjs.addressDecode(address),
            s = coinjs.script();
          return "bech32m" == addr.type
            ? (s.writeBytes(Crypto.util.hexToBytes(addr.outstring)), s)
            : ("bech32" == addr.type || "multisigBech32" == addr.type
                ? (s.writeOp(0),
                  s.writeBytes(Crypto.util.hexToBytes(addr.redeemscript)))
                : addr.version == coinjs.multisig
                ? (s.writeOp(169), s.writeBytes(addr.bytes), s.writeOp(135))
                : (s.writeOp(118),
                  s.writeOp(169),
                  s.writeBytes(addr.bytes),
                  s.writeOp(136),
                  s.writeOp(172)),
              s);
        }),
        (r.pubkeyHash = function (address) {
          var addr = coinjs.addressDecode(address),
            s = coinjs.script();
          return (
            s.writeOp(118),
            s.writeOp(169),
            s.writeBytes(addr.bytes),
            s.writeOp(136),
            s.writeOp(172),
            s
          );
        }),
        (r.writeOp = function (op) {
          return this.buffer.push(op), this.chunks.push(op), !0;
        }),
        (r.writeBytes = function (data) {
          return (
            data.length < 76
              ? this.buffer.push(data.length)
              : data.length <= 255
              ? (this.buffer.push(76), this.buffer.push(data.length))
              : data.length <= 65535
              ? (this.buffer.push(77),
                this.buffer.push(255 & data.length),
                this.buffer.push((data.length >>> 8) & 255))
              : (this.buffer.push(78),
                this.buffer.push(255 & data.length),
                this.buffer.push((data.length >>> 8) & 255),
                this.buffer.push((data.length >>> 16) & 255),
                this.buffer.push((data.length >>> 24) & 255)),
            (this.buffer = this.buffer.concat(data)),
            this.chunks.push(data),
            !0
          );
        }),
        r.parse(),
        r
      );
    }),
    (coinjs.transaction = function () {
      var r = {
        version: 1,
        lock_time: 0,
        ins: [],
        outs: [],
        witness: !1,
        timestamp: null,
        block: null,
        addinput: function (txid, index, script, sequence) {
          var o = {};
          return (
            (o.outpoint = { hash: txid, index: index }),
            (o.script = coinjs.script(script || [])),
            (o.sequence = sequence || (0 == r.lock_time ? 4294967295 : 0)),
            this.ins.push(o)
          );
        },
        addoutput: function (address, value) {
          var o = {};
          o.value = new BigInteger("" + Math.round(1 * value * 1e8), 10);
          var s = coinjs.script();
          return (o.script = s.spendToScript(address)), this.outs.push(o);
        },
        addstealth: function (stealth, value) {
          var ephemeralKeyBigInt = BigInteger.fromByteArrayUnsigned(
              Crypto.util.hexToBytes(coinjs.newPrivkey())
            ),
            curve = EllipticCurve.getSECCurveByName("secp256k1"),
            p = EllipticCurve.fromHex(
              "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F"
            ),
            a = BigInteger.ZERO,
            b = EllipticCurve.fromHex("7"),
            calccurve = new EllipticCurve.CurveFp(p, a, b),
            ephemeralPt = curve.getG().multiply(ephemeralKeyBigInt),
            sharedPt = calccurve
              .decodePointHex(stealth.scankey)
              .multiply(ephemeralKeyBigInt),
            stealthindexKeyBigInt = BigInteger.fromByteArrayUnsigned(
              Crypto.SHA256(sharedPt.getEncoded(!0), { asBytes: !0 })
            ),
            stealthindexPt = curve.getG().multiply(stealthindexKeyBigInt),
            addressPt = calccurve
              .decodePointHex(stealth.spendkey)
              .add(stealthindexPt),
            sendaddress = coinjs.pubkey2address(
              Crypto.util.bytesToHex(addressPt.getEncoded(!0))
            ),
            OPRETBytes = [6]
              .concat(Crypto.util.randomBytes(4))
              .concat(ephemeralPt.getEncoded(!0)),
            q = coinjs.script();
          q.writeOp(106),
            q.writeBytes(OPRETBytes),
            (v = {}),
            (v.value = 0),
            (v.script = q),
            this.outs.push(v);
          var o = {};
          o.value = new BigInteger("" + Math.round(1 * value * 1e8), 10);
          var s = coinjs.script();
          return (o.script = s.spendToScript(sendaddress)), this.outs.push(o);
        },
        adddata: function (data) {
          if (
            data.match(/^[a-f0-9]+$/gi) &&
            data.length < 160 &&
            data.length % 2 == 0
          ) {
            var s = coinjs.script();
            return (
              s.writeOp(106),
              s.writeBytes(Crypto.util.hexToBytes(data)),
              (o = {}),
              (o.value = 0),
              (o.script = s),
              this.outs.push(o)
            );
          }
          return !1;
        },
        listUnspent: function (address, callback) {
          coinjs.ajax(
            coinjs.host +
              "?uid=" +
              coinjs.uid +
              "&key=" +
              coinjs.key +
              "&setmodule=addresses&request=unspent&address=" +
              address +
              "&r=" +
              Math.random(),
            callback,
            "GET"
          );
        },
        getTransaction: function (txid, callback) {
          coinjs.ajax(
            coinjs.host +
              "?uid=" +
              coinjs.uid +
              "&key=" +
              coinjs.key +
              "&setmodule=bitcoin&request=gettransaction&txid=" +
              txid +
              "&r=" +
              Math.random(),
            callback,
            "GET"
          );
        },
        addUnspent: function (address, callback, script, segwit, sequence) {
          var self = this;
          this.listUnspent(address, function (data) {
            var s = coinjs.script(),
              value = 0,
              total = 0,
              x = {};
            GLOBAL.DOMParser
              ? ((parser = new DOMParser()),
                (xmlDoc = parser.parseFromString(data, "text/xml")))
              : ((xmlDoc = new ActiveXObject("Microsoft.XMLDOM")),
                (xmlDoc.async = !1),
                xmlDoc.loadXML(data));
            var unspent = xmlDoc.getElementsByTagName("unspent")[0];
            if (unspent)
              for (i = 1; i <= unspent.childElementCount; i++) {
                var u = xmlDoc.getElementsByTagName("unspent_" + i)[0],
                  txhash =
                    u
                      .getElementsByTagName("tx_hash")[0]
                      .childNodes[0].nodeValue.match(/.{1,2}/g)
                      .reverse()
                      .join("") + "",
                  n =
                    u.getElementsByTagName("tx_output_n")[0].childNodes[0]
                      .nodeValue,
                  scr =
                    script ||
                    u.getElementsByTagName("script")[0].childNodes[0].nodeValue;
                segwit &&
                  ((s = coinjs.script()).writeBytes(
                    Crypto.util.hexToBytes(script)
                  ),
                  s.writeOp(0),
                  s.writeBytes(
                    coinjs.numToBytes(
                      1 *
                        u.getElementsByTagName("value")[0].childNodes[0]
                          .nodeValue,
                      8
                    )
                  ),
                  (scr = Crypto.util.bytesToHex(s.buffer)));
                var seq = sequence || !1;
                self.addinput(txhash, n, scr, seq),
                  (value +=
                    1 *
                    u.getElementsByTagName("value")[0].childNodes[0].nodeValue),
                  total++;
              }
            return (
              (x.result =
                xmlDoc.getElementsByTagName(
                  "result"
                )[0].childNodes[0].nodeValue),
              (x.unspent = unspent),
              (x.value = value),
              (x.total = total),
              (x.response =
                xmlDoc.getElementsByTagName(
                  "response"
                )[0].childNodes[0].nodeValue),
              callback(x)
            );
          });
        },
        addUnspentAndSign: function (wif, callback) {
          var self = this,
            address = coinjs.wif2address(wif);
          self.addUnspent(address.address, function (data) {
            return self.sign(wif), callback(data);
          });
        },
        broadcast: function (callback, txhex) {
          var tx = txhex || this.serialize();
          coinjs.ajax(
            coinjs.host +
              "?uid=" +
              coinjs.uid +
              "&key=" +
              coinjs.key +
              "&setmodule=bitcoin&request=sendrawtransaction",
            callback,
            "POST",
            ["rawtx=" + tx]
          );
        },
        transactionHash: function (index, sigHashType) {
          for (
            var clone = coinjs.clone(this), shType = sigHashType || 1, i = 0;
            i < clone.ins.length;
            i++
          )
            index != i && (clone.ins[i].script = coinjs.script());
          var extract = this.extractScriptKey(index);
          if (
            ((clone.ins[index].script = coinjs.script(extract.script)),
            clone.ins && clone.ins[index])
          ) {
            if (1 == shType);
            else if (2 == shType)
              for (clone.outs = [], i = 0; i < clone.ins.length; i++)
                index != i && (clone.ins[i].sequence = 0);
            else if (3 == shType) {
              for (clone.outs.length = index + 1, i = 0; i < index; i++)
                (clone.outs[i].value = -1), (clone.outs[i].script.buffer = []);
              for (i = 0; i < clone.ins.length; i++)
                index != i && (clone.ins[i].sequence = 0);
            } else if (shType >= 128)
              if (((clone.ins = [clone.ins[index]]), 129 == shType));
              else if (130 == shType) clone.outs = [];
              else if (131 == shType)
                for (clone.outs.length = index + 1, i = 0; i < index; i++)
                  (clone.outs[i].value = -1),
                    (clone.outs[i].script.buffer = []);
            var buffer = Crypto.util.hexToBytes(clone.serialize());
            buffer = buffer.concat(coinjs.numToBytes(parseInt(shType), 4));
            var hash = Crypto.SHA256(buffer, { asBytes: !0 });
            return Crypto.util.bytesToHex(Crypto.SHA256(hash, { asBytes: !0 }));
          }
          return !1;
        },
        transactionHashSegWitV0: function (index, sigHashType) {
          var extract = this.extractScriptKey(index);
          if ("segwit" != extract.type && "multisig_bech32" != extract.type)
            return {
              result: 0,
              fail: "redeemscript",
              response: "redeemscript missing or not valid for segwit",
            };
          if (-1 == extract.value)
            return {
              result: 0,
              fail: "value",
              response:
                "unable to generate a valid segwit hash without a value",
            };
          var scriptcode = Crypto.util.hexToBytes(extract.script);
          20 == scriptcode.length && (scriptcode = [0, 20].concat(scriptcode)),
            22 == scriptcode.length
              ? ((scriptcode = scriptcode.slice(1)).unshift(25, 118, 169),
                scriptcode.push(136, 172))
              : scriptcode[0] > 80 && scriptcode.unshift(scriptcode.length);
          var value = coinjs.numToBytes(extract.value, 8),
            zero = coinjs.numToBytes(0, 32),
            version = coinjs.numToBytes(parseInt(this.version), 4),
            bufferTmp = [];
          if (!(sigHashType >= 80))
            for (var i = 0; i < this.ins.length; i++)
              bufferTmp = (bufferTmp = bufferTmp.concat(
                Crypto.util.hexToBytes(this.ins[i].outpoint.hash).reverse()
              )).concat(coinjs.numToBytes(this.ins[i].outpoint.index, 4));
          var hashPrevouts =
            bufferTmp.length >= 1
              ? Crypto.SHA256(Crypto.SHA256(bufferTmp, { asBytes: !0 }), {
                  asBytes: !0,
                })
              : zero;
          if (
            ((bufferTmp = []),
            !(sigHashType >= 80) && 2 != sigHashType && 3 != sigHashType)
          )
            for (i = 0; i < this.ins.length; i++)
              bufferTmp = bufferTmp.concat(
                coinjs.numToBytes(this.ins[i].sequence, 4)
              );
          var hashSequence =
              bufferTmp.length >= 1
                ? Crypto.SHA256(Crypto.SHA256(bufferTmp, { asBytes: !0 }), {
                    asBytes: !0,
                  })
                : zero,
            outpoint = Crypto.util
              .hexToBytes(this.ins[index].outpoint.hash)
              .reverse();
          outpoint = outpoint.concat(
            coinjs.numToBytes(this.ins[index].outpoint.index, 4)
          );
          var nsequence = coinjs.numToBytes(this.ins[index].sequence, 4),
            hashOutputs = zero;
          if (((bufferTmp = []), 2 != sigHashType && 3 != sigHashType)) {
            for (i = 0; i < this.outs.length; i++)
              bufferTmp = (bufferTmp = (bufferTmp = bufferTmp.concat(
                coinjs.numToBytes(this.outs[i].value, 8)
              )).concat(
                coinjs.numToVarInt(this.outs[i].script.buffer.length)
              )).concat(this.outs[i].script.buffer);
            hashOutputs = Crypto.SHA256(
              Crypto.SHA256(bufferTmp, { asBytes: !0 }),
              { asBytes: !0 }
            );
          } else
            2 == sigHashType &&
              index < this.outs.length &&
              ((bufferTmp = (bufferTmp = (bufferTmp = bufferTmp.concat(
                coinjs.numToBytes(this.outs[index].value, 8)
              )).concat(
                coinjs.numToVarInt(this.outs[i].script.buffer.length)
              )).concat(this.outs[index].script.buffer)),
              (hashOutputs = Crypto.SHA256(
                Crypto.SHA256(bufferTmp, { asBytes: !0 }),
                { asBytes: !0 }
              )));
          var locktime = coinjs.numToBytes(this.lock_time, 4),
            sighash = coinjs.numToBytes(sigHashType, 4),
            buffer = [];
          buffer = (buffer = (buffer = (buffer = (buffer = (buffer = (buffer =
            (buffer = (buffer = (buffer = buffer.concat(version)).concat(
              hashPrevouts
            )).concat(hashSequence)).concat(outpoint)).concat(
            scriptcode
          )).concat(value)).concat(nsequence)).concat(hashOutputs)).concat(
            locktime
          )).concat(sighash);
          var hash = Crypto.SHA256(buffer, { asBytes: !0 });
          return {
            result: 1,
            hash: Crypto.util.bytesToHex(Crypto.SHA256(hash, { asBytes: !0 })),
            response: "hash generated",
          };
        },
        transactionHashSegWitV1: function (index, sigHashType) {
          var extract = this.extractScriptKey(index);
          if ("segwit" != extract.type && "multisig_bech32" != extract.type)
            return {
              result: 0,
              fail: "redeemscript",
              response: "redeemscript missing or not valid for segwit",
            };
          if (-1 == extract.value)
            return {
              result: 0,
              fail: "value",
              response:
                "unable to generate a valid segwit hash without a value",
            };
          var scriptcode = Crypto.util.hexToBytes(extract.script);
          20 == scriptcode.length && (scriptcode = [0, 20].concat(scriptcode)),
            22 == scriptcode.length
              ? ((scriptcode = scriptcode.slice(1)).unshift(25, 118, 169),
                scriptcode.push(136, 172))
              : scriptcode[0] > 80 && scriptcode.unshift(scriptcode.length);
          var value = coinjs.numToBytes(extract.value, 8),
            zero = coinjs.numToBytes(0, 32),
            version = coinjs.numToBytes(parseInt(this.version), 4),
            bufferTmp = [];
          if (!(sigHashType >= 80))
            for (var i = 0; i < this.ins.length; i++)
              bufferTmp = (bufferTmp = bufferTmp.concat(
                Crypto.util.hexToBytes(this.ins[i].outpoint.hash).reverse()
              )).concat(coinjs.numToBytes(this.ins[i].outpoint.index, 4));
          var hashPrevouts =
            bufferTmp.length >= 1
              ? Crypto.SHA256(Crypto.SHA256(bufferTmp, { asBytes: !0 }), {
                  asBytes: !0,
                })
              : zero;
          if (
            ((bufferTmp = []),
            !(sigHashType >= 80) && 2 != sigHashType && 3 != sigHashType)
          )
            for (i = 0; i < this.ins.length; i++)
              bufferTmp = bufferTmp.concat(
                coinjs.numToBytes(this.ins[i].sequence, 4)
              );
          var hashSequence =
              bufferTmp.length >= 1
                ? Crypto.SHA256(Crypto.SHA256(bufferTmp, { asBytes: !0 }), {
                    asBytes: !0,
                  })
                : zero,
            outpoint = Crypto.util
              .hexToBytes(this.ins[index].outpoint.hash)
              .reverse();
          outpoint = outpoint.concat(
            coinjs.numToBytes(this.ins[index].outpoint.index, 4)
          );
          var nsequence = coinjs.numToBytes(this.ins[index].sequence, 4),
            hashOutputs = zero;
          if (((bufferTmp = []), 2 != sigHashType && 3 != sigHashType)) {
            for (i = 0; i < this.outs.length; i++)
              bufferTmp = (bufferTmp = (bufferTmp = bufferTmp.concat(
                coinjs.numToBytes(this.outs[i].value, 8)
              )).concat(
                coinjs.numToVarInt(this.outs[i].script.buffer.length)
              )).concat(this.outs[i].script.buffer);
            hashOutputs = Crypto.SHA256(
              Crypto.SHA256(bufferTmp, { asBytes: !0 }),
              { asBytes: !0 }
            );
          } else
            2 == sigHashType &&
              index < this.outs.length &&
              ((bufferTmp = (bufferTmp = (bufferTmp = bufferTmp.concat(
                coinjs.numToBytes(this.outs[index].value, 8)
              )).concat(
                coinjs.numToVarInt(this.outs[i].script.buffer.length)
              )).concat(this.outs[index].script.buffer)),
              (hashOutputs = Crypto.SHA256(
                Crypto.SHA256(bufferTmp, { asBytes: !0 }),
                { asBytes: !0 }
              )));
          var locktime = coinjs.numToBytes(this.lock_time, 4),
            sighash = coinjs.numToBytes(sigHashType, 4),
            buffer = [];
          buffer = (buffer = (buffer = (buffer = (buffer = (buffer = (buffer =
            (buffer = (buffer = (buffer = buffer.concat(version)).concat(
              locktime
            )).concat(hashPrevouts)).concat(value)).concat(hashOutputs)).concat(
            nsequence
          )).concat(outpoint)).concat(hashSequence)).concat(sighash)).concat(
            scriptcode
          );
          var hash = Crypto.SHA256(buffer, { asBytes: !0 });
          return {
            result: 1,
            hash: Crypto.util.bytesToHex(Crypto.SHA256(hash, { asBytes: !0 })),
            response: "hash generated",
          };
        },
        extractScriptKey: function (index) {
          if (this.ins[index]) {
            if (
              5 == this.ins[index].script.chunks.length &&
              172 == this.ins[index].script.chunks[4] &&
              coinjs.isArray(this.ins[index].script.chunks[2])
            )
              return {
                type: "scriptpubkey",
                signed: "false",
                signatures: 0,
                script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
              };
            if (
              2 == this.ins[index].script.chunks.length &&
              48 == this.ins[index].script.chunks[0][0] &&
              5 == this.ins[index].script.chunks[1].length &&
              177 == this.ins[index].script.chunks[1][1]
            )
              return {
                type: "hodl",
                signed: "true",
                signatures: 1,
                script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
              };
            if (
              2 == this.ins[index].script.chunks.length &&
              48 == this.ins[index].script.chunks[0][0]
            )
              return {
                type: "scriptpubkey",
                signed: "true",
                signatures: 1,
                script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
              };
            if (
              5 == this.ins[index].script.chunks.length &&
              177 == this.ins[index].script.chunks[1]
            )
              return {
                type: "hodl",
                signed: "false",
                signatures: 0,
                script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
              };
            if (
              this.ins[index].script.chunks.length <= 3 &&
              this.ins[index].script.chunks.length > 0 &&
              ((22 == this.ins[index].script.chunks[0].length &&
                0 == this.ins[index].script.chunks[0][0]) ||
                (20 == this.ins[index].script.chunks[0].length &&
                  0 == this.ins[index].script.chunks[1]))
            ) {
              var sigs =
                  "true" ==
                  (signed =
                    this.witness[index] && 2 == this.witness[index].length
                      ? "true"
                      : "false")
                    ? 1
                    : 0,
                value = -1;
              return (
                this.ins[index].script.chunks[2] &&
                  8 == this.ins[index].script.chunks[2].length &&
                  (value = coinjs.bytesToNum(this.ins[index].script.chunks[2])),
                {
                  type: "segwit",
                  signed: signed,
                  signatures: sigs,
                  script: Crypto.util.bytesToHex(
                    this.ins[index].script.chunks[0]
                  ),
                  value: value,
                }
              );
            }
            if (
              0 == this.ins[index].script.chunks[0] &&
              174 ==
                this.ins[index].script.chunks[
                  this.ins[index].script.chunks.length - 1
                ][
                  this.ins[index].script.chunks[
                    this.ins[index].script.chunks.length - 1
                  ].length - 1
                ]
            ) {
              var sigcount = 0;
              for (let i = 1; i < this.ins[index].script.chunks.length - 1; i++)
                0 != this.ins[index].script.chunks[i] && sigcount++;
              return {
                type: "multisig",
                signed: "true",
                signatures: sigcount,
                script: Crypto.util.bytesToHex(
                  this.ins[index].script.chunks[
                    this.ins[index].script.chunks.length - 1
                  ]
                ),
              };
            }
            if (
              this.ins[index].script.chunks[0] >= 80 &&
              174 ==
                this.ins[index].script.chunks[
                  this.ins[index].script.chunks.length - 1
                ]
            )
              return {
                type: "multisig",
                signed: "false",
                signatures: 0,
                script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
              };
            if (
              3 == this.ins[index].script.chunks.length &&
              this.ins[index].script.chunks[0][0] >= 80 &&
              174 ==
                this.ins[index].script.chunks[0][
                  this.ins[index].script.chunks[0].length - 1
                ] &&
              0 == this.ins[index].script.chunks[1]
            ) {
              let last_index = this.ins[index].script.chunks.length - 1;
              return (
                (value = -1),
                last_index >= 2 &&
                  8 == this.ins[index].script.chunks[last_index].length &&
                  (value = coinjs.bytesToNum(
                    this.ins[index].script.chunks[last_index]
                  )),
                {
                  type: "multisig_bech32",
                  signed: "false",
                  signatures: (sigcount = this.witness[index]
                    ? this.witness[index].length - 2
                    : 0),
                  script: Crypto.util.bytesToHex(
                    this.ins[index].script.chunks[0]
                  ),
                  value: value,
                }
              );
            }
            var signed;
            return 0 == this.ins[index].script.chunks.length
              ? {
                  type: "empty",
                  signed: (signed =
                    this.witness[index] && this.witness[index].length >= 2
                      ? "true"
                      : "false"),
                  signatures: (sigs =
                    "true" == signed
                      ? this.witness[index][0]
                        ? 1
                        : this.witness[index].length - 2
                      : 0),
                  script: "",
                }
              : 2 == this.ins[index].script.chunks.length &&
                81 == this.ins[index].script.chunks[0] &&
                32 == this.ins[index].script.chunks[1].length &&
                32 == this.ins[index].script.buffer[1]
              ? {
                  type: "bech32m",
                  signed: "false",
                  signatures: 0,
                  script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
                }
              : {
                  type: "unknown",
                  signed: "false",
                  signatures: 0,
                  script: Crypto.util.bytesToHex(this.ins[index].script.buffer),
                };
          }
          return !1;
        },
        transactionSig: function (index, wif, sigHashType, txhash) {
          var shType = sigHashType || 1,
            hash =
              txhash ||
              Crypto.util.hexToBytes(this.transactionHash(index, shType));
          if (hash) {
            var curve = EllipticCurve.getSECCurveByName("secp256k1"),
              key = coinjs.wif2privkey(wif),
              priv = BigInteger.fromByteArrayUnsigned(
                Crypto.util.hexToBytes(key.privkey)
              ),
              n = curve.getN(),
              e = BigInteger.fromByteArrayUnsigned(hash),
              badrs = 0;
            do {
              var k = this.deterministicK(wif, hash, badrs),
                r = curve.getG().multiply(k).getX().toBigInteger().mod(n),
                s = k
                  .modInverse(n)
                  .multiply(e.add(priv.multiply(r)))
                  .mod(n);
              badrs++;
            } while (
              r.compareTo(BigInteger.ZERO) <= 0 ||
              s.compareTo(BigInteger.ZERO) <= 0
            );
            var halfn = n.shiftRight(1);
            s.compareTo(halfn) > 0 && (s = n.subtract(s));
            var sig = (function (r, s) {
              var rBa = r.toByteArraySigned(),
                sBa = s.toByteArraySigned(),
                sequence = [];
              return (
                sequence.push(2),
                sequence.push(rBa.length),
                (sequence = sequence.concat(rBa)).push(2),
                sequence.push(sBa.length),
                (sequence = sequence.concat(sBa)).unshift(sequence.length),
                sequence.unshift(48),
                sequence
              );
            })(r, s);
            return sig.push(parseInt(shType, 10)), Crypto.util.bytesToHex(sig);
          }
          return !1;
        },
        deterministicK: function (wif, hash, badrs) {
          badrs = badrs || 0;
          var key = coinjs.wif2privkey(wif),
            x = Crypto.util.hexToBytes(key.privkey),
            N = EllipticCurve.getSECCurveByName("secp256k1").getN(),
            v = [
              1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
              1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            ],
            k = [
              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            ];
          (k = Crypto.HMAC(
            Crypto.SHA256,
            v.concat([0]).concat(x).concat(hash),
            k,
            { asBytes: !0 }
          )),
            (v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 })),
            (k = Crypto.HMAC(
              Crypto.SHA256,
              v.concat([1]).concat(x).concat(hash),
              k,
              { asBytes: !0 }
            )),
            (v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 }));
          var T = [];
          T = v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 });
          for (
            var KBigInt = BigInteger.fromByteArrayUnsigned(T), i = 0;
            KBigInt.compareTo(N) >= 0 ||
            KBigInt.compareTo(BigInteger.ZERO) <= 0 ||
            i < badrs;

          )
            (k = Crypto.HMAC(Crypto.SHA256, v.concat([0]), k, { asBytes: !0 })),
              (v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 })),
              (T = v = Crypto.HMAC(Crypto.SHA256, v, k, { asBytes: !0 })),
              (KBigInt = BigInteger.fromByteArrayUnsigned(T)),
              i++;
          return KBigInt;
        },
        signinput: function (index, wif, sigHashType) {
          var key = coinjs.wif2pubkey(wif),
            shType = sigHashType || 1,
            signature = this.transactionSig(index, wif, shType),
            s = coinjs.script();
          return (
            s.writeBytes(Crypto.util.hexToBytes(signature)),
            s.writeBytes(Crypto.util.hexToBytes(key.pubkey)),
            (this.ins[index].script = s),
            !0
          );
        },
        signhodl: function (index, wif, sigHashType) {
          var shType = sigHashType || 1,
            signature = this.transactionSig(index, wif, shType),
            redeemScript = this.ins[index].script.buffer,
            s = coinjs.script();
          return (
            s.writeBytes(Crypto.util.hexToBytes(signature)),
            s.writeBytes(redeemScript),
            (this.ins[index].script = s),
            !0
          );
        },
        signtaproot: function (index, wif, sigHashType) {
          var shType = sigHashType || 1,
            signature = this.transactionSig(index, wif, shType),
            redeemScript = this.ins[index].script.buffer,
            s = coinjs.script();
          return (
            s.writeBytes(Crypto.util.hexToBytes(signature)),
            s.writeBytes(redeemScript),
            (this.ins[index].script = s),
            !0
          );
        },
        signmultisig_bech32: function (index, wif, sigHashType) {
          var redeemScript = Crypto.util.bytesToHex(
            this.ins[index].script.chunks[0]
          );
          coinjs.isArray(this.witness) ||
            ((this.witness = new Array(this.ins.length)),
            this.witness.fill([]));
          var pubkeyList = (function (redeemScript_decoded) {
              for (
                var r = {}, i = 1;
                i < redeemScript_decoded.chunks.length - 2;
                i++
              )
                r[i] = Crypto.util.hexToBytes(
                  coinjs.pubkeydecompress(
                    Crypto.util.bytesToHex(redeemScript_decoded.chunks[i])
                  )
                );
              return r;
            })(coinjs.script(redeemScript)),
            sigsList = (function (sigList) {
              let r = {};
              var c = 0;
              if (Array.isArray(sigList))
                for (let i = 1; i < sigList.length - 1; i++)
                  r[++c] = Crypto.util.hexToBytes(sigList[i]);
              return r;
            })(this.witness[index]);
          let decode_rs = coinjs
            .script()
            .decodeRedeemScriptBech32(redeemScript);
          var shType = sigHashType || 1,
            txhash = this.transactionHashSegWitV0(index, shType);
          if (
            1 == txhash.result &&
            decode_rs.pubkeys.includes(coinjs.wif2pubkey(wif).pubkey)
          ) {
            var segwitHash = Crypto.util.hexToBytes(txhash.hash),
              signature = Crypto.util.hexToBytes(
                this.transactionSig(index, wif, shType, segwitHash)
              );
            sigsList[coinjs.countObject(sigsList) + 1] = signature;
            var w = [];
            for (let x in pubkeyList)
              for (let y in sigsList) {
                var sighash = this.transactionHashSegWitV0(
                  index,
                  1 * sigsList[y].slice(-1)[0]
                ).hash;
                (sighash = Crypto.util.hexToBytes(sighash)),
                  coinjs.verifySignature(sighash, sigsList[y], pubkeyList[x]) &&
                    w.push(Crypto.util.bytesToHex(sigsList[y]));
              }
            w.length >= decode_rs.signaturesRequired &&
              (this.ins[index].script = coinjs.script()),
              w.unshift(0),
              w.push(redeemScript),
              (this.witness[index] = w);
          }
        },
        signmultisig: function (index, wif, sigHashType) {
          var redeemScript =
              174 ==
              this.ins[index].script.chunks[
                this.ins[index].script.chunks.length - 1
              ]
                ? this.ins[index].script.buffer
                : this.ins[index].script.chunks[
                    this.ins[index].script.chunks.length - 1
                  ],
            pubkeyList = (function (redeemScript) {
              for (var r = {}, i = 1; i < redeemScript.chunks.length - 2; i++)
                r[i] = Crypto.util.hexToBytes(
                  coinjs.pubkeydecompress(
                    Crypto.util.bytesToHex(redeemScript.chunks[i])
                  )
                );
              return r;
            })(coinjs.script(redeemScript)),
            sigsList = (function (scriptSig) {
              var r = {},
                c = 0;
              if (
                0 == scriptSig.chunks[0] &&
                174 ==
                  scriptSig.chunks[scriptSig.chunks.length - 1][
                    scriptSig.chunks[scriptSig.chunks.length - 1].length - 1
                  ]
              )
                for (var i = 1; i < scriptSig.chunks.length - 1; i++)
                  0 != scriptSig.chunks[i] && (r[++c] = scriptSig.chunks[i]);
              return r;
            })(this.ins[index].script),
            shType = sigHashType || 1,
            sighash = Crypto.util.hexToBytes(
              this.transactionHash(index, shType)
            ),
            signature = Crypto.util.hexToBytes(
              this.transactionSig(index, wif, shType)
            );
          sigsList[coinjs.countObject(sigsList) + 1] = signature;
          var s = coinjs.script();
          s.writeOp(0);
          for (let x in pubkeyList)
            for (let y in sigsList)
              (this.ins[index].script.buffer = redeemScript),
                (sighash = Crypto.util.hexToBytes(
                  this.transactionHash(index, 1 * sigsList[y].slice(-1)[0])
                )),
                coinjs.verifySignature(sighash, sigsList[y], pubkeyList[x]) &&
                  s.writeBytes(sigsList[y]);
          return s.writeBytes(redeemScript), (this.ins[index].script = s), !0;
        },
        signsegwit: function (index, wif, sigHashType) {
          var shType = sigHashType || 1,
            wif2 = coinjs.wif2pubkey(wif),
            segwit = coinjs.segwitAddress(wif2.pubkey),
            bech32 = coinjs.bech32Address(wif2.pubkey);
          if (
            segwit.redeemscript ==
              Crypto.util.bytesToHex(this.ins[index].script.chunks[0]) ||
            bech32.redeemscript ==
              Crypto.util.bytesToHex(this.ins[index].script.chunks[0])
          ) {
            var txhash = this.transactionHashSegWitV0(index, shType);
            if (1 == txhash.result) {
              var segwitHash = Crypto.util.hexToBytes(txhash.hash),
                signature = this.transactionSig(index, wif, shType, segwitHash),
                script = coinjs.script();
              script.writeBytes(this.ins[index].script.chunks[0]),
                (this.ins[index].script = script),
                coinjs.isArray(this.witness) ||
                  ((this.witness = new Array(this.ins.length)),
                  this.witness.fill([])),
                (this.witness[index] = [signature, wif2.pubkey]),
                bech32.redeemscript ==
                  Crypto.util.bytesToHex(this.ins[index].script.chunks[0]) &&
                  (this.ins[index].script = coinjs.script());
            }
          }
          return !0;
        },
        sign: function (wif, sigHashType) {
          for (var shType = sigHashType || 1, i = 0; i < this.ins.length; i++) {
            var d = this.extractScriptKey(i),
              w2a = coinjs.wif2address(wif),
              pubkeyHash = coinjs.script().pubkeyHash(w2a.address);
            (("scriptpubkey" == d.type &&
              d.script == Crypto.util.bytesToHex(pubkeyHash.buffer)) ||
              "empty" == d.type) &&
            "false" == d.signed
              ? this.signinput(i, wif, shType)
              : "hodl" == d.type && "false" == d.signed
              ? this.signhodl(i, wif, shType)
              : "multisig" == d.type
              ? this.signmultisig(i, wif, shType)
              : "multisig_bech32" == d.type && "false" == d.signed
              ? this.signmultisig_bech32(i, wif, shType)
              : "segwit" == d.type
              ? this.signsegwit(i, wif, shType)
              : "bech32m" == d.type && this.signtaproot(i, wif, shType);
          }
          return this.serialize();
        },
        serialize: function () {
          var buffer = [];
          (buffer = buffer.concat(
            coinjs.numToBytes(parseInt(this.version), 4)
          )),
            coinjs.isArray(this.witness) && (buffer = buffer.concat([0, 1])),
            (buffer = buffer.concat(coinjs.numToVarInt(this.ins.length)));
          for (var i = 0; i < this.ins.length; i++) {
            var txin = this.ins[i];
            buffer = (buffer = buffer.concat(
              Crypto.util.hexToBytes(txin.outpoint.hash).reverse()
            )).concat(coinjs.numToBytes(parseInt(txin.outpoint.index), 4));
            var scriptBytes = txin.script.buffer;
            buffer = (buffer = (buffer = buffer.concat(
              coinjs.numToVarInt(scriptBytes.length)
            )).concat(scriptBytes)).concat(
              coinjs.numToBytes(parseInt(txin.sequence), 4)
            );
          }
          for (
            buffer = buffer.concat(coinjs.numToVarInt(this.outs.length)), i = 0;
            i < this.outs.length;
            i++
          ) {
            var txout = this.outs[i];
            (buffer = buffer.concat(coinjs.numToBytes(txout.value, 8))),
              (scriptBytes = txout.script.buffer),
              (buffer = (buffer = buffer.concat(
                coinjs.numToVarInt(scriptBytes.length)
              )).concat(scriptBytes));
          }
          if (coinjs.isArray(this.witness) && this.witness.length >= 1)
            for (i = 0; i < this.witness.length; i++) {
              buffer = buffer.concat(
                coinjs.numToVarInt(this.witness[i].length)
              );
              for (var x = 0; x < this.witness[i].length; x++)
                buffer = (buffer = buffer.concat(
                  coinjs.numToVarInt(
                    Crypto.util.hexToBytes(this.witness[i][x]).length
                  )
                )).concat(Crypto.util.hexToBytes(this.witness[i][x]));
            }
          return (
            (buffer = buffer.concat(
              coinjs.numToBytes(parseInt(this.lock_time), 4)
            )),
            Crypto.util.bytesToHex(buffer)
          );
        },
        transactionSigNoIndex: function (wif, sigHashType, txhash) {
          var shType = sigHashType || 1,
            hash = Crypto.util.hexToBytes(txhash);
          if (hash) {
            var curve = EllipticCurve.getSECCurveByName("secp256k1"),
              key = coinjs.wif2privkey(wif),
              priv = BigInteger.fromByteArrayUnsigned(
                Crypto.util.hexToBytes(key.privkey)
              ),
              n = curve.getN(),
              e = BigInteger.fromByteArrayUnsigned(hash),
              badrs = 0;
            do {
              var k = this.deterministicK(wif, hash, badrs),
                r = curve.getG().multiply(k).getX().toBigInteger().mod(n),
                s = k
                  .modInverse(n)
                  .multiply(e.add(priv.multiply(r)))
                  .mod(n);
              badrs++;
            } while (
              r.compareTo(BigInteger.ZERO) <= 0 ||
              s.compareTo(BigInteger.ZERO) <= 0
            );
            var halfn = n.shiftRight(1);
            s.compareTo(halfn) > 0 && (s = n.subtract(s));
            var sig = (function (r, s) {
              var rBa = r.toByteArraySigned(),
                sBa = s.toByteArraySigned(),
                sequence = [];
              return (
                sequence.push(2),
                sequence.push(rBa.length),
                (sequence = sequence.concat(rBa)).push(2),
                sequence.push(sBa.length),
                (sequence = sequence.concat(sBa)).unshift(sequence.length),
                sequence.unshift(48),
                sequence
              );
            })(r, s);
            return sig.push(parseInt(shType, 10)), Crypto.util.bytesToHex(sig);
          }
          return !1;
        },
        deserialize: function (buffer) {
          "string" == typeof buffer &&
            (buffer = Crypto.util.hexToBytes(buffer));
          var pos = 0,
            witness = !1,
            readAsInt = function (bytes) {
              return 0 == bytes
                ? 0
                : (pos++, buffer[pos - 1] + 256 * readAsInt(bytes - 1));
            },
            readVarInt = function () {
              return (
                pos++,
                buffer[pos - 1] < 253
                  ? buffer[pos - 1]
                  : readAsInt(buffer[pos - 1] - 251)
              );
            },
            readBytes = function (bytes) {
              return (pos += bytes), buffer.slice(pos - bytes, pos);
            },
            readVarString = function () {
              var size = readVarInt();
              return readBytes(size);
            },
            obj = new coinjs.transaction();
          (obj.version = readAsInt(4)),
            0 == buffer[pos] &&
              1 == buffer[pos + 1] &&
              ((witness = !0), (obj.witness = []), (pos += 2));
          for (var ins = readVarInt(), i = 0; i < ins; i++)
            obj.ins.push({
              outpoint: {
                hash: Crypto.util.bytesToHex(readBytes(32).reverse()),
                index: readAsInt(4),
              },
              script: coinjs.script(readVarString()),
              sequence: readAsInt(4),
            });
          var outs = readVarInt();
          for (i = 0; i < outs; i++)
            obj.outs.push({
              value: coinjs.bytesToNum(readBytes(8)),
              script: coinjs.script(readVarString()),
            });
          if (1 == witness)
            for (i = 0; i < ins; ++i) {
              var count = readVarInt();
              coinjs.isArray(obj.witness[i]) || (obj.witness[i] = []);
              for (var y = 0; y < count; y++) {
                var slice = readVarInt();
                (pos += slice),
                  obj.witness[i].push(
                    Crypto.util.bytesToHex(buffer.slice(pos - slice, pos))
                  );
              }
            }
          return (obj.lock_time = readAsInt(4)), obj;
        },
        size: function () {
          return (this.serialize().length / 2).toFixed(0);
        },
      };
      return r;
    }),
    (coinjs.verifySignature = function (hash, sig, pubkey) {
      var r, s, Q;
      if (coinjs.isArray(sig)) {
        var obj = (function (sig) {
          var cursor;
          if (48 != sig[0])
            throw new Error("Signature not a valid DERSequence");
          if (2 != sig[(cursor = 2)])
            throw new Error("First element in signature must be a DERInteger");
          var rBa = sig.slice(cursor + 2, cursor + 2 + sig[cursor + 1]);
          if (2 != sig[(cursor += 2 + sig[cursor + 1])])
            throw new Error("Second element in signature must be a DERInteger");
          var sBa = sig.slice(cursor + 2, cursor + 2 + sig[cursor + 1]);
          return (
            (cursor += 2 + sig[cursor + 1]),
            {
              r: BigInteger.fromByteArrayUnsigned(rBa),
              s: BigInteger.fromByteArrayUnsigned(sBa),
            }
          );
        })(sig);
        (r = obj.r), (s = obj.s);
      } else {
        if ("object" != typeof sig || !sig.r || !sig.s)
          throw "Invalid value for signature";
        (r = sig.r), (s = sig.s);
      }
      if (!coinjs.isArray(pubkey))
        throw "Invalid format for pubkey value, must be byte array";
      var ecparams = EllipticCurve.getSECCurveByName("secp256k1");
      Q = EllipticCurve.PointFp.decodeFrom(ecparams.getCurve(), pubkey);
      var e = BigInteger.fromByteArrayUnsigned(hash);
      return coinjs.verifySignatureRaw(e, r, s, Q);
    }),
    (coinjs.verifySignatureRaw = function (e, r, s, Q) {
      var ecparams = EllipticCurve.getSECCurveByName("secp256k1"),
        n = ecparams.getN(),
        G = ecparams.getG();
      if (r.compareTo(BigInteger.ONE) < 0 || r.compareTo(n) >= 0) return !1;
      if (s.compareTo(BigInteger.ONE) < 0 || s.compareTo(n) >= 0) return !1;
      var c = s.modInverse(n),
        u1 = e.multiply(c).mod(n),
        u2 = r.multiply(c).mod(n);
      return G.multiply(u1)
        .add(Q.multiply(u2))
        .getX()
        .toBigInteger()
        .mod(n)
        .equals(r);
    }),
    (coinjs.base58encode = function (buffer) {
      for (
        var alphabet =
            "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
          base = BigInteger.valueOf(58),
          bi = BigInteger.fromByteArrayUnsigned(buffer),
          chars = [];
        bi.compareTo(base) >= 0;

      ) {
        var mod = bi.mod(base);
        chars.unshift(alphabet[mod.intValue()]),
          (bi = bi.subtract(mod).divide(base));
      }
      chars.unshift(alphabet[bi.intValue()]);
      for (var i = 0; i < buffer.length && 0 == buffer[i]; i++)
        chars.unshift(alphabet[0]);
      return chars.join("");
    }),
    (coinjs.base58decode = function (buffer) {
      for (
        var base = BigInteger.valueOf(58),
          bi = BigInteger.valueOf(0),
          leadingZerosNum = 0,
          i = buffer.length - 1;
        i >= 0;
        i--
      ) {
        var alphaIndex =
          "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".indexOf(
            buffer[i]
          );
        if (alphaIndex < 0) throw "Invalid character";
        (bi = bi.add(
          BigInteger.valueOf(alphaIndex).multiply(
            base.pow(buffer.length - 1 - i)
          )
        )),
          "1" == buffer[i] ? leadingZerosNum++ : (leadingZerosNum = 0);
      }
      for (var bytes = bi.toByteArrayUnsigned(); leadingZerosNum-- > 0; )
        bytes.unshift(0);
      return bytes;
    }),
    (coinjs.ajax = function (u, f, m, a) {
      var x = !1;
      try {
        x = new ActiveXObject("Msxml2.XMLHTTP");
      } catch (e) {
        try {
          x = new ActiveXObject("Microsoft.XMLHTTP");
        } catch (e) {
          x = new XMLHttpRequest();
        }
      }
      if (0 == x) return !1;
      x.open(m, u, !0),
        (x.onreadystatechange = function () {
          4 == x.readyState && f && f(x.responseText);
        }),
        "POST" == m &&
          x.setRequestHeader(
            "Content-type",
            "application/x-www-form-urlencoded"
          ),
        x.send(a);
    }),
    (coinjs.clone = function (obj) {
      if (null == obj || "object" != typeof obj) return obj;
      var temp = new obj.constructor();
      for (var key in obj)
        obj.hasOwnProperty(key) && (temp[key] = coinjs.clone(obj[key]));
      return temp;
    }),
    (coinjs.numToBytes = function (num, bytes) {
      return (
        void 0 === bytes && (bytes = 8),
        0 == bytes
          ? []
          : -1 == num
          ? Crypto.util.hexToBytes("ffffffffffffffff")
          : [num % 256].concat(
              coinjs.numToBytes(Math.floor(num / 256), bytes - 1)
            )
      );
    }),
    (coinjs.numToScriptNumBytes = function (_number) {
      for (
        var value = Math.abs(_number),
          size = (function (i) {
            return i > 2147483647
              ? 5
              : i > 8388607
              ? 4
              : i > 32767
              ? 3
              : i > 127
              ? 2
              : i > 0
              ? 1
              : 0;
          })(value),
          result = [],
          i = 0;
        i < size;
        ++i
      )
        result.push(0);
      var negative = _number < 0;
      for (i = 0; i < size; ++i)
        (result[i] = 255 & value), (value = Math.floor(value / 256));
      return negative && (result[size - 1] |= 128), result;
    }),
    (coinjs.numToVarInt = function (num) {
      return num < 253
        ? [num]
        : num < 65536
        ? [253].concat(coinjs.numToBytes(num, 2))
        : num < 4294967296
        ? [254].concat(coinjs.numToBytes(num, 4))
        : [255].concat(coinjs.numToBytes(num, 8));
    }),
    (coinjs.bytesToNum = function (bytes) {
      return 0 == bytes.length
        ? 0
        : bytes[0] + 256 * coinjs.bytesToNum(bytes.slice(1));
    }),
    (coinjs.uint = function (f, size) {
      if (f.length < size) throw new Error("not enough data");
      for (var n = 0, i = 0; i < size; i++) (n *= 256), (n += f[i]);
      return n;
    }),
    (coinjs.isArray = function (o) {
      return "[object Array]" === Object.prototype.toString.call(o);
    }),
    (coinjs.countObject = function (obj) {
      var i,
        count = 0;
      for (i in obj) obj.hasOwnProperty(i) && count++;
      return count;
    }),
    (coinjs.changeEndianness = (string) => {
      const result = [];
      let len = string.length - 2;
      for (; len >= 0; ) result.push(string.substr(len, 2)), (len -= 2);
      return result.join("");
    }),
    (coinjs.getTransactionHash = function (
      transaction_in_hex,
      changeOutputEndianess
    ) {
      var x1, x2, x3, x4, x5;
      return (
        (x1 = Crypto.util.hexToBytes(transaction_in_hex)),
        (x2 = Crypto.SHA256(x1)),
        (x3 = Crypto.util.hexToBytes(x2)),
        (x4 = Crypto.SHA256(x3)),
        (x5 = coinjs.changeEndianness(x4)),
        1 == changeOutputEndianess ||
          (void 0 !== changeOutputEndianess && 0 != changeOutputEndianess) ||
          (x5 = x4),
        x5
      );
    }),
    (coinjs.compressedToUncompressed = function (compressed) {
      var t1,
        curve = EllipticCurve.getSECCurveByName("secp256k1");
      return (
        (t1 = curve.curve.decodePointHex(compressed)),
        curve.curve.encodePointHex(t1)
      );
    }),
    (coinjs.uncompressedToCompressed = function (uncompressed) {
      var t1;
      return (
        (t1 = uncompressed.charAt(uncompressed.length - 1)),
        (parseInt(t1, 10) % 2 == 1 ? "03" : "02") + uncompressed.substr(2, 64)
      );
    }),
    (coinjs.verifySignatureHex = function (hashHex, sigHex, pubHexCompressed) {
      var h1, s1, p1, p2;
      return (
        (h1 = Crypto.util.hexToBytes(hashHex)),
        (s1 = Crypto.util.hexToBytes(sigHex)),
        (p1 = coinjs.compressedToUncompressed(pubHexCompressed)),
        (p2 = Crypto.util.hexToBytes(p1)),
        coinjs.verifySignature(h1, s1, p2)
      );
    }),
    (coinjs.generateBitcoinSignature = function (
      private_key,
      hash,
      sighash_type_int = 1
    ) {
      var wif;
      return (
        (wif =
          private_key.length < 60
            ? private_key
            : coinjs.privkey2wif(private_key)),
        coinjs.transaction().transactionSigNoIndex(wif, sighash_type_int, hash)
      );
    }),
    (coinjs.dSHA256 = function (data) {
      var t1, t2;
      return (
        (t1 = Crypto.SHA256(Crypto.util.hexToBytes(data))),
        (t2 = Crypto.util.hexToBytes(t1)),
        Crypto.SHA256(t2)
      );
    }),
    (coinjs.fromBitcoinAmountFormat = function (data) {
      var x1;
      return (x1 = coinjs.changeEndianness(data)), parseInt(x1, 16) / 10 ** 8;
    }),
    (coinjs.toBitcoinAmountFormat = function (countBitcoin) {
      var t3;
      return (
        (t3 = (countBitcoin * 10 ** 8).toString(16)),
        coinjs.changeEndianness(t3).padEnd(16, "0")
      );
    }),
    (coinjs.scriptcodeCreatorBasic = function (scriptpubkey) {
      return "0014" == scriptpubkey.substr(0, 4)
        ? "1976a9" + scriptpubkey.slice(2) + "88ac"
        : (scriptpubkey.length / 2).toString(16) + scriptpubkey;
    }),
    (coinjs.ripemd160sha256 = function (data) {
      var t1;
      return (
        (t1 = ripemd160(
          Crypto.SHA256(Crypto.util.hexToBytes(data), { asBytes: !0 }),
          { asBytes: !0 }
        )),
        Crypto.util.bytesToHex(t1)
      );
    }),
    (coinjs.random = function (length) {
      var r = "",
        l = length || 25;
      for (let x = 0; x < l; x++)
        r +=
          "!$%^&*()_+{}:@~?><|./;'#][=-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".charAt(
            Math.floor(62 * Math.random())
          );
      return r;
    }),
    (function () {
      var SecretShare = (GLOBAL.shamirSecretShare = {}),
        defaults = {
          bits: 8,
          radix: 16,
          minBits: 3,
          maxBits: 20,
          bytesPerChar: 2,
          maxBytesPerChar: 6,
          primitivePolynomials: [
            null,
            null,
            1,
            3,
            3,
            5,
            3,
            3,
            29,
            17,
            9,
            5,
            83,
            27,
            43,
            3,
            45,
            9,
            39,
            39,
            9,
            5,
            3,
            33,
            27,
            9,
            71,
            39,
            9,
            5,
            83,
          ],
          warning:
            "WARNING:\nA secure random number generator was not found.\nUsing securedMathRandom(), which is NOT cryptographically strong!",
        },
        config = {};
      function init(bits) {
        if (
          bits &&
          ("number" != typeof bits ||
            bits % 1 != 0 ||
            bits < defaults.minBits ||
            bits > defaults.maxBits)
        )
          throw new Error(
            "Number of bits must be an integer between " +
              defaults.minBits +
              " and " +
              defaults.maxBits +
              ", inclusive."
          );
        (config.radix = defaults.radix),
          (config.bits = bits || defaults.bits),
          (config.size = Math.pow(2, config.bits)),
          (config.max = config.size - 1);
        for (
          var logs = [],
            exps = [],
            x = 1,
            primitive = defaults.primitivePolynomials[config.bits],
            i = 0;
          i < config.size;
          i++
        )
          (exps[i] = x),
            (logs[x] = i),
            (x <<= 1) >= config.size && ((x ^= primitive), (x &= config.max));
        (config.logs = logs), (config.exps = exps);
      }
      function isInited() {
        return !!(
          config.bits &&
          config.size &&
          config.max &&
          config.logs &&
          config.exps &&
          config.logs.length === config.size &&
          config.exps.length === config.size
        );
      }
      function warn() {
        GLOBAL.console.warn(defaults.warning),
          "function" == typeof GLOBAL.alert &&
            config.alert &&
            GLOBAL.alert(defaults.warning);
      }
      function isSetRNG() {
        return "function" == typeof config.rng;
      }
      function horner(x, coeffs) {
        for (
          var logx = config.logs[x], fx = 0, i = coeffs.length - 1;
          i >= 0;
          i--
        )
          fx =
            0 !== fx
              ? config.exps[(logx + config.logs[fx]) % config.max] ^ coeffs[i]
              : coeffs[i];
        return fx;
      }
      function inArray(arr, val) {
        for (var i = 0, len = arr.length; i < len; i++)
          if (arr[i] === val) return !0;
        return !1;
      }
      function processShare(share) {
        var bits = parseInt(share[0], 36);
        if (
          bits &&
          ("number" != typeof bits ||
            bits % 1 != 0 ||
            bits < defaults.minBits ||
            bits > defaults.maxBits)
        )
          throw new Error(
            "Number of bits must be an integer between " +
              defaults.minBits +
              " and " +
              defaults.maxBits +
              ", inclusive."
          );
        var max = Math.pow(2, bits) - 1,
          idLength = max.toString(config.radix).length,
          id = parseInt(share.substr(1, idLength), config.radix);
        if ("number" != typeof id || id % 1 != 0 || id < 1 || id > max)
          throw new Error(
            "Share id must be an integer between 1 and " +
              config.max +
              ", inclusive."
          );
        if (!(share = share.substr(idLength + 1)).length)
          throw new Error("Invalid share: zero-length share.");
        return { bits: bits, id: id, value: share };
      }
      function combine(at, shares) {
        for (
          var setBits,
            share,
            x = [],
            y = [],
            result = "",
            i = 0,
            len = shares.length;
          i < len;
          i++
        ) {
          if (((share = processShare(shares[i])), void 0 === setBits))
            setBits = share.bits;
          else if (share.bits !== setBits)
            throw new Error("Mismatched shares: Different bit settings.");
          if (
            (config.bits !== setBits && init(setBits), !inArray(x, share.id))
          ) {
            idx = x.push(share.id) - 1;
            for (
              var j = 0, len2 = (share = split(hex2bin(share.value))).length;
              j < len2;
              j++
            )
              (y[j] = y[j] || []), (y[j][idx] = share[j]);
          }
        }
        for (i = 0, len = y.length; i < len; i++)
          result = padLeft(lagrange(at, x, y[i]).toString(2)) + result;
        if (0 === at) {
          var idx = result.indexOf("1");
          return bin2hex(result.slice(idx + 1));
        }
        return bin2hex(result);
      }
      function lagrange(at, x, y) {
        for (var product, sum = 0, i = 0, len = x.length; i < len; i++)
          if (y[i]) {
            product = config.logs[y[i]];
            for (var j = 0; j < len; j++)
              if (i !== j) {
                if (at === x[j]) {
                  product = -1;
                  break;
                }
                product =
                  (product +
                    config.logs[at ^ x[j]] -
                    config.logs[x[i] ^ x[j]] +
                    config.max) %
                  config.max;
              }
            sum = -1 === product ? sum : sum ^ config.exps[product];
          }
        return sum;
      }
      function split(str, padLength) {
        padLength && (str = padLeft(str, padLength));
        for (var parts = [], i = str.length; i > config.bits; i -= config.bits)
          parts.push(parseInt(str.slice(i - config.bits, i), 2));
        return parts.push(parseInt(str.slice(0, i), 2)), parts;
      }
      function padLeft(str, bits) {
        bits = bits || config.bits;
        var missing = str.length % bits;
        return (missing ? new Array(bits - missing + 1).join("0") : "") + str;
      }
      function hex2bin(str) {
        for (var num, bin = "", i = str.length - 1; i >= 0; i--) {
          if (((num = parseInt(str[i], 16)), isNaN(num)))
            throw new Error("Invalid hex character.");
          bin = padLeft(num.toString(2), 4) + bin;
        }
        return bin;
      }
      function bin2hex(str) {
        for (
          var num, hex = "", i = (str = padLeft(str, 4)).length;
          i >= 4;
          i -= 4
        ) {
          if (((num = parseInt(str.slice(i - 4, i), 2)), isNaN(num)))
            throw new Error("Invalid binary character.");
          hex = num.toString(16) + hex;
        }
        return hex;
      }
      (SecretShare.getConfig = function () {
        return { bits: config.bits, unsafePRNG: config.unsafePRNG };
      }),
        (SecretShare.init = init),
        (SecretShare.setRNG = function (rng, alert) {
          if (
            (isInited() || this.init(),
            (config.unsafePRNG = !1),
            "function" !=
              typeof (rng =
                rng ||
                (function () {
                  var crypto;
                  function construct(bits, arr, radix, size) {
                    for (
                      var str = "", i = 0, len = arr.length - 1;
                      i < len || str.length < bits;

                    )
                      (str += padLeft(
                        parseInt(arr[i], radix).toString(2),
                        size
                      )),
                        i++;
                    return ((str = str.substr(-bits)).match(/0/g) || [])
                      .length === str.length
                      ? null
                      : str;
                  }
                  if ("function" == typeof require)
                    return function (bits) {
                      for (
                        var bytes = Math.ceil(bits / 8), str = null;
                        null === str;

                      )
                        str = construct(
                          bits,
                          require("crypto").randomBytes(bytes).toString("hex"),
                          16,
                          4
                        );
                      return str;
                    };
                  if (
                    GLOBAL.crypto &&
                    "function" == typeof GLOBAL.crypto.getRandomValues &&
                    "function" == typeof GLOBAL.Uint32Array
                  )
                    return (
                      (crypto = GLOBAL.crypto),
                      function (bits) {
                        for (
                          var elems = Math.ceil(bits / 32),
                            str = null,
                            arr = new GLOBAL.Uint32Array(elems);
                          null === str;

                        )
                          crypto.getRandomValues(arr),
                            (str = construct(bits, arr, 10, 32));
                        return str;
                      }
                    );
                  (config.unsafePRNG = !0), warn();
                  var max = Math.pow(2, 32) - 1;
                  return function (bits) {
                    for (
                      var elems = Math.ceil(bits / 32), arr = [], str = null;
                      null === str;

                    ) {
                      for (var i = 0; i < elems; i++)
                        arr[i] = Math.floor(securedMathRandom() * max + 1);
                      str = construct(bits, arr, 10, 32);
                    }
                    return str;
                  };
                })()) ||
              "string" != typeof rng(config.bits) ||
              !parseInt(rng(config.bits), 2) ||
              rng(config.bits).length > config.bits ||
              rng(config.bits).length < config.bits)
          )
            throw new Error(
              "Random number generator is invalid. Supply an RNG of the form function(bits){} that returns a string containing 'bits' number of random 1's and 0's."
            );
          return (
            (config.rng = rng), (config.alert = !!alert), !!config.unsafePRNG
          );
        }),
        (SecretShare.random = function (bits) {
          if (
            (isSetRNG() || this.setRNG(),
            "number" != typeof bits || bits % 1 != 0 || bits < 2)
          )
            throw new Error(
              "Number of bits must be an integer greater than 1."
            );
          return config.unsafePRNG && warn(), bin2hex(config.rng(bits));
        }),
        (SecretShare.share = function (
          secret,
          numShares,
          threshold,
          padLength,
          withoutPrefix
        ) {
          if (
            (isInited() || this.init(),
            isSetRNG() || this.setRNG(),
            (padLength = padLength || 0),
            "string" != typeof secret)
          )
            throw new Error("Secret must be a string.");
          if (
            "number" != typeof numShares ||
            numShares % 1 != 0 ||
            numShares < 2
          )
            throw new Error(
              "Number of shares must be an integer between 2 and 2^bits-1 (" +
                config.max +
                "), inclusive."
            );
          if (numShares > config.max) {
            var neededBits = Math.ceil(Math.log(numShares + 1) / Math.LN2);
            throw new Error(
              "Number of shares must be an integer between 2 and 2^bits-1 (" +
                config.max +
                "), inclusive. To create " +
                numShares +
                " shares, use at least " +
                neededBits +
                " bits."
            );
          }
          if (
            "number" != typeof threshold ||
            threshold % 1 != 0 ||
            threshold < 2
          )
            throw new Error(
              "Threshold number of shares must be an integer between 2 and 2^bits-1 (" +
                config.max +
                "), inclusive."
            );
          if (threshold > config.max) {
            neededBits = Math.ceil(Math.log(threshold + 1) / Math.LN2);
            throw new Error(
              "Threshold number of shares must be an integer between 2 and 2^bits-1 (" +
                config.max +
                "), inclusive.  To use a threshold of " +
                threshold +
                ", use at least " +
                neededBits +
                " bits."
            );
          }
          if ("number" != typeof padLength || padLength % 1 != 0)
            throw new Error(
              "Zero-pad length must be an integer greater than 1."
            );
          config.unsafePRNG && warn(),
            (secret = split((secret = "1" + hex2bin(secret)), padLength));
          for (
            var x = new Array(numShares),
              y = new Array(numShares),
              i = 0,
              len = secret.length;
            i < len;
            i++
          )
            for (
              var subShares = this._getShares(secret[i], numShares, threshold),
                j = 0;
              j < numShares;
              j++
            )
              (x[j] = x[j] || subShares[j].x.toString(config.radix)),
                (y[j] =
                  padLeft(subShares[j].y.toString(2)) + (y[j] ? y[j] : ""));
          var padding = config.max.toString(config.radix).length;
          if (withoutPrefix)
            for (i = 0; i < numShares; i++) x[i] = bin2hex(y[i]);
          else
            for (i = 0; i < numShares; i++)
              x[i] =
                config.bits.toString(36).toUpperCase() +
                padLeft(x[i], padding) +
                bin2hex(y[i]);
          return x;
        }),
        (SecretShare._getShares = function (secret, numShares, threshold) {
          for (var shares = [], coeffs = [secret], i = 1; i < threshold; i++)
            coeffs[i] = parseInt(config.rng(config.bits), 2);
          i = 1;
          for (var len = numShares + 1; i < len; i++)
            shares[i - 1] = { x: i, y: horner(i, coeffs) };
          return shares;
        }),
        (SecretShare._processShare = processShare),
        (SecretShare.combine = function (shares) {
          return combine(0, shares);
        }),
        (SecretShare.newShare = function (id, shares) {
          "string" == typeof id && (id = parseInt(id, config.radix));
          var share = processShare(shares[0]),
            max = Math.pow(2, share.bits) - 1;
          if ("number" != typeof id || id % 1 != 0 || id < 1 || id > max)
            throw new Error(
              "Share id must be an integer between 1 and " +
                config.max +
                ", inclusive."
            );
          var padding = max.toString(config.radix).length;
          return (
            config.bits.toString(36).toUpperCase() +
            padLeft(id.toString(config.radix), padding) +
            combine(id, shares)
          );
        }),
        (SecretShare._lagrange = lagrange),
        (SecretShare.str2hex = function (str, bytesPerChar) {
          if ("string" != typeof str)
            throw new Error("Input must be a character string.");
          if (
            "number" !=
              typeof (bytesPerChar = bytesPerChar || defaults.bytesPerChar) ||
            bytesPerChar % 1 != 0 ||
            bytesPerChar < 1 ||
            bytesPerChar > defaults.maxBytesPerChar
          )
            throw new Error(
              "Bytes per character must be an integer between 1 and " +
                defaults.maxBytesPerChar +
                ", inclusive."
            );
          for (
            var num,
              hexChars = 2 * bytesPerChar,
              max = Math.pow(16, hexChars) - 1,
              out = "",
              i = 0,
              len = str.length;
            i < len;
            i++
          ) {
            if (((num = str[i].charCodeAt()), isNaN(num)))
              throw new Error("Invalid character: " + str[i]);
            if (num > max) {
              var neededBytes = Math.ceil(Math.log(num + 1) / Math.log(256));
              throw new Error(
                "Invalid character code (" +
                  num +
                  "). Maximum allowable is 256^bytes-1 (" +
                  max +
                  "). To convert this character, use at least " +
                  neededBytes +
                  " bytes."
              );
            }
            out = padLeft(num.toString(16), hexChars) + out;
          }
          return out;
        }),
        (SecretShare.hex2str = function (str, bytesPerChar) {
          if ("string" != typeof str)
            throw new Error("Input must be a hexadecimal string.");
          if (
            "number" !=
              typeof (bytesPerChar = bytesPerChar || defaults.bytesPerChar) ||
            bytesPerChar % 1 != 0 ||
            bytesPerChar < 1 ||
            bytesPerChar > defaults.maxBytesPerChar
          )
            throw new Error(
              "Bytes per character must be an integer between 1 and " +
                defaults.maxBytesPerChar +
                ", inclusive."
            );
          for (
            var hexChars = 2 * bytesPerChar,
              out = "",
              i = 0,
              len = (str = padLeft(str, hexChars)).length;
            i < len;
            i += hexChars
          )
            out =
              String.fromCharCode(parseInt(str.slice(i, i + hexChars), 16)) +
              out;
          return out;
        }),
        SecretShare.init();
    })(),
    (GLOBAL.BuildKBucket = function KBucket(options = {}) {
      if (!(this instanceof KBucket)) return new KBucket(options);
      (this.localNodeId =
        options.localNodeId || getRandomBytes(new Uint8Array(20))),
        (this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20),
        (this.numberOfNodesToPing = options.numberOfNodesToPing || 3),
        (this.distance = options.distance || this.distance),
        (this.arbiter = options.arbiter || this.arbiter),
        (this.metadata = Object.assign({}, options.metadata)),
        (this.createNode = function () {
          return { contacts: [], dontSplit: !1, left: null, right: null };
        }),
        (this.ensureInt8 = function (name, val) {
          if (!(val instanceof Uint8Array))
            throw new TypeError(name + " is not a Uint8Array");
        }),
        (this.arrayEquals = function (array1, array2) {
          if (array1 === array2) return !0;
          if (array1.length !== array2.length) return !1;
          for (let i = 0, length = array1.length; i < length; ++i)
            if (array1[i] !== array2[i]) return !1;
          return !0;
        }),
        this.ensureInt8("option.localNodeId as parameter 1", this.localNodeId),
        (this.root = this.createNode()),
        (this.arbiter = function (incumbent, candidate) {
          return incumbent.vectorClock > candidate.vectorClock
            ? incumbent
            : candidate;
        }),
        (this.distance = function (firstId, secondId) {
          let distance = 0,
            i = 0;
          const min = Math.min(firstId.length, secondId.length),
            max = Math.max(firstId.length, secondId.length);
          for (; i < min; ++i)
            distance = 256 * distance + (firstId[i] ^ secondId[i]);
          for (; i < max; ++i) distance = 256 * distance + 255;
          return distance;
        }),
        (this.add = function (contact) {
          this.ensureInt8("contact.id", (contact || {}).id);
          let bitIndex = 0,
            node = this.root;
          for (; null === node.contacts; )
            node = this._determineNode(node, contact.id, bitIndex++);
          const index = this._indexOf(node, contact.id);
          return index >= 0
            ? (this._update(node, index, contact), this)
            : node.contacts.length < this.numberOfNodesPerKBucket
            ? (node.contacts.push(contact), this)
            : node.dontSplit
            ? this
            : (this._split(node, bitIndex), this.add(contact));
        }),
        (this.closest = function (id, n = 1 / 0) {
          if (
            (this.ensureInt8("id", id),
            (!Number.isInteger(n) && n !== 1 / 0) || n <= 0)
          )
            throw new TypeError("n is not positive number");
          let contacts = [];
          for (
            let nodes = [this.root], bitIndex = 0;
            nodes.length > 0 && contacts.length < n;

          ) {
            const node = nodes.pop();
            if (null === node.contacts) {
              const detNode = this._determineNode(node, id, bitIndex++);
              nodes.push(node.left === detNode ? node.right : node.left),
                nodes.push(detNode);
            } else contacts = contacts.concat(node.contacts);
          }
          return contacts
            .map((a) => [this.distance(a.id, id), a])
            .sort((a, b) => a[0] - b[0])
            .slice(0, n)
            .map((a) => a[1]);
        }),
        (this.count = function () {
          let count = 0;
          for (const nodes = [this.root]; nodes.length > 0; ) {
            const node = nodes.pop();
            null === node.contacts
              ? nodes.push(node.right, node.left)
              : (count += node.contacts.length);
          }
          return count;
        }),
        (this._determineNode = function (node, id, bitIndex) {
          const bytesDescribedByBitIndex = bitIndex >> 3,
            bitIndexWithinByte = bitIndex % 8;
          return id.length <= bytesDescribedByBitIndex &&
            0 !== bitIndexWithinByte
            ? node.left
            : id[bytesDescribedByBitIndex] & (1 << (7 - bitIndexWithinByte))
            ? node.right
            : node.left;
        }),
        (this.get = function (id) {
          this.ensureInt8("id", id);
          let bitIndex = 0,
            node = this.root;
          for (; null === node.contacts; )
            node = this._determineNode(node, id, bitIndex++);
          const index = this._indexOf(node, id);
          return index >= 0 ? node.contacts[index] : null;
        }),
        (this._indexOf = function (node, id) {
          for (let i = 0; i < node.contacts.length; ++i)
            if (this.arrayEquals(node.contacts[i].id, id)) return i;
          return -1;
        }),
        (this.remove = function (id) {
          this.ensureInt8("the id as parameter 1", id);
          let bitIndex = 0,
            node = this.root;
          for (; null === node.contacts; )
            node = this._determineNode(node, id, bitIndex++);
          const index = this._indexOf(node, id);
          return index >= 0 && node.contacts.splice(index, 1)[0], this;
        }),
        (this._split = function (node, bitIndex) {
          (node.left = this.createNode()), (node.right = this.createNode());
          for (const contact of node.contacts)
            this._determineNode(node, contact.id, bitIndex).contacts.push(
              contact
            );
          node.contacts = null;
          const detNode = this._determineNode(node, this.localNodeId, bitIndex);
          (node.left === detNode ? node.right : node.left).dontSplit = !0;
        }),
        (this.toArray = function () {
          let result = [];
          for (const nodes = [this.root]; nodes.length > 0; ) {
            const node = nodes.pop();
            null === node.contacts
              ? nodes.push(node.right, node.left)
              : (result = result.concat(node.contacts));
          }
          return result;
        }),
        (this._update = function (node, index, contact) {
          if (!this.arrayEquals(node.contacts[index].id, contact.id))
            throw new Error("wrong index for _update");
          const incumbent = node.contacts[index],
            selection = this.arbiter(incumbent, contact);
          (selection === incumbent && incumbent !== contact) ||
            (node.contacts.splice(index, 1), node.contacts.push(selection));
        });
    });
})("undefined" != typeof global ? global : window);