@zohocorporation/vault-cli 1.1.2

package/out/js/crypto/rsa.js

@@ -0,0 +1,1945 @@
+// Depends on jsbn.js and rng.js
+// Version 1.1: support utf-8 encoding in pkcs1pad2
+// convert a (hex) string to a bignum object
+/*function parseBigInt(str,r) {
+  return new BigInteger(str,r);
+}*/
+//
+// function linebrk(s,n) {
+//   var ret = "";
+//   var i = 0;
+//   while(i + n < s.length) {
+//     ret += s.substring(i,i+n) + "\n";
+//     i += n;
+//   }
+//   return ret + s.substring(i,s.length);
+// }
+//
+// function byte2Hex(b) {
+//   if(b < 0x10)
+//     return "0" + b.toString(16);
+//   else
+//     return b.toString(16);
+// }
+// PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
+/*function pkcs1pad2(s,n) {
+  if(n < s.length + 11) { // TODO: fix for utf-8
+    alert("Message too long for RSA");
+    return null;
+  }
+  var ba = new Array();
+  var i = s.length - 1;
+  while(i >= 0 && n > 0) {
+    var c = s.charCodeAt(i--);
+    if(c < 128) { // encode using utf-8
+      ba[--n] = c;
+    }
+    else if((c > 127) && (c < 2048)) {
+      ba[--n] = (c & 63) | 128;
+      ba[--n] = (c >> 6) | 192;
+    }
+    else {
+      ba[--n] = (c & 63) | 128;
+      ba[--n] = ((c >> 6) & 63) | 128;
+      ba[--n] = (c >> 12) | 224;
+    }
+  }
+  ba[--n] = 0;
+  var rng = new SecureRandom();
+  var x = new Array();
+  while(n > 2) { // random non-zero pad
+    x[0] = 0;
+    while(x[0] == 0) rng.nextBytes(x);
+    ba[--n] = x[0];
+  }
+  ba[--n] = 2;
+  ba[--n] = 0;
+  return new BigInteger(ba);
+}*/
+// "empty" RSA key constructor
+/*function RSAKey() {
+  this.n = null;
+  this.e = 0;
+  this.d = null;
+  this.p = null;
+  this.q = null;
+  this.dmp1 = null;
+  this.dmq1 = null;
+  this.coeff = null;
+}*/
+/*
+// Set the public key fields N and e from hex strings
+function RSASetPublic(N,E) {
+  if(N != null && E != null && N.length > 0 && E.length > 0) {
+    this.n = parseBigInt(N,16);
+    this.e = parseInt(E,16);
+  }
+  else
+    alert("Invalid RSA public key");
+}
+
+// Perform raw public operation on "x": return x^e (mod n)
+function RSADoPublic(x) {
+  return x.modPowInt(this.e, this.n);
+}
+
+// Return the PKCS#1 RSA encryption of "text" as an even-length hex string
+function RSAEncrypt(text) {
+  var m = pkcs1pad2(text,(this.n.bitLength()+7)>>3);
+  if(m == null) return null;
+  var c = this.doPublic(m);
+  if(c == null) return null;
+  var h = c.toString(16);
+  if((h.length & 1) == 0) return h; else return "0" + h;
+}*/
+// Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
+//function RSAEncryptB64(text) {
+//  var h = this.encrypt(text);
+//  if(h) return hex2b64(h); else return null;
+//}
+// protected
+// RSAKey.prototype.doPublic = RSADoPublic;
+// public
+// RSAKey.prototype.setPublic = RSASetPublic;
+// RSAKey.prototype.encrypt = RSAEncrypt;
+//RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
+let navigator = {};
+navigator.appName = "";
+function 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);
+}
+function am1(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;
+}
+function am2(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;
+        (l = xl * l + ((32767 & m) << 15) + w[j] + (1073741823 & c)),
+            (c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)),
+            (w[j++] = 1073741823 & l);
+    }
+    return c;
+}
+function am3(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;
+        (l = xl * l + ((16383 & m) << 14) + w[j] + c),
+            (c = (l >> 28) + (m >> 14) + xh * h),
+            (w[j++] = 268435455 & l);
+    }
+    return c;
+}
+function int2char(n) {
+    return BI_RM.charAt(n);
+}
+function intAt(s, i) {
+    var c = BI_RC[s.charCodeAt(i)];
+    return null == c ? -1 : c;
+}
+function bnpCopyTo(r) {
+    for (var i = this.t - 1; i >= 0; --i)
+        r[i] = this[i];
+    (r.t = this.t), (r.s = this.s);
+}
+function bnpFromInt(x) {
+    (this.t = 1),
+        (this.s = 0 > x ? -1 : 0),
+        x > 0 ? (this[0] = x) : -1 > x ? (this[0] = x + DV) : (this.t = 0);
+}
+function nbv(i) {
+    var r = nbi();
+    return r.fromInt(i), r;
+}
+function bnpFromString(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);
+        0 > x
+            ? "-" == 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),
+                sh >= 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);
+}
+function bnpClamp() {
+    for (var c = this.s & this.DM; this.t > 0 && this[this.t - 1] == c;)
+        --this.t;
+}
+function bnToString(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;)
+            k > p
+                ? ((d = (this[i] & ((1 << p) - 1)) << (k - p)),
+                    (d |= this[--i] >> (p += this.DB - k)))
+                : ((d = (this[i] >> (p -= k)) & km), 0 >= p && ((p += this.DB), --i)),
+                d > 0 && (m = !0),
+                m && (r += int2char(d));
+    return m ? r : "0";
+}
+function bnNegate() {
+    var r = nbi();
+    return BigInteger.ZERO.subTo(this, r), r;
+}
+function bnAbs() {
+    return this.s < 0 ? this.negate() : this;
+}
+function bnCompareTo(a) {
+    var r = this.s - a.s;
+    if (0 != r)
+        return r;
+    var i = this.t;
+    if (((r = i - a.t), 0 != r))
+        return r;
+    for (; --i >= 0;)
+        if (0 != (r = this[i] - a[i]))
+            return r;
+    return 0;
+}
+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 bnBitLength() {
+    return this.t <= 0
+        ? 0
+        : this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM));
+}
+function bnpDLShiftTo(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);
+}
+function bnpDRShiftTo(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);
+}
+function bnpLShiftTo(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();
+}
+function bnpRShiftTo(n, r) {
+    r.s = this.s;
+    var ds = Math.floor(n / this.DB);
+    if (ds >= this.t)
+        return void (r.t = 0);
+    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();
+}
+function bnpSubTo(a, r) {
+    for (var i = 0, c = 0, m = Math.min(a.t, this.t); m > i;)
+        (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 = 0 > c ? -1 : 0),
+        -1 > c ? (r[i++] = this.DV + c) : c > 0 && (r[i++] = c),
+        (r.t = i),
+        r.clamp();
+}
+function bnpMultiplyTo(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);
+}
+function bnpSquareTo(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();
+}
+function bnpDivRemTo(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),
+                0 > ts && BigInteger.ZERO.subTo(r, r);
+        }
+    }
+}
+function bnMod(a) {
+    var r = nbi();
+    return (this.abs().divRemTo(a, null, r),
+        this.s < 0 && r.compareTo(BigInteger.ZERO) > 0 && a.subTo(r, r),
+        r);
+}
+function Classic(m) {
+    this.m = m;
+}
+function cConvert(x) {
+    return x.s < 0 || x.compareTo(this.m) >= 0 ? x.mod(this.m) : x;
+}
+function cRevert(x) {
+    return x;
+}
+function cReduce(x) {
+    x.divRemTo(this.m, null, x);
+}
+function cMulTo(x, y, r) {
+    x.multiplyTo(y, r), this.reduce(r);
+}
+function cSqrTo(x, r) {
+    x.squareTo(r), this.reduce(r);
+}
+function bnpInvDigit() {
+    if (this.t < 1)
+        return 0;
+    var x = this[0];
+    if (0 == (1 & x))
+        return 0;
+    var y = 3 & x;
+    return ((y = (y * (2 - (15 & x) * y)) & 15),
+        (y = (y * (2 - (255 & x) * y)) & 255),
+        (y = (y * (2 - (((65535 & x) * y) & 65535))) & 65535),
+        (y = (y * (2 - ((x * y) % this.DV))) % this.DV),
+        y > 0 ? this.DV - y : -y);
+}
+function Montgomery(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);
+}
+function montConvert(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);
+}
+function montRevert(x) {
+    var r = nbi();
+    return x.copyTo(r), this.reduce(r), r;
+}
+function montReduce(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 (j = i + this.m.t, x[j] += 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);
+}
+function montSqrTo(x, r) {
+    x.squareTo(r), this.reduce(r);
+}
+function montMulTo(x, y, r) {
+    x.multiplyTo(y, r), this.reduce(r);
+}
+function bnpIsEven() {
+    return 0 == (this.t > 0 ? 1 & this[0] : this.s);
+}
+function bnpExp(e, z) {
+    if (e > 4294967295 || 1 > e)
+        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);
+}
+function bnModPowInt(e, m) {
+    var z;
+    return ((z = 256 > e || m.isEven() ? new Classic(m) : new Montgomery(m)),
+        this.exp(e, z));
+}
+function bnClone() {
+    var r = nbi();
+    return this.copyTo(r), r;
+}
+function bnIntValue() {
+    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];
+}
+function bnByteValue() {
+    return 0 == this.t ? this.s : (this[0] << 24) >> 24;
+}
+function bnShortValue() {
+    return 0 == this.t ? this.s : (this[0] << 16) >> 16;
+}
+function bnpChunkSize(r) {
+    return Math.floor((Math.LN2 * this.DB) / Math.log(r));
+}
+function bnSigNum() {
+    return this.s < 0 ? -1 : this.t <= 0 || (1 == this.t && this[0] <= 0) ? 0 : 1;
+}
+function bnpToRadix(b) {
+    if ((null == b && (b = 10), 0 == this.signum() || 2 > b || 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;
+}
+function bnpFromRadix(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);
+        0 > x
+            ? "-" == 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);
+}
+function bnpFromNumber(a, b, c) {
+    if ("number" == typeof b)
+        if (2 > a)
+            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 = (a >> 3) + 1),
+            b.nextBytes(x),
+            t > 0 ? (x[0] &= (1 << t) - 1) : (x[0] = 0),
+            this.fromString(x, 256);
+    }
+}
+function bnToByteArray() {
+    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;)
+            8 > p
+                ? ((d = (this[i] & ((1 << p) - 1)) << (8 - p)),
+                    (d |= this[--i] >> (p += this.DB - 8)))
+                : ((d = (this[i] >> (p -= 8)) & 255), 0 >= p && ((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;
+}
+function bnEquals(a) {
+    return 0 == this.compareTo(a);
+}
+function bnMin(a) {
+    return this.compareTo(a) < 0 ? this : a;
+}
+function bnMax(a) {
+    return this.compareTo(a) > 0 ? this : a;
+}
+function bnpBitwiseTo(a, op, r) {
+    var i, f, m = Math.min(a.t, this.t);
+    for (i = 0; m > i; ++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();
+}
+function op_and(x, y) {
+    return x & y;
+}
+function bnAnd(a) {
+    var r = nbi();
+    return this.bitwiseTo(a, op_and, r), r;
+}
+function op_or(x, y) {
+    return x | y;
+}
+function bnOr(a) {
+    var r = nbi();
+    return this.bitwiseTo(a, op_or, r), r;
+}
+function op_xor(x, y) {
+    return x ^ y;
+}
+function bnXor(a) {
+    var r = nbi();
+    return this.bitwiseTo(a, op_xor, r), r;
+}
+function op_andnot(x, y) {
+    return x & ~y;
+}
+function bnAndNot(a) {
+    var r = nbi();
+    return this.bitwiseTo(a, op_andnot, r), r;
+}
+function bnNot() {
+    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;
+}
+function bnShiftLeft(n) {
+    var r = nbi();
+    return 0 > n ? this.rShiftTo(-n, r) : this.lShiftTo(n, r), r;
+}
+function bnShiftRight(n) {
+    var r = nbi();
+    return 0 > n ? this.lShiftTo(-n, r) : this.rShiftTo(n, r), 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 bnGetLowestSetBit() {
+    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;
+}
+function cbit(x) {
+    for (var r = 0; 0 != x;)
+        (x &= x - 1), ++r;
+    return r;
+}
+function bnBitCount() {
+    for (var r = 0, x = this.s & this.DM, i = 0; i < this.t; ++i)
+        r += cbit(this[i] ^ x);
+    return r;
+}
+function bnTestBit(n) {
+    var j = Math.floor(n / this.DB);
+    return j >= this.t ? 0 != this.s : 0 != (this[j] & (1 << n % this.DB));
+}
+function bnpChangeBit(n, op) {
+    var r = BigInteger.ONE.shiftLeft(n);
+    return this.bitwiseTo(r, op, r), r;
+}
+function bnSetBit(n) {
+    return this.changeBit(n, op_or);
+}
+function bnClearBit(n) {
+    return this.changeBit(n, op_andnot);
+}
+function bnFlipBit(n) {
+    return this.changeBit(n, op_xor);
+}
+function bnpAddTo(a, r) {
+    for (var i = 0, c = 0, m = Math.min(a.t, this.t); m > i;)
+        (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 = 0 > c ? -1 : 0),
+        c > 0 ? (r[i++] = c) : -1 > c && (r[i++] = this.DV + c),
+        (r.t = i),
+        r.clamp();
+}
+function bnAdd(a) {
+    var r = nbi();
+    return this.addTo(a, r), r;
+}
+function bnSubtract(a) {
+    var r = nbi();
+    return this.subTo(a, r), r;
+}
+function bnMultiply(a) {
+    var r = nbi();
+    return this.multiplyTo(a, r), r;
+}
+function bnDivide(a) {
+    var r = nbi();
+    return this.divRemTo(a, r, null), r;
+}
+function bnRemainder(a) {
+    var r = nbi();
+    return this.divRemTo(a, null, r), r;
+}
+function bnDivideAndRemainder(a) {
+    var q = nbi(), r = nbi();
+    return this.divRemTo(a, q, r), new Array(q, r);
+}
+function bnpDMultiply(n) {
+    (this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)),
+        ++this.t,
+        this.clamp();
+}
+function bnpDAddOffset(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];
+    }
+}
+function NullExp() { }
+function nNop(x) {
+    return x;
+}
+function nMulTo(x, y, r) {
+    x.multiplyTo(y, r);
+}
+function nSqrTo(x, r) {
+    x.squareTo(r);
+}
+function bnPow(e) {
+    return this.exp(e, new NullExp());
+}
+function bnpMultiplyLowerTo(a, n, r) {
+    var i = Math.min(this.t + a.t, n);
+    for (r.s = 0, r.t = i; i > 0;)
+        r[--i] = 0;
+    var j;
+    for (j = r.t - this.t; j > i; ++i)
+        r[i + this.t] = this.am(0, a[i], r, i, 0, this.t);
+    for (j = Math.min(a.t, n); j > i; ++i)
+        this.am(0, a[i], r, i, 0, n - i);
+    r.clamp();
+}
+function bnpMultiplyUpperTo(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);
+}
+function Barrett(m) {
+    (this.r2 = nbi()),
+        (this.q3 = nbi()),
+        BigInteger.ONE.dlShiftTo(2 * m.t, this.r2),
+        (this.mu = this.r2.divide(m)),
+        (this.m = m);
+}
+function barrettConvert(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;
+}
+function barrettRevert(x) {
+    return x;
+}
+function barrettReduce(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);
+}
+function barrettSqrTo(x, r) {
+    x.squareTo(r), this.reduce(r);
+}
+function barrettMulTo(x, y, r) {
+    x.multiplyTo(y, r), this.reduce(r);
+}
+function bnModPow(e, m) {
+    var k, z, i = e.bitLength(), r = nbv(1);
+    if (0 >= i)
+        return r;
+    (k = 18 > i ? 1 : 48 > i ? 3 : 144 > i ? 4 : 768 > i ? 5 : 6),
+        (z =
+            8 > i ? 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); km >= n;)
+            (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);
+}
+function bnGCD(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 (0 > g)
+        return x;
+    for (g > i && (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;
+}
+function bnpModInt(n) {
+    if (0 >= n)
+        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;
+}
+function bnModInverse(m) {
+    var ac = m.isEven();
+    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));
+    }
+    return 0 != v.compareTo(BigInteger.ONE)
+        ? BigInteger.ZERO
+        : d.compareTo(m) >= 0
+            ? d.subtract(m)
+            : d.signum() < 0
+                ? (d.addTo(m, d), d.signum() < 0 ? d.add(m) : d)
+                : d;
+}
+function bnIsProbablePrime(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 && lplim > m;)
+            m *= lowprimes[j++];
+        for (m = x.modInt(m); j > i;)
+            if (m % lowprimes[i++] == 0)
+                return !1;
+    }
+    return x.millerRabin(t);
+}
+function bnpMillerRabin(t) {
+    var n1 = this.subtract(BigInteger.ONE), k = n1.getLowestSetBit();
+    if (0 >= k)
+        return !1;
+    var r = n1.shiftRight(k);
+    (t = (t + 1) >> 1), t > lowprimes.length && (t = lowprimes.length);
+    for (var a = nbi(), i = 0; t > i; ++i) {
+        a.fromInt(lowprimes[i]);
+        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 (((y = y.modPowInt(2, this)), 0 == y.compareTo(BigInteger.ONE)))
+                    return !1;
+            if (0 != y.compareTo(n1))
+                return !1;
+        }
+    }
+    return !0;
+}
+function Arcfour() {
+    (this.i = 0), (this.j = 0), (this.S = new Array());
+}
+function ARC4init(key) {
+    var i, j, t;
+    for (i = 0; 256 > i; ++i)
+        this.S[i] = i;
+    for (j = 0, i = 0; 256 > i; ++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);
+}
+function ARC4next() {
+    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]);
+}
+function prng_newstate() {
+    return new Arcfour();
+}
+function rng_seed_int(x) {
+    (rng_pool[rng_pptr++] ^= 255 & x),
+        (rng_pool[rng_pptr++] ^= (x >> 8) & 255),
+        (rng_pool[rng_pptr++] ^= (x >> 16) & 255),
+        (rng_pool[rng_pptr++] ^= (x >> 24) & 255),
+        rng_pptr >= rng_psize && (rng_pptr -= rng_psize);
+}
+function rng_seed_time() {
+    rng_seed_int(new Date().getTime());
+}
+function rng_get_byte() {
+    if (null == rng_state) {
+        for (rng_seed_time(),
+            rng_state = prng_newstate(),
+            rng_state.init(rng_pool),
+            rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
+            rng_pool[rng_pptr] = 0;
+        rng_pptr = 0;
+    }
+    return rng_state.next();
+}
+function rng_get_bytes(ba) {
+    var i;
+    for (i = 0; i < ba.length; ++i)
+        ba[i] = rng_get_byte();
+}
+function SecureRandom() { }
+function parseBigInt(str, r) {
+    return new BigInteger(str, r);
+}
+function linebrk(s, n) {
+    for (var ret = "", i = 0; i + n < s.length;)
+        (ret += s.substring(i, i + n) + "\n"), (i += n);
+    return ret + s.substring(i, s.length);
+}
+function byte2Hex(b) {
+    return 16 > b ? "0" + b.toString(16) : b.toString(16);
+}
+function pkcs1pad2(s, n) {
+    if (n < s.length + 11)
+        return alert("Message too long for RSA"), null;
+    for (var ba = new Array(), i = s.length - 1; i >= 0 && n > 0;) {
+        var c = s.charCodeAt(i--);
+        128 > c
+            ? (ba[--n] = c)
+            : c > 127 && 2048 > c
+                ? ((ba[--n] = (63 & c) | 128), (ba[--n] = (c >> 6) | 192))
+                : ((ba[--n] = (63 & c) | 128),
+                    (ba[--n] = ((c >> 6) & 63) | 128),
+                    (ba[--n] = (c >> 12) | 224));
+    }
+    ba[--n] = 0;
+    for (var rng = new SecureRandom(), x = new Array(); n > 2;) {
+        for (x[0] = 0; 0 == x[0];)
+            rng.nextBytes(x);
+        ba[--n] = x[0];
+    }
+    return (ba[--n] = 2), (ba[--n] = 0), new BigInteger(ba);
+}
+function RSAKey() {
+    (this.n = null),
+        (this.e = 0),
+        (this.d = null),
+        (this.p = null),
+        (this.q = null),
+        (this.dmp1 = null),
+        (this.dmq1 = null),
+        (this.coeff = null);
+}
+function RSASetPublic(N, E) {
+    null != N && null != E && N.length > 0 && E.length > 0
+        ? ((this.n = parseBigInt(N, 16)), (this.e = parseInt(E, 16)))
+        : alert("Invalid RSA public key");
+}
+function RSADoPublic(x) {
+    return x.modPowInt(this.e, this.n);
+}
+function RSAEncrypt(text) {
+    var m = pkcs1pad2(text, (this.n.bitLength() + 7) >> 3);
+    if (null == m)
+        return null;
+    var c = this.doPublic(m);
+    if (null == c)
+        return null;
+    var h = c.toString(16);
+    return 0 == (1 & h.length) ? h : "0" + h;
+}
+function pkcs1unpad2(d, n) {
+    for (var b = d.toByteArray(), i = 0; i < b.length && 0 == b[i];)
+        ++i;
+    if (b.length - i != n - 1 || 2 != b[i])
+        return null;
+    for (++i; 0 != b[i];)
+        if (++i >= b.length)
+            return null;
+    for (var ret = ""; ++i < b.length;) {
+        var c = 255 & b[i];
+        128 > c
+            ? (ret += String.fromCharCode(c))
+            : c > 191 && 224 > c
+                ? ((ret += String.fromCharCode(((31 & c) << 6) | (63 & b[i + 1]))), ++i)
+                : ((ret += String.fromCharCode(((15 & c) << 12) | ((63 & b[i + 1]) << 6) | (63 & b[i + 2]))),
+                    (i += 2));
+    }
+    return ret;
+}
+function RSASetPrivate(N, E, D) {
+    null != N && null != E && N.length > 0 && E.length > 0
+        ? ((this.n = parseBigInt(N, 16)),
+            (this.e = parseInt(E, 16)),
+            (this.d = parseBigInt(D, 16)))
+        : alert("Invalid RSA private key");
+}
+function RSASetPrivateEx(N, E, D, P, Q, DP, DQ, C) {
+    null != N && null != E && N.length > 0 && E.length > 0
+        ? ((this.n = parseBigInt(N, 16)),
+            (this.e = parseInt(E, 16)),
+            (this.d = parseBigInt(D, 16)),
+            (this.p = parseBigInt(P, 16)),
+            (this.q = parseBigInt(Q, 16)),
+            (this.dmp1 = parseBigInt(DP, 16)),
+            (this.dmq1 = parseBigInt(DQ, 16)),
+            (this.coeff = parseBigInt(C, 16)))
+        : alert("Invalid RSA private key");
+}
+function RSAGenerate(B, E) {
+    var rng = new SecureRandom(), qs = B >> 1;
+    this.e = parseInt(E, 16);
+    for (var ee = new BigInteger(E, 16);;) {
+        for (; (this.p = new BigInteger(B - qs, 1, rng)),
+            0 !=
+                this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) ||
+                !this.p.isProbablePrime(10);)
+            ;
+        for (; (this.q = new BigInteger(qs, 1, rng)),
+            0 !=
+                this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) ||
+                !this.q.isProbablePrime(10);)
+            ;
+        if (this.p.compareTo(this.q) <= 0) {
+            var t = this.p;
+            (this.p = this.q), (this.q = t);
+        }
+        var p1 = this.p.subtract(BigInteger.ONE), q1 = this.q.subtract(BigInteger.ONE), phi = p1.multiply(q1);
+        if (0 == phi.gcd(ee).compareTo(BigInteger.ONE)) {
+            (this.n = this.p.multiply(this.q)),
+                (this.d = ee.modInverse(phi)),
+                (this.dmp1 = this.d.mod(p1)),
+                (this.dmq1 = this.d.mod(q1)),
+                (this.coeff = this.q.modInverse(this.p));
+            break;
+        }
+    }
+}
+function RSADoPrivate(x) {
+    if (null == this.p || null == this.q)
+        return x.modPow(this.d, this.n);
+    for (var xp = x.mod(this.p).modPow(this.dmp1, this.p), xq = x.mod(this.q).modPow(this.dmq1, this.q); xp.compareTo(xq) < 0;)
+        xp = xp.add(this.p);
+    return xp
+        .subtract(xq)
+        .multiply(this.coeff)
+        .mod(this.p)
+        .multiply(this.q)
+        .add(xq);
+}
+function RSADecrypt(ctext) {
+    var c = parseBigInt(ctext, 16), m = this.doPrivate(c);
+    return null == m ? null : pkcs1unpad2(m, (this.n.bitLength() + 7) >> 3);
+}
+var dbits, canary = 0xdeadbeefcafe, j_lm = 15715070 == (16777215 & canary);
+j_lm && "Microsoft Internet Explorer" == navigator.appName
+    ? ((BigInteger.prototype.am = am2), (dbits = 30))
+    : j_lm && "Netscape" != navigator.appName
+        ? ((BigInteger.prototype.am = am1), (dbits = 26))
+        : ((BigInteger.prototype.am = am3), (dbits = 28)),
+    (BigInteger.prototype.DB = dbits),
+    (BigInteger.prototype.DM = (1 << dbits) - 1),
+    (BigInteger.prototype.DV = 1 << dbits);
+var BI_FP = 52;
+(BigInteger.prototype.FV = Math.pow(2, BI_FP)),
+    (BigInteger.prototype.F1 = BI_FP - dbits),
+    (BigInteger.prototype.F2 = 2 * dbits - BI_FP);
+var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz", BI_RC = new Array(), rr, vv;
+for (rr = "0".charCodeAt(0), vv = 0; 9 >= vv; ++vv)
+    BI_RC[rr++] = vv;
+for (rr = "a".charCodeAt(0), vv = 10; 36 > vv; ++vv)
+    BI_RC[rr++] = vv;
+for (rr = "A".charCodeAt(0), vv = 10; 36 > vv; ++vv)
+    BI_RC[rr++] = vv;
+(Classic.prototype.convert = cConvert),
+    (Classic.prototype.revert = cRevert),
+    (Classic.prototype.reduce = cReduce),
+    (Classic.prototype.mulTo = cMulTo),
+    (Classic.prototype.sqrTo = cSqrTo),
+    (Montgomery.prototype.convert = montConvert),
+    (Montgomery.prototype.revert = montRevert),
+    (Montgomery.prototype.reduce = montReduce),
+    (Montgomery.prototype.mulTo = montMulTo),
+    (Montgomery.prototype.sqrTo = montSqrTo),
+    (BigInteger.prototype.copyTo = bnpCopyTo),
+    (BigInteger.prototype.fromInt = bnpFromInt),
+    (BigInteger.prototype.fromString = bnpFromString),
+    (BigInteger.prototype.clamp = bnpClamp),
+    (BigInteger.prototype.dlShiftTo = bnpDLShiftTo),
+    (BigInteger.prototype.drShiftTo = bnpDRShiftTo),
+    (BigInteger.prototype.lShiftTo = bnpLShiftTo),
+    (BigInteger.prototype.rShiftTo = bnpRShiftTo),
+    (BigInteger.prototype.subTo = bnpSubTo),
+    (BigInteger.prototype.multiplyTo = bnpMultiplyTo),
+    (BigInteger.prototype.squareTo = bnpSquareTo),
+    (BigInteger.prototype.divRemTo = bnpDivRemTo),
+    (BigInteger.prototype.invDigit = bnpInvDigit),
+    (BigInteger.prototype.isEven = bnpIsEven),
+    (BigInteger.prototype.exp = bnpExp),
+    (BigInteger.prototype.toString = bnToString),
+    (BigInteger.prototype.negate = bnNegate),
+    (BigInteger.prototype.abs = bnAbs),
+    (BigInteger.prototype.compareTo = bnCompareTo),
+    (BigInteger.prototype.bitLength = bnBitLength),
+    (BigInteger.prototype.mod = bnMod),
+    (BigInteger.prototype.modPowInt = bnModPowInt),
+    (BigInteger.ZERO = nbv(0)),
+    (BigInteger.ONE = nbv(1)),
+    (NullExp.prototype.convert = nNop),
+    (NullExp.prototype.revert = nNop),
+    (NullExp.prototype.mulTo = nMulTo),
+    (NullExp.prototype.sqrTo = nSqrTo),
+    (Barrett.prototype.convert = barrettConvert),
+    (Barrett.prototype.revert = barrettRevert),
+    (Barrett.prototype.reduce = barrettReduce),
+    (Barrett.prototype.mulTo = barrettMulTo),
+    (Barrett.prototype.sqrTo = barrettSqrTo);
+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,
+], lplim = (1 << 26) / lowprimes[lowprimes.length - 1];
+(BigInteger.prototype.chunkSize = bnpChunkSize),
+    (BigInteger.prototype.toRadix = bnpToRadix),
+    (BigInteger.prototype.fromRadix = bnpFromRadix),
+    (BigInteger.prototype.fromNumber = bnpFromNumber),
+    (BigInteger.prototype.bitwiseTo = bnpBitwiseTo),
+    (BigInteger.prototype.changeBit = bnpChangeBit),
+    (BigInteger.prototype.addTo = bnpAddTo),
+    (BigInteger.prototype.dMultiply = bnpDMultiply),
+    (BigInteger.prototype.dAddOffset = bnpDAddOffset),
+    (BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo),
+    (BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo),
+    (BigInteger.prototype.modInt = bnpModInt),
+    (BigInteger.prototype.millerRabin = bnpMillerRabin),
+    (BigInteger.prototype.clone = bnClone),
+    (BigInteger.prototype.intValue = bnIntValue),
+    (BigInteger.prototype.byteValue = bnByteValue),
+    (BigInteger.prototype.shortValue = bnShortValue),
+    (BigInteger.prototype.signum = bnSigNum),
+    (BigInteger.prototype.toByteArray = bnToByteArray),
+    (BigInteger.prototype.equals = bnEquals),
+    (BigInteger.prototype.min = bnMin),
+    (BigInteger.prototype.max = bnMax),
+    (BigInteger.prototype.and = bnAnd),
+    (BigInteger.prototype.or = bnOr),
+    (BigInteger.prototype.xor = bnXor),
+    (BigInteger.prototype.andNot = bnAndNot),
+    (BigInteger.prototype.not = bnNot),
+    (BigInteger.prototype.shiftLeft = bnShiftLeft),
+    (BigInteger.prototype.shiftRight = bnShiftRight),
+    (BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit),
+    (BigInteger.prototype.bitCount = bnBitCount),
+    (BigInteger.prototype.testBit = bnTestBit),
+    (BigInteger.prototype.setBit = bnSetBit),
+    (BigInteger.prototype.clearBit = bnClearBit),
+    (BigInteger.prototype.flipBit = bnFlipBit),
+    (BigInteger.prototype.add = bnAdd),
+    (BigInteger.prototype.subtract = bnSubtract),
+    (BigInteger.prototype.multiply = bnMultiply),
+    (BigInteger.prototype.divide = bnDivide),
+    (BigInteger.prototype.remainder = bnRemainder),
+    (BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder),
+    (BigInteger.prototype.modPow = bnModPow),
+    (BigInteger.prototype.modInverse = bnModInverse),
+    (BigInteger.prototype.pow = bnPow),
+    (BigInteger.prototype.gcd = bnGCD),
+    (BigInteger.prototype.isProbablePrime = bnIsProbablePrime),
+    (Arcfour.prototype.init = ARC4init),
+    (Arcfour.prototype.next = ARC4next);
+var rng_psize = 256, rng_state, rng_pool, rng_pptr;
+if (null == rng_pool) {
+    (rng_pool = new Array()), (rng_pptr = 0);
+    var t;
+    if ("Netscape" == navigator.appName &&
+        navigator.appVersion < "5" &&
+        window.crypto) {
+        var z = window.crypto.random(32);
+        for (t = 0; t < z.length; ++t)
+            rng_pool[rng_pptr++] = 255 & z.charCodeAt(t);
+    }
+    for (; rng_psize > rng_pptr;)
+        (t = Math.floor(65536 * Math.random())),
+            (rng_pool[rng_pptr++] = t >>> 8),
+            (rng_pool[rng_pptr++] = 255 & t);
+    (rng_pptr = 0), rng_seed_time();
+}
+(SecureRandom.prototype.nextBytes = rng_get_bytes),
+    (RSAKey.prototype.doPublic = RSADoPublic),
+    (RSAKey.prototype.setPublic = RSASetPublic),
+    (RSAKey.prototype.encrypt = RSAEncrypt),
+    (RSAKey.prototype.doPrivate = RSADoPrivate),
+    (RSAKey.prototype.setPrivate = RSASetPrivate),
+    (RSAKey.prototype.setPrivateEx = RSASetPrivateEx),
+    (RSAKey.prototype.generate = RSAGenerate),
+    (RSAKey.prototype.decrypt = RSADecrypt);
+var CryptoJS = CryptoJS ||
+    (function (u, p) {
+        var d = {}, l = (d.lib = {}), s = function () { }, t = (l.Base = {
+            extend: function (a) {
+                s.prototype = this;
+                var c = new s();
+                return (a && c.mixIn(a),
+                    c.hasOwnProperty("init") ||
+                        (c.init = function () {
+                            c.$super.init.apply(this, arguments);
+                        }),
+                    (c.init.prototype = c),
+                    (c.$super = this),
+                    c);
+            },
+            create: function () {
+                var a = this.extend();
+                return a.init.apply(a, arguments), a;
+            },
+            init: function () { },
+            mixIn: function (a) {
+                for (var c in a)
+                    a.hasOwnProperty(c) && (this[c] = a[c]);
+                a.hasOwnProperty("toString") && (this.toString = a.toString);
+            },
+            clone: function () {
+                return this.init.prototype.extend(this);
+            },
+        }), r = (l.WordArray = t.extend({
+            init: function (a, c) {
+                (a = this.words = a || []),
+                    (this.sigBytes = c != p ? c : 4 * a.length);
+            },
+            toString: function (a) {
+                return (a || v).stringify(this);
+            },
+            concat: function (a) {
+                var c = this.words, e = a.words, j = this.sigBytes;
+                if (((a = a.sigBytes), this.clamp(), j % 4))
+                    for (var k = 0; a > k; k++)
+                        c[(j + k) >>> 2] |=
+                            ((e[k >>> 2] >>> (24 - 8 * (k % 4))) & 255) <<
+                                (24 - 8 * ((j + k) % 4));
+                else if (65535 < e.length)
+                    for (k = 0; a > k; k += 4)
+                        c[(j + k) >>> 2] = e[k >>> 2];
+                else
+                    c.push.apply(c, e);
+                return (this.sigBytes += a), this;
+            },
+            clamp: function () {
+                var a = this.words, c = this.sigBytes;
+                (a[c >>> 2] &= 4294967295 << (32 - 8 * (c % 4))),
+                    (a.length = u.ceil(c / 4));
+            },
+            clone: function () {
+                var a = t.clone.call(this);
+                return (a.words = this.words.slice(0)), a;
+            },
+            random: function (a) {
+                for (var c = [], e = 0; a > e; e += 4)
+                    c.push((4294967296 * u.random()) | 0);
+                return new r.init(c, a);
+            },
+        })), w = (d.enc = {}), v = (w.Hex = {
+            stringify: function (a) {
+                var c = a.words;
+                a = a.sigBytes;
+                for (var e = [], j = 0; a > j; j++) {
+                    var k = (c[j >>> 2] >>> (24 - 8 * (j % 4))) & 255;
+                    e.push((k >>> 4).toString(16)), e.push((15 & k).toString(16));
+                }
+                return e.join("");
+            },
+            parse: function (a) {
+                for (var c = a.length, e = [], j = 0; c > j; j += 2)
+                    e[j >>> 3] |= parseInt(a.substr(j, 2), 16) << (24 - 4 * (j % 8));
+                return new r.init(e, c / 2);
+            },
+        }), b = (w.Latin1 = {
+            stringify: function (a) {
+                var c = a.words;
+                a = a.sigBytes;
+                for (var e = [], j = 0; a > j; j++)
+                    e.push(String.fromCharCode((c[j >>> 2] >>> (24 - 8 * (j % 4))) & 255));
+                return e.join("");
+            },
+            parse: function (a) {
+                for (var c = a.length, e = [], j = 0; c > j; j++)
+                    e[j >>> 2] |= (255 & a.charCodeAt(j)) << (24 - 8 * (j % 4));
+                return new r.init(e, c);
+            },
+        }), x = (w.Utf8 = {
+            stringify: function (a) {
+                try {
+                    return decodeURIComponent(escape(b.stringify(a)));
+                }
+                catch (c) {
+                    throw Error("Malformed UTF-8 data");
+                }
+            },
+            parse: function (a) {
+                return b.parse(unescape(encodeURIComponent(a)));
+            },
+        }), q = (l.BufferedBlockAlgorithm = t.extend({
+            reset: function () {
+                (this._data = new r.init()), (this._nDataBytes = 0);
+            },
+            _append: function (a) {
+                "string" == typeof a && (a = x.parse(a)),
+                    this._data.concat(a),
+                    (this._nDataBytes += a.sigBytes);
+            },
+            _process: function (a) {
+                var c = this._data, e = c.words, j = c.sigBytes, k = this.blockSize, b = j / (4 * k), b = a ? u.ceil(b) : u.max((0 | b) - this._minBufferSize, 0);
+                if (((a = b * k), (j = u.min(4 * a, j)), a)) {
+                    for (var q = 0; a > q; q += k)
+                        this._doProcessBlock(e, q);
+                    (q = e.splice(0, a)), (c.sigBytes -= j);
+                }
+                return new r.init(q, j);
+            },
+            clone: function () {
+                var a = t.clone.call(this);
+                return (a._data = this._data.clone()), a;
+            },
+            _minBufferSize: 0,
+        }));
+        l.Hasher = q.extend({
+            cfg: t.extend(),
+            init: function (a) {
+                (this.cfg = this.cfg.extend(a)), this.reset();
+            },
+            reset: function () {
+                q.reset.call(this), this._doReset();
+            },
+            update: function (a) {
+                return this._append(a), this._process(), this;
+            },
+            finalize: function (a) {
+                return a && this._append(a), this._doFinalize();
+            },
+            blockSize: 16,
+            _createHelper: function (a) {
+                return function (b, e) {
+                    return new a.init(e).finalize(b);
+                };
+            },
+            _createHmacHelper: function (a) {
+                return function (b, e) {
+                    return new n.HMAC.init(a, e).finalize(b);
+                };
+            },
+        });
+        var n = (d.algo = {});
+        return d;
+    })(Math);
+!(function () {
+    var u = CryptoJS, p = u.lib.WordArray;
+    u.enc.Base64 = {
+        stringify: function (d) {
+            var l = d.words, p = d.sigBytes, t = this._map;
+            d.clamp(), (d = []);
+            for (var r = 0; p > r; r += 3)
+                for (var w = (((l[r >>> 2] >>> (24 - 8 * (r % 4))) & 255) << 16) |
+                    (((l[(r + 1) >>> 2] >>> (24 - 8 * ((r + 1) % 4))) & 255) << 8) |
+                    ((l[(r + 2) >>> 2] >>> (24 - 8 * ((r + 2) % 4))) & 255), v = 0; 4 > v && p > r + 0.75 * v; v++)
+                    d.push(t.charAt((w >>> (6 * (3 - v))) & 63));
+            if ((l = t.charAt(64)))
+                for (; d.length % 4;)
+                    d.push(l);
+            return d.join("");
+        },
+        parse: function (d) {
+            var l = d.length, s = this._map, t = s.charAt(64);
+            t && ((t = d.indexOf(t)), -1 != t && (l = t));
+            for (var t = [], r = 0, w = 0; l > w; w++)
+                if (w % 4) {
+                    var v = s.indexOf(d.charAt(w - 1)) << (2 * (w % 4)), b = s.indexOf(d.charAt(w)) >>> (6 - 2 * (w % 4));
+                    (t[r >>> 2] |= (v | b) << (24 - 8 * (r % 4))), r++;
+                }
+            return p.create(t, r);
+        },
+        _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+    };
+})(),
+    (function (u) {
+        function p(b, n, a, c, e, j, k) {
+            return ((b = b + ((n & a) | (~n & c)) + e + k),
+                ((b << j) | (b >>> (32 - j))) + n);
+        }
+        function d(b, n, a, c, e, j, k) {
+            return ((b = b + ((n & c) | (a & ~c)) + e + k),
+                ((b << j) | (b >>> (32 - j))) + n);
+        }
+        function l(b, n, a, c, e, j, k) {
+            return (b = b + (n ^ a ^ c) + e + k), ((b << j) | (b >>> (32 - j))) + n;
+        }
+        function s(b, n, a, c, e, j, k) {
+            return ((b = b + (a ^ (n | ~c)) + e + k), ((b << j) | (b >>> (32 - j))) + n);
+        }
+        for (var t = CryptoJS, r = t.lib, w = r.WordArray, v = r.Hasher, r = t.algo, b = [], x = 0; 64 > x; x++)
+            b[x] = (4294967296 * u.abs(u.sin(x + 1))) | 0;
+        (r = r.MD5 = v.extend({
+            _doReset: function () {
+                this._hash = new w.init([
+                    1732584193,
+                    4023233417,
+                    2562383102,
+                    271733878,
+                ]);
+            },
+            _doProcessBlock: function (q, n) {
+                for (var a = 0; 16 > a; a++) {
+                    var c = n + a, e = q[c];
+                    q[c] =
+                        (16711935 & ((e << 8) | (e >>> 24))) |
+                            (4278255360 & ((e << 24) | (e >>> 8)));
+                }
+                var a = this._hash.words, c = q[n + 0], e = q[n + 1], j = q[n + 2], k = q[n + 3], z = q[n + 4], r = q[n + 5], t = q[n + 6], w = q[n + 7], v = q[n + 8], A = q[n + 9], B = q[n + 10], C = q[n + 11], u = q[n + 12], D = q[n + 13], E = q[n + 14], x = q[n + 15], f = a[0], m = a[1], g = a[2], h = a[3], f = p(f, m, g, h, c, 7, b[0]), h = p(h, f, m, g, e, 12, b[1]), g = p(g, h, f, m, j, 17, b[2]), m = p(m, g, h, f, k, 22, b[3]), f = p(f, m, g, h, z, 7, b[4]), h = p(h, f, m, g, r, 12, b[5]), g = p(g, h, f, m, t, 17, b[6]), m = p(m, g, h, f, w, 22, b[7]), f = p(f, m, g, h, v, 7, b[8]), h = p(h, f, m, g, A, 12, b[9]), g = p(g, h, f, m, B, 17, b[10]), m = p(m, g, h, f, C, 22, b[11]), f = p(f, m, g, h, u, 7, b[12]), h = p(h, f, m, g, D, 12, b[13]), g = p(g, h, f, m, E, 17, b[14]), m = p(m, g, h, f, x, 22, b[15]), f = d(f, m, g, h, e, 5, b[16]), h = d(h, f, m, g, t, 9, b[17]), g = d(g, h, f, m, C, 14, b[18]), m = d(m, g, h, f, c, 20, b[19]), f = d(f, m, g, h, r, 5, b[20]), h = d(h, f, m, g, B, 9, b[21]), g = d(g, h, f, m, x, 14, b[22]), m = d(m, g, h, f, z, 20, b[23]), f = d(f, m, g, h, A, 5, b[24]), h = d(h, f, m, g, E, 9, b[25]), g = d(g, h, f, m, k, 14, b[26]), m = d(m, g, h, f, v, 20, b[27]), f = d(f, m, g, h, D, 5, b[28]), h = d(h, f, m, g, j, 9, b[29]), g = d(g, h, f, m, w, 14, b[30]), m = d(m, g, h, f, u, 20, b[31]), f = l(f, m, g, h, r, 4, b[32]), h = l(h, f, m, g, v, 11, b[33]), g = l(g, h, f, m, C, 16, b[34]), m = l(m, g, h, f, E, 23, b[35]), f = l(f, m, g, h, e, 4, b[36]), h = l(h, f, m, g, z, 11, b[37]), g = l(g, h, f, m, w, 16, b[38]), m = l(m, g, h, f, B, 23, b[39]), f = l(f, m, g, h, D, 4, b[40]), h = l(h, f, m, g, c, 11, b[41]), g = l(g, h, f, m, k, 16, b[42]), m = l(m, g, h, f, t, 23, b[43]), f = l(f, m, g, h, A, 4, b[44]), h = l(h, f, m, g, u, 11, b[45]), g = l(g, h, f, m, x, 16, b[46]), m = l(m, g, h, f, j, 23, b[47]), f = s(f, m, g, h, c, 6, b[48]), h = s(h, f, m, g, w, 10, b[49]), g = s(g, h, f, m, E, 15, b[50]), m = s(m, g, h, f, r, 21, b[51]), f = s(f, m, g, h, u, 6, b[52]), h = s(h, f, m, g, k, 10, b[53]), g = s(g, h, f, m, B, 15, b[54]), m = s(m, g, h, f, e, 21, b[55]), f = s(f, m, g, h, v, 6, b[56]), h = s(h, f, m, g, x, 10, b[57]), g = s(g, h, f, m, t, 15, b[58]), m = s(m, g, h, f, D, 21, b[59]), f = s(f, m, g, h, z, 6, b[60]), h = s(h, f, m, g, C, 10, b[61]), g = s(g, h, f, m, j, 15, b[62]), m = s(m, g, h, f, A, 21, b[63]);
+                (a[0] = (a[0] + f) | 0),
+                    (a[1] = (a[1] + m) | 0),
+                    (a[2] = (a[2] + g) | 0),
+                    (a[3] = (a[3] + h) | 0);
+            },
+            _doFinalize: function () {
+                var b = this._data, n = b.words, a = 8 * this._nDataBytes, c = 8 * b.sigBytes;
+                n[c >>> 5] |= 128 << (24 - (c % 32));
+                var e = u.floor(a / 4294967296);
+                for (n[(((c + 64) >>> 9) << 4) + 15] =
+                    (16711935 & ((e << 8) | (e >>> 24))) |
+                        (4278255360 & ((e << 24) | (e >>> 8))),
+                    n[(((c + 64) >>> 9) << 4) + 14] =
+                        (16711935 & ((a << 8) | (a >>> 24))) |
+                            (4278255360 & ((a << 24) | (a >>> 8))),
+                    b.sigBytes = 4 * (n.length + 1),
+                    this._process(),
+                    b = this._hash,
+                    n = b.words,
+                    a = 0; 4 > a; a++)
+                    (c = n[a]),
+                        (n[a] =
+                            (16711935 & ((c << 8) | (c >>> 24))) |
+                                (4278255360 & ((c << 24) | (c >>> 8))));
+                return b;
+            },
+            clone: function () {
+                var b = v.clone.call(this);
+                return (b._hash = this._hash.clone()), b;
+            },
+        })),
+            (t.MD5 = v._createHelper(r)),
+            (t.HmacMD5 = v._createHmacHelper(r));
+    })(Math),
+    (function () {
+        var u = CryptoJS, p = u.lib, d = p.Base, l = p.WordArray, p = u.algo, s = (p.EvpKDF = d.extend({
+            cfg: d.extend({ keySize: 4, hasher: p.MD5, iterations: 1 }),
+            init: function (d) {
+                this.cfg = this.cfg.extend(d);
+            },
+            compute: function (d, r) {
+                for (var p = this.cfg, s = p.hasher.create(), b = l.create(), u = b.words, q = p.keySize, p = p.iterations; u.length < q;) {
+                    n && s.update(n);
+                    var n = s.update(d).finalize(r);
+                    s.reset();
+                    for (var a = 1; p > a; a++)
+                        (n = s.finalize(n)), s.reset();
+                    b.concat(n);
+                }
+                return (b.sigBytes = 4 * q), b;
+            },
+        }));
+        u.EvpKDF = function (d, l, p) {
+            return s.create(p).compute(d, l);
+        };
+    })(),
+    CryptoJS.lib.Cipher ||
+        (function (u) {
+            var p = CryptoJS, d = p.lib, l = d.Base, s = d.WordArray, t = d.BufferedBlockAlgorithm, r = p.enc.Base64, w = p.algo.EvpKDF, v = (d.Cipher = t.extend({
+                cfg: l.extend(),
+                createEncryptor: function (e, a) {
+                    return this.create(this._ENC_XFORM_MODE, e, a);
+                },
+                createDecryptor: function (e, a) {
+                    return this.create(this._DEC_XFORM_MODE, e, a);
+                },
+                init: function (e, a, b) {
+                    (this.cfg = this.cfg.extend(b)),
+                        (this._xformMode = e),
+                        (this._key = a),
+                        this.reset();
+                },
+                reset: function () {
+                    t.reset.call(this), this._doReset();
+                },
+                process: function (e) {
+                    return this._append(e), this._process();
+                },
+                finalize: function (e) {
+                    return e && this._append(e), this._doFinalize();
+                },
+                keySize: 4,
+                ivSize: 4,
+                _ENC_XFORM_MODE: 1,
+                _DEC_XFORM_MODE: 2,
+                _createHelper: function (e) {
+                    return {
+                        encrypt: function (b, k, d) {
+                            return ("string" == typeof k ? c : a).encrypt(e, b, k, d);
+                        },
+                        decrypt: function (b, k, d) {
+                            console.log(c);
+                            return ("string" == typeof k ? c : a).decrypt(e, b, k, d);
+                        },
+                    };
+                },
+            }));
+            d.StreamCipher = v.extend({
+                _doFinalize: function () {
+                    return this._process(!0);
+                },
+                blockSize: 1,
+            });
+            var b = (p.mode = {}), x = function (e, a, b) {
+                var c = this._iv;
+                c ? (this._iv = u) : (c = this._prevBlock);
+                for (var d = 0; b > d; d++)
+                    e[a + d] ^= c[d];
+            }, q = (d.BlockCipherMode = l.extend({
+                createEncryptor: function (e, a) {
+                    return this.Encryptor.create(e, a);
+                },
+                createDecryptor: function (e, a) {
+                    return this.Decryptor.create(e, a);
+                },
+                init: function (e, a) {
+                    (this._cipher = e), (this._iv = a);
+                },
+            })).extend();
+            (q.Encryptor = q.extend({
+                processBlock: function (e, a) {
+                    var b = this._cipher, c = b.blockSize;
+                    x.call(this, e, a, c),
+                        b.encryptBlock(e, a),
+                        (this._prevBlock = e.slice(a, a + c));
+                },
+            })),
+                (q.Decryptor = q.extend({
+                    processBlock: function (e, a) {
+                        var b = this._cipher, c = b.blockSize, d = e.slice(a, a + c);
+                        b.decryptBlock(e, a), x.call(this, e, a, c), (this._prevBlock = d);
+                    },
+                })),
+                (b = b.CBC = q),
+                (q = (p.pad = {}).Pkcs7 = {
+                    pad: function (a, b) {
+                        for (var c = 4 * b, c = c - (a.sigBytes % c), d = (c << 24) | (c << 16) | (c << 8) | c, l = [], n = 0; c > n; n += 4)
+                            l.push(d);
+                        (c = s.create(l, c)), a.concat(c);
+                    },
+                    unpad: function (a) {
+                        a.sigBytes -= 255 & a.words[(a.sigBytes - 1) >>> 2];
+                    },
+                }),
+                (d.BlockCipher = v.extend({
+                    cfg: v.cfg.extend({ mode: b, padding: q }),
+                    reset: function () {
+                        v.reset.call(this);
+                        var a = this.cfg, b = a.iv, a = a.mode;
+                        if (this._xformMode == this._ENC_XFORM_MODE)
+                            var c = a.createEncryptor;
+                        else
+                            (c = a.createDecryptor), (this._minBufferSize = 1);
+                        this._mode = c.call(a, this, b && b.words);
+                    },
+                    _doProcessBlock: function (a, b) {
+                        this._mode.processBlock(a, b);
+                    },
+                    _doFinalize: function () {
+                        var a = this.cfg.padding;
+                        if (this._xformMode == this._ENC_XFORM_MODE) {
+                            a.pad(this._data, this.blockSize);
+                            var b = this._process(!0);
+                        }
+                        else
+                            (b = this._process(!0)), a.unpad(b);
+                        return b;
+                    },
+                    blockSize: 4,
+                }));
+            var n = (d.CipherParams = l.extend({
+                init: function (a) {
+                    this.mixIn(a);
+                },
+                toString: function (a) {
+                    return (a || this.formatter).stringify(this);
+                },
+            })), b = ((p.format = {}).OpenSSL = {
+                stringify: function (a) {
+                    var b = a.ciphertext;
+                    return ((a = a.salt),
+                        (a
+                            ? s.create([1398893684, 1701076831]).concat(a).concat(b)
+                            : b).toString(r));
+                },
+                parse: function (a) {
+                    a = r.parse(a);
+                    var b = a.words;
+                    if (1398893684 == b[0] && 1701076831 == b[1]) {
+                        var c = s.create(b.slice(2, 4));
+                        b.splice(0, 4), (a.sigBytes -= 16);
+                    }
+                    return n.create({ ciphertext: a, salt: c });
+                },
+            }), a = (d.SerializableCipher = l.extend({
+                cfg: l.extend({ format: b }),
+                encrypt: function (a, b, c, d) {
+                    d = this.cfg.extend(d);
+                    var l = a.createEncryptor(c, d);
+                    return ((b = l.finalize(b)),
+                        (l = l.cfg),
+                        n.create({
+                            ciphertext: b,
+                            key: c,
+                            iv: l.iv,
+                            algorithm: a,
+                            mode: l.mode,
+                            padding: l.padding,
+                            blockSize: a.blockSize,
+                            formatter: d.format,
+                        }));
+                },
+                decrypt: function (a, b, c, d) {
+                    return ((d = this.cfg.extend(d)),
+                        (b = this._parse(b, d.format)),
+                        a.createDecryptor(c, d).finalize(b.ciphertext));
+                },
+                _parse: function (a, b) {
+                    return "string" == typeof a ? b.parse(a, this) : a;
+                },
+            })), p = ((p.kdf = {}).OpenSSL = {
+                execute: function (a, b, c, d) {
+                    return (d || (d = s.random(8)),
+                        (a = w.create({ keySize: b + c }).compute(a, d)),
+                        (c = s.create(a.words.slice(b), 4 * c)),
+                        (a.sigBytes = 4 * b),
+                        n.create({ key: a, iv: c, salt: d }));
+                },
+            }), c = (d.PasswordBasedCipher = a.extend({
+                cfg: a.cfg.extend({ kdf: p }),
+                encrypt: function (b, c, d, l) {
+                    return ((l = this.cfg.extend(l)),
+                        (d = l.kdf.execute(d, b.keySize, b.ivSize)),
+                        (l.iv = d.iv),
+                        (b = a.encrypt.call(this, b, c, d.key, l)),
+                        b.mixIn(d),
+                        b);
+                },
+                decrypt: function (b, c, d, l) {
+                    return ((l = this.cfg.extend(l)),
+                        (c = this._parse(c, l.format)),
+                        (d = l.kdf.execute(d, b.keySize, b.ivSize, c.salt)),
+                        (l.iv = d.iv),
+                        a.decrypt.call(this, b, c, d.key, l));
+                },
+            }));
+        })(),
+    (function () {
+        for (var u = CryptoJS, p = u.lib.BlockCipher, d = u.algo, l = [], s = [], t = [], r = [], w = [], v = [], b = [], x = [], q = [], n = [], a = [], c = 0; 256 > c; c++)
+            a[c] = 128 > c ? c << 1 : (c << 1) ^ 283;
+        for (var e = 0, j = 0, c = 0; 256 > c; c++) {
+            var k = j ^ (j << 1) ^ (j << 2) ^ (j << 3) ^ (j << 4), k = (k >>> 8) ^ (255 & k) ^ 99;
+            (l[e] = k), (s[k] = e);
+            var z = a[e], F = a[z], G = a[F], y = (257 * a[k]) ^ (16843008 * k);
+            (t[e] = (y << 24) | (y >>> 8)),
+                (r[e] = (y << 16) | (y >>> 16)),
+                (w[e] = (y << 8) | (y >>> 24)),
+                (v[e] = y),
+                (y = (16843009 * G) ^ (65537 * F) ^ (257 * z) ^ (16843008 * e)),
+                (b[k] = (y << 24) | (y >>> 8)),
+                (x[k] = (y << 16) | (y >>> 16)),
+                (q[k] = (y << 8) | (y >>> 24)),
+                (n[k] = y),
+                e ? ((e = z ^ a[a[a[G ^ z]]]), (j ^= a[a[j]])) : (e = j = 1);
+        }
+        var H = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54], d = (d.AES = p.extend({
+            _doReset: function () {
+                for (var a = this._key, c = a.words, d = a.sigBytes / 4, a = 4 * ((this._nRounds = d + 6) + 1), e = (this._keySchedule = []), j = 0; a > j; j++)
+                    if (d > j)
+                        e[j] = c[j];
+                    else {
+                        var k = e[j - 1];
+                        j % d
+                            ? d > 6 &&
+                                4 == j % d &&
+                                (k =
+                                    (l[k >>> 24] << 24) |
+                                        (l[(k >>> 16) & 255] << 16) |
+                                        (l[(k >>> 8) & 255] << 8) |
+                                        l[255 & k])
+                            : ((k = (k << 8) | (k >>> 24)),
+                                (k =
+                                    (l[k >>> 24] << 24) |
+                                        (l[(k >>> 16) & 255] << 16) |
+                                        (l[(k >>> 8) & 255] << 8) |
+                                        l[255 & k]),
+                                (k ^= H[(j / d) | 0] << 24)),
+                            (e[j] = e[j - d] ^ k);
+                    }
+                for (c = this._invKeySchedule = [], d = 0; a > d; d++)
+                    (j = a - d),
+                        (k = d % 4 ? e[j] : e[j - 4]),
+                        (c[d] =
+                            4 > d || 4 >= j
+                                ? k
+                                : b[l[k >>> 24]] ^
+                                    x[l[(k >>> 16) & 255]] ^
+                                    q[l[(k >>> 8) & 255]] ^
+                                    n[l[255 & k]]);
+            },
+            encryptBlock: function (a, b) {
+                this._doCryptBlock(a, b, this._keySchedule, t, r, w, v, l);
+            },
+            decryptBlock: function (a, c) {
+                var d = a[c + 1];
+                (a[c + 1] = a[c + 3]),
+                    (a[c + 3] = d),
+                    this._doCryptBlock(a, c, this._invKeySchedule, b, x, q, n, s),
+                    (d = a[c + 1]),
+                    (a[c + 1] = a[c + 3]),
+                    (a[c + 3] = d);
+            },
+            _doCryptBlock: function (a, b, c, d, e, j, l, f) {
+                for (var m = this._nRounds, g = a[b] ^ c[0], h = a[b + 1] ^ c[1], k = a[b + 2] ^ c[2], n = a[b + 3] ^ c[3], p = 4, r = 1; m > r; r++)
+                    var q = d[g >>> 24] ^
+                        e[(h >>> 16) & 255] ^
+                        j[(k >>> 8) & 255] ^
+                        l[255 & n] ^
+                        c[p++], s = d[h >>> 24] ^
+                        e[(k >>> 16) & 255] ^
+                        j[(n >>> 8) & 255] ^
+                        l[255 & g] ^
+                        c[p++], t = d[k >>> 24] ^
+                        e[(n >>> 16) & 255] ^
+                        j[(g >>> 8) & 255] ^
+                        l[255 & h] ^
+                        c[p++], n = d[n >>> 24] ^
+                        e[(g >>> 16) & 255] ^
+                        j[(h >>> 8) & 255] ^
+                        l[255 & k] ^
+                        c[p++], g = q, h = s, k = t;
+                (q =
+                    ((f[g >>> 24] << 24) |
+                        (f[(h >>> 16) & 255] << 16) |
+                        (f[(k >>> 8) & 255] << 8) |
+                        f[255 & n]) ^
+                        c[p++]),
+                    (s =
+                        ((f[h >>> 24] << 24) |
+                            (f[(k >>> 16) & 255] << 16) |
+                            (f[(n >>> 8) & 255] << 8) |
+                            f[255 & g]) ^
+                            c[p++]),
+                    (t =
+                        ((f[k >>> 24] << 24) |
+                            (f[(n >>> 16) & 255] << 16) |
+                            (f[(g >>> 8) & 255] << 8) |
+                            f[255 & h]) ^
+                            c[p++]),
+                    (n =
+                        ((f[n >>> 24] << 24) |
+                            (f[(g >>> 16) & 255] << 16) |
+                            (f[(h >>> 8) & 255] << 8) |
+                            f[255 & k]) ^
+                            c[p++]),
+                    (a[b] = q),
+                    (a[b + 1] = s),
+                    (a[b + 2] = t),
+                    (a[b + 3] = n);
+            },
+            keySize: 8,
+        }));
+        u.AES = p._createHelper(d);
+    })();
+export default RSAKey;
+//# sourceMappingURL=rsa.js.map