diff --git a/猿人学练习/68js加密防并发谁能并发我叫谁爹/w.js b/猿人学练习/68js加密防并发谁能并发我叫谁爹/w.js
new file mode 100644
index 0000000..2816ae2
--- /dev/null
+++ b/猿人学练习/68js加密防并发谁能并发我叫谁爹/w.js
@@ -0,0 +1,1983 @@
+window = global;
+window.wp = '';
+
+
+var h = {
+    "base64-js": 1,
+    "buffer": 2,
+    "ieee754": 3
+};
+var z = {
+    "./lib": 5
+};
+var B = {
+    "buffer": 2
+};
+var V = {
+    "whirlpool-js": 4
+};
+
+(function () {
+    function G(F, W, c) {
+        function L(D, q) {
+            if (!W[D]) {
+                if (!F[D]) {
+                    var Y = "function" == typeof require && require;
+                    if (!q && Y) return Y(D, !0);
+                    if (N) return N(D, !0);
+                    var m = new Error("Cannot find module '" + D + "'");
+                    throw m.code = "MODULE_NOT_FOUND", m;
+                }
+
+                var C = {
+                    "exports": {}
+                };
+                var R = W[D] = C;
+                F[D][0].call(R.exports, function (w) {
+                    var S = F[D][1][w];
+                    return L(S || w);
+                }, R, R.exports, G, F, W, c);
+            }
+
+            return W[D].exports;
+        }
+
+        for (var N = "function" == typeof require && require, T = 0; T < c.length; T++) L(c[T]);
+
+        return L;
+    }
+
+    return G;
+})()({
+    1: [function (X, l, s) {
+        'use strict';
+
+        s.byteLength = W;
+        s.toByteArray = U;
+        s.fromByteArray = T;
+        var O = [];
+        var Z = [];
+
+        if (typeof Uint8Array !== "undefined") {
+            var K = Uint8Array;
+        } else {
+            var K = Array;
+        }
+
+        var v = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+        for (var M = 0, G = v.length; M < G; ++M) {
+            O[M] = v[M];
+            Z[v.charCodeAt(M)] = M;
+        }
+
+        Z["-".charCodeAt(0)] = 62;
+        Z["_".charCodeAt(0)] = 63;
+
+        function W(D) {
+            var q = F(D);
+            var e = q[0];
+            var f = q[1];
+            return (e + f) * 3 / 4 - f;
+        }
+
+        function c(D, q, e) {
+            return (q + e) * 3 / 4 - e;
+        }
+
+        function U(D) {
+            var Y;
+            var r = F(D);
+            var o = r[0];
+            var P = r[1];
+            var m = new K(c(D, o, P));
+            var f = 0;
+            var C = P > 0 ? o - 4 : o;
+            var J;
+
+            for (J = 0; J < C; J += 4) {
+                Y = Z[D.charCodeAt(J)] << 18 | Z[D.charCodeAt(J + 1)] << 12 | Z[D.charCodeAt(J + 2)] << 6 | Z[D.charCodeAt(J + 3)];
+                m[f++] = Y >> 16 & 255;
+                m[f++] = Y >> 8 & 255;
+                m[f++] = Y & 255;
+            }
+
+            P === 2 && (Y = Z[D.charCodeAt(J)] << 2 | Z[D.charCodeAt(J + 1)] >> 4, m[f++] = Y & 255);
+            P === 1 && (Y = Z[D.charCodeAt(J)] << 10 | Z[D.charCodeAt(J + 1)] << 4 | Z[D.charCodeAt(J + 2)] >> 2, m[f++] = Y >> 8 & 255, m[f++] = Y & 255);
+            return m;
+        }
+
+        function L(D) {
+            return O[D >> 18 & 63] + O[D >> 12 & 63] + O[D >> 6 & 63] + O[D & 63];
+        }
+
+        function N(D, q, e) {
+            var f;
+            var J = [];
+
+            for (var r = q; r < e; r += 3) {
+                f = (D[r] << 16 & 16711680) + (D[r + 1] << 8 & 65280) + (D[r + 2] & 255);
+                J.push(L(f));
+            }
+
+            return J.join("");
+        }
+
+        function T(D) {
+            var P;
+            var Y = D.length;
+            var J = Y % 3;
+            var r = [];
+            var f = 16383;
+
+            for (var o = 0, m = Y - J; o < m; o += f) {
+                r.push(N(D, o, o + f > m ? m : o + f));
+            }
+
+            if (J === 1) {
+                P = D[Y - 1];
+                r.push(O[P >> 2] + O[P << 4 & 63] + "==");
+            } else J === 2 && (P = (D[Y - 2] << 8) + D[Y - 1], r.push(O[P >> 10] + O[P >> 4 & 63] + O[P << 2 & 63] + "="));
+
+            return r.join("");
+        }
+    }, {}],
+    2: [function (X, l, s) {
+        (function (O) {
+            (function () {
+                /*!
+                * The buffer module from node.js, for the browser.
+                *
+                * @author   Feross Aboukhadijeh <https://feross.org>
+                * @license  MIT
+                */
+                'use strict';
+
+                var v = X("base64-js");
+                var M = X("ieee754");
+                s.Buffer = c;
+                s.SlowBuffer = P;
+                s.INSPECT_MAX_BYTES = 50;
+                var G = 2147483647;
+                s.kMaxLength = G;
+                c.TYPED_ARRAY_SUPPORT = F();
+                !c.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+
+                function F() {
+                    try {
+                        var XX = new Uint8Array(1);
+                        var Xl = {
+                            "__proto__": Uint8Array.prototype,
+                            "foo": function () {
+                                return 42;
+                            }
+                        };
+                        return XX.__proto__ = Xl, XX.foo() === 42;
+                    } catch (Xs) {
+                        console.log(Xs);
+                        return ![];
+                    }
+                }
+
+                Object.defineProperty(c.prototype, "parent", {
+                    "enumerable": !![],
+                    "get": function () {
+                        if (!c.isBuffer(this)) return undefined;
+                        return this.buffer;
+                    }
+                });
+                Object.defineProperty(c.prototype, "offset", {
+                    "enumerable": !![],
+                    "get": function () {
+                        if (!c.isBuffer(this)) return undefined;
+                        return this.byteOffset;
+                    }
+                });
+
+                function W(XX) {
+                    if (XX > G) throw new RangeError("The value \"" + XX + "\" is invalid for option \"size\"");
+                    var Xl = new Uint8Array(XX);
+                    return Xl.__proto__ = c.prototype, Xl;
+                }
+
+                function c(XX, Xl, Xs) {
+                    if (typeof XX === "number") {
+                        if (typeof Xl === "string") throw new TypeError("The \"string\" argument must be of type string. Received type number");
+                        return D(XX);
+                    }
+
+                    return L(XX, Xl, Xs);
+                }
+
+                if (typeof Symbol !== "undefined" && Symbol.species != null && c[Symbol.species] === c) {
+                    var U = {
+                        "value": null,
+                        "configurable": !![],
+                        "enumerable": ![],
+                        "writable": ![]
+                    };
+                    Object.defineProperty(c, Symbol.species, U);
+                }
+
+                c.poolSize = 8192;
+
+                function L(XX, Xl, Xs) {
+                    if (typeof XX === "string") return q(XX, Xl);
+                    if (ArrayBuffer.isView(XX)) return e(XX);
+                    if (XX == null) throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof XX);
+                    if (X8(XX, ArrayBuffer) || XX && X8(XX.buffer, ArrayBuffer)) return f(XX, Xl, Xs);
+                    if (typeof XX === "number") throw new TypeError("The \"value\" argument must not be of type number. Received type number");
+                    var Xy = XX.valueOf && XX.valueOf();
+                    if (Xy != null && Xy !== XX) return c.from(Xy, Xl, Xs);
+                    var XO = J(XX);
+                    if (XO) return XO;
+                    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof XX[Symbol.toPrimitive] === "function") return c.from(XX[Symbol.toPrimitive]("string"), Xl, Xs);
+                    throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof XX);
+                }
+
+                c.from = function (XX, Xl, Xs) {
+                    return L(XX, Xl, Xs);
+                };
+
+                c.prototype.__proto__ = Uint8Array.prototype;
+                c.__proto__ = Uint8Array;
+
+                function N(XX) {
+                    if (typeof XX !== "number") throw new TypeError("\"size\" argument must be of type number"); else {
+                        if (XX < 0) throw new RangeError("The value \"" + XX + "\" is invalid for option \"size\"");
+                    }
+                }
+
+                function T(XX, Xl, Xs) {
+                    N(XX);
+                    if (XX <= 0) return W(XX);
+                    if (Xl !== undefined) return typeof Xs === "string" ? W(XX).fill(Xl, Xs) : W(XX).fill(Xl);
+                    return W(XX);
+                }
+
+                c.alloc = function (XX, Xl, Xs) {
+                    return T(XX, Xl, Xs);
+                };
+
+                function D(XX) {
+                    return N(XX), W(XX < 0 ? 0 : r(XX) | 0);
+                }
+
+                c.allocUnsafe = function (XX) {
+                    return D(XX);
+                };
+
+                c.allocUnsafeSlow = function (XX) {
+                    return D(XX);
+                };
+
+                function q(XX, Xl) {
+                    (typeof Xl !== "string" || Xl === "") && (Xl = "utf8");
+                    if (!c.isEncoding(Xl)) throw new TypeError("Unknown encoding: " + Xl);
+                    var Xs = Y(XX, Xl) | 0;
+                    var Xy = W(Xs);
+                    var XO = Xy.write(XX, Xl);
+                    return XO !== Xs && (Xy = Xy.slice(0, XO)), Xy;
+                }
+
+                function e(XX) {
+                    if (XX.length < 0) {
+                        var Xl = 0;
+                    } else {
+                        var Xl = r(XX.length) | 0;
+                    }
+
+                    var Xs = W(Xl);
+
+                    for (var Xy = 0; Xy < Xl; Xy += 1) {
+                        Xs[Xy] = XX[Xy] & 255;
+                    }
+
+                    return Xs;
+                }
+
+                function J(XX) {
+                    if (c.isBuffer(XX)) {
+                        var Xy = r(XX.length) | 0;
+                        var XO = W(Xy);
+                        if (XO.length === 0) return XO;
+                        XX.copy(XO, 0, 0, Xy);
+                        return XO;
+                    }
+
+                    if (XX.length !== undefined) {
+                        if (typeof XX.length !== "number" || X9(XX.length)) return W(0);
+                        return e(XX);
+                    }
+
+                    if (XX.type === "Buffer" && Array.isArray(XX.data)) return e(XX.data);
+                }
+
+                function r(XX) {
+                    if (XX >= G) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + G.toString(16) + " bytes");
+                    return XX | 0;
+                }
+
+                function P(XX) {
+                    return +XX != XX && (XX = 0), c.alloc(+XX);
+                }
+
+                c.isBuffer = function XX(Xl) {
+                    return Xl != null && Xl._isBuffer === !![] && Xl !== c.prototype;
+                };
+
+                c.compare = function Xl(Xs, Xy) {
+                    if (X8(Xs, Uint8Array)) Xs = c.from(Xs, Xs.offset, Xs.byteLength);
+                    if (X8(Xy, Uint8Array)) Xy = c.from(Xy, Xy.offset, Xy.byteLength);
+                    if (!c.isBuffer(Xs) || !c.isBuffer(Xy)) throw new TypeError("The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array");
+                    if (Xs === Xy) return 0;
+                    var XO = Xs.length;
+                    var Xh = Xy.length;
+
+                    for (var Xz = 0, XB = Math.min(XO, Xh); Xz < XB; ++Xz) {
+                        if (Xs[Xz] !== Xy[Xz]) {
+                            XO = Xs[Xz];
+                            Xh = Xy[Xz];
+                            break;
+                        }
+                    }
+
+                    if (XO < Xh) return -1;
+                    if (Xh < XO) return 1;
+                    return 0;
+                };
+
+                c.isEncoding = function Xs(Xy) {
+                    switch (String(Xy).toLowerCase()) {
+                        case "hex":
+                        case "utf8":
+                        case "utf-8":
+                        case "ascii":
+                        case "latin1":
+                        case "binary":
+                        case "base64":
+                        case "ucs2":
+                        case "ucs-2":
+                        case "utf16le":
+                        case "utf-16le":
+                            return !![];
+
+                        default:
+                            return ![];
+                    }
+                };
+
+                c.concat = function Xy(XO, Xh) {
+                    if (!Array.isArray(XO)) throw new TypeError("\"list\" argument must be an Array of Buffers");
+                    if (XO.length === 0) return c.alloc(0);
+                    var XK;
+
+                    if (Xh === undefined) {
+                        Xh = 0;
+
+                        for (XK = 0; XK < XO.length; ++XK) {
+                            Xh += XO[XK].length;
+                        }
+                    }
+
+                    var Xv = c.allocUnsafe(Xh);
+                    var XZ = 0;
+
+                    for (XK = 0; XK < XO.length; ++XK) {
+                        var XV = XO[XK];
+                        X8(XV, Uint8Array) && (XV = c.from(XV));
+                        if (!c.isBuffer(XV)) throw new TypeError("\"list\" argument must be an Array of Buffers");
+                        XV.copy(Xv, XZ);
+                        XZ += XV.length;
+                    }
+
+                    return Xv;
+                };
+
+                function Y(XO, Xh) {
+                    if (c.isBuffer(XO)) return XO.length;
+                    if (ArrayBuffer.isView(XO) || X8(XO, ArrayBuffer)) return XO.byteLength;
+                    if (typeof XO !== "string") throw new TypeError("The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type " + typeof XO);
+                    var XZ = XO.length;
+                    var XV = arguments.length > 2 && arguments[2] === !![];
+                    if (!XV && XZ === 0) return 0;
+                    var XK = ![];
+
+                    for (; ;) {
+                        switch (Xh) {
+                            case "ascii":
+                            case "latin1":
+                            case "binary":
+                                return XZ;
+
+                            case "utf8":
+                            case "utf-8":
+                                return X3(XO).length;
+
+                            case "ucs2":
+                            case "ucs-2":
+                            case "utf16le":
+                            case "utf-16le":
+                                return XZ * 2;
+
+                            case "hex":
+                                return XZ >>> 1;
+
+                            case "base64":
+                                return X6(XO).length;
+
+                            default:
+                                if (XK) return XV ? -1 : X3(XO).length;
+                                Xh = ("" + Xh).toLowerCase();
+                                XK = !![];
+                        }
+                    }
+                }
+
+                c.byteLength = Y;
+
+                function o(XO, Xh, Xz) {
+                    var XZ = ![];
+                    (Xh === undefined || Xh < 0) && (Xh = 0);
+                    if (Xh > this.length) return "";
+                    (Xz === undefined || Xz > this.length) && (Xz = this.length);
+                    if (Xz <= 0) return "";
+                    Xz >>>= 0;
+                    Xh >>>= 0;
+                    if (Xz <= Xh) return "";
+                    if (!XO) XO = "utf8";
+
+                    while (!![]) {
+                        switch (XO) {
+                            case "hex":
+                                return u(this, Xh, Xz);
+
+                            case "utf8":
+                            case "utf-8":
+                                return Q(this, Xh, Xz);
+
+                            case "ascii":
+                                return x(this, Xh, Xz);
+
+                            case "latin1":
+                            case "binary":
+                                return i(this, Xh, Xz);
+
+                            case "base64":
+                                return I(this, Xh, Xz);
+
+                            case "ucs2":
+                            case "ucs-2":
+                            case "utf16le":
+                            case "utf-16le":
+                                return j(this, Xh, Xz);
+
+                            default:
+                                if (XZ) throw new TypeError("Unknown encoding: " + XO);
+                                XO = (XO + "").toLowerCase();
+                                XZ = !![];
+                        }
+                    }
+                }
+
+                c.prototype._isBuffer = !![];
+
+                function m(XO, Xh, Xz) {
+                    var XB = XO[Xh];
+                    XO[Xh] = XO[Xz];
+                    XO[Xz] = XB;
+                }
+
+                c.prototype.swap16 = function XO() {
+                    var Xh = this.length;
+                    if (Xh % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+
+                    for (var Xz = 0; Xz < Xh; Xz += 2) {
+                        m(this, Xz, Xz + 1);
+                    }
+
+                    return this;
+                };
+
+                c.prototype.swap32 = function Xh() {
+                    var Xz = this.length;
+                    if (Xz % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+
+                    for (var XB = 0; XB < Xz; XB += 4) {
+                        m(this, XB, XB + 3);
+                        m(this, XB + 1, XB + 2);
+                    }
+
+                    return this;
+                };
+
+                c.prototype.swap64 = function Xz() {
+                    var XB = this.length;
+                    if (XB % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+
+                    for (var XV = 0; XV < XB; XV += 8) {
+                        m(this, XV, XV + 7);
+                        m(this, XV + 1, XV + 6);
+                        m(this, XV + 2, XV + 5);
+                        m(this, XV + 3, XV + 4);
+                    }
+
+                    return this;
+                };
+
+                c.prototype.toString = function XB() {
+                    var XV = this.length;
+                    if (XV === 0) return "";
+                    if (arguments.length === 0) return Q(this, 0, XV);
+                    return o.apply(this, arguments);
+                };
+
+                c.prototype.toLocaleString = c.prototype.toString;
+
+                c.prototype.equals = function XV(XZ) {
+                    if (!c.isBuffer(XZ)) throw new TypeError("Argument must be a Buffer");
+                    if (this === XZ) return !![];
+                    return c.compare(this, XZ) === 0;
+                };
+
+                c.prototype.inspect = function XZ() {
+                    var XG = "";
+                    var XM = s.INSPECT_MAX_BYTES;
+                    XG = this.toString("hex", 0, XM).replace(/(.{2})/g, "$1 ").trim();
+                    if (this.length > XM) XG += " ... ";
+                    return "<Buffer " + XG + ">";
+                };
+
+                c.prototype.compare = function XK(Xv, XM, XG, XF, XW) {
+                    X8(Xv, Uint8Array) && (Xv = c.from(Xv, Xv.offset, Xv.byteLength));
+                    if (!c.isBuffer(Xv)) throw new TypeError("The \"target\" argument must be one of type Buffer or Uint8Array. Received type " + typeof Xv);
+                    XM === undefined && (XM = 0);
+                    XG === undefined && (Xv ? XG = Xv.length : XG = 0);
+                    XF === undefined && (XF = 0);
+                    XW === undefined && (XW = this.length);
+                    if (XM < 0 || XG > Xv.length || XF < 0 || XW > this.length) throw new RangeError("out of range index");
+                    if (XF >= XW && XM >= XG) return 0;
+                    if (XF >= XW) return -1;
+                    if (XM >= XG) return 1;
+                    XM >>>= 0;
+                    XG >>>= 0;
+                    XF >>>= 0;
+                    XW >>>= 0;
+                    if (this === Xv) return 0;
+                    var Xc = XW - XF;
+                    var XU = XG - XM;
+                    var XL = Math.min(Xc, XU);
+                    var XN = this.slice(XF, XW);
+                    var XT = Xv.slice(XM, XG);
+
+                    for (var XD = 0; XD < XL; ++XD) {
+                        if (XN[XD] !== XT[XD]) {
+                            Xc = XN[XD];
+                            XU = XT[XD];
+                            break;
+                        }
+                    }
+
+                    if (Xc < XU) return -1;
+                    if (XU < Xc) return 1;
+                    return 0;
+                };
+
+                function C(Xv, XM, XG, XF, XW) {
+                    if (Xv.length === 0) return -1;
+
+                    if (typeof XG === "string") {
+                        XF = XG;
+                        XG = 0;
+                    } else {
+                        if (XG > 2147483647) XG = 2147483647; else XG < -2147483648 && (XG = -2147483648);
+                    }
+
+                    XG = +XG;
+                    X9(XG) && (XW ? XG = 0 : XG = Xv.length - 1);
+                    if (XG < 0) XG = Xv.length + XG;
+
+                    if (XG >= Xv.length) {
+                        if (XW) return -1; else XG = Xv.length - 1;
+                    } else {
+                        if (XG < 0) {
+                            if (XW) XG = 0; else return -1;
+                        }
+                    }
+
+                    typeof XM === "string" && (XM = c.from(XM, XF));
+
+                    if (c.isBuffer(XM)) {
+                        if (XM.length === 0) return -1;
+                        return a(Xv, XM, XG, XF, XW);
+                    } else {
+                        if (typeof XM === "number") {
+                            XM = XM & 255;
+                            if (typeof Uint8Array.prototype.indexOf === "function") return XW ? Uint8Array.prototype.indexOf.call(Xv, XM, XG) : Uint8Array.prototype.lastIndexOf.call(Xv, XM, XG);
+                            return a(Xv, [XM], XG, XF, XW);
+                        }
+                    }
+
+                    throw new TypeError("val must be string, number or Buffer");
+                }
+
+                function a(Xv, XM, XG, XF, XW) {
+                    var XU = 1;
+                    var XL = Xv.length;
+                    var XN = XM.length;
+
+                    if (XF !== undefined) {
+                        XF = String(XF).toLowerCase();
+
+                        if (XF === "ucs2" || XF === "ucs-2" || XF === "utf16le" || XF === "utf-16le") {
+                            if (Xv.length < 2 || XM.length < 2) return -1;
+                            XU = 2;
+                            XL /= 2;
+                            XN /= 2;
+                            XG /= 2;
+                        }
+                    }
+
+                    function Xq(XP, XY) {
+                        return XU === 1 ? XP[XY] : XP.readUInt16BE(XY * XU);
+                    }
+
+                    var Xe;
+
+                    if (XW) {
+                        var Xf = -1;
+
+                        for (Xe = XG; Xe < XL; Xe++) {
+                            if (Xq(Xv, Xe) === Xq(XM, Xf === -1 ? 0 : Xe - Xf)) {
+                                if (Xf === -1) Xf = Xe;
+                                if (Xe - Xf + 1 === XN) return Xf * XU;
+                            } else {
+                                if (Xf !== -1) Xe -= Xe - Xf;
+                                Xf = -1;
+                            }
+                        }
+                    } else {
+                        if (XG + XN > XL) XG = XL - XN;
+
+                        for (Xe = XG; Xe >= 0; Xe--) {
+                            var XJ = !![];
+
+                            for (var Xr = 0; Xr < XN; Xr++) {
+                                if (Xq(Xv, Xe + Xr) !== Xq(XM, Xr)) {
+                                    XJ = ![];
+                                    break;
+                                }
+                            }
+
+                            if (XJ) return Xe;
+                        }
+                    }
+
+                    return -1;
+                }
+
+                c.prototype.includes = function Xv(XM, XG, XF) {
+                    return this.indexOf(XM, XG, XF) !== -1;
+                };
+
+                c.prototype.indexOf = function XM(XG, XF, XW) {
+                    return C(this, XG, XF, XW, !![]);
+                };
+
+                c.prototype.lastIndexOf = function XG(XF, XW, Xc) {
+                    return C(this, XF, XW, Xc, ![]);
+                };
+
+                function t(XF, XW, Xc, XU) {
+                    Xc = Number(Xc) || 0;
+                    var Xe = XF.length - Xc;
+
+                    if (!XU) {
+                        XU = Xe;
+                    } else {
+                        XU = Number(XU);
+                        XU > Xe && (XU = Xe);
+                    }
+
+                    var Xq = XW.length;
+                    XU > Xq / 2 && (XU = Xq / 2);
+
+                    for (var XT = 0; XT < XU; ++XT) {
+                        var XD = parseInt(XW.substr(XT * 2, 2), 16);
+                        if (X9(XD)) return XT;
+                        XF[Xc + XT] = XD;
+                    }
+
+                    return XT;
+                }
+
+                function n(XF, XW, Xc, XU) {
+                    return X7(X3(XW, XF.length - Xc), XF, Xc, XU);
+                }
+
+                function R(XF, XW, Xc, XU) {
+                    return X7(X4(XW), XF, Xc, XU);
+                }
+
+                function w(XF, XW, Xc, XU) {
+                    return R(XF, XW, Xc, XU);
+                }
+
+                function S(XF, XW, Xc, XU) {
+                    return X7(X6(XW), XF, Xc, XU);
+                }
+
+                function E(XF, XW, Xc, XU) {
+                    return X7(X5(XW, XF.length - Xc), XF, Xc, XU);
+                }
+
+                c.prototype.write = function XF(XW, Xc, XU, XL) {
+                    if (Xc === undefined) {
+                        XL = "utf8";
+                        XU = this.length;
+                        Xc = 0;
+                    } else {
+                        if (XU === undefined && typeof Xc === "string") {
+                            XL = Xc;
+                            XU = this.length;
+                            Xc = 0;
+                        } else {
+                            if (isFinite(Xc)) {
+                                Xc = Xc >>> 0;
+
+                                if (isFinite(XU)) {
+                                    XU = XU >>> 0;
+                                    if (XL === undefined) XL = "utf8";
+                                } else {
+                                    XL = XU;
+                                    XU = undefined;
+                                }
+                            } else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+                        }
+                    }
+
+                    var XD = this.length - Xc;
+                    if (XU === undefined || XU > XD) XU = XD;
+                    if (XW.length > 0 && (XU < 0 || Xc < 0) || Xc > this.length) throw new RangeError("Attempt to write outside buffer bounds");
+                    if (!XL) XL = "utf8";
+                    var Xq = ![];
+
+                    for (; ;) {
+                        switch (XL) {
+                            case "hex":
+                                return t(this, XW, Xc, XU);
+
+                            case "utf8":
+                            case "utf-8":
+                                return n(this, XW, Xc, XU);
+
+                            case "ascii":
+                                return R(this, XW, Xc, XU);
+
+                            case "latin1":
+                            case "binary":
+                                return w(this, XW, Xc, XU);
+
+                            case "base64":
+                                return S(this, XW, Xc, XU);
+
+                            case "ucs2":
+                            case "ucs-2":
+                            case "utf16le":
+                            case "utf-16le":
+                                return E(this, XW, Xc, XU);
+
+                            default:
+                                if (Xq) throw new TypeError("Unknown encoding: " + XL);
+                                XL = ("" + XL).toLowerCase();
+                                Xq = !![];
+                        }
+                    }
+                };
+
+                c.prototype.toJSON = function XW() {
+                    return {
+                        "type": "Buffer",
+                        "data": Array.prototype.slice.call(this._arr || this, 0)
+                    };
+                };
+
+                function I(Xc, XU, XL) {
+                    return XU === 0 && XL === Xc.length ? v.fromByteArray(Xc) : v.fromByteArray(Xc.slice(XU, XL));
+                }
+
+                function Q(Xc, XU, XL) {
+                    XL = Math.min(Xc.length, XL);
+                    var XN = [];
+                    var XT = XU;
+
+                    while (XT < XL) {
+                        var XD = Xc[XT];
+                        var Xq = null;
+
+                        if (XD > 239) {
+                            var Xe = 4;
+                        } else {
+                            var Xe = XD > 223 ? 3 : XD > 191 ? 2 : 1;
+                        }
+
+                        if (XT + Xe <= XL) {
+                            var Xf;
+                            var XJ;
+                            var Xr;
+                            var XP;
+
+                            switch (Xe) {
+                                case 1:
+                                    XD < 128 && (Xq = XD);
+                                    break;
+
+                                case 2:
+                                    Xf = Xc[XT + 1];
+                                    (Xf & 192) === 128 && (XP = (XD & 31) << 6 | Xf & 63, XP > 127 && (Xq = XP));
+                                    break;
+
+                                case 3:
+                                    Xf = Xc[XT + 1];
+                                    XJ = Xc[XT + 2];
+                                    (Xf & 192) === 128 && (XJ & 192) === 128 && (XP = (XD & 15) << 12 | (Xf & 63) << 6 | XJ & 63, XP > 2047 && (XP < 55296 || XP > 57343) && (Xq = XP));
+                                    break;
+
+                                case 4:
+                                    Xf = Xc[XT + 1];
+                                    XJ = Xc[XT + 2];
+                                    Xr = Xc[XT + 3];
+                                    (Xf & 192) === 128 && (XJ & 192) === 128 && (Xr & 192) === 128 && (XP = (XD & 15) << 18 | (Xf & 63) << 12 | (XJ & 63) << 6 | Xr & 63, XP > 65535 && XP < 1114112 && (Xq = XP));
+                            }
+                        }
+
+                        if (Xq === null) {
+                            Xq = 65533;
+                            Xe = 1;
+                        } else Xq > 65535 && (Xq -= 65536, XN.push(Xq >>> 10 & 1023 | 55296), Xq = 56320 | Xq & 1023);
+
+                        XN.push(Xq);
+                        XT += Xe;
+                    }
+
+                    return d(XN);
+                }
+
+                var p = 4096;
+
+                function d(Xc) {
+                    var XD = Xc.length;
+                    if (XD <= p) return String.fromCharCode.apply(String, Xc);
+                    var XT = "";
+                    var XN = 0;
+
+                    while (XN < XD) {
+                        XT += String.fromCharCode.apply(String, Xc.slice(XN, XN += p));
+                    }
+
+                    return XT;
+                }
+
+                function x(Xc, XU, XL) {
+                    var XN = "";
+                    XL = Math.min(Xc.length, XL);
+
+                    for (var XT = XU; XT < XL; ++XT) {
+                        XN += String.fromCharCode(Xc[XT] & 127);
+                    }
+
+                    return XN;
+                }
+
+                function i(Xc, XU, XL) {
+                    var XN = "";
+                    XL = Math.min(Xc.length, XL);
+
+                    for (var XT = XU; XT < XL; ++XT) {
+                        XN += String.fromCharCode(Xc[XT]);
+                    }
+
+                    return XN;
+                }
+
+                function u(Xc, XU, XL) {
+                    var Xe = Xc.length;
+                    if (!XU || XU < 0) XU = 0;
+                    if (!XL || XL < 0 || XL > Xe) XL = Xe;
+                    var XD = "";
+
+                    for (var Xq = XU; Xq < XL; ++Xq) {
+                        XD += X2(Xc[Xq]);
+                    }
+
+                    return XD;
+                }
+
+                function j(Xc, XU, XL) {
+                    var XN = Xc.slice(XU, XL);
+                    var XT = "";
+
+                    for (var XD = 0; XD < XN.length; XD += 2) {
+                        XT += String.fromCharCode(XN[XD] + XN[XD + 1] * 256);
+                    }
+
+                    return XT;
+                }
+
+                c.prototype.slice = function Xc(XU, XL) {
+                    var Xq = this.length;
+                    XU = ~~XU;
+
+                    if (XL === undefined) {
+                        XL = Xq;
+                    } else {
+                        XL = ~~XL;
+                    }
+
+                    if (XU < 0) {
+                        XU += Xq;
+                        if (XU < 0) XU = 0;
+                    } else XU > Xq && (XU = Xq);
+
+                    if (XL < 0) {
+                        XL += Xq;
+                        if (XL < 0) XL = 0;
+                    } else XL > Xq && (XL = Xq);
+
+                    if (XL < XU) XL = XU;
+                    var XD = this.subarray(XU, XL);
+                    XD.__proto__ = c.prototype;
+                    return XD;
+                };
+
+                function b(XU, XL, XN) {
+                    if (XU % 1 !== 0 || XU < 0) throw new RangeError("offset is not uint");
+                    if (XU + XL > XN) throw new RangeError("Trying to access beyond buffer length");
+                }
+
+                c.prototype.readUIntLE = function XU(XL, XN, XT) {
+                    XL = XL >>> 0;
+                    XN = XN >>> 0;
+                    if (!XT) b(XL, XN, this.length);
+                    var Xf = this[XL];
+                    var Xe = 1;
+                    var XJ = 0;
+
+                    while (++XJ < XN && (Xe *= 256)) {
+                        Xf += this[XL + XJ] * Xe;
+                    }
+
+                    return Xf;
+                };
+
+                c.prototype.readUIntBE = function XL(XN, XT, XD) {
+                    XN = XN >>> 0;
+                    XT = XT >>> 0;
+                    !XD && b(XN, XT, this.length);
+                    var Xf = this[XN + --XT];
+                    var XJ = 1;
+
+                    while (XT > 0 && (XJ *= 256)) {
+                        Xf += this[XN + --XT] * XJ;
+                    }
+
+                    return Xf;
+                };
+
+                c.prototype.readUInt8 = function XN(XT, XD) {
+                    XT = XT >>> 0;
+                    if (!XD) b(XT, 1, this.length);
+                    return this[XT];
+                };
+
+                c.prototype.readUInt16LE = function XT(XD, Xq) {
+                    XD = XD >>> 0;
+                    if (!Xq) b(XD, 2, this.length);
+                    return this[XD] | this[XD + 1] << 8;
+                };
+
+                c.prototype.readUInt16BE = function XD(Xq, Xe) {
+                    Xq = Xq >>> 0;
+                    if (!Xe) b(Xq, 2, this.length);
+                    return this[Xq] << 8 | this[Xq + 1];
+                };
+
+                c.prototype.readUInt32LE = function Xq(Xe, Xf) {
+                    Xe = Xe >>> 0;
+                    if (!Xf) b(Xe, 4, this.length);
+                    return (this[Xe] | this[Xe + 1] << 8 | this[Xe + 2] << 16) + this[Xe + 3] * 16777216;
+                };
+
+                c.prototype.readUInt32BE = function Xe(Xf, XJ) {
+                    Xf = Xf >>> 0;
+                    if (!XJ) b(Xf, 4, this.length);
+                    return this[Xf] * 16777216 + (this[Xf + 1] << 16 | this[Xf + 2] << 8 | this[Xf + 3]);
+                };
+
+                c.prototype.readIntLE = function Xf(XJ, Xr, XP) {
+                    XJ = XJ >>> 0;
+                    Xr = Xr >>> 0;
+                    if (!XP) b(XJ, Xr, this.length);
+                    var XY = this[XJ];
+                    var Xo = 1;
+                    var Xm = 0;
+
+                    while (++Xm < Xr && (Xo *= 256)) {
+                        XY += this[XJ + Xm] * Xo;
+                    }
+
+                    Xo *= 128;
+                    if (XY >= Xo) XY -= Math.pow(2, 8 * Xr);
+                    return XY;
+                };
+
+                c.prototype.readIntBE = function XJ(Xr, XP, XY) {
+                    Xr = Xr >>> 0;
+                    XP = XP >>> 0;
+                    if (!XY) b(Xr, XP, this.length);
+                    var Xo = XP;
+                    var Xm = 1;
+                    var XC = this[Xr + --Xo];
+
+                    while (Xo > 0 && (Xm *= 256)) {
+                        XC += this[Xr + --Xo] * Xm;
+                    }
+
+                    Xm *= 128;
+                    if (XC >= Xm) XC -= Math.pow(2, 8 * XP);
+                    return XC;
+                };
+
+                c.prototype.readInt8 = function Xr(XP, XY) {
+                    XP = XP >>> 0;
+                    if (!XY) b(XP, 1, this.length);
+                    if (!(this[XP] & 128)) return this[XP];
+                    return (255 - this[XP] + 1) * -1;
+                };
+
+                c.prototype.readInt16LE = function XP(XY, Xo) {
+                    XY = XY >>> 0;
+                    if (!Xo) b(XY, 2, this.length);
+                    var Xm = this[XY] | this[XY + 1] << 8;
+                    return Xm & 32768 ? Xm | 4294901760 : Xm;
+                };
+
+                c.prototype.readInt16BE = function XY(Xo, Xm) {
+                    Xo = Xo >>> 0;
+                    if (!Xm) b(Xo, 2, this.length);
+                    var XC = this[Xo + 1] | this[Xo] << 8;
+                    return XC & 32768 ? XC | 4294901760 : XC;
+                };
+
+                c.prototype.readInt32LE = function Xo(Xm, XC) {
+                    Xm = Xm >>> 0;
+                    if (!XC) b(Xm, 4, this.length);
+                    return this[Xm] | this[Xm + 1] << 8 | this[Xm + 2] << 16 | this[Xm + 3] << 24;
+                };
+
+                c.prototype.readInt32BE = function Xm(XC, Xa) {
+                    XC = XC >>> 0;
+                    if (!Xa) b(XC, 4, this.length);
+                    return this[XC] << 24 | this[XC + 1] << 16 | this[XC + 2] << 8 | this[XC + 3];
+                };
+
+                c.prototype.readFloatLE = function XC(Xa, Xt) {
+                    Xa = Xa >>> 0;
+                    if (!Xt) b(Xa, 4, this.length);
+                    return M.read(this, Xa, !![], 23, 4);
+                };
+
+                c.prototype.readFloatBE = function Xa(Xt, Xn) {
+                    Xt = Xt >>> 0;
+                    if (!Xn) b(Xt, 4, this.length);
+                    return M.read(this, Xt, ![], 23, 4);
+                };
+
+                c.prototype.readDoubleLE = function Xt(Xn, XR) {
+                    Xn = Xn >>> 0;
+                    if (!XR) b(Xn, 8, this.length);
+                    return M.read(this, Xn, !![], 52, 8);
+                };
+
+                c.prototype.readDoubleBE = function Xn(XR, Xw) {
+                    XR = XR >>> 0;
+                    if (!Xw) b(XR, 8, this.length);
+                    return M.read(this, XR, ![], 52, 8);
+                };
+
+                function g(XR, Xw, XS, XE, XI, XQ) {
+                    if (!c.isBuffer(XR)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
+                    if (Xw > XI || Xw < XQ) throw new RangeError("\"value\" argument is out of bounds");
+                    if (XS + XE > XR.length) throw new RangeError("Index out of range");
+                }
+
+                c.prototype.writeUIntLE = function XR(Xw, XS, XE, XI) {
+                    Xw = +Xw;
+                    XS = XS >>> 0;
+                    XE = XE >>> 0;
+
+                    if (!XI) {
+                        var Xi = Math.pow(2, 8 * XE) - 1;
+                        g(this, Xw, XS, XE, Xi, 0);
+                    }
+
+                    var Xx = 1;
+                    var Xd = 0;
+                    this[XS] = Xw & 255;
+
+                    while (++Xd < XE && (Xx *= 256)) {
+                        this[XS + Xd] = Xw / Xx & 255;
+                    }
+
+                    return XS + XE;
+                };
+
+                c.prototype.writeUIntBE = function Xw(XS, XE, XI, XQ) {
+                    XS = +XS;
+                    XE = XE >>> 0;
+                    XI = XI >>> 0;
+
+                    if (!XQ) {
+                        var Xu = Math.pow(2, 8 * XI) - 1;
+                        g(this, XS, XE, XI, Xu, 0);
+                    }
+
+                    var Xi = XI - 1;
+                    var Xx = 1;
+                    this[XE + Xi] = XS & 255;
+
+                    while (--Xi >= 0 && (Xx *= 256)) {
+                        this[XE + Xi] = XS / Xx & 255;
+                    }
+
+                    return XE + XI;
+                };
+
+                c.prototype.writeUInt8 = function XS(XE, XI, XQ) {
+                    XE = +XE;
+                    XI = XI >>> 0;
+                    if (!XQ) g(this, XE, XI, 1, 255, 0);
+                    this[XI] = XE & 255;
+                    return XI + 1;
+                };
+
+                c.prototype.writeUInt16LE = function XE(XI, XQ, Xp) {
+                    XI = +XI;
+                    XQ = XQ >>> 0;
+                    if (!Xp) g(this, XI, XQ, 2, 65535, 0);
+                    this[XQ] = XI & 255;
+                    this[XQ + 1] = XI >>> 8;
+                    return XQ + 2;
+                };
+
+                c.prototype.writeUInt16BE = function XI(XQ, Xp, Xd) {
+                    XQ = +XQ;
+                    Xp = Xp >>> 0;
+                    if (!Xd) g(this, XQ, Xp, 2, 65535, 0);
+                    return this[Xp] = XQ >>> 8, this[Xp + 1] = XQ & 255, Xp + 2;
+                };
+
+                c.prototype.writeUInt32LE = function XQ(Xp, Xd, Xx) {
+                    Xp = +Xp;
+                    Xd = Xd >>> 0;
+                    if (!Xx) g(this, Xp, Xd, 4, 4294967295, 0);
+                    return this[Xd + 3] = Xp >>> 24, this[Xd + 2] = Xp >>> 16, this[Xd + 1] = Xp >>> 8, this[Xd] = Xp & 255, Xd + 4;
+                };
+
+                c.prototype.writeUInt32BE = function Xp(Xd, Xx, Xi) {
+                    Xd = +Xd;
+                    Xx = Xx >>> 0;
+                    if (!Xi) g(this, Xd, Xx, 4, 4294967295, 0);
+                    this[Xx] = Xd >>> 24;
+                    this[Xx + 1] = Xd >>> 16;
+                    this[Xx + 2] = Xd >>> 8;
+                    this[Xx + 3] = Xd & 255;
+                    return Xx + 4;
+                };
+
+                c.prototype.writeIntLE = function Xd(Xx, Xi, Xu, Xj) {
+                    Xx = +Xx;
+                    Xi = Xi >>> 0;
+
+                    if (!Xj) {
+                        var XA = Math.pow(2, 8 * Xu - 1);
+                        g(this, Xx, Xi, Xu, XA - 1, -XA);
+                    }
+
+                    var l0 = 0;
+                    var Xk = 1;
+                    var XH = 0;
+                    this[Xi] = Xx & 255;
+
+                    while (++l0 < Xu && (Xk *= 256)) {
+                        Xx < 0 && XH === 0 && this[Xi + l0 - 1] !== 0 && (XH = 1);
+                        this[Xi + l0] = (Xx / Xk >> 0) - XH & 255;
+                    }
+
+                    return Xi + Xu;
+                };
+
+                c.prototype.writeIntBE = function Xx(Xi, Xu, Xj, Xb) {
+                    Xi = +Xi;
+                    Xu = Xu >>> 0;
+
+                    if (!Xb) {
+                        var XA = Math.pow(2, 8 * Xj - 1);
+                        g(this, Xi, Xu, Xj, XA - 1, -XA);
+                    }
+
+                    var Xk = Xj - 1;
+                    var l0 = 1;
+                    var l1 = 0;
+                    this[Xu + Xk] = Xi & 255;
+
+                    while (--Xk >= 0 && (l0 *= 256)) {
+                        Xi < 0 && l1 === 0 && this[Xu + Xk + 1] !== 0 && (l1 = 1);
+                        this[Xu + Xk] = (Xi / l0 >> 0) - l1 & 255;
+                    }
+
+                    return Xu + Xj;
+                };
+
+                c.prototype.writeInt8 = function Xi(Xu, Xj, Xb) {
+                    Xu = +Xu;
+                    Xj = Xj >>> 0;
+                    if (!Xb) g(this, Xu, Xj, 1, 127, -128);
+                    if (Xu < 0) Xu = 255 + Xu + 1;
+                    this[Xj] = Xu & 255;
+                    return Xj + 1;
+                };
+
+                c.prototype.writeInt16LE = function Xu(Xj, Xb, Xg) {
+                    Xj = +Xj;
+                    Xb = Xb >>> 0;
+                    if (!Xg) g(this, Xj, Xb, 2, 32767, -32768);
+                    this[Xb] = Xj & 255;
+                    this[Xb + 1] = Xj >>> 8;
+                    return Xb + 2;
+                };
+
+                c.prototype.writeInt16BE = function Xj(Xb, Xg, XH) {
+                    Xb = +Xb;
+                    Xg = Xg >>> 0;
+                    if (!XH) g(this, Xb, Xg, 2, 32767, -32768);
+                    this[Xg] = Xb >>> 8;
+                    this[Xg + 1] = Xb & 255;
+                    return Xg + 2;
+                };
+
+                c.prototype.writeInt32LE = function Xb(Xg, XH, Xk) {
+                    Xg = +Xg;
+                    XH = XH >>> 0;
+                    if (!Xk) g(this, Xg, XH, 4, 2147483647, -2147483648);
+                    return this[XH] = Xg & 255, this[XH + 1] = Xg >>> 8, this[XH + 2] = Xg >>> 16, this[XH + 3] = Xg >>> 24, XH + 4;
+                };
+
+                c.prototype.writeInt32BE = function Xg(XH, Xk, XA) {
+                    XH = +XH;
+                    Xk = Xk >>> 0;
+                    if (!XA) g(this, XH, Xk, 4, 2147483647, -2147483648);
+                    if (XH < 0) XH = 4294967295 + XH + 1;
+                    this[Xk] = XH >>> 24;
+                    this[Xk + 1] = XH >>> 16;
+                    this[Xk + 2] = XH >>> 8;
+                    this[Xk + 3] = XH & 255;
+                    return Xk + 4;
+                };
+
+                function H(XH, Xk, XA, l0, l1, l2) {
+                    if (XA + l0 > XH.length) throw new RangeError("Index out of range");
+                    if (XA < 0) throw new RangeError("Index out of range");
+                }
+
+                function k(XH, Xk, XA, l0, l1) {
+                    Xk = +Xk;
+                    XA = XA >>> 0;
+                    !l1 && H(XH, Xk, XA, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                    M.write(XH, Xk, XA, l0, 23, 4);
+                    return XA + 4;
+                }
+
+                c.prototype.writeFloatLE = function XH(Xk, XA, l0) {
+                    return k(this, Xk, XA, !![], l0);
+                };
+
+                c.prototype.writeFloatBE = function Xk(XA, l0, l1) {
+                    return k(this, XA, l0, ![], l1);
+                };
+
+                function A(XA, l0, l1, l2, l3) {
+                    l0 = +l0;
+                    l1 = l1 >>> 0;
+                    !l3 && H(XA, l0, l1, 8, 1.7976931348623157e+308, -1.7976931348623157e+308);
+                    M.write(XA, l0, l1, l2, 52, 8);
+                    return l1 + 8;
+                }
+
+                c.prototype.writeDoubleLE = function XA(l0, l1, l2) {
+                    return A(this, l0, l1, !![], l2);
+                };
+
+                c.prototype.writeDoubleBE = function l0(l1, l2, l3) {
+                    return A(this, l1, l2, ![], l3);
+                };
+
+                c.prototype.copy = function l1(l2, l3, l4, l5) {
+                    if (!c.isBuffer(l2)) throw new TypeError("argument should be a Buffer");
+                    if (!l4) l4 = 0;
+                    if (!l5 && l5 !== 0) l5 = this.length;
+                    if (l3 >= l2.length) l3 = l2.length;
+                    if (!l3) l3 = 0;
+                    if (l5 > 0 && l5 < l4) l5 = l4;
+                    if (l5 === l4) return 0;
+                    if (l2.length === 0 || this.length === 0) return 0;
+                    if (l3 < 0) throw new RangeError("targetStart out of bounds");
+                    if (l4 < 0 || l4 >= this.length) throw new RangeError("Index out of range");
+                    if (l5 < 0) throw new RangeError("sourceEnd out of bounds");
+                    if (l5 > this.length) l5 = this.length;
+                    l2.length - l3 < l5 - l4 && (l5 = l2.length - l3 + l4);
+                    var l8 = l5 - l4;
+                    if (this === l2 && typeof Uint8Array.prototype.copyWithin === "function") this.copyWithin(l3, l4, l5); else {
+                        if (this === l2 && l4 < l3 && l3 < l5) for (var l9 = l8 - 1; l9 >= 0; --l9) {
+                            l2[l9 + l3] = this[l9 + l4];
+                        } else Uint8Array.prototype.set.call(l2, this.subarray(l4, l5), l3);
+                    }
+                    return l8;
+                };
+
+                c.prototype.fill = function l2(l3, l4, l5, l6) {
+                    if (typeof l3 === "string") {
+                        if (typeof l4 === "string") {
+                            l6 = l4;
+                            l4 = 0;
+                            l5 = this.length;
+                        } else typeof l5 === "string" && (l6 = l5, l5 = this.length);
+
+                        if (l6 !== undefined && typeof l6 !== "string") throw new TypeError("encoding must be a string");
+                        if (typeof l6 === "string" && !c.isEncoding(l6)) throw new TypeError("Unknown encoding: " + l6);
+
+                        if (l3.length === 1) {
+                            var ls = l3.charCodeAt(0);
+                            (l6 === "utf8" && ls < 128 || l6 === "latin1") && (l3 = ls);
+                        }
+                    } else typeof l3 === "number" && (l3 = l3 & 255);
+
+                    if (l4 < 0 || this.length < l4 || this.length < l5) throw new RangeError("Out of range index");
+                    if (l5 <= l4) return this;
+                    l4 = l4 >>> 0;
+
+                    if (l5 === undefined) {
+                        l5 = this.length;
+                    } else {
+                        l5 = l5 >>> 0;
+                    }
+
+                    if (!l3) l3 = 0;
+                    var l9;
+                    if (typeof l3 === "number") for (l9 = l4; l9 < l5; ++l9) {
+                        this[l9] = l3;
+                    } else {
+                        if (c.isBuffer(l3)) {
+                            var lX = l3;
+                        } else {
+                            var lX = c.from(l3, l6);
+                        }
+
+                        var ll = lX.length;
+                        if (ll === 0) throw new TypeError("The value \"" + l3 + "\" is invalid for argument \"value\"");
+
+                        for (l9 = 0; l9 < l5 - l4; ++l9) {
+                            this[l9 + l4] = lX[l9 % ll];
+                        }
+                    }
+                    return this;
+                };
+
+                var X0 = /[^+/0-9A-Za-z-_]/g;
+
+                function X1(l3) {
+                    l3 = l3.split("=")[0];
+                    l3 = l3.trim().replace(X0, "");
+                    if (l3.length < 2) return "";
+
+                    while (l3.length % 4 !== 0) {
+                        l3 = l3 + "=";
+                    }
+
+                    return l3;
+                }
+
+                function X2(l3) {
+                    if (l3 < 16) return "0" + l3.toString(16);
+                    return l3.toString(16);
+                }
+
+                function X3(l3, l4) {
+                    l4 = l4 || Infinity;
+                    var l5;
+                    var l6 = l3.length;
+                    var l7 = null;
+                    var l8 = [];
+
+                    for (var l9 = 0; l9 < l6; ++l9) {
+                        l5 = l3.charCodeAt(l9);
+
+                        if (l5 > 55295 && l5 < 57344) {
+                            if (!l7) {
+                                if (l5 > 56319) {
+                                    if ((l4 -= 3) > -1) l8.push(239, 191, 189);
+                                    continue;
+                                } else {
+                                    if (l9 + 1 === l6) {
+                                        if ((l4 -= 3) > -1) l8.push(239, 191, 189);
+                                        continue;
+                                    }
+                                }
+
+                                l7 = l5;
+                                continue;
+                            }
+
+                            if (l5 < 56320) {
+                                if ((l4 -= 3) > -1) l8.push(239, 191, 189);
+                                l7 = l5;
+                                continue;
+                            }
+
+                            l5 = (l7 - 55296 << 10 | l5 - 56320) + 65536;
+                        } else {
+                            if (l7) {
+                                if ((l4 -= 3) > -1) l8.push(239, 191, 189);
+                            }
+                        }
+
+                        l7 = null;
+
+                        if (l5 < 128) {
+                            if ((l4 -= 1) < 0) break;
+                            l8.push(l5);
+                        } else {
+                            if (l5 < 2048) {
+                                if ((l4 -= 2) < 0) break;
+                                l8.push(l5 >> 6 | 192, l5 & 63 | 128);
+                            } else {
+                                if (l5 < 65536) {
+                                    if ((l4 -= 3) < 0) break;
+                                    l8.push(l5 >> 12 | 224, l5 >> 6 & 63 | 128, l5 & 63 | 128);
+                                } else {
+                                    if (l5 < 1114112) {
+                                        if ((l4 -= 4) < 0) break;
+                                        l8.push(l5 >> 18 | 240, l5 >> 12 & 63 | 128, l5 >> 6 & 63 | 128, l5 & 63 | 128);
+                                    } else throw new Error("Invalid code point");
+                                }
+                            }
+                        }
+                    }
+
+                    return l8;
+                }
+
+                function X4(l3) {
+                    var l4 = [];
+
+                    for (var l5 = 0; l5 < l3.length; ++l5) {
+                        l4.push(l3.charCodeAt(l5) & 255);
+                    }
+
+                    return l4;
+                }
+
+                function X5(l3, l4) {
+                    var l5;
+                    var l6;
+                    var l7;
+                    var l8 = [];
+
+                    for (var l9 = 0; l9 < l3.length; ++l9) {
+                        if ((l4 -= 2) < 0) break;
+                        l5 = l3.charCodeAt(l9);
+                        l6 = l5 >> 8;
+                        l7 = l5 % 256;
+                        l8.push(l7);
+                        l8.push(l6);
+                    }
+
+                    return l8;
+                }
+
+                function X6(l3) {
+                    return v.toByteArray(X1(l3));
+                }
+
+                function X7(l3, l4, l5, l6) {
+                    for (var l7 = 0; l7 < l6; ++l7) {
+                        if (l7 + l5 >= l4.length || l7 >= l3.length) break;
+                        l4[l7 + l5] = l3[l7];
+                    }
+
+                    return l7;
+                }
+
+                function X8(l3, l4) {
+                    return l3 instanceof l4 || l3 != null && l3.constructor != null && l3.constructor.name != null && l3.constructor.name === l4.name;
+                }
+
+                function X9(l3) {
+                    return l3 !== l3;
+                }
+            }).call(this);
+        }).call(this, X("buffer").Buffer);
+    }, h],
+    3: [function (X, l, s) {
+        s.read = function (O, Z, K, v, M) {
+            var D;
+            var q;
+            var T = M * 8 - v - 1;
+            var L = (1 << T) - 1;
+            var c = L >> 1;
+            var f = -7;
+
+            if (K) {
+                var W = M - 1;
+            } else {
+                var W = 0;
+            }
+
+            var U = K ? -1 : 1;
+            var N = O[Z + W];
+            W += U;
+            D = N & (1 << -f) - 1;
+            N >>= -f;
+            f += T;
+
+            for (; f > 0; D = D * 256 + O[Z + W], W += U, f -= 8) {
+            }
+
+            q = D & (1 << -f) - 1;
+            D >>= -f;
+            f += v;
+
+            for (; f > 0; q = q * 256 + O[Z + W], W += U, f -= 8) {
+            }
+
+            if (D === 0) D = 1 - c; else {
+                if (D === L) return q ? NaN : (N ? -1 : 1) * Infinity; else {
+                    q = q + Math.pow(2, v);
+                    D = D - c;
+                }
+            }
+            return (N ? -1 : 1) * q * Math.pow(2, D - v);
+        };
+
+        s.write = function (O, Z, K, v, M, G) {
+            var r;
+            var P;
+            var Y;
+            var L = G * 8 - M - 1;
+            var N = (1 << L) - 1;
+            var q = N >> 1;
+
+            if (M === 23) {
+                var T = Math.pow(2, -24) - Math.pow(2, -77);
+            } else {
+                var T = 0;
+            }
+
+            var D = v ? 0 : G - 1;
+            var o = v ? 1 : -1;
+            var U = Z < 0 || Z === 0 && 1 / Z < 0 ? 1 : 0;
+            Z = Math.abs(Z);
+
+            if (isNaN(Z) || Z === Infinity) {
+                isNaN(Z) ? P = 1 : P = 0;
+                r = N;
+            } else {
+                r = Math.floor(Math.log(Z) / Math.LN2);
+                Z * (Y = Math.pow(2, -r)) < 1 && (r--, Y *= 2);
+
+                if (r + q >= 1) {
+                    Z += T / Y;
+                } else {
+                    Z += T * Math.pow(2, 1 - q);
+                }
+
+                Z * Y >= 2 && (r++, Y /= 2);
+
+                if (r + q >= N) {
+                    P = 0;
+                    r = N;
+                } else if (r + q >= 1) {
+                    P = (Z * Y - 1) * Math.pow(2, M);
+                    r = r + q;
+                } else {
+                    P = Z * Math.pow(2, q - 1) * Math.pow(2, M);
+                    r = 0;
+                }
+            }
+
+            for (; M >= 8; O[K + D] = P & 255, D += o, P /= 256, M -= 8) {
+            }
+
+            r = r << M | P;
+            L += M;
+
+            for (; L > 0; O[K + D] = r & 255, D += o, r /= 256, L -= 8) {
+            }
+
+            O[K + D - o] |= U * 128;
+        };
+    }, {}],
+    4: [function (X, l, s) {
+        l.exports = X("./lib");
+    }, z],
+    5: [function (X, l, s) {
+        (function (O) {
+            (function () {
+                'use strict';
+
+                function v() {
+                    var c = 10;
+                    var U = [];
+                    var L = [];
+                    var N;
+                    var T;
+                    var D;
+                    var J;
+                    var r;
+                    var P;
+                    var Y;
+                    var C;
+                    var t;
+                    var R;
+                    var S;
+                    var I = "ᠣ웨螸ŏ㚦틵祯酒悼鮎ꌌ笵ᷠퟂ⹋﹗ᕷ㟥鿰䫚壉⤊놠殅뵝ჴ쬾է䆋Ᵹ闘ﯮ籦�䞞쨭뼇굚茳挂ꩱ젙䧙守騦㊰햀뻍㑈ｺ遟⁨᪮둔錢擱猒䀈쏬�贽需켫皂혛떯橐䗳ワ㽕ꋪ斺⿀�﵍鉵ڊ닦ฟ拔ꢖ暈╙葲㥌幸㢌톥댡鰞䏇ﰄ写洍﫟縤㮫츑轎럫㲁铷뤓ⳓ쐃噄義⪻셓�鵬ㅴ겉ᓡᘺ椉炶탭챂颤⡜";
+
+                    for (N = 8; N-- > 0;) {
+                        U[N] = [];
+                    }
+
+                    for (T = 0; T < 256; T++) {
+                        D = I.charCodeAt(T / 2);
+
+                        if ((T & 1) == 0) {
+                            P = D >>> 8;
+                        } else {
+                            P = D & 255;
+                        }
+
+                        Y = P << 1;
+                        Y >= 256 && (Y ^= 285);
+                        C = Y << 1;
+                        C >= 256 && (C ^= 285);
+                        t = C ^ P;
+                        R = C << 1;
+                        R >= 256 && (R ^= 285);
+                        S = R ^ P;
+                        U[0][T] = [0, 0];
+                        U[0][T][0] = P << 24 | P << 16 | C << 8 | P;
+                        U[0][T][1] = R << 24 | t << 16 | Y << 8 | S;
+
+                        for (var N = 1; N < 8; N++) {
+                            U[N][T] = [0, 0];
+                            U[N][T][0] = U[N - 1][T][0] >>> 8 | U[N - 1][T][1] << 24;
+                            U[N][T][1] = U[N - 1][T][1] >>> 8 | U[N - 1][T][0] << 24;
+                        }
+                    }
+
+                    L[0] = [0, 0];
+
+                    for (J = 1; J <= c; J++) {
+                        r = 8 * (J - 1);
+                        L[J] = [0, 0];
+                        L[J][0] = U[0][r][0] & 4278190080 ^ U[1][r + 1][0] & 16711680 ^ U[2][r + 2][0] & 65280 ^ U[3][r + 3][0] & 255;
+                        L[J][1] = U[4][r + 4][1] & 4278190080 ^ U[5][r + 5][1] & 16711680 ^ U[6][r + 6][1] & 65280 ^ U[7][r + 7][1] & 255;
+                    }
+
+                    let i = [];
+                    let H = [];
+                    let X0 = [];
+                    let X1 = [];
+                    let X2 = [];
+                    let X3 = [];
+                    let X4 = [];
+                    let X5 = 0;
+                    let X6 = 0;
+
+                    function X7() {
+                        let Xh;
+                        let Xz;
+                        let XB;
+                        let XV;
+                        let XZ;
+
+                        for (Xh = 0, Xz = 0; Xh < 8; Xh++, Xz += 8) {
+                            X3[Xh] = [0, 0];
+                            X3[Xh][0] = (H[Xz] & 255) << 24 ^ (H[Xz + 1] & 255) << 16 ^ (H[Xz + 2] & 255) << 8 ^ H[Xz + 3] & 255;
+                            X3[Xh][1] = (H[Xz + 4] & 255) << 24 ^ (H[Xz + 5] & 255) << 16 ^ (H[Xz + 6] & 255) << 8 ^ H[Xz + 7] & 255;
+                        }
+
+                        for (Xh = 0; Xh < 8; Xh++) {
+                            X4[Xh] = [0, 0];
+                            X1[Xh] = [0, 0];
+                            X4[Xh][0] = X3[Xh][0] ^ (X1[Xh][0] = X0[Xh][0]);
+                            X4[Xh][1] = X3[Xh][1] ^ (X1[Xh][1] = X0[Xh][1]);
+                        }
+
+                        for (XB = 1; XB <= c; XB++) {
+                            for (Xh = 0; Xh < 8; Xh++) {
+                                X2[Xh] = [0, 0];
+
+                                for (XZ = 0, XV = 56, Xz = 0; XZ < 8; XZ++, XV -= 8, XV < 32 ? Xz = 1 : Xz = 0) {
+                                    X2[Xh][0] ^= U[XZ][X1[Xh - XZ & 7][Xz] >>> XV % 32 & 255][0];
+                                    X2[Xh][1] ^= U[XZ][X1[Xh - XZ & 7][Xz] >>> XV % 32 & 255][1];
+                                }
+                            }
+
+                            for (Xh = 0; Xh < 8; Xh++) {
+                                X1[Xh][0] = X2[Xh][0];
+                                X1[Xh][1] = X2[Xh][1];
+                            }
+
+                            X1[0][0] ^= L[XB][0];
+                            X1[0][1] ^= L[XB][1];
+
+                            for (Xh = 0; Xh < 8; Xh++) {
+                                X2[Xh][0] = X1[Xh][0];
+                                X2[Xh][1] = X1[Xh][1];
+
+                                for (XZ = 0, XV = 56, Xz = 0; XZ < 8; XZ++, XV -= 8, XV < 32 ? Xz = 1 : Xz = 0) {
+                                    X2[Xh][0] ^= U[XZ][X4[Xh - XZ & 7][Xz] >>> XV % 32 & 255][0];
+                                    X2[Xh][1] ^= U[XZ][X4[Xh - XZ & 7][Xz] >>> XV % 32 & 255][1];
+                                }
+                            }
+
+                            for (Xh = 0; Xh < 8; Xh++) {
+                                X4[Xh][0] = X2[Xh][0];
+                                X4[Xh][1] = X2[Xh][1];
+                            }
+                        }
+
+                        for (Xh = 0; Xh < 8; Xh++) {
+                            X0[Xh][0] ^= X4[Xh][0] ^ X3[Xh][0];
+                            X0[Xh][1] ^= X4[Xh][1] ^ X3[Xh][1];
+                        }
+                    };
+
+                    function X8(Xh) {
+                        let Xz;
+                        let XB;
+                        let XV = Xh.toString();
+                        Xh = [];
+
+                        for (Xz = 0; Xz < XV.length; Xz++) {
+                            XB = XV.charCodeAt(Xz);
+                            XB >= 256 && Xh.push(XB >>> 8 & 255);
+                            Xh.push(XB & 255);
+                        }
+
+                        return Xh;
+                    }
+
+                    ;
+                    const X9 = {
+                        "init": function () {
+                            for (var XB = 32; XB-- > 0;) {
+                                i[XB] = 0;
+                            }
+
+                            X5 = X6 = 0;
+                            H = [0];
+
+                            for (XB = 8; XB-- > 0;) {
+                                X0[XB] = [0, 0];
+                            }
+
+                            return X9;
+                        },
+                        "add": function (Xh) {
+                            if (!Xh) return X9;
+                            Xh = X8(Xh);
+                            let Xz = Xh.length * 8;
+                            let XB = 0;
+                            let XV = 8 - (Xz & 7) & 7;
+                            let XZ = X5 & 7;
+                            let XK;
+                            let Xv;
+                            let XM;
+                            let XG = Xz;
+
+                            for (XK = 31, XM = 0; XK >= 0; XK--) {
+                                XM += (i[XK] & 255) + XG % 256;
+                                i[XK] = XM & 255;
+                                XM >>>= 8;
+                                XG = Math.floor(XG / 256);
+                            }
+
+                            while (Xz > 8) {
+                                Xv = Xh[XB] << XV & 255 | (Xh[XB + 1] & 255) >>> 8 - XV;
+                                H[X6++] |= Xv >>> XZ;
+                                X5 += 8 - XZ;
+                                X5 == 512 && (X7(), X5 = X6 = 0, H = []);
+                                H[X6] = Xv << 8 - XZ & 255;
+                                X5 += XZ;
+                                Xz -= 8;
+                                XB++;
+                            }
+
+                            return Xz > 0 ? (Xv = Xh[XB] << XV & 255, H[X6] |= Xv >>> XZ) : Xv = 0, XZ + Xz < 8 ? X5 += Xz : (X6++, X5 += 8 - XZ, Xz -= 8 - XZ, X5 == 512 && (X7(), X5 = X6 = 0, H = []), H[X6] = Xv << 8 - XZ & 255, X5 += Xz), X9;
+                        },
+                        "finalize": function () {
+                            let Xh;
+                            let Xz;
+                            let XB;
+                            let XV = "";
+                            let XZ = [];
+                            let XK = "0123456789ABCDEF".split("");
+                            H[X6] |= 128 >>> (X5 & 7);
+                            X6++;
+
+                            if (X6 > 32) {
+                                while (X6 < 64) {
+                                    H[X6++] = 0;
+                                }
+
+                                X7();
+                                X6 = 0;
+                                H = [];
+                            }
+
+                            while (X6 < 32) {
+                                H[X6++] = 0;
+                            }
+
+                            H.push.apply(H, i);
+                            X7();
+
+                            for (Xh = 0, Xz = 0; Xh < 8; Xh++, Xz += 8) {
+                                XB = X0[Xh][0];
+                                XZ[Xz] = XB >>> 24 & 255;
+                                XZ[Xz + 1] = XB >>> 16 & 255;
+                                XZ[Xz + 2] = XB >>> 8 & 255;
+                                XZ[Xz + 3] = XB & 255;
+                                XB = X0[Xh][1];
+                                XZ[Xz + 4] = XB >>> 24 & 255;
+                                XZ[Xz + 5] = XB >>> 16 & 255;
+                                XZ[Xz + 6] = XB >>> 8 & 255;
+                                XZ[Xz + 7] = XB & 255;
+                            }
+
+                            for (Xh = 0; Xh < XZ.length; Xh++) {
+                                XV += XK[XZ[Xh] >>> 4];
+                                XV += XK[XZ[Xh] & 15];
+                            }
+
+                            return XV.toLowerCase();
+                        }
+                    };
+
+                    function XX(Xh) {
+                        let Xz = Xh;
+                        let XB = "";
+
+                        for (var XV = 0; XV < Xz.length; XV += 2) {
+                            XB += String.fromCharCode(parseInt(Xz.substr(XV, 2), 16));
+                        }
+
+                        return XB;
+                    }
+
+                    function Xl(Xh, Xz) {
+                        var XB = new Uint8Array(Xh.length / 2);
+
+                        for (var XV = 0; XV < Xh.length; XV += 2) {
+                            XB[XV / 2] = parseInt(Xh.substring(XV, XV + 2), 16);
+                        }
+
+                        if (Xz) return XB.buffer;
+                        return XB;
+                    }
+
+                    function Xs(Xh) {
+                        return O.from(Xh, "hex").toString("base64");
+                    }
+
+                    let Xy;
+                    const XO = {
+                        "encSync": function (Xh, Xz) {
+                            if (!Xh || typeof Xh !== "string" || Xh === "") return null;
+                            Xy = X9.init().add(Xh).finalize();
+                            if (!Xz || Xz.toLowerCase() === "hex") return Xy;
+                            if (Xz.toLowerCase() === "bytes") return XX(Xy);
+                            if (Xz.toLowerCase() === "base64") return Xs(Xy);
+                            if (Xz.toLowerCase() === "uint8") return Xl(Xy, ![]);
+                            if (Xz.toLowerCase() === "arraybuffer") return Xl(Xy, !![]);
+                        },
+                        "enc": function (Xh, Xz, XB) {
+                            if (typeof Xz == "function") {
+                                XB = Xz;
+                                return;
+                            }
+
+                            if (typeof Xh !== "string" || Xh === "") {
+                                XB("whirlpool input must be a string", null);
+                                return;
+                            }
+
+                            try {
+                                Xy = X9.init().add(Xh).finalize();
+                                (typeof disgest === "function" || Xz.toLowerCase() === "hex") && XB(![], Xy);
+                                Xz.toLowerCase() === "bytes" && XB(![], XX(Xy));
+                                Xz.toLowerCase() === "base64" && XB(![], Xs(Xy));
+                                Xz.toLowerCase() === "uint8" && XB(![], Xl(Xy, ![]));
+                                Xz.toLowerCase() === "arraybuffer" && XB(![], Xl(Xy, !![]));
+                            } catch (XK) {
+                                console.log(XK);
+                                XB(XK, null);
+                            }
+                        },
+                        "encP": function (Xh, Xz) {
+                            return new Promise(function (XV, XZ) {
+                                (!Xh || typeof Xh !== "string" || Xh === "") && XZ("whirlpool input must be a string");
+
+                                try {
+                                    Xy = X9.init().add(Xh).finalize();
+                                    (!Xz || Xz.toLowerCase() === "hex") && XV(Xy);
+                                    Xz.toLowerCase() === "bytes" && XV(XX(Xy));
+                                    Xz.toLowerCase() === "base64" && XV(Xs(Xy));
+                                    Xz.toLowerCase() === "uint8" && XV(Xl(Xy, ![]));
+                                    Xz.toLowerCase() === "arraybuffer" && XV(Xl(Xy, !![]));
+                                    return;
+                                } catch (XM) {
+                                    console.log(XM);
+                                    XZ(XM);
+                                }
+                            });
+                        }
+                    };
+                    return XO;
+                }
+
+                const M = new v();
+                l.exports = M;
+            }).call(this);
+        }).call(this, X("buffer").Buffer);
+    }, B],
+    6: [function (l, s, y) {
+        window.wp = l("whirlpool-js");
+        result = wp.encSync("11111", "hex");
+    }, V]
+}, {}, [6]);
+
+// onmessage = X => {
+//     for (var s = parseInt(X.data.split("|")[0]); s <= parseInt(X.data.split("|")[1]); s++) {
+//         result = self.wp.encSync(X.data.split("|")[2] + s.toString(), "hex");
+//
+//         if (result.slice(0, 10) === X.data.split("|")[3]) {
+//             self.postMessage(s);
+//             break;
+//         }
+//     };
+// };
+
+result = window.wp.encSync('1', "hex");
+console.log(result);
\ No newline at end of file