igwutil-yy 0.0.1-security → 1.0.5

package/SmCrypto-2.9.js

@@ -0,0 +1,3625 @@
+/********************************************/
+/*                                          */
+/*        Copyright (c) 2020 Aostar         */
+/*        @author bgu                       */
+/*        @version 2.9  		            */
+/*        四川中电启明星版权所有                */
+/********************************************/
+(function(factory){
+	if(typeof define == 'function' && define.amd){
+		define(factory);
+	}else{
+		factory();
+	}
+})(function(){
+function K(src, ei, ed, eo, dm) {
+	var gX = dm;
+	if (ei + dm > src.length && eo + dm <= ed.length) {
+		gX = src.length - ei;
+	} else if (eo + dm > ed.length && ei + dm <= src.length) {
+		gX = ed.length - eo;
+	} else if (ei + dm <= src.length && eo + dm <= ed.length) {
+		gX = dm;
+	} else if (ed.length < src.length) {
+		gX = ed.length - eo;
+	} else {
+		gX = src.length - eo;
+	}
+	for (var i = 0; i < gX; i++) {
+		ed[i + eo] = src[i + ei];
+	}
+};
+
+function co(jr, ei, ij, eo, dm) {
+	if (jr.length - ei < dm) {
+		return -1;
+	}
+	if (ij.length - eo < dm) {
+		return -1;
+	}
+	for (var i = 0; i < dm; i++) {
+		if (jr[ei++] != ij[eo++]) {
+			return -1;
+		}
+	}
+	return 0;
+};
+
+function F(hA) {
+	return new Array((hA >> 24) & 0x000000FF, (hA >> 16) & 0x000000FF, (hA >> 8) & 0x000000FF, (hA) & 0x000000FF);
+};
+
+function ap(gL) {
+	var b = new Array(gL.length * 4);
+	for (var i = 0; i < gL.length; i++) {
+		K(F(gL[i]), 0, b, i * 4, 4);
+	}
+	return b;
+};
+
+function bB(b, pos) {
+	if (pos + 3 < b.length) {
+		return ((b[pos]) << 24) | ((b[pos + 1]) << 16) | ((b[pos + 2]) << 8) | ((b[pos + 3]));
+	} else if (pos + 2 < b.length) {
+		return ((b[pos + 1]) << 16) | ((b[pos + 2]) << 8) | ((b[pos + 3]));
+	} else if (pos + 1 < b.length) {
+		return ((b[pos]) << 8) | ((b[pos + 1]));
+	} else {
+		return ((b[pos]));
+	}
+};
+
+function aI(b) {
+	var kF = Math.ceil(b.length / 4);
+	var out = new Array(kF);
+	for (var i = 0; i < b.length; i++) {
+		b[i] = b[i] & 0xFF;
+	}
+	for (var i = 0; i < out.length; i++) {
+		out[i] = bB(b, i * 4);
+	}
+	return out;
+};
+var CommonUtils = {
+	bytesToHex: function(ev) {
+		var dm = ev.length;
+		var dg = new Array(dm * 2);
+		var ju = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
+		for (var i = 0, j = 0; i < dm; i++, j++) {
+			dg[j] = ju[(ev[i] & 0xFF) >> 4];
+			dg[++j] = ju[(ev[i] & 0x0F)];
+		}
+		return dg.join('');
+	},
+	hexToBytes: function(hC) {
+		if (hC == null || hC == '') {
+			return null;
+		}
+		if (hC.length % 2 != 0) {
+			return null;
+		}
+		var il = hC.length / 2;
+		var dg = this.jY(hC);
+		var eG = new Array(il);
+		for (var i = 0; i < il; i++) {
+			if (dg[2 * i] >= 0x30 && dg[2 * i] <= 0x39) {
+				eG[i] = ((dg[2 * i] - 0x30) << 4);
+			} else if (dg[2 * i] >= 0x41 && dg[2 * i] <= 0x46) {
+				eG[i] = ((dg[2 * i] - 0x41 + 10) << 4);
+			} else if (dg[2 * i] >= 0x61 && dg[2 * i] <= 0x66) {
+				eG[i] = ((dg[2 * i] - 0x61 + 10) << 4);
+			} else {
+				return null;
+			}
+			if (dg[2 * i + 1] >= 0x30 && dg[2 * i + 1] <= 0x39) {
+				eG[i] = (eG[i] | (dg[2 * i + 1] - 0x30));
+			} else if (dg[2 * i + 1] >= 0x41 && dg[2 * i + 1] <= 0x46) {
+				eG[i] = (eG[i] | (dg[2 * i + 1] - 0x41 + 10));
+			} else if (dg[2 * i + 1] >= 0x61 && dg[2 * i + 1] <= 0x66) {
+				eG[i] = (eG[i] | (dg[2 * i + 1] - 0x61 + 10));
+			} else {
+				return null;
+			}
+		}
+		return eG;
+	},
+	utf8StrToHex: function(fT) {
+		var iG = encodeURIComponent(fT);
+		var gA = unescape(iG);
+		var iY = gA.length;
+		var eN = [];
+		for (var i = 0; i < iY; i++) {
+			eN[i] = (gA.charCodeAt(i).toString(16)).toUpperCase();
+		}
+		return eN.join('');
+	},
+	utf8StrToBytes: function(fT) {
+		var iG = encodeURIComponent(fT);
+		var gA = unescape(iG);
+		var iY = gA.length;
+		var eN = [];
+		for (var i = 0; i < iY; i++) {
+			eN[i] = gA.charCodeAt(i);
+		}
+		return eN;
+	},
+	hexToUtf8Str: function(fT) {
+		var gn = CommonUtils.hexToBytes(fT);
+		var gE = [];
+		for (var i = 0; i < gn.length; i++) {
+			gE.push(String.fromCharCode(gn[i]));
+		}
+		return decodeURIComponent(escape(gE.join('')));
+	},
+	bytesToUtf8Str: function(kt) {
+		var gn = kt;
+		var gE = [];
+		for (var i = 0; i < gn.length; i++) {
+			gE.push(String.fromCharCode(gn[i]));
+		}
+		return decodeURIComponent(escape(gE.join('')));
+	},
+	jY: function(hN) {
+		var iW = new Array(hN.length);
+		for (var i = 0; i < hN.length; i++) {
+			iW[i] = hN.charCodeAt(i);
+		}
+		return iW;
+	},
+	isHexString: function(fL) {
+		var pattern = new RegExp(/^[A-Za-z0-9]+$/);
+		return fL != null && pattern.test(fL);
+	},
+	randomWord: function(dm) {
+		var fL = "";
+		var hF = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
+			'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B',
+			'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+			'V', 'W', 'X', 'Y', 'Z', '~', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_'
+		];
+		for (var i = 0; i < dm; i++) {
+			pos = Math.round(Math.random() * (hF.length - 1));
+			fL += hF[pos];
+		}
+		return fL;
+	},
+	randomHex: function(dm) {
+		var fL = "";
+		var hF = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+		for (var i = 0; i < dm; i++) {
+			pos = Math.round(Math.random() * (hF.length - 1));
+			fL += hF[pos];
+		}
+		return fL;
+	},
+	equals: function(eH, fv) {
+		for (fK in eH) {
+			if (eH.hasOwnProperty(fK) != fv.hasOwnProperty(fK)) {
+				return false;
+			} else if (typeof eH[fK] != typeof fv[fK]) {
+				return false;
+			}
+		}
+		for (fK in fv) {
+			if (eH.hasOwnProperty(fK) != fv.hasOwnProperty(fK)) {
+				return false;
+			} else if (typeof eH[fK] != typeof fv[fK]) {
+				return false;
+			}
+			if (!eH.hasOwnProperty(fK)) continue;
+			if (eH[fK] instanceof Array && fv[fK] instanceof Array) {
+				if (!eH[fK].equals(fv[fK])) return false;
+			} else if (eH[fK] instanceof Object && fv[fK] instanceof Object) {
+				if (!eH[fK].equals(fv[fK])) return false;
+			} else if (eH[fK] != fv[fK]) {
+				return false;
+			}
+		}
+		return true;
+	},
+	v_ltd: function() {
+		var word = new jW.mG.mP.gD([-442786843, -1214389064, -1377332043, -443502618, -1735465320, -1612398687,
+			-427708442, -1971263844, -1343841143, -375811867, -2052266609, -1207959552
+		]);
+		var text = word.toString(jW.ey.nj);
+		return text;
+	}
+};
+var ep;
+var kK = 0xdeadbeefcafe;
+var iL = ((kK & 0xffffff) == 0xefcafe);
+
+function L(a, b, c) {
+	if (a != null)
+		if ("number" == typeof a) this.iM(a, b, c);
+		else if (b == null && "string" != typeof a) this.hK(a, 256);
+	else this.hK(a, b);
+};
+
+function C() {
+	return new L(null);
+};
+
+function al(i, x, w, j, c, n) {
+	while (--n >= 0) {
+		var v = x * this[i++] + w[j] + c;
+		c = Math.floor(v / 0x4000000);
+		w[j++] = v & 0x3ffffff;
+	}
+	return c;
+};
+
+function bD(i, x, w, j, c, n) {
+	var gw = x & 0x7fff,
+		gl = x >> 15;
+	while (--n >= 0) {
+		var l = this[i] & 0x7fff;
+		var h = this[i++] >> 15;
+		var m = gl * l + h * gw;
+		l = gw * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);
+		c = (l >>> 30) + (m >>> 15) + gl * h + (c >>> 30);
+		w[j++] = l & 0x3fffffff;
+	}
+	return c;
+};
+
+function dK(i, x, w, j, c, n) {
+	var gw = x & 0x3fff,
+		gl = x >> 14;
+	while (--n >= 0) {
+		var l = this[i] & 0x3fff;
+		var h = this[i++] >> 14;
+		var m = gl * l + h * gw;
+		l = gw * l + ((m & 0x3fff) << 14) + w[j] + c;
+		c = (l >> 28) + (m >> 14) + gl * h;
+		w[j++] = l & 0xfffffff;
+	}
+	return c;
+};
+if (iL && (navigator.appName == "Microsoft Internet Explorer")) {
+	L.prototype.eZ = bD;
+	ep = 30;
+} else if (iL && (navigator.appName != "Netscape")) {
+	L.prototype.eZ = al;
+	ep = 26;
+} else {
+	L.prototype.eZ = dK;
+	ep = 28;
+}
+L.prototype.ct = ep;
+L.prototype.fi = ((1 << ep) - 1);
+L.prototype.ez = (1 << ep);
+var im = 52;
+L.prototype.ku = Math.pow(2, im);
+L.prototype.iR = im - ep;
+L.prototype.io = 2 * ep - im;
+var jV = "0123456789abcdefghijklmnopqrstuvwxyz";
+var gQ = new Array();
+var gr = "0".charCodeAt(0);
+for (var ej = 0; ej <= 9; ++ej) gQ[gr++] = ej;
+gr = "a".charCodeAt(0);
+for (var ej = 10; ej < 36; ++ej) gQ[gr++] = ej;
+gr = "A".charCodeAt(0);
+for (var ej = 10; ej < 36; ++ej) gQ[gr++] = ej;
+
+function bk(n) {
+	return jV.charAt(n);
+};
+
+function bw(s, i) {
+	var c = gQ[s.charCodeAt(i)];
+	return (c == null) ? -1 : c;
+};
+
+function dQ(r) {
+	for (var i = this.t - 1; i >= 0; --i) r[i] = this[i];
+	r.t = this.t;
+	r.s = this.s;
+};
+
+function cS(x) {
+	this.t = 1;
+	this.s = (x < 0) ? -1 : 0;
+	if (x > 0) this[0] = x;
+	else if (x < -1) this[0] = x + this.ez;
+	else this.t = 0;
+};
+
+function H(i) {
+	var r = C();
+	r.eT(i);
+	return r;
+};
+
+function dc(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.jP(s, b);
+		return;
+	}
+	this.t = 0;
+	this.s = 0;
+	var i = s.length,
+		gO = false,
+		fr = 0;
+	while (--i >= 0) {
+		var x = (k == 8) ? s[i] & 0xff : bw(s, i);
+		if (x < 0) {
+			if (s.charAt(i) == "-") gO = true;
+			continue;
+		}
+		gO = false;
+		if (fr == 0) this[this.t++] = x;
+		else if (fr + k > this.ct) {
+			this[this.t - 1] |= (x & ((1 << (this.ct - fr)) - 1)) << fr;
+			this[this.t++] = (x >> (this.ct - fr));
+		} else this[this.t - 1] |= x << fr;
+		fr += k;
+		if (fr >= this.ct) fr -= this.ct;
+	}
+	if (k == 8 && (s[0] & 0x80) != 0) {
+		this.s = -1;
+		if (fr > 0) this[this.t - 1] |= ((1 << (this.ct - fr)) - 1) << fr;
+	}
+	this.ff();
+	if (gO) L.ZERO.cp(this, this);
+};
+
+function cf() {
+	var c = this.s & this.fi;
+	while (this.t > 0 && this[this.t - 1] == c) --this.t;
+};
+
+function aH(b) {
+	if (this.s < 0) return "-" + this.el().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.eD(b);
+	var hx = (1 << k) - 1,
+		d, m = false,
+		r = "",
+		i = this.t;
+	var p = this.ct - (i * this.ct) % k;
+	if (i-- > 0) {
+		if (p < this.ct && (d = this[i] >> p) > 0) {
+			m = true;
+			r = bk(d);
+		}
+		while (i >= 0) {
+			if (p < k) {
+				d = (this[i] & ((1 << p) - 1)) << (k - p);
+				d |= this[--i] >> (p += this.ct - k);
+			} else {
+				d = (this[i] >> (p -= k)) & hx;
+				if (p <= 0) {
+					p += this.ct;
+					--i;
+				}
+			}
+			if (d > 0) m = true;
+			if (m) r += bk(d);
+		}
+	}
+	return m ? r : "0";
+};
+
+function aL() {
+	var r = C();
+	L.ZERO.cp(this, r);
+	return r;
+};
+
+function cn() {
+	return (this.s < 0) ? this.el() : this;
+};
+
+function aD(a) {
+	var r = this.s - a.s;
+	if (r != 0) return r;
+	var i = this.t;
+	r = i - a.t;
+	if (r != 0) return (this.s < 0) ? -r : r;
+	while (--i >= 0)
+		if ((r = this[i] - a[i]) != 0) return r;
+	return 0;
+};
+
+function bN(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 dI() {
+	if (this.t <= 0) return 0;
+	return this.ct * (this.t - 1) + bN(this[this.t - 1] ^ (this.s & this.fi));
+};
+
+function da(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 cP(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 cq(n, r) {
+	var fD = n % this.ct;
+	var gC = this.ct - fD;
+	var hD = (1 << gC) - 1;
+	var eL = Math.floor(n / this.ct),
+		c = (this.s << fD) & this.fi,
+		i;
+	for (i = this.t - 1; i >= 0; --i) {
+		r[i + eL + 1] = (this[i] >> gC) | c;
+		c = (this[i] & hD) << fD;
+	}
+	for (i = eL - 1; i >= 0; --i) r[i] = 0;
+	r[eL] = c;
+	r.t = this.t + eL + 1;
+	r.s = this.s;
+	r.ff();
+};
+
+function dM(n, r) {
+	r.s = this.s;
+	var eL = Math.floor(n / this.ct);
+	if (eL >= this.t) {
+		r.t = 0;
+		return;
+	}
+	var fD = n % this.ct;
+	var gC = this.ct - fD;
+	var hD = (1 << fD) - 1;
+	r[0] = this[eL] >> fD;
+	for (var i = eL + 1; i < this.t; ++i) {
+		r[i - eL - 1] |= (this[i] & hD) << gC;
+		r[i - eL] = this[i] >> fD;
+	}
+	if (fD > 0) r[this.t - eL - 1] |= (this.s & hD) << gC;
+	r.t = this.t - eL;
+	r.ff();
+};
+
+function de(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.fi;
+		c >>= this.ct;
+	}
+	if (a.t < this.t) {
+		c -= a.s;
+		while (i < this.t) {
+			c += this[i];
+			r[i++] = c & this.fi;
+			c >>= this.ct;
+		}
+		c += this.s;
+	} else {
+		c += this.s;
+		while (i < a.t) {
+			c -= a[i];
+			r[i++] = c & this.fi;
+			c >>= this.ct;
+		}
+		c -= a.s;
+	}
+	r.s = (c < 0) ? -1 : 0;
+	if (c < -1) r[i++] = this.ez + c;
+	else if (c > 0) r[i++] = c;
+	r.t = i;
+	r.ff();
+};
+
+function bX(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.eZ(0, y[i], r, i, 0, x.t);
+	r.s = 0;
+	r.ff();
+	if (this.s != a.s) L.ZERO.cp(r, r);
+};
+
+function cr(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.eZ(i, x[i], r, 2 * i, 0, 1);
+		if ((r[i + x.t] += x.eZ(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.ez) {
+			r[i + x.t] -= x.ez;
+			r[i + x.t + 1] = 1;
+		}
+	}
+	if (r.t > 0) r[r.t - 1] += x.eZ(i, x[i], r, 2 * i, 0, 1);
+	r.s = 0;
+	r.ff();
+};
+
+function dJ(m, q, r) {
+	var hz = m.abs();
+	if (hz.t <= 0) return;
+	var pt = this.abs();
+	if (pt.t < hz.t) {
+		if (q != null) q.eT(0);
+		if (r != null) this.eh(r);
+		return;
+	}
+	if (r == null) r = C();
+	var y = C(),
+		jb = this.s,
+		ms = m.s;
+	var gP = this.ct - bN(hz[hz.t - 1]);
+	if (gP > 0) {
+		hz.gx(gP, y);
+		pt.gx(gP, r);
+	} else {
+		hz.eh(y);
+		pt.eh(r);
+	}
+	var fG = y.t;
+	var gb = y[fG - 1];
+	if (gb == 0) return;
+	var jA = gb * (1 << this.iR) + ((fG > 1) ? y[fG - 2] >> this.io : 0);
+	var kA = this.ku / jA,
+		ko = (1 << this.iR) / jA,
+		e = 1 << this.io;
+	var i = r.t,
+		j = i - fG,
+		t = (q == null) ? C() : q;
+	y.gS(j, t);
+	if (r.dw(t) >= 0) {
+		r[r.t++] = 1;
+		r.cp(t, r);
+	}
+	L.ONE.gS(fG, t);
+	t.cp(y, y);
+	while (y.t < fG) y[y.t++] = 0;
+	while (--j >= 0) {
+		var gc = (r[--i] == gb) ? this.fi : Math.floor(r[i] * kA + (r[i - 1] + e) * ko);
+		if ((r[i] += y.eZ(0, gc, r, j, 0, fG)) < gc) {
+			y.gS(j, t);
+			r.cp(t, r);
+			while (r[i] < --gc) r.cp(t, r);
+		}
+	}
+	if (q != null) {
+		r.gJ(fG, q);
+		if (jb != ms) L.ZERO.cp(q, q);
+	}
+	r.t = fG;
+	r.ff();
+	if (gP > 0) r.dY(gP, r);
+	if (jb < 0) L.ZERO.cp(r, r);
+};
+
+function aZ(a) {
+	var r = C();
+	this.abs().fw(a, null, r);
+	if (this.s < 0 && r.dw(L.ZERO) > 0) a.cp(r, r);
+	return r;
+};
+
+function af(m) {
+	this.m = m;
+};
+
+function ak(x) {
+	if (x.s < 0 || x.dw(this.m) >= 0) return x.cl(this.m);
+	else return x;
+};
+
+function aj(x) {
+	return x;
+};
+
+function aU(x) {
+	x.fw(this.m, null, x);
+};
+
+function bM(x, y, r) {
+	x.gG(y, r);
+	this.reduce(r);
+};
+
+function bE(x, r) {
+	x.hc(r);
+	this.reduce(r);
+};
+af.prototype.convert = ak;
+af.prototype.revert = aj;
+af.prototype.reduce = aU;
+af.prototype.fO = bM;
+af.prototype.eO = bE;
+
+function dh() {
+	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.ez)) % this.ez;
+	return (y > 0) ? this.ez - y : -y;
+};
+
+function O(m) {
+	this.m = m;
+	this.ik = m.kC();
+	this.jB = this.ik & 0x7fff;
+	this.kl = this.ik >> 15;
+	this.lf = (1 << (m.ct - 15)) - 1;
+	this.kV = 2 * m.t;
+};
+
+function bC(x) {
+	var r = C();
+	x.abs().gS(this.m.t, r);
+	r.fw(this.m, null, r);
+	if (x.s < 0 && r.dw(L.ZERO) > 0) this.m.cp(r, r);
+	return r;
+};
+
+function ax(x) {
+	var r = C();
+	x.eh(r);
+	this.reduce(r);
+	return r;
+};
+
+function au(x) {
+	while (x.t <= this.kV) x[x.t++] = 0;
+	for (var i = 0; i < this.m.t; ++i) {
+		var j = x[i] & 0x7fff;
+		var kh = (j * this.jB + (((j * this.kl + (x[i] >> 15) * this.jB) & this.lf) << 15)) & x.fi;
+		j = i + this.m.t;
+		x[j] += this.m.eZ(0, kh, x, i, 0, this.m.t);
+		while (x[j] >= x.ez) {
+			x[j] -= x.ez;
+			x[++j]++;
+		}
+	}
+	x.ff();
+	x.gJ(this.m.t, x);
+	if (x.dw(this.m) >= 0) x.cp(this.m, x);
+};
+
+function aC(x, r) {
+	x.hc(r);
+	this.reduce(r);
+};
+
+function bi(x, y, r) {
+	x.gG(y, r);
+	this.reduce(r);
+};
+O.prototype.convert = bC;
+O.prototype.revert = ax;
+O.prototype.reduce = au;
+O.prototype.fO = bi;
+O.prototype.eO = aC;
+
+function cz() {
+	return ((this.t > 0) ? (this[0] & 1) : this.s) == 0;
+};
+
+function df(e, z) {
+	if (e > 0xffffffff || e < 1) return L.ONE;
+	var r = C(),
+		r2 = C(),
+		g = z.convert(this),
+		i = bN(e) - 1;
+	g.eh(r);
+	while (--i >= 0) {
+		z.eO(r, r2);
+		if ((e & (1 << i)) > 0) z.fO(r2, g, r);
+		else {
+			var t = r;
+			r = r2;
+			r2 = t;
+		}
+	}
+	return z.revert(r);
+};
+
+function bH(e, m) {
+	var z;
+	if (e < 256 || m.ef()) z = new af(m);
+	else z = new O(m);
+	return this.exp(e, z);
+};
+L.prototype.eh = dQ;
+L.prototype.eT = cS;
+L.prototype.hK = dc;
+L.prototype.ff = cf;
+L.prototype.gS = da;
+L.prototype.gJ = cP;
+L.prototype.gx = cq;
+L.prototype.dY = dM;
+L.prototype.cp = de;
+L.prototype.gG = bX;
+L.prototype.hc = cr;
+L.prototype.fw = dJ;
+L.prototype.kC = dh;
+L.prototype.ef = cz;
+L.prototype.exp = df;
+L.prototype.toString = aH;
+L.prototype.el = aL;
+L.prototype.abs = cn;
+L.prototype.dw = aD;
+L.prototype.fg = dI;
+L.prototype.cl = aZ;
+L.prototype.kr = bH;
+L.ZERO = H(0);
+L.ONE = H(1);
+
+function an() {
+	var r = C();
+	this.eh(r);
+	return r;
+};
+
+function bK() {
+	if (this.s < 0) {
+		if (this.t == 1) return this[0] - this.ez;
+		else if (this.t == 0) return -1;
+	} else if (this.t == 1) return this[0];
+	else if (this.t == 0) return 0;
+	return ((this[1] & ((1 << (32 - this.ct)) - 1)) << this.ct) | this[0];
+};
+
+function cI() {
+	return (this.t == 0) ? this.s : (this[0] << 24) >> 24;
+};
+
+function dn() {
+	return (this.t == 0) ? this.s : (this[0] << 16) >> 16;
+};
+
+function ca(r) {
+	return Math.floor(Math.LN2 * this.ct / Math.log(r));
+};
+
+function aF() {
+	if (this.s < 0) return -1;
+	else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
+	else return 1;
+};
+
+function dk(b) {
+	if (b == null) b = 10;
+	if (this.eJ() == 0 || b < 2 || b > 36) return "0";
+	var gf = this.iw(b);
+	var a = Math.pow(b, gf);
+	var d = H(a),
+		y = C(),
+		z = C(),
+		r = "";
+	this.fw(d, y, z);
+	while (y.eJ() > 0) {
+		r = (a + z.hs()).toString(b).substr(1) + r;
+		y.fw(d, y, z);
+	}
+	return z.hs().toString(b) + r;
+};
+
+function bY(s, b) {
+	this.eT(0);
+	if (b == null) b = 10;
+	var gf = this.iw(b);
+	var d = Math.pow(b, gf),
+		gO = false,
+		j = 0,
+		w = 0;
+	for (var i = 0; i < s.length; ++i) {
+		var x = bw(s, i);
+		if (x < 0) {
+			if (s.charAt(i) == "-" && this.eJ() == 0) gO = true;
+			continue;
+		}
+		w = b * w + x;
+		if (++j >= gf) {
+			this.ja(d);
+			this.hJ(w, 0);
+			j = 0;
+			w = 0;
+		}
+	}
+	if (j > 0) {
+		this.ja(Math.pow(b, j));
+		this.hJ(w, 0);
+	}
+	if (gO) L.ZERO.cp(this, this);
+};
+
+function cX(a, b, c) {
+	if ("number" == typeof b) {
+		if (a < 2) this.eT(1);
+		else {
+			this.iM(a, c);
+			if (!this.en(a - 1)) this.gj(L.ONE.shiftLeft(a - 1), ay, this);
+			if (this.ef()) this.hJ(1, 0);
+			while (!this.kv(b)) {
+				this.hJ(2, 0);
+				if (this.fg() > a) this.cp(L.ONE.shiftLeft(a - 1), this);
+			}
+		}
+	} else {
+		var x = new Array(),
+			t = a & 7;
+		x.length = (a >> 3) + 1;
+		b.kj(x);
+		if (t > 0) x[0] &= ((1 << t) - 1);
+		else x[0] = 0;
+		this.hK(x, 256);
+	}
+};
+
+function bv() {
+	var i = this.t,
+		r = new Array();
+	r[0] = this.s;
+	var p = this.ct - (i * this.ct) % 8,
+		d, k = 0;
+	if (i-- > 0) {
+		if (p < this.ct && (d = this[i] >> p) != (this.s & this.fi) >> p) r[k++] = d | (this.s << (this.ct - p));
+		while (i >= 0) {
+			if (p < 8) {
+				d = (this[i] & ((1 << p) - 1)) << (8 - p);
+				d |= this[--i] >> (p += this.ct - 8);
+			} else {
+				d = (this[i] >> (p -= 8)) & 0xff;
+				if (p <= 0) {
+					p += this.ct;
+					--i;
+				}
+			}
+			if ((d & 0x80) != 0) d |= -256;
+			if (k == 0 && (this.s & 0x80) != (d & 0x80)) ++k;
+			if (k > 0 || d != this.s) r[k++] = d;
+		}
+	}
+	return r;
+};
+
+function ab(a) {
+	return (this.dw(a) == 0);
+};
+
+function aw(a) {
+	return (this.dw(a) < 0) ? this : a;
+};
+
+function ao(a) {
+	return (this.dw(a) > 0) ? this : a;
+};
+
+function cC(a, hv, r) {
+	var i, f, m = Math.min(a.t, this.t);
+	for (i = 0; i < m; ++i) r[i] = hv(this[i], a[i]);
+	if (a.t < this.t) {
+		f = a.s & this.fi;
+		for (i = m; i < this.t; ++i) r[i] = hv(this[i], f);
+		r.t = this.t;
+	} else {
+		f = this.s & this.fi;
+		for (i = m; i < a.t; ++i) r[i] = hv(f, a[i]);
+		r.t = a.t;
+	}
+	r.s = hv(this.s, a.s);
+	r.ff();
+};
+
+function aR(x, y) {
+	return x & y;
+};
+
+function dN(a) {
+	var r = C();
+	this.gj(a, aR, r);
+	return r;
+};
+
+function ay(x, y) {
+	return x | y;
+};
+
+function bW(a) {
+	var r = C();
+	this.gj(a, ay, r);
+	return r;
+};
+
+function aT(x, y) {
+	return x ^ y;
+};
+
+function aQ(a) {
+	var r = C();
+	this.gj(a, aT, r);
+	return r;
+};
+
+function ag(x, y) {
+	return x & ~y;
+};
+
+function cg(a) {
+	var r = C();
+	this.gj(a, ag, r);
+	return r;
+};
+
+function db() {
+	var r = C();
+	for (var i = 0; i < this.t; ++i) r[i] = this.fi & ~this[i];
+	r.t = this.t;
+	r.s = ~this.s;
+	return r;
+};
+
+function cA(n) {
+	var r = C();
+	if (n < 0) this.dY(-n, r);
+	else this.gx(n, r);
+	return r;
+};
+
+function dv(n) {
+	var r = C();
+	if (n < 0) this.gx(-n, r);
+	else this.dY(n, r);
+	return r;
+};
+
+function aA(x) {
+	if (x == 0) return -1;
+	var r = 0;
+	if ((x & 0xffff) == 0) {
+		x >>= 16;
+		r += 16;
+	}
+	if ((x & 0xff) == 0) {
+		x >>= 8;
+		r += 8;
+	}
+	if ((x & 0xf) == 0) {
+		x >>= 4;
+		r += 4;
+	}
+	if ((x & 3) == 0) {
+		x >>= 2;
+		r += 2;
+	}
+	if ((x & 1) == 0) ++r;
+	return r;
+};
+
+function aq() {
+	for (var i = 0; i < this.t; ++i)
+		if (this[i] != 0) return i * this.ct + aA(this[i]);
+	if (this.s < 0) return this.t * this.ct;
+	return -1;
+};
+
+function ad(x) {
+	var r = 0;
+	while (x != 0) {
+		x &= x - 1;
+		++r;
+	}
+	return r;
+};
+
+function cj() {
+	var r = 0,
+		x = this.s & this.fi;
+	for (var i = 0; i < this.t; ++i) r += ad(this[i] ^ x);
+	return r;
+};
+
+function aM(n) {
+	var j = Math.floor(n / this.ct);
+	if (j >= this.t) return (this.s != 0);
+	return ((this[j] & (1 << (n % this.ct))) != 0);
+};
+
+function dE(n, hv) {
+	var r = L.ONE.shiftLeft(n);
+	this.gj(r, hv, r);
+	return r;
+};
+
+function cc(n) {
+	return this.hY(n, ay);
+};
+
+function cT(n) {
+	return this.hY(n, ag);
+};
+
+function bb(n) {
+	return this.hY(n, aT);
+};
+
+function ce(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.fi;
+		c >>= this.ct;
+	}
+	if (a.t < this.t) {
+		c += a.s;
+		while (i < this.t) {
+			c += this[i];
+			r[i++] = c & this.fi;
+			c >>= this.ct;
+		}
+		c += this.s;
+	} else {
+		c += this.s;
+		while (i < a.t) {
+			c += a[i];
+			r[i++] = c & this.fi;
+			c >>= this.ct;
+		}
+		c += a.s;
+	}
+	r.s = (c < 0) ? -1 : 0;
+	if (c > 0) r[i++] = c;
+	else if (c < -1) r[i++] = this.ez + c;
+	r.t = i;
+	r.ff();
+};
+
+function cO(a) {
+	var r = C();
+	this.hG(a, r);
+	return r;
+};
+
+function bQ(a) {
+	var r = C();
+	this.cp(a, r);
+	return r;
+};
+
+function bF(a) {
+	var r = C();
+	this.gG(a, r);
+	return r;
+};
+
+function aa() {
+	var r = C();
+	this.hc(r);
+	return r;
+};
+
+function bd(a) {
+	var r = C();
+	this.fw(a, r, null);
+	return r;
+};
+
+function cQ(a) {
+	var r = C();
+	this.fw(a, null, r);
+	return r;
+};
+
+function bI(a) {
+	var q = C(),
+		r = C();
+	this.fw(a, q, r);
+	return new Array(q, r);
+};
+
+function dp(n) {
+	this[this.t] = this.eZ(0, n - 1, this, 0, 0, this.t);
+	++this.t;
+	this.ff();
+};
+
+function cJ(n, w) {
+	if (n == 0) return;
+	while (this.t <= w) this[this.t++] = 0;
+	this[w] += n;
+	while (this[w] >= this.ez) {
+		this[w] -= this.ez;
+		if (++w >= this.t) this[this.t++] = 0;
+		++this[w];
+	}
+};
+
+function bj() {};
+
+function aY(x) {
+	return x;
+};
+
+function aG(x, y, r) {
+	x.gG(y, r);
+};
+
+function bA(x, r) {
+	x.hc(r);
+};
+bj.prototype.convert = aY;
+bj.prototype.revert = aY;
+bj.prototype.fO = aG;
+bj.prototype.eO = bA;
+
+function cG(e) {
+	return this.exp(e, new bj());
+};
+
+function cW(a, n, r) {
+	var i = Math.min(this.t + a.t, n);
+	r.s = 0;
+	r.t = i;
+	while (i > 0) r[--i] = 0;
+	var j;
+	for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.eZ(0, a[i], r, i, 0, this.t);
+	for (j = Math.min(a.t, n); i < j; ++i) this.eZ(0, a[i], r, i, 0, n - i);
+	r.ff();
+};
+
+function ci(a, n, r) {
+	--n;
+	var i = r.t = this.t + a.t - n;
+	r.s = 0;
+	while (--i >= 0) r[i] = 0;
+	for (i = Math.max(n - this.t, 0); i < a.t; ++i) r[this.t + i - n] = this.eZ(n - i, a[i], r, 0, 0, this.t + i - n);
+	r.ff();
+	r.gJ(1, r);
+};
+
+function bh(m) {
+	this.r2 = C();
+	this.jx = C();
+	L.ONE.gS(2 * m.t, this.r2);
+	this.jQ = this.r2.divide(m);
+	this.m = m;
+};
+
+function bu(x) {
+	if (x.s < 0 || x.t > 2 * this.m.t) return x.cl(this.m);
+	else if (x.dw(this.m) < 0) return x;
+	else {
+		var r = C();
+		x.eh(r);
+		this.reduce(r);
+		return r;
+	}
+};
+
+function aN(x) {
+	return x;
+};
+
+function bS(x) {
+	x.gJ(this.m.t - 1, this.r2);
+	if (x.t > this.m.t + 1) {
+		x.t = this.m.t + 1;
+		x.ff();
+	}
+	this.jQ.ld(this.r2, this.m.t + 1, this.jx);
+	this.m.lx(this.jx, this.m.t + 1, this.r2);
+	while (x.dw(this.r2) < 0) x.hJ(1, this.m.t + 1);
+	x.cp(this.r2, x);
+	while (x.dw(this.m) >= 0) x.cp(this.m, x);
+};
+
+function dq(x, r) {
+	x.hc(r);
+	this.reduce(r);
+};
+
+function bU(x, y, r) {
+	x.gG(y, r);
+	this.reduce(r);
+};
+bh.prototype.convert = bu;
+bh.prototype.revert = aN;
+bh.prototype.reduce = bS;
+bh.prototype.fO = bU;
+bh.prototype.eO = dq;
+
+function aE(e, m) {
+	var i = e.fg(),
+		k, r = H(1),
+		z;
+	if (i <= 0) return r;
+	else if (i < 18) k = 1;
+	else if (i < 48) k = 3;
+	else if (i < 144) k = 4;
+	else if (i < 768) k = 5;
+	else k = 6;
+	if (i < 8) z = new af(m);
+	else if (m.ef()) z = new bh(m);
+	else z = new O(m);
+	var g = new Array(),
+		n = 3,
+		hh = k - 1,
+		hx = (1 << k) - 1;
+	g[1] = z.convert(this);
+	if (k > 1) {
+		var jg = C();
+		z.eO(g[1], jg);
+		while (n <= hx) {
+			g[n] = C();
+			z.fO(jg, g[n - 2], g[n]);
+			n += 2;
+		}
+	}
+	var j = e.t - 1,
+		w, iZ = true,
+		r2 = C(),
+		t;
+	i = bN(e[j]) - 1;
+	while (j >= 0) {
+		if (i >= hh) w = (e[j] >> (i - hh)) & hx;
+		else {
+			w = (e[j] & ((1 << (i + 1)) - 1)) << (hh - i);
+			if (j > 0) w |= e[j - 1] >> (this.ct + i - hh);
+		}
+		n = k;
+		while ((w & 1) == 0) {
+			w >>= 1;
+			--n;
+		}
+		if ((i -= n) < 0) {
+			i += this.ct;
+			--j;
+		}
+		if (iZ) {
+			g[w].eh(r);
+			iZ = false;
+		} else {
+			while (n > 1) {
+				z.eO(r, r2);
+				z.eO(r2, r);
+				n -= 2;
+			}
+			if (n > 0) z.eO(r, r2);
+			else {
+				t = r;
+				r = r2;
+				r2 = t;
+			}
+			z.fO(r2, g[w], r);
+		}
+		while (j >= 0 && (e[j] & (1 << i)) == 0) {
+			z.eO(r, r2);
+			t = r;
+			r = r2;
+			r2 = t;
+			if (--i < 0) {
+				i = this.ct - 1;
+				--j;
+			}
+		}
+	}
+	return z.revert(r);
+};
+
+function aV(a) {
+	var x = (this.s < 0) ? this.el() : this.clone();
+	var y = (a.s < 0) ? a.el() : a.clone();
+	if (x.dw(y) < 0) {
+		var t = x;
+		x = y;
+		y = t;
+	}
+	var i = x.gg(),
+		g = y.gg();
+	if (g < 0) return x;
+	if (i < g) g = i;
+	if (g > 0) {
+		x.dY(g, x);
+		y.dY(g, y);
+	}
+	while (x.eJ() > 0) {
+		if ((i = x.gg()) > 0) x.dY(i, x);
+		if ((i = y.gg()) > 0) y.dY(i, y);
+		if (x.dw(y) >= 0) {
+			x.cp(y, x);
+			x.dY(1, x);
+		} else {
+			y.cp(x, y);
+			y.dY(1, y);
+		}
+	}
+	if (g > 0) y.gx(g, y);
+	return y;
+};
+
+function di(n) {
+	if (n <= 0) return 0;
+	var d = this.ez % n,
+		r = (this.s < 0) ? n - 1 : 0;
+	if (this.t > 0)
+		if (d == 0) r = this[0] % n;
+		else
+			for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n;
+	return r;
+};
+
+function ah(m) {
+	var fY = m.ef();
+	if ((this.ef() && fY) || m.eJ() == 0) return L.ZERO;
+	var u = m.clone(),
+		v = this.clone();
+	var a = H(1),
+		b = H(0),
+		c = H(0),
+		d = H(1);
+	while (u.eJ() != 0) {
+		while (u.ef()) {
+			u.dY(1, u);
+			if (fY) {
+				if (!a.ef() || !b.ef()) {
+					a.hG(this, a);
+					b.cp(m, b);
+				}
+				a.dY(1, a);
+			} else if (!b.ef()) b.cp(m, b);
+			b.dY(1, b);
+		}
+		while (v.ef()) {
+			v.dY(1, v);
+			if (fY) {
+				if (!c.ef() || !d.ef()) {
+					c.hG(this, c);
+					d.cp(m, d);
+				}
+				c.dY(1, c);
+			} else if (!d.ef()) d.cp(m, d);
+			d.dY(1, d);
+		}
+		if (u.dw(v) >= 0) {
+			u.cp(v, u);
+			if (fY) a.cp(c, a);
+			b.cp(d, b);
+		} else {
+			v.cp(u, v);
+			if (fY) c.cp(a, c);
+			d.cp(b, d);
+		}
+	}
+	if (v.dw(L.ONE) != 0) return L.ZERO;
+	if (d.dw(m) >= 0) return d.cv(m);
+	if (d.eJ() < 0) d.hG(m, d);
+	else return d;
+	if (d.eJ() < 0) return d.add(m);
+	else return d;
+};
+var eb = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
+	109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
+	233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
+	367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
+	499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
+	643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
+	797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
+	947, 953, 967, 971, 977, 983, 991, 997
+];
+var kE = (1 << 26) / eb[eb.length - 1];
+
+function as(t) {
+	var i, x = this.abs();
+	if (x.t == 1 && x[0] <= eb[eb.length - 1]) {
+		for (i = 0; i < eb.length; ++i)
+			if (x[0] == eb[i]) return true;
+		return false;
+	}
+	if (x.ef()) return false;
+	i = 1;
+	while (i < eb.length) {
+		var m = eb[i],
+			j = i + 1;
+		while (j < eb.length && m < kE) m *= eb[j++];
+		m = x.kq(m);
+		while (i < j)
+			if (m % eb[i++] == 0) return false;
+	}
+	return x.kJ(t);
+};
+
+function dR(t) {
+	var gV = this.cv(L.ONE);
+	var k = gV.gg();
+	if (k <= 0) return false;
+	var r = gV.ic(k);
+	t = (t + 1) >> 1;
+	if (t > eb.length) t = eb.length;
+	var a = C();
+	for (var i = 0; i < t; ++i) {
+		a.eT(eb[Math.floor(Math.random() * eb.length)]);
+		var y = a.lb(r, this);
+		if (y.dw(L.ONE) != 0 && y.dw(gV) != 0) {
+			var j = 1;
+			while (j++ < k && y.dw(gV) != 0) {
+				y = y.kr(2, this);
+				if (y.dw(L.ONE) == 0) return false;
+			}
+			if (y.dw(gV) != 0) return false;
+		}
+	}
+	return true;
+};
+L.prototype.iw = ca;
+L.prototype.eD = dk;
+L.prototype.jP = bY;
+L.prototype.iM = cX;
+L.prototype.gj = cC;
+L.prototype.hY = dE;
+L.prototype.hG = ce;
+L.prototype.ja = dp;
+L.prototype.hJ = cJ;
+L.prototype.lx = cW;
+L.prototype.ld = ci;
+L.prototype.kq = di;
+L.prototype.kJ = dR;
+L.prototype.clone = an;
+L.prototype.hs = bK;
+L.prototype.lQ = cI;
+L.prototype.lZ = dn;
+L.prototype.eJ = aF;
+L.prototype.gv = bv;
+L.prototype.equals = ab;
+L.prototype.min = aw;
+L.prototype.max = ao;
+L.prototype.and = dN;
+L.prototype.jw = bW;
+L.prototype.xor = aQ;
+L.prototype.mg = cg;
+L.prototype.not = db;
+L.prototype.shiftLeft = cA;
+L.prototype.ic = dv;
+L.prototype.gg = aq;
+L.prototype.nx = cj;
+L.prototype.en = aM;
+L.prototype.nu = cc;
+L.prototype.mR = cT;
+L.prototype.nc = bb;
+L.prototype.add = cO;
+L.prototype.cv = bQ;
+L.prototype.multiply = bF;
+L.prototype.divide = bd;
+L.prototype.mU = cQ;
+L.prototype.lH = bI;
+L.prototype.lb = aE;
+L.prototype.fZ = ah;
+L.prototype.pow = cG;
+L.prototype.mN = aV;
+L.prototype.kv = as;
+L.prototype.square = aa;
+
+function J(q, x) {
+	this.x = x;
+	this.q = q;
+};
+
+function bx(other) {
+	if (other == this) return true;
+	return (this.q.equals(other.q) && this.x.equals(other.x));
+};
+
+function av() {
+	return this.x;
+};
+
+function aO() {
+	return new J(this.q, this.x.el().cl(this.q));
+};
+
+function bz(b) {
+	return new J(this.q, this.x.add(b.cR()).cl(this.q));
+};
+
+function be(b) {
+	return new J(this.q, this.x.cv(b.cR()).cl(this.q));
+};
+
+function bf(b) {
+	return new J(this.q, this.x.multiply(b.cR()).cl(this.q));
+};
+
+function aJ() {
+	return new J(this.q, this.x.square().cl(this.q));
+};
+
+function ar(b) {
+	return new J(this.q, this.x.multiply(b.cR().fZ(this.q)).cl(this.q));
+};
+J.prototype.equals = bx;
+J.prototype.cR = av;
+J.prototype.el = aO;
+J.prototype.add = bz;
+J.prototype.cv = be;
+J.prototype.multiply = bf;
+J.prototype.square = aJ;
+J.prototype.divide = ar;
+
+function G(dP, x, y, z) {
+	this.dP = dP;
+	this.x = x;
+	this.y = y;
+	if (z == null) {
+		this.z = L.ONE;
+	} else {
+		this.z = z;
+	}
+	this.gH = null;
+};
+
+function az() {
+	if (this.gH == null) {
+		this.gH = this.z.fZ(this.dP.q);
+	}
+	return this.dP.fm(this.x.cR().multiply(this.gH).cl(this.dP.q));
+};
+
+function bP() {
+	if (this.gH == null) {
+		this.gH = this.z.fZ(this.dP.q);
+	}
+	return this.dP.fm(this.y.cR().multiply(this.gH).cl(this.dP.q));
+};
+
+function bV(other) {
+	if (other == this) return true;
+	if (this.eg()) return other.eg();
+	if (other.eg()) return this.eg();
+	var u, v;
+	u = other.y.cR().multiply(this.z).cv(this.y.cR().multiply(other.z)).cl(this.dP.q);
+	if (!u.equals(L.ZERO)) return false;
+	v = other.x.cR().multiply(this.z).cv(this.x.cR().multiply(other.z)).cl(this.dP.q);
+	return v.equals(L.ZERO);
+};
+
+function bp() {
+	if ((this.x == null) && (this.y == null)) return true;
+	return this.z.equals(L.ZERO) && !this.y.cR().equals(L.ZERO);
+};
+
+function aX() {
+	return new G(this.dP, this.x, this.y.el(), this.z);
+};
+
+function aB(b) {
+	if (this.eg()) return b;
+	if (b.eg()) return this;
+	var u = b.y.cR().multiply(this.z).cv(this.y.cR().multiply(b.z)).cl(this.dP.q);
+	var v = b.x.cR().multiply(this.z).cv(this.x.cR().multiply(b.z)).cl(this.dP.q);
+	if (L.ZERO.equals(v)) {
+		if (L.ZERO.equals(u)) {
+			return this.gI();
+		}
+		return this.dP.gy();
+	}
+	var hm = new L("3");
+	var x1 = this.x.cR();
+	var y1 = this.y.cR();
+	var iT = v.square();
+	var hq = iT.multiply(v);
+	var iy = x1.multiply(iT);
+	var iq = u.square().multiply(this.z);
+	var eE = iq.cv(iy.shiftLeft(1)).multiply(b.z).cv(hq).multiply(v).cl(this.dP.q);
+	var fE = iy.multiply(hm).multiply(u).cv(y1.multiply(hq)).cv(iq.multiply(u)).multiply(b.z).add(u.multiply(hq)).cl(
+		this.dP.q);
+	var js = hq.multiply(this.z).multiply(b.z).cl(this.dP.q);
+	return new G(this.dP, this.dP.fm(eE), this.dP.fm(fE), js);
+};
+
+function bq() {
+	if (this.eg()) return this;
+	if (this.y.cR().eJ() == 0) return this.dP.gy();
+	var hm = new L("3");
+	var x1 = this.x.cR();
+	var y1 = this.y.cR();
+	var gz = y1.multiply(this.z);
+	var jp = gz.multiply(y1).cl(this.dP.q);
+	var a = this.dP.a.cR();
+	var w = x1.square().multiply(hm);
+	if (!L.ZERO.equals(a)) {
+		w = w.add(this.z.square().multiply(a));
+	}
+	w = w.cl(this.dP.q);
+	var eE = w.square().cv(x1.shiftLeft(3).multiply(jp)).shiftLeft(1).multiply(gz).cl(this.dP.q);
+	var fE = w.multiply(hm).multiply(x1).cv(jp.shiftLeft(1)).shiftLeft(2).multiply(jp).cv(w.square().multiply(w)).cl(
+		this.dP.q);
+	var js = gz.square().multiply(gz).shiftLeft(3).cl(this.dP.q);
+	return new G(this.dP, this.dP.fm(eE), this.dP.fm(fE), js);
+};
+
+function ai(k) {
+	if (this.eg()) return this;
+	if (k.eJ() == 0) return this.dP.gy();
+	var e = k;
+	var h = e.multiply(new L("3"));
+	var hw = this.el();
+	var R = this;
+	var i;
+	for (i = h.fg() - 2; i > 0; --i) {
+		R = R.gI();
+		var gm = h.en(i);
+		var hV = e.en(i);
+		if (gm != hV) {
+			R = R.add(gm ? this : hw);
+		}
+	}
+	return R;
+};
+
+function aS(j, x, k) {
+	var i;
+	if (j.fg() > k.fg()) i = j.fg() - 1;
+	else i = k.fg() - 1;
+	var R = this.dP.gy();
+	var both = this.add(x);
+	while (i >= 0) {
+		R = R.gI();
+		if (j.en(i)) {
+			if (k.en(i)) {
+				R = R.add(both);
+			} else {
+				R = R.add(this);
+			}
+		} else {
+			if (k.en(i)) {
+				R = R.add(x);
+			}
+		}--i;
+	}
+	return R;
+};
+G.prototype.fI = az;
+G.prototype.ec = bP;
+G.prototype.equals = bV;
+G.prototype.eg = bp;
+G.prototype.el = aX;
+G.prototype.add = aB;
+G.prototype.gI = bq;
+G.prototype.multiply = ai;
+G.prototype.nb = aS;
+
+function V(q, a, b) {
+	this.q = q;
+	this.a = this.fm(a);
+	this.b = this.fm(b);
+	this.jz = new G(this, null, null);
+};
+
+function bO() {
+	return this.q;
+};
+
+function aW() {
+	return this.a;
+};
+
+function bc() {
+	return this.b;
+};
+
+function bJ(other) {
+	if (other == this) return true;
+	return (this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b));
+};
+
+function bn() {
+	return this.jz;
+};
+
+function ae(x) {
+	return new J(this.q, x);
+};
+
+function by(s) {
+	switch (parseInt(s.substr(0, 2), 16)) {
+		case 0:
+			return this.jz;
+		case 2:
+		case 3:
+			return null;
+		case 4:
+		case 6:
+		case 7:
+			var dm = (s.length - 2) / 2;
+			var hf = s.substr(2, dm);
+			var ih = s.substr(dm + 2, dm);
+			return new G(this, this.fm(new L(hf, 16)), this.fm(new L(ih, 16)));
+		default:
+			return null;
+	}
+};
+
+function bG(x, y) {
+	return new G(this, this.fm(x), this.fm(y));
+};
+V.prototype.jh = bO;
+V.prototype.kH = aW;
+V.prototype.kB = bc;
+V.prototype.equals = bJ;
+V.prototype.gy = bn;
+V.prototype.fm = ae;
+V.prototype.kR = by;
+V.prototype.kU = bG;
+J.prototype.lO = function() {
+	return Math.floor((this.cR().fg() + 7) / 8);
+};
+G.prototype.mj = function(jG) {
+	var hM = function(i, dm) {
+		var ev = i.lW();
+		if (dm < ev.length) {
+			ev = ev.slice(ev.length - dm);
+		} else
+			while (dm > ev.length) {
+				ev.unshift(0);
+			}
+		return ev;
+	};
+	var x = this.fI().cR();
+	var y = this.ec().cR();
+	var ey = hM(x, 32);
+	if (jG) {
+		if (y.ef()) {
+			ey.unshift(0x02);
+		} else {
+			ey.unshift(0x03);
+		}
+	} else {
+		ey.unshift(0x04);
+		ey = ey.concat(hM(y, 32));
+	}
+	return ey;
+};
+G.jZ = function(dP, ey) {
+	var ea = ey.length - 1;
+	var iP = ey.slice(1, 1 + ea / 2);
+	var je = ey.slice(1 + ea / 2, 1 + ea);
+	iP.unshift(0);
+	je.unshift(0);
+	var x = new L(iP);
+	var y = new L(je);
+	return new G(dP, dP.fm(x), dP.fm(y));
+};
+G.hQ = function(dP, hU) {
+	var ea = hU.length - 2;
+	var hf = hU.substr(2, ea / 2);
+	var ih = hU.substr(2 + ea / 2, ea / 2);
+	var x = new L(hf, 16);
+	var y = new L(ih, 16);
+	return new G(dP, dP.fm(x), dP.fm(y));
+};
+G.prototype.jK = function(b) {
+	if (this.eg()) return b;
+	if (b.eg()) return this;
+	if (this.x.equals(b.x)) {
+		if (this.y.equals(b.y)) {
+			return this.gI();
+		}
+		return this.dP.gy();
+	}
+	var kW = b.x.cv(this.x);
+	var la = b.y.cv(this.y);
+	var hl = la.divide(kW);
+	var eE = hl.square().cv(this.x).cv(b.x);
+	var fE = hl.multiply(this.x.cv(eE)).cv(this.y);
+	return new G(this.dP, eE, fE);
+};
+G.prototype.mV = function() {
+	if (this.eg()) return this;
+	if (this.y.cR().eJ() == 0) {
+		return this.dP.gy();
+	}
+	var jF = this.dP.fm(L.valueOf(2));
+	var hm = this.dP.fm(L.valueOf(3));
+	var hl = this.x.square().multiply(hm).add(this.dP.a).divide(this.y.multiply(jF));
+	var eE = hl.square().cv(this.x.multiply(jF));
+	var fE = hl.multiply(this.x.cv(eE)).cv(this.y);
+	return new G(this.dP, eE, fE);
+};
+G.prototype.nl = function(k) {
+	if (this.eg()) return this;
+	if (k.eJ() == 0) return this.dP.gy();
+	var e = k;
+	var h = e.multiply(new L("3"));
+	var hw = this.el();
+	var R = this;
+	var i;
+	for (i = h.fg() - 2; i > 0; --i) {
+		R = R.gI();
+		var gm = h.en(i);
+		var hV = e.en(i);
+		if (gm != hV) {
+			R = R.jK(gm ? this : hw);
+		}
+	}
+	return R;
+};
+G.prototype.kM = function() {
+	var x = this.fI().cR();
+	var y = this.ec().cR();
+	var a = this.dP.kH().cR();
+	var b = this.dP.kB().cR();
+	var n = this.dP.jh();
+	var lhs = y.multiply(y).cl(n);
+	var rhs = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).cl(n);
+	return lhs.equals(rhs);
+};
+G.prototype.toString = function() {
+	return '(' + this.fI().cR().toString() + ',' + this.ec().cR().toString() + ')';
+};
+G.prototype.mY = function() {
+	var n = this.dP.jh();
+	if (this.eg()) {
+		throw new Error("Point is at jz.");
+	}
+	var x = this.fI().cR();
+	var y = this.ec().cR();
+	if (x.dw(L.ONE) < 0 || x.dw(n.cv(L.ONE)) > 0) {
+		throw new Error('x coordinate out of bounds');
+	}
+	if (y.dw(L.ONE) < 0 || y.dw(n.cv(L.ONE)) > 0) {
+		throw new Error('y coordinate out of bounds');
+	}
+	if (!this.kM()) {
+		throw new Error("Point is not on the dP.");
+	}
+	if (this.multiply(n).eg()) {
+		throw new Error("Point is not a scalar multiple of G.");
+	}
+	return true;
+};
+
+function bo() {
+	this.fB = null;
+	this.et = null;
+	this.iA = null;
+	this.hb = 256;
+	this.ho = 0;
+	this.gR = 0;
+	this.eu = new Array();
+	if (this.fB == null) {
+		this.fB = new Array();
+		this.et = 0;
+		if (navigator.appName == "Netscape" && navigator.appVersion < "5" && window.crypto) {
+			var z = window.crypto.random(32);
+			for (var t = 0; t < z.length; ++t) {
+				this.fB[this.et++] = z.charCodeAt(t) & 255;
+			}
+		}
+		while (this.et < this.hb) {
+			t = Math.floor(65536 * Math.random());
+			this.fB[this.et++] = t >>> 8;
+			this.fB[this.et++] = t & 255;
+		}
+		this.et = 0;
+		this.jj();
+	}
+};
+bo.prototype = {
+	ka: function(x) {
+		this.fB[this.et++] ^= x & 255;
+		this.fB[this.et++] ^= (x >> 8) & 255;
+		this.fB[this.et++] ^= (x >> 16) & 255;
+		this.fB[this.et++] ^= (x >> 24) & 255;
+		if (this.et >= this.hb) this.et -= this.hb;
+	},
+	jj: function() {
+		this.ka(new Date().getTime());
+	},
+	kg: function() {
+		if (this.iA == null) {
+			this.jj();
+			this.iA = 1;
+			this.gD(this.fB);
+			for (var et = 0; et < this.fB.length; ++et) {
+				this.fB[et] = 0;
+			}
+			this.et = 0;
+		}
+		return this.next();
+	},
+	kj: function(iQ) {
+		var i;
+		for (i = 0; i < iQ.length; ++i) iQ[i] = this.kg();
+	},
+	gD: function(key) {
+		var i, j, t;
+		for (i = 0; i < 256; ++i) this.eu[i] = i;
+		j = 0;
+		for (i = 0; i < 256; ++i) {
+			j = (j + this.eu[i] + key[i % key.length]) & 255;
+			t = this.eu[i];
+			this.eu[i] = this.eu[j];
+			this.eu[j] = t;
+		}
+		this.ho = 0;
+		this.gR = 0;
+	},
+	next: function() {
+		var t;
+		this.ho = (this.ho + 1) & 255;
+		this.gR = (this.gR + this.eu[this.ho]) & 255;
+		t = this.eu[this.ho];
+		this.eu[this.ho] = this.eu[this.gR];
+		this.eu[this.gR] = t;
+		return this.eu[(t + this.eu[this.ho]) & 255];
+	}
+};
+
+function aP() {
+	this.dX = new Array(0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
+		0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99, 0x9c, 0x42,
+		0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62, 0xe4, 0xb3, 0x1c, 0xa9,
+		0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6, 0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73,
+		0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8, 0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b,
+		0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22,
+		0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87, 0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7,
+		0xa0, 0xc4, 0xc8, 0x9e, 0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61,
+		0x15, 0xa1, 0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
+		0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f, 0xd5, 0xdb,
+		0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51, 0x8d, 0x1b, 0xaf, 0x92,
+		0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8, 0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd,
+		0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0, 0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e,
+		0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84, 0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee,
+		0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48);
+	this.gi = new Array(0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc);
+	this.kw = new Array(0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269, 0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
+		0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249, 0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9, 0xc0c7ced5,
+		0xdce3eaf1, 0xf8ff060d, 0x141b2229, 0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299, 0xa0a7aeb5, 0xbcc3cad1,
+		0xd8dfe6ed, 0xf4fb0209, 0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279);
+};
+aP.prototype = {
+	hy: function(key) {
+		var k = new Array(36);
+		var gM = aI(key);
+		k[0] = gM[0] ^ this.gi[0];
+		k[1] = gM[1] ^ this.gi[1];
+		k[2] = gM[2] ^ this.gi[2];
+		k[3] = gM[3] ^ this.gi[3];
+		var fH = new Array(32);
+		for (var i = 0; i < 32; i++) {
+			k[(i + 4)] = (k[i] ^ this.jO(k[(i + 1)] ^ k[(i + 2)] ^ k[(i + 3)] ^ this.kw[i]));
+			fH[i] = k[(i + 4)];
+		}
+		return fH;
+	},
+	jO: function(fS) {
+		var b = new Array(4);
+		var a = F(fS);
+		b[0] = this.dX[a[0] & 0xFF];
+		b[1] = this.dX[a[1] & 0xFF];
+		b[2] = this.dX[a[2] & 0xFF];
+		b[3] = this.dX[a[3] & 0xFF];
+		var ek = bB(b, 0);
+		var fH = ek ^ (ek << 13 | (ek >>> (32 - 13))) ^ (ek << 23 | (ek >>> (32 - 23)));
+		return fH;
+	},
+	eA: function(fH, data) {
+		var x = new Array(36);
+		x[0] = bB(data, 0);
+		x[1] = bB(data, 4);
+		x[2] = bB(data, 8);
+		x[3] = bB(data, 12);
+		for (var i = 0; i < 32; i++) {
+			x[(i + 4)] = x[i] ^ this.kN(x[(i + 1)] ^ x[(i + 2)] ^ x[(i + 3)] ^ fH[i]);
+		}
+		var iI = new Array(4);
+		for (var i = 35; i >= 32; i--) {
+			iI[35 - i] = x[i];
+		}
+		var kS = ap(iI);
+		return kS;
+	},
+	kN: function(fS) {
+		var a = F(fS);
+		var b = new Array(4);
+		b[0] = this.dX[a[0] & 0xFF];
+		b[1] = this.dX[a[1] & 0xFF];
+		b[2] = this.dX[a[2] & 0xFF];
+		b[3] = this.dX[a[3] & 0xFF];
+		var ek = bB(b, 0);
+		var c = ek ^ (ek << 2 | (ek >>> (32 - 2))) ^ (ek << 10 | (ek >>> (32 - 10))) ^ (ek << 18 | (ek >>> (32 -
+			18))) ^ (ek << 24 | (ek >>> (32 - 24)));
+		return c;
+	},
+	gY: function(input, mode) {
+		if (input == null) {
+			return null;
+		}
+		var gT = null;
+		if (mode == 1) {
+			var p = 16 - input.length % 16;
+			gT = new Array(input.length + p);
+			K(input, 0, gT, 0, input.length);
+			for (var i = 0; i < p; i++) {
+				gT[input.length + i] = p;
+			}
+		} else {
+			var p = input[input.length - 1];
+			gT = new Array(input.length - p);
+			K(input, 0, gT, 0, input.length - p);
+		}
+		return gT;
+	},
+	lk: function(data, key) {
+		if (data == undefined || data == null || data.length <= 0) {
+			dB.log("data is error!");
+			return null;
+		}
+		if (key == undefined || key == null || key.length % 16 != 0) {
+			dB.log("dV key is error!");
+			return null;
+		}
+		var fH = this.hy(key);
+		var cU = 16;
+		var loop = parseInt(data.length / cU);
+		var cw = new Array((loop + 1) * cU);
+		var dF = new Array(cU);
+		var hk = null;
+		for (var i = 0; i < loop; i++) {
+			K(data, i * cU, dF, 0, cU);
+			hk = this.eA(fH, dF);
+			K(hk, 0, cw, i * cU, cU);
+		}
+		var eR = new Array(data.length % cU);
+		if (eR.length > 0) {
+			K(data, loop * cU, eR, 0, data.length % cU);
+		}
+		var padding = this.gY(eR, 1);
+		hk = this.eA(fH, padding);
+		K(hk, 0, cw, loop * cU, cU);
+		return cw;
+	},
+	kY: function(data, key) {
+		if (data == undefined || data == null || data.length % 16 != 0) {
+			dB.log("data is error!");
+			return null;
+		}
+		if (key == undefined || key == null || key.length % 16 != 0) {
+			dB.log("dV key is error!");
+			return null;
+		}
+		var fH = this.hy(key);
+		var gW = new Array(32);
+		for (var i = 0; i < fH.length; i++) {
+			gW[i] = fH[32 - i - 1];
+		}
+		var cU = 16;
+		var loop = data.length / cU - 1;
+		var dF = new Array(cU);
+		var fh = null;
+		var fz = null;
+		K(data, loop * cU, dF, 0, cU);
+		fh = this.eA(gW, dF);
+		var eY = this.gY(fh, 0);
+		fz = new Array(loop * cU + eY.length);
+		K(eY, 0, fz, loop * cU, eY.length);
+		for (var i = 0; i < loop; i++) {
+			K(data, i * cU, dF, 0, cU);
+			fh = this.eA(gW, dF);
+			K(fh, 0, fz, i * cU, cU);
+		}
+		return fz;
+	},
+	ll: function(data, key, cd) {
+		if (cd == undefined || cd == null || cd.length % 16 != 0) {
+			dB.log("cd is error!");
+			return null;
+		}
+		if (key == undefined || key == null || key.length % 16 != 0) {
+			dB.log("dV key is error!");
+			return null;
+		}
+		if (data == undefined || data == null || data.length <= 0) {
+			dB.log("data is error!");
+			return null;
+		}
+		var fH = this.hy(key);
+		var cU = 16;
+		var loop = parseInt(data.length / cU);
+		var cw = new Array((loop + 1) * cU);
+		var dF = new Array(cU);
+		for (var i = 0; i < loop; i++) {
+			K(data, i * cU, dF, 0, cU);
+			for (var j = 0; j < cU; j++) {
+				dF[j] = dF[j] ^ cd[j];
+			}
+			cd = this.eA(fH, dF);
+			K(cd, 0, cw, i * cU, cU);
+		}
+		var eR = new Array(data.length % cU);
+		if (eR.length > 0) {
+			K(data, loop * cU, eR, 0, data.length % cU);
+		}
+		var padding = this.gY(eR, 1);
+		for (var i = 0; i < cU; i++) {
+			padding[i] = padding[i] ^ cd[i];
+		}
+		cd = this.eA(fH, padding);
+		K(cd, 0, cw, loop * cU, cU);
+		return cw;
+	},
+	kD: function(data, key, cd) {
+		if (cd == undefined || cd == null || cd.length % 16 != 0) {
+			dB.log("cd is error!");
+			return null;
+		}
+		if (key == undefined || key == null || key.length % 16 != 0) {
+			dB.log("dV key is error!");
+			return null;
+		}
+		if (data == undefined || data == null || data.length % 16 != 0) {
+			dB.log("data is error!");
+			return null;
+		}
+		var fH = this.hy(key);
+		var gW = new Array(32);
+		for (var i = 0; i < fH.length; i++) {
+			gW[i] = fH[32 - i - 1];
+		}
+		var cU = 16;
+		var loop = data.length / cU;
+		var dF = new Array(cU);
+		var fh = null;
+		var fz = null;
+		fz = new Array(data.length);
+		for (var i = 0; i < loop; i++) {
+			K(data, i * cU, dF, 0, cU);
+			fh = this.eA(gW, dF);
+			for (var j = 0; j < cU; j++) {
+				fh[j] = fh[j] ^ cd[j];
+			}
+			K(dF, 0, cd, 0, cU);
+			K(fh, 0, fz, i * cU, cU);
+		}
+		var eY = this.gY(fh, 0);
+		var gq = new Array(fz.length - cU + eY.length);
+		K(fz, 0, gq, 0, fz.length - cU);
+		K(eY, 0, gq, fz.length - cU, eY.length);
+		return gq;
+	}
+};
+
+function T() {
+	this.ft = new Array();
+	this.eW = 0;
+	this.hB = 0;
+	this.hZ = 32;
+	this.gU = [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e];
+	this.gU = [0x7380166f, 0x4914b2b9, 0x172442d7, -628488704, -1452330820, 0x163138aa, -477237683, -1325724082];
+	this.v = new Array(8);
+	this.jJ = new Array(8);
+	this.fU = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+	this.X = new Array(68);
+	this.eI = 0;
+	this.lw = 0x79cc4519;
+	this.lz = 0x7a879d8a;
+	if (arguments.length > 0) {
+		this.lc(arguments[0]);
+	} else {
+		this.gD();
+	}
+};
+T.prototype = {
+	dj: {
+		ki: -parseInt('10000000000000000000000000000000', 2),
+		ir: parseInt('1111111111111111111111111111111', 2),
+		parse: function(n) {
+			if (n < this.ki) {
+				var fa = new Number(-n);
+				var fe = fa.toString(2);
+				var dU = fe.substr(fe.length - 31, 31);
+				var fC = '';
+				for (var i = 0; i < dU.length; i++) {
+					var hE = dU.substr(i, 1);
+					fC += hE == '0' ? '1' : '0';
+				}
+				var result = parseInt(fC, 2);
+				return (result + 1);
+			} else if (n > this.ir) {
+				var fa = Number(n);
+				var fe = fa.toString(2);
+				var dU = fe.substr(fe.length - 31, 31);
+				var fC = '';
+				for (var i = 0; i < dU.length; i++) {
+					var hE = dU.substr(i, 1);
+					fC += hE == '0' ? '1' : '0';
+				}
+				var result = parseInt(fC, 2);
+				return -(result + 1);
+			} else {
+				return n;
+			}
+		},
+		gK: function(n) {
+			if (n < 0) {
+				var fa = new Number(-n);
+				var fe = fa.toString(2);
+				var dU = fe.substr(fe.length - 8, 8);
+				var fC = '';
+				for (var i = 0; i < dU.length; i++) {
+					var hE = dU.substr(i, 1);
+					fC += hE == '0' ? '1' : '0';
+				}
+				var result = parseInt(fC, 2);
+				return (result + 1);
+			} else if (n > 255) {
+				var fa = Number(n);
+				var fe = fa.toString(2);
+				return parseInt(fe.substr(fe.length - 8, 8), 2);
+			} else {
+				return n;
+			}
+		}
+	},
+	gD: function() {
+		this.ft = new Array(4);
+		this.reset();
+	},
+	lc: function(t) {
+		this.ft = [].concat(t.ft);
+		this.eW = t.eW;
+		this.hB = t.hB;
+		K(t.X, 0, this.X, 0, t.X.length);
+		this.eI = t.eI;
+		K(t.v, 0, this.v, 0, t.v.length);
+	},
+	hL: function() {
+		return this.hZ;
+	},
+	reset: function() {
+		this.hB = 0;
+		this.eW = 0;
+		for (var kc in this.ft) this.ft[kc] = null;
+		K(this.gU, 0, this.v, 0, this.gU.length);
+		this.eI = 0;
+		K(this.fU, 0, this.X, 0, this.fU.length);
+	},
+	hS: function() {
+		var i;
+		var fs = this.X;
+		var gu = new Array(64);
+		for (i = 16; i < 68; i++) {
+			fs[i] = this.kT(fs[i - 16] ^ fs[i - 9] ^ (this.rotate(fs[i - 3], 15))) ^ (this.rotate(fs[i - 13],
+				7)) ^ fs[i - 6];
+		}
+		for (i = 0; i < 64; i++) {
+			gu[i] = fs[i] ^ fs[i + 4];
+		}
+		var ej = this.v;
+		var dr = this.jJ;
+		K(ej, 0, dr, 0, this.gU.length);
+		var fj, fV, hI, fQ, fW;
+		for (i = 0; i < 16; i++) {
+			fW = this.rotate(dr[0], 12);
+			fj = this.dj.parse(this.dj.parse(fW + dr[4]) + this.rotate(this.lw, i));
+			fj = this.rotate(fj, 7);
+			fV = fj ^ fW;
+			hI = this.dj.parse(this.dj.parse(this.lu(dr[0], dr[1], dr[2]) + dr[3]) + fV) + gu[i];
+			fQ = this.dj.parse(this.dj.parse(this.ky(dr[4], dr[5], dr[6]) + dr[7]) + fj) + fs[i];
+			dr[3] = dr[2];
+			dr[2] = this.rotate(dr[1], 9);
+			dr[1] = dr[0];
+			dr[0] = hI;
+			dr[7] = dr[6];
+			dr[6] = this.rotate(dr[5], 19);
+			dr[5] = dr[4];
+			dr[4] = this.ii(fQ);
+		}
+		for (i = 16; i < 64; i++) {
+			fW = this.rotate(dr[0], 12);
+			fj = this.dj.parse(this.dj.parse(fW + dr[4]) + this.rotate(this.lz, i));
+			fj = this.rotate(fj, 7);
+			fV = fj ^ fW;
+			hI = this.dj.parse(this.dj.parse(this.kk(dr[0], dr[1], dr[2]) + dr[3]) + fV) + gu[i];
+			fQ = this.dj.parse(this.dj.parse(this.jL(dr[4], dr[5], dr[6]) + dr[7]) + fj) + fs[i];
+			dr[3] = dr[2];
+			dr[2] = this.rotate(dr[1], 9);
+			dr[1] = dr[0];
+			dr[0] = hI;
+			dr[7] = dr[6];
+			dr[6] = this.rotate(dr[5], 19);
+			dr[5] = dr[4];
+			dr[4] = this.ii(fQ);
+		}
+		for (i = 0; i < 8; i++) {
+			ej[i] ^= this.dj.parse(dr[i]);
+		}
+		this.eI = 0;
+		K(this.fU, 0, this.X, 0, this.fU.length);
+	},
+	iC: function(hg, ee) {
+		var n = hg[ee] << 24;
+		n |= (hg[++ee] & 0xff) << 16;
+		n |= (hg[++ee] & 0xff) << 8;
+		n |= (hg[++ee] & 0xff);
+		this.X[this.eI] = n;
+		if (++this.eI == 16) {
+			this.hS();
+		}
+	},
+	ly: function(fg) {
+		if (this.eI > 14) {
+			this.hS();
+		}
+		this.X[14] = (this.ke(fg, 32));
+		this.X[15] = (fg & (0xffffffff));
+	},
+	kP: function(n, fD, off) {
+		fD[off] = this.dj.gK(this.hu(n, 24)) & 0x000000FF;
+		fD[++off] = this.dj.gK(this.hu(n, 16)) & 0x000000FF;
+		fD[++off] = this.dj.gK(this.hu(n, 8)) & 0x000000FF;
+		fD[++off] = this.dj.gK(n) & 0x000000FF;
+	},
+	gN: function(lm, lv) {
+		this.finish();
+		for (var i = 0; i < 8; i++) {
+			this.kP(this.v[i], lm, lv + i * 4);
+		}
+		this.reset();
+		return this.hZ;
+	},
+	update: function(input) {
+		this.ft[this.eW++] = input;
+		if (this.eW == this.ft.length) {
+			this.iC(this.ft, 0);
+			this.eW = 0;
+		}
+		this.hB++;
+	},
+	fc: function(input, ee, length) {
+		while ((this.eW != 0) && (length > 0)) {
+			this.update(input[ee]);
+			ee++;
+			length--;
+		}
+		while (length > this.ft.length) {
+			this.iC(input, ee);
+			ee += this.ft.length;
+			length -= this.ft.length;
+			this.hB += this.ft.length;
+		}
+		while (length > 0) {
+			this.update(input[ee]);
+			ee++;
+			length--;
+		}
+	},
+	finish: function() {
+		var fg = (this.hB << 3);
+		this.update((128));
+		while (this.eW != 0) this.update((0));
+		this.ly(fg);
+		this.hS();
+	},
+	rotate: function(x, n) {
+		return (x << n) | (this.hu(x, (32 - n)));
+	},
+	ii: function(X) {
+		return ((X) ^ this.rotate((X), 9) ^ this.rotate((X), 17));
+	},
+	kT: function(X) {
+		return ((X) ^ this.rotate((X), 15) ^ this.rotate((X), 23));
+	},
+	lu: function(X, Y, Z) {
+		return (X ^ Y ^ Z);
+	},
+	kk: function(X, Y, Z) {
+		return ((X & Y) | (X & Z) | (Y & Z));
+	},
+	ky: function(X, Y, Z) {
+		return (X ^ Y ^ Z);
+	},
+	jL: function(X, Y, Z) {
+		return ((X & Y) | (~X & Z));
+	},
+	hu: function(number, fu) {
+		if (number > this.dj.ir || number < this.dj.ki) {
+			number = this.dj.parse(number);
+		}
+		if (number >= 0) {
+			return number >> fu;
+		} else {
+			return (number >> fu) + (2 << ~fu);
+		}
+	},
+	ke: function(number, fu) {
+		var fR;
+		var big = new L();
+		big.eT(number);
+		if (big.eJ() >= 0) {
+			fR = big.ic(fu).hs();
+		} else {
+			var jm = new L();
+			jm.eT(2);
+			var iU = ~fu;
+			var gh = '';
+			if (iU < 0) {
+				var jS = 64 + iU;
+				for (var i = 0; i < jS; i++) {
+					gh += '0';
+				}
+				var jE = new L();
+				jE.eT(number >> fu);
+				var jC = new L("10" + gh, 2);
+				gh = jC.eD(10);
+				var r = jC.add(jE);
+				fR = r.eD(10);
+			} else {
+				gh = jm.shiftLeft((~fu)).hs();
+				fR = (number >> fu) + gh;
+			}
+		}
+		return fR;
+	},
+	jN: function(g, kz) {
+		var jf = new Array(32);
+		var iz = new Array(32);
+		K(kz, 1, jf, 0, 32);
+		K(kz, 33, iz, 0, 32);
+		var iB = CommonUtils.utf8StrToHex('1234567812345678');
+		var dm = iB.length * 4;
+		this.update((dm >> 8 & 0x00ff));
+		this.update((dm & 0x00ff));
+		var ia = this.gB(iB);
+		this.fc(ia, 0, ia.length);
+		var it = this.gB(g.dP.a.cR().eD(16));
+		var ip = this.gB(g.dP.b.cR().eD(16));
+		var jl = this.gB(g.fI().cR().eD(16));
+		var ie = this.gB(g.ec().cR().eD(16));
+		var ig = jf;
+		var iu = iz;
+		this.fc(it, 0, it.length);
+		this.fc(ip, 0, ip.length);
+		this.fc(jl, 0, jl.length);
+		this.fc(ie, 0, ie.length);
+		this.fc(ig, 0, ig.length);
+		this.fc(iu, 0, iu.length);
+		var hX = new Array(this.hL());
+		this.gN(hX, 0);
+		return hX;
+	},
+	gB: function(jq) {
+		var eN = [];
+		var lp = jq.length;
+		for (var i = 0; i < lp; i += 2) {
+			eN.push(parseInt(jq.substr(i, 2), 16));
+		}
+		return eN;
+	}
+};
+window.CipherMode = {
+	C1C2C3: 0,
+	C1C3C2: 1,
+	c1c2c3: 0,
+	c1c3c2: 1
+};
+
+function aK(eV, eC) {
+	if (typeof(eV) != 'undefined' && eV === 1) {
+		this.eV = CipherMode.C1C3C2;
+	} else {
+		this.eV = CipherMode.C1C2C3;
+	}
+	if (typeof(eC) != 'undefined' && CommonUtils.isHexString(eC)) {
+		this.eC = eC;
+	} else {
+		this.eC = null;
+	}
+	this.kQ = new L("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", 16);
+	this.ks = new L("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", 16);
+	this.kG = new L("28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", 16);
+	this.eB = new L("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", 16);
+	this.jX = new L("32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", 16);
+	this.kI = new L("BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", 16);
+	this.lK = 256;
+	this.jM = new bo();
+	this.gZ = new V(this.kQ, this.ks, this.kG);
+	this.ha = G.hQ(this.gZ, "04" + this.jX.toString(16) + this.kI.toString(16));
+};
+aK.prototype = {
+	jU: function(jo) {
+		return new L(jo.fg(), this.jM).cl(jo.cv(L.ONE)).add(L.ONE);
+	},
+	generateKeyPair: function() {
+		var eF = this.jt();
+		var cZ = eF['gk'].gv();
+		var jd = eF['fb'].fI().cR();
+		var jn = eF['fb'].ec().cR();
+		var jH = this.fN(jd, 32);
+		var lj = this.fN(jn, 32);
+		var dC = new Array(65);
+		dC[0] = 0x04;
+		K(jH, 0, dC, 1, 32);
+		K(lj, 0, dC, 33, 32);
+		return {
+			'gk': cZ,
+			'fb': dC
+		};
+	},
+	kX: function() {
+		var eF = this.generateKeyPair();
+		var lo = eF.fb;
+		var lA = eF.gk;
+		return {
+			'prvkeyhex': CommonUtils.bytesToHex(lA),
+			'pubkeyhex': CommonUtils.bytesToHex(lo)
+		};
+	},
+	jt: function(eC) {
+		var iJ = this.eB;
+		var gF = null;
+		var iV = null;
+		if (CommonUtils.isHexString(eC)) {
+			gF = new L(eC, 16);
+		} else {
+			do {
+				gF = this.jU(iJ);
+			} while (gF.equals(L.ZERO) || gF.dw(iJ) >= 0);
+		}
+		iV = this.ha.multiply(gF);
+		return {
+			'gk': gF,
+			"fb": iV
+		};
+	},
+	jR: function(cZ) {
+		var hn = this.ha.multiply(new L(CommonUtils.bytesToHex(cZ), 16));
+		var x = this.fN(hn.fI().cR(), 32);
+		var y = this.fN(hn.ec().cR(), 32);
+		var dC = new Array(65);
+		dC[0] = 0x04;
+		K(x, 0, dC, 1, 32);
+		K(y, 0, dC, 33, 32);
+		return dC;
+	},
+	jT: function() {
+		var eF = this.jt();
+		var jd = eF['fb'].fI().cR();
+		var jn = eF['fb'].ec().cR();
+		var hn = this.gZ.kU(jd, jn);
+		eF.x1 = hn.fI().cR();
+		return eF;
+	},
+	fN: function(kb, hH) {
+		var dF = new Array(hH);
+		for (var i = 0; i < dF.length; i++) {
+			dF[i] = 0;
+		}
+		var eK = kb.gv();
+		if (eK == null) {
+			return null;
+		}
+		if (eK.length > hH) {
+			K(eK, eK.length - hH, dF, 0, hH);
+		} else if (eK.length == hH) {
+			dF = eK;
+		} else {
+			K(eK, 0, dF, hH - eK.length, eK.length);
+		}
+		return dF;
+	},
+	iH: function(eU, data) {
+		var loop = Math.ceil(data.length / 32);
+		var eP;
+		var hash = new Array(32);
+		for (var i = 0; i < loop; i++) {
+			eP = new T();
+			eP.fc(eU, 0, eU.length);
+			eP.fc(F(i + 1), 0, 4);
+			eP.gN(hash, 0);
+			for (var j = 0; j < hash.length && (i * 32 + j) < data.length; j++) {
+				data[i * 32 + j] ^= hash[j];
+			}
+		}
+		return 0;
+	},
+	iO: function(data, dC) {
+		var hi = new T();
+		var iK = new T().jN(this.ha, dC);
+		var hO = data;
+		var eQ = new Array(hi.hL());
+		hi.fc(iK, 0, iK.length);
+		hi.fc(hO, 0, hO.length);
+		hi.gN(eQ, 0);
+		return eQ;
+	},
+	er: function(data, cZ, bZ) {
+		var dC = this.jR(cZ);
+		var eQ = this.iO(data, dC);
+		var iE = new L(CommonUtils.bytesToHex(cZ), 16);
+		var e = new L(CommonUtils.bytesToHex(eQ), 16);
+		var k = null;
+		var r = null;
+		var s = null;
+		do {
+			do {
+				var ib = this.jT();
+				k = ib.gk;
+				r = e.add(ib.x1).cl(this.eB);
+			} while (r.equals(L.ZERO) || r.add(k).equals(this.eB));
+			s = iE.add(L.ONE).fZ(this.eB).multiply(k.cv(r.multiply(iE))).cl(this.eB);
+		} while (s.equals(L.ZERO));
+		if (typeof(bZ) != 'undefined' && bZ == true) {
+			var kx = this.kd(r.gv(), s.gv());
+			return kx;
+		} else {
+			var kO = this.fN(r, 32);
+			var jI = this.fN(s, 32);
+			return CommonUtils.hexToBytes(CommonUtils.bytesToHex(kO) + CommonUtils.bytesToHex(jI));
+		}
+	},
+	ga: function(data, cB, dC, bZ) {
+		var eQ = this.iO(data, dC);
+		var r = null;
+		var s = null;
+		if (typeof(bZ) != 'undefined' && bZ == true) {
+			var cN = this.le(cB);
+			var hW = new Array(cN["r"].length);
+			var iF = new Array(cN["s"].length);
+			K(cN["r"], 0, hW, 0, cN["r"].length);
+			K(cN["s"], 0, iF, 0, cN["s"].length);
+			r = new L(CommonUtils.bytesToHex(hW), 16);
+			s = new L(CommonUtils.bytesToHex(iF), 16);
+		} else {
+			var dW = CommonUtils.bytesToHex(cB);
+			r = new L(dW.substring(0, 64), 16);
+			s = new L(dW.substring(64), 16);
+		}
+		var hn = this.gZ.kR(CommonUtils.bytesToHex(dC));
+		var e = new L(CommonUtils.bytesToHex(eQ), 16);
+		var t = r.add(s).cl(this.eB);
+		if (t.equals(L.ZERO)) return false;
+		var lB = this.ha.multiply(s).add(hn.multiply(t));
+		var R = e.add(lB.fI().cR()).cl(this.eB);
+		return r.equals(R);
+	},
+	gd: function(dC, data, bZ) {
+		if (dC == null || dC.length == 0 || data == null || data.length == 0) {
+			return null;
+		}
+		var lq = G.jZ(this.gZ, dC);
+		var cL = null;
+		var fA = null;
+		var x2 = null;
+		var y2 = null;
+		var ji = this.jt(this.eC);
+		fA = ji['fb'];
+		var iS = lq.multiply(ji['gk']);
+		x2 = this.fN(iS.fI().cR(), 32);
+		y2 = this.fN(iS.ec().cR(), 32);
+		cL = new Array(data.length);
+		K(data, 0, cL, 0, data.length);
+		var eU = new Array(x2.length + y2.length);
+		K(x2, 0, eU, 0, x2.length);
+		K(y2, 0, eU, x2.length, y2.length);
+		this.iH(eU, cL);
+		var cD = new Array(32);
+		var eP = new T();
+		eP.fc(x2, 0, x2.length);
+		eP.fc(data, 0, data.length);
+		eP.fc(y2, 0, y2.length);
+		eP.gN(cD, 0);
+		if (typeof(bZ) != 'undefined' && bZ == true) {
+			var ln = fA.fI().cR().gv();
+			var kf = fA.ec().cR().gv();
+			var kn = this.kZ(ln, kf, cL, cD);
+			return kn;
+		} else {
+			var dG = this.fN(fA.fI().cR(), 32);
+			var cF = this.fN(fA.ec().cR(), 32);
+			var cw = new Array(97 + cL.length);
+			cw[0] = 0x04;
+			K(dG, 0, cw, 1, dG.length);
+			K(cF, 0, cw, 1 + dG.length, cF.length);
+			if (this.eV === CipherMode.C1C2C3) {
+				K(cL, 0, cw, 1 + dG.length + cF.length, cL.length);
+				K(cD, 0, cw, 1 + dG.length + cF.length + cL.length, cD.length);
+			} else {
+				K(cD, 0, cw, 1 + dG.length + cF.length, cD.length);
+				K(cL, 0, cw, 1 + dG.length + cF.length + cD.length, cL.length);
+			}
+			return cw;
+		}
+	},
+	ht: function(cZ, dH, bZ) {
+		if (cZ == null || cZ.length == 0 || dH == null || dH.length == 0) {
+			return null;
+		}
+		var fA = new Array(64 + 1);
+		var cL = null;
+		var cD = new Array(32);
+		if (typeof(bZ) != 'undefined' && bZ == true) {
+			var cN = this.lh(dH);
+			cL = new Array(cN["cL"].length);
+			for (var i = 0; i < fA.length; i++) {
+				fA[i] = 0;
+			}
+			fA[0] = 0x04;
+			if (cN["dG"].length <= 32) {
+				K(cN["dG"], 0, fA, 1 + (32 - cN["dG"].length), cN["dG"].length);
+			} else {
+				K(cN["dG"], cN["dG"].length - 32, fA, 1, 32);
+			}
+			if (cN["cF"].length <= 32) {
+				K(cN["cF"], 0, fA, 1 + 32 + (32 - cN["cF"].length), cN["cF"].length);
+			} else {
+				K(cN["cF"], cN["cF"].length - 32, fA, 1 + 32, 32);
+			}
+			K(cN["cL"], 0, cL, 0, cL.length);
+			K(cN["cD"], 0, cD, 0, 32);
+		} else {
+			cL = new Array(dH.length - 97);
+			K(dH, 0, fA, 0, 65);
+			if (this.eV === CipherMode.C1C2C3) {
+				K(dH, 65, cL, 0, dH.length - 97);
+				K(dH, dH.length - 32, cD, 0, 32);
+			} else {
+				K(dH, 65, cD, 0, 32);
+				K(dH, 97, cL, 0, dH.length - 97);
+			}
+		}
+		var lg = G.hQ(this.gZ, CommonUtils.bytesToHex(fA));
+		var jc = lg.multiply(new L(CommonUtils.bytesToHex(cZ), 16));
+		var x2 = this.fN(jc.fI().cR(), 32);
+		var y2 = this.fN(jc.ec().cR(), 32);
+		var eU = new Array(x2.length + y2.length);
+		K(x2, 0, eU, 0, x2.length);
+		K(y2, 0, eU, x2.length, y2.length);
+		var jv = new Array(cL.length);
+		K(cL, 0, jv, 0, cL.length);
+		this.iH(eU, cL);
+		if (co(jv, 0, cL, 0, cL.length) == 0) {
+			return null;
+		}
+		var eP = new T();
+		var hash = new Array(32);
+		eP.fc(x2, 0, x2.length);
+		eP.fc(cL, 0, cL.length);
+		eP.fc(y2, 0, y2.length);
+		eP.gN(hash, 0);
+		var hT = CommonUtils.bytesToHex(cD);
+		var ix = CommonUtils.bytesToHex(hash);
+		if (!hT || !ix || hT != ix) {
+			return null;
+		}
+		return cL;
+	},
+	kd: function(r, s) {
+		var fl = r.length + s.length + 4;
+		var ew = [];
+		ew[0] = 0x30;
+		if (fl < 0x80) {
+			ew[1] = fl;
+		} else {
+			var fp = F(fl);
+			var i = 0;
+			while (fp[i] == 0 && i < fp.length) {
+				i++;
+			}
+			ew[1] = 0x80 | (fp.length - i);
+			for (var j = 2; i < fp.length; i++, j++) {
+				ew[j] = fp[i];
+			}
+		}
+		var bZ = new Array(fl + ew.length);
+		var cY = 0;
+		K(ew, 0, bZ, 0, ew.length);
+		cY += ew.length;
+		bZ[cY++] = 0x02;
+		bZ[cY++] = r.length;
+		K(r, 0, bZ, cY, r.length);
+		cY += r.length;
+		bZ[cY++] = 0x02;
+		bZ[cY++] = s.length;
+		K(s, 0, bZ, cY, s.length);
+		cY += s.length;
+		return bZ;
+	},
+	kZ: function(dG, cF, cL, cD) {
+		var fJ = cL.length;
+		var dS = [];
+		if (fJ < 0x80) {
+			dS[0] = 0x04;
+			dS[1] = fJ;
+		} else {
+			dS[0] = 0x04;
+			var gs = F(fJ);
+			var i = 0;
+			while (gs[i] == 0 && i < gs.length) {
+				i++;
+			}
+			dS[1] = 0x80 | (gs.length - i);
+			for (var j = 2; i < gs.length; i++, j++) {
+				dS[j] = gs[i];
+			}
+		}
+		var fl = dG.length + cF.length + cL.length + cD.length + 6 + dS.length;
+		var ew = [];
+		ew[0] = 0x30;
+		if (fl < 0x80) {
+			ew[1] = fl;
+		} else {
+			var fp = F(fl);
+			var i = 0;
+			while (fp[i] == 0 && i < fp.length) {
+				i++;
+			}
+			ew[1] = 0x80 | (fp.length - i);
+			for (var j = 2; i < fp.length; i++, j++) {
+				ew[j] = fp[i];
+			}
+		}
+		var bZ = new Array(fl + ew.length);
+		var cY = 0;
+		K(ew, 0, bZ, 0, ew.length);
+		cY += ew.length;
+		bZ[cY++] = 0x02;
+		bZ[cY++] = dG.length;
+		K(dG, 0, bZ, cY, dG.length);
+		cY += dG.length;
+		bZ[cY++] = 0x02;
+		bZ[cY++] = cF.length;
+		K(cF, 0, bZ, cY, cF.length);
+		cY += cF.length;
+		bZ[cY++] = 0x04;
+		bZ[cY++] = cD.length;
+		K(cD, 0, bZ, cY, cD.length);
+		cY += cD.length;
+		K(dS, 0, bZ, cY, dS.length);
+		cY += dS.length;
+		K(cL, 0, bZ, cY, cL.length);
+		return bZ;
+	},
+	le: function(bZ) {
+		var pos = 0;
+		if (bZ[pos++] != 0x30) {
+			return null;
+		}
+		if ((bZ[pos] & 0xFF) <= 0x7F) {
+			pos++;
+		} else {
+			pos += (bZ[pos] & 0x7F) + 1;
+		}
+		pos++;
+		var fX = bZ[pos];
+		var r = new Array(fX);
+		K(bZ, ++pos, r, 0, fX);
+		pos += fX;
+		pos++;
+		var he = bZ[pos];
+		var s = new Array(he);
+		K(bZ, ++pos, s, 0, he);
+		pos += he;
+		return {
+			'r': r,
+			"s": s
+		};
+	},
+	lh: function(bZ) {
+		var pos = 0;
+		if (bZ[pos++] != 0x30) {
+			return null;
+		}
+		if ((bZ[pos] & 0xFF) <= 0x7F) {
+			pos++;
+		} else {
+			pos += (bZ[pos] & 0x7F) + 1;
+		}
+		pos++;
+		var jk = bZ[pos];
+		var dG = new Array(jk);
+		K(bZ, ++pos, dG, 0, jk);
+		pos += jk;
+		pos++;
+		var iX = bZ[pos];
+		var cF = new Array(iX);
+		K(bZ, ++pos, cF, 0, iX);
+		pos += iX;
+		pos++;
+		var jD = bZ[pos];
+		var cD = new Array(jD);
+		K(bZ, ++pos, cD, 0, jD);
+		pos += jD;
+		pos++;
+		var fJ = 0;
+		if ((bZ[pos] & 0xFF) <= 0x7F) {
+			fJ = bZ[pos] & 0xFF;
+		} else {
+			for (var i = 0, j = (bZ[pos] & 0x7F) - 1; i < (bZ[pos] & 0x7F); i++, j--) {
+				fJ = fJ | ((bZ[pos + i + 1] & 0xFF) << (j * 8));
+			}
+			pos += (bZ[pos] & 0x7F);
+		}
+		var cL = new Array(fJ);
+		K(bZ, ++pos, cL, 0, fJ);
+		pos += fJ;
+		return {
+			'dG': dG,
+			"cF": cF,
+			"cL": cL,
+			"cD": cD
+		};
+	}
+};
+
+function bL() {};
+bL.prototype = {
+	source: function(source) {
+		if (!source) {
+			dB.error("source is empty!");
+			return false;
+		} else {
+			return true;
+		}
+	},
+	fd: function(eS) {
+		if (typeof(eS) == 'undefined') {
+			dB.error("eS type undefined!");
+		} else if (eS instanceof Array) {
+			eS = CommonUtils.bytesToHex(eS);
+		}
+		if (this.ge(eS, "04") && eS.length == 130) {
+			return true;
+		} else {
+			dB.error("eS length error!");
+			return false;
+		}
+	},
+	fo: function(fM) {
+		if (typeof(fM) == 'undefined') {
+			dB.error("fM type undefined!");
+		} else if (fM instanceof Array) {
+			fM = CommonUtils.bytesToHex(fM);
+		}
+		if (fM.length % 2 == 0) {
+			return true;
+		} else {
+			dB.error("fM length error!");
+			return false;
+		}
+	},
+	gp: function(cw) {
+		if (typeof(cw) == 'undefined') {
+			dB.error("cw type undefined!");
+		} else if (cw instanceof Array) {
+			cw = CommonUtils.bytesToHex(cw);
+		}
+		if (this.ge(cw, "04") && cw.length % 2 == 0 && cw.length > 194) {
+			return true;
+		} else if (this.ge(cw, "30") && cw.length % 2 == 0 && cw.length > 216) {
+			return true;
+		} else {
+			dB.error("cw format jw length error!");
+			return false;
+		}
+	},
+	fP: function(er) {
+		if (typeof(er) == 'undefined') {
+			dB.error("er type undefined!");
+		} else if (er instanceof Array) {
+			er = CommonUtils.bytesToHex(er);
+		}
+		if (er.length == 128) {
+			return true;
+		} else if (this.ge(er, "30") && er.length % 2 == 0) {
+			return true;
+		} else {
+			dB.error("er format jw length error!");
+			return false;
+		}
+	},
+	fF: function(key) {
+		if (typeof(key) == 'undefined') {
+			dB.error("key type undefined!");
+		} else if (key instanceof Array) {
+			key = CommonUtils.bytesToHex(key);
+		}
+		if (key.length == 32) {
+			return true;
+		} else {
+			dB.error("key length error!");
+			return false;
+		}
+	},
+	hj: function(cd) {
+		if (typeof(cd) == 'undefined') {
+			dB.error("cd type undefined!");
+		} else if (cd instanceof Array) {
+			cd = CommonUtils.bytesToHex(cd);
+		}
+		if (cd.length == 32) {
+			return true;
+		} else {
+			dB.error("cd length error!");
+			return false;
+		}
+	},
+	hd: function(cw) {
+		if (typeof(cw) == 'undefined') {
+			dB.error("cw type undefined!");
+		} else if (cw instanceof Array) {
+			cw = CommonUtils.bytesToHex(cw);
+		}
+		if (cw && cw.length % 16 == 0) {
+			return true;
+		} else {
+			dB.error("cw format jw length error!");
+			return false;
+		}
+	},
+	ge: function(fL, start) {
+		var reg = new RegExp("^" + start);
+		return reg.test(fL);
+	}
+};
+
+var Sm2Utils = {
+	eV: CipherMode.C1C2C3,
+	eC: null,
+	cw: new aK(this.eV, this.eC),
+	smValidate: new bL(),
+	generateKeyPair: function() {
+		return this.cw.kX();
+	},
+	getPublicKey: function(kL) {
+		var cZ = CommonUtils.hexToBytes(kL);
+		var dC = this.cw.jR(cZ);
+		return CommonUtils.bytesToHex(dC);
+	},
+	encryptFromText: function(cV, cb) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var dH = this.cw.gd(dC, cu, false);
+		return CommonUtils.bytesToHex(dH);
+	},
+	decryptToText: function(du, cE) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.gp(cE)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var dH = CommonUtils.hexToBytes(cE);
+		var cu = this.cw.ht(cZ, dH, false);
+		return CommonUtils.bytesToUtf8Str(cu);
+	},
+	encryptFromHex: function(cV, dO) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.hexToBytes(dO);
+		var dH = this.cw.gd(dC, cu, false);
+		return CommonUtils.bytesToHex(dH);
+	},
+	decryptToHex: function(du, cE) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.gp(cE)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var dH = CommonUtils.hexToBytes(cE);
+		var cu = this.cw.ht(cZ, dH, false);
+		return CommonUtils.bytesToHex(cu);
+	},
+	encryptFromData: function(dC, cu) {
+		if (!this.smValidate.fd(dC)) {
+			return null;
+		}
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		return this.cw.gd(dC, cu, false);
+	},
+	decryptToData: function(cZ, dH) {
+		if (!this.smValidate.fo(cZ)) {
+			return null;
+		}
+		if (!this.smValidate.gp(dH)) {
+			return null;
+		}
+		return this.cw.ht(cZ, dH, false);
+	},
+	encryptASN1FromText: function(cV, cb) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var dH = this.cw.gd(dC, cu, true);
+		return CommonUtils.bytesToHex(dH);
+	},
+	decryptASN1ToText: function(du, cE) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.gp(cE)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var dH = CommonUtils.hexToBytes(cE);
+		var cu = this.cw.ht(cZ, dH, true);
+		return CommonUtils.bytesToUtf8Str(cu);
+	},
+	encryptASN1FromHex: function(cV, dO) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.hexToBytes(dO);
+		var dH = this.cw.gd(dC, cu, true);
+		return CommonUtils.bytesToHex(dH);
+	},
+	decryptASN1ToHex: function(du, cE) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.gp(cE)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var dH = CommonUtils.hexToBytes(cE);
+		var cu = this.cw.ht(cZ, dH, true);
+		return CommonUtils.bytesToHex(cu);
+	},
+	encryptASN1FromData: function(dC, cu) {
+		if (!this.smValidate.fd(dC)) {
+			return null;
+		}
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		return this.cw.gd(dC, cu, true);
+	},
+	decryptASN1ToData: function(cZ, dH) {
+		if (!this.smValidate.fo(cZ)) {
+			return null;
+		}
+		if (!this.smValidate.gp(dH)) {
+			return null;
+		}
+		return this.cw.ht(cZ, dH, true);
+	},
+	signFromText: function(du, cb) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var cB = this.cw.er(cu, cZ, false);
+		return CommonUtils.bytesToHex(cB);
+	},
+	verifySignFromText: function(cV, cb, dW) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		if (!this.smValidate.fP(dW)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var cB = CommonUtils.hexToBytes(dW);
+		return this.cw.ga(cu, cB, dC, false);
+	},
+	signFromHex: function(du, dO) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var cu = CommonUtils.hexToBytes(dO);
+		var cB = this.cw.er(cu, cZ, false);
+		return CommonUtils.bytesToHex(cB);
+	},
+	verifySignFromHex: function(cV, dO, dW) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		if (!this.smValidate.fP(dW)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.hexToBytes(dO);
+		var cB = CommonUtils.hexToBytes(dW);
+		return this.cw.ga(cu, cB, dC, false);
+	},
+	signFromData: function(cZ, cu) {
+		if (!this.smValidate.fo(cZ)) {
+			return null;
+		}
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		return this.cw.er(cu, cZ, false);
+	},
+	verifySignFromData: function(dC, cu, cB) {
+		if (!this.smValidate.fd(dC)) {
+			return null;
+		}
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		if (!this.smValidate.fP(cB)) {
+			return null;
+		}
+		return this.cw.ga(cu, cB, dC, false);
+	},
+	signASN1FromText: function(du, cb) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var cB = this.cw.er(cu, cZ, true);
+		return CommonUtils.bytesToHex(cB);
+	},
+	verifySignASN1FromText: function(cV, cb, dW) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		if (!this.smValidate.fP(dW)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var cB = CommonUtils.hexToBytes(dW);
+		return this.cw.ga(cu, cB, dC, true);
+	},
+	signASN1FromHex: function(du, dO) {
+		if (!this.smValidate.fo(du)) {
+			return null;
+		}
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		var cZ = CommonUtils.hexToBytes(du);
+		var cu = CommonUtils.hexToBytes(dO);
+		var cB = this.cw.er(cu, cZ, true);
+		return CommonUtils.bytesToHex(cB);
+	},
+	verifySignASN1FromHex: function(cV, dO, dW) {
+		if (!this.smValidate.fd(cV)) {
+			return null;
+		}
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		if (!this.smValidate.fP(dW)) {
+			return null;
+		}
+		var dC = CommonUtils.hexToBytes(cV);
+		var cu = CommonUtils.hexToBytes(dO);
+		var cB = CommonUtils.hexToBytes(dW);
+		return this.cw.ga(cu, cB, dC, true);
+	},
+	signASN1FromData: function(cZ, cu) {
+		if (!this.smValidate.fo(cZ)) {
+			return null;
+		}
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		return this.cw.er(cu, cZ, true);
+	},
+	verifySignASN1FromData: function(dC, cu, cB) {
+		if (!this.smValidate.fd(dC)) {
+			return null;
+		}
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		if (!this.smValidate.fP(cB)) {
+			return null;
+		}
+		return this.cw.ga(cu, cB, dC, true);
+	}
+};
+var Sm3Utils = {
+	smValidate: new bL(),
+	encryptFromText: function(cb) {
+		if (!this.smValidate.source(cb)) {
+			return null;
+		}
+		var cu = CommonUtils.utf8StrToBytes(cb);
+		var eQ = this.encryptFromData(cu);
+		return CommonUtils.bytesToHex(eQ);
+	},
+	encryptFromHex: function(dO) {
+		if (!this.smValidate.source(dO)) {
+			return null;
+		}
+		var cu = CommonUtils.hexToBytes(dO);
+		var eQ = this.encryptFromData(cu);
+		return CommonUtils.bytesToHex(eQ);
+	},
+	encryptFromData: function(cu) {
+		if (!this.smValidate.source(cu)) {
+			return null;
+		}
+		var eQ = new Array(32);
+		var jy = new T();
+		jy.fc(cu, 0, cu.length);
+		jy.gN(eQ, 0);
+		return eQ;
+	}
+};
+var Sm4Utils = {
+	ECB: {
+		smValidate: new bL(),
+		encryptFromText: function(cb, dz) {
+			if (!this.smValidate.source(cb)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var cu = CommonUtils.utf8StrToBytes(cb);
+			var dH = this.encryptFromData(cu, cK);
+			return CommonUtils.bytesToHex(dH);
+		},
+		encryptFromHex: function(dO, dz) {
+			if (!this.smValidate.source(dO)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var cu = CommonUtils.hexToBytes(dO);
+			var dH = this.encryptFromData(cu, cK);
+			return CommonUtils.bytesToHex(dH);
+		},
+		encryptFromData: function(cu, cK) {
+			if (!this.smValidate.source(cu)) {
+				return null;
+			}
+			if (!this.smValidate.fF(cK)) {
+				return null;
+			}
+			try {
+				var dV = new aP();
+				return dV.lk(cu, cK);
+			} catch (e) {
+				dB.error(e);
+				return null;
+			}
+		},
+		decryptToText: function(cE, dz) {
+			if (!this.smValidate.hd(cE)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var dH = CommonUtils.hexToBytes(cE);
+			var cu = this.decryptToData(dH, cK);
+			return CommonUtils.bytesToUtf8Str(cu);
+		},
+		decryptToHex: function(cE, dz) {
+			if (!this.smValidate.hd(cE)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var dH = CommonUtils.hexToBytes(cE);
+			var cu = this.decryptToData(dH, cK);
+			return CommonUtils.bytesToHex(cu);
+		},
+		decryptToData: function(dH, cK) {
+			if (!this.smValidate.hd(dH)) {
+				return null;
+			}
+			if (!this.smValidate.fF(cK)) {
+				return null;
+			}
+			try {
+				var dV = new aP();
+				return dV.kY(dH, cK);
+			} catch (e) {
+				dB.error(e);
+				return null;
+			}
+		}
+	},
+	CBC: {
+		smValidate: new bL(),
+		encryptFromText: function(cb, dz, dZ) {
+			if (!this.smValidate.source(cb)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			if (!this.smValidate.hj(dZ)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var fq = CommonUtils.hexToBytes(dZ);
+			var cu = CommonUtils.utf8StrToBytes(cb);
+			var dH = this.encryptFromData(cu, cK, fq);
+			return CommonUtils.bytesToHex(dH);
+		},
+		encryptFromHex: function(dO, dz, dZ) {
+			if (!this.smValidate.source(dO)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			if (!this.smValidate.hj(dZ)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var fq = CommonUtils.hexToBytes(dZ);
+			var cu = CommonUtils.hexToBytes(dO);
+			var dH = this.encryptFromData(cu, cK, fq);
+			return CommonUtils.bytesToHex(dH);
+		},
+		encryptFromData: function(cu, cK, fq) {
+			if (!this.smValidate.source(cu)) {
+				return null;
+			}
+			if (!this.smValidate.fF(cK)) {
+				return null;
+			}
+			if (!this.smValidate.hj(fq)) {
+				return null;
+			}
+			try {
+				var dV = new aP();
+				return dV.ll(cu, cK, fq);
+			} catch (e) {
+				dB.error(e);
+				return null;
+			}
+		},
+		decryptToText: function(cE, dz, dZ) {
+			if (!this.smValidate.hd(cE)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			if (!this.smValidate.hj(dZ)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var fq = CommonUtils.hexToBytes(dZ);
+			var dH = CommonUtils.hexToBytes(cE);
+			var cu = this.decryptToData(dH, cK, fq);
+			return CommonUtils.bytesToUtf8Str(cu);
+		},
+		decryptToHex: function(cE, dz, dZ) {
+			if (!this.smValidate.hd(cE)) {
+				return null;
+			}
+			if (!this.smValidate.fF(dz)) {
+				return null;
+			}
+			if (!this.smValidate.hj(dZ)) {
+				return null;
+			}
+			var cK = CommonUtils.hexToBytes(dz);
+			var fq = CommonUtils.hexToBytes(dZ);
+			var dH = CommonUtils.hexToBytes(cE);
+			var cu = this.decryptToData(dH, cK, fq);
+			return CommonUtils.bytesToHex(cu);
+		},
+		decryptToData: function(dH, cK, fq) {
+			if (!this.smValidate.hd(dH)) {
+				return null;
+			}
+			if (!this.smValidate.fF(cK)) {
+				return null;
+			}
+			if (!this.smValidate.hj(fq)) {
+				return null;
+			}
+			try {
+				var dV = new aP();
+				return dV.kD(dH, cK, fq);
+			} catch (e) {
+				dB.error(e);
+				return null;
+			}
+		}
+	}
+};
+return {
+	Sm2Utils: Sm2Utils,
+	Sm3Utils: Sm3Utils,
+	Sm4Utils: Sm4Utils,
+}
+});