text: navigator = {
      // WT-JS_DEBUG
      appCodeName: "Mozilla",
      appMinorVersion: "0",
      appName: "Netscape",
      appVersion: "5.0 (Windows NT 10.0; WOW64; Trident/7.0; .NET4.0C; .NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; InfoPath.3; rv:11.0) like Gecko",
      browserLanguage: "zh-CN",
      cookieEnabled: true,
      cpuClass: "x86",
      language: "zh-CN",
      maxTouchPoints: 0,
      msManipulationViewsEnabled: true,
      msMaxTouchPoints: 0,
      msPointerEnabled: true,
      onLine: true,
      platform: "Win32",
      pointerEnabled: true,
      product: "Gecko",
      systemLanguage: "zh-CN",
      userAgent: "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; .NET4.0C; .NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; InfoPath.3; rv:11.0) like Gecko",
      userLanguage: "zh-CN",
      vendor: "",
      vendorSub: "",
      webdriver: false
  }, window = this, window.navigator = navigator;
  
  function getRandomStr(t) {
      for (var e = ""; e.length < t;)
          e += Math.random().toString(36).substr(2);
      return e = e.slice(0, t)
  }
  
  var dbits;
  var canary = 0xdeadbeefcafe;
  var j_lm = ((canary & 0xffffff) == 0xefcafe);
  
  function BigInteger(a, b, c) {
      if (a != null) if ("number" == typeof a) this.fromNumber(a, b, c);
      else if (b == null && "string" != typeof a) this.fromString(a, 256);
      else this.fromString(a, b)
  }
  
  function nbi() {
      return new BigInteger(null)
  }
  
  function am3(i, x, w, j, c, n) {
      var xl = x & 0x3fff,
          xh = x >> 14;
      while (--n >= 0) {
          var l = this[i] & 0x3fff;
          var h = this[i++] >> 14;
          var m = xh * l + h * xl;
          l = xl * l + ((m & 0x3fff) << 14) + w[j] + c;
          c = (l >> 28) + (m >> 14) + xh * h;
          w[j++] = l & 0xfffffff
      }
      return c
  }
  
  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";
  var BI_RC = new Array();
  var rr, vv;
  rr = "0".charCodeAt(0);
  for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
  rr = "a".charCodeAt(0);
  for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
  rr = "A".charCodeAt(0);
  for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
  
  function int2char(n) {
      return BI_RM.charAt(n)
  }
  
  function intAt(s, i) {
      var c = BI_RC[s.charCodeAt(i)];
      return (c == null) ? -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 = (x < 0) ? -1 : 0;
      if (x > 0) this[0] = x;
      else if (x < -1) this[0] = x + DV;
      else this.t = 0
  }
  
  function nbv(i) {
      var r = nbi();
      r.fromInt(i);
      return r
  }
  
  function bnpFromString(s, b) {
      var k;
      if (b == 16) k = 4;
      else if (b == 8) k = 3;
      else if (b == 256) k = 8;
      else if (b == 2) k = 1;
      else if (b == 32) k = 5;
      else if (b == 4) k = 2;
      else {
          this.fromRadix(s, b);
          return
      }
      this.t = 0;
      this.s = 0;
      var i = s.length,
          mi = false,
          sh = 0;
      while (--i >= 0) {
          var x = (k == 8) ? s[i] & 0xff : intAt(s, i);
          if (x < 0) {
              if (s.charAt(i) == "-") mi = true;
              continue
          }
          mi = false;
          if (sh == 0) this[this.t++] = x;
          else if (sh + k > this.DB) {
              this[this.t - 1] |= (x & ((1 << (this.DB - sh)) - 1)) << sh;
              this[this.t++] = (x >> (this.DB - sh))
          } else this[this.t - 1] |= x << sh;
          sh += k;
          if (sh >= this.DB) sh -= this.DB
      }
      if (k == 8 && (s[0] & 0x80) != 0) {
          this.s = -1;
          if (sh > 0) this[this.t - 1] |= ((1 << (this.DB - sh)) - 1) << sh
      }
      this.clamp();
      if (mi) BigInteger.ZERO.subTo(this, this)
  }
  
  function bnpClamp() {
      var c = this.s & this.DM;
      while (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 (b == 16) k = 4;
      else if (b == 8) k = 3;
      else if (b == 2) k = 1;
      else if (b == 32) k = 5;
      else if (b == 4) k = 2;
      else return this.toRadix(b);
      var km = (1 << k) - 1,
          d,
          m = false,
          r = "",
          i = this.t;
      var p = this.DB - (i * this.DB) % k;
      if (i-- > 0) {
          if (p < this.DB && (d = this[i] >> p) > 0) {
              m = true;
              r = int2char(d)
          }
          while (i >= 0) {
              if (p < k) {
                  d = (this[i] & ((1 << p) - 1)) << (k - p);
                  d |= this[--i] >> (p += this.DB - k)
              } else {
                  d = (this[i] >> (p -= k)) & km;
                  if (p <= 0) {
                      p += this.DB;
                      --i
                  }
              }
              if (d > 0) m = true;
              if (m) r += int2char(d)
          }
      }
      return m ? r : "0"
  }
  
  function bnAbs() {
      return (this.s < 0) ? this.negate() : this
  }
  
  function bnCompareTo(a) {
      var r = this.s - a.s;
      if (r != 0) return r;
      var i = this.t;
      r = i - a.t;
      if (r != 0) return r;
      while (--i >= 0) if ((r = this[i] - a[i]) != 0) return r;
      return 0
  }
  
  function nbits(x) {
      var r = 1,
          t;
      if ((t = x >>> 16) != 0) {
          x = t;
          r += 16
      }
      if ((t = x >> 8) != 0) {
          x = t;
          r += 8
      }
      if ((t = x >> 4) != 0) {
          x = t;
          r += 4
      }
      if ((t = x >> 2) != 0) {
          x = t;
          r += 2
      }
      if ((t = x >> 1) != 0) {
          x = t;
          r += 1
      }
      return r
  }
  
  function bnBitLength() {
      if (this.t <= 0) return 0;
      return 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 bs = n % this.DB;
      var cbs = this.DB - bs;
      var bm = (1 << cbs) - 1;
      var ds = Math.floor(n / this.DB),
          c = (this.s << bs) & this.DM,
          i;
      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) {
          r.t = 0;
          return
      }
      var bs = n % this.DB;
      var cbs = this.DB - bs;
      var 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
      }
      if (bs > 0) r[this.t - ds - 1] |= (this.s & bm) << cbs;
      r.t = this.t - ds;
      r.clamp()
  }
  
  function bnpSubTo(a, r) {
      var i = 0,
          c = 0,
          m = Math.min(a.t, this.t);
      while (i < m) {
          c += this[i] - a[i];
          r[i++] = c & this.DM;
          c >>= this.DB
      }
      if (a.t < this.t) {
          c -= a.s;
          while (i < this.t) {
              c += this[i];
              r[i++] = c & this.DM;
              c >>= this.DB
          }
          c += this.s
      } else {
          c += this.s;
          while (i < a.t) {
              c -= a[i];
              r[i++] = c & this.DM;
              c >>= this.DB
          }
          c -= a.s
      }
      r.s = (c < 0) ? -1 : 0;
      if (c < -1) r[i++] = this.DV + c;
      else if (c > 0) r[i++] = c;
      r.t = i;
      r.clamp()
  }
  
  function bnpMultiplyTo(a, r) {
      var x = this.abs(),
          y = a.abs();
      var i = x.t;
      r.t = i + y.t;
      while (--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();
      if (this.s != a.s) BigInteger.ZERO.subTo(r, r)
  }
  
  function bnpSquareTo(r) {
      var x = this.abs();
      var i = r.t = 2 * x.t;
      while (--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);
          if ((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
          }
      }
      if (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) return;
      var pt = this.abs();
      if (pt.t < pm.t) {
          if (q != null) q.fromInt(0);
          if (r != null) this.copyTo(r);
          return
      }
      if (r == null) r = nbi();
      var y = nbi(),
          ts = this.s,
          ms = m.s;
      var nsh = this.DB - nbits(pm[pm.t - 1]);
      if (nsh > 0) {
          pm.lShiftTo(nsh, y);
          pt.lShiftTo(nsh, r)
      } else {
          pm.copyTo(y);
          pt.copyTo(r)
      }
      var ys = y.t;
      var y0 = y[ys - 1];
      if (y0 == 0) return;
      var yt = y0 * (1 << this.F1) + ((ys > 1) ? y[ys - 2] >> this.F2 : 0);
      var d1 = this.FV / yt,
          d2 = (1 << this.F1) / yt,
          e = 1 << this.F2;
      var i = r.t,
          j = i - ys,
          t = (q == null) ? nbi() : q;
      y.dlShiftTo(j, t);
      if (r.compareTo(t) >= 0) {
          r[r.t++] = 1;
          r.subTo(t, r)
      }
      BigInteger.ONE.dlShiftTo(ys, t);
      t.subTo(y, y);
      while (y.t < ys) y[y.t++] = 0;
      while (--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) {
              y.dlShiftTo(j, t);
              r.subTo(t, r);
              while (r[i] < --qd) r.subTo(t, r)
          }
      }
      if (q != null) {
          r.drShiftTo(ys, q);
          if (ts != ms) BigInteger.ZERO.subTo(q, q)
      }
      r.t = ys;
      r.clamp();
      if (nsh > 0) r.rShiftTo(nsh, r);
      if (ts < 0) BigInteger.ZERO.subTo(r, r)
  }
  
  function bnpInvDigit() {
      if (this.t < 1) return 0;
      var x = this[0];
      if ((x & 1) == 0) return 0;
      var y = x & 3;
      y = (y * (2 - (x & 0xf) * y)) & 0xf;
      y = (y * (2 - (x & 0xff) * y)) & 0xff;
      y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff;
      y = (y * (2 - x * y % this.DV)) % this.DV;
      return (y > 0) ? this.DV - y : -y
  }
  
  function Montgomery(m) {
      this.m = m;
      this.mp = m.invDigit();
      this.mpl = this.mp & 0x7fff;
      this.mph = this.mp >> 15;
      this.um = (1 << (m.DB - 15)) - 1;
      this.mt2 = 2 * m.t
  }
  
  function montConvert(x) {
      var r = nbi();
      x.abs().dlShiftTo(this.m.t, r);
      r.divRemTo(this.m, null, r);
      if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r);
      return r
  }
  
  function montRevert(x) {
      var r = nbi();
      x.copyTo(r);
      this.reduce(r);
      return r
  }
  
  function montReduce(x) {
      while (x.t <= this.mt2) x[x.t++] = 0;
      for (var i = 0; i < this.m.t; ++i) {
          var j = x[i] & 0x7fff;
          var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM;
          j = i + this.m.t;
          x[j] += this.m.am(0, u0, x, i, 0, this.m.t);
          while (x[j] >= x.DV) {
              x[j] -= x.DV;
              x[++j]++
          }
      }
      x.clamp();
      x.drShiftTo(this.m.t, x);
      if (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)
  }
  
  Montgomery.prototype.convert = montConvert;
  Montgomery.prototype.revert = montRevert;
  Montgomery.prototype.reduce = montReduce;
  Montgomery.prototype.mulTo = montMulTo;
  Montgomery.prototype.sqrTo = montSqrTo;
  
  function bnpIsEven() {
      return ((this.t > 0) ? (this[0] & 1) : this.s) == 0
  }
  
  function bnpExp(e, z) {
      if (e > 0xffffffff || e < 1) return BigInteger.ONE;
      var r = nbi(),
          r2 = nbi(),
          g = z.convert(this),
          i = nbits(e) - 1;
      g.copyTo(r);
      while (--i >= 0) {
          z.sqrTo(r, r2);
          if ((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;
      if (e < 256 || m.isEven()) z = new Classic(m);
      else z = new Montgomery(m);
      return this.exp(e, z)
  }
  
  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.abs = bnAbs;
  BigInteger.prototype.compareTo = bnCompareTo;
  BigInteger.prototype.bitLength = bnBitLength;
  BigInteger.prototype.modPowInt = bnModPowInt;
  BigInteger.ZERO = nbv(0);
  BigInteger.ONE = nbv(1);
  pidCrypt = {};
  
  function parseBigInt(str, r) {
      return new BigInteger(str, r)
  }
  
  function pkcs1pad2(s, n) {
      if (n < s.length + 11) {
          console.log("Message too long for RSA");
          return null
      }
      var ba = new Array();
      var i = s.length - 1;
      while (i >= 0 && n > 0) {
          ba[--n] = s.charCodeAt(i--)
      }
      ;
      ba[--n] = 0;
      var rng = new SecureRandom();
      var x = new Array();
      while (n > 2) {
          x[0] = 0;
          while (x[0] == 0) rng.nextBytes(x);
          ba[--n] = x[0]
      }
      ba[--n] = 2;
      ba[--n] = 0;
      return new BigInteger(ba)
  }
  
  function SecureRandom() {
      this.rng_state;
      this.rng_pool;
      this.rng_pptr;
      this.rng_pool = new Array();
      var rng_psize = 256;
      this.rng_seed_int = function (x) {
          this.rng_pool[this.rng_pptr++] ^= x & 255;
          this.rng_pool[this.rng_pptr++] ^= (x >> 8) & 255;
          this.rng_pool[this.rng_pptr++] ^= (x >> 16) & 255;
          this.rng_pool[this.rng_pptr++] ^= (x >> 24) & 255;
          if (this.rng_pptr >= rng_psize) this.rng_pptr -= rng_psize
      }
      this.rng_seed_time = function () {
          this.rng_seed_int(new Date().getTime())
      }
      this.rng_get_byte = function () {
          if (this.rng_state == null) {
              this.rng_seed_time();
              this.rng_state = prng_newstate();
              this.rng_state.init(this.rng_pool);
              for (this.rng_pptr = 0; this.rng_pptr < this.rng_pool.length; ++this.rng_pptr) this.rng_pool[this.rng_pptr] = 0;
              this.rng_pptr = 0
          }
          return this.rng_state.next()
      }
      this.nextBytes = function (ba) {
          var i;
          for (i = 0; i < ba.length; ++i) ba[i] = this.rng_get_byte()
      }
  }
  
  function prng_newstate() {
      return new Arcfour()
  }
  
  function Arcfour() {
      this.i = 0;
      this.j = 0;
      this.S = new Array()
  }
  
  function ARC4init(key) {
      var i, j, t;
      for (i = 0; i < 256; ++i) this.S[i] = i;
      j = 0;
      for (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
  }
  
  function ARC4next() {
      var t;
      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;
      return this.S[(t + this.S[this.i]) & 255]
  }
  
  Arcfour.prototype.init = ARC4init;
  Arcfour.prototype.next = ARC4next;
  pidCrypt.RSA = function () {
      this.n = null;
      this.e = 0;
      this.d = null;
      this.p = null;
      this.q = null;
      this.dmp1 = null;
      this.dmq1 = null;
      this.coeff = null
  }
  pidCrypt.RSA.prototype.setPublic = function (N, E, radix) {
      if (typeof (radix) == 'undefined') radix = 16;
      if (N != null && E != null && N.length > 0 && E.length > 0) {
          this.n = parseBigInt(N, radix);
          this.e = parseInt(E, radix)
      } else alert("Invalid RSA public key")
  }
  pidCrypt.RSA.prototype.doPublic = function (x) {
      return x.modPowInt(this.e, this.n)
  }
  pidCrypt.RSA.prototype.encryptRaw = function (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
  }
  pidCrypt.RSA.prototype.encrypt = function (text) {
      return this.encryptRaw(text)
  }
  pidCrypt.RSA.prototype.getASNData = function (tree) {
      var params = {};
      var data = [];
      var p = 0;
      if (tree.value && tree.type == 'INTEGER') data[p++] = tree.value;
      if (tree.sub) for (var i = 0; i < tree.sub.length; i++) data = data.concat(this.getASNData(tree.sub[i]));
      return data
  }
  pidCrypt.RSA.prototype.setKeyFromASN = function (key, asntree) {
      var keys = ['N', 'E', 'D', 'P', 'Q', 'DP', 'DQ', 'C'];
      var params = {};
      var asnData = this.getASNData(asntree);
      switch (key) {
          case 'Public':
          case 'public':
              for (var i = 0; i < asnData.length; i++) params[keys[i]] = asnData[i].toLowerCase();
              this.setPublic(params.N, params.E, 16);
              break
      }
  }
  pidCrypt.RSA.prototype.setPublicKeyFromASN = function (asntree) {
      this.setKeyFromASN('public', asntree)
  }
  pidCryptUtil = {};
  pidCryptUtil.encodeBase64 = function (str, utf8encode) {
      if (!str) str = "";
      var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
      utf8encode = (typeof utf8encode == 'undefined') ? false : utf8encode;
      var o1, o2, o3, bits, h1, h2, h3, h4, e = [],
          pad = '',
          c,
          plain,
          coded;
      plain = utf8encode ? pidCryptUtil.encodeUTF8(str) : str;
      c = plain.length % 3;
      if (c > 0) {
          while (c++ < 3) {
              pad += '=';
              plain += '\0'
          }
      }
      for (c = 0; c < plain.length; c += 3) {
          o1 = plain.charCodeAt(c);
          o2 = plain.charCodeAt(c + 1);
          o3 = plain.charCodeAt(c + 2);
          bits = o1 << 16 | o2 << 8 | o3;
          h1 = bits >> 18 & 0x3f;
          h2 = bits >> 12 & 0x3f;
          h3 = bits >> 6 & 0x3f;
          h4 = bits & 0x3f;
          e[c / 3] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4)
      }
      coded = e.join('');
      coded = coded.slice(0, coded.length - pad.length) + pad;
      return coded
  }
  pidCryptUtil.decodeBase64 = function (str, utf8decode) {
      if (!str) str = "";
      var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
      utf8decode = (typeof utf8decode == 'undefined') ? false : utf8decode;
      var o1, o2, o3, h1, h2, h3, h4, bits, d = [],
          plain,
          coded;
      coded = utf8decode ? pidCryptUtil.decodeUTF8(str) : str;
      for (var c = 0; c < coded.length; c += 4) {
          h1 = b64.indexOf(coded.charAt(c));
          h2 = b64.indexOf(coded.charAt(c + 1));
          h3 = b64.indexOf(coded.charAt(c + 2));
          h4 = b64.indexOf(coded.charAt(c + 3));
          bits = h1 << 18 | h2 << 12 | h3 << 6 | h4;
          o1 = bits >>> 16 & 0xff;
          o2 = bits >>> 8 & 0xff;
          o3 = bits & 0xff;
          d[c / 4] = String.fromCharCode(o1, o2, o3);
          if (h4 == 0x40) d[c / 4] = String.fromCharCode(o1, o2);
          if (h3 == 0x40) d[c / 4] = String.fromCharCode(o1)
      }
      plain = d.join('');
      plain = utf8decode ? pidCryptUtil.decodeUTF8(plain) : plain
      return plain
  }
  pidCryptUtil.convertToHex = function (str) {
      if (!str) str = "";
      var hs = '';
      var hv = '';
      for (var i = 0; i < str.length; i++) {
          hv = str.charCodeAt(i).toString(16);
          hs += (hv.length == 1) ? '0' + hv : hv
      }
      return hs
  }
  pidCryptUtil.convertFromHex = function (str) {
      if (!str) str = "";
      var s = "";
      for (var i = 0; i < str.length; i += 2) {
          s += String.fromCharCode(parseInt(str.substring(i, i + 2), 16))
      }
      return s
  }
  pidCryptUtil.stripLineFeeds = function (str) {
      if (!str) str = "";
      var s = '';
      s = str.replace(/\n/g, '');
      s = s.replace(/\r/g, '');
      return s
  }
  pidCryptUtil.toByteArray = function (str) {
      if (!str) str = "";
      var ba = [];
      for (var i = 0; i < str.length; i++) ba[i] = str.charCodeAt(i);
      return ba
  }
  
  function Stream(enc, pos) {
      if (enc instanceof Stream) {
          this.enc = enc.enc;
          this.pos = enc.pos
      } else {
          this.enc = enc;
          this.pos = pos
      }
  }
  
  Stream.prototype.parseStringHex = function (start, end) {
      if (typeof (end) == 'undefined') end = this.enc.length;
      var s = "";
      for (var i = start; i < end; ++i) {
          var h = this.get(i);
          s += this.hexDigits.charAt(h >> 4) + this.hexDigits.charAt(h & 0xF)
      }
      return s
  }
  Stream.prototype.get = function (pos) {
      if (pos == undefined) pos = this.pos++;
      if (pos >= this.enc.length) throw 'Requesting byte offset ' + pos + ' on a stream of length ' + this.enc.length;
      return this.enc[pos]
  }
  Stream.prototype.hexDigits = "0123456789ABCDEF";
  if (typeof (pidCrypt) != 'undefined') {
      pidCrypt.ASN1 = function (stream, header, length, tag, sub) {
          this.stream = stream;
          this.header = header;
          this.length = length;
          this.tag = tag;
          this.sub = sub
      }
      pidCrypt.ASN1.prototype.toHexTree = function () {
          var node = {};
          node.type = this.typeName();
          if (node.type != 'SEQUENCE') node.value = this.stream.parseStringHex(this.posContent(), this.posEnd());
          if (this.sub != null) {
              node.sub = [];
              for (var i = 0,
                       max = this.sub.length; i < max; ++i) node.sub[i] = this.sub[i].toHexTree()
          }
          return node
      }
      pidCrypt.ASN1.prototype.typeName = function () {
          if (this.tag == undefined) return "unknown";
          var tagClass = this.tag >> 6;
          var tagNumber = this.tag & 0x1F;
          switch (tagClass) {
              case 0:
                  switch (tagNumber) {
                      case 0x00:
                          return "EOC";
                      case 0x01:
                          return "BOOLEAN";
                      case 0x02:
                          return "INTEGER";
                      case 0x03:
                          return "BIT_STRING";
                      case 0x04:
                          return "OCTET_STRING";
                      case 0x05:
                          return "NULL";
                      case 0x06:
                          return "OBJECT_IDENTIFIER";
                      case 0x07:
                          return "ObjectDescriptor";
                      case 0x08:
                          return "EXTERNAL";
                      case 0x09:
                          return "REAL";
                      case 0x0A:
                          return "ENUMERATED";
                      case 0x0B:
                          return "EMBEDDED_PDV";
                      case 0x0C:
                          return "UTF8String";
                      case 0x10:
                          return "SEQUENCE";
                      case 0x11:
                          return "SET";
                      case 0x12:
                          return "NumericString";
                      case 0x13:
                          return "PrintableString";
                      case 0x14:
                          return "TeletexString";
                      case 0x15:
                          return "VideotexString";
                      case 0x16:
                          return "IA5String";
                      case 0x17:
                          return "UTCTime";
                      case 0x18:
                          return "GeneralizedTime";
                      case 0x19:
                          return "GraphicString";
                      case 0x1A:
                          return "VisibleString";
                      case 0x1B:
                          return "GeneralString";
                      case 0x1C:
                          return "UniversalString";
                      case 0x1E:
                          return "BMPString";
                      default:
                          return "Universal_" + tagNumber.toString(16)
                  }
              case 1:
                  return "Application_" + tagNumber.toString(16);
              case 2:
                  return "[" + tagNumber + "]";
              case 3:
                  return "Private_" + tagNumber.toString(16)
          }
      }
      pidCrypt.ASN1.prototype.posStart = function () {
          return this.stream.pos
      }
      pidCrypt.ASN1.prototype.posContent = function () {
          return this.stream.pos + this.header
      }
      pidCrypt.ASN1.prototype.posEnd = function () {
          return this.stream.pos + this.header + Math.abs(this.length)
      }
      pidCrypt.ASN1.decodeLength = function (stream) {
          var buf = stream.get();
          var len = buf & 0x7F;
          if (len == buf) return len;
          if (len > 3) throw "Length over 24 bits not supported at position " + (stream.pos - 1);
          if (len == 0) return -1;
          buf = 0;
          for (var i = 0; i < len; ++i) buf = (buf << 8) | stream.get();
          return buf
      }
      pidCrypt.ASN1.hasContent = function (tag, len, stream) {
          if (tag & 0x20) return true;
          if ((tag < 0x03) || (tag > 0x04)) return false;
          var p = new Stream(stream);
          if (tag == 0x03) p.get();
          var subTag = p.get();
          if ((subTag >> 6) & 0x01) return false;
          try {
              var subLength = pidCrypt.ASN1.decodeLength(p);
              return ((p.pos - stream.pos) + subLength == len)
          } catch (exception) {
              return false
          }
      }
      pidCrypt.ASN1.decode = function (stream) {
          if (!(stream instanceof Stream)) stream = new Stream(stream, 0);
          var streamStart = new Stream(stream);
          var tag = stream.get();
          var len = pidCrypt.ASN1.decodeLength(stream);
          var header = stream.pos - streamStart.pos;
          var sub = null;
          if (pidCrypt.ASN1.hasContent(tag, len, stream)) {
              var start = stream.pos;
              if (tag == 0x03) stream.get();
              sub = [];
              if (len >= 0) {
                  var end = start + len;
                  while (stream.pos < end) sub[sub.length] = pidCrypt.ASN1.decode(stream);
                  if (stream.pos != end) throw "Content size is not correct for container starting at offset " + start;
              } else {
                  try {
                      for (; ;) {
                          var s = pidCrypt.ASN1.decode(stream);
                          if (s.tag == 0) break;
                          sub[sub.length] = s
                      }
                      len = start - stream.pos
                  } catch (e) {
                      throw "Exception while decoding undefined length content: " + e;
                  }
              }
          } else stream.pos += len;
          return new pidCrypt.ASN1(streamStart, header, len, tag, sub)
      }
  }
  
  function certParser(cert) {
      var retObj = {};
      retObj.info = '';
      retObj.salt = '';
      retObj.iv;
      retObj.b64 = cert;
      retObj.aes = false;
      retObj.mode = '';
      retObj.bits = 0;
      return retObj
  }
  
  function rsaEncrypt(data) {
      var public_key = 'MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDnOWe/gs033L/2/xR3oi6SLAMPBY5VledUqqH6dbCNOdrGX4xW+1x6NUfvmwpHRBA2C7xWDDvOIldTl0rMtERTDy9homrVqEcW6/TY+dSVFL3e2Yg2sVaehHv7FhmATkgfC2FcXt8Wvm99QpKRSrGKpcFYJwOj2F8hJh+rTG0IPQIDAQAB';
      var params = certParser(public_key);
      var key = pidCryptUtil.decodeBase64(params.b64);
      var rsa = new pidCrypt.RSA();
      var asn = pidCrypt.ASN1.decode(pidCryptUtil.toByteArray(key));
      var tree = asn.toHexTree();
      rsa.setPublicKeyFromASN(tree);
      var crypted = rsa.encrypt(data);
      var b64encrypted = pidCryptUtil.encodeBase64(pidCryptUtil.convertFromHex(crypted));
      return (b64encrypted)
  }
  
  var CryptoJS = CryptoJS || (function (Math, undefined) {
      var C = {};
      var C_lib = C.lib = {};
      var Base = C_lib.Base = (function () {
          function F() {
          };
          return {
              extend: function (overrides) {
                  F.prototype = this;
                  var subtype = new F();
                  if (overrides) {
                      subtype.mixIn(overrides);
                  }
                  if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
                      subtype.init = function () {
                          subtype.$super.init.apply(this, arguments);
                      };
                  }
                  subtype.init.prototype = subtype;
                  subtype.$super = this;
                  return subtype;
              }, create: function () {
                  var instance = this.extend();
                  instance.init.apply(instance, arguments);
                  return instance;
              }, init: function () {
              }, mixIn: function (properties) {
                  for (var propertyName in properties) {
                      if (properties.hasOwnProperty(propertyName)) {
                          this[propertyName] = properties[propertyName];
                      }
                  }
                  if (properties.hasOwnProperty('toString')) {
                      this.toString = properties.toString;
                  }
              }, clone: function () {
                  return this.init.prototype.extend(this);
              }
          };
      }());
      var WordArray = C_lib.WordArray = Base.extend({
          init: function (words, sigBytes) {
              words = this.words = words || [];
              if (sigBytes != undefined) {
                  this.sigBytes = sigBytes;
              } else {
                  this.sigBytes = words.length * 4;
              }
          }, toString: function (encoder) {
              return (encoder || Hex).stringify(this);
          }, concat: function (wordArray) {
              var thisWords = this.words;
              var thatWords = wordArray.words;
              var thisSigBytes = this.sigBytes;
              var thatSigBytes = wordArray.sigBytes;
              this.clamp();
              if (thisSigBytes % 4) {
                  for (var i = 0; i < thatSigBytes; i++) {
                      var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                      thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
                  }
              } else if (thatWords.length > 0xffff) {
                  for (var i = 0; i < thatSigBytes; i += 4) {
                      thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
                  }
              } else {
                  thisWords.push.apply(thisWords, thatWords);
              }
              this.sigBytes += thatSigBytes;
              return this;
          }, clamp: function () {
              var words = this.words;
              var sigBytes = this.sigBytes;
              words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
              words.length = Math.ceil(sigBytes / 4);
          }, clone: function () {
              var clone = Base.clone.call(this);
              clone.words = this.words.slice(0);
              return clone;
          }, random: function (nBytes) {
              var words = [];
              var r = (function (m_w) {
                  var m_w = m_w;
                  var m_z = 0x3ade68b1;
                  var mask = 0xffffffff;
                  return function () {
                      m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
                      m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
                      var result = ((m_z << 0x10) + m_w) & mask;
                      result /= 0x100000000;
                      result += 0.5;
                      return result * (Math.random() > .5 ? 1 : -1);
                  }
              });
              for (var i = 0, rcache; i < nBytes; i += 4) {
                  var _r = r((rcache || Math.random()) * 0x100000000);
                  rcache = _r() * 0x3ade67b7;
                  words.push((_r() * 0x100000000) | 0);
              }
              return new WordArray.init(words, nBytes);
          }
      });
      var C_enc = C.enc = {};
      var Hex = C_enc.Hex = {
          stringify: function (wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var hexChars = [];
              for (var i = 0; i < sigBytes; i++) {
                  var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                  hexChars.push((bite >>> 4).toString(16));
                  hexChars.push((bite & 0x0f).toString(16));
              }
              return hexChars.join('');
          }, parse: function (hexStr) {
              var hexStrLength = hexStr.length;
              var words = [];
              for (var i = 0; i < hexStrLength; i += 2) {
                  words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
              }
              return new WordArray.init(words, hexStrLength / 2);
          }
      };
      var Latin1 = C_enc.Latin1 = {
          stringify: function (wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var latin1Chars = [];
              for (var i = 0; i < sigBytes; i++) {
                  var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                  latin1Chars.push(String.fromCharCode(bite));
              }
              return latin1Chars.join('');
          }, parse: function (latin1Str) {
              var latin1StrLength = latin1Str.length;
              var words = [];
              for (var i = 0; i < latin1StrLength; i++) {
                  words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
              }
              return new WordArray.init(words, latin1StrLength);
          }
      };
      var Utf8 = C_enc.Utf8 = {
          stringify: function (wordArray) {
              try {
                  return decodeURIComponent(escape(Latin1.stringify(wordArray)));
              } catch (e) {
                  throw new Error('Malformed UTF-8 data');
              }
          }, parse: function (utf8Str) {
              return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
          }
      };
      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
          reset: function () {
              this._data = new WordArray.init();
              this._nDataBytes = 0;
          }, _append: function (data) {
              if (typeof data == 'string') {
                  data = Utf8.parse(data);
              }
              this._data.concat(data);
              this._nDataBytes += data.sigBytes;
          }, _process: function (doFlush) {
              var data = this._data;
              var dataWords = data.words;
              var dataSigBytes = data.sigBytes;
              var blockSize = this.blockSize;
              var blockSizeBytes = blockSize * 4;
              var nBlocksReady = dataSigBytes / blockSizeBytes;
              if (doFlush) {
                  nBlocksReady = Math.ceil(nBlocksReady);
              } else {
                  nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
              }
              var nWordsReady = nBlocksReady * blockSize;
              var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
              if (nWordsReady) {
                  for (var offset = 0; offset < nWordsReady; offset += blockSize) {
                      this._doProcessBlock(dataWords, offset);
                  }
                  var processedWords = dataWords.splice(0, nWordsReady);
                  data.sigBytes -= nBytesReady;
              }
              return new WordArray.init(processedWords, nBytesReady);
          }, clone: function () {
              var clone = Base.clone.call(this);
              clone._data = this._data.clone();
              return clone;
          }, _minBufferSize: 0
      });
      var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
          cfg: Base.extend(),
          init: function (cfg) {
              this.cfg = this.cfg.extend(cfg);
              this.reset();
          }, reset: function () {
              BufferedBlockAlgorithm.reset.call(this);
              this._doReset();
          }, update: function (messageUpdate) {
              this._append(messageUpdate);
              this._process();
              return this;
          }, finalize: function (messageUpdate) {
              if (messageUpdate) {
                  this._append(messageUpdate);
              }
              var hash = this._doFinalize();
              return hash;
          }, blockSize: 512 / 32,
          _createHelper: function (hasher) {
              return function (message, cfg) {
                  return new hasher.init(cfg).finalize(message);
              };
          }, _createHmacHelper: function (hasher) {
              return function (message, key) {
                  return new C_algo.HMAC.init(hasher, key).finalize(message);
              };
          }
      });
      var C_algo = C.algo = {};
      return C;
  }(Math));
  
  (function () {
      var C = CryptoJS;
      var C_lib = C.lib;
      var WordArray = C_lib.WordArray;
      var C_enc = C.enc;
      var Base64 = C_enc.Base64 = {
          stringify: function (wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var map = this._map;
              wordArray.clamp();
              var base64Chars = [];
              for (var i = 0; i < sigBytes; i += 3) {
                  var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                  var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
                  var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
                  var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
                  for (var j = 0;
                       (j < 4) && (i + j * 0.75 < sigBytes); j++) {
                      base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
                  }
              }
              var paddingChar = map.charAt(64);
              if (paddingChar) {
                  while (base64Chars.length % 4) {
                      base64Chars.push(paddingChar);
                  }
              }
              return base64Chars.join('');
          }, parse: function (base64Str) {
              var base64StrLength = base64Str.length;
              var map = this._map;
              var reverseMap = this._reverseMap;
              if (!reverseMap) {
                  reverseMap = this._reverseMap = [];
                  for (var j = 0; j < map.length; j++) {
                      reverseMap[map.charCodeAt(j)] = j;
                  }
              }
              var paddingChar = map.charAt(64);
              if (paddingChar) {
                  var paddingIndex = base64Str.indexOf(paddingChar);
                  if (paddingIndex !== -1) {
                      base64StrLength = paddingIndex;
                  }
              }
              return parseLoop(base64Str, base64StrLength, reverseMap);
          }, _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
      };
  
      function parseLoop(base64Str, base64StrLength, reverseMap) {
          var words = [];
          var nBytes = 0;
          for (var i = 0; i < base64StrLength; i++) {
              if (i % 4) {
                  var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
                  var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
                  words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
                  nBytes++;
              }
          }
          return WordArray.create(words, nBytes);
      }
  }());
  
  CryptoJS.lib.Cipher || (function (undefined) {
      var C = CryptoJS;
      var C_lib = C.lib;
      var Base = C_lib.Base;
      var WordArray = C_lib.WordArray;
      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
      var C_enc = C.enc;
      var Utf8 = C_enc.Utf8;
      var Base64 = C_enc.Base64;
      var C_algo = C.algo;
      var EvpKDF = C_algo.EvpKDF;
      var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
          cfg: Base.extend(),
          createEncryptor: function (key, cfg) {
              return this.create(this._ENC_XFORM_MODE, key, cfg);
          }, createDecryptor: function (key, cfg) {
              return this.create(this._DEC_XFORM_MODE, key, cfg);
          }, init: function (xformMode, key, cfg) {
              this.cfg = this.cfg.extend(cfg);
              this._xformMode = xformMode;
              this._key = key;
              this.reset();
          }, reset: function () {
              BufferedBlockAlgorithm.reset.call(this);
              this._doReset();
          }, process: function (dataUpdate) {
              this._append(dataUpdate);
              return this._process();
          }, finalize: function (dataUpdate) {
              if (dataUpdate) {
                  this._append(dataUpdate);
              }
              var finalProcessedData = this._doFinalize();
              return finalProcessedData;
          }, keySize: 128 / 32,
          ivSize: 128 / 32,
          _ENC_XFORM_MODE: 1,
          _DEC_XFORM_MODE: 2,
          _createHelper: (function () {
              function selectCipherStrategy(key) {
                  if (typeof key == 'string') {
                      return PasswordBasedCipher;
                  } else {
                      return SerializableCipher;
                  }
              }
  
              return function (cipher) {
                  return {
                      encrypt: function (message, key, cfg) {
                          return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
                      }, decrypt: function (ciphertext, key, cfg) {
                          return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
                      }
                  };
              };
          }())
      });
      var StreamCipher = C_lib.StreamCipher = Cipher.extend({
          _doFinalize: function () {
              var finalProcessedBlocks = this._process(!!'flush');
              return finalProcessedBlocks;
          }, blockSize: 1
      });
      var C_mode = C.mode = {};
      var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
          createEncryptor: function (cipher, iv) {
              return this.Encryptor.create(cipher, iv);
          }, createDecryptor: function (cipher, iv) {
              return this.Decryptor.create(cipher, iv);
          }, init: function (cipher, iv) {
              this._cipher = cipher;
              this._iv = iv;
          }
      });
      var CBC = C_mode.CBC = (function () {
          var CBC = BlockCipherMode.extend();
          CBC.Encryptor = CBC.extend({
              processBlock: function (words, offset) {
                  var cipher = this._cipher;
                  var blockSize = cipher.blockSize;
                  xorBlock.call(this, words, offset, blockSize);
                  cipher.encryptBlock(words, offset);
                  this._prevBlock = words.slice(offset, offset + blockSize);
              }
          });
          CBC.Decryptor = CBC.extend({
              processBlock: function (words, offset) {
                  var cipher = this._cipher;
                  var blockSize = cipher.blockSize;
                  var thisBlock = words.slice(offset, offset + blockSize);
                  cipher.decryptBlock(words, offset);
                  xorBlock.call(this, words, offset, blockSize);
                  this._prevBlock = thisBlock;
              }
          });
  
          function xorBlock(words, offset, blockSize) {
              var iv = this._iv;
              if (iv) {
                  var block = iv;
                  this._iv = undefined;
              } else {
                  var block = this._prevBlock;
              }
              for (var i = 0; i < blockSize; i++) {
                  words[offset + i] ^= block[i];
              }
          }
  
          return CBC;
      }());
      var C_pad = C.pad = {};
      var Pkcs7 = C_pad.Pkcs7 = {
          pad: function (data, blockSize) {
              var blockSizeBytes = blockSize * 4;
              var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
              var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
              var paddingWords = [];
              for (var i = 0; i < nPaddingBytes; i += 4) {
                  paddingWords.push(paddingWord);
              }
              var padding = WordArray.create(paddingWords, nPaddingBytes);
              data.concat(padding);
          }, unpad: function (data) {
              var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
              data.sigBytes -= nPaddingBytes;
          }
      };
      var BlockCipher = C_lib.BlockCipher = Cipher.extend({
          cfg: Cipher.cfg.extend({
              mode: CBC,
              padding: Pkcs7
          }),
          reset: function () {
              Cipher.reset.call(this);
              var cfg = this.cfg;
              var iv = cfg.iv;
              var mode = cfg.mode;
              if (this._xformMode == this._ENC_XFORM_MODE) {
                  var modeCreator = mode.createEncryptor;
              } else {
                  var modeCreator = mode.createDecryptor;
                  this._minBufferSize = 1;
              }
              if (this._mode && this._mode.__creator == modeCreator) {
                  this._mode.init(this, iv && iv.words);
              } else {
                  this._mode = modeCreator.call(mode, this, iv && iv.words);
                  this._mode.__creator = modeCreator;
              }
          }, _doProcessBlock: function (words, offset) {
              this._mode.processBlock(words, offset);
          }, _doFinalize: function () {
              var padding = this.cfg.padding;
              if (this._xformMode == this._ENC_XFORM_MODE) {
                  padding.pad(this._data, this.blockSize);
                  var finalProcessedBlocks = this._process(!!'flush');
              } else {
                  var finalProcessedBlocks = this._process(!!'flush');
                  padding.unpad(finalProcessedBlocks);
              }
              return finalProcessedBlocks;
          }, blockSize: 128 / 32
      });
      var CipherParams = C_lib.CipherParams = Base.extend({
          init: function (cipherParams) {
              this.mixIn(cipherParams);
          }, toString: function (formatter) {
              return (formatter || this.formatter).stringify(this);
          }
      });
      var C_format = C.format = {};
      var OpenSSLFormatter = C_format.OpenSSL = {
          stringify: function (cipherParams) {
              var ciphertext = cipherParams.ciphertext;
              var salt = cipherParams.salt;
              if (salt) {
                  var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
              } else {
                  var wordArray = ciphertext;
              }
              return wordArray.toString(Base64);
          }, parse: function (openSSLStr) {
              var ciphertext = Base64.parse(openSSLStr);
              var ciphertextWords = ciphertext.words;
              if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
                  var salt = WordArray.create(ciphertextWords.slice(2, 4));
                  ciphertextWords.splice(0, 4);
                  ciphertext.sigBytes -= 16;
              }
              return CipherParams.create({
                  ciphertext: ciphertext,
                  salt: salt
              });
          }
      };
      var SerializableCipher = C_lib.SerializableCipher = Base.extend({
          cfg: Base.extend({
              format: OpenSSLFormatter
          }),
          encrypt: function (cipher, message, key, cfg) {
              cfg = this.cfg.extend(cfg);
              var encryptor = cipher.createEncryptor(key, cfg);
              var ciphertext = encryptor.finalize(message);
              var cipherCfg = encryptor.cfg;
              return CipherParams.create({
                  ciphertext: ciphertext,
                  key: key,
                  iv: cipherCfg.iv,
                  algorithm: cipher,
                  mode: cipherCfg.mode,
                  padding: cipherCfg.padding,
                  blockSize: cipher.blockSize,
                  formatter: cfg.format
              });
          }, decrypt: function (cipher, ciphertext, key, cfg) {
              cfg = this.cfg.extend(cfg);
              ciphertext = this._parse(ciphertext, cfg.format);
              var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
              return plaintext;
          }, _parse: function (ciphertext, format) {
              if (typeof ciphertext == 'string') {
                  return format.parse(ciphertext, this);
              } else {
                  return ciphertext;
              }
          }
      });
      var C_kdf = C.kdf = {};
      var OpenSSLKdf = C_kdf.OpenSSL = {
          execute: function (password, keySize, ivSize, salt) {
              if (!salt) {
                  salt = WordArray.random(64 / 8);
              }
              var key = EvpKDF.create({
                  keySize: keySize + ivSize
              }).compute(password, salt);
              var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
              key.sigBytes = keySize * 4;
              return CipherParams.create({
                  key: key,
                  iv: iv,
                  salt: salt
              });
          }
      };
      var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
          cfg: SerializableCipher.cfg.extend({
              kdf: OpenSSLKdf
          }),
          encrypt: function (cipher, message, password, cfg) {
              cfg = this.cfg.extend(cfg);
              var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
              cfg.iv = derivedParams.iv;
              var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
              ciphertext.mixIn(derivedParams);
              return ciphertext;
          }, decrypt: function (cipher, ciphertext, password, cfg) {
              cfg = this.cfg.extend(cfg);
              ciphertext = this._parse(ciphertext, cfg.format);
              var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
              cfg.iv = derivedParams.iv;
              var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
              return plaintext;
          }
      });
  }());
  
  (function () {
      var C = CryptoJS;
      var C_lib = C.lib;
      var BlockCipher = C_lib.BlockCipher;
      var C_algo = C.algo;
      var SBOX = [];
      var INV_SBOX = [];
      var SUB_MIX_0 = [];
      var SUB_MIX_1 = [];
      var SUB_MIX_2 = [];
      var SUB_MIX_3 = [];
      var INV_SUB_MIX_0 = [];
      var INV_SUB_MIX_1 = [];
      var INV_SUB_MIX_2 = [];
      var INV_SUB_MIX_3 = [];
      (function () {
          var d = [];
          for (var i = 0; i < 256; i++) {
              if (i < 128) {
                  d[i] = i << 1;
              } else {
                  d[i] = (i << 1) ^ 0x11b;
              }
          }
          var x = 0;
          var xi = 0;
          for (var i = 0; i < 256; i++) {
              var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
              sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
              SBOX[x] = sx;
              INV_SBOX[sx] = x;
              var x2 = d[x];
              var x4 = d[x2];
              var x8 = d[x4];
              var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
              SUB_MIX_0[x] = (t << 24) | (t >>> 8);
              SUB_MIX_1[x] = (t << 16) | (t >>> 16);
              SUB_MIX_2[x] = (t << 8) | (t >>> 24);
              SUB_MIX_3[x] = t;
              var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
              INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
              INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
              INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);
              INV_SUB_MIX_3[sx] = t;
              if (!x) {
                  x = xi = 1;
              } else {
                  x = x2 ^ d[d[d[x8 ^ x2]]];
                  xi ^= d[d[xi]];
              }
          }
      }());
      var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
      var AES = C_algo.AES = BlockCipher.extend({
          _doReset: function () {
              if (this._nRounds && this._keyPriorReset === this._key) {
                  return;
              }
              var key = this._keyPriorReset = this._key;
              var keyWords = key.words;
              var keySize = key.sigBytes / 4;
              var nRounds = this._nRounds = keySize + 6;
              var ksRows = (nRounds + 1) * 4;
              var keySchedule = this._keySchedule = [];
              for (var ksRow = 0; ksRow < ksRows; ksRow++) {
                  if (ksRow < keySize) {
                      keySchedule[ksRow] = keyWords[ksRow];
                  } else {
                      var t = keySchedule[ksRow - 1];
                      if (!(ksRow % keySize)) {
                          t = (t << 8) | (t >>> 24);
                          t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
                          t ^= RCON[(ksRow / keySize) | 0] << 24;
                      } else if (keySize > 6 && ksRow % keySize == 4) {
                          t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
                      }
                      keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
                  }
              }
              var invKeySchedule = this._invKeySchedule = [];
              for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
                  var ksRow = ksRows - invKsRow;
                  if (invKsRow % 4) {
                      var t = keySchedule[ksRow];
                  } else {
                      var t = keySchedule[ksRow - 4];
                  }
                  if (invKsRow < 4 || ksRow <= 4) {
                      invKeySchedule[invKsRow] = t;
                  } else {
                      invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^ INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
                  }
              }
          }, encryptBlock: function (M, offset) {
              this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
          }, decryptBlock: function (M, offset) {
              var t = M[offset + 1];
              M[offset + 1] = M[offset + 3];
              M[offset + 3] = t;
              this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
              var t = M[offset + 1];
              M[offset + 1] = M[offset + 3];
              M[offset + 3] = t;
          }, _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
              var nRounds = this._nRounds;
              var s0 = M[offset] ^ keySchedule[0];
              var s1 = M[offset + 1] ^ keySchedule[1];
              var s2 = M[offset + 2] ^ keySchedule[2];
              var s3 = M[offset + 3] ^ keySchedule[3];
              var ksRow = 4;
              for (var round = 1; round < nRounds; round++) {
                  var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
                  var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
                  var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
                  var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
                  s0 = t0;
                  s1 = t1;
                  s2 = t2;
                  s3 = t3;
              }
              var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
              var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
              var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
              var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
              M[offset] = t0;
              M[offset + 1] = t1;
              M[offset + 2] = t2;
              M[offset + 3] = t3;
          }, keySize: 256 / 32
      });
      C.AES = BlockCipher._createHelper(AES);
  }());
  
  
  function encrypt(data) {
      // var data = {
      //     points: track,
      //     distanceX: distance / 310,
      //     fp: fingerprint,
      //     address: "https://www.yunpian.com",
      //     yp_riddler_id: yp_riddler_id
      // },
      t = JSON.stringify(data);
      var e = getRandomStr(16)
          , n = getRandomStr(16);
      console.log(e,n)
      return {
          i: CryptoJS.AES.encrypt(t, CryptoJS.enc.Latin1.parse(e), {
              iv: CryptoJS.enc.Latin1.parse(n),
              mode: CryptoJS.mode.CBC,
              padding: CryptoJS.pad.Pkcs7
          }).toString(),
          k: rsaEncrypt(e + n)
      }
  }
  
  console.log(encrypt('{"browserInfo":[{"key":"userAgent","value":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36"},{"key":"language","value":"zh-CN"},{"key":"hardware_concurrency","value":4},{"key":"resolution","value":[1366,768]},{"key":"navigator_platform","value":"Win32"}],"mobile":"","nativeInfo":{},"options":{"sdk":"https://www.yunpian.com/static/official/js/libs/riddler-sdk-0.2.2.js?version=d64b4905b3d97729a01f89b39459c6ae"},"fp":"87a6ecfe812d030a3c2885223270da33","address":"https://www.yunpian.com","yp_riddler_id":"0dd345b7-b3b5-4c48-8b33-93dd4970e11f"}'));
  
  
  function get_cb() {
      var pool = {};
      for (var t; (t = Math.random().toString(32).replace("0.", "")) in pool;)
          ;
      return pool[t] = {
          ts: 1 / 0
      },
      t
  }
  
  console.log(get_cb());
  
  
  function RandomNum(min, max) {
      return Math.floor(Math.random()*(max-min)) + min + 1
  }
  
  function RandomChoice(arr) {
      return arr[Math.floor(Math.random()*arr.length)]
  }
  
  function get_trace(distance){
      distance = Math.floor(distance);
      var trace = [];
      var sy = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0];
      var st = [15, 16, 17, 18, 15, 16, 17, 18, 15, 16, 17, 18, 15, 16, 17, 18, 15, 16, 17, 18, 15, 16, 17, 18, 15, 16, 17,
          18, 15, 16, 17, 18, 15, 16, 17, 18, 15, 16, 17, 18, 14, 16, 17, 18, 16, 17, 18, 19, 20, 17];
      //items[Math.floor(Math.random()*items.length)]
  
      if (distance < 95) {
          var sx = [1, 2, 1, 2, 1, 2, 1, 1, 2, 1];
      }else{
          var sx = [1, 2, 1, 2, 1, 2, 2, 2, 3, 4];
      }
      // zt是第三个参数
      var zt = RandomNum(20, 200);
      // baseX X轴的位置 产生随机数字 也就是初始位置
      var baseX = RandomNum(810, 860),
          baseY = RandomNum(1190, 1220),
          zx = 0, // 后面需要移动的X位置
          zy = 0; // 后面需要移动的Y位置
      var random_x = RandomNum(9, 14);
      // 第一个点的位置 也就是初始化的位置 后续的位置都是基于此位置
      trace.push(["" + baseX, "" + baseY, zt]);
      var n = 0, x = 0, y = 0, t = 0;
      while (true){
          n += 1; // 循环次数
          if (n < 5){
              x = 1;
          }else{
              x = RandomChoice(sx)
          }
          if (distance > 125 && random_x === n){
              x = RandomNum(14, 18)
          }
          y = RandomChoice(sy);
          t = RandomChoice(st);
          zx += x;
          zy += y;
          zt += t;
          trace.push(["" + (zx + baseX), "" + (zy + baseY), zt]);
          if (distance - zx < 6){
              break;
          }
      }
      var value = distance - zx;
      for (var i = 0; i < value; i++){
          t = RandomChoice(st);
  
          if (value === i + 1){
              t = RandomNum(42, 56)
          }
          if (value === i + 2){
              t = RandomNum(32, 38)
          }
          if (value === i + 3){
              t = RandomNum(30, 36)
          }
          x = 1;
          zx += x;
          zt += t;
          trace.push([""+(zx + baseX), ""+ (zy + baseY), zt]);
      }
      t = RandomNum(100, 200);
      zt += t;
      trace.push([""+(zx + baseX), ""+ (zy + baseY), zt]);
  	return trace;
  }
  
  console.log(get_trace(100));
  