mirror of
https://github.com/luzhisheng/js_reverse.git
synced 2025-04-19 04:54:43 +08:00
7641 lines
307 KiB
JavaScript
7641 lines
307 KiB
JavaScript
var window = global;
|
|
// Date.now = function now() {
|
|
// return 1661986251253
|
|
// };
|
|
// Date.parse = function () {
|
|
// return 1661986251253
|
|
// };
|
|
// Date.prototype.valueOf = function () {
|
|
// return 1661986251253
|
|
// };
|
|
// Date.prototype.getTime = function () {
|
|
// return 1661986251253
|
|
// };
|
|
// Date.prototype.toString = function () {
|
|
// return 1661986251253
|
|
// };
|
|
// Performance.prototype.now = function now() {
|
|
// return Number('1661986251253'.slice(8))
|
|
// };
|
|
// Math.random = function random() {
|
|
// return 0.08636862211354912
|
|
// };
|
|
// window.crypto.getRandomValues = function getRandomValues(array32, ...args) {
|
|
// return array32;
|
|
// };
|
|
var _n;
|
|
!function (q) {
|
|
var R = {};
|
|
|
|
function L(G) {
|
|
if (R[G])
|
|
return R[G].exports;
|
|
var p = R[G] = {
|
|
"i": G,
|
|
"l": !1,
|
|
"exports": {}
|
|
};
|
|
return q[G].call(p.exports, p, p.exports, L),
|
|
p.l = !0,
|
|
p.exports
|
|
}
|
|
|
|
_n = L
|
|
}({
|
|
"encrypt": function (R, L, G) {
|
|
var p = {};
|
|
p.yMOtj = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.aoeqs = "number";
|
|
p.VPtnN = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.nvitN = "string";
|
|
p.NuAaH = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.ekfNq = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.cjItI = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.UZAuQ = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.WBCKk = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.sXebZ = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.PxIGP = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.Vamfn = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.BXvFM = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.vbNbB = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.szSWf = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.vWTEo = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.XzRfz = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.HOIdh = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.RVDoi = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.fDcur = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.ENgVY = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.zWdKW = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.EyooA = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.pdRDx = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.QObtY = function (h, o) {
|
|
return h <= o
|
|
}
|
|
;
|
|
p.RWpTC = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.OxEIB = function (h, o) {
|
|
return h(o)
|
|
}
|
|
;
|
|
p.vOXOW = "4|0|3|5|6|2|1";
|
|
p.gpUSL = function (h, o) {
|
|
return h / o
|
|
}
|
|
;
|
|
p.eaCeB = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.lGCXz = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.rdngm = function (h, o) {
|
|
return h % o
|
|
}
|
|
;
|
|
p.VnRNu = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.BQrfg = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.NrXEw = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.rlHId = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.pQuJc = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.TbPFh = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.sRSAw = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.suOvI = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.RmPxN = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.raaWW = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.hjtga = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.IeBzn = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.KFXsi = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.Wnmtu = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.JYrwO = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.nOKyy = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.KkWRM = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.bDBhK = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.qQazD = "2|0|4|3|1";
|
|
p.BwtxY = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.Eezpt = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.omBTW = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.nlvEd = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.rdVRk = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.EARrs = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.jYDcp = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.MNNBI = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.Xcadz = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.MPQul = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.iZCcZ = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.pHneT = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.zaMlq = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.barYY = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.fiyoX = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.zAlhd = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.HrHPT = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.DydwZ = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.fzrht = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.uvBrG = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.mgUiS = "3|4|0|2|1|5";
|
|
p.eFcEb = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.VfVQi = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.ucnKx = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.xUQYu = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.HWfNK = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.Oebjd = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.xNlRw = "3|4|2|0|1";
|
|
p.sZrWA = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.ZnXKp = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.XfSXR = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.RBxSw = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.sxmIT = function (h, o) {
|
|
return h | o
|
|
}
|
|
;
|
|
p.ZSPZD = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.NJvnP = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.GKJrO = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.aAnkJ = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.REJpn = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.YuuDx = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.WjGiL = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.ykPDN = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.Gwqpy = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.TMFuj = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.TAtAc = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.dshAB = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.pnwdf = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.quRVT = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.xxaFq = function (h, o) {
|
|
return h === o
|
|
}
|
|
;
|
|
p.oDDon = "https";
|
|
p.WmsWX = "windows";
|
|
p.XcqNK = "rhino";
|
|
p.DQpPw = "Apple";
|
|
p.EhCdT = "WebOS";
|
|
p.qfqwE = "Android";
|
|
p.JHcEY = "function";
|
|
p.Mcgzf = "3|0|4|1|2";
|
|
p.KkkTq = "\r\n-----END ";
|
|
p.DRicM = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.gwfUu = ",v=";
|
|
p.FnieI = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.FZixB = "ASN.1 length too long to represent by 8x: n = ";
|
|
p.BcJGK = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.GuoIH = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.DAvRq = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.sDclx = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.IGxHk = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.qvRVZ = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.qgqzs = "int";
|
|
p.mmQxr = "unused bits shall be from 0 to 7: u = ";
|
|
p.cefEj = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.UItDy = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.jhYfP = "malformed oid string: ";
|
|
p.BCKTo = "utc";
|
|
p.wvEoK = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.Muiyk = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.ghEuG = "RegExp out of sync";
|
|
p.rBLgD = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.rwgxM = "Illegal character at offset ";
|
|
p.hceLd = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.snCfT = function (h, o) {
|
|
return h | o
|
|
}
|
|
;
|
|
p.eqJTQ = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.zonUt = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.GsrHZ = "unknown";
|
|
p.cVCoN = "INTEGER";
|
|
p.OqHeN = "OCTET_STRING";
|
|
p.FUwsz = "OBJECT_IDENTIFIER";
|
|
p.QnrNB = "EXTERNAL";
|
|
p.ihvhY = "REAL";
|
|
p.RkIuE = "ENUMERATED";
|
|
p.UsblA = "EMBEDDED_PDV";
|
|
p.CiJjC = "SET";
|
|
p.RARGI = "PrintableString";
|
|
p.oZjMN = "TeletexString";
|
|
p.SydSb = "VideotexString";
|
|
p.lqwIY = "VisibleString";
|
|
p.zHNcG = "UniversalString";
|
|
p.Nrnlc = "Universal_";
|
|
p.erupT = "Application_";
|
|
p.seHCu = "Private_";
|
|
p.QigEs = "0|2|4|1|3";
|
|
p.GvCka = "true";
|
|
p.ozahH = " elem)";
|
|
p.SfvqK = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.JHrTb = function (h, o) {
|
|
return h !== o
|
|
}
|
|
;
|
|
p.kxklz = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.mnXyI = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.YNLBL = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.XVaqz = "[header:";
|
|
p.bOhxc = "null";
|
|
p.QPikQ = "7|1|6|3|4|0|5|2";
|
|
p.syUdp = "1.2.840.113549.1.1.1";
|
|
p.imsBE = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.sxInn = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.gcGDc = function (h, o) {
|
|
return h || o
|
|
}
|
|
;
|
|
p.eoLYf = "A key was already set, overriding existing.";
|
|
p.tMPma = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.uLbls = "Netscape";
|
|
p.XpDTh = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
p.NGziR = "mousemove";
|
|
p.xZVta = "onmousemove";
|
|
p.FVssu = "toString";
|
|
p.iBiID = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.denfQ = "undefined";
|
|
p.tkrOw = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.FObpk = "2.3.1";
|
|
p.EavwM = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.HLEPN = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.UrrWV = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.gypqo = function (h, o) {
|
|
return h >>> o
|
|
}
|
|
;
|
|
p.Xxuwp = "4|0|2|3|5|1";
|
|
p.jWRPW = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.vbcwT = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.vHNOU = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.Sormo = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.iktCA = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.binbK = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.EGDbQ = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.EgPnI = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.tNnYw = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.Qftvu = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.xVoNr = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.iyRYV = function (h, o) {
|
|
return h >>> o
|
|
}
|
|
;
|
|
p.yoihf = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.TKsOQ = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.qWYTh = function (h, o) {
|
|
return h / o
|
|
}
|
|
;
|
|
p.MzNwE = function (h, o) {
|
|
return h | o
|
|
}
|
|
;
|
|
p.oByOT = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.lHmOj = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.mTqRu = "4|0|3|1|2";
|
|
p.QPgou = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.ZJQmz = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.IJHnr = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.WtQWo = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.QKhxc = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.UfZNK = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.KKnrO = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.QslaL = function (h, o) {
|
|
return h / o
|
|
}
|
|
;
|
|
p.nevNh = function (h, o) {
|
|
return h < o
|
|
}
|
|
;
|
|
p.GXfeo = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.PaBUJ = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.YRGgt = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.tsLIL = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.TvejN = function (h, o) {
|
|
return h ^ o
|
|
}
|
|
;
|
|
p.RYnuK = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.XNMSh = function (h, o) {
|
|
return h(o)
|
|
}
|
|
;
|
|
p.IbXiF = function (h, o) {
|
|
return h ^ o
|
|
}
|
|
;
|
|
p.XNlmv = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.JOUdh = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.GwECZ = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.femdy = function (h) {
|
|
return h()
|
|
}
|
|
;
|
|
p.aRsIj = "1|2|0|3|4";
|
|
p.XvWwy = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.aAOjV = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.qwRVo = "7|3|1|5|0|6|2|4";
|
|
p.wnswQ = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.bdQgL = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.gBinm = function (h, o) {
|
|
return h >> o
|
|
}
|
|
;
|
|
p.mtRFQ = function (h, o) {
|
|
return h - o
|
|
}
|
|
;
|
|
p.bDlRf = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.nAFhv = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.YPfyi = function (h, o) {
|
|
return h(o)
|
|
}
|
|
;
|
|
p.lyYwM = function (h, o) {
|
|
return h(o)
|
|
}
|
|
;
|
|
p.wHLwz = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.qpONy = "2|1|0|3|4";
|
|
p.NzlCH = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.hcgfW = function (h, o) {
|
|
return h >= o
|
|
}
|
|
;
|
|
p.nTtzn = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.XiooC = function (h, o) {
|
|
return h & o
|
|
}
|
|
;
|
|
p.agMMw = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.hfCPQ = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.nxWET = "Invalid RSA private key";
|
|
p.UzkNV = function (h, o) {
|
|
return h(o)
|
|
}
|
|
;
|
|
p.QdebC = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.rmvVM = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.SWtvw = "extend failed, please check that all dependencies are included.";
|
|
p.cvlqy = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.moTiE = "0500";
|
|
p.tsnsB = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.gsZSv = function (h, o) {
|
|
return h != o
|
|
}
|
|
;
|
|
p.BvDQw = function (h, o) {
|
|
return h === o
|
|
}
|
|
;
|
|
p.yMoZd = function (h, o) {
|
|
return h instanceof o
|
|
}
|
|
;
|
|
p.FZkLR = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.uMsqi = "Requesting byte offset ";
|
|
p.kuKEH = function (h, o) {
|
|
return h << o
|
|
}
|
|
;
|
|
p.fUGvo = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.PHddz = " UTC";
|
|
p.lOZEY = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.FiCuO = " bit)";
|
|
p.sHMdl = function (h, o) {
|
|
return h > o
|
|
}
|
|
;
|
|
p.OKTbA = " (constructed)";
|
|
p.uwSDE = "node collapsed";
|
|
p.UTNVO = "node";
|
|
p.KexZP = "span";
|
|
p.HxCzo = "<br/>";
|
|
p.MsVyq = "<br/>(encapsulates)";
|
|
p.ZIMdJ = function (h, o) {
|
|
return h + o
|
|
}
|
|
;
|
|
p.iQMav = "<br/>Value:<br/><b>";
|
|
p.SbPvL = "<br/>(warning!)";
|
|
p.kjanl = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.VCQSs = "tag";
|
|
p.EuBnZ = "ulen";
|
|
p.UApLK = "5|2|6|1|0|4|3";
|
|
p.ystbG = "Length over 24 bits not supported at position ";
|
|
p.ppPyI = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.wCSAq = "0123456789ABCDEF";
|
|
p.YpTgQ = function (h, o) {
|
|
return h * o
|
|
}
|
|
;
|
|
p.ldEFI = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.XviLE = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.KcMXV = function (h, o, m) {
|
|
return h(o, m)
|
|
}
|
|
;
|
|
p.XcbrV = "})( +|$\n?)|(.{1,";
|
|
p.MQnMc = "coeff";
|
|
p.PwSpw = function (h, o) {
|
|
return h == o
|
|
}
|
|
;
|
|
p.qozxg = function (h, o) {
|
|
return h === o
|
|
}
|
|
;
|
|
p.UpDNT = "[object Function]";
|
|
p.Glyvi = function (h, o) {
|
|
return h === o
|
|
}
|
|
;
|
|
var C = p;
|
|
var f;
|
|
var Y;
|
|
var A;
|
|
C.Glyvi(A = function (h, o, m) {
|
|
var x = {};
|
|
x.nkKNf = function (Z, a) {
|
|
return Z >= a
|
|
}
|
|
;
|
|
x.tCIaf = function (Z, a) {
|
|
return C.EavwM(Z, a)
|
|
}
|
|
;
|
|
x.sdHSW = function (Z, a) {
|
|
return C.EavwM(Z, a)
|
|
}
|
|
;
|
|
x.HvXqg = function (Z, a) {
|
|
return C.quRVT(Z, a)
|
|
}
|
|
;
|
|
x.RWKHq = function (Z, a) {
|
|
return C.hceLd(Z, a)
|
|
}
|
|
;
|
|
x.ubmKK = function (Z, a) {
|
|
return C.HLEPN(Z, a)
|
|
}
|
|
;
|
|
x.YTGma = function (Z, a) {
|
|
return C.HLEPN(Z, a)
|
|
}
|
|
;
|
|
x.qKVHI = function (Z, a) {
|
|
return Z * a
|
|
}
|
|
;
|
|
x.iaGwq = function (Z, a) {
|
|
return C.UrrWV(Z, a)
|
|
}
|
|
;
|
|
x.Yobyd = function (Z, a) {
|
|
return C.gypqo(Z, a)
|
|
}
|
|
;
|
|
x.hTgdZ = function (Z, a) {
|
|
return C.kxklz(Z, a)
|
|
}
|
|
;
|
|
x.ZSXSF = C.Xxuwp;
|
|
x.eBkWN = function (Z, a) {
|
|
return C.jWRPW(Z, a)
|
|
}
|
|
;
|
|
x.AICVW = function (Z, a) {
|
|
return Z == a
|
|
}
|
|
;
|
|
x.GshWW = function (Z, a) {
|
|
return C.vbcwT(Z, a)
|
|
}
|
|
;
|
|
x.hrfHa = function (Z, a) {
|
|
return C.tkrOw(Z, a)
|
|
}
|
|
;
|
|
x.sLveP = function (Z, a) {
|
|
return C.vHNOU(Z, a)
|
|
}
|
|
;
|
|
x.YKHqj = function (Z, a) {
|
|
return C.Sormo(Z, a)
|
|
}
|
|
;
|
|
x.cpuUC = function (Z, a) {
|
|
return Z % a
|
|
}
|
|
;
|
|
x.jpLiq = function (Z, a) {
|
|
return C.iktCA(Z, a)
|
|
}
|
|
;
|
|
x.WoEdI = function (Z, a) {
|
|
return C.binbK(Z, a)
|
|
}
|
|
;
|
|
x.OQQXY = function (Z, a) {
|
|
return C.zonUt(Z, a)
|
|
}
|
|
;
|
|
x.jVCpH = function (Z, a) {
|
|
return Z(a)
|
|
}
|
|
;
|
|
x.fqrBG = function (Z, a) {
|
|
return C.zonUt(Z, a)
|
|
}
|
|
;
|
|
x.VJgeC = function (Z, a) {
|
|
return C.UrrWV(Z, a)
|
|
}
|
|
;
|
|
x.rXkyR = function (Z, a) {
|
|
return C.EGDbQ(Z, a)
|
|
}
|
|
;
|
|
x.pNTMp = function (Z, a) {
|
|
return C.EgPnI(Z, a)
|
|
}
|
|
;
|
|
x.cySGj = function (Z, a) {
|
|
return C.tNnYw(Z, a)
|
|
}
|
|
;
|
|
x.AJTVB = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.mRsou = function (Z, a) {
|
|
return C.Qftvu(Z, a)
|
|
}
|
|
;
|
|
x.UAFdg = function (Z, a) {
|
|
return C.hceLd(Z, a)
|
|
}
|
|
;
|
|
x.miLBx = function (Z, a) {
|
|
return C.zonUt(Z, a)
|
|
}
|
|
;
|
|
x.RBjvU = function (Z, a) {
|
|
return Z(a)
|
|
}
|
|
;
|
|
x.xKRkc = function (Z, a) {
|
|
return C.xVoNr(Z, a)
|
|
}
|
|
;
|
|
x.YWRsD = function (Z, a) {
|
|
return Z != a
|
|
}
|
|
;
|
|
x.owmJD = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.SUZMe = function (Z, a) {
|
|
return C.iyRYV(Z, a)
|
|
}
|
|
;
|
|
x.BXaVK = function (Z, a) {
|
|
return Z >> a
|
|
}
|
|
;
|
|
x.uNvaM = function (Z, a) {
|
|
return C.yoihf(Z, a)
|
|
}
|
|
;
|
|
x.mFEOn = function (Z, a) {
|
|
return C.tNnYw(Z, a)
|
|
}
|
|
;
|
|
x.FgCtf = function (Z, a) {
|
|
return C.iktCA(Z, a)
|
|
}
|
|
;
|
|
x.yYMCA = function (Z, a) {
|
|
return C.TKsOQ(Z, a)
|
|
}
|
|
;
|
|
x.nOxAW = function (Z, a) {
|
|
return Z << a
|
|
}
|
|
;
|
|
x.LZjaC = function (Z, a) {
|
|
return C.qWYTh(Z, a)
|
|
}
|
|
;
|
|
x.CMVvx = function (Z, a) {
|
|
return Z >= a
|
|
}
|
|
;
|
|
x.EtzCR = function (Z, a) {
|
|
return C.MzNwE(Z, a)
|
|
}
|
|
;
|
|
x.WgBOs = function (Z, a) {
|
|
return Z << a
|
|
}
|
|
;
|
|
x.OVZli = function (Z, a) {
|
|
return C.pnwdf(Z, a)
|
|
}
|
|
;
|
|
x.ElFTz = function (Z, a) {
|
|
return C.binbK(Z, a)
|
|
}
|
|
;
|
|
x.mqjUH = function (Z, a) {
|
|
return Z > a
|
|
}
|
|
;
|
|
x.bGNWx = function (Z, a) {
|
|
return C.Qftvu(Z, a)
|
|
}
|
|
;
|
|
x.GqvGw = function (Z, a) {
|
|
return C.zonUt(Z, a)
|
|
}
|
|
;
|
|
x.ZGwHb = function (Z, a) {
|
|
return C.oByOT(Z, a)
|
|
}
|
|
;
|
|
x.uaTxm = function (Z, a) {
|
|
return C.lHmOj(Z, a)
|
|
}
|
|
;
|
|
x.PjZMH = C.mTqRu;
|
|
x.Iyalt = function (Z, a) {
|
|
return Z * a
|
|
}
|
|
;
|
|
x.YCbXF = function (Z, a) {
|
|
return C.QPgou(Z, a)
|
|
}
|
|
;
|
|
x.nsHBA = function (Z, a) {
|
|
return Z * a
|
|
}
|
|
;
|
|
x.vOaKr = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.xfYVo = function (Z, a) {
|
|
return C.ZJQmz(Z, a)
|
|
}
|
|
;
|
|
x.zMtXj = function (Z, a) {
|
|
return C.IJHnr(Z, a)
|
|
}
|
|
;
|
|
x.nOzRJ = function (Z, a) {
|
|
return C.ZJQmz(Z, a)
|
|
}
|
|
;
|
|
x.RheCP = function (Z, a) {
|
|
return Z * a
|
|
}
|
|
;
|
|
x.gRZTt = function (Z, a) {
|
|
return C.ZJQmz(Z, a)
|
|
}
|
|
;
|
|
x.jptlM = function (Z, a) {
|
|
return C.QPgou(Z, a)
|
|
}
|
|
;
|
|
x.mFHzd = function (Z, a) {
|
|
return C.WtQWo(Z, a)
|
|
}
|
|
;
|
|
x.FGypG = function (Z, a) {
|
|
return C.ZJQmz(Z, a)
|
|
}
|
|
;
|
|
x.pknkP = function (Z, a) {
|
|
return C.oByOT(Z, a)
|
|
}
|
|
;
|
|
x.MeeTr = function (Z, a) {
|
|
return Z > a
|
|
}
|
|
;
|
|
x.znchO = function (Z, a) {
|
|
return C.QKhxc(Z, a)
|
|
}
|
|
;
|
|
x.HDpVU = function (Z, a) {
|
|
return C.UfZNK(Z, a)
|
|
}
|
|
;
|
|
x.RnGUD = function (Z, a) {
|
|
return C.KKnrO(Z, a)
|
|
}
|
|
;
|
|
x.bXRqm = function (Z, a) {
|
|
return C.QslaL(Z, a)
|
|
}
|
|
;
|
|
x.DEnUW = function (Z, a) {
|
|
return C.nevNh(Z, a)
|
|
}
|
|
;
|
|
x.LuPYd = function (Z, a, X) {
|
|
return C.GXfeo(Z, a, X)
|
|
}
|
|
;
|
|
x.HRNjf = function (Z, a) {
|
|
return C.PaBUJ(Z, a)
|
|
}
|
|
;
|
|
x.xihmh = function (Z, a) {
|
|
return Z >= a
|
|
}
|
|
;
|
|
x.gOLGt = function (Z, a) {
|
|
return C.YRGgt(Z, a)
|
|
}
|
|
;
|
|
x.UEvGy = function (Z, a, X) {
|
|
return Z(a, X)
|
|
}
|
|
;
|
|
x.acghB = function (Z, a) {
|
|
return C.tsLIL(Z, a)
|
|
}
|
|
;
|
|
x.OOsqd = function (Z, a) {
|
|
return C.TvejN(Z, a)
|
|
}
|
|
;
|
|
x.oebAG = function (Z, a) {
|
|
return C.KKnrO(Z, a)
|
|
}
|
|
;
|
|
x.GHseG = function (Z, a) {
|
|
return C.tsLIL(Z, a)
|
|
}
|
|
;
|
|
x.DgZUt = function (Z, a) {
|
|
return C.RYnuK(Z, a)
|
|
}
|
|
;
|
|
x.dJrbq = function (Z, a) {
|
|
return Z & a
|
|
}
|
|
;
|
|
x.uyoLE = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.ohxRf = function (Z, a) {
|
|
return C.XNMSh(Z, a)
|
|
}
|
|
;
|
|
x.Ocbdv = function (Z, a) {
|
|
return C.IbXiF(Z, a)
|
|
}
|
|
;
|
|
x.bEagz = function (Z, a) {
|
|
return Z > a
|
|
}
|
|
;
|
|
x.EbEHm = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.pUzEz = function (Z, a) {
|
|
return C.nevNh(Z, a)
|
|
}
|
|
;
|
|
x.nGAYf = function (Z, a) {
|
|
return C.XNlmv(Z, a)
|
|
}
|
|
;
|
|
x.SPZfV = function (Z, a) {
|
|
return C.nevNh(Z, a)
|
|
}
|
|
;
|
|
x.JuHSD = function (Z, a) {
|
|
return Z & a
|
|
}
|
|
;
|
|
x.MmyNL = function (Z, a) {
|
|
return C.JOUdh(Z, a)
|
|
}
|
|
;
|
|
x.XYiTN = function (Z, a) {
|
|
return C.GwECZ(Z, a)
|
|
}
|
|
;
|
|
x.ErkTV = function (Z) {
|
|
return C.femdy(Z)
|
|
}
|
|
;
|
|
x.JcSmr = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.iPjiX = C.aRsIj;
|
|
x.BaUOo = function (Z, a) {
|
|
return C.XvWwy(Z, a)
|
|
}
|
|
;
|
|
x.EtahI = function (Z, a) {
|
|
return Z * a
|
|
}
|
|
;
|
|
x.TzPpe = function (Z, a) {
|
|
return C.aAOjV(Z, a)
|
|
}
|
|
;
|
|
x.fAkTh = function (Z, a) {
|
|
return C.GwECZ(Z, a)
|
|
}
|
|
;
|
|
x.RiRYk = function (Z, a) {
|
|
return C.GwECZ(Z, a)
|
|
}
|
|
;
|
|
x.WQcoQ = C.qwRVo;
|
|
x.SrdpF = function (Z, a) {
|
|
return C.lHmOj(Z, a)
|
|
}
|
|
;
|
|
x.mgAIO = function (Z) {
|
|
return C.femdy(Z)
|
|
}
|
|
;
|
|
x.zDHBa = function (Z, a) {
|
|
return C.aAOjV(Z, a)
|
|
}
|
|
;
|
|
x.glVDu = function (Z, a) {
|
|
return C.wnswQ(Z, a)
|
|
}
|
|
;
|
|
x.KWzXe = function (Z, a) {
|
|
return C.wnswQ(Z, a)
|
|
}
|
|
;
|
|
x.McOgc = function (Z, a) {
|
|
return C.lHmOj(Z, a)
|
|
}
|
|
;
|
|
x.GQhRB = function (Z, a) {
|
|
return C.bdQgL(Z, a)
|
|
}
|
|
;
|
|
x.IkJsq = function (Z, a) {
|
|
return C.gBinm(Z, a)
|
|
}
|
|
;
|
|
x.KOcMi = function (Z, a) {
|
|
return C.mtRFQ(Z, a)
|
|
}
|
|
;
|
|
x.dXuGG = function (Z, a) {
|
|
return C.EgPnI(Z, a)
|
|
}
|
|
;
|
|
x.UJmYs = function (Z, a) {
|
|
return C.mtRFQ(Z, a)
|
|
}
|
|
;
|
|
x.LeVSk = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.wSIqX = function (Z, a) {
|
|
return C.mtRFQ(Z, a)
|
|
}
|
|
;
|
|
x.CWoyi = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.qQpbk = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.LdsqW = function (Z, a) {
|
|
return C.wnswQ(Z, a)
|
|
}
|
|
;
|
|
x.XDXAk = function (Z, a) {
|
|
return C.bdQgL(Z, a)
|
|
}
|
|
;
|
|
x.zWiQy = function (Z, a) {
|
|
return C.bDlRf(Z, a)
|
|
}
|
|
;
|
|
x.EWeAz = function (Z, a) {
|
|
return C.nAFhv(Z, a)
|
|
}
|
|
;
|
|
x.OzgIn = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.anPWw = function (Z, a) {
|
|
return C.bdQgL(Z, a)
|
|
}
|
|
;
|
|
x.KcLFs = function (Z, a) {
|
|
return C.mtRFQ(Z, a)
|
|
}
|
|
;
|
|
x.biNto = function (Z) {
|
|
return C.femdy(Z)
|
|
}
|
|
;
|
|
x.fsYyP = function (Z, a) {
|
|
return C.YPfyi(Z, a)
|
|
}
|
|
;
|
|
x.fvqxb = function (Z, a) {
|
|
return C.bDlRf(Z, a)
|
|
}
|
|
;
|
|
x.emsrR = function (Z, a) {
|
|
return Z(a)
|
|
}
|
|
;
|
|
x.UNZJm = function (Z, a) {
|
|
return C.lyYwM(Z, a)
|
|
}
|
|
;
|
|
x.JtkDZ = function (Z, a) {
|
|
return Z != a
|
|
}
|
|
;
|
|
x.fXfsR = function (Z, a) {
|
|
return Z <= a
|
|
}
|
|
;
|
|
x.tszKs = function (Z, a) {
|
|
return C.bDlRf(Z, a)
|
|
}
|
|
;
|
|
x.hStLf = function (Z, a) {
|
|
return Z < a
|
|
}
|
|
;
|
|
x.HjWiz = function (Z, a) {
|
|
return Z < a
|
|
}
|
|
;
|
|
x.tpMAg = function (Z, a) {
|
|
return C.wHLwz(Z, a)
|
|
}
|
|
;
|
|
x.yDKIR = function (Z, a) {
|
|
return Z % a
|
|
}
|
|
;
|
|
x.kpgOz = function (Z, a) {
|
|
return C.XNlmv(Z, a)
|
|
}
|
|
;
|
|
x.TORTh = function (Z, a) {
|
|
return C.nevNh(Z, a)
|
|
}
|
|
;
|
|
x.OBCXQ = C.qpONy;
|
|
x.QRakU = function (Z, a) {
|
|
return C.NzlCH(Z, a)
|
|
}
|
|
;
|
|
x.imhlT = function (Z, a) {
|
|
return C.hcgfW(Z, a)
|
|
}
|
|
;
|
|
x.wwmHc = function (Z, a) {
|
|
return Z != a
|
|
}
|
|
;
|
|
x.UWXXj = function (Z, a) {
|
|
return C.nTtzn(Z, a)
|
|
}
|
|
;
|
|
x.OTTcd = function (Z, a) {
|
|
return Z == a
|
|
}
|
|
;
|
|
x.GnTJo = function (Z, a) {
|
|
return Z & a
|
|
}
|
|
;
|
|
x.eArWj = function (Z, a) {
|
|
return Z > a
|
|
}
|
|
;
|
|
x.qtrXY = function (Z, a) {
|
|
return C.XNlmv(Z, a)
|
|
}
|
|
;
|
|
x.LCAMm = function (Z, a) {
|
|
return C.GwECZ(Z, a)
|
|
}
|
|
;
|
|
x.VAyWm = function (Z, a) {
|
|
return C.MzNwE(Z, a)
|
|
}
|
|
;
|
|
x.YJCRW = function (Z, a) {
|
|
return C.XiooC(Z, a)
|
|
}
|
|
;
|
|
x.bQYQH = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.iXVgq = function (Z, a) {
|
|
return C.XiooC(Z, a)
|
|
}
|
|
;
|
|
x.gFgNO = function (Z, a) {
|
|
return C.agMMw(Z, a)
|
|
}
|
|
;
|
|
x.ImrcA = function (Z, a, X) {
|
|
return C.hfCPQ(Z, a, X)
|
|
}
|
|
;
|
|
x.ktCBH = function (Z, a, X) {
|
|
return C.hfCPQ(Z, a, X)
|
|
}
|
|
;
|
|
x.IQycX = C.nxWET;
|
|
x.lyZcT = function (Z, a, X) {
|
|
return Z(a, X)
|
|
}
|
|
;
|
|
x.VgqQS = function (Z, a, X) {
|
|
return C.hfCPQ(Z, a, X)
|
|
}
|
|
;
|
|
x.tDXId = function (Z, a) {
|
|
return C.gBinm(Z, a)
|
|
}
|
|
;
|
|
x.VsBUP = "4|3|0|1|2";
|
|
x.AtYSS = function (Z, a) {
|
|
return Z > a
|
|
}
|
|
;
|
|
x.NhsVJ = function (Z, a) {
|
|
return C.wHLwz(Z, a)
|
|
}
|
|
;
|
|
x.PAXwW = function (Z, a) {
|
|
return C.UzkNV(Z, a)
|
|
}
|
|
;
|
|
x.dhbZz = function (Z, a) {
|
|
return C.QdebC(Z, a)
|
|
}
|
|
;
|
|
x.wFepq = C.aoeqs;
|
|
x.YXBmi = function (Z, a) {
|
|
return C.gBinm(Z, a)
|
|
}
|
|
;
|
|
x.DWmHp = function (Z, a) {
|
|
return C.rmvVM(Z, a)
|
|
}
|
|
;
|
|
x.RrUEC = function (Z, a) {
|
|
return C.mtRFQ(Z, a)
|
|
}
|
|
;
|
|
x.GCmaz = function (Z, a) {
|
|
return Z < a
|
|
}
|
|
;
|
|
x.isEZE = function (Z, a) {
|
|
return C.agMMw(Z, a)
|
|
}
|
|
;
|
|
x.GPhRM = function (Z, a) {
|
|
return C.gcGDc(Z, a)
|
|
}
|
|
;
|
|
x.Bjmam = C.SWtvw;
|
|
x.jbYqm = function (Z, a) {
|
|
return C.cvlqy(Z, a)
|
|
}
|
|
;
|
|
x.UYpYj = "0101ff";
|
|
x.RBJIj = C.moTiE;
|
|
x.vHCzi = function (Z, a) {
|
|
return C.GwECZ(Z, a)
|
|
};
|
|
x.GJtmq = function (Z, a) {
|
|
return C.agMMw(Z, a)
|
|
}
|
|
;
|
|
x.iIkiv = C.denfQ;
|
|
x.UyaUB = function (Z, a) {
|
|
return Z != a
|
|
}
|
|
;
|
|
x.zZyNj = function (Z, a) {
|
|
return C.tsnsB(Z, a)
|
|
}
|
|
;
|
|
x.DKMMb = function (Z, a) {
|
|
return C.gsZSv(Z, a)
|
|
}
|
|
;
|
|
x.stHpC = function (Z, a) {
|
|
return C.BvDQw(Z, a)
|
|
}
|
|
;
|
|
x.KccZJ = function (Z, a) {
|
|
return C.rmvVM(Z, a)
|
|
}
|
|
;
|
|
x.MzTCG = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.DyTvf = "Illegal character at offset ";
|
|
x.unSVS = function (Z, a) {
|
|
return C.yMoZd(Z, a)
|
|
}
|
|
;
|
|
x.ZGGFY = function (Z, a) {
|
|
return C.FZkLR(Z, a)
|
|
}
|
|
;
|
|
x.UonDO = C.uMsqi;
|
|
x.eakbC = function (Z, a) {
|
|
return C.JHrTb(Z, a)
|
|
}
|
|
;
|
|
x.advyF = function (Z, a) {
|
|
return C.kuKEH(Z, a)
|
|
}
|
|
;
|
|
x.JOrPO = function (Z, a) {
|
|
return C.fUGvo(Z, a)
|
|
}
|
|
;
|
|
x.zUJtu = C.PHddz;
|
|
x.PnrqC = function (Z, a) {
|
|
return C.lOZEY(Z, a)
|
|
}
|
|
;
|
|
x.rinhL = function (Z, a) {
|
|
return C.BvDQw(Z, a)
|
|
}
|
|
;
|
|
x.zoGLP = C.FiCuO;
|
|
x.lTSdm = function (Z, a) {
|
|
return C.sHMdl(Z, a)
|
|
}
|
|
;
|
|
x.jPTuq = function (Z, a) {
|
|
return C.hcgfW(Z, a)
|
|
}
|
|
;
|
|
x.qWuth = "bigint";
|
|
x.XifDc = C.OKTbA;
|
|
x.FfvlX = C.uwSDE;
|
|
x.GbWHP = "div";
|
|
x.epwKW = C.UTNVO;
|
|
x.wBJFK = "head";
|
|
x.OuxAf = function (Z, a) {
|
|
return C.UzkNV(Z, a)
|
|
}
|
|
;
|
|
x.EfMxW = "<";
|
|
x.NlyKZ = C.KexZP;
|
|
x.qaLOF = C.HxCzo;
|
|
x.vhLHD = C.MsVyq;
|
|
x.CUOCI = function (Z, a) {
|
|
return C.ZIMdJ(Z, a)
|
|
}
|
|
;
|
|
x.aupVO = C.iQMav;
|
|
x.vznqn = "</b>";
|
|
x.hqnlL = C.SbPvL;
|
|
x.NOYau = function (Z, a) {
|
|
return C.ZIMdJ(Z, a)
|
|
}
|
|
;
|
|
x.xDGRv = " hover";
|
|
x.iCuDU = function (Z, a) {
|
|
return C.kjanl(Z, a)
|
|
}
|
|
;
|
|
x.berdN = C.VCQSs;
|
|
x.AOhkt = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.MVSyP = C.EuBnZ;
|
|
x.snFmI = C.UApLK;
|
|
x.EhZeV = function (Z, a) {
|
|
return C.kjanl(Z, a)
|
|
}
|
|
;
|
|
x.UuKZy = function (Z, a) {
|
|
return C.kuKEH(Z, a)
|
|
}
|
|
;
|
|
x.LQoGs = function (Z, a) {
|
|
return C.XiooC(Z, a)
|
|
}
|
|
;
|
|
x.FosgW = C.ystbG;
|
|
x.HESbY = function (Z, a) {
|
|
return C.mtRFQ(Z, a)
|
|
}
|
|
;
|
|
x.Pzuze = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.yZewf = function (Z, a) {
|
|
return C.ppPyI(Z, a)
|
|
}
|
|
;
|
|
x.fCBAn = function (Z, a) {
|
|
return Z - a
|
|
}
|
|
;
|
|
x.WPQMA = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.SoBOg = C.wCSAq;
|
|
x.QELUQ = function (Z, a) {
|
|
return C.YpTgQ(Z, a)
|
|
}
|
|
;
|
|
x.ruGHB = function (Z, a) {
|
|
return C.BvDQw(Z, a)
|
|
}
|
|
;
|
|
x.xmCmh = function (Z, a, X) {
|
|
return C.ldEFI(Z, a, X)
|
|
}
|
|
;
|
|
x.HQoSn = function (Z, a, X) {
|
|
return C.ldEFI(Z, a, X)
|
|
}
|
|
;
|
|
x.kZRBO = function (Z, a, X) {
|
|
return C.ldEFI(Z, a, X)
|
|
}
|
|
;
|
|
x.VGjct = function (Z, a, X) {
|
|
return C.XviLE(Z, a, X)
|
|
}
|
|
;
|
|
x.TPXHx = function (Z, a, X) {
|
|
return C.KcMXV(Z, a, X)
|
|
}
|
|
;
|
|
x.HoiIC = function (Z, a) {
|
|
return C.UzkNV(Z, a)
|
|
}
|
|
;
|
|
x.yuwzU = function (Z, a) {
|
|
return Z + a
|
|
}
|
|
;
|
|
x.YJHfm = "(.{1,";
|
|
x.Twdtd = C.XcbrV;
|
|
x.UaxBt = function (Z, a) {
|
|
return C.gcGDc(Z, a)
|
|
}
|
|
;
|
|
x.fNvBR = "dmp1";
|
|
x.nhgqk = "dmq1";
|
|
x.KeWtU = C.MQnMc;
|
|
x.XowTU = function (Z, a) {
|
|
return C.PwSpw(Z, a)
|
|
}
|
|
;
|
|
x.zIyHc = C.nvitN;
|
|
x.mMdAc = function (Z, a) {
|
|
return Z(a)
|
|
}
|
|
;
|
|
x.tmUNF = function (Z, a) {
|
|
return C.qozxg(Z, a)
|
|
}
|
|
;
|
|
x.aZLmj = C.UpDNT;
|
|
var H = x;
|
|
Y = [o];
|
|
(C.PwSpw(C.JHcEY, typeof (f = function (T0) {
|
|
var T1 = {};
|
|
T1.JQIBd = function (qJ, qu) {
|
|
return C.yMOtj(qJ, qu)
|
|
}
|
|
;
|
|
T1.SJStG = C.aoeqs;
|
|
T1.BINQv = function (qJ, qu) {
|
|
return C.VPtnN(qJ, qu)
|
|
}
|
|
;
|
|
T1.EWeYn = C.nvitN;
|
|
T1.aCQdR = function (qJ, qu) {
|
|
return C.NuAaH(qJ, qu)
|
|
}
|
|
;
|
|
T1.xnwyO = function (qJ, qu) {
|
|
return C.ekfNq(qJ, qu)
|
|
}
|
|
;
|
|
T1.KIplz = function (qJ, qu) {
|
|
return C.cjItI(qJ, qu)
|
|
}
|
|
;
|
|
T1.AmRLj = function (qJ, qu) {
|
|
return C.UZAuQ(qJ, qu)
|
|
}
|
|
;
|
|
T1.LhHjK = function (qJ, qu) {
|
|
return C.cjItI(qJ, qu)
|
|
}
|
|
;
|
|
T1.Edlzx = function (qJ, qu) {
|
|
return C.WBCKk(qJ, qu)
|
|
}
|
|
;
|
|
T1.JPvZT = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.pfmZz = function (qJ, qu) {
|
|
return C.sXebZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.COgax = function (qJ, qu) {
|
|
return C.ekfNq(qJ, qu)
|
|
}
|
|
;
|
|
T1.sNQoy = function (qJ, qu) {
|
|
return C.PxIGP(qJ, qu)
|
|
}
|
|
;
|
|
T1.pTByM = function (qJ) {
|
|
return C.Vamfn(qJ)
|
|
}
|
|
;
|
|
T1.CWGWi = function (qJ, qu) {
|
|
return C.VPtnN(qJ, qu)
|
|
}
|
|
;
|
|
T1.dbQWD = function (qJ, qu) {
|
|
return C.BXvFM(qJ, qu)
|
|
}
|
|
;
|
|
T1.yuXbv = function (qJ, qu) {
|
|
return qJ >= qu
|
|
}
|
|
;
|
|
T1.PrUrd = function (qJ, qu) {
|
|
return C.vbNbB(qJ, qu)
|
|
}
|
|
;
|
|
T1.LtKKW = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.DTlFy = function (qJ, qu, qb) {
|
|
return C.szSWf(qJ, qu, qb)
|
|
}
|
|
;
|
|
T1.absEa = function (qJ, qu) {
|
|
return C.vWTEo(qJ, qu)
|
|
}
|
|
;
|
|
T1.EgIEL = function (qJ, qu) {
|
|
return C.vbNbB(qJ, qu)
|
|
}
|
|
;
|
|
T1.gaAcY = function (qJ, qu) {
|
|
return C.XzRfz(qJ, qu)
|
|
}
|
|
;
|
|
T1.JNzPG = function (qJ, qu) {
|
|
return qJ << qu
|
|
}
|
|
;
|
|
T1.NobGV = function (qJ, qu) {
|
|
return qJ - qu
|
|
}
|
|
;
|
|
T1.pOzDI = function (qJ, qu) {
|
|
return C.HOIdh(qJ, qu)
|
|
}
|
|
;
|
|
T1.XyKZg = function (qJ, qu) {
|
|
return C.HOIdh(qJ, qu)
|
|
}
|
|
;
|
|
T1.NibRw = function (qJ, qu) {
|
|
return qJ >= qu
|
|
}
|
|
;
|
|
T1.hlcUk = function (qJ, qu) {
|
|
return qJ == qu
|
|
}
|
|
;
|
|
T1.CziqF = function (qJ, qu) {
|
|
return C.RVDoi(qJ, qu)
|
|
}
|
|
;
|
|
T1.cKRku = function (qJ, qu) {
|
|
return C.fDcur(qJ, qu)
|
|
}
|
|
;
|
|
T1.cTlus = function (qJ, qu) {
|
|
return C.ENgVY(qJ, qu)
|
|
}
|
|
;
|
|
T1.fyeqR = function (qJ, qu) {
|
|
return C.PxIGP(qJ, qu)
|
|
}
|
|
;
|
|
T1.ulrep = function (qJ, qu) {
|
|
return C.zWdKW(qJ, qu)
|
|
}
|
|
;
|
|
T1.HJudT = function (qJ, qu) {
|
|
return C.EyooA(qJ, qu)
|
|
}
|
|
;
|
|
T1.aTeHb = function (qJ) {
|
|
return C.Vamfn(qJ)
|
|
}
|
|
;
|
|
T1.TrHcz = function (qJ, qu) {
|
|
return C.pdRDx(qJ, qu)
|
|
}
|
|
;
|
|
T1.bFWMW = function (qJ, qu) {
|
|
return C.QObtY(qJ, qu)
|
|
}
|
|
;
|
|
T1.TlMjt = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.cnrlW = function (qJ, qu) {
|
|
return C.RWpTC(qJ, qu)
|
|
}
|
|
;
|
|
T1.xnBWr = function (qJ, qu) {
|
|
return qJ - qu
|
|
}
|
|
;
|
|
T1.mENgl = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.IUXAb = function (qJ, qu) {
|
|
return qJ ^ qu
|
|
}
|
|
;
|
|
T1.IBOZx = C.vOXOW;
|
|
T1.KxaKN = function (qJ, qu) {
|
|
return C.gpUSL(qJ, qu)
|
|
}
|
|
;
|
|
T1.XlSyL = function (qJ, qu) {
|
|
return C.eaCeB(qJ, qu)
|
|
}
|
|
;
|
|
T1.MRNxl = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.XmTyi = function (qJ, qu) {
|
|
return C.eaCeB(qJ, qu)
|
|
}
|
|
;
|
|
T1.qVgED = function (qJ, qu) {
|
|
return C.lGCXz(qJ, qu)
|
|
}
|
|
;
|
|
T1.JHnGR = function (qJ, qu) {
|
|
return C.eaCeB(qJ, qu)
|
|
}
|
|
;
|
|
T1.FyxbR = function (qJ, qu) {
|
|
return C.rdngm(qJ, qu)
|
|
}
|
|
;
|
|
T1.WFOVl = function (qJ, qu) {
|
|
return C.ekfNq(qJ, qu)
|
|
}
|
|
;
|
|
T1.MQunM = function (qJ, qu) {
|
|
return C.VnRNu(qJ, qu)
|
|
}
|
|
;
|
|
T1.jBeOO = function (qJ, qu) {
|
|
return C.BQrfg(qJ, qu)
|
|
}
|
|
;
|
|
T1.qoZWS = function (qJ, qu) {
|
|
return C.VnRNu(qJ, qu)
|
|
}
|
|
;
|
|
T1.WJoyU = function (qJ, qu) {
|
|
return C.NrXEw(qJ, qu)
|
|
}
|
|
;
|
|
T1.SWwyM = function (qJ, qu) {
|
|
return C.RWpTC(qJ, qu)
|
|
}
|
|
;
|
|
T1.WFcyX = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.KtUFm = function (qJ, qu) {
|
|
return C.sXebZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.XdaKv = function (qJ, qu) {
|
|
return qJ > qu
|
|
}
|
|
;
|
|
T1.wyXQP = function (qJ, qu) {
|
|
return qJ - qu
|
|
}
|
|
;
|
|
T1.leUtv = "2|4|6|3|5|0|1";
|
|
T1.EPWnn = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.UYYRN = function (qJ, qu) {
|
|
return C.ENgVY(qJ, qu)
|
|
}
|
|
;
|
|
T1.blZKX = function (qJ, qu) {
|
|
return C.rlHId(qJ, qu)
|
|
}
|
|
;
|
|
T1.pBtoj = function (qJ, qu) {
|
|
return C.pQuJc(qJ, qu)
|
|
}
|
|
;
|
|
T1.VGmgC = function (qJ, qu) {
|
|
return C.eaCeB(qJ, qu)
|
|
}
|
|
;
|
|
T1.kapdV = function (qJ) {
|
|
return C.TbPFh(qJ)
|
|
}
|
|
;
|
|
T1.JpwJi = function (qJ, qu) {
|
|
return C.sRSAw(qJ, qu)
|
|
}
|
|
;
|
|
T1.GgQRd = function (qJ, qu) {
|
|
return C.suOvI(qJ, qu)
|
|
}
|
|
;
|
|
T1.SrQkp = function (qJ, qu) {
|
|
return C.RmPxN(qJ, qu)
|
|
}
|
|
;
|
|
T1.FOtPO = function (qJ, qu) {
|
|
return C.raaWW(qJ, qu)
|
|
}
|
|
;
|
|
T1.Warxl = function (qJ, qu) {
|
|
return C.eaCeB(qJ, qu)
|
|
}
|
|
;
|
|
T1.LUvKl = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.lLyXU = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.XAWjd = function (qJ, qu) {
|
|
return C.zWdKW(qJ, qu)
|
|
}
|
|
;
|
|
T1.XdVor = function (qJ, qu) {
|
|
return C.hjtga(qJ, qu)
|
|
}
|
|
;
|
|
T1.MwJLH = function (qJ, qu) {
|
|
return C.PxIGP(qJ, qu)
|
|
}
|
|
;
|
|
T1.jyTcZ = function (qJ, qu) {
|
|
return C.sXebZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.KSvfl = function (qJ, qu) {
|
|
return C.ekfNq(qJ, qu)
|
|
}
|
|
;
|
|
T1.ptkKP = function (qJ, qu) {
|
|
return C.hjtga(qJ, qu)
|
|
}
|
|
;
|
|
T1.xJWhO = function (qJ) {
|
|
return C.IeBzn(qJ)
|
|
}
|
|
;
|
|
T1.VZWlS = function (qJ, qu) {
|
|
return C.suOvI(qJ, qu)
|
|
}
|
|
;
|
|
T1.UgXxN = function (qJ, qu) {
|
|
return C.hjtga(qJ, qu)
|
|
}
|
|
;
|
|
T1.FWNHY = function (qJ, qu) {
|
|
return C.KFXsi(qJ, qu)
|
|
}
|
|
;
|
|
T1.MOoeY = function (qJ, qu) {
|
|
return qJ == qu
|
|
}
|
|
;
|
|
T1.hEJkL = function (qJ, qu) {
|
|
return C.pQuJc(qJ, qu)
|
|
}
|
|
;
|
|
T1.yzWch = function (qJ, qu) {
|
|
return C.zWdKW(qJ, qu)
|
|
}
|
|
;
|
|
T1.nlsnX = function (qJ, qu) {
|
|
return C.Wnmtu(qJ, qu)
|
|
}
|
|
;
|
|
T1.PMDAF = function (qJ, qu) {
|
|
return qJ(qu)
|
|
}
|
|
;
|
|
T1.KnXjO = function (qJ) {
|
|
return C.JYrwO(qJ)
|
|
}
|
|
;
|
|
T1.ZrKJz = function (qJ) {
|
|
return C.nOKyy(qJ)
|
|
}
|
|
;
|
|
T1.FEUla = function (qJ, qu) {
|
|
return qJ > qu
|
|
}
|
|
;
|
|
T1.xMbtp = function (qJ, qu) {
|
|
return C.KkWRM(qJ, qu)
|
|
}
|
|
;
|
|
T1.yFGsF = function (qJ, qu) {
|
|
return C.bDBhK(qJ, qu)
|
|
}
|
|
;
|
|
T1.sknMN = function (qJ, qu) {
|
|
return C.bDBhK(qJ, qu)
|
|
}
|
|
;
|
|
T1.XBFBa = C.qQazD;
|
|
T1.mkURk = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.AiqNR = function (qJ, qu) {
|
|
return C.BwtxY(qJ, qu)
|
|
}
|
|
;
|
|
T1.lAIFn = function (qJ, qu) {
|
|
return qJ | qu
|
|
}
|
|
;
|
|
T1.JgmUq = function (qJ, qu) {
|
|
return C.Eezpt(qJ, qu)
|
|
}
|
|
;
|
|
T1.BBtkF = function (qJ, qu) {
|
|
return C.KkWRM(qJ, qu)
|
|
}
|
|
;
|
|
T1.lUCtj = function (qJ, qu) {
|
|
return C.KFXsi(qJ, qu)
|
|
}
|
|
;
|
|
T1.Niskj = function (qJ, qu) {
|
|
return qJ << qu
|
|
}
|
|
;
|
|
T1.axFEu = function (qJ, qu) {
|
|
return C.omBTW(qJ, qu)
|
|
}
|
|
;
|
|
T1.LsXfP = function (qJ, qu) {
|
|
return C.bDBhK(qJ, qu)
|
|
}
|
|
;
|
|
T1.rVprn = function (qJ, qu) {
|
|
return C.nlvEd(qJ, qu)
|
|
}
|
|
;
|
|
T1.ZLwXu = function (qJ, qu) {
|
|
return C.rdVRk(qJ, qu)
|
|
}
|
|
;
|
|
T1.RuNvD = function (qJ, qu) {
|
|
return C.zWdKW(qJ, qu)
|
|
}
|
|
;
|
|
T1.ixlNQ = function (qJ, qu) {
|
|
return C.EARrs(qJ, qu)
|
|
}
|
|
;
|
|
T1.VyvHR = function (qJ, qu) {
|
|
return C.bDBhK(qJ, qu)
|
|
}
|
|
;
|
|
T1.MxBTq = function (qJ, qu) {
|
|
return C.jYDcp(qJ, qu)
|
|
}
|
|
;
|
|
T1.GOCfu = function (qJ, qu) {
|
|
return C.MNNBI(qJ, qu)
|
|
}
|
|
;
|
|
T1.iTyJv = function (qJ, qu) {
|
|
return C.Xcadz(qJ, qu)
|
|
}
|
|
;
|
|
T1.AKTyR = function (qJ) {
|
|
return C.MPQul(qJ)
|
|
}
|
|
;
|
|
T1.rflXO = function (qJ, qu) {
|
|
return C.iZCcZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.LLHAb = function (qJ) {
|
|
return C.MPQul(qJ)
|
|
}
|
|
;
|
|
T1.CzFDK = function (qJ, qu) {
|
|
return qJ > qu
|
|
}
|
|
;
|
|
T1.dFxYo = function (qJ, qu) {
|
|
return C.pHneT(qJ, qu)
|
|
}
|
|
;
|
|
T1.ljorW = function (qJ, qu) {
|
|
return C.pHneT(qJ, qu)
|
|
}
|
|
;
|
|
T1.NbjXS = function (qJ, qu) {
|
|
return C.zaMlq(qJ, qu)
|
|
}
|
|
;
|
|
T1.tUJbt = function (qJ, qu) {
|
|
return C.barYY(qJ, qu)
|
|
}
|
|
;
|
|
T1.moRCT = function (qJ) {
|
|
return C.MPQul(qJ)
|
|
}
|
|
;
|
|
T1.GMyHt = function (qJ, qu) {
|
|
return C.fiyoX(qJ, qu)
|
|
}
|
|
;
|
|
T1.PzRhB = function (qJ, qu) {
|
|
return C.suOvI(qJ, qu)
|
|
}
|
|
;
|
|
T1.vKdPZ = function (qJ, qu) {
|
|
return C.zAlhd(qJ, qu)
|
|
}
|
|
;
|
|
T1.QhjbT = function (qJ, qu) {
|
|
return C.iZCcZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.VWJdp = function (qJ, qu) {
|
|
return C.zAlhd(qJ, qu)
|
|
}
|
|
;
|
|
T1.AWonT = function (qJ, qu) {
|
|
return C.HrHPT(qJ, qu)
|
|
}
|
|
;
|
|
T1.jeMqn = function (qJ, qu) {
|
|
return C.iZCcZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.JuqQm = function (qJ) {
|
|
return qJ()
|
|
}
|
|
;
|
|
T1.GVBgw = "5|1|0|3|2|4";
|
|
T1.wdmxi = function (qJ, qu) {
|
|
return C.iZCcZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.yzXyc = function (qJ, qu) {
|
|
return C.DydwZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.BwboT = function (qJ, qu) {
|
|
return C.DydwZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.hsVME = function (qJ, qu) {
|
|
return C.HrHPT(qJ, qu)
|
|
}
|
|
;
|
|
T1.RpISk = function (qJ, qu) {
|
|
return C.fzrht(qJ, qu)
|
|
}
|
|
;
|
|
T1.jgSJH = function (qJ, qu) {
|
|
return C.bDBhK(qJ, qu)
|
|
}
|
|
;
|
|
T1.xMscz = function (qJ, qu) {
|
|
return C.uvBrG(qJ, qu)
|
|
}
|
|
;
|
|
T1.TwZoU = C.mgUiS;
|
|
T1.QZvOQ = function (qJ, qu) {
|
|
return C.eFcEb(qJ, qu)
|
|
}
|
|
;
|
|
T1.cKTuA = function (qJ, qu) {
|
|
return C.fiyoX(qJ, qu)
|
|
}
|
|
;
|
|
T1.Lfbzx = function (qJ, qu) {
|
|
return C.VfVQi(qJ, qu)
|
|
}
|
|
;
|
|
T1.Opfux = function (qJ, qu) {
|
|
return C.ucnKx(qJ, qu)
|
|
}
|
|
;
|
|
T1.CwEaP = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.pGwJz = function (qJ, qu) {
|
|
return C.xUQYu(qJ, qu)
|
|
}
|
|
;
|
|
T1.YcvqW = function (qJ, qu) {
|
|
return C.HWfNK(qJ, qu)
|
|
}
|
|
;
|
|
T1.XgZgm = function (qJ, qu) {
|
|
return C.Oebjd(qJ, qu)
|
|
}
|
|
;
|
|
T1.cAzea = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.QzQDA = C.xNlRw;
|
|
T1.FOMRZ = function (qJ, qu) {
|
|
return qJ > qu
|
|
}
|
|
;
|
|
T1.vundK = function (qJ, qu) {
|
|
return C.MNNBI(qJ, qu)
|
|
}
|
|
;
|
|
T1.afZbf = function (qJ, qu) {
|
|
return C.sZrWA(qJ, qu)
|
|
}
|
|
;
|
|
T1.pnUxC = function (qJ, qu) {
|
|
return C.ZnXKp(qJ, qu)
|
|
}
|
|
;
|
|
T1.zhlAb = function (qJ, qu) {
|
|
return C.XfSXR(qJ, qu)
|
|
}
|
|
;
|
|
T1.qDlLU = function (qJ, qu) {
|
|
return C.RBxSw(qJ, qu)
|
|
}
|
|
;
|
|
T1.QMyJZ = function (qJ, qu) {
|
|
return C.sxmIT(qJ, qu)
|
|
}
|
|
;
|
|
T1.vjNkQ = function (qJ, qu) {
|
|
return C.RBxSw(qJ, qu)
|
|
}
|
|
;
|
|
T1.mdZxF = function (qJ, qu) {
|
|
return C.ZSPZD(qJ, qu)
|
|
}
|
|
;
|
|
T1.XAubh = function (qJ, qu) {
|
|
return qJ >> qu
|
|
}
|
|
;
|
|
T1.Oykmt = function (qJ, qu) {
|
|
return C.VfVQi(qJ, qu)
|
|
}
|
|
;
|
|
T1.LUjGk = function (qJ, qu) {
|
|
return C.NJvnP(qJ, qu)
|
|
}
|
|
;
|
|
T1.uIkVl = function (qJ, qu) {
|
|
return C.NJvnP(qJ, qu)
|
|
}
|
|
;
|
|
T1.JdrPR = "Invalid RSA public key";
|
|
T1.vVTig = function (qJ, qu) {
|
|
return C.ZSPZD(qJ, qu)
|
|
}
|
|
;
|
|
T1.gkfGN = function (qJ, qu) {
|
|
return C.Oebjd(qJ, qu)
|
|
}
|
|
;
|
|
T1.brjev = function (qJ, qu) {
|
|
return qJ == qu
|
|
}
|
|
;
|
|
T1.lGHgR = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.QdsIm = function (qJ, qu) {
|
|
return C.GKJrO(qJ, qu)
|
|
}
|
|
;
|
|
T1.EoEpv = function (qJ, qu) {
|
|
return C.aAnkJ(qJ, qu)
|
|
}
|
|
;
|
|
T1.LCckH = function (qJ, qu) {
|
|
return C.REJpn(qJ, qu)
|
|
}
|
|
;
|
|
T1.aBgic = function (qJ, qu, qb) {
|
|
return C.szSWf(qJ, qu, qb)
|
|
}
|
|
;
|
|
T1.PkzgD = function (qJ, qu, qb) {
|
|
return qJ(qu, qb)
|
|
}
|
|
;
|
|
T1.OeVDx = function (qJ, qu, qb) {
|
|
return C.YuuDx(qJ, qu, qb)
|
|
}
|
|
;
|
|
T1.SdCoG = function (qJ, qu, qb) {
|
|
return C.WjGiL(qJ, qu, qb)
|
|
}
|
|
;
|
|
T1.EqSfc = function (qJ, qu) {
|
|
return C.ZSPZD(qJ, qu)
|
|
}
|
|
;
|
|
T1.YeSkx = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.xZfZR = function (qJ, qu) {
|
|
return C.ykPDN(qJ, qu)
|
|
}
|
|
;
|
|
T1.sTeDf = function (qJ, qu) {
|
|
return C.Gwqpy(qJ, qu)
|
|
}
|
|
;
|
|
T1.dgQhD = function (qJ, qu) {
|
|
return C.TMFuj(qJ, qu)
|
|
}
|
|
;
|
|
T1.oyQDV = function (qJ, qu) {
|
|
return C.QObtY(qJ, qu)
|
|
}
|
|
;
|
|
T1.fhLpK = function (qJ, qu) {
|
|
return C.Oebjd(qJ, qu)
|
|
}
|
|
;
|
|
T1.UtJkT = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.nmPHP = function (qJ, qu) {
|
|
return C.Oebjd(qJ, qu)
|
|
}
|
|
;
|
|
T1.GcDoE = function (qJ, qu, qb) {
|
|
return qJ(qu, qb)
|
|
}
|
|
;
|
|
T1.EoEDA = function (qJ, qu) {
|
|
return C.Oebjd(qJ, qu)
|
|
}
|
|
;
|
|
T1.XXXFE = function (qJ, qu) {
|
|
return C.Oebjd(qJ, qu)
|
|
}
|
|
;
|
|
T1.gLEQE = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.KOjiH = function (qJ, qu) {
|
|
return C.REJpn(qJ, qu)
|
|
}
|
|
;
|
|
T1.EbqzM = function (qJ, qu) {
|
|
return C.aAnkJ(qJ, qu)
|
|
}
|
|
;
|
|
T1.uXLtI = function (qJ, qu) {
|
|
return C.TMFuj(qJ, qu)
|
|
}
|
|
;
|
|
T1.lojoc = function (qJ, qu) {
|
|
return C.TAtAc(qJ, qu)
|
|
}
|
|
;
|
|
T1.ldeug = function (qJ, qu) {
|
|
return C.barYY(qJ, qu)
|
|
}
|
|
;
|
|
T1.JzjnQ = function (qJ, qu) {
|
|
return C.TAtAc(qJ, qu)
|
|
}
|
|
;
|
|
T1.vjAam = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.uGEjr = function (qJ, qu) {
|
|
return C.dshAB(qJ, qu)
|
|
}
|
|
;
|
|
T1.tloob = function (qJ, qu) {
|
|
return C.dshAB(qJ, qu)
|
|
}
|
|
;
|
|
T1.JvduP = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.kJmRG = function (qJ, qu) {
|
|
return qJ == qu
|
|
}
|
|
;
|
|
T1.sCwJz = function (qJ, qu) {
|
|
return C.pnwdf(qJ, qu)
|
|
}
|
|
;
|
|
T1.EJFde = function (qJ, qu) {
|
|
return C.pnwdf(qJ, qu)
|
|
}
|
|
;
|
|
T1.QuxFV = function (qJ, qu) {
|
|
return C.quRVT(qJ, qu)
|
|
}
|
|
;
|
|
T1.ebkcG = function (qJ, qu) {
|
|
return C.xxaFq(qJ, qu)
|
|
}
|
|
;
|
|
T1.WLwRq = C.oDDon;
|
|
T1.oxyQD = C.WmsWX;
|
|
T1.EgOxI = C.XcqNK;
|
|
T1.ROSKQ = C.DQpPw;
|
|
T1.hAfng = function (qJ, qu) {
|
|
return qJ(qu)
|
|
}
|
|
;
|
|
T1.jzSzc = C.EhCdT;
|
|
T1.BURkv = C.qfqwE;
|
|
T1.QhRxz = function (qJ, qu) {
|
|
return qJ(qu)
|
|
}
|
|
;
|
|
T1.LUaiQ = function (qJ, qu) {
|
|
return qJ(qu)
|
|
}
|
|
;
|
|
T1.JrOyR = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.OTlRj = C.JHcEY;
|
|
T1.jIQHr = function (qJ, qu) {
|
|
return qJ % qu
|
|
}
|
|
;
|
|
T1.vKTLy = C.Mcgzf;
|
|
T1.DPTrS = "$1\r\n";
|
|
T1.tgSnK = C.KkkTq;
|
|
T1.VhdMd = function (qJ, qu) {
|
|
return qJ == qu
|
|
}
|
|
;
|
|
T1.KRmGu = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.qLktx = "undefined";
|
|
T1.oOQyf = function (qJ, qu) {
|
|
return C.DRicM(qJ, qu)
|
|
}
|
|
;
|
|
T1.cNiaP = "value hex must be even length: n=";
|
|
T1.gXDNL = C.gwfUu;
|
|
T1.aYExY = function (qJ, qu) {
|
|
return C.FnieI(qJ, qu)
|
|
}
|
|
;
|
|
T1.EXcIX = C.FZixB;
|
|
T1.anyCu = function (qJ, qu) {
|
|
return C.BcJGK(qJ, qu)
|
|
}
|
|
;
|
|
T1.gLhIW = function (qJ, qu) {
|
|
return C.aAnkJ(qJ, qu)
|
|
}
|
|
;
|
|
T1.uUvDs = function (qJ, qu) {
|
|
return C.GuoIH(qJ, qu)
|
|
}
|
|
;
|
|
T1.vsSBk = function (qJ, qu) {
|
|
return C.DAvRq(qJ, qu)
|
|
}
|
|
;
|
|
T1.zAlTw = function (qJ, qu) {
|
|
return C.jYDcp(qJ, qu)
|
|
}
|
|
;
|
|
T1.SHEPk = function (qJ, qu) {
|
|
return C.pnwdf(qJ, qu)
|
|
}
|
|
;
|
|
T1.qnkiy = function (qJ, qu) {
|
|
return C.sDclx(qJ, qu)
|
|
}
|
|
;
|
|
T1.imffO = function (qJ, qu, qb) {
|
|
return C.IGxHk(qJ, qu, qb)
|
|
}
|
|
;
|
|
T1.sTMUU = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.bMBIb = function (qJ, qu) {
|
|
return C.DAvRq(qJ, qu)
|
|
}
|
|
;
|
|
T1.jXKaK = function (qJ, qu) {
|
|
return C.qvRVZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.AIRGz = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.aRTkn = function (qJ, qu) {
|
|
return C.qvRVZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.gYITy = C.qgqzs;
|
|
T1.sUYky = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.oCeXk = function (qJ, qu) {
|
|
return C.TMFuj(qJ, qu)
|
|
}
|
|
;
|
|
T1.diCza = C.mmQxr;
|
|
T1.lAICz = function (qJ, qu) {
|
|
return C.sDclx(qJ, qu)
|
|
}
|
|
;
|
|
T1.jLcKU = function (qJ, qu) {
|
|
return qJ == qu
|
|
}
|
|
;
|
|
T1.BXgSn = function (qJ, qu) {
|
|
return C.qvRVZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.GWEFb = function (qJ, qu) {
|
|
return C.cefEj(qJ, qu)
|
|
}
|
|
;
|
|
T1.CnSfa = function (qJ, qu) {
|
|
return C.DAvRq(qJ, qu)
|
|
}
|
|
;
|
|
T1.dVrrO = function (qJ, qu) {
|
|
return C.UItDy(qJ, qu)
|
|
}
|
|
;
|
|
T1.SyeZa = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.guGAk = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.LUbwa = C.jhYfP;
|
|
T1.OdwOJ = function (qJ, qu) {
|
|
return C.DAvRq(qJ, qu)
|
|
}
|
|
;
|
|
T1.LtucB = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.JVkOh = function (qJ, qu) {
|
|
return qJ < qu
|
|
}
|
|
;
|
|
T1.ehATV = function (qJ, qu) {
|
|
return C.DRicM(qJ, qu)
|
|
}
|
|
;
|
|
T1.xfCxM = "DERObjectIdentifier oidName undefined: ";
|
|
T1.OaYYR = C.BCKTo;
|
|
T1.XfCnp = function (qJ, qu) {
|
|
return C.OxEIB(qJ, qu)
|
|
}
|
|
;
|
|
T1.YskHK = function (qJ, qu) {
|
|
return C.qvRVZ(qJ, qu)
|
|
}
|
|
;
|
|
T1.dJxVR = function (qJ, qu) {
|
|
return C.wvEoK(qJ, qu)
|
|
}
|
|
;
|
|
T1.bsVxt = function (qJ, qu) {
|
|
return C.Muiyk(qJ, qu)
|
|
}
|
|
;
|
|
T1.FkMng = function (qJ, qu) {
|
|
return C.Muiyk(qJ, qu)
|
|
}
|
|
;
|
|
T1.PRnQA = C.ghEuG;
|
|
T1.rlFsN = function (qJ, qu) {
|
|
return C.rBLgD(qJ, qu)
|
|
}
|
|
;
|
|
T1.YasRU = function (qJ, qu) {
|
|
return qJ != qu
|
|
}
|
|
;
|
|
T1.kjPMZ = C.rwgxM;
|
|
T1.sHwBJ = function (qJ, qu) {
|
|
return C.quRVT(qJ, qu)
|
|
}
|
|
;
|
|
T1.elNji = function (qJ, qu) {
|
|
return C.hceLd(qJ, qu)
|
|
}
|
|
;
|
|
T1.aTNji = function (qJ, qu) {
|
|
return qJ >> qu
|
|
}
|
|
;
|
|
T1.sbNiu = function (qJ, qu) {
|
|
return qJ >> qu
|
|
}
|
|
;
|
|
T1.qlGPr = function (qJ, qu) {
|
|
return qJ & qu
|
|
}
|
|
;
|
|
T1.YBWLK = function (qJ, qu) {
|
|
return qJ > qu
|
|
}
|
|
;
|
|
T1.PtKFg = function (qJ, qu) {
|
|
return C.rBLgD(qJ, qu)
|
|
}
|
|
;
|
|
T1.kRNfk = function (qJ, qu) {
|
|
return C.snCfT(qJ, qu)
|
|
}
|
|
;
|
|
T1.ckIZU = function (qJ, qu) {
|
|
return C.quRVT(qJ, qu)
|
|
}
|
|
;
|
|
T1.oQlmj = function (qJ, qu) {
|
|
return C.quRVT(qJ, qu)
|
|
}
|
|
;
|
|
T1.CCXAv = function (qJ, qu) {
|
|
return C.DAvRq(qJ, qu)
|
|
}
|
|
;
|
|
T1.hcfGL = " byte) ";
|
|
T1.inTUD = function (qJ, qu) {
|
|
return C.eqJTQ(qJ, qu)
|
|
}
|
|
;
|
|
T1.RoaCq = function (qJ, qu) {
|
|
return qJ > qu
|
|
}
|
|
;
|
|
T1.jcbeP = function (qJ, qu) {
|
|
return C.zonUt(qJ, qu)
|
|
}
|
|
;
|
|
T1.fMRxO = C.GsrHZ;
|
|
T1.uASxf = function (qJ, qu) {
|
|
return C.quRVT(qJ, qu)
|
|
}
|
|
;
|
|
T1.WhdEd = "EOC";
|
|
T1.tNFcM = C.cVCoN;
|
|
T1.MEzWB = C.OqHeN;
|
|
T1.AphMF = C.FUwsz;
|
|
T1.BGpsQ = "ObjectDescriptor";
|
|
T1.cOZjq = C.QnrNB;
|
|
T1.LvbPp = C.ihvhY;
|
|
T1.nUvol = C.RkIuE;
|
|
T1.crfvk = C.UsblA;
|
|
T1.CSDrx = "SEQUENCE";
|
|
T1.JAjiK = C.CiJjC;
|
|
T1.aVwQP = "NumericString";
|
|
T1.WiAGY = C.RARGI;
|
|
T1.MzwLL = C.oZjMN;
|
|
T1.tadqZ = C.SydSb;
|
|
T1.rjPxS = "IA5String";
|
|
T1.ezopV = "UTCTime";
|
|
T1.ZFdJS = "GeneralizedTime";
|
|
T1.ckWVT = C.lqwIY;
|
|
T1.KrVFq = "GeneralString";
|
|
T1.jrfjB = C.zHNcG;
|
|
T1.fccoR = "BMPString";
|
|
T1.Qybau = function (qJ, qu) {
|
|
return C.eqJTQ(qJ, qu)
|
|
}
|
|
;
|
|
T1.jRCpT = C.Nrnlc;
|
|
T1.DIVWO = function (qJ, qu) {
|
|
return C.eqJTQ(qJ, qu)
|
|
}
|
|
;
|
|
T1.aLdPr = C.erupT;
|
|
T1.NFnPg = function (qJ, qu) {
|
|
return C.eqJTQ(qJ, qu)
|
|
}
|
|
;
|
|
T1.gIrFA = C.seHCu;
|
|
T1.FjwjR = C.QigEs;
|
|
T1.EnxJX = function (qJ, qu) {
|
|
return C.xxaFq(qJ, qu)
|
|
}
|
|
;
|
|
T1.LfZzP = "false";
|
|
T1.BheWL = C.GvCka;
|
|
T1.uPfYa = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.NcaHd = C.ozahH;
|
|
T1.ofxUT = function (qJ, qu) {
|
|
return C.eqJTQ(qJ, qu)
|
|
}
|
|
;
|
|
T1.jTMYR = function (qJ, qu) {
|
|
return qJ + qu
|
|
}
|
|
;
|
|
T1.LKrVM = function (qJ, qu) {
|
|
return C.SfvqK(qJ, qu)
|
|
}
|
|
;
|
|
T1.Sowyx = function (qJ, qu) {
|
|
return C.JHrTb(qJ, qu)
|
|
}
|
|
;
|
|
T1.zbHqd = function (qJ, qu) {
|
|
return C.JHrTb(qJ, qu)
|
|
}
|
|
;
|
|
T1.ydEOK = function (qJ, qu) {
|
|
return C.SfvqK(qJ, qu)
|
|
}
|
|
;
|
|
T1.tFpum = function (qJ, qu) {
|
|
return C.kxklz(qJ, qu)
|
|
}
|
|
;
|
|
T1.EiDeW = function (qJ, qu) {
|
|
return C.mnXyI(qJ, qu)
|
|
}
|
|
;
|
|
T1.LKqBJ = function (qJ, qu) {
|
|
return C.YNLBL(qJ, qu)
|
|
}
|
|
;
|
|
T1.NMTdh = function (qJ, qu) {
|
|
return C.YNLBL(qJ, qu)
|
|
}
|
|
;
|
|
T1.QeGDP = function (qJ, qu) {
|
|
return C.YNLBL(qJ, qu)
|
|
}
|
|
;
|
|
T1.hdqMD = function (qJ, qu) {
|
|
return C.YNLBL(qJ, qu)
|
|
}
|
|
;
|
|
T1.MmFTk = C.XVaqz;
|
|
T1.YIrhG = ",sub:";
|
|
T1.JrvAL = function (qJ, qu) {
|
|
return C.xxaFq(qJ, qu)
|
|
}
|
|
;
|
|
T1.LKpGK = C.bOhxc;
|
|
T1.FsJpO = function (qJ, qu) {
|
|
return C.YNLBL(qJ, qu)
|
|
}
|
|
;
|
|
T1.iANgj = C.QPikQ;
|
|
T1.FimOf = C.syUdp;
|
|
T1.Nedvl = function (qJ, qu) {
|
|
return C.imsBE(qJ, qu)
|
|
}
|
|
;
|
|
T1.rFDHx = "-----BEGIN PUBLIC KEY-----\n";
|
|
T1.NTNgW = function (qJ, qu) {
|
|
return C.sxInn(qJ, qu)
|
|
}
|
|
;
|
|
T1.vJUQI = function (qJ, qu) {
|
|
return C.gcGDc(qJ, qu)
|
|
}
|
|
;
|
|
T1.xQZTm = C.eoLYf;
|
|
T1.mThbX = function (qJ, qu) {
|
|
return qJ(qu)
|
|
}
|
|
;
|
|
var T2 = T1;
|
|
|
|
function T3(qJ, qu, qb) {
|
|
if (T2.JQIBd(null, qJ)) {
|
|
if (T2.SJStG == typeof qJ) {
|
|
this.fromNumber(qJ, qu, qb)
|
|
} else {
|
|
if (T2.BINQv(null, qu) && T2.JQIBd(T2.EWeYn, typeof qJ)) {
|
|
this.fromString(qJ, 256)
|
|
} else {
|
|
this.fromString(qJ, qu)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function T4() {
|
|
return new T3(null)
|
|
}
|
|
|
|
function T5(qJ, qu, qb, qU, qM, qK) {
|
|
for (; H.nkKNf(--qK, 0);) {
|
|
var qB = H.tCIaf(H.sdHSW(qu * this[qJ++], qb[qU]), qM);
|
|
qM = Math.floor(qB / 67108864);
|
|
qb[qU++] = 67108863 & qB
|
|
}
|
|
return qM
|
|
}
|
|
|
|
function T6(qJ, qu, qb, qU, qM, qK) {
|
|
for (var qB = H.HvXqg(32767, qu), qI = H.RWKHq(qu, 15); --qK >= 0;) {
|
|
var qQ = H.HvXqg(32767, this[qJ]);
|
|
var qS = H.RWKHq(this[qJ++], 15);
|
|
var qg = H.ubmKK(qI * qQ, qS * qB);
|
|
qQ = H.YTGma(H.YTGma(H.qKVHI(qB, qQ), H.iaGwq(H.HvXqg(32767, qg), 15)) + qb[qU], 1073741823 & qM);
|
|
qM = H.YTGma(H.YTGma(qQ >>> 30, H.Yobyd(qg, 15)) + H.hTgdZ(qI, qS), H.Yobyd(qM, 30));
|
|
qb[qU++] = H.HvXqg(1073741823, qQ)
|
|
}
|
|
return qM
|
|
}
|
|
|
|
function T7(qJ, qu, qb, qU, qM, qK) {
|
|
for (var qB = 16383 & qu, qI = qu >> 14; --qK >= 0;) {
|
|
var qQ = T2.aCQdR(16383, this[qJ]);
|
|
var qS = T2.xnwyO(this[qJ++], 14);
|
|
var qg = T2.KIplz(qI, qQ) + T2.KIplz(qS, qB);
|
|
qQ = T2.AmRLj(T2.LhHjK(qB, qQ), T2.Edlzx(T2.JPvZT(16383, qg), 14)) + qb[qU] + qM;
|
|
qM = T2.AmRLj(T2.pfmZz(T2.COgax(qQ, 28), T2.COgax(qg, 14)), qI * qS);
|
|
qb[qU++] = T2.sNQoy(267625455, qQ)
|
|
}
|
|
return qM
|
|
}
|
|
|
|
function T8(qJ) {
|
|
return qp.charAt(qJ)
|
|
}
|
|
|
|
function T9(qJ, qu) {
|
|
var qb = qC[qJ.charCodeAt(qu)];
|
|
return null == qb ? -1 : qb
|
|
}
|
|
|
|
function TT(qJ) {
|
|
for (var qu = this.t - 1; H.nkKNf(qu, 0); --qu)
|
|
qJ[qu] = this[qu];
|
|
qJ.t = this.t;
|
|
qJ.s = this.s
|
|
}
|
|
|
|
function TN(qJ) {
|
|
this.t = 1;
|
|
if (0 > qJ) {
|
|
this.s = -1
|
|
} else {
|
|
this.s = 0
|
|
}
|
|
if (qJ > 0) {
|
|
this[0] = qJ
|
|
} else {
|
|
if (-1 > qJ) {
|
|
this[0] = H.YTGma(qJ, this.DV)
|
|
} else {
|
|
this.t = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
function Tq(qJ) {
|
|
var qu = T2.pTByM(T4);
|
|
return qu.fromInt(qJ),
|
|
qu
|
|
}
|
|
|
|
function TR(qJ, qu) {
|
|
var qb;
|
|
if (16 == qu)
|
|
qb = 4;
|
|
else {
|
|
if (T2.CWGWi(8, qu))
|
|
qb = 3;
|
|
else {
|
|
if (T2.CWGWi(256, qu))
|
|
qb = 8;
|
|
else {
|
|
if (T2.CWGWi(2, qu))
|
|
qb = 1;
|
|
else {
|
|
if (T2.dbQWD(32, qu))
|
|
qb = 5;
|
|
else {
|
|
if (4 != qu)
|
|
return void this.fromRadix(qJ, qu);
|
|
qb = 2
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.t = 0;
|
|
this.s = 0;
|
|
for (var qU = qJ.length, qM = !1, qK = 0; T2.yuXbv(--qU, 0);) {
|
|
var qB;
|
|
if (T2.PrUrd(8, qb)) {
|
|
qB = T2.LtKKW(255, qJ[qU])
|
|
} else {
|
|
qB = T2.DTlFy(T9, qJ, qU)
|
|
}
|
|
if (T2.absEa(0, qB)) {
|
|
if ("-" == qJ.charAt(qU)) {
|
|
qM = !0
|
|
}
|
|
} else {
|
|
qM = !1;
|
|
if (T2.EgIEL(0, qK)) {
|
|
this[this.t++] = qB
|
|
} else {
|
|
if (T2.gaAcY(T2.pfmZz(qK, qb), this.DB)) {
|
|
this[this.t - 1] |= T2.JNzPG(qB & T2.NobGV(T2.JNzPG(1, T2.pOzDI(this.DB, qK)), 1), qK);
|
|
this[this.t++] = qB >> this.DB - qK
|
|
} else {
|
|
this[T2.XyKZg(this.t, 1)] |= T2.JNzPG(qB, qK)
|
|
}
|
|
}
|
|
qK += qb;
|
|
if (T2.NibRw(qK, this.DB)) {
|
|
qK -= this.DB
|
|
}
|
|
}
|
|
}
|
|
if (T2.hlcUk(8, qb) && T2.JQIBd(0, 128 & qJ[0])) {
|
|
this.s = -1;
|
|
T2.gaAcY(qK, 0) && (this[T2.CziqF(this.t, 1)] |= T2.JNzPG(T2.cKRku(T2.cTlus(1, this.DB - qK), 1), qK))
|
|
}
|
|
this.clamp();
|
|
if (qM) {
|
|
T3.ZERO.subTo(this, this)
|
|
}
|
|
}
|
|
|
|
function TL() {
|
|
for (var qJ = T2.fyeqR(this.s, this.DM); this.t > 0 && T2.ulrep(this[T2.HJudT(this.t, 1)], qJ);)
|
|
--this.t
|
|
}
|
|
|
|
function TG(qJ) {
|
|
var qu = H.ZSXSF.split("|");
|
|
var qb = 0;
|
|
while (!![]) {
|
|
switch (qu[qb++]) {
|
|
case "0":
|
|
var qU;
|
|
continue;
|
|
case "1":
|
|
return qB ? qI : "0";
|
|
case "2":
|
|
if (H.eBkWN(16, qJ))
|
|
qU = 4;
|
|
else {
|
|
if (H.eBkWN(8, qJ))
|
|
qU = 3;
|
|
else {
|
|
if (H.AICVW(2, qJ))
|
|
qU = 1;
|
|
else {
|
|
if (H.GshWW(32, qJ))
|
|
qU = 5;
|
|
else {
|
|
if (H.hrfHa(4, qJ))
|
|
return this.toRadix(qJ);
|
|
qU = 2
|
|
}
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
case "3":
|
|
var qM;
|
|
var qK = H.sLveP(1 << qU, 1);
|
|
var qB = !1;
|
|
var qI = "";
|
|
var qQ = this.t;
|
|
var qS = H.YKHqj(this.DB, H.cpuUC(H.hTgdZ(qQ, this.DB), qU));
|
|
continue;
|
|
case "4":
|
|
if (H.jpLiq(this.s, 0))
|
|
return H.WoEdI("-", this.negate().toString(qJ));
|
|
continue;
|
|
case "5":
|
|
if (qQ-- > 0)
|
|
for (qS < this.DB && H.OQQXY(qM = this[qQ] >> qS, 0) && (qB = !0,
|
|
qI = H.jVCpH(T8, qM)); qQ >= 0;) {
|
|
if (H.fqrBG(qU, qS)) {
|
|
qM = H.VJgeC(H.rXkyR(this[qQ], H.YKHqj(H.pNTMp(1, qS), 1)), H.cySGj(qU, qS));
|
|
qM |= H.RWKHq(this[--qQ], qS += H.AJTVB(this.DB, qU))
|
|
} else {
|
|
qM = H.mRsou(H.UAFdg(this[qQ], qS -= qU), qK);
|
|
0 >= qS && (qS += this.DB,
|
|
--qQ)
|
|
}
|
|
if (H.miLBx(qM, 0)) {
|
|
qB = !0
|
|
}
|
|
if (qB) {
|
|
qI += H.RBjvU(T8, qM)
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Tp() {
|
|
var qJ = T2.aTeHb(T4);
|
|
return T3.ZERO.subTo(this, qJ),
|
|
qJ
|
|
}
|
|
|
|
function TC() {
|
|
return T2.TrHcz(this.s, 0) ? this.negate() : this
|
|
}
|
|
|
|
function Tf(qJ) {
|
|
var qu = H.AJTVB(this.s, qJ.s);
|
|
if (H.xKRkc(0, qu))
|
|
return qu;
|
|
var qb = this.t;
|
|
if (qu = qb - qJ.t,
|
|
H.xKRkc(0, qu))
|
|
return this.s < 0 ? -qu : qu;
|
|
for (; --qb >= 0;)
|
|
if (H.YWRsD(0, qu = H.owmJD(this[qb], qJ[qb])))
|
|
return qu;
|
|
return 0
|
|
}
|
|
|
|
function TY(qJ) {
|
|
if (qJ === 65537) {
|
|
} else
|
|
qJ = 60115;
|
|
var qu;
|
|
var qb = 1;
|
|
return 0 != (qu = H.SUZMe(qJ, 16)) && (qJ = qu,
|
|
qb += 16),
|
|
H.YWRsD(0, qu = H.UAFdg(qJ, 8)) && (qJ = qu,
|
|
qb += 8),
|
|
H.YWRsD(0, qu = qJ >> 4) && (qJ = qu,
|
|
qb += 4),
|
|
H.YWRsD(0, qu = H.BXaVK(qJ, 2)) && (qJ = qu,
|
|
qb += 2),
|
|
H.YWRsD(0, qu = H.uNvaM(qJ, 1)) && (qJ = qu,
|
|
qb += 1),
|
|
qb
|
|
}
|
|
|
|
function TA() {
|
|
return T2.bFWMW(this.t, 0) ? 0 : T2.TlMjt(T2.cnrlW(this.DB, T2.xnBWr(this.t, 1)), T2.mENgl(TY, T2.IUXAb(this[T2.xnBWr(this.t, 1)], T2.fyeqR(this.s, this.DM))))
|
|
}
|
|
|
|
function Tr(qJ, qu) {
|
|
var qb;
|
|
for (qb = H.owmJD(this.t, 1); qb >= 0; --qb)
|
|
qu[H.WoEdI(qb, qJ)] = this[qb];
|
|
for (qb = H.mFEOn(qJ, 1); H.nkKNf(qb, 0); --qb)
|
|
qu[qb] = 0;
|
|
qu.t = H.WoEdI(this.t, qJ);
|
|
qu.s = this.s
|
|
}
|
|
|
|
function Tn(qJ, qu) {
|
|
for (var qb = qJ; H.FgCtf(qb, this.t); ++qb)
|
|
qu[H.mFEOn(qb, qJ)] = this[qb];
|
|
qu.t = Math.max(H.mFEOn(this.t, qJ), 0);
|
|
qu.s = this.s
|
|
}
|
|
|
|
function Th(qJ, qu) {
|
|
var qb;
|
|
var qU = qJ % this.DB;
|
|
var qM = this.DB - qU;
|
|
var qK = H.yYMCA(H.nOxAW(1, qM), 1);
|
|
var qB = Math.floor(H.LZjaC(qJ, this.DB));
|
|
var qI = H.nOxAW(this.s, qU) & this.DM;
|
|
for (qb = this.t - 1; H.CMVvx(qb, 0); --qb) {
|
|
qu[H.WoEdI(H.WoEdI(qb, qB), 1)] = H.EtzCR(this[qb] >> qM, qI);
|
|
qI = H.WgBOs(H.mRsou(this[qb], qK), qU)
|
|
}
|
|
for (qb = H.yYMCA(qB, 1); H.OVZli(qb, 0); --qb)
|
|
qu[qb] = 0;
|
|
qu[qB] = qI;
|
|
qu.t = H.WoEdI(H.ElFTz(this.t, qB), 1);
|
|
qu.s = this.s;
|
|
qu.clamp()
|
|
}
|
|
|
|
function To(qJ, qu) {
|
|
var qb = T2.IBOZx.split("|");
|
|
var qU = 0;
|
|
while (!![]) {
|
|
switch (qb[qU++]) {
|
|
case "0":
|
|
var qM = Math.floor(T2.KxaKN(qJ, this.DB));
|
|
continue;
|
|
case "1":
|
|
if (qB > 0) {
|
|
qu[T2.XlSyL(T2.XlSyL(this.t, qM), 1)] |= T2.cTlus(T2.MRNxl(this.s, qQ), qI)
|
|
}
|
|
qu.t = T2.XmTyi(this.t, qM);
|
|
qu.clamp();
|
|
continue;
|
|
case "2":
|
|
for (var qK = T2.TlMjt(qM, 1); T2.qVgED(qK, this.t); ++qK) {
|
|
qu[T2.JHnGR(T2.JHnGR(qK, qM), 1)] |= T2.MRNxl(this[qK], qQ) << qI;
|
|
qu[qK - qM] = T2.COgax(this[qK], qB)
|
|
}
|
|
continue;
|
|
case "3":
|
|
if (qM >= this.t)
|
|
return void (qu.t = 0);
|
|
continue;
|
|
case "4":
|
|
qu.s = this.s;
|
|
continue;
|
|
case "5":
|
|
var qB = T2.FyxbR(qJ, this.DB);
|
|
var qI = this.DB - qB;
|
|
var qQ = T2.cTlus(1, qB) - 1;
|
|
continue;
|
|
case "6":
|
|
qu[0] = T2.WFOVl(this[qM], qB);
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Tm(qJ, qu) {
|
|
for (var qb = 0, qU = 0, qM = Math.min(qJ.t, this.t); H.mqjUH(qM, qb);) {
|
|
qU += H.yYMCA(this[qb], qJ[qb]);
|
|
qu[qb++] = H.mRsou(qU, this.DM);
|
|
qU >>= this.DB
|
|
}
|
|
if (H.FgCtf(qJ.t, this.t)) {
|
|
for (qU -= qJ.s; H.FgCtf(qb, this.t);) {
|
|
qU += this[qb];
|
|
qu[qb++] = H.bGNWx(qU, this.DM);
|
|
qU >>= this.DB
|
|
}
|
|
qU += this.s
|
|
} else {
|
|
for (qU += this.s; qb < qJ.t;) {
|
|
qU -= qJ[qb];
|
|
qu[qb++] = qU & this.DM;
|
|
qU >>= this.DB
|
|
}
|
|
qU -= qJ.s
|
|
}
|
|
if (0 > qU) {
|
|
qu.s = -1
|
|
} else {
|
|
qu.s = 0
|
|
}
|
|
if (H.GqvGw(-1, qU)) {
|
|
qu[qb++] = H.ElFTz(this.DV, qU)
|
|
} else {
|
|
if (qU > 0) {
|
|
qu[qb++] = qU
|
|
}
|
|
}
|
|
qu.t = qb;
|
|
qu.clamp()
|
|
}
|
|
|
|
function Tx(qJ, qu) {
|
|
var qb = this.abs();
|
|
var qU = qJ.abs();
|
|
var qM = qb.t;
|
|
for (qu.t = qM + qU.t; T2.MQunM(--qM, 0);)
|
|
qu[qM] = 0;
|
|
for (qM = 0; T2.jBeOO(qM, qU.t); ++qM)
|
|
qu[qM + qb.t] = qb.am(0, qU[qM], qu, qM, 0, qb.t);
|
|
qu.s = 0;
|
|
qu.clamp();
|
|
if (this.s != qJ.s) {
|
|
T3.ZERO.subTo(qu, qu)
|
|
}
|
|
}
|
|
|
|
function TH(qJ) {
|
|
for (var qu = this.abs(), qb = qJ.t = 2 * qu.t; T2.qoZWS(--qb, 0);)
|
|
qJ[qb] = 0;
|
|
for (qb = 0; T2.WJoyU(qb, T2.JHnGR(qu.t, 1)); ++qb) {
|
|
var qU = qu.am(qb, qu[qb], qJ, T2.SWwyM(2, qb), 0, 1);
|
|
if (T2.qoZWS(qJ[qb + qu.t] += qu.am(T2.WFcyX(qb, 1), T2.SWwyM(2, qu[qb]), qJ, T2.KtUFm(T2.SWwyM(2, qb), 1), qU, T2.JHnGR(T2.JHnGR(qu.t, qb), 1)), qu.DV)) {
|
|
qJ[T2.KtUFm(qb, qu.t)] -= qu.DV;
|
|
qJ[T2.KtUFm(T2.KtUFm(qb, qu.t), 1)] = 1
|
|
}
|
|
}
|
|
if (T2.XdaKv(qJ.t, 0)) {
|
|
qJ[T2.wyXQP(qJ.t, 1)] += qu.am(qb, qu[qb], qJ, T2.SWwyM(2, qb), 0, 1)
|
|
}
|
|
qJ.s = 0;
|
|
qJ.clamp()
|
|
}
|
|
|
|
function TZ(qJ, qu, qb) {
|
|
var qU = qJ.abs();
|
|
if (!T2.bFWMW(qU.t, 0)) {
|
|
var qM = T2.leUtv.split("|");
|
|
var qK = 0;
|
|
while (!![]) {
|
|
switch (qM[qK++]) {
|
|
case "0":
|
|
var qB = qc.t;
|
|
var qI = qc[qB - 1];
|
|
continue;
|
|
case "1":
|
|
if (T2.EPWnn(0, qI)) {
|
|
var qQ = T2.KtUFm(T2.SWwyM(qI, T2.UYYRN(1, this.F1)), T2.blZKX(qB, 1) ? T2.WFOVl(qc[T2.wyXQP(qB, 2)], this.F2) : 0);
|
|
var qS = this.FV / qQ;
|
|
var qg = (1 << this.F1) / qQ;
|
|
var qP = T2.pBtoj(1, this.F2);
|
|
var qF = qb.t;
|
|
var qW = T2.VGmgC(qF, qB);
|
|
var qO;
|
|
if (null == qu) {
|
|
qO = T2.kapdV(T4)
|
|
} else {
|
|
qO = qu
|
|
}
|
|
for (qc.dlShiftTo(qW, qO),
|
|
T2.qoZWS(qb.compareTo(qO), 0) && (qb[qb.t++] = 1,
|
|
qb.subTo(qO, qb)),
|
|
T3.ONE.dlShiftTo(qB, qO),
|
|
qO.subTo(qc, qc); T2.JpwJi(qc.t, qB);)
|
|
qc[qc.t++] = 0;
|
|
for (; T2.GgQRd(--qW, 0);) {
|
|
var qj;
|
|
if (T2.ulrep(qb[--qF], qI)) {
|
|
qj = this.DM
|
|
} else {
|
|
qj = Math.floor(T2.KtUFm(T2.SrQkp(qb[qF], qS), T2.FOtPO(T2.KtUFm(qb[T2.Warxl(qF, 1)], qP), qg)))
|
|
}
|
|
if (T2.JpwJi(qb[qF] += qc.am(0, qj, qb, qW, 0, qB), qj))
|
|
for (qc.dlShiftTo(qW, qO),
|
|
qb.subTo(qO, qb); T2.JpwJi(qb[qF], --qj);)
|
|
qb.subTo(qO, qb)
|
|
}
|
|
if (null != qu) {
|
|
qb.drShiftTo(qB, qu);
|
|
T2.EPWnn(qv, qV) && T3.ZERO.subTo(qu, qu)
|
|
}
|
|
qb.t = qB;
|
|
qb.clamp();
|
|
if (qz > 0) {
|
|
qb.rShiftTo(qz, qb)
|
|
}
|
|
if (0 > qv) {
|
|
T3.ZERO.subTo(qb, qb)
|
|
}
|
|
}
|
|
continue;
|
|
case "2":
|
|
var qs = this.abs();
|
|
continue;
|
|
case "3":
|
|
var qc = T4();
|
|
var qv = this.s;
|
|
var qV = qJ.s;
|
|
var qz = this.DB - T2.mENgl(TY, qU[qU.t - 1]);
|
|
continue;
|
|
case "4":
|
|
if (qs.t < qU.t)
|
|
return T2.LUvKl(null, qu) && qu.fromInt(0),
|
|
void (T2.lLyXU(null, qb) && this.copyTo(qb));
|
|
continue;
|
|
case "5":
|
|
if (T2.blZKX(qz, 0)) {
|
|
qU.lShiftTo(qz, qc);
|
|
qs.lShiftTo(qz, qb)
|
|
} else {
|
|
qU.copyTo(qc);
|
|
qs.copyTo(qb)
|
|
}
|
|
continue;
|
|
case "6":
|
|
if (T2.XAWjd(null, qb)) {
|
|
qb = T2.kapdV(T4)
|
|
}
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
function Ta(qJ) {
|
|
var qu = T2.kapdV(T4);
|
|
return this.abs().divRemTo(qJ, null, qu),
|
|
T2.JpwJi(this.s, 0) && T2.XdVor(qu.compareTo(T3.ZERO), 0) && qJ.subTo(qu, qu),
|
|
qu
|
|
}
|
|
|
|
function TX(qJ) {
|
|
this.m = qJ
|
|
}
|
|
|
|
function Ty(qJ) {
|
|
return H.ZGwHb(qJ.s, 0) || H.uaTxm(qJ.compareTo(this.m), 0) ? qJ.mod(this.m) : qJ
|
|
}
|
|
|
|
function Ti(qJ) {
|
|
return qJ
|
|
}
|
|
|
|
function Tw(qJ) {
|
|
qJ.divRemTo(this.m, null, qJ)
|
|
}
|
|
|
|
function TD(qJ, qu, qb) {
|
|
qJ.multiplyTo(qu, qb);
|
|
this.reduce(qb)
|
|
}
|
|
|
|
function TJ(qJ, qu) {
|
|
qJ.squareTo(qu);
|
|
this.reduce(qu)
|
|
}
|
|
|
|
function Tu() {
|
|
var qJ = H.PjZMH.split("|");
|
|
var qu = 0;
|
|
while (!![]) {
|
|
switch (qJ[qu++]) {
|
|
case "0":
|
|
var qb = this[0];
|
|
continue;
|
|
case "1":
|
|
var qU = 3 & qb;
|
|
continue;
|
|
case "2":
|
|
return qU = H.Iyalt(qU, H.YCbXF(2, H.bGNWx(15, qb) * qU)) & 15,
|
|
qU = H.bGNWx(H.nsHBA(qU, H.vOaKr(2, H.nsHBA(H.xfYVo(255, qb), qU))), 255),
|
|
qU = H.xfYVo(H.zMtXj(qU, 2 - H.nOzRJ(H.RheCP(H.gRZTt(65535, qb), qU), 65535)), 65535),
|
|
qU = H.cpuUC(H.RheCP(qU, H.jptlM(2, H.cpuUC(H.mFHzd(qb, qU), this.DV))), this.DV),
|
|
qU > 0 ? H.jptlM(this.DV, qU) : -qU;
|
|
case "3":
|
|
if (H.GshWW(0, H.FGypG(1, qb)))
|
|
return 0;
|
|
continue;
|
|
case "4":
|
|
if (H.pknkP(this.t, 1))
|
|
return 0;
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Tb(qJ) {
|
|
this.m = qJ;
|
|
this.mp = qJ.invDigit();
|
|
this.mpl = 32767 & this.mp;
|
|
this.mph = this.mp >> 15;
|
|
this.um = (1 << T2.Warxl(qJ.DB, 15)) - 1;
|
|
this.mt2 = T2.FOtPO(2, qJ.t)
|
|
}
|
|
|
|
function TU(qJ) {
|
|
var qu = T4();
|
|
return qJ.abs().dlShiftTo(this.m.t, qu),
|
|
qu.divRemTo(this.m, null, qu),
|
|
T2.JpwJi(qJ.s, 0) && T2.XdVor(qu.compareTo(T3.ZERO), 0) && this.m.subTo(qu, qu),
|
|
qu
|
|
}
|
|
|
|
function TM(qJ) {
|
|
var qu = T4();
|
|
return qJ.copyTo(qu),
|
|
this.reduce(qu),
|
|
qu
|
|
}
|
|
|
|
function TK(qJ) {
|
|
for (; T2.bFWMW(qJ.t, this.mt2);)
|
|
qJ[qJ.t++] = 0;
|
|
for (var qu = 0; T2.JpwJi(qu, this.m.t); ++qu) {
|
|
var qb = T2.MRNxl(32767, qJ[qu]);
|
|
var qU = T2.MwJLH(T2.KtUFm(T2.FOtPO(qb, this.mpl), T2.pBtoj(T2.MwJLH(T2.jyTcZ(T2.FOtPO(qb, this.mph), T2.FOtPO(T2.KSvfl(qJ[qu], 15), this.mpl)), this.um), 15)), qJ.DM);
|
|
for (qb = T2.jyTcZ(qu, this.m.t),
|
|
qJ[qb] += this.m.am(0, qU, qJ, qu, 0, this.m.t); T2.GgQRd(qJ[qb], qJ.DV);) {
|
|
qJ[qb] -= qJ.DV;
|
|
qJ[++qb]++
|
|
}
|
|
}
|
|
qJ.clamp();
|
|
qJ.drShiftTo(this.m.t, qJ);
|
|
if (T2.GgQRd(qJ.compareTo(this.m), 0)) {
|
|
qJ.subTo(this.m, qJ)
|
|
}
|
|
}
|
|
|
|
function TB(qJ, qu) {
|
|
qJ.squareTo(qu);
|
|
this.reduce(qu)
|
|
}
|
|
|
|
function TI(qJ, qu, qb) {
|
|
qJ.multiplyTo(qu, qb);
|
|
this.reduce(qb)
|
|
}
|
|
|
|
function TQ() {
|
|
return H.GshWW(0, H.GqvGw(this.t, 0) ? 1 & this[0] : this.s)
|
|
}
|
|
|
|
function TS(qJ, qu) {
|
|
if (T2.ptkKP(qJ, 4294967295) || T2.ptkKP(1, qJ))
|
|
return T3.ONE;
|
|
var qb = T2.xJWhO(T4);
|
|
var qU = T2.xJWhO(T4);
|
|
var qM = qu.convert(this);
|
|
var qK = TY(qJ) - 1;
|
|
for (qM.copyTo(qb); T2.VZWlS(--qK, 0);)
|
|
if (qu.sqrTo(qb, qU),
|
|
T2.UgXxN(T2.FWNHY(qJ, T2.pBtoj(1, qK)), 0))
|
|
qu.mulTo(qU, qM, qb);
|
|
else {
|
|
var qB = qb;
|
|
qb = qU;
|
|
qU = qB
|
|
}
|
|
return qu.revert(qb)
|
|
}
|
|
|
|
function Tg(qJ, qu) {
|
|
var qb;
|
|
return H.MeeTr(256, qJ) || qu.isEven() ? qb = new TX(qu) : qb = new Tb(qu),
|
|
this.exp(qJ, qb)
|
|
}
|
|
|
|
function TP() {
|
|
var qJ = T2.xJWhO(T4);
|
|
return this.copyTo(qJ),
|
|
qJ
|
|
}
|
|
|
|
function TF() {
|
|
if (H.pknkP(this.s, 0)) {
|
|
if (1 == this.t)
|
|
return H.jptlM(this[0], this.DV);
|
|
if (H.znchO(0, this.t))
|
|
return -1
|
|
} else {
|
|
if (H.HDpVU(1, this.t))
|
|
return this[0];
|
|
if (H.RnGUD(0, this.t))
|
|
return 0
|
|
}
|
|
return H.EtzCR(H.FGypG(this[1], H.jptlM(1 << 32 - this.DB, 1)) << this.DB, this[0])
|
|
}
|
|
|
|
function TW() {
|
|
return T2.MOoeY(0, this.t) ? this.s : T2.hEJkL(this[0], 24) >> 24
|
|
}
|
|
|
|
function TO() {
|
|
return T2.yzWch(0, this.t) ? this.s : T2.KSvfl(this[0] << 16, 16)
|
|
}
|
|
|
|
function Tj(qJ) {
|
|
return Math.floor(H.bXRqm(Math.LN2 * this.DB, Math.log(qJ)))
|
|
}
|
|
|
|
function Ts() {
|
|
return H.pknkP(this.s, 0) ? -1 : this.t <= 0 || H.RnGUD(1, this.t) && this[0] <= 0 ? 0 : 1
|
|
}
|
|
|
|
function Tc(qJ) {
|
|
if (T2.yzWch(null, qJ) && (qJ = 10),
|
|
T2.yzWch(0, this.signum()) || 2 > qJ || T2.nlsnX(qJ, 36))
|
|
return "0";
|
|
var qu = this.chunkSize(qJ);
|
|
var qb = Math.pow(qJ, qu);
|
|
var qU = T2.PMDAF(Tq, qb);
|
|
var qM = T2.KnXjO(T4);
|
|
var qK = T2.ZrKJz(T4);
|
|
var qB = "";
|
|
for (this.divRemTo(qU, qM, qK); T2.FEUla(qM.signum(), 0);) {
|
|
qB = T2.jyTcZ(T2.jyTcZ(qb, qK.intValue()).toString(qJ).substr(1), qB);
|
|
qM.divRemTo(qU, qM, qK)
|
|
}
|
|
return T2.jyTcZ(qK.intValue().toString(qJ), qB)
|
|
}
|
|
|
|
function Tv(qJ, qu) {
|
|
this.fromInt(0);
|
|
if (H.RnGUD(null, qu)) {
|
|
qu = 10
|
|
}
|
|
for (var qb = this.chunkSize(qu), qU = Math.pow(qu, qb), qM = !1, qK = 0, qB = 0, qI = 0; H.DEnUW(qI, qJ.length); ++qI) {
|
|
var qQ = H.LuPYd(T9, qJ, qI);
|
|
if (H.HRNjf(0, qQ)) {
|
|
if (H.RnGUD("-", qJ.charAt(qI)) && H.RnGUD(0, this.signum())) {
|
|
qM = !0
|
|
}
|
|
} else {
|
|
qB = H.ElFTz(H.mFHzd(qu, qB), qQ);
|
|
if (H.xihmh(++qK, qb)) {
|
|
this.dMultiply(qU);
|
|
this.dAddOffset(qB, 0);
|
|
qK = 0;
|
|
qB = 0
|
|
}
|
|
}
|
|
}
|
|
if (H.HRNjf(qK, 0)) {
|
|
this.dMultiply(Math.pow(qu, qK));
|
|
this.dAddOffset(qB, 0)
|
|
}
|
|
if (qM) {
|
|
T3.ZERO.subTo(this, this)
|
|
}
|
|
}
|
|
|
|
function TV(qJ, qu, qb) {
|
|
if (T2.yzWch(T2.SJStG, typeof qu)) {
|
|
if (T2.xMbtp(2, qJ))
|
|
this.fromInt(1);
|
|
else
|
|
for (this.fromNumber(qJ, qb),
|
|
this.testBit(T2.Warxl(qJ, 1)) || this.bitwiseTo(T3.ONE.shiftLeft(T2.yFGsF(qJ, 1)), N2, this),
|
|
this.isEven() && this.dAddOffset(1, 0); !this.isProbablePrime(qu);) {
|
|
this.dAddOffset(2, 0);
|
|
if (this.bitLength() > qJ) {
|
|
this.subTo(T3.ONE.shiftLeft(qJ - 1), this)
|
|
}
|
|
}
|
|
} else {
|
|
var qU = new Array;
|
|
var qM = 7 & qJ;
|
|
qU.length = T2.jyTcZ(T2.KSvfl(qJ, 3), 1);
|
|
qu.nextBytes(qU);
|
|
if (qM > 0) {
|
|
qU[0] &= T2.sknMN(T2.hEJkL(1, qM), 1)
|
|
} else {
|
|
qU[0] = 0
|
|
}
|
|
this.fromString(qU, 256)
|
|
}
|
|
}
|
|
|
|
function Tz() {
|
|
var qJ = T2.XBFBa.split("|");
|
|
var qu = 0;
|
|
while (!![]) {
|
|
switch (qJ[qu++]) {
|
|
case "0":
|
|
qU[0] = this.s;
|
|
continue;
|
|
case "1":
|
|
return qU;
|
|
case "2":
|
|
var qb = this.t;
|
|
var qU = new Array;
|
|
continue;
|
|
case "3":
|
|
if (T2.xMbtp(qb--, 0))
|
|
for (T2.JpwJi(qK, this.DB) && T2.mkURk(qM = T2.AiqNR(this[qb], qK), T2.AiqNR(this.s & this.DM, qK)) && (qU[qB++] = T2.lAIFn(qM, T2.JgmUq(this.s, T2.sknMN(this.DB, qK)))); qb >= 0;) {
|
|
if (T2.BBtkF(8, qK)) {
|
|
qM = T2.lUCtj(this[qb], T2.sknMN(T2.Niskj(1, qK), 1)) << 8 - qK;
|
|
qM |= T2.axFEu(this[--qb], qK += T2.LsXfP(this.DB, 8))
|
|
} else {
|
|
qM = this[qb] >> (qK -= 8) & 255;
|
|
0 >= qK && (qK += this.DB,
|
|
--qb)
|
|
}
|
|
if (T2.rVprn(0, T2.ZLwXu(128, qM))) {
|
|
qM |= -256
|
|
}
|
|
if (T2.RuNvD(0, qB) && T2.rVprn(T2.ixlNQ(128, this.s), T2.ixlNQ(128, qM))) {
|
|
++qB
|
|
}
|
|
if (T2.BBtkF(qB, 0) || T2.rVprn(qM, this.s)) {
|
|
qU[qB++] = qM
|
|
}
|
|
}
|
|
continue;
|
|
case "4":
|
|
var qM;
|
|
var qK = T2.VyvHR(this.DB, T2.FyxbR(T2.MxBTq(qb, this.DB), 8));
|
|
var qB = 0;
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Tk(qJ) {
|
|
return T2.GOCfu(0, this.compareTo(qJ))
|
|
}
|
|
|
|
function TE(qJ) {
|
|
return T2.iTyJv(this.compareTo(qJ), 0) ? this : qJ
|
|
}
|
|
|
|
function Td(qJ) {
|
|
return H.gOLGt(this.compareTo(qJ), 0) ? this : qJ
|
|
}
|
|
|
|
function Tl(qJ, qu, qb) {
|
|
var qU;
|
|
var qM;
|
|
var qK = Math.min(qJ.t, this.t);
|
|
for (qU = 0; H.gOLGt(qK, qU); ++qU)
|
|
qb[qU] = H.LuPYd(qu, this[qU], qJ[qU]);
|
|
if (H.DEnUW(qJ.t, this.t)) {
|
|
for (qM = H.FGypG(qJ.s, this.DM),
|
|
qU = qK; H.DEnUW(qU, this.t); ++qU)
|
|
qb[qU] = H.UEvGy(qu, this[qU], qM);
|
|
qb.t = this.t
|
|
} else {
|
|
for (qM = H.acghB(this.s, this.DM),
|
|
qU = qK; qU < qJ.t; ++qU)
|
|
qb[qU] = qu(qM, qJ[qU]);
|
|
qb.t = qJ.t
|
|
}
|
|
qb.s = H.UEvGy(qu, this.s, qJ.s);
|
|
qb.clamp()
|
|
}
|
|
|
|
function N0(qJ, qu) {
|
|
return T2.ixlNQ(qJ, qu)
|
|
}
|
|
|
|
function N1(qJ) {
|
|
var qu = T2.ZrKJz(T4);
|
|
return this.bitwiseTo(qJ, N0, qu),
|
|
qu
|
|
}
|
|
|
|
function N2(qJ, qu) {
|
|
return qJ | qu
|
|
}
|
|
|
|
function N3(qJ) {
|
|
var qu = T2.ZrKJz(T4);
|
|
return this.bitwiseTo(qJ, N2, qu),
|
|
qu
|
|
}
|
|
|
|
function N4(qJ, qu) {
|
|
return H.OOsqd(qJ, qu)
|
|
}
|
|
|
|
function N5(qJ) {
|
|
var qu = T2.AKTyR(T4);
|
|
return this.bitwiseTo(qJ, N4, qu),
|
|
qu
|
|
}
|
|
|
|
function N6(qJ, qu) {
|
|
return H.acghB(qJ, ~qu)
|
|
}
|
|
|
|
function N7(qJ) {
|
|
var qu = T2.AKTyR(T4);
|
|
return this.bitwiseTo(qJ, N6, qu),
|
|
qu
|
|
}
|
|
|
|
function N8() {
|
|
for (var qJ = T2.AKTyR(T4), qu = 0; T2.iTyJv(qu, this.t); ++qu)
|
|
qJ[qu] = T2.ixlNQ(this.DM, ~this[qu]);
|
|
return qJ.t = this.t,
|
|
qJ.s = ~this.s,
|
|
qJ
|
|
}
|
|
|
|
function N9(qJ) {
|
|
var qu = T4();
|
|
return T2.rflXO(0, qJ) ? this.rShiftTo(-qJ, qu) : this.lShiftTo(qJ, qu),
|
|
qu
|
|
}
|
|
|
|
function NT(qJ) {
|
|
var qu = T2.LLHAb(T4);
|
|
return T2.CzFDK(0, qJ) ? this.lShiftTo(-qJ, qu) : this.rShiftTo(qJ, qu),
|
|
qu
|
|
}
|
|
|
|
function NN(qJ) {
|
|
if (0 == qJ)
|
|
return -1;
|
|
var qu = 0;
|
|
return H.RnGUD(0, H.acghB(65535, qJ)) && (qJ >>= 16,
|
|
qu += 16),
|
|
H.RnGUD(0, H.acghB(255, qJ)) && (qJ >>= 8,
|
|
qu += 8),
|
|
H.oebAG(0, H.GHseG(15, qJ)) && (qJ >>= 4,
|
|
qu += 4),
|
|
0 == H.DgZUt(3, qJ) && (qJ >>= 2,
|
|
qu += 2),
|
|
H.oebAG(0, H.dJrbq(1, qJ)) && ++qu,
|
|
qu
|
|
}
|
|
|
|
function Nq() {
|
|
for (var qJ = 0; qJ < this.t; ++qJ)
|
|
if (0 != this[qJ])
|
|
return H.uyoLE(H.mFHzd(qJ, this.DB), H.RBjvU(NN, this[qJ]));
|
|
return this.s < 0 ? H.mFHzd(this.t, this.DB) : -1
|
|
}
|
|
|
|
function NR(qJ) {
|
|
for (var qu = 0; T2.dFxYo(0, qJ);) {
|
|
qJ &= T2.VyvHR(qJ, 1);
|
|
++qu
|
|
}
|
|
return qu
|
|
}
|
|
|
|
function NL() {
|
|
for (var qJ = 0, qu = this.s & this.DM, qb = 0; qb < this.t; ++qb)
|
|
qJ += H.ohxRf(NR, H.Ocbdv(this[qb], qu));
|
|
return qJ
|
|
}
|
|
|
|
function NG(qJ) {
|
|
var qu = Math.floor(T2.KxaKN(qJ, this.DB));
|
|
return qu >= this.t ? T2.dFxYo(0, this.s) : T2.ljorW(0, T2.NbjXS(this[qu], T2.tUJbt(1, qJ % this.DB)))
|
|
}
|
|
|
|
function Np(qJ, qu) {
|
|
var qb = T3.ONE.shiftLeft(qJ);
|
|
return this.bitwiseTo(qb, qu, qb),
|
|
qb
|
|
}
|
|
|
|
function NC(qJ) {
|
|
return this.changeBit(qJ, N2)
|
|
}
|
|
|
|
function Nf(qJ) {
|
|
return this.changeBit(qJ, N6)
|
|
}
|
|
|
|
function NY(qJ) {
|
|
return this.changeBit(qJ, N4)
|
|
}
|
|
|
|
function NA(qJ, qu) {
|
|
for (var qb = 0, qU = 0, qM = Math.min(qJ.t, this.t); H.bEagz(qM, qb);) {
|
|
qU += H.EbEHm(this[qb], qJ[qb]);
|
|
qu[qb++] = qU & this.DM;
|
|
qU >>= this.DB
|
|
}
|
|
if (qJ.t < this.t) {
|
|
for (qU += qJ.s; H.pUzEz(qb, this.t);) {
|
|
qU += this[qb];
|
|
qu[qb++] = H.nGAYf(qU, this.DM);
|
|
qU >>= this.DB
|
|
}
|
|
qU += this.s
|
|
} else {
|
|
for (qU += this.s; H.SPZfV(qb, qJ.t);) {
|
|
qU += qJ[qb];
|
|
qu[qb++] = H.JuHSD(qU, this.DM);
|
|
qU >>= this.DB
|
|
}
|
|
qU += qJ.s
|
|
}
|
|
if (H.bEagz(0, qU)) {
|
|
qu.s = -1
|
|
} else {
|
|
qu.s = 0
|
|
}
|
|
if (H.bEagz(qU, 0)) {
|
|
qu[qb++] = qU
|
|
} else {
|
|
if (H.MmyNL(-1, qU)) {
|
|
qu[qb++] = H.XYiTN(this.DV, qU)
|
|
}
|
|
}
|
|
qu.t = qb;
|
|
qu.clamp()
|
|
}
|
|
|
|
function Nr(qJ) {
|
|
var qu = T2.LLHAb(T4);
|
|
return this.addTo(qJ, qu),
|
|
qu
|
|
}
|
|
|
|
function Nn(qJ) {
|
|
var qu = H.ErkTV(T4);
|
|
return this.subTo(qJ, qu),
|
|
qu
|
|
}
|
|
|
|
function Nh(qJ) {
|
|
var qu = T2.LLHAb(T4);
|
|
return this.multiplyTo(qJ, qu),
|
|
qu
|
|
}
|
|
|
|
function No() {
|
|
var qJ = T2.moRCT(T4);
|
|
return this.squareTo(qJ),
|
|
qJ
|
|
}
|
|
|
|
function Nm(qJ) {
|
|
var qu = T2.moRCT(T4);
|
|
return this.divRemTo(qJ, qu, null),
|
|
qu
|
|
}
|
|
|
|
function Nx(qJ) {
|
|
var qu = T2.moRCT(T4);
|
|
return this.divRemTo(qJ, null, qu),
|
|
qu
|
|
}
|
|
|
|
function NH(qJ) {
|
|
var qu = T4();
|
|
var qb = T4();
|
|
return this.divRemTo(qJ, qu, qb),
|
|
new Array(qu, qb)
|
|
}
|
|
|
|
function NZ(qJ) {
|
|
this[this.t] = this.am(0, H.JcSmr(qJ, 1), this, 0, 0, this.t);
|
|
++this.t;
|
|
this.clamp()
|
|
}
|
|
|
|
function Na(qJ, qu) {
|
|
if (T2.GMyHt(0, qJ)) {
|
|
for (; this.t <= qu;)
|
|
this[this.t++] = 0;
|
|
for (this[qu] += qJ; T2.VZWlS(this[qu], this.DV);) {
|
|
this[qu] -= this.DV;
|
|
if (T2.PzRhB(++qu, this.t)) {
|
|
this[this.t++] = 0
|
|
}
|
|
++this[qu]
|
|
}
|
|
}
|
|
}
|
|
|
|
function NX() {
|
|
}
|
|
|
|
function Ny(qJ) {
|
|
return qJ
|
|
}
|
|
|
|
function Ni(qJ, qu, qb) {
|
|
qJ.multiplyTo(qu, qb)
|
|
}
|
|
|
|
function Nw(qJ, qu) {
|
|
qJ.squareTo(qu)
|
|
}
|
|
|
|
function ND(qJ) {
|
|
return this.exp(qJ, new NX)
|
|
}
|
|
|
|
function NJ(qJ, qu, qb) {
|
|
var qU = Math.min(T2.vKdPZ(this.t, qJ.t), qu);
|
|
for (qb.s = 0,
|
|
qb.t = qU; T2.QhjbT(qU, 0);)
|
|
qb[--qU] = 0;
|
|
var qM;
|
|
for (qM = T2.VyvHR(qb.t, this.t); qM > qU; ++qU)
|
|
qb[T2.VWJdp(qU, this.t)] = this.am(0, qJ[qU], qb, qU, 0, this.t);
|
|
for (qM = Math.min(qJ.t, qu); qM > qU; ++qU)
|
|
this.am(0, qJ[qU], qb, qU, 0, T2.VyvHR(qu, qU));
|
|
qb.clamp()
|
|
}
|
|
|
|
function Nu(qJ, qu, qb) {
|
|
var qU = H.iPjiX.split("|");
|
|
var qM = 0;
|
|
while (!![]) {
|
|
switch (qU[qM++]) {
|
|
case "0":
|
|
for (qb.s = 0; H.xihmh(--qK, 0);)
|
|
qb[qK] = 0;
|
|
continue;
|
|
case "1":
|
|
--qu;
|
|
continue;
|
|
case "2":
|
|
var qK = qb.t = H.JcSmr(this.t + qJ.t, qu);
|
|
continue;
|
|
case "3":
|
|
for (qK = Math.max(H.BaUOo(qu, this.t), 0); qK < qJ.t; ++qK)
|
|
qb[this.t + qK - qu] = this.am(qu - qK, qJ[qK], qb, 0, 0, H.XYiTN(this.t, qK) - qu);
|
|
continue;
|
|
case "4":
|
|
qb.clamp();
|
|
qb.drShiftTo(1, qb);
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Nb(qJ) {
|
|
this.r2 = T4();
|
|
this.q3 = H.ErkTV(T4);
|
|
T3.ONE.dlShiftTo(H.EtahI(2, qJ.t), this.r2);
|
|
this.mu = this.r2.divide(qJ);
|
|
this.m = qJ
|
|
}
|
|
|
|
function NU(qJ) {
|
|
if (T2.AWonT(qJ.s, 0) || T2.jeMqn(qJ.t, T2.MxBTq(2, this.m.t)))
|
|
return qJ.mod(this.m);
|
|
if (qJ.compareTo(this.m) < 0)
|
|
return qJ;
|
|
var qu = T2.JuqQm(T4);
|
|
return qJ.copyTo(qu),
|
|
this.reduce(qu),
|
|
qu
|
|
}
|
|
|
|
function NM(qJ) {
|
|
return qJ
|
|
}
|
|
|
|
function NK(qJ) {
|
|
for (qJ.drShiftTo(H.TzPpe(this.m.t, 1), this.r2),
|
|
H.MmyNL(qJ.t, this.m.t + 1) && (qJ.t = H.fAkTh(this.m.t, 1),
|
|
qJ.clamp()),
|
|
this.mu.multiplyUpperTo(this.r2, H.fAkTh(this.m.t, 1), this.q3),
|
|
this.m.multiplyLowerTo(this.q3, H.fAkTh(this.m.t, 1), this.r2); H.SPZfV(qJ.compareTo(this.r2), 0);)
|
|
qJ.dAddOffset(1, H.RiRYk(this.m.t, 1));
|
|
for (qJ.subTo(this.r2, qJ); qJ.compareTo(this.m) >= 0;)
|
|
qJ.subTo(this.m, qJ)
|
|
}
|
|
|
|
function NB(qJ, qu) {
|
|
qJ.squareTo(qu);
|
|
this.reduce(qu)
|
|
}
|
|
|
|
function NI(qJ, qu, qb) {
|
|
qJ.multiplyTo(qu, qb);
|
|
this.reduce(qb)
|
|
}
|
|
|
|
function NQ(qJ, qu) {
|
|
var qb = H.WQcoQ.split("|");
|
|
var qU = 0;
|
|
while (!![]) {
|
|
switch (qb[qU++]) {
|
|
case "0":
|
|
if (qK[1] = qj.convert(this),
|
|
qO > 1) {
|
|
var qM = H.ErkTV(T4);
|
|
for (qj.sqrTo(qK[1], qM); H.SrdpF(qQ, qB);) {
|
|
qK[qB] = H.mgAIO(T4);
|
|
qj.mulTo(qM, qK[H.zDHBa(qB, 2)], qK[qB]);
|
|
qB += 2
|
|
}
|
|
}
|
|
continue;
|
|
case "1":
|
|
if (H.MmyNL(18, qs)) {
|
|
qO = 1
|
|
} else {
|
|
if (H.glVDu(48, qs)) {
|
|
qO = 3
|
|
} else {
|
|
if (H.KWzXe(144, qs)) {
|
|
qO = 4
|
|
} else {
|
|
if (H.KWzXe(768, qs)) {
|
|
qO = 5
|
|
} else {
|
|
qO = 6
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (8 > qs) {
|
|
qj = new TX(qu)
|
|
} else {
|
|
if (qu.isEven()) {
|
|
qj = new Nb(qu)
|
|
} else {
|
|
qj = new Tb(qu)
|
|
}
|
|
}
|
|
continue;
|
|
case "2":
|
|
for (qs = TY(qJ[qP]) - 1; H.McOgc(qP, 0);) {
|
|
for (H.GQhRB(qs, qI) ? qS = H.IkJsq(qJ[qP], H.KOcMi(qs, qI)) & qQ : (qS = H.dXuGG(qJ[qP] & H.UJmYs(H.dXuGG(1, H.LeVSk(qs, 1)), 1), H.wSIqX(qI, qs)),
|
|
qP > 0 && (qS |= qJ[H.wSIqX(qP, 1)] >> H.CWoyi(H.qQpbk(this.DB, qs), qI))),
|
|
qB = qO; 0 == H.JuHSD(1, qS);) {
|
|
qS >>= 1;
|
|
--qB
|
|
}
|
|
if (H.SPZfV(qs -= qB, 0) && (qs += this.DB,
|
|
--qP),
|
|
qF) {
|
|
qK[qS].copyTo(qc);
|
|
qF = !1
|
|
} else {
|
|
for (; qB > 1;) {
|
|
qj.sqrTo(qc, qW);
|
|
qj.sqrTo(qW, qc);
|
|
qB -= 2
|
|
}
|
|
if (H.LdsqW(qB, 0)) {
|
|
qj.sqrTo(qc, qW)
|
|
} else {
|
|
qg = qc;
|
|
qc = qW;
|
|
qW = qg
|
|
}
|
|
qj.mulTo(qW, qK[qS], qc)
|
|
}
|
|
for (; H.XDXAk(qP, 0) && H.zWiQy(0, qJ[qP] & H.EWeAz(1, qs));) {
|
|
qj.sqrTo(qc, qW);
|
|
qg = qc;
|
|
qc = qW;
|
|
qW = qg;
|
|
if (H.SPZfV(--qs, 0)) {
|
|
qs = H.OzgIn(this.DB, 1);
|
|
--qP
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
case "3":
|
|
if (H.anPWw(0, qs))
|
|
return qc;
|
|
continue;
|
|
case "4":
|
|
return qj.revert(qc);
|
|
case "5":
|
|
var qK = new Array;
|
|
var qB = 3;
|
|
var qI = H.OzgIn(qO, 1);
|
|
var qQ = H.KcLFs(H.EWeAz(1, qO), 1);
|
|
continue;
|
|
case "6":
|
|
var qS;
|
|
var qg;
|
|
var qP = qJ.t - 1;
|
|
var qF = !0;
|
|
var qW = H.biNto(T4);
|
|
continue;
|
|
case "7":
|
|
var qO;
|
|
var qj;
|
|
var qs = qJ.bitLength();
|
|
var qc = H.fsYyP(Tq, 1);
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function NS(qJ) {
|
|
var qu = T2.GVBgw.split("|");
|
|
var qb = 0;
|
|
while (!![]) {
|
|
switch (qu[qb++]) {
|
|
case "0":
|
|
var qU = qB.getLowestSetBit();
|
|
var qM = qI.getLowestSetBit();
|
|
continue;
|
|
case "1":
|
|
if (qB.compareTo(qI) < 0) {
|
|
var qK = qB;
|
|
qB = qI;
|
|
qI = qK
|
|
}
|
|
continue;
|
|
case "2":
|
|
for (T2.wdmxi(qM, qU) && (qM = qU),
|
|
T2.yzXyc(qM, 0) && (qB.rShiftTo(qM, qB),
|
|
qI.rShiftTo(qM, qI)); T2.BwboT(qB.signum(), 0);) {
|
|
if ((qU = qB.getLowestSetBit()) > 0) {
|
|
qB.rShiftTo(qU, qB)
|
|
}
|
|
if (T2.BwboT(qU = qI.getLowestSetBit(), 0)) {
|
|
qI.rShiftTo(qU, qI)
|
|
}
|
|
if (qB.compareTo(qI) >= 0) {
|
|
qB.subTo(qI, qB);
|
|
qB.rShiftTo(1, qB)
|
|
} else {
|
|
qI.subTo(qB, qI);
|
|
qI.rShiftTo(1, qI)
|
|
}
|
|
}
|
|
continue;
|
|
case "3":
|
|
if (0 > qM)
|
|
return qB;
|
|
continue;
|
|
case "4":
|
|
return T2.BwboT(qM, 0) && qI.lShiftTo(qM, qI),
|
|
qI;
|
|
case "5":
|
|
var qB;
|
|
if (T2.hsVME(this.s, 0)) {
|
|
qB = this.negate()
|
|
} else {
|
|
qB = this.clone()
|
|
}
|
|
var qI;
|
|
if (qJ.s < 0) {
|
|
qI = qJ.negate()
|
|
} else {
|
|
qI = qJ.clone()
|
|
}
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Ng(qJ) {
|
|
if (T2.PzRhB(0, qJ))
|
|
return 0;
|
|
var qu = this.DV % qJ;
|
|
var qb;
|
|
if (T2.RpISk(this.s, 0)) {
|
|
qb = T2.jgSJH(qJ, 1)
|
|
} else {
|
|
qb = 0
|
|
}
|
|
if (T2.xMscz(this.t, 0)) {
|
|
if (0 == qu)
|
|
qb = this[0] % qJ;
|
|
else
|
|
for (var qU = T2.jgSJH(this.t, 1); T2.PzRhB(qU, 0); --qU)
|
|
qb = T2.FyxbR(T2.MxBTq(qu, qb) + this[qU], qJ)
|
|
}
|
|
return qb
|
|
}
|
|
|
|
function NP(qJ) {
|
|
var qu = qJ.isEven();
|
|
if (this.isEven() && qu || H.fvqxb(0, qJ.signum()))
|
|
return T3.ZERO;
|
|
for (var qb = qJ.clone(), qU = this.clone(), qM = H.fsYyP(Tq, 1), qK = H.emsrR(Tq, 0), qB = H.UNZJm(Tq, 0), qI = H.UNZJm(Tq, 1); H.YWRsD(0, qb.signum());) {
|
|
for (; qb.isEven();) {
|
|
qb.rShiftTo(1, qb);
|
|
if (qu) {
|
|
qM.isEven() && qK.isEven() || (qM.addTo(this, qM),
|
|
qK.subTo(qJ, qK));
|
|
qM.rShiftTo(1, qM)
|
|
} else {
|
|
qK.isEven() || qK.subTo(qJ, qK)
|
|
}
|
|
qK.rShiftTo(1, qK)
|
|
}
|
|
for (; qU.isEven();) {
|
|
qU.rShiftTo(1, qU);
|
|
if (qu) {
|
|
qB.isEven() && qI.isEven() || (qB.addTo(this, qB),
|
|
qI.subTo(qJ, qI));
|
|
qB.rShiftTo(1, qB)
|
|
} else {
|
|
qI.isEven() || qI.subTo(qJ, qI)
|
|
}
|
|
qI.rShiftTo(1, qI)
|
|
}
|
|
if (qb.compareTo(qU) >= 0) {
|
|
qb.subTo(qU, qb);
|
|
if (qu) {
|
|
qM.subTo(qB, qM)
|
|
}
|
|
qK.subTo(qI, qK)
|
|
} else {
|
|
qU.subTo(qb, qU);
|
|
if (qu) {
|
|
qB.subTo(qM, qB)
|
|
}
|
|
qI.subTo(qK, qI)
|
|
}
|
|
}
|
|
return H.JtkDZ(0, qU.compareTo(T3.ONE)) ? T3.ZERO : H.anPWw(qI.compareTo(qJ), 0) ? qI.subtract(qJ) : qI.signum() < 0 ? (qI.addTo(qJ, qI),
|
|
H.SPZfV(qI.signum(), 0) ? qI.add(qJ) : qI) : qI
|
|
}
|
|
|
|
function NF(qJ) {
|
|
var qu;
|
|
var qb = this.abs();
|
|
if (H.fvqxb(1, qb.t) && H.fXfsR(qb[0], qf[H.KcLFs(qf.length, 1)])) {
|
|
for (qu = 0; qu < qf.length; ++qu)
|
|
if (H.tszKs(qb[0], qf[qu]))
|
|
return !0;
|
|
return !1
|
|
}
|
|
if (qb.isEven())
|
|
return !1;
|
|
for (qu = 1; H.hStLf(qu, qf.length);) {
|
|
for (var qU = qf[qu], qM = H.qQpbk(qu, 1); H.HjWiz(qM, qf.length) && qY > qU;)
|
|
qU *= qf[qM++];
|
|
for (qU = qb.modInt(qU); H.LdsqW(qM, qu);)
|
|
if (H.tszKs(H.cpuUC(qU, qf[qu++]), 0))
|
|
return !1
|
|
}
|
|
return qb.millerRabin(qJ)
|
|
}
|
|
|
|
function NW(qJ) {
|
|
var qu = T2.TwZoU.split("|");
|
|
var qb = 0;
|
|
while (!![]) {
|
|
switch (qu[qb++]) {
|
|
case "0":
|
|
var qU = qQ.shiftRight(qS);
|
|
continue;
|
|
case "1":
|
|
for (var qM = T4(), qK = 0; T2.QZvOQ(qJ, qK); ++qK) {
|
|
var qB = qM.modPow(qU, this);
|
|
if (T2.cKTuA(0, qB.compareTo(T3.ONE)) && T2.Lfbzx(0, qB.compareTo(qQ))) {
|
|
for (var qI = 1; T2.Opfux(qI++, qS) && T2.Lfbzx(0, qB.compareTo(qQ));)
|
|
if (qB = qB.modPowInt(2, this),
|
|
T2.GOCfu(0, qB.compareTo(T3.ONE)))
|
|
return !1;
|
|
if (T2.CwEaP(0, qB.compareTo(qQ)))
|
|
return !1
|
|
}
|
|
}
|
|
continue;
|
|
case "2":
|
|
qJ = T2.pGwJz(qJ, 1) >> 1;
|
|
if (T2.QZvOQ(qJ, qf.length)) {
|
|
qJ = qf.length
|
|
}
|
|
continue;
|
|
case "3":
|
|
var qQ = this.subtract(T3.ONE);
|
|
var qS = qQ.getLowestSetBit();
|
|
continue;
|
|
case "4":
|
|
if (T2.YcvqW(0, qS))
|
|
return !1;
|
|
continue;
|
|
case "5":
|
|
return !0;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function NO() {
|
|
this.i = 0;
|
|
this.j = 0;
|
|
this.S = new Array
|
|
}
|
|
|
|
function Nj(qJ) {
|
|
var qu;
|
|
var qb;
|
|
var qU;
|
|
for (qu = 0; H.LdsqW(256, qu); ++qu)
|
|
this.S[qu] = qu;
|
|
for (qb = 0,
|
|
qu = 0; H.tpMAg(256, qu); ++qu) {
|
|
qb = H.JuHSD(H.qQpbk(qb, this.S[qu]) + qJ[H.yDKIR(qu, qJ.length)], 255);
|
|
qU = this.S[qu];
|
|
this.S[qu] = this.S[qb];
|
|
this.S[qb] = qU
|
|
}
|
|
this.i = 0;
|
|
this.j = 0
|
|
}
|
|
|
|
function Ns() {
|
|
var qJ;
|
|
return this.i = T2.NbjXS(T2.XgZgm(this.i, 1), 255),
|
|
this.j = T2.cAzea(this.j + this.S[this.i], 255),
|
|
qJ = this.S[this.i],
|
|
this.S[this.i] = this.S[this.j],
|
|
this.S[this.j] = qJ,
|
|
this.S[qJ + this.S[this.i] & 255]
|
|
}
|
|
|
|
function Nc() {
|
|
return new NO
|
|
}
|
|
|
|
function Nv() {
|
|
if (H.tszKs(null, qA)) {
|
|
for (qA = H.biNto(Nc); qh > qn;) {
|
|
qr[qn++] = H.kpgOz(255, T0)
|
|
}
|
|
for (qA.init(qr),
|
|
qn = 0; H.HjWiz(qn, qr.length); ++qn)
|
|
qr[qn] = 0;
|
|
qn = 0
|
|
}
|
|
return qA.next()
|
|
}
|
|
|
|
function NV(qJ) {
|
|
var qu;
|
|
for (qu = 0; H.TORTh(qu, qJ.length); ++qu)
|
|
qJ[qu] = Nv()
|
|
}
|
|
|
|
function Nz() {
|
|
}
|
|
|
|
function Nk(qJ, qu) {
|
|
return new T3(qJ, qu)
|
|
}
|
|
|
|
function NE(qJ, qu) {
|
|
var qb = T2.QzQDA.split("|");
|
|
var qU = 0;
|
|
while (!![]) {
|
|
switch (qb[qU++]) {
|
|
case "0":
|
|
for (var qM = new Nz, qK = new Array; T2.FOMRZ(qu, 2);) {
|
|
for (qK[0] = 0; T2.vundK(0, qK[0]);)
|
|
qM.nextBytes(qK);
|
|
qB[--qu] = qK[0]
|
|
}
|
|
continue;
|
|
case "1":
|
|
return qB[--qu] = 2,
|
|
qB[--qu] = 0,
|
|
new T3(qB);
|
|
case "2":
|
|
qB[--qu] = 0;
|
|
continue;
|
|
case "3":
|
|
if (T2.afZbf(qu, qJ.length + 11))
|
|
return console.error("Message too long for RSA"),
|
|
null;
|
|
continue;
|
|
case "4":
|
|
for (var qB = new Array, qI = qJ.length - 1; qI >= 0 && T2.FOMRZ(qu, 0);) {
|
|
var qQ = qJ.charCodeAt(qI--);
|
|
if (T2.pnUxC(128, qQ)) {
|
|
qB[--qu] = qQ
|
|
} else {
|
|
if (qQ > 127 && T2.zhlAb(2048, qQ)) {
|
|
qB[--qu] = T2.qDlLU(63, qQ) | 128;
|
|
qB[--qu] = T2.QMyJZ(qQ >> 6, 192)
|
|
} else {
|
|
qB[--qu] = T2.QMyJZ(T2.vjNkQ(63, qQ), 128);
|
|
qB[--qu] = T2.QMyJZ(T2.vjNkQ(T2.mdZxF(qQ, 6), 63), 128);
|
|
qB[--qu] = T2.QMyJZ(T2.XAubh(qQ, 12), 224)
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function Nd() {
|
|
this.n = null;
|
|
this.e = 0;
|
|
this.d = null;
|
|
this.p = null;
|
|
this.q = null;
|
|
this.dmp1 = null;
|
|
this.dmq1 = null;
|
|
this.coeff = null
|
|
}
|
|
|
|
function Nl(qJ, qu) {
|
|
if (T2.Oykmt(null, qJ) && T2.Oykmt(null, qu) && T2.LUjGk(qJ.length, 0) && T2.uIkVl(qu.length, 0)) {
|
|
this.n = T2.DTlFy(Nk, qJ, 16);
|
|
this.e = parseInt(qu, 16)
|
|
} else {
|
|
console.error(T2.JdrPR)
|
|
}
|
|
}
|
|
|
|
function q0(qJ) {
|
|
return qJ.modPowInt(this.e, this.n)
|
|
}
|
|
|
|
function q1(qJ) {
|
|
var qu = T2.DTlFy(NE, qJ, T2.vVTig(T2.gkfGN(this.n.bitLength(), 7), 3));
|
|
if (T2.brjev(null, qu))
|
|
return null;
|
|
var qb = this.doPublic(qu);
|
|
if (T2.brjev(null, qb))
|
|
return null;
|
|
var qU = qb.toString(16);
|
|
return T2.brjev(0, 1 & qU.length) ? qU : T2.lGHgR("0", qU)
|
|
}
|
|
|
|
function q2(qJ, qu) {
|
|
var qb = H.OBCXQ.split("|");
|
|
var qU = 0;
|
|
while (!![]) {
|
|
switch (qb[qU++]) {
|
|
case "0":
|
|
for (++qK; H.QRakU(0, qM[qK]);)
|
|
if (H.imhlT(++qK, qM.length))
|
|
return null;
|
|
continue;
|
|
case "1":
|
|
if (H.wwmHc(qM.length - qK, H.KcLFs(qu, 1)) || H.UWXXj(2, qM[qK]))
|
|
return null;
|
|
continue;
|
|
case "2":
|
|
for (var qM = qJ.toByteArray(), qK = 0; H.TORTh(qK, qM.length) && H.OTTcd(0, qM[qK]);)
|
|
++qK;
|
|
continue;
|
|
case "3":
|
|
for (var qB = ""; H.TORTh(++qK, qM.length);) {
|
|
var qI = H.GnTJo(255, qM[qK]);
|
|
if (128 > qI) {
|
|
qB += String.fromCharCode(qI)
|
|
} else {
|
|
if (H.eArWj(qI, 191) && H.eArWj(224, qI)) {
|
|
qB += String.fromCharCode(H.EtzCR((31 & qI) << 6, H.qtrXY(63, qM[H.LCAMm(qK, 1)])));
|
|
++qK
|
|
} else {
|
|
qB += String.fromCharCode(H.EtzCR(H.VAyWm(H.EWeAz(15 & qI, 12), H.EWeAz(H.YJCRW(63, qM[H.bQYQH(qK, 1)]), 6)), H.iXVgq(63, qM[H.bQYQH(qK, 2)])));
|
|
qK += 2
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
case "4":
|
|
return qB;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
function q3(qJ, qu, qb) {
|
|
if (H.gFgNO(null, qJ) && null != qu && H.eArWj(qJ.length, 0) && H.eArWj(qu.length, 0)) {
|
|
this.n = H.ImrcA(Nk, qJ, 16);
|
|
this.e = H.ktCBH(parseInt, qu, 16);
|
|
this.d = H.ktCBH(Nk, qb, 16)
|
|
} else {
|
|
console.error(H.IQycX)
|
|
}
|
|
}
|
|
|
|
function q4(qJ, qu, qb, qU, qM, qK, qB, qI) {
|
|
if (T2.QdsIm(null, qJ) && T2.EoEpv(null, qu) && T2.LCckH(qJ.length, 0) && qu.length > 0) {
|
|
this.n = T2.DTlFy(Nk, qJ, 16);
|
|
this.e = T2.DTlFy(parseInt, qu, 16);
|
|
this.d = T2.aBgic(Nk, qb, 16);
|
|
this.p = T2.aBgic(Nk, qU, 16);
|
|
this.q = T2.PkzgD(Nk, qM, 16);
|
|
this.dmp1 = T2.OeVDx(Nk, qK, 16);
|
|
this.dmq1 = T2.OeVDx(Nk, qB, 16);
|
|
this.coeff = T2.SdCoG(Nk, qI, 16)
|
|
} else {
|
|
console.error("Invalid RSA private key")
|
|
}
|
|
}
|
|
|
|
function q5(qJ, qu) {
|
|
var qb = new Nz;
|
|
var qU = T2.EqSfc(qJ, 1);
|
|
this.e = parseInt(qu, 16);
|
|
for (var qM = new T3(qu, 16); ;) {
|
|
for (; this.p = new T3(qJ - qU, 1, qb),
|
|
T2.EoEpv(0, this.p.subtract(T3.ONE).gcd(qM).compareTo(T3.ONE)) || !this.p.isProbablePrime(10);)
|
|
;
|
|
for (; this.q = new T3(qU, 1, qb),
|
|
T2.YeSkx(0, this.q.subtract(T3.ONE).gcd(qM).compareTo(T3.ONE)) || !this.q.isProbablePrime(10);)
|
|
;
|
|
if (T2.bFWMW(this.p.compareTo(this.q), 0)) {
|
|
var qK = this.p;
|
|
this.p = this.q;
|
|
this.q = qK
|
|
}
|
|
var qB = this.p.subtract(T3.ONE);
|
|
var qI = this.q.subtract(T3.ONE);
|
|
var qQ = qB.multiply(qI);
|
|
if (T2.xZfZR(0, qQ.gcd(qM).compareTo(T3.ONE))) {
|
|
this.n = this.p.multiply(this.q);
|
|
this.d = qM.modInverse(qQ);
|
|
this.dmp1 = this.d.mod(qB);
|
|
this.dmq1 = this.d.mod(qI);
|
|
this.coeff = this.q.modInverse(this.p);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
function q6(qJ) {
|
|
if (T2.xZfZR(null, this.p) || T2.sTeDf(null, this.q))
|
|
return qJ.modPow(this.d, this.n);
|
|
for (var qu = qJ.mod(this.p).modPow(this.dmp1, this.p), qb = qJ.mod(this.q).modPow(this.dmq1, this.q); T2.dgQhD(qu.compareTo(qb), 0);)
|
|
qu = qu.add(this.p);
|
|
return qu.subtract(qb).multiply(this.coeff).mod(this.p).multiply(this.q).add(qb)
|
|
}
|
|
|
|
function q7(qJ) {
|
|
var qu = H.lyZcT(Nk, qJ, 16);
|
|
var qb = this.doPrivate(qu);
|
|
return H.OTTcd(null, qb) ? null : H.VgqQS(q2, qb, H.tDXId(this.n.bitLength() + 7, 3))
|
|
}
|
|
|
|
function q8(qJ) {
|
|
var qu;
|
|
var qb;
|
|
var qU = "";
|
|
for (qu = 0; T2.oyQDV(qu + 3, qJ.length); qu += 3) {
|
|
qb = T2.SdCoG(parseInt, qJ.substring(qu, qu + 3), 16);
|
|
qU += T2.fhLpK(qx.charAt(qb >> 6), qx.charAt(T2.UtJkT(63, qb)))
|
|
}
|
|
for (T2.sTeDf(T2.nmPHP(qu, 1), qJ.length) ? (qb = T2.GcDoE(parseInt, qJ.substring(qu, T2.EoEDA(qu, 1)), 16),
|
|
qU += qx.charAt(T2.tUJbt(qb, 2))) : T2.sTeDf(T2.XXXFE(qu, 2), qJ.length) && (qb = T2.GcDoE(parseInt, qJ.substring(qu, T2.gLEQE(qu, 2)), 16),
|
|
qU += T2.gLEQE(qx.charAt(qb >> 2), qx.charAt(T2.UtJkT(3, qb) << 4))); T2.KOjiH(T2.UtJkT(3, qU.length), 0);)
|
|
qU += qH;
|
|
return qU
|
|
}
|
|
|
|
function q9(qJ) {
|
|
var qu;
|
|
var qb;
|
|
var qU = "";
|
|
var qM = 0;
|
|
for (qu = 0; qu < qJ.length && T2.EbqzM(qJ.charAt(qu), qH); ++qu) {
|
|
T1 = qx.indexOf(qJ.charAt(qu));
|
|
T2.uXLtI(T1, 0) || (T2.lojoc(0, qM) ? (qU += T8(T2.EqSfc(T1, 2)),
|
|
qb = 3 & T1,
|
|
qM = 1) : 1 == qM ? (qU += T2.PMDAF(T8, T2.QMyJZ(T2.ldeug(qb, 2), T1 >> 4)),
|
|
qb = T2.UtJkT(15, T1),
|
|
qM = 2) : T2.JzjnQ(2, qM) ? (qU += T8(qb),
|
|
qU += T2.vjAam(T8, T2.uGEjr(T1, 2)),
|
|
qb = 3 & T1,
|
|
qM = 3) : (qU += T2.vjAam(T8, T2.ldeug(qb, 2) | T2.tloob(T1, 4)),
|
|
qU += T8(T2.JvduP(15, T1)),
|
|
qM = 0))
|
|
}
|
|
return T2.kJmRG(1, qM) && (qU += T2.vjAam(T8, qb << 2)),
|
|
qU
|
|
}
|
|
|
|
var qT;
|
|
var qN;
|
|
var qq = C.DRicM(15715070, 15715070);
|
|
if (qq && C.tMPma("Microsoft Internet Explorer", 'Netscape')) {
|
|
T3.prototype.am = T6;
|
|
qT = 26
|
|
} else {
|
|
if (qq && C.uLbls != 'Netscape') {
|
|
T3.prototype.am = T5;
|
|
qT = 26
|
|
} else {
|
|
T3.prototype.am = T7;
|
|
qT = 28
|
|
}
|
|
}
|
|
T3.prototype.DB = qT;
|
|
T3.prototype.DM = C.UItDy(1 << qT, 1);
|
|
T3.prototype.DV = 1 << qT;
|
|
var qR = 52;
|
|
T3.prototype.FV = Math.pow(2, qR);
|
|
T3.prototype.F1 = qR - qT;
|
|
T3.prototype.F2 = 2 * qT - qR;
|
|
var qL;
|
|
var qG;
|
|
var qp = C.XpDTh;
|
|
var qC = new Array;
|
|
for (qL = "0".charCodeAt(0),
|
|
qG = 0; C.pnwdf(9, qG); ++qG)
|
|
qC[qL++] = qG;
|
|
for (qL = "a".charCodeAt(0),
|
|
qG = 10; C.zonUt(36, qG); ++qG)
|
|
qC[qL++] = qG;
|
|
for (qL = "A".charCodeAt(0),
|
|
qG = 10; C.zonUt(36, qG); ++qG)
|
|
qC[qL++] = qG;
|
|
TX.prototype.convert = Ty;
|
|
TX.prototype.revert = Ti;
|
|
TX.prototype.reduce = Tw;
|
|
TX.prototype.mulTo = TD;
|
|
TX.prototype.sqrTo = TJ;
|
|
Tb.prototype.convert = TU;
|
|
Tb.prototype.revert = TM;
|
|
Tb.prototype.reduce = TK;
|
|
Tb.prototype.mulTo = TI;
|
|
Tb.prototype.sqrTo = TB;
|
|
T3.prototype.copyTo = TT;
|
|
T3.prototype.fromInt = TN;
|
|
T3.prototype.fromString = TR;
|
|
T3.prototype.clamp = TL;
|
|
T3.prototype.dlShiftTo = Tr;
|
|
T3.prototype.drShiftTo = Tn;
|
|
T3.prototype.lShiftTo = Th;
|
|
T3.prototype.rShiftTo = To;
|
|
T3.prototype.subTo = Tm;
|
|
T3.prototype.multiplyTo = Tx;
|
|
T3.prototype.squareTo = TH;
|
|
T3.prototype.divRemTo = TZ;
|
|
T3.prototype.invDigit = Tu;
|
|
T3.prototype.isEven = TQ;
|
|
T3.prototype.exp = TS;
|
|
T3.prototype.toString = TG;
|
|
T3.prototype.negate = Tp;
|
|
T3.prototype.abs = TC;
|
|
T3.prototype.compareTo = Tf;
|
|
T3.prototype.bitLength = TA;
|
|
T3.prototype.mod = Ta;
|
|
T3.prototype.modPowInt = Tg;
|
|
T3.ZERO = Tq(0);
|
|
T3.ONE = C.OxEIB(Tq, 1);
|
|
NX.prototype.convert = Ny;
|
|
NX.prototype.revert = Ny;
|
|
NX.prototype.mulTo = Ni;
|
|
NX.prototype.sqrTo = Nw;
|
|
Nb.prototype.convert = NU;
|
|
Nb.prototype.revert = NM;
|
|
Nb.prototype.reduce = NK;
|
|
Nb.prototype.mulTo = NI;
|
|
Nb.prototype.sqrTo = NB;
|
|
var qf = [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 qY = C.gpUSL(C.barYY(1, 26), qf[C.UItDy(qf.length, 1)]);
|
|
T3.prototype.chunkSize = Tj;
|
|
T3.prototype.toRadix = Tc;
|
|
T3.prototype.fromRadix = Tv;
|
|
T3.prototype.fromNumber = TV;
|
|
T3.prototype.bitwiseTo = Tl;
|
|
T3.prototype.changeBit = Np;
|
|
T3.prototype.addTo = NA;
|
|
T3.prototype.dMultiply = NZ;
|
|
T3.prototype.dAddOffset = Na;
|
|
T3.prototype.multiplyLowerTo = NJ;
|
|
T3.prototype.multiplyUpperTo = Nu;
|
|
T3.prototype.modInt = Ng;
|
|
T3.prototype.millerRabin = NW;
|
|
T3.prototype.clone = TP;
|
|
T3.prototype.intValue = TF;
|
|
T3.prototype.byteValue = TW;
|
|
T3.prototype.shortValue = TO;
|
|
T3.prototype.signum = Ts;
|
|
T3.prototype.toByteArray = Tz;
|
|
T3.prototype.equals = Tk;
|
|
T3.prototype.min = TE;
|
|
T3.prototype.max = Td;
|
|
T3.prototype.and = N1;
|
|
T3.prototype.or = N3;
|
|
T3.prototype.xor = N5;
|
|
T3.prototype.andNot = N7;
|
|
T3.prototype.not = N8;
|
|
T3.prototype.shiftLeft = N9;
|
|
T3.prototype.shiftRight = NT;
|
|
T3.prototype.getLowestSetBit = Nq;
|
|
T3.prototype.bitCount = NL;
|
|
T3.prototype.testBit = NG;
|
|
T3.prototype.setBit = NC;
|
|
T3.prototype.clearBit = Nf;
|
|
T3.prototype.flipBit = NY;
|
|
T3.prototype.add = Nr;
|
|
T3.prototype.subtract = Nn;
|
|
T3.prototype.multiply = Nh;
|
|
T3.prototype.divide = Nm;
|
|
T3.prototype.remainder = Nx;
|
|
T3.prototype.divideAndRemainder = NH;
|
|
T3.prototype.modPow = NQ;
|
|
T3.prototype.modInverse = NP;
|
|
T3.prototype.pow = ND;
|
|
T3.prototype.gcd = NS;
|
|
T3.prototype.isProbablePrime = NF;
|
|
T3.prototype.square = No;
|
|
NO.prototype.init = Nj;
|
|
NO.prototype.next = Ns;
|
|
var qA;
|
|
var qr;
|
|
var qn;
|
|
var qh = 256;
|
|
if (null == qr) {
|
|
qr = new Array;
|
|
qn = 0;
|
|
var qo;
|
|
var qm = function (qJ) {
|
|
if (this.count = this.count || 0,
|
|
T2.sCwJz(this.count, 256) || T2.EJFde(qn, qh))
|
|
try {
|
|
var qu = T2.gLEQE(qJ.x, qJ.y);
|
|
qr[qn++] = T2.QuxFV(255, qu);
|
|
this.count += 1
|
|
} catch (qb) {
|
|
console.log(qb);
|
|
console.log(qb)
|
|
}
|
|
};
|
|
// window.addEventListener(C.NGziR, qm, !1)
|
|
}
|
|
Nz.prototype.nextBytes = NV;
|
|
Nd.prototype.doPublic = q0;
|
|
Nd.prototype.setPublic = Nl;
|
|
Nd.prototype.encrypt = q1;
|
|
Nd.prototype.doPrivate = q6;
|
|
Nd.prototype.setPrivate = q3;
|
|
Nd.prototype.setPrivateEx = q4;
|
|
Nd.prototype.generate = q5;
|
|
Nd.prototype.decrypt = q7;
|
|
(function () {
|
|
var qJ = "4|0|3|5|1|2|6".split("|");
|
|
var qu = 0;
|
|
while (!![]) {
|
|
switch (qJ[qu++]) {
|
|
case "0":
|
|
var qb = function (qI, qQ, qS) {
|
|
var qg = qK.rZvRq.split("|");
|
|
var qP = 0;
|
|
while (!![]) {
|
|
switch (qg[qP++]) {
|
|
case "0":
|
|
this.e = parseInt(qQ, 16);
|
|
continue;
|
|
case "1":
|
|
var qF = new T3(qQ, 16);
|
|
var qW = this;
|
|
var qO = function () {
|
|
var qV = {};
|
|
qV.mIgfX = function (ql) {
|
|
return ql()
|
|
}
|
|
;
|
|
qV.qJOse = function (ql, R0) {
|
|
return ql == R0
|
|
}
|
|
;
|
|
qV.VRSKB = function (ql) {
|
|
return qK.Hgeah(ql)
|
|
}
|
|
;
|
|
qV.LmfBU = function (ql, R0, R1) {
|
|
return qK.nhuDr(ql, R0, R1)
|
|
}
|
|
;
|
|
qV.dcnTD = function (ql, R0) {
|
|
return ql - R0
|
|
}
|
|
;
|
|
var qz = qV;
|
|
var qk = function () {
|
|
if (qW.p.compareTo(qW.q) <= 0) {
|
|
var ql = qW.p;
|
|
qW.p = qW.q;
|
|
qW.q = ql
|
|
}
|
|
var R0 = qW.p.subtract(T3.ONE);
|
|
var R1 = qW.q.subtract(T3.ONE);
|
|
var R2 = R0.multiply(R1);
|
|
if (0 == R2.gcd(qF).compareTo(T3.ONE)) {
|
|
qW.n = qW.p.multiply(qW.q);
|
|
qW.d = qF.modInverse(R2);
|
|
qW.dmp1 = qW.d.mod(R0);
|
|
qW.dmq1 = qW.d.mod(R1);
|
|
qW.coeff = qW.q.modInverse(qW.p);
|
|
qv.qiozw(setTimeout, function () {
|
|
qz.mIgfX(qS)
|
|
}, 0)
|
|
} else {
|
|
qv.GGBHm(setTimeout, qO, 0)
|
|
}
|
|
};
|
|
var qE = function () {
|
|
qW.q = qz.VRSKB(T4);
|
|
qW.q.fromNumberAsync(qs, 1, qj, function () {
|
|
var ql = {};
|
|
ql.BxHNu = function (R1, R2) {
|
|
return qz.qJOse(R1, R2)
|
|
}
|
|
;
|
|
ql.DoYGC = function (R1, R2, R3) {
|
|
return R1(R2, R3)
|
|
}
|
|
;
|
|
var R0 = ql;
|
|
qW.q.subtract(T3.ONE).gcda(qF, function (R1) {
|
|
if (R0.BxHNu(0, R1.compareTo(T3.ONE)) && qW.q.isProbablePrime(10)) {
|
|
R0.DoYGC(setTimeout, qk, 0)
|
|
} else {
|
|
setTimeout(qE, 0)
|
|
}
|
|
})
|
|
})
|
|
};
|
|
var qd = function () {
|
|
var ql = {};
|
|
ql.oSekp = function (R1, R2, R3) {
|
|
return qz.LmfBU(R1, R2, R3)
|
|
}
|
|
;
|
|
var R0 = ql;
|
|
qW.p = qz.VRSKB(T4);
|
|
qW.p.fromNumberAsync(qz.dcnTD(qI, qs), 1, qj, function () {
|
|
qW.p.subtract(T3.ONE).gcda(qF, function (R1) {
|
|
if (0 == R1.compareTo(T3.ONE) && qW.p.isProbablePrime(10)) {
|
|
setTimeout(qE, 0)
|
|
} else {
|
|
R0.oSekp(setTimeout, qd, 0)
|
|
}
|
|
})
|
|
})
|
|
};
|
|
qK.nhuDr(setTimeout, qd, 0)
|
|
};
|
|
continue;
|
|
case "2":
|
|
qK.nhuDr(setTimeout, qO, 0);
|
|
continue;
|
|
case "3":
|
|
var qj = new Nz;
|
|
var qs = qK.vgEPE(qI, 1);
|
|
continue;
|
|
case "4":
|
|
var qc = {};
|
|
qc.qiozw = function (qV, qz, qk) {
|
|
return qK.nhuDr(qV, qz, qk)
|
|
}
|
|
;
|
|
qc.GGBHm = function (qV, qz, qk) {
|
|
return qV(qz, qk)
|
|
}
|
|
;
|
|
var qv = qc;
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
};
|
|
continue;
|
|
case "1":
|
|
T3.prototype.gcda = qB;
|
|
continue;
|
|
case "2":
|
|
var qU = function (qI, qQ, qS, qg) {
|
|
if (qK.GCBSD(qK.dTarM, typeof qQ)) {
|
|
if (2 > qI)
|
|
this.fromInt(1);
|
|
else {
|
|
this.fromNumber(qI, qS);
|
|
this.testBit(qK.EizQG(qI, 1)) || this.bitwiseTo(T3.ONE.shiftLeft(qI - 1), N2, this);
|
|
if (this.isEven()) {
|
|
this.dAddOffset(1, 0)
|
|
}
|
|
var qP = this;
|
|
var qF = function () {
|
|
var qj = {};
|
|
qj.hhJAi = function (qc) {
|
|
return qK.Hgeah(qc)
|
|
}
|
|
;
|
|
var qs = qj;
|
|
qP.dAddOffset(2, 0);
|
|
if (qK.pHFsl(qP.bitLength(), qI)) {
|
|
qP.subTo(T3.ONE.shiftLeft(qI - 1), qP)
|
|
}
|
|
if (qP.isProbablePrime(qQ)) {
|
|
qK.GvCFC(setTimeout, function () {
|
|
qs.hhJAi(qg)
|
|
}, 0)
|
|
} else {
|
|
qK.GvCFC(setTimeout, qF, 0)
|
|
}
|
|
};
|
|
qK.GvCFC(setTimeout, qF, 0)
|
|
}
|
|
} else {
|
|
var qW = new Array;
|
|
var qO = qK.BLtSg(7, qI);
|
|
qW.length = qK.BtKUH(qI, 3) + 1;
|
|
qQ.nextBytes(qW);
|
|
if (qK.iwDvc(qO, 0)) {
|
|
qW[0] &= qK.iNnoD(qK.RknPm(1, qO), 1)
|
|
} else {
|
|
qW[0] = 0
|
|
}
|
|
this.fromString(qW, 256)
|
|
}
|
|
};
|
|
continue;
|
|
case "3":
|
|
Nd.prototype.generateAsync = qb;
|
|
continue;
|
|
case "4":
|
|
var qM = {};
|
|
qM.Hgeah = function (qI) {
|
|
return qI()
|
|
}
|
|
;
|
|
qM.nhuDr = function (qI, qQ, qS) {
|
|
return H.VgqQS(qI, qQ, qS)
|
|
}
|
|
;
|
|
qM.rZvRq = H.VsBUP;
|
|
qM.vgEPE = function (qI, qQ) {
|
|
return qI >> qQ
|
|
}
|
|
;
|
|
qM.KOnEX = function (qI, qQ) {
|
|
return H.AtYSS(qI, qQ)
|
|
}
|
|
;
|
|
qM.WaqUq = function (qI, qQ) {
|
|
return qI >= qQ
|
|
}
|
|
;
|
|
qM.EtZyM = function (qI, qQ) {
|
|
return H.NhsVJ(qI, qQ)
|
|
}
|
|
;
|
|
qM.GjFBv = function (qI, qQ) {
|
|
return H.TORTh(qI, qQ)
|
|
}
|
|
;
|
|
qM.AUWiF = function (qI, qQ) {
|
|
return H.TORTh(qI, qQ)
|
|
}
|
|
;
|
|
qM.VeyHR = function (qI, qQ) {
|
|
return qI > qQ
|
|
}
|
|
;
|
|
qM.UXzOL = function (qI, qQ) {
|
|
return H.PAXwW(qI, qQ)
|
|
}
|
|
;
|
|
qM.LFXnq = function (qI, qQ) {
|
|
return H.NhsVJ(qI, qQ)
|
|
}
|
|
;
|
|
qM.pHFsl = function (qI, qQ) {
|
|
return H.dhbZz(qI, qQ)
|
|
}
|
|
;
|
|
qM.GvCFC = function (qI, qQ, qS) {
|
|
return qI(qQ, qS)
|
|
}
|
|
;
|
|
qM.GCBSD = function (qI, qQ) {
|
|
return qI == qQ
|
|
}
|
|
;
|
|
qM.dTarM = H.wFepq;
|
|
qM.EizQG = function (qI, qQ) {
|
|
return H.KcLFs(qI, qQ)
|
|
}
|
|
;
|
|
qM.BLtSg = function (qI, qQ) {
|
|
return H.iXVgq(qI, qQ)
|
|
}
|
|
;
|
|
qM.BtKUH = function (qI, qQ) {
|
|
return H.YXBmi(qI, qQ)
|
|
}
|
|
;
|
|
qM.iwDvc = function (qI, qQ) {
|
|
return H.DWmHp(qI, qQ)
|
|
}
|
|
;
|
|
qM.iNnoD = function (qI, qQ) {
|
|
return H.RrUEC(qI, qQ)
|
|
}
|
|
;
|
|
qM.RknPm = function (qI, qQ) {
|
|
return H.EWeAz(qI, qQ)
|
|
}
|
|
;
|
|
var qK = qM;
|
|
continue;
|
|
case "5":
|
|
var qB = function (qI, qQ) {
|
|
var qS;
|
|
if (qK.GjFBv(this.s, 0)) {
|
|
qS = this.negate()
|
|
} else {
|
|
qS = this.clone()
|
|
}
|
|
var qg;
|
|
if (qK.AUWiF(qI.s, 0)) {
|
|
qg = qI.negate()
|
|
} else {
|
|
qg = qI.clone()
|
|
}
|
|
if (qS.compareTo(qg) < 0) {
|
|
var qP = qS;
|
|
qS = qg;
|
|
qg = qP
|
|
}
|
|
var qF = qS.getLowestSetBit();
|
|
var qW = qg.getLowestSetBit();
|
|
if (qK.VeyHR(0, qW))
|
|
return void qK.UXzOL(qQ, qS);
|
|
if (qW > qF) {
|
|
qW = qF
|
|
}
|
|
if (qK.LFXnq(qW, 0)) {
|
|
qS.rShiftTo(qW, qS);
|
|
qg.rShiftTo(qW, qg)
|
|
}
|
|
var qO = function () {
|
|
if ((qF = qS.getLowestSetBit()) > 0) {
|
|
qS.rShiftTo(qF, qS)
|
|
}
|
|
if (qK.KOnEX(qF = qg.getLowestSetBit(), 0)) {
|
|
qg.rShiftTo(qF, qg)
|
|
}
|
|
if (qK.WaqUq(qS.compareTo(qg), 0)) {
|
|
qS.subTo(qg, qS);
|
|
qS.rShiftTo(1, qS)
|
|
} else {
|
|
qg.subTo(qS, qg);
|
|
qg.rShiftTo(1, qg)
|
|
}
|
|
if (qS.signum() > 0) {
|
|
setTimeout(qO, 0)
|
|
} else {
|
|
qK.EtZyM(qW, 0) && qg.lShiftTo(qW, qg);
|
|
setTimeout(function () {
|
|
qQ(qg)
|
|
}, 0)
|
|
}
|
|
};
|
|
setTimeout(qO, 10)
|
|
};
|
|
continue;
|
|
case "6":
|
|
T3.prototype.fromNumberAsync = qU;
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
)();
|
|
var qx = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
var qH = "=";
|
|
var qZ = C.gcGDc(qZ, {});
|
|
qZ.env = qZ.env || {};
|
|
var qa = qZ;
|
|
var qX = Object.prototype;
|
|
var qy = "[object Function]";
|
|
var qi = [C.FVssu, "valueOf"];
|
|
qZ.env.parseUA = function (qJ) {
|
|
var qu = {};
|
|
qu.emMkL = function (qI, qQ) {
|
|
return T2.kJmRG(qI, qQ)
|
|
}
|
|
;
|
|
qu.xpUrY = function (qI, qQ) {
|
|
return T2.vjAam(qI, qQ)
|
|
}
|
|
;
|
|
var qb = qu;
|
|
var qU;
|
|
var qM = function (qI) {
|
|
var qQ = 0;
|
|
return qb.xpUrY(parseFloat, qI.replace(/\./g, function () {
|
|
return qb.emMkL(1, qQ++) ? "" : "."
|
|
}))
|
|
};
|
|
var qK = {};
|
|
var qB = {
|
|
"ie": 0,
|
|
"opera": 0,
|
|
"gecko": 0,
|
|
"webkit": 0,
|
|
"chrome": 0,
|
|
"mobile": null,
|
|
"air": 0,
|
|
"ipad": 0,
|
|
"iphone": 0,
|
|
"ipod": 0,
|
|
"ios": null,
|
|
"android": 0,
|
|
"webos": 0,
|
|
"caja": qK && undefined,
|
|
"secure": !1,
|
|
"os": null
|
|
};
|
|
return TL = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
|
|
TG = window && window,
|
|
TC = TG && TG.href,
|
|
(qB.secure = TC && T2.ebkcG(0, TC.toLowerCase().indexOf(T2.WLwRq)),
|
|
TL && (/windows|win32/i.test(TL) ? qB.os = T2.oxyQD : /macintosh/i.test(TL) ? qB.os = "macintosh" : /rhino/i.test(TL) && (qB.os = T2.EgOxI),
|
|
/KHTML/.test(TL) && (qB.webkit = 1),
|
|
qU = TL.match(/AppleWebKit\/([^\s]*)/),
|
|
qU && qU[1] && (qB.webkit = T2.vjAam(qM, qU[1]),
|
|
/ Mobile\//.test(TL) ? (qB.mobile = T2.ROSKQ,
|
|
qU = TL.match(/OS ([^\s]*)/),
|
|
qU && qU[1] && (qU = T2.hAfng(qM, qU[1].replace("_", "."))),
|
|
qB.ios = qU,
|
|
qB.ipad = qB.ipod = qB.iphone = 0,
|
|
qU = TL.match(/iPad|iPod|iPhone/),
|
|
qU && qU[0] && (qB[qU[0].toLowerCase()] = qB.ios)) : (qU = TL.match(/NokiaN[^\/]*|Android \d\.\d|webOS\/\d\.\d/),
|
|
qU && (qB.mobile = qU[0]),
|
|
/webOS/.test(TL) && (qB.mobile = T2.jzSzc,
|
|
qU = TL.match(/webOS\/([^\s]*);/),
|
|
qU && qU[1] && (qB.webos = T2.hAfng(qM, qU[1]))),
|
|
/ Android/.test(TL) && (qB.mobile = T2.BURkv,
|
|
qU = TL.match(/Android ([^\s]*);/),
|
|
qU && qU[1] && (qB.android = T2.hAfng(qM, qU[1])))),
|
|
qU = TL.match(/Chrome\/([^\s]*)/),
|
|
qU && qU[1] ? qB.chrome = T2.QhRxz(qM, qU[1]) : (qU = TL.match(/AdobeAIR\/([^\s]*)/),
|
|
qU && (qB.air = qU[0]))),
|
|
qB.webkit || (qU = TL.match(/Opera[\s\/]([^\s]*)/),
|
|
qU && qU[1] ? (qB.opera = T2.LUaiQ(qM, qU[1]),
|
|
qU = TL.match(/Version\/([^\s]*)/),
|
|
qU && qU[1] && (qB.opera = qM(qU[1])),
|
|
qU = TL.match(/Opera Mini[^;]*/),
|
|
qU && (qB.mobile = qU[0])) : (qU = TL.match(/MSIE\s([^;]*)/),
|
|
qU && qU[1] ? qB.ie = T2.LUaiQ(qM, qU[1]) : (qU = TL.match(/Gecko\/([^\s]*)/),
|
|
qU && (qB.gecko = 1,
|
|
qU = TL.match(/rv:([^\s\)]*)/),
|
|
qU && qU[1] && (qB.gecko = T2.JrOyR(qM, qU[1]))))))),
|
|
qB)
|
|
}
|
|
;
|
|
qZ.env.ua = qZ.env.parseUA();
|
|
qZ.isFunction = function (qJ) {
|
|
return T2.OTlRj == typeof qJ || qX.toString.apply(qJ) === qy
|
|
}
|
|
;
|
|
if (qZ.env.ua.ie) {
|
|
qZ._IEEnumFix = function (qJ, qu) {
|
|
var qb;
|
|
var qU;
|
|
var qM;
|
|
for (qb = 0; H.GCmaz(qb, qi.length); qb += 1) {
|
|
qU = qi[qb];
|
|
qM = qu[qU];
|
|
if (qa.isFunction(qM) && H.isEZE(qM, qX[qU])) {
|
|
qJ[qU] = qM
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
qZ._IEEnumFix = function () {
|
|
}
|
|
}
|
|
qZ.extend = function (qJ, qu, qb) {
|
|
if (H.GPhRM(!qu, !qJ))
|
|
throw new Error(H.Bjmam);
|
|
var qU;
|
|
var qM = function () {
|
|
};
|
|
if (qM.prototype = qu.prototype,
|
|
qJ.prototype = new qM,
|
|
qJ.prototype.constructor = qJ,
|
|
qJ.superclass = qu.prototype,
|
|
H.jbYqm(qu.prototype.constructor, qX.constructor) && (qu.prototype.constructor = qu),
|
|
qb) {
|
|
for (qU in qb)
|
|
if (qa.hasOwnProperty(qb, qU)) {
|
|
qJ.prototype[qU] = qb[qU]
|
|
}
|
|
qa._IEEnumFix(qJ.prototype, qb)
|
|
}
|
|
}
|
|
;
|
|
C.iBiID(C.denfQ, typeof KJUR) && KJUR || (KJUR = {});
|
|
C.tkrOw("undefined", typeof KJUR.asn1) && KJUR.asn1 || (KJUR.asn1 = {});
|
|
KJUR.asn1.ASN1Util = new function () {
|
|
var qJ = {};
|
|
qJ.FzHYF = T2.DPTrS;
|
|
qJ.NjdSl = function (qb, qU) {
|
|
return T2.gLEQE(qb, qU)
|
|
}
|
|
;
|
|
qJ.acGaC = function (qb, qU) {
|
|
return qb + qU
|
|
}
|
|
;
|
|
qJ.hCKLQ = function (qb, qU) {
|
|
return T2.gLEQE(qb, qU)
|
|
}
|
|
;
|
|
qJ.eseNC = T2.tgSnK;
|
|
var qu = qJ;
|
|
this.integerToByteHex = function (qb) {
|
|
var qU = qb.toString(16);
|
|
return T2.kJmRG(T2.jIQHr(qU.length, 2), 1) && (qU = T2.gLEQE("0", qU)),
|
|
qU
|
|
}
|
|
;
|
|
this.bigIntToMinTwosComplementsHex = function (qb) {
|
|
var qU = qb.toString(16);
|
|
if (T2.EbqzM("-", qU.substr(0, 1))) {
|
|
if (T2.kJmRG(T2.jIQHr(qU.length, 2), 1)) {
|
|
qU = T2.gLEQE("0", qU)
|
|
} else {
|
|
qU.match(/^[0-7]/) || (qU = T2.gLEQE("00", qU))
|
|
}
|
|
} else {
|
|
var qM = T2.vKTLy.split("|");
|
|
var qK = 0;
|
|
while (!![]) {
|
|
switch (qM[qK++]) {
|
|
case "0":
|
|
if (T2.kJmRG(T2.jIQHr(qS, 2), 1)) {
|
|
qS += 1
|
|
} else {
|
|
qU.match(/^[0-7]/) || (qS += 2)
|
|
}
|
|
continue;
|
|
case "1":
|
|
var qB = new T3(qg, 16);
|
|
var qI = qB.xor(qb).add(T3.ONE);
|
|
continue;
|
|
case "2":
|
|
qU = qI.toString(16).replace(/^-/, "");
|
|
continue;
|
|
case "3":
|
|
var qQ = qU.substr(1);
|
|
var qS = qQ.length;
|
|
continue;
|
|
case "4":
|
|
for (var qg = "", qP = 0; T2.KOjiH(qS, qP); qP++)
|
|
qg += "f";
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
return qU
|
|
}
|
|
;
|
|
this.getPEMStringFromHex = function (qb, qU) {
|
|
var qM = CryptoJS.enc.Hex.parse(qb);
|
|
var qK = CryptoJS.enc.Base64.stringify(qM);
|
|
var qB = qK.replace(/(.{64})/g, qu.FzHYF);
|
|
return qB = qB.replace(/\r\n$/, ""),
|
|
qu.NjdSl(qu.acGaC(qu.acGaC(qu.hCKLQ(qu.hCKLQ(qu.hCKLQ("-----BEGIN ", qU), "-----\r\n"), qB), qu.eseNC), qU), "-----\r\n")
|
|
}
|
|
}
|
|
;
|
|
KJUR.asn1.ASN1Object = function () {
|
|
var qJ = {};
|
|
qJ.AELnh = function (qU, qM) {
|
|
return T2.VhdMd(qU, qM)
|
|
}
|
|
;
|
|
qJ.ZKKuj = T2.qLktx;
|
|
qJ.hCgRp = function (qU, qM) {
|
|
return T2.oOQyf(qU, qM)
|
|
}
|
|
;
|
|
qJ.qzKvo = function (qU, qM) {
|
|
return T2.jIQHr(qU, qM)
|
|
}
|
|
;
|
|
qJ.IBBzo = function (qU, qM) {
|
|
return T2.KRmGu(qU, qM)
|
|
}
|
|
;
|
|
qJ.AKMrm = T2.cNiaP;
|
|
qJ.ZgykJ = T2.gXDNL;
|
|
qJ.TcEph = function (qU, qM) {
|
|
return T2.KRmGu(qU, qM)
|
|
}
|
|
;
|
|
qJ.Zmcly = function (qU, qM) {
|
|
return T2.aYExY(qU, qM)
|
|
}
|
|
;
|
|
qJ.BPYzr = function (qU, qM) {
|
|
return T2.KxaKN(qU, qM)
|
|
}
|
|
;
|
|
qJ.gnaHD = function (qU, qM) {
|
|
return T2.KRmGu(qU, qM)
|
|
}
|
|
;
|
|
qJ.pMWLN = T2.EXcIX;
|
|
qJ.poLLn = function (qU, qM) {
|
|
return qU + qM
|
|
}
|
|
;
|
|
qJ.pBSLz = function (qU, qM) {
|
|
return T2.anyCu(qU, qM)
|
|
}
|
|
;
|
|
var qu = qJ;
|
|
var qb = "";
|
|
this.getLengthHexFromValue = function () {
|
|
if (qu.AELnh(qu.ZKKuj, typeof this.hV) || qu.AELnh(null, this.hV))
|
|
throw "this.hV is null or undefined.";
|
|
if (qu.hCgRp(qu.qzKvo(this.hV.length, 2), 1))
|
|
throw qu.IBBzo(qu.IBBzo(qu.IBBzo(qu.AKMrm, qb.length), qu.ZgykJ), this.hV);
|
|
var qU = this.hV.length / 2;
|
|
var qM = qU.toString(16);
|
|
if (qu.hCgRp(qu.qzKvo(qM.length, 2), 1) && (qM = qu.TcEph("0", qM)),
|
|
qu.Zmcly(128, qU))
|
|
return qM;
|
|
var qK = qu.BPYzr(qM.length, 2);
|
|
if (qK > 15)
|
|
throw qu.gnaHD(qu.pMWLN, qU.toString(16));
|
|
var qB = qu.poLLn(128, qK);
|
|
return qu.pBSLz(qB.toString(16), qM)
|
|
}
|
|
;
|
|
this.getEncodedHex = function () {
|
|
return (T2.VhdMd(null, this.hTLV) || this.isModified) && (this.hV = this.getFreshValueHex(),
|
|
this.hL = this.getLengthHexFromValue(),
|
|
this.hTLV = T2.gLEQE(T2.KRmGu(this.hT, this.hL), this.hV),
|
|
this.isModified = !1),
|
|
this.hTLV
|
|
}
|
|
;
|
|
this.getValueHex = function () {
|
|
return this.getEncodedHex(),
|
|
this.hV
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return ""
|
|
}
|
|
}
|
|
;
|
|
KJUR.asn1.DERAbstractString = function (qJ) {
|
|
KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
|
|
this.getString = function () {
|
|
return this.s
|
|
}
|
|
;
|
|
this.setString = function (qu) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.s = qu;
|
|
this.hV = T2.JrOyR(stohex, this.s)
|
|
}
|
|
;
|
|
this.setStringHex = function (qu) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.s = null;
|
|
this.hV = qu
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return this.hV
|
|
}
|
|
;
|
|
if (T2.EbqzM(T2.qLktx, typeof qJ)) {
|
|
T2.gLhIW(T2.qLktx, typeof qJ.str) ? this.setString(qJ.str) : T2.uUvDs(T2.qLktx, typeof qJ.hex) && this.setStringHex(qJ.hex)
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERAbstractTime = function (qJ) {
|
|
var qu = {};
|
|
qu.frxJS = function (qU, qM) {
|
|
return qU == qM
|
|
}
|
|
;
|
|
qu.atLzd = function (qU, qM) {
|
|
return qU(qM)
|
|
}
|
|
;
|
|
qu.tvicD = function (qU, qM) {
|
|
return T2.vsSBk(qU, qM)
|
|
}
|
|
;
|
|
qu.IAlmS = function (qU, qM, qK) {
|
|
return T2.imffO(qU, qM, qK)
|
|
}
|
|
;
|
|
qu.YqlIk = function (qU, qM) {
|
|
return T2.JrOyR(qU, qM)
|
|
}
|
|
;
|
|
qu.IezUk = function (qU, qM) {
|
|
return T2.sTMUU(qU, qM)
|
|
}
|
|
;
|
|
qu.mjxOF = function (qU, qM) {
|
|
return T2.vsSBk(qU, qM)
|
|
}
|
|
;
|
|
qu.OWdsV = function (qU, qM) {
|
|
return T2.bMBIb(qU, qM)
|
|
}
|
|
;
|
|
var qb = qu;
|
|
KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);
|
|
this.localDateToUTC = function (qU) {
|
|
utc = T2.vsSBk(qU.getTime(), T2.zAlTw(60000, qU.getTimezoneOffset()));
|
|
var qM = new Date(utc);
|
|
return qM
|
|
}
|
|
;
|
|
this.formatDate = function (qU, qM) {
|
|
var qK = this.zeroPadding;
|
|
var qB = this.localDateToUTC(qU);
|
|
var qI = String(qB.getFullYear());
|
|
if (qb.frxJS("utc", qM)) {
|
|
qI = qI.substr(2, 2)
|
|
}
|
|
var qQ = qK(qb.atLzd(String, qb.tvicD(qB.getMonth(), 1)), 2);
|
|
var qS = qb.IAlmS(qK, qb.YqlIk(String, qB.getDate()), 2);
|
|
var qg = qb.IAlmS(qK, qb.YqlIk(String, qB.getHours()), 2);
|
|
var qP = qb.IAlmS(qK, qb.IezUk(String, qB.getMinutes()), 2);
|
|
var qF = qb.IAlmS(qK, String(qB.getSeconds()), 2);
|
|
return qb.tvicD(qb.mjxOF(qb.OWdsV(qb.OWdsV(qI, qQ) + qS + qg, qP), qF), "Z")
|
|
}
|
|
;
|
|
this.zeroPadding = function (qU, qM) {
|
|
return T2.SHEPk(qU.length, qM) ? qU : new Array(qM - qU.length + 1).join("0") + qU
|
|
}
|
|
;
|
|
this.getString = function () {
|
|
return this.s
|
|
}
|
|
;
|
|
this.setString = function (qU) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.s = qU;
|
|
this.hV = qb.IezUk(stohex, this.s)
|
|
}
|
|
;
|
|
this.setByDateValue = function (qU, qM, qK, qB, qI, qQ) {
|
|
var qS = new Date(Date.UTC(qU, T2.qnkiy(qM, 1), qK, qB, qI, qQ, 0));
|
|
this.setByDate(qS)
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return this.hV
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERAbstractStructured = function (qJ) {
|
|
KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
|
|
this.setByASN1ObjectArray = function (qu) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.asn1Array = qu
|
|
}
|
|
;
|
|
this.appendASN1Object = function (qu) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.asn1Array.push(qu)
|
|
}
|
|
;
|
|
this.asn1Array = new Array;
|
|
if (T2.jXKaK(T2.qLktx, typeof qJ) && T2.qLktx != typeof qJ.array) {
|
|
this.asn1Array = qJ.array
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERBoolean = function () {
|
|
KJUR.asn1.DERBoolean.superclass.constructor.call(this);
|
|
this.hT = "01";
|
|
this.hTLV = H.UYpYj
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERInteger = function (qJ) {
|
|
KJUR.asn1.DERInteger.superclass.constructor.call(this);
|
|
this.hT = "02";
|
|
this.setByBigInteger = function (qu) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(qu)
|
|
}
|
|
;
|
|
this.setByInteger = function (qu) {
|
|
var qb = new T3(String(qu), 10);
|
|
this.setByBigInteger(qb)
|
|
}
|
|
;
|
|
this.setValueHex = function (qu) {
|
|
this.hV = qu
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return this.hV
|
|
}
|
|
;
|
|
if (T2.jXKaK("undefined", typeof qJ)) {
|
|
T2.AIRGz(T2.qLktx, typeof qJ.bigint) ? this.setByBigInteger(qJ.bigint) : T2.aRTkn(T2.qLktx, typeof qJ[T2.gYITy]) ? this.setByInteger(qJ.int) : T2.sUYky(T2.qLktx, typeof qJ.hex) && this.setValueHex(qJ.hex)
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERBitString = function (qJ) {
|
|
var qu = {};
|
|
qu.rdBZP = function (qU, qM) {
|
|
return qU > qM
|
|
}
|
|
;
|
|
qu.kQDQk = function (qU, qM) {
|
|
return T2.bMBIb(qU, qM)
|
|
}
|
|
;
|
|
qu.GLKaS = T2.diCza;
|
|
qu.ZSfSM = function (qU, qM) {
|
|
return T2.lAICz(qU, qM)
|
|
}
|
|
;
|
|
qu.WuQHd = function (qU, qM) {
|
|
return T2.jLcKU(qU, qM)
|
|
}
|
|
;
|
|
qu.cxkWv = function (qU, qM) {
|
|
return T2.SHEPk(qU, qM)
|
|
}
|
|
;
|
|
qu.Ugorv = function (qU, qM) {
|
|
return T2.oCeXk(qU, qM)
|
|
}
|
|
;
|
|
qu.uoqTk = function (qU, qM, qK) {
|
|
return qU(qM, qK)
|
|
}
|
|
;
|
|
qu.ZZbkP = function (qU, qM) {
|
|
return qU + qM
|
|
}
|
|
;
|
|
var qb = qu;
|
|
KJUR.asn1.DERBitString.superclass.constructor.call(this);
|
|
this.hT = "03";
|
|
this.setHexValueIncludingUnusedBits = function (qU) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.hV = qU
|
|
}
|
|
;
|
|
this.setUnusedBitsAndHexValue = function (qU, qM) {
|
|
if (qb.rdBZP(0, qU) || qU > 7)
|
|
throw qb.kQDQk(qb.GLKaS, qU);
|
|
var qK = qb.kQDQk("0", qU);
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.hV = qb.kQDQk(qK, qM)
|
|
}
|
|
;
|
|
this.setByBinaryString = function (qU) {
|
|
qU = qU.replace(/0+$/, "");
|
|
var qM = qb.ZSfSM(8, qU.length % 8);
|
|
if (qb.WuQHd(8, qM)) {
|
|
qM = 0
|
|
}
|
|
for (var qK = 0; qb.cxkWv(qM, qK); qK++)
|
|
qU += "0";
|
|
for (var qB = "", qK = 0; qb.Ugorv(qK, qU.length - 1); qK += 8) {
|
|
var qI = qU.substr(qK, 8);
|
|
var qQ = qb.uoqTk(parseInt, qI, 2).toString(16);
|
|
if (1 == qQ.length) {
|
|
qQ = "0" + qQ
|
|
}
|
|
qB += qQ
|
|
}
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.hV = qb.kQDQk(qb.ZZbkP("0", qM), qB)
|
|
}
|
|
;
|
|
this.setByBooleanArray = function (qU) {
|
|
for (var qM = "", qK = 0; T2.oCeXk(qK, qU.length); qK++)
|
|
qM += 1 == qU[qK] ? "1" : "0";
|
|
this.setByBinaryString(qM)
|
|
}
|
|
;
|
|
this.newFalseArray = function (qU) {
|
|
for (var qM = new Array(qU), qK = 0; qb.rdBZP(qU, qK); qK++)
|
|
qM[qK] = !1;
|
|
return qM
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return this.hV
|
|
}
|
|
;
|
|
if (T2.BXgSn(T2.qLktx, typeof qJ)) {
|
|
T2.BXgSn(T2.qLktx, typeof qJ.hex) ? this.setHexValueIncludingUnusedBits(qJ.hex) : T2.BXgSn(T2.qLktx, typeof qJ.bin) ? this.setByBinaryString(qJ.bin) : "undefined" != typeof qJ.array && this.setByBooleanArray(qJ.array)
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DEROctetString = function (qJ) {
|
|
KJUR.asn1.DEROctetString.superclass.constructor.call(this, qJ);
|
|
this.hT = "04"
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);
|
|
KJUR.asn1.DERNull = function () {
|
|
KJUR.asn1.DERNull.superclass.constructor.call(this);
|
|
this.hT = "05";
|
|
this.hTLV = H.RBJIj
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERObjectIdentifier = function (qJ) {
|
|
var qu = {};
|
|
qu.FfVXW = function (qK, qB) {
|
|
return H.jbYqm(qK, qB)
|
|
}
|
|
;
|
|
qu.ERuzp = function (qK, qB) {
|
|
return H.vHCzi(qK, qB)
|
|
}
|
|
;
|
|
var qb = qu;
|
|
var qU = function (qK) {
|
|
var qB = qK.toString(16);
|
|
return qb.FfVXW(1, qB.length) && (qB = qb.ERuzp("0", qB)),
|
|
qB
|
|
};
|
|
var qM = function (qK) {
|
|
var qB = "";
|
|
var qI = new T3(qK, 10);
|
|
var qQ = qI.toString(2);
|
|
var qS = T2.GWEFb(7, qQ.length % 7);
|
|
if (T2.jLcKU(7, qS)) {
|
|
qS = 0
|
|
}
|
|
for (var qg = "", qP = 0; T2.aYExY(qS, qP); qP++)
|
|
qg += "0";
|
|
qQ = T2.CnSfa(qg, qQ);
|
|
for (var qP = 0; qP < T2.dVrrO(qQ.length, 1); qP += 7) {
|
|
var qF = qQ.substr(qP, 7);
|
|
if (T2.BXgSn(qP, T2.dVrrO(qQ.length, 7))) {
|
|
qF = T2.SyeZa("1", qF)
|
|
}
|
|
qB += T2.guGAk(qU, T2.imffO(parseInt, qF, 2))
|
|
}
|
|
return qB
|
|
};
|
|
KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);
|
|
this.hT = "06";
|
|
this.setValueHex = function (qK) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.s = null;
|
|
this.hV = qK
|
|
}
|
|
;
|
|
this.setValueOidString = function (qK) {
|
|
if (!qK.match(/^[0-9.]+$/))
|
|
throw T2.SyeZa(T2.LUbwa, qK);
|
|
var qB = "";
|
|
var qI = qK.split(".");
|
|
var qQ = T2.OdwOJ(40 * parseInt(qI[0]), T2.LtucB(parseInt, qI[1]));
|
|
qB += T2.LtucB(qU, qQ);
|
|
qI.splice(0, 2);
|
|
for (var qS = 0; T2.JVkOh(qS, qI.length); qS++)
|
|
qB += T2.LtucB(qM, qI[qS]);
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.s = null;
|
|
this.hV = qB
|
|
}
|
|
;
|
|
this.setValueName = function (qK) {
|
|
if (T2.ehATV(T2.qLktx, typeof KJUR.asn1.x509.OID.name2oidList[qK]))
|
|
throw T2.OdwOJ(T2.xfCxM, qK);
|
|
var qB = KJUR.asn1.x509.OID.name2oidList[qK];
|
|
this.setValueOidString(qB)
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return this.hV
|
|
}
|
|
;
|
|
if (H.GJtmq(H.iIkiv, typeof qJ)) {
|
|
"undefined" != typeof qJ.oid ? this.setValueOidString(qJ.oid) : H.iIkiv != typeof qJ.hex ? this.setValueHex(qJ.hex) : H.GJtmq(H.iIkiv, typeof qJ.name) && this.setValueName(qJ.name)
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);
|
|
KJUR.asn1.DERUTF8String = function (qJ) {
|
|
KJUR.asn1.DERUTF8String.superclass.constructor.call(this, qJ);
|
|
this.hT = "0c"
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);
|
|
KJUR.asn1.DERNumericString = function (qJ) {
|
|
KJUR.asn1.DERNumericString.superclass.constructor.call(this, qJ);
|
|
this.hT = "12"
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);
|
|
KJUR.asn1.DERPrintableString = function (qJ) {
|
|
KJUR.asn1.DERPrintableString.superclass.constructor.call(this, qJ);
|
|
this.hT = "13"
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);
|
|
KJUR.asn1.DERTeletexString = function (qJ) {
|
|
KJUR.asn1.DERTeletexString.superclass.constructor.call(this, qJ);
|
|
this.hT = "14"
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);
|
|
KJUR.asn1.DERIA5String = function (qJ) {
|
|
KJUR.asn1.DERIA5String.superclass.constructor.call(this, qJ);
|
|
this.hT = "16"
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);
|
|
KJUR.asn1.DERUTCTime = function (qJ) {
|
|
KJUR.asn1.DERUTCTime.superclass.constructor.call(this, qJ);
|
|
this.hT = "17";
|
|
this.setByDate = function (qu) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.date = qu;
|
|
this.s = this.formatDate(this.date, T2.OaYYR);
|
|
this.hV = T2.XfCnp(stohex, this.s)
|
|
}
|
|
;
|
|
if (T2.YskHK(T2.qLktx, typeof qJ)) {
|
|
T2.dJxVR("undefined", typeof qJ.str) ? this.setString(qJ.str) : T2.dJxVR("undefined", typeof qJ.hex) ? this.setStringHex(qJ.hex) : T2.bsVxt(T2.qLktx, typeof qJ.date) && this.setByDate(qJ.date)
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);
|
|
KJUR.asn1.DERGeneralizedTime = function (qJ) {
|
|
var qu = {};
|
|
qu.JGtfe = function (qU, qM) {
|
|
return qU(qM)
|
|
}
|
|
;
|
|
var qb = qu;
|
|
KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, qJ);
|
|
this.hT = "18";
|
|
this.setByDate = function (qU) {
|
|
this.hTLV = null;
|
|
this.isModified = !0;
|
|
this.date = qU;
|
|
this.s = this.formatDate(this.date, "gen");
|
|
this.hV = qb.JGtfe(stohex, this.s)
|
|
}
|
|
;
|
|
if (T2.FkMng(T2.qLktx, typeof qJ)) {
|
|
T2.FkMng("undefined", typeof qJ.str) ? this.setString(qJ.str) : T2.qLktx != typeof qJ.hex ? this.setStringHex(qJ.hex) : T2.FkMng("undefined", typeof qJ.date) && this.setByDate(qJ.date)
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);
|
|
KJUR.asn1.DERSequence = function (qJ) {
|
|
KJUR.asn1.DERSequence.superclass.constructor.call(this, qJ);
|
|
this.hT = "30";
|
|
this.getFreshValueHex = function () {
|
|
for (var qu = "", qb = 0; T2.JVkOh(qb, this.asn1Array.length); qb++) {
|
|
var qU = this.asn1Array[qb];
|
|
qu += qU.getEncodedHex()
|
|
}
|
|
return this.hV = qu,
|
|
this.hV
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);
|
|
KJUR.asn1.DERSet = function (qJ) {
|
|
KJUR.asn1.DERSet.superclass.constructor.call(this, qJ);
|
|
this.hT = "31";
|
|
this.getFreshValueHex = function () {
|
|
for (var qu = new Array, qb = 0; qb < this.asn1Array.length; qb++) {
|
|
var qU = this.asn1Array[qb];
|
|
qu.push(qU.getEncodedHex())
|
|
}
|
|
return qu.sort(),
|
|
this.hV = qu.join(""),
|
|
this.hV
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);
|
|
KJUR.asn1.DERTaggedObject = function (qJ) {
|
|
KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);
|
|
this.hT = "a0";
|
|
this.hV = "";
|
|
this.isExplicit = !0;
|
|
this.asn1Object = null;
|
|
this.setASN1Object = function (qu, qb, qU) {
|
|
this.hT = qb;
|
|
this.isExplicit = qu;
|
|
this.asn1Object = qU;
|
|
if (this.isExplicit) {
|
|
this.hV = this.asn1Object.getEncodedHex();
|
|
this.hTLV = null;
|
|
this.isModified = !0
|
|
} else {
|
|
this.hV = null;
|
|
this.hTLV = qU.getEncodedHex();
|
|
this.hTLV = this.hTLV.replace(/^../, qb);
|
|
this.isModified = !1
|
|
}
|
|
}
|
|
;
|
|
this.getFreshValueHex = function () {
|
|
return this.hV
|
|
}
|
|
;
|
|
if (H.UyaUB(H.iIkiv, typeof qJ)) {
|
|
H.zZyNj(H.iIkiv, typeof qJ.tag) && (this.hT = qJ.tag);
|
|
H.zZyNj("undefined", typeof qJ.explicit) && (this.isExplicit = qJ.explicit);
|
|
H.DKMMb(H.iIkiv, typeof qJ.obj) && (this.asn1Object = qJ.obj,
|
|
this.setASN1Object(this.isExplicit, this.hT, this.asn1Object))
|
|
}
|
|
}
|
|
;
|
|
qZ.extend(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);
|
|
(function (qJ) {
|
|
var qu = {};
|
|
qu.JRgGP = function (qK, qB) {
|
|
return H.stHpC(qK, qB)
|
|
}
|
|
;
|
|
qu.SHNjV = function (qK, qB) {
|
|
return H.KccZJ(qK, qB)
|
|
}
|
|
;
|
|
qu.sMOea = function (qK, qB) {
|
|
return qK == qB
|
|
}
|
|
;
|
|
qu.lkCQn = function (qK, qB) {
|
|
return H.MzTCG(qK, qB)
|
|
}
|
|
;
|
|
qu.VZifI = H.DyTvf;
|
|
qu.tJODa = function (qK, qB) {
|
|
return qK >= qB
|
|
}
|
|
;
|
|
var qb = qu;
|
|
"use strict";
|
|
var qU;
|
|
var qM = {};
|
|
qM.decode = function (qK) {
|
|
var qB;
|
|
if (qb.JRgGP(qU, qJ)) {
|
|
var qI = "0123456789ABCDEF";
|
|
var qQ = " \f\n\r \xA0\u2028\u2029";
|
|
for (qU = [],
|
|
qB = 0; qb.SHNjV(16, qB); ++qB)
|
|
qU[qI.charAt(qB)] = qB;
|
|
for (qI = qI.toLowerCase(),
|
|
qB = 10; 16 > qB; ++qB)
|
|
qU[qI.charAt(qB)] = qB;
|
|
for (qB = 0; qB < qQ.length; ++qB)
|
|
qU[qQ.charAt(qB)] = -1
|
|
}
|
|
var qS = [];
|
|
var qg = 0;
|
|
var qP = 0;
|
|
for (qB = 0; qB < qK.length; ++qB) {
|
|
var qF = qK.charAt(qB);
|
|
if (qb.sMOea("=", qF))
|
|
break;
|
|
if (qF = qU[qF],
|
|
-1 != qF) {
|
|
if (qb.JRgGP(qF, qJ))
|
|
throw qb.lkCQn(qb.VZifI, qB);
|
|
qg |= qF;
|
|
if (qb.tJODa(++qP, 2)) {
|
|
qS[qS.length] = qg;
|
|
qg = 0;
|
|
qP = 0
|
|
} else {
|
|
qg <<= 4
|
|
}
|
|
}
|
|
}
|
|
if (qP)
|
|
throw "Hex encoding incomplete: 4 bits missing";
|
|
return qS
|
|
}
|
|
;
|
|
window.Hex = qM
|
|
}
|
|
)();
|
|
(function (qJ) {
|
|
var qu = {};
|
|
qu.NbAnG = function (qK, qB) {
|
|
return T2.rlFsN(qK, qB)
|
|
}
|
|
;
|
|
qu.cGGlc = function (qK, qB) {
|
|
return T2.ehATV(qK, qB)
|
|
}
|
|
;
|
|
qu.oayvU = function (qK, qB) {
|
|
return T2.YasRU(qK, qB)
|
|
}
|
|
;
|
|
qu.cTIyb = function (qK, qB) {
|
|
return qK === qB
|
|
}
|
|
;
|
|
qu.XOvAo = function (qK, qB) {
|
|
return qK + qB
|
|
}
|
|
;
|
|
qu.sgnmk = T2.kjPMZ;
|
|
qu.SHANH = function (qK, qB) {
|
|
return T2.SHEPk(qK, qB)
|
|
}
|
|
;
|
|
qu.oGefE = function (qK, qB) {
|
|
return T2.tloob(qK, qB)
|
|
}
|
|
;
|
|
qu.XPnFc = function (qK, qB) {
|
|
return T2.sHwBJ(qK, qB)
|
|
}
|
|
;
|
|
qu.YvcLI = "Base64 encoding incomplete: at least 2 bits missing";
|
|
qu.wfcZl = function (qK, qB) {
|
|
return T2.elNji(qK, qB)
|
|
}
|
|
;
|
|
qu.pDAla = function (qK, qB) {
|
|
return T2.aTNji(qK, qB)
|
|
}
|
|
;
|
|
var qb = qu;
|
|
"use strict";
|
|
var qU;
|
|
var qM = {};
|
|
qM.decode = function (qK) {
|
|
var qB;
|
|
if (qU === qJ) {
|
|
var qI = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
var qQ = "= \f\n\r \xA0\u2028\u2029";
|
|
for (qU = [],
|
|
qB = 0; qb.NbAnG(64, qB); ++qB)
|
|
qU[qI.charAt(qB)] = qB;
|
|
for (qB = 0; qB < qQ.length; ++qB)
|
|
qU[qQ.charAt(qB)] = -1
|
|
}
|
|
var qS = [];
|
|
var qg = 0;
|
|
var qP = 0;
|
|
for (qB = 0; qB < qK.length; ++qB) {
|
|
var qF = qK.charAt(qB);
|
|
if (qb.cGGlc("=", qF))
|
|
break;
|
|
if (qF = qU[qF],
|
|
qb.oayvU(-1, qF)) {
|
|
if (qb.cTIyb(qF, qJ))
|
|
throw qb.XOvAo(qb.sgnmk, qB);
|
|
qg |= qF;
|
|
if (qb.SHANH(++qP, 4)) {
|
|
qS[qS.length] = qb.oGefE(qg, 16);
|
|
qS[qS.length] = qb.oGefE(qg, 8) & 255;
|
|
qS[qS.length] = qb.XPnFc(255, qg);
|
|
qg = 0;
|
|
qP = 0
|
|
} else {
|
|
qg <<= 6
|
|
}
|
|
}
|
|
}
|
|
switch (qP) {
|
|
case 1:
|
|
throw qb.YvcLI;
|
|
case 2:
|
|
qS[qS.length] = qb.wfcZl(qg, 10);
|
|
break;
|
|
case 3:
|
|
qS[qS.length] = qb.pDAla(qg, 16);
|
|
qS[qS.length] = qb.XPnFc(qg >> 8, 255);
|
|
}
|
|
return qS
|
|
}
|
|
;
|
|
qM.re = /-----BEGIN [^-]+-----([A-Za-z0-9+\/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+\/=\s]+)====/;
|
|
qM.unarmor = function (qK) {
|
|
var qB = qM.re.exec(qK);
|
|
if (qB) {
|
|
if (qB[1])
|
|
qK = qB[1];
|
|
else {
|
|
if (!qB[2])
|
|
throw T2.PRnQA;
|
|
qK = qB[2]
|
|
}
|
|
}
|
|
return qM.decode(qK)
|
|
}
|
|
;
|
|
window.Base64 = qM
|
|
}
|
|
)();
|
|
(function (qJ) {
|
|
var qu = {};
|
|
qu.mgCea = function (qS, qg) {
|
|
return H.unSVS(qS, qg)
|
|
}
|
|
;
|
|
qu.WOmNO = function (qS, qg) {
|
|
return qS >= qg
|
|
}
|
|
;
|
|
qu.pKdWo = function (qS, qg) {
|
|
return H.MzTCG(qS, qg)
|
|
}
|
|
;
|
|
qu.aWENs = function (qS, qg) {
|
|
return H.ZGGFY(qS, qg)
|
|
}
|
|
;
|
|
qu.BreXn = H.UonDO;
|
|
qu.FjDSm = function (qS, qg) {
|
|
return H.eakbC(qS, qg)
|
|
}
|
|
;
|
|
qu.pmboh = function (qS, qg) {
|
|
return H.KccZJ(qS, qg)
|
|
}
|
|
;
|
|
qu.HTWfe = function (qS, qg) {
|
|
return H.advyF(qS, qg)
|
|
}
|
|
;
|
|
qu.JpIaa = function (qS, qg) {
|
|
return H.JOrPO(qS, qg)
|
|
}
|
|
;
|
|
qu.hGmmf = function (qS, qg) {
|
|
return H.JOrPO(qS, qg)
|
|
}
|
|
;
|
|
qu.FYbAU = H.zUJtu;
|
|
qu.gUQwh = function (qS, qg) {
|
|
return H.DKMMb(qS, qg)
|
|
}
|
|
;
|
|
qu.CBSom = function (qS, qg) {
|
|
return H.PnrqC(qS, qg)
|
|
}
|
|
;
|
|
qu.zHtQa = "Unrecognized time: ";
|
|
qu.yLDKy = function (qS, qg) {
|
|
return qS - qg
|
|
}
|
|
;
|
|
qu.KTSYt = function (qS, qg) {
|
|
return H.rinhL(qS, qg)
|
|
}
|
|
;
|
|
qu.tTgTR = H.zoGLP;
|
|
qu.BDBcf = function (qS, qg) {
|
|
return H.lTSdm(qS, qg)
|
|
}
|
|
;
|
|
qu.zQUKK = function (qS, qg) {
|
|
return qS - qg
|
|
}
|
|
;
|
|
qu.JPBuf = function (qS, qg) {
|
|
return qS + qg
|
|
}
|
|
;
|
|
qu.bciYM = function (qS, qg) {
|
|
return H.jPTuq(qS, qg)
|
|
}
|
|
;
|
|
qu.HmtFa = function (qS, qg) {
|
|
return H.lTSdm(qS, qg)
|
|
}
|
|
;
|
|
qu.pEWNT = function (qS, qg) {
|
|
return H.YXBmi(qS, qg)
|
|
}
|
|
;
|
|
qu.ksuWe = function (qS, qg) {
|
|
return qS | qg
|
|
}
|
|
;
|
|
qu.NnfgM = function (qS, qg) {
|
|
return H.iXVgq(qS, qg)
|
|
}
|
|
;
|
|
qu.qsnzq = function (qS, qg) {
|
|
return H.rinhL(qS, qg)
|
|
}
|
|
;
|
|
qu.cAQiD = function (qS, qg) {
|
|
return qS * qg
|
|
}
|
|
;
|
|
qu.GEhPH = H.qWuth;
|
|
qu.ptwjU = function (qS, qg) {
|
|
return qS + qg
|
|
}
|
|
;
|
|
qu.mHYky = function (qS, qg) {
|
|
return H.PnrqC(qS, qg)
|
|
}
|
|
;
|
|
qu.VlWHf = H.XifDc;
|
|
qu.rGidL = function (qS, qg) {
|
|
return H.DKMMb(qS, qg)
|
|
}
|
|
;
|
|
qu.nRbBv = function (qS, qg) {
|
|
return qS == qg
|
|
}
|
|
;
|
|
qu.WopGP = H.FfvlX;
|
|
qu.QaHVJ = H.GbWHP;
|
|
qu.CLTiC = H.epwKW;
|
|
qu.RmNpi = H.wBJFK;
|
|
qu.NMDpM = function (qS, qg) {
|
|
return H.eakbC(qS, qg)
|
|
}
|
|
;
|
|
qu.hVNjK = function (qS, qg) {
|
|
return H.OuxAf(qS, qg)
|
|
}
|
|
;
|
|
qu.zGcUp = H.EfMxW;
|
|
qu.hyjUb = H.NlyKZ;
|
|
qu.BwDrC = "value";
|
|
qu.uMFSF = function (qS, qg) {
|
|
return H.PnrqC(qS, qg)
|
|
}
|
|
;
|
|
qu.TsvwU = "Offset: ";
|
|
qu.cbdKn = H.qaLOF;
|
|
qu.zfBSQ = function (qS, qg) {
|
|
return qS + qg
|
|
}
|
|
;
|
|
qu.enAVD = function (qS, qg) {
|
|
return qS + qg
|
|
}
|
|
;
|
|
qu.RWFmy = function (qS, qg) {
|
|
return H.iXVgq(qS, qg)
|
|
}
|
|
;
|
|
qu.jAEeL = function (qS, qg) {
|
|
return qS != qg
|
|
}
|
|
;
|
|
qu.QgEpD = function (qS, qg) {
|
|
return H.DKMMb(qS, qg)
|
|
}
|
|
;
|
|
qu.nYxji = H.vhLHD;
|
|
qu.LSUnc = function (qS, qg) {
|
|
return H.CUOCI(qS, qg)
|
|
}
|
|
;
|
|
qu.ZHVOH = H.aupVO;
|
|
qu.npjam = H.vznqn;
|
|
qu.bJMBO = "object";
|
|
qu.XXclD = H.hqnlL;
|
|
qu.ysQAs = function (qS, qg) {
|
|
return qS !== qg
|
|
}
|
|
;
|
|
qu.oAJsW = function (qS, qg) {
|
|
return H.lTSdm(qS, qg)
|
|
}
|
|
;
|
|
qu.BMSzC = function (qS, qg) {
|
|
return H.NOYau(qS, qg)
|
|
}
|
|
;
|
|
qu.MTqPG = H.xDGRv;
|
|
qu.WEHVe = function (qS, qg) {
|
|
return H.jPTuq(qS, qg)
|
|
}
|
|
;
|
|
qu.Jjfxq = "hex";
|
|
qu.pCzRr = function (qS, qg) {
|
|
return H.iCuDU(qS, qg)
|
|
}
|
|
;
|
|
qu.iZnow = function (qS, qg) {
|
|
return H.rinhL(qS, qg)
|
|
}
|
|
;
|
|
qu.PMvog = H.berdN;
|
|
qu.joLPM = function (qS, qg) {
|
|
return H.AOhkt(qS, qg)
|
|
}
|
|
;
|
|
qu.QTVKQ = H.MVSyP;
|
|
qu.rBXeG = function (qS, qg) {
|
|
return qS === qg
|
|
}
|
|
;
|
|
qu.TiEWW = H.snFmI;
|
|
qu.ckIgK = function (qS, qg) {
|
|
return H.EhZeV(qS, qg)
|
|
}
|
|
;
|
|
qu.tBaWf = function (qS, qg) {
|
|
return H.UuKZy(qS, qg)
|
|
}
|
|
;
|
|
qu.qXIFd = function (qS, qg) {
|
|
return H.LQoGs(qS, qg)
|
|
}
|
|
;
|
|
qu.hnAAo = H.FosgW;
|
|
qu.QybuI = function (qS, qg) {
|
|
return H.HESbY(qS, qg)
|
|
}
|
|
;
|
|
qu.HGMeV = function (qS, qg) {
|
|
return qS > qg
|
|
}
|
|
;
|
|
qu.AEkFR = function (qS, qg) {
|
|
return qS > qg
|
|
}
|
|
;
|
|
qu.zKpkk = function (qS, qg) {
|
|
return H.Pzuze(qS, qg)
|
|
}
|
|
;
|
|
qu.FPXSI = function (qS, qg) {
|
|
return H.LQoGs(qS, qg)
|
|
}
|
|
;
|
|
qu.bxNEE = function (qS, qg) {
|
|
return qS >> qg
|
|
}
|
|
;
|
|
qu.oJDpU = function (qS, qg) {
|
|
return H.yZewf(qS, qg)
|
|
}
|
|
;
|
|
qu.iAdTj = function (qS, qg) {
|
|
return H.jPTuq(qS, qg)
|
|
}
|
|
;
|
|
qu.lIqWN = function (qS, qg) {
|
|
return qS + qg
|
|
}
|
|
;
|
|
qu.WKxgP = function (qS, qg) {
|
|
return H.DKMMb(qS, qg)
|
|
}
|
|
;
|
|
qu.EmcAR = function (qS, qg) {
|
|
return qS === qg
|
|
}
|
|
;
|
|
qu.AQLGQ = function (qS, qg) {
|
|
return H.fCBAn(qS, qg)
|
|
}
|
|
;
|
|
qu.UAHRr = function (qS, qg) {
|
|
return H.WPQMA(qS, qg)
|
|
}
|
|
;
|
|
var qb = qu;
|
|
"use strict";
|
|
|
|
function qU(qS, qg) {
|
|
if (qb.mgCea(qS, qU)) {
|
|
this.enc = qS.enc;
|
|
this.pos = qS.pos
|
|
} else {
|
|
this.enc = qS;
|
|
this.pos = qg
|
|
}
|
|
}
|
|
|
|
function qM(qS, qg, qP, qF, qW) {
|
|
this.stream = qS;
|
|
this.header = qg;
|
|
this.length = qP;
|
|
this.tag = qF;
|
|
this.sub = qW
|
|
}
|
|
|
|
var qK = {};
|
|
qK.tag = function (qS, qg) {
|
|
}
|
|
;
|
|
qK.text = function (qS) {
|
|
}
|
|
;
|
|
var qB = 100;
|
|
var qI = "\u2026";
|
|
var qQ = qK;
|
|
qU.prototype.get = function (qS) {
|
|
if (qS === qJ && (qS = this.pos++),
|
|
qb.WOmNO(qS, this.enc.length))
|
|
throw qb.pKdWo(qb.aWENs(qb.BreXn + qS, " on a stream of length "), this.enc.length);
|
|
return this.enc[qS]
|
|
}
|
|
;
|
|
qU.prototype.hexDigits = H.SoBOg;
|
|
qU.prototype.hexByte = function (qS) {
|
|
return this.hexDigits.charAt(T2.sHwBJ(T2.sbNiu(qS, 4), 15)) + this.hexDigits.charAt(T2.qlGPr(15, qS))
|
|
}
|
|
;
|
|
qU.prototype.hexDump = function (qS, qg, qP) {
|
|
for (var qF = "", qW = qS; qg > qW; ++qW)
|
|
if (qF += this.hexByte(this.get(qW)),
|
|
qb.FjDSm(qP, !0))
|
|
switch (15 & qW) {
|
|
case 7:
|
|
qF += " ";
|
|
break;
|
|
case 15:
|
|
qF += "\n";
|
|
break;
|
|
default:
|
|
qF += " ";
|
|
}
|
|
return qF
|
|
}
|
|
;
|
|
qU.prototype.parseStringISO = function (qS, qg) {
|
|
for (var qP = "", qF = qS; qg > qF; ++qF)
|
|
qP += String.fromCharCode(this.get(qF));
|
|
return qP
|
|
}
|
|
;
|
|
qU.prototype.parseStringUTF = function (qS, qg) {
|
|
for (var qP = "", qF = qS; qg > qF;) {
|
|
var qW = this.get(qF++);
|
|
qP += T2.YBWLK(128, qW) ? String.fromCharCode(qW) : T2.YBWLK(qW, 191) && T2.PtKFg(224, qW) ? String.fromCharCode(T2.kRNfk((31 & qW) << 6, T2.qlGPr(63, this.get(qF++)))) : String.fromCharCode(T2.ldeug(T2.qlGPr(15, qW), 12) | T2.ldeug(T2.ckIZU(63, this.get(qF++)), 6) | T2.oQlmj(63, this.get(qF++)))
|
|
}
|
|
return qP
|
|
}
|
|
;
|
|
qU.prototype.parseStringBMP = function (qS, qg) {
|
|
for (var qP = "", qF = qS; qb.pmboh(qg, qF); qF += 2) {
|
|
var qW = this.get(qF);
|
|
var qO = this.get(qF + 1);
|
|
qP += String.fromCharCode(qb.aWENs(qb.HTWfe(qW, 8), qO))
|
|
}
|
|
return qP
|
|
}
|
|
;
|
|
qU.prototype.reTime = /^((?:1[89]|2\d)?\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
|
|
qU.prototype.parseTime = function (qS, qg) {
|
|
var qP = this.parseStringISO(qS, qg);
|
|
var qF = this.reTime.exec(qP);
|
|
return qF ? (qP = qb.aWENs(qb.JpIaa(qb.JpIaa(qb.JpIaa(qb.JpIaa(qF[1], "-"), qF[2]), "-"), qF[3]) + " ", qF[4]),
|
|
qF[5] && (qP += qb.JpIaa(":", qF[5]),
|
|
qF[6] && (qP += qb.hGmmf(":", qF[6]),
|
|
qF[7] && (qP += qb.hGmmf(".", qF[7])))),
|
|
qF[8] && (qP += qb.FYbAU,
|
|
qb.gUQwh("Z", qF[8]) && (qP += qF[8],
|
|
qF[9] && (qP += qb.CBSom(":", qF[9])))),
|
|
qP) : qb.zHtQa + qP
|
|
}
|
|
;
|
|
qU.prototype.parseInteger = function (qS, qg) {
|
|
var qP = qb.yLDKy(qg, qS);
|
|
if (qb.pmboh(qP, 4)) {
|
|
qP <<= 3;
|
|
var qF = this.get(qS);
|
|
if (qb.KTSYt(0, qF))
|
|
qP -= 8;
|
|
else
|
|
for (; 128 > qF;) {
|
|
qF <<= 1;
|
|
--qP
|
|
}
|
|
return qb.CBSom(qb.CBSom("(", qP), qb.tTgTR)
|
|
}
|
|
for (var qW = 0, qO = qS; qb.BDBcf(qg, qO); ++qO)
|
|
qW = qW << 8 | this.get(qO);
|
|
return qW
|
|
}
|
|
;
|
|
qU.prototype.parseBitString = function (qS, qg) {
|
|
var qP = this.get(qS);
|
|
var qF = qb.HTWfe(qb.zQUKK(qg - qS, 1), 3) - qP;
|
|
var qW = qb.CBSom(qb.JPBuf("(", qF), qb.tTgTR);
|
|
if (qb.bciYM(20, qF)) {
|
|
var qO = qP;
|
|
qW += " ";
|
|
for (var qj = qg - 1; qb.HmtFa(qj, qS); --qj) {
|
|
for (var qs = this.get(qj), qc = qO; 8 > qc; ++qc)
|
|
qW += qb.pEWNT(qs, qc) & 1 ? "1" : "0";
|
|
qO = 0
|
|
}
|
|
}
|
|
return qW
|
|
}
|
|
;
|
|
qU.prototype.parseOctetString = function (qS, qg) {
|
|
var qP = T2.dVrrO(qg, qS);
|
|
var qF = T2.CCXAv(T2.CCXAv("(", qP), T2.hcfGL);
|
|
if (T2.PtKFg(qP, qB)) {
|
|
qg = T2.inTUD(qS, qB)
|
|
}
|
|
for (var qW = qS; T2.RoaCq(qg, qW); ++qW)
|
|
qF += this.hexByte(this.get(qW));
|
|
return T2.jcbeP(qP, qB) && (qF += qI),
|
|
qF
|
|
}
|
|
;
|
|
qU.prototype.parseOID = function (qS, qg) {
|
|
for (var qP = "", qF = 0, qW = 0, qO = qS; qb.HmtFa(qg, qO); ++qO) {
|
|
var qj = this.get(qO);
|
|
if (qF = qb.ksuWe(qb.HTWfe(qF, 7), 127 & qj),
|
|
qW += 7,
|
|
!qb.NnfgM(128, qj)) {
|
|
if (qb.qsnzq("", qP)) {
|
|
var qs;
|
|
if (80 > qF) {
|
|
if (40 > qF) {
|
|
qs = 0
|
|
} else {
|
|
qs = 1
|
|
}
|
|
} else {
|
|
qs = 2
|
|
}
|
|
qP = qb.JPBuf(qb.JPBuf(qs, "."), qF - qb.cAQiD(40, qs))
|
|
} else
|
|
qP += qb.JPBuf(".", qb.bciYM(qW, 31) ? qb.GEhPH : qF);
|
|
qF = qW = 0
|
|
}
|
|
}
|
|
return qP
|
|
}
|
|
;
|
|
qM.prototype.typeName = function () {
|
|
if (T2.ebkcG(this.tag, qJ))
|
|
return T2.fMRxO;
|
|
var qS = T2.sbNiu(this.tag, 6);
|
|
var qg = (T2.sbNiu(this.tag, 5) & 1,
|
|
T2.uASxf(31, this.tag));
|
|
switch (qS) {
|
|
case 0:
|
|
switch (qg) {
|
|
case 0:
|
|
return T2.WhdEd;
|
|
case 1:
|
|
return "BOOLEAN";
|
|
case 2:
|
|
return T2.tNFcM;
|
|
case 3:
|
|
return "BIT_STRING";
|
|
case 4:
|
|
return T2.MEzWB;
|
|
case 5:
|
|
return "NULL";
|
|
case 6:
|
|
return T2.AphMF;
|
|
case 7:
|
|
return T2.BGpsQ;
|
|
case 8:
|
|
return T2.cOZjq;
|
|
case 9:
|
|
return T2.LvbPp;
|
|
case 10:
|
|
return T2.nUvol;
|
|
case 11:
|
|
return T2.crfvk;
|
|
case 12:
|
|
return "UTF8String";
|
|
case 16:
|
|
return T2.CSDrx;
|
|
case 17:
|
|
return T2.JAjiK;
|
|
case 18:
|
|
return T2.aVwQP;
|
|
case 19:
|
|
return T2.WiAGY;
|
|
case 20:
|
|
return T2.MzwLL;
|
|
case 21:
|
|
return T2.tadqZ;
|
|
case 22:
|
|
return T2.rjPxS;
|
|
case 23:
|
|
return T2.ezopV;
|
|
case 24:
|
|
return T2.ZFdJS;
|
|
case 25:
|
|
return "GraphicString";
|
|
case 26:
|
|
return T2.ckWVT;
|
|
case 27:
|
|
return T2.KrVFq;
|
|
case 28:
|
|
return T2.jrfjB;
|
|
case 30:
|
|
return T2.fccoR;
|
|
default:
|
|
return T2.Qybau(T2.jRCpT, qg.toString(16));
|
|
}
|
|
case 1:
|
|
return T2.DIVWO(T2.aLdPr, qg.toString(16));
|
|
case 2:
|
|
return T2.NFnPg(T2.NFnPg("[", qg), "]");
|
|
case 3:
|
|
return T2.gIrFA + qg.toString(16);
|
|
}
|
|
}
|
|
;
|
|
qM.prototype.reSeemsASCII = /^[ -~]+$/;
|
|
qM.prototype.content = function () {
|
|
var qS = T2.FjwjR.split("|");
|
|
var qg = 0;
|
|
while (!![]) {
|
|
switch (qS[qg++]) {
|
|
case "0":
|
|
if (T2.EnxJX(this.tag, qJ))
|
|
return null;
|
|
continue;
|
|
case "1":
|
|
switch (qF) {
|
|
case 1:
|
|
return T2.EnxJX(0, this.stream.get(qW)) ? T2.LfZzP : T2.BheWL;
|
|
case 2:
|
|
return this.stream.parseInteger(qW, T2.uPfYa(qW, qO));
|
|
case 3:
|
|
return this.sub ? T2.uPfYa("(", this.sub.length) + T2.NcaHd : this.stream.parseBitString(qW, T2.uPfYa(qW, qO));
|
|
case 4:
|
|
return this.sub ? T2.uPfYa(T2.uPfYa("(", this.sub.length), T2.NcaHd) : this.stream.parseOctetString(qW, T2.ofxUT(qW, qO));
|
|
case 6:
|
|
return this.stream.parseOID(qW, qW + qO);
|
|
case 16:
|
|
case 17:
|
|
return T2.jTMYR("(", this.sub.length) + " elem)";
|
|
case 12:
|
|
return this.stream.parseStringUTF(qW, qW + qO);
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 26:
|
|
return this.stream.parseStringISO(qW, T2.jTMYR(qW, qO));
|
|
case 30:
|
|
return this.stream.parseStringBMP(qW, T2.LKrVM(qW, qO));
|
|
case 23:
|
|
case 24:
|
|
return this.stream.parseTime(qW, qW + qO);
|
|
}
|
|
continue;
|
|
case "2":
|
|
var qP = T2.sbNiu(this.tag, 6);
|
|
var qF = 31 & this.tag;
|
|
var qW = this.posContent();
|
|
var qO = Math.abs(this.length);
|
|
continue;
|
|
case "3":
|
|
return null;
|
|
case "4":
|
|
if (T2.Sowyx(0, qP)) {
|
|
if (T2.zbHqd(null, this.sub))
|
|
return T2.LKrVM("(" + this.sub.length, T2.NcaHd);
|
|
var qj = this.stream.parseStringISO(qW, T2.LKrVM(qW, Math.min(qO, qB)));
|
|
return this.reSeemsASCII.test(qj) ? T2.ydEOK(qj.substring(0, T2.tFpum(2, qB)), qj.length > 2 * qB ? qI : "") : this.stream.parseOctetString(qW, T2.EiDeW(qW, qO))
|
|
}
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
;
|
|
qM.prototype.toString = function () {
|
|
return T2.LKqBJ(T2.NMTdh(T2.NMTdh(T2.QeGDP(T2.QeGDP(T2.hdqMD(T2.hdqMD(this.typeName(), "@"), this.stream.pos) + T2.MmFTk, this.header), ",length:"), this.length) + T2.YIrhG, T2.JrvAL(null, this.sub) ? T2.LKpGK : this.sub.length), "]")
|
|
}
|
|
;
|
|
qM.prototype.print = function (qS) {
|
|
if (T2.JrvAL(qS, qJ) && (qS = ""),
|
|
null !== this.sub) {
|
|
qS += " ";
|
|
for (var qg = 0, qP = this.sub.length; T2.jcbeP(qP, qg); ++qg)
|
|
this.sub[qg].print(qS)
|
|
}
|
|
}
|
|
;
|
|
qM.prototype.toPrettyString = function (qS) {
|
|
if (qb.qsnzq(qS, qJ)) {
|
|
qS = ""
|
|
}
|
|
var qg = qb.ptwjU(qb.mHYky(qb.mHYky(qS, this.typeName()), " @"), this.stream.pos);
|
|
if (this.length >= 0 && (qg += "+"),
|
|
qg += this.length,
|
|
32 & this.tag ? qg += qb.VlWHf : qb.rGidL(3, this.tag) && qb.rGidL(4, this.tag) || qb.qsnzq(null, this.sub) || (qg += " (encapsulates)"),
|
|
qg += "\n",
|
|
null !== this.sub) {
|
|
qS += " ";
|
|
for (var qP = 0, qF = this.sub.length; qb.HmtFa(qF, qP); ++qP)
|
|
qg += this.sub[qP].toPrettyString(qS)
|
|
}
|
|
return qg
|
|
}
|
|
;
|
|
qM.prototype.toDOM = function () {
|
|
var qS = {};
|
|
qS.REDAe = function (qk, qE) {
|
|
return qb.nRbBv(qk, qE)
|
|
}
|
|
;
|
|
qS.CMLPb = qb.WopGP;
|
|
qS.RsHLq = "node";
|
|
var qg = qS;
|
|
var qP = qQ.tag(qb.QaHVJ, qb.CLTiC);
|
|
qP.asn1 = this;
|
|
var qF = qQ.tag(qb.QaHVJ, qb.RmNpi);
|
|
var qW = this.typeName().replace(/_/g, " ");
|
|
qF.innerHTML = qW;
|
|
var qO = this.content();
|
|
if (qb.NMDpM(null, qO)) {
|
|
qO = qb.hVNjK(String, qO).replace(/</g, qb.zGcUp);
|
|
var qj = qQ.tag(qb.hyjUb, "preview");
|
|
qj.appendChild(qQ.text(qO));
|
|
qF.appendChild(qj)
|
|
}
|
|
qP.appendChild(qF);
|
|
this.node = qP;
|
|
this.head = qF;
|
|
var qs = qQ.tag(qb.QaHVJ, qb.BwDrC);
|
|
if (qW = qb.uMFSF(qb.TsvwU, this.stream.pos) + qb.cbdKn,
|
|
qW += qb.uMFSF(qb.zfBSQ("Length: ", this.header), "+"),
|
|
qW += this.length >= 0 ? this.length : qb.enAVD(-this.length, " (undefined)"),
|
|
qb.RWFmy(32, this.tag) ? qW += "<br/>(constructed)" : qb.jAEeL(3, this.tag) && qb.QgEpD(4, this.tag) || qb.qsnzq(null, this.sub) || (qW += qb.nYxji),
|
|
null !== qO && (qW += qb.LSUnc(qb.LSUnc(qb.ZHVOH, qO), qb.npjam),
|
|
qb.nRbBv(qb.bJMBO, typeof oids) && 6 == this.tag)) {
|
|
var qc = oids[qO];
|
|
if (qc) {
|
|
if (qc.d) {
|
|
qW += qb.cbdKn + qc.d
|
|
}
|
|
if (qc.c) {
|
|
qW += qb.cbdKn + qc.c
|
|
}
|
|
if (qc.w) {
|
|
qW += qb.XXclD
|
|
}
|
|
}
|
|
}
|
|
qs.innerHTML = qW;
|
|
qP.appendChild(qs);
|
|
var qv = qQ.tag(qb.QaHVJ, "sub");
|
|
if (qb.ysQAs(null, this.sub))
|
|
for (var qV = 0, qz = this.sub.length; qb.oAJsW(qz, qV); ++qV)
|
|
qv.appendChild(this.sub[qV].toDOM());
|
|
return qP.appendChild(qv),
|
|
qF.onclick = function () {
|
|
if (qg.REDAe(qg.CMLPb, qP.className)) {
|
|
qP.className = qg.RsHLq
|
|
} else {
|
|
qP.className = qg.CMLPb
|
|
}
|
|
}
|
|
,
|
|
qP
|
|
}
|
|
;
|
|
qM.prototype.posStart = function () {
|
|
return this.stream.pos
|
|
}
|
|
;
|
|
qM.prototype.posContent = function () {
|
|
return T2.FsJpO(this.stream.pos, this.header)
|
|
}
|
|
;
|
|
qM.prototype.posEnd = function () {
|
|
return qb.BMSzC(this.stream.pos + this.header, Math.abs(this.length))
|
|
}
|
|
;
|
|
qM.prototype.fakeHover = function (qS) {
|
|
this.node.className += qb.MTqPG;
|
|
if (qS) {
|
|
this.head.className += qb.MTqPG
|
|
}
|
|
}
|
|
;
|
|
qM.prototype.fakeOut = function (qS) {
|
|
var qg = / ?hover/;
|
|
this.node.className = this.node.className.replace(qg, "");
|
|
if (qS) {
|
|
this.head.className = this.head.className.replace(qg, "")
|
|
}
|
|
}
|
|
;
|
|
qM.prototype.toHexDOM_sub = function (qS, qg, qP, qF, qW) {
|
|
if (!qb.WEHVe(qF, qW)) {
|
|
var qO = qQ.tag(qb.hyjUb, qg);
|
|
qO.appendChild(qQ.text(qP.hexDump(qF, qW)));
|
|
qS.appendChild(qO)
|
|
}
|
|
}
|
|
;
|
|
qM.prototype.toHexDOM = function (qS) {
|
|
var qg = qQ.tag(qb.hyjUb, "hex");
|
|
if (qb.iZnow(qS, qJ) && (qS = qg),
|
|
this.head.hexNode = qg,
|
|
this.head.onmouseover = function () {
|
|
this.hexNode.className = "hexCurrent"
|
|
}
|
|
,
|
|
this.head.onmouseout = function () {
|
|
this.hexNode.className = qb.Jjfxq
|
|
}
|
|
,
|
|
qg.asn1 = this,
|
|
qg.onmouseover = function () {
|
|
var qj = !qS.selected;
|
|
if (qj) {
|
|
qS.selected = this.asn1;
|
|
this.className = "hexCurrent"
|
|
}
|
|
this.asn1.fakeHover(qj)
|
|
}
|
|
,
|
|
qg.onmouseout = function () {
|
|
var qj = qb.pCzRr(qS.selected, this.asn1);
|
|
this.asn1.fakeOut(qj);
|
|
if (qj) {
|
|
qS.selected = null;
|
|
this.className = qb.Jjfxq
|
|
}
|
|
}
|
|
,
|
|
this.toHexDOM_sub(qg, qb.PMvog, this.stream, this.posStart(), qb.joLPM(this.posStart(), 1)),
|
|
this.toHexDOM_sub(qg, qb.WEHVe(this.length, 0) ? "dlen" : qb.QTVKQ, this.stream, this.posStart() + 1, this.posContent()),
|
|
qb.rBXeG(null, this.sub))
|
|
qg.appendChild(qQ.text(this.stream.hexDump(this.posContent(), this.posEnd())));
|
|
else {
|
|
if (this.sub.length > 0) {
|
|
var qP = this.sub[0];
|
|
var qF = this.sub[qb.zQUKK(this.sub.length, 1)];
|
|
this.toHexDOM_sub(qg, "intro", this.stream, this.posContent(), qP.posStart());
|
|
for (var qW = 0, qO = this.sub.length; qb.oAJsW(qO, qW); ++qW)
|
|
qg.appendChild(this.sub[qW].toHexDOM(qS));
|
|
this.toHexDOM_sub(qg, "outro", this.stream, qF.posEnd(), this.posEnd())
|
|
}
|
|
}
|
|
return qg
|
|
}
|
|
;
|
|
qM.prototype.toHexString = function (qS) {
|
|
return this.stream.hexDump(this.posStart(), this.posEnd(), !0)
|
|
}
|
|
;
|
|
qM.decodeLength = function (qS) {
|
|
var qg = qb.TiEWW.split("|");
|
|
var qP = 0;
|
|
while (!![]) {
|
|
switch (qg[qP++]) {
|
|
case "0":
|
|
qW = 0;
|
|
continue;
|
|
case "1":
|
|
if (qb.rBXeG(0, qO))
|
|
return -1;
|
|
continue;
|
|
case "2":
|
|
if (qb.ckIgK(qO, qW))
|
|
return qO;
|
|
continue;
|
|
case "3":
|
|
return qW;
|
|
case "4":
|
|
for (var qF = 0; qO > qF; ++qF)
|
|
qW = qb.ksuWe(qb.tBaWf(qW, 8), qS.get());
|
|
continue;
|
|
case "5":
|
|
var qW = qS.get();
|
|
var qO = qb.qXIFd(127, qW);
|
|
continue;
|
|
case "6":
|
|
if (qb.oAJsW(qO, 3))
|
|
throw qb.hnAAo + qb.QybuI(qS.pos, 1);
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
;
|
|
qM.hasContent = function (qS, qg, qP) {
|
|
var qF = "5|2|0|1|3|6|4".split("|");
|
|
var qW = 0;
|
|
while (!![]) {
|
|
switch (qF[qW++]) {
|
|
case "0":
|
|
var qO = new qU(qP);
|
|
continue;
|
|
case "1":
|
|
if (3 == qS) {
|
|
qO.get()
|
|
}
|
|
continue;
|
|
case "2":
|
|
if (qb.HGMeV(3, qS) || qb.AEkFR(qS, 4))
|
|
return !1;
|
|
continue;
|
|
case "3":
|
|
var qj = qO.get();
|
|
continue;
|
|
case "4":
|
|
try {
|
|
var qs = qM.decodeLength(qO);
|
|
return qb.joLPM(qb.zKpkk(qO.pos, qP.pos), qs) == qg
|
|
} catch (qc) {
|
|
console.log(qc);
|
|
console.log(qc);
|
|
return !1
|
|
}
|
|
continue;
|
|
case "5":
|
|
if (qb.qXIFd(32, qS))
|
|
return !0;
|
|
continue;
|
|
case "6":
|
|
if (qb.FPXSI(qb.bxNEE(qj, 6), 1))
|
|
return !1;
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
;
|
|
qM.decode = function (qS) {
|
|
qb.mgCea(qS, qU) || (qS = new qU(qS, 0));
|
|
var qg = new qU(qS);
|
|
var qP = qS.get();
|
|
var qF = qM.decodeLength(qS);
|
|
var qW = qb.zKpkk(qS.pos, qg.pos);
|
|
var qO = null;
|
|
if (qM.hasContent(qP, qF, qS)) {
|
|
var qj = qS.pos;
|
|
if (qb.oJDpU(3, qP) && qS.get(),
|
|
qO = [],
|
|
qb.iAdTj(qF, 0)) {
|
|
for (var qs = qb.lIqWN(qj, qF); qS.pos < qs;)
|
|
qO[qO.length] = qM.decode(qS);
|
|
if (qb.WKxgP(qS.pos, qs))
|
|
throw "Content size is not correct for container starting at offset " + qj
|
|
} else
|
|
try {
|
|
for (; ;) {
|
|
var qc = qM.decode(qS);
|
|
if (qb.EmcAR(0, qc.tag))
|
|
break;
|
|
qO[qO.length] = qc
|
|
}
|
|
qF = qb.AQLGQ(qj, qS.pos)
|
|
} catch (qv) {
|
|
console.log(qv);
|
|
console.log(qv);
|
|
throw qb.UAHRr("Exception while decoding undefined length content: ", qv)
|
|
}
|
|
} else
|
|
qS.pos += qF;
|
|
return new qM(qg, qW, qF, qP, qO)
|
|
}
|
|
;
|
|
qM.test = function () {
|
|
var qS = {};
|
|
qS.value = [39];
|
|
qS.expected = 39;
|
|
var qg = {};
|
|
qg.value = [129, 201];
|
|
qg.expected = 201;
|
|
var qP = {};
|
|
qP.value = [131, 254, 220, 186];
|
|
qP.expected = 16702650;
|
|
for (var qF = [qS, qg, qP], qW = 0, qO = qF.length; qb.AEkFR(qO, qW); ++qW) {
|
|
var qj = new qU(qF[qW].value, 0);
|
|
var qs = qM.decodeLength(qj)
|
|
}
|
|
}
|
|
;
|
|
window.ASN1 = qM
|
|
}
|
|
)();
|
|
window.ASN1.prototype.getHexStringValue = function () {
|
|
var qJ = this.toHexString();
|
|
var qu = H.EtahI(2, this.header);
|
|
var qb = H.QELUQ(2, this.length);
|
|
return qJ.substr(qu, qb)
|
|
}
|
|
;
|
|
Nd.prototype.parseKey = function (qJ) {
|
|
try {
|
|
var qu = 0;
|
|
var qb = 0;
|
|
var qU = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;
|
|
var qM;
|
|
if (qU.test(qJ)) {
|
|
qM = window.Hex.decode(qJ)
|
|
} else {
|
|
qM = window.Base64.unarmor(qJ)
|
|
}
|
|
var qK = window.ASN1.decode(qM);
|
|
if (H.ruGHB(3, qK.sub.length) && (qK = qK.sub[2].sub[0]),
|
|
H.ruGHB(9, qK.sub.length)) {
|
|
qu = qK.sub[1].getHexStringValue();
|
|
this.n = H.xmCmh(Nk, qu, 16);
|
|
qb = qK.sub[2].getHexStringValue();
|
|
this.e = H.xmCmh(parseInt, qb, 16);
|
|
var qB = qK.sub[3].getHexStringValue();
|
|
this.d = Nk(qB, 16);
|
|
var qI = qK.sub[4].getHexStringValue();
|
|
this.p = H.HQoSn(Nk, qI, 16);
|
|
var qQ = qK.sub[5].getHexStringValue();
|
|
this.q = H.HQoSn(Nk, qQ, 16);
|
|
var qS = qK.sub[6].getHexStringValue();
|
|
this.dmp1 = H.kZRBO(Nk, qS, 16);
|
|
var qg = qK.sub[7].getHexStringValue();
|
|
this.dmq1 = H.VGjct(Nk, qg, 16);
|
|
var qP = qK.sub[8].getHexStringValue();
|
|
this.coeff = Nk(qP, 16)
|
|
} else {
|
|
if (2 !== qK.sub.length)
|
|
return !1;
|
|
var qF = qK.sub[1];
|
|
var qW = qF.sub[0];
|
|
qu = qW.sub[0].getHexStringValue();
|
|
this.n = H.TPXHx(Nk, qu, 16);
|
|
qb = qW.sub[1].getHexStringValue();
|
|
this.e = parseInt(qb, 16)
|
|
}
|
|
return !0
|
|
} catch (qO) {
|
|
console.log(qO);
|
|
console.log(qO);
|
|
return !1
|
|
}
|
|
}
|
|
;
|
|
Nd.prototype.getPrivateBaseKey = function () {
|
|
var qJ = {};
|
|
qJ.int = 0;
|
|
var qu = {};
|
|
qu.bigint = this.n;
|
|
var qb = {};
|
|
qb.int = this.e;
|
|
var qU = {};
|
|
qU.bigint = this.d;
|
|
var qM = {};
|
|
qM.bigint = this.p;
|
|
var qK = {};
|
|
qK.bigint = this.q;
|
|
var qB = {};
|
|
qB.bigint = this.dmp1;
|
|
var qI = {};
|
|
qI.bigint = this.dmq1;
|
|
var qQ = {};
|
|
qQ.bigint = this.coeff;
|
|
var qS = {};
|
|
qS.array = [new KJUR.asn1.DERInteger(qJ), new KJUR.asn1.DERInteger(qu), new KJUR.asn1.DERInteger(qb), new KJUR.asn1.DERInteger(qU), new KJUR.asn1.DERInteger(qM), new KJUR.asn1.DERInteger(qK), new KJUR.asn1.DERInteger(qB), new KJUR.asn1.DERInteger(qI), new KJUR.asn1.DERInteger(qQ)];
|
|
var qg = qS;
|
|
var qP = new KJUR.asn1.DERSequence(qg);
|
|
return qP.getEncodedHex()
|
|
}
|
|
;
|
|
Nd.prototype.getPrivateBaseKeyB64 = function () {
|
|
return H.OuxAf(q8, this.getPrivateBaseKey())
|
|
}
|
|
;
|
|
Nd.prototype.getPublicBaseKey = function () {
|
|
var qJ = T2.iANgj.split("|");
|
|
var qu = 0;
|
|
while (!![]) {
|
|
switch (qJ[qu++]) {
|
|
case "0":
|
|
var qb = {};
|
|
qb.array = [qW, qI];
|
|
qF = qb;
|
|
continue;
|
|
case "1":
|
|
var qU = {};
|
|
qU.bigint = this.n;
|
|
var qM = {};
|
|
qM.int = this.e;
|
|
var qK = {};
|
|
qK.array = [new KJUR.asn1.DERInteger(qU), new KJUR.asn1.DERInteger(qM)];
|
|
qF = qK;
|
|
continue;
|
|
case "2":
|
|
return qQ.getEncodedHex();
|
|
case "3":
|
|
var qB = {};
|
|
qB.hex = T2.FsJpO("00", qS.getEncodedHex());
|
|
qF = qB;
|
|
continue;
|
|
case "4":
|
|
var qI = new KJUR.asn1.DERBitString(qF);
|
|
continue;
|
|
case "5":
|
|
var qQ = new KJUR.asn1.DERSequence(qF);
|
|
continue;
|
|
case "6":
|
|
var qS = new KJUR.asn1.DERSequence(qF);
|
|
continue;
|
|
case "7":
|
|
var qg = {};
|
|
qg.oid = T2.FimOf;
|
|
var qP = {};
|
|
qP.array = [new KJUR.asn1.DERObjectIdentifier(qg), new KJUR.asn1.DERNull];
|
|
var qF = qP;
|
|
var qW = new KJUR.asn1.DERSequence(qF);
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
;
|
|
Nd.prototype.getPublicBaseKeyB64 = function () {
|
|
return H.HoiIC(q8, this.getPublicBaseKey())
|
|
}
|
|
;
|
|
Nd.prototype.wordwrap = function (qJ, qu) {
|
|
if (qu = H.GPhRM(qu, 64),
|
|
!qJ)
|
|
return qJ;
|
|
var qb = H.WPQMA(H.WPQMA(H.WPQMA(H.yuwzU(H.YJHfm, qu), H.Twdtd), qu), "})");
|
|
return qJ.match(H.TPXHx(RegExp, qb, "g")).join("\n")
|
|
}
|
|
;
|
|
Nd.prototype.getPrivateKey = function () {
|
|
var qJ = "-----BEGIN RSA PRIVATE KEY-----\n";
|
|
return qJ += T2.Nedvl(this.wordwrap(this.getPrivateBaseKeyB64()), "\n"),
|
|
qJ += "-----END RSA PRIVATE KEY-----"
|
|
}
|
|
;
|
|
Nd.prototype.getPublicKey = function () {
|
|
var qJ = T2.rFDHx;
|
|
return qJ += T2.NTNgW(this.wordwrap(this.getPublicBaseKeyB64()), "\n"),
|
|
qJ += "-----END PUBLIC KEY-----"
|
|
}
|
|
;
|
|
Nd.prototype.hasPublicKeyProperty = function (qJ) {
|
|
return qJ = T2.vJUQI(qJ, {}),
|
|
qJ.hasOwnProperty("n") && qJ.hasOwnProperty("e")
|
|
}
|
|
;
|
|
Nd.prototype.hasPrivateKeyProperty = function (qJ) {
|
|
return qJ = H.UaxBt(qJ, {}),
|
|
qJ.hasOwnProperty("n") && qJ.hasOwnProperty("e") && qJ.hasOwnProperty("d") && qJ.hasOwnProperty("p") && qJ.hasOwnProperty("q") && qJ.hasOwnProperty(H.fNvBR) && qJ.hasOwnProperty(H.nhgqk) && qJ.hasOwnProperty(H.KeWtU)
|
|
}
|
|
;
|
|
Nd.prototype.parsePropertiesFrom = function (qJ) {
|
|
this.n = qJ.n;
|
|
this.e = qJ.e;
|
|
if (qJ.hasOwnProperty("d")) {
|
|
this.d = qJ.d;
|
|
this.p = qJ.p;
|
|
this.q = qJ.q;
|
|
this.dmp1 = qJ.dmp1;
|
|
this.dmq1 = qJ.dmq1;
|
|
this.coeff = qJ.coeff
|
|
}
|
|
}
|
|
;
|
|
var qw = function (qJ) {
|
|
Nd.call(this);
|
|
if (qJ) {
|
|
H.XowTU(H.zIyHc, typeof qJ) ? this.parseKey(qJ) : (this.hasPrivateKeyProperty(qJ) || this.hasPublicKeyProperty(qJ)) && this.parsePropertiesFrom(qJ)
|
|
}
|
|
};
|
|
(qw.prototype = new Nd).constructor = qw;
|
|
var qD = function (qJ) {
|
|
qJ = T2.vJUQI(qJ, {});
|
|
this.default_key_size = parseInt(qJ.default_key_size) || 1024;
|
|
this.default_public_exponent = qJ.default_public_exponent || "010001";
|
|
this.log = qJ.log || !1;
|
|
this.key = null
|
|
};
|
|
qD.prototype.setKey = function (qJ) {
|
|
if (this.log && this.key) {
|
|
console.warn(T2.xQZTm)
|
|
}
|
|
this.key = new qw(qJ)
|
|
}
|
|
;
|
|
qD.prototype.setPrivateKey = function (qJ) {
|
|
this.setKey(qJ)
|
|
}
|
|
;
|
|
qD.prototype.setPublicKey = function (qJ) {
|
|
this.setKey(qJ)
|
|
}
|
|
;
|
|
qD.prototype.decrypt = function (qJ) {
|
|
try {
|
|
return this.getKey().decrypt(H.mMdAc(q9, qJ))
|
|
} catch (qu) {
|
|
console.log(qu);
|
|
console.log(qu);
|
|
return !1
|
|
}
|
|
}
|
|
;
|
|
qD.prototype.encrypt = function (qJ) {
|
|
try {
|
|
return T2.mThbX(q8, this.getKey().encrypt(qJ))
|
|
} catch (qu) {
|
|
console.log(qu);
|
|
console.log(qu);
|
|
return !1
|
|
}
|
|
}
|
|
;
|
|
qD.prototype.getKey = function (qJ) {
|
|
if (!this.key) {
|
|
if (this.key = new qw,
|
|
qJ && H.tmUNF(H.aZLmj, {}.toString.call(qJ)))
|
|
return void this.key.generateAsync(this.default_key_size, this.default_public_exponent, qJ);
|
|
this.key.generate(this.default_key_size, this.default_public_exponent)
|
|
}
|
|
return this.key
|
|
}
|
|
;
|
|
qD.prototype.getPrivateKey = function () {
|
|
return this.getKey().getPrivateKey()
|
|
}
|
|
;
|
|
qD.prototype.getPrivateKeyB64 = function () {
|
|
return this.getKey().getPrivateBaseKeyB64()
|
|
}
|
|
;
|
|
qD.prototype.getPublicKey = function () {
|
|
return this.getKey().getPublicKey()
|
|
}
|
|
;
|
|
qD.prototype.getPublicKeyB64 = function () {
|
|
return this.getKey().getPublicBaseKeyB64()
|
|
}
|
|
;
|
|
qD.version = C.FObpk;
|
|
T0.JSEncrypt = qD
|
|
}
|
|
)) ? A = f.apply(o, Y) : A = f) === undefined || (m.exports = A)
|
|
}
|
|
.call(L, G, L, R), undefined) || (R.exports = A)
|
|
},
|
|
"jsencrypt": function (R, L, G) {
|
|
var p = {};
|
|
p.gNNnN = function (Y, A) {
|
|
return Y !== A
|
|
}
|
|
;
|
|
p.gAKYI = function (Y, A) {
|
|
return Y + A
|
|
}
|
|
;
|
|
p.Oqpbk = function (Y, A) {
|
|
return Y(A)
|
|
}
|
|
;
|
|
p.CBIha = function (Y, A) {
|
|
return Y(A)
|
|
}
|
|
;
|
|
p.MNdGu = function (Y, A) {
|
|
return Y === A
|
|
}
|
|
;
|
|
var C = p;
|
|
var f;
|
|
C.MNdGu(f = function (Y, A, h) {
|
|
var o = {};
|
|
o.PTHrK = function (Z, a) {
|
|
return C.gAKYI(Z, a)
|
|
}
|
|
;
|
|
o.Xamtb = function (Z, a) {
|
|
return C.Oqpbk(Z, a)
|
|
}
|
|
;
|
|
var m = o;
|
|
var x = C.CBIha(G, "encrypt");
|
|
|
|
function H() {
|
|
if (C.gNNnN(void 0, x)) {
|
|
this.jsencrypt = new x.JSEncrypt;
|
|
this.jsencrypt.setPublicKey("-----BEGIN PUBLIC KEY-----MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDq04c6My441Gj0UFKgrqUhAUg+kQZeUeWSPlAU9fr4HBPDldAeqzx1UR92KJHuQh/zs1HOamE2dgX9z/2oXcJaqoRIA/FXysx+z2YlJkSk8XQLcQ8EBOkp//MZrixam7lCYpNOjadQBb2Ot0U/Ky+jF2p+Ie8gSZ7/u+Wnr5grywIDAQAB-----END PUBLIC KEY-----")
|
|
}
|
|
}
|
|
|
|
H.prototype.encode = function (Z, a) {
|
|
var X;
|
|
if (a) {
|
|
X = m.PTHrK(a + "|", Z)
|
|
} else {
|
|
X = Z
|
|
}
|
|
return m.Xamtb(encodeURIComponent, this.jsencrypt.encrypt(X))
|
|
}
|
|
;
|
|
h.exports = H
|
|
}
|
|
.call(L, G, L, R), undefined) || (R.exports = f)
|
|
}
|
|
});
|
|
|
|
var n = {};
|
|
n.XBtPX = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.jrGLZ = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.bOtEk = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.vplbC = "0|5|1|2|3|4";
|
|
n.TcSyJ = function (K, Y) {
|
|
return K != Y
|
|
}
|
|
;
|
|
n.vwmjl = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.ykolN = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.Wmydc = function (K, Y) {
|
|
return K * Y
|
|
}
|
|
;
|
|
n.xkAVN = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.UnFsY = function (K, Y) {
|
|
return K(Y)
|
|
}
|
|
;
|
|
n.UMXqo = function (K, Y, x) {
|
|
return K(Y, x)
|
|
}
|
|
;
|
|
n.BMaoD = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.jJHVQ = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.cWQTT = function (K, Y) {
|
|
return K(Y)
|
|
}
|
|
;
|
|
n.nMHiD = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.NumKJ = "mz=";
|
|
n.ZDKbv = ";path=/";
|
|
n.DnNJW = "/api/match/14/m";
|
|
n.tlpBr = function (K, Y) {
|
|
return K(Y)
|
|
}
|
|
;
|
|
n.BtdNq = function (K, Y) {
|
|
return K / Y
|
|
}
|
|
;
|
|
n.ROwxM = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.zWYmB = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.ycfRT = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.qfSxT = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.ydZhv = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.fixAu = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.Jhspr = function (K, Y, x, d, h, b, F) {
|
|
return K(Y, x, d, h, b, F)
|
|
}
|
|
;
|
|
n.OoepU = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.MQOJb = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.JEyfp = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.LnlnO = function (K, Y) {
|
|
return K + Y
|
|
}
|
|
;
|
|
n.CdSNM = function (K, Y, x, d, h, b, F) {
|
|
return K(Y, x, d, h, b, F)
|
|
}
|
|
;
|
|
n.IOCDS = "\u5C31\u50CF\u98CE\u4E00\u6837\u81EA\u7531~ \u4F60\u7684\u6E29\u67D4~ \u65E0\u6CD5\u633D\u7559~ \u4F9D\u513F\u5440~ \u4F9D\u513F\u5440~";
|
|
var G = n;
|
|
|
|
|
|
function E(K) {
|
|
var Y = {};
|
|
Y.omDMx = G.vplbC;
|
|
Y.CuLuB = function (h, b) {
|
|
return G.TcSyJ(h, b)
|
|
}
|
|
;
|
|
Y.OPnPG = function (h, b) {
|
|
return G.bOtEk(h, b)
|
|
}
|
|
;
|
|
Y.PtKem = function (h, b) {
|
|
return G.vwmjl(h, b)
|
|
}
|
|
;
|
|
Y.eZkFz = function (h, b) {
|
|
return G.vwmjl(h, b)
|
|
}
|
|
;
|
|
Y.kXFxj = function (h, b) {
|
|
return h + b
|
|
}
|
|
;
|
|
Y.AKZTZ = function (h, b) {
|
|
return h + b
|
|
}
|
|
;
|
|
Y.JYVAM = function (h, b) {
|
|
return G.ykolN(h, b)
|
|
}
|
|
;
|
|
Y.gJsFT = function (h, b) {
|
|
return G.Wmydc(h, b)
|
|
}
|
|
;
|
|
Y.xiQWv = function (h, b) {
|
|
return h + b
|
|
}
|
|
;
|
|
Y.pSnMY = function (h, b) {
|
|
return G.xkAVN(h, b)
|
|
}
|
|
;
|
|
Y.SgOqf = function (h, b) {
|
|
return G.UnFsY(h, b)
|
|
}
|
|
;
|
|
Y.wxVwq = "jsencrypt";
|
|
var x = Y;
|
|
|
|
function d(h, b) {
|
|
var F = x.omDMx.split("|");
|
|
var H = 0;
|
|
while (!![]) {
|
|
switch (F[H++]) {
|
|
case "0":
|
|
var D = b;
|
|
continue;
|
|
case "1":
|
|
var u = new I;
|
|
continue;
|
|
case "2":
|
|
var Q = u.encode(h, D);
|
|
continue;
|
|
case "3":
|
|
continue;
|
|
case "4":
|
|
return Q;
|
|
case "5":
|
|
var I = x.SgOqf(_n, x.wxVwq);
|
|
continue;
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
return result = G.UMXqo(d, K, K),
|
|
result
|
|
}
|
|
|
|
module.exports =
|
|
{
|
|
E
|
|
};
|
|
|
|
|
|
// console.log('E=' + E(parseInt(1704909642000)));
|