【8.1】八一建军节，致敬最可爱的人！

(()=>{

    var aN = (C0，Dc)=>()=>(Dc C0((Dc = {

        exports: {}

    }).exports， Dc)，

    Dc.exports);

    var rN = aN((ac，rc)=>{

        (()=>{

            var C0 = {

                89998: (Se，v，J)=>{

                    "use strict";

                    J.r(v)，

                    J.d(v， {

                        arrayify: ()=>x，

                        concat: ()=>h，

                        hexConcat: ()=>ee，

                        hexDataLength: ()=>H，

                        hexDataSlice: ()=>Q，

                        hexStripZeros: ()=>B，

                        hexValue: ()=>Z，

                        hexZeroPad: ()=>I，

                        hexlify: ()=>P，

                        isBytes: ()=>u，

                        isBytesLike: ()=>C，

                        isHexString: ()=>$，

                        joinSignature: ()=>z，

                        splitSignature: ()=>D，

                        stripZeros: ()=>R，

                        zeroPad: ()=>K

                    });

                    var X = J(71408);

                    const Y = "bytes/5.7.0"

                      ， V = new X.Logger(Y);

                    function W(U) {

                        return ！！U.toHexString

                    }

                    function b(U) {

                        return U.slice (U.slice = function() {

                            const q = Array.prototype.slice.call(arguments);

                            return b(new Uint8Array(Array.prototype.slice.apply(U， q)))

                        }

                        )，

                        U

                    }

                    function C(U) {

                        return $(U) && ！(U.length % 2) u(U)

                    }

                    function m(U) {

                        return typeof U == "number" && U == U && U % 1 === 0

                    }

                    function u(U) {

                        if (U == null)

                            return ！1;

                        if (U.constructor === Uint8Array)

                            return ！0;

                        if (typeof U == "string" ！m(U.length) U.length < 0)

                            return ！1;

                        for (let q = 0; q < U.length; q++) {

                            const G = U[q];

                            if (！m(G) G < 0 G >= 256)

                                return ！1

                        }

                        return ！0

                    }

                    function x(U， q) {

                        if (q (q = {})，

                        typeof U == "number") {

                            V.checkSafeUint53(U， "invalid arrayify value");

                            const G = [];

                            for (; U; )

                                G.unshift(U & 255)，

                                U = parseInt(String(U / 256));

                            return G.length === 0 && G.push(0)，

                            b(new Uint8Array(G))

                        }

                        if (q.allowMissingPrefix && typeof U == "string" && U.substring(0， 2) ！== "0x" && (U = "0x" + U)，

                        W(U) && (U = U.toHexString())，

                        $(U)) {

                            let G = U.substring(2);

                            G.length % 2 && (q.hexPad === "left" ？ G = "0" + G : q.hexPad === "right" ？ G += "0" : V.throwArgumentError("hex data is odd-length"， "value"， U));

                            const T = [];

                            for (let o = 0; o < G.length; o += 2)

                                T.push(parseInt(G.substring(o， o + 2)， 16));

                            return b(new Uint8Array(T))

                        }

                        return u(U) ？ b(new Uint8Array(U)) : V.throwArgumentError("invalid arrayify value"， "value"， U)

                    }

                    function h(U) {

                        const q = U.map(o=>x(o))

                          ， G = q.reduce((o，y)=>o + y.length， 0)

                          ， T = new Uint8Array(G);

                        return q.reduce((o，y)=>(T.set(y， o)，

                        o + y.length)， 0)，

                        b(T)

                    }

                    function R(U) {

                        let q = x(U);

                        if (q.length === 0)

                            return q;

                        let G = 0;

                        for (; G < q.length && q[G] === 0; )

                            G++;

                        return G && (q = q.slice(G))，

                        q

                    }

                    function K(U， q) {

                        U = x(U)，

                        U.length > q && V.throwArgumentError("value out of range"， "value"， arguments[0]);

                        const G = new Uint8Array(q);

                        return G.set(U， q - U.length)，

                        b(G)

                    }

                    function $(U， q) {

                        return ！(typeof U ！= "string" ！U.match(/^0x[0-9A-Fa-f]*$/) q && U.length ！== 2 + 2 * q)

                    }

                    const j = "0123456789abcdef";

                    function P(U， q) {

                        if (q (q = {})，

                        typeof U == "number") {

                            V.checkSafeUint53(U， "invalid hexlify value");

                            let G = "";

                            for (; U; )

                                G = j[U & 15] + G，

                                U = Math.floor(U / 16);

                            return G.length ？ (G.length % 2 && (G = "0" + G)，

                            "0x" + G) : "0x00"

                        }

                        if (typeof U == "bigint")

                            return U = U.toString(16)，

                            U.length % 2 ？ "0x0" + U : "0x" + U;

                        if (q.allowMissingPrefix && typeof U == "string" && U.substring(0， 2) ！== "0x" && (U = "0x" + U)，

                        W(U))

                            return U.toHexString();

                        if ($(U))

                            return U.length % 2 && (q.hexPad === "left" ？ U = "0x0" + U.substring(2) : q.hexPad === "right" ？ U += "0" : V.throwArgumentError("hex data is odd-length"， "value"， U))，

                            U.toLowerCase();

                        if (u(U)) {

                            let G = "0x";

                            for (let T = 0; T < U.length; T++) {

                                let o = U[T];

                                G += j[(o & 240) >> 4] + j[o & 15]

                            }

                            return G

                        }

                        return V.throwArgumentError("invalid hexlify value"， "value"， U)

                    }

                    function H(U) {

                        if (typeof U ！= "string")

                            U = P(U);

                        else if (！$(U) U.length % 2)

                            return null;

                        return (U.length - 2) / 2

                    }

                    function Q(U， q， G) {

                        return typeof U ！= "string" ？ U = P(U) : (！$(U) U.length % 2) && V.throwArgumentError("invalid hexData"， "value"， U)，

                        q = 2 + 2 * q，

                        G ！= null ？ "0x" + U.substring(q， 2 + 2 * G) : "0x" + U.substring(q)

                    }

                    function ee(U) {

                        let q = "0x";

                        return U.forEach(G=>{

                            q += P(G).substring(2)

                        }

                        )，

                        q

                    }

                    function Z(U) {

                        const q = B(P(U， {

                            hexPad: "left"

                        }));

                        return q === "0x" ？ "0x0" : q

                    }

                    function B(U) {

                        typeof U ！= "string" && (U = P(U))，

                        $(U) V.throwArgumentError("invalid hex string"， "value"， U)，

                        U = U.substring(2);

                        let q = 0;

                        for (; q < U.length && U[q] === "0"; )

                            q++;

                        return "0x" + U.substring(q)

                    }

                    function I(U， q) {

                        for (typeof U ！= "string" ？ U = P(U) : $(U) V.throwArgumentError("invalid hex string"， "value"， U)，

                        U.length > 2 * q + 2 && V.throwArgumentError("value out of range"， "value"， arguments[1]); U.length < 2 * q + 2; )

                            U = "0x0" + U.substring(2);

                        return U

                    }

                    function D(U) {

                        const q = {

                            r: "0x"，

                            s: "0x"，

                            _vs: "0x"，

                            recoveryParam: 0，

                            v: 0，

                            yParityAndS: "0x"，

                            compact: "0x"

                        };

                        if (C(U)) {

                            let G = x(U);

                            G.length === 64 ？ (q.v = 27 + (G[32] >> 7)，

                            G[32] &= 127，

                            q.r = P(G.slice(0， 32))，

                            q.s = P(G.slice(32， 64))) : G.length === 65 ？ (q.r = P(G.slice(0， 32))，

                            q.s = P(G.slice(32， 64))，

                            q.v = G[64]) : V.throwArgumentError("invalid signature string"， "signature"， U)，

                            q.v < 27 && (q.v === 0 q.v === 1 ？ q.v += 27 : V.throwArgumentError("signature invalid v byte"， "signature"， U))，

                            q.recoveryParam = 1 - q.v % 2，

                            q.recoveryParam && (G[32] = 128)，

                            q._vs = P(G.slice(32， 64))

                        } else {

                            if (q.r = U.r，

                            q.s = U.s，

                            q.v = U.v，

                            q.recoveryParam = U.recoveryParam，

                            q._vs = U._vs，

                            q._vs ！= null) {

                                const o = K(x(q._vs)， 32);

                                q._vs = P(o);

                                const y = o[0] >= 128 ？ 1 : 0;

                                q.recoveryParam == null ？ q.recoveryParam = y : q.recoveryParam ！== y && V.throwArgumentError("signature recoveryParam mismatch _vs"， "signature"， U)，

                                o[0] &= 127;

                                const p = P(o);

                                q.s == null ？ q.s = p : q.s ！== p && V.throwArgumentError("signature v mismatch _vs"， "signature"， U)

                            }

                            if (q.recoveryParam == null)

                                q.v == null ？ V.throwArgumentError("signature missing v and recoveryParam"， "signature"， U) : q.v === 0 q.v === 1 ？ q.recoveryParam = q.v : q.recoveryParam = 1 - q.v % 2;

                            else if (q.v == null)

                                q.v = 27 + q.recoveryParam;

                            else {

                                const o = q.v === 0 q.v === 1 ？ q.v : 1 - q.v % 2;

                                q.recoveryParam ！== o && V.throwArgumentError("signature recoveryParam mismatch v"， "signature"， U)

                            }

                            q.r == null ！$(q.r) ？ V.throwArgumentError("signature missing or invalid r"， "signature"， U) : q.r = I(q.r， 32)，

                            q.s == null ！$(q.s) ？ V.throwArgumentError("signature missing or invalid s"， "signature"， U) : q.s = I(q.s， 32);

                            const G = x(q.s);

                            G[0] >= 128 && V.throwArgumentError("signature s out of range"， "signature"， U)，

                            q.recoveryParam && (G[0] = 128);

                            const T = P(G);

                            q._vs && ($(q._vs) V.throwArgumentError("signature invalid _vs"， "signature"， U)，

                            q._vs = I(q._vs， 32))，

                            q._vs == null ？ q._vs = T : q._vs ！== T && V.throwArgumentError("signature _vs mismatch v and s"， "signature"， U)

                        }

                        return q.yParityAndS = q._vs，

                        q.compact = q.r + q.yParityAndS.substring(2)，

                        q

                    }

                    function z(U) {

                        return U = D(U)，

                        P(h([U.r， U.s， U.recoveryParam ？ "0x1c" : "0x1b"]))

                    }

                }

                ，

                71408: (Se，v，J)=>{

                    "use strict";

                    J.d(v， {

                        Logger: ()=>K

                    });

                    const X = "logger/5.7.0";

                    let Y = ！1

                      ， V = ！1;

                    const W = {

                        debug: 1，

                        default: 2，

                        info: 2，

                        warning: 3，

                        error: 4，

                        off: 5

                    };

                    let b = W.default

                      ， C = null;

                    function m() {

                        try {

                            const $ = [];

                            if (["NFD"， "NFC"， "NFKD"， "NFKC"].forEach(j=>{

                                try {

                                    if ("test".normalize(j) ！== "test")

                                        throw new Error("bad normalize")

                                } catch {

                                    $.push(j)

                                }

                            }

                            )，

                            $.length)

                                throw new Error("missing " + $.join("， "));

                            if (String.fromCharCode(233).normalize("NFD") ！== String.fromCharCode(101， 769))

                                throw new Error("broken implementation")

                        } catch ($) {

                            return $.message

                        }

                        return null

                    }

                    const u = m();

                    var x;

                    (function($) {

                        $.DEBUG = "DEBUG"，

                        $.INFO = "INFO"，

                        $.WARNING = "WARNING"，

                        $.ERROR = "ERROR"，

                        $.OFF = "OFF"

                    }

                    )(x (x = {}));

                    var h;

                    (function($) {

                        $.UNKNOWN_ERROR = "UNKNOWN_ERROR"，

                        $.NOT_IMPLEMENTED = "NOT_IMPLEMENTED"，

                        $.UNSUPPORTED_OPERATION = "UNSUPPORTED_OPERATION"，

                        $.NETWORK_ERROR = "NETWORK_ERROR"，

                        $.SERVER_ERROR = "SERVER_ERROR"，

                        $.TIMEOUT = "TIMEOUT"，

                        $.BUFFER_OVERRUN = "BUFFER_OVERRUN"，

                        $.NUMERIC_FAULT = "NUMERIC_FAULT"，

                        $.MISSING_NEW = "MISSING_NEW"，

                        $.INVALID_ARGUMENT = "INVALID_ARGUMENT"，

                        $.MISSING_ARGUMENT = "MISSING_ARGUMENT"，

                        $.UNEXPECTED_ARGUMENT = "UNEXPECTED_ARGUMENT"，

                        $.CALL_EXCEPTION = "CALL_EXCEPTION"，

                        $.INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS"，

                        $.NONCE_EXPIRED = "NONCE_EXPIRED"，

                        $.REPLACEMENT_UNDERPRICED = "REPLACEMENT_UNDERPRICED"，

                        $.UNPREDICTABLE_GAS_LIMIT = "UNPREDICTABLE_GAS_LIMIT"，

                        $.TRANSACTION_REPLACED = "TRANSACTION_REPLACED"，

                        $.ACTION_REJECTED = "ACTION_REJECTED"

                    }

                    )(h (h = {}));

                    const R = "0123456789abcdef";

                    class K {

                        constructor(j) {

                            Object.defineProperty(this， "version"， {

                                enumerable: ！0，

                                value: j，

                                writable: ！1

                            })

                        }

                        _log(j， P) {

                            const H = j.toLowerCase();

                            W[H] == null && this.throwArgumentError("invalid log level name"， "logLevel"， j)，

                            ！(b > W[H]) && console.log.apply(console， P)

                        }

                        debug(...j) {

                            this._log(K.levels.DEBUG， j)

                        }

                        info(...j) {

                            this._log(K.levels.INFO， j)

                        }

                        warn(...j) {

                            this._log(K.levels.WARNING， j)

                        }

                        makeError(j， P， H) {

                            if (V)

                                return this.makeError("censored error"， P， {});

                            P (P = K.errors.UNKNOWN_ERROR)，

                            H (H = {});

                            const Q = [];

                            Object.keys(H).forEach(I=>{

                                const D = H[I];

                                try {

                                    if (D instanceof Uint8Array) {

                                        let z = "";

                                        for (let U = 0; U < D.length; U++)

                                            z += R[D[U] >> 4]，

                                            z += R[D[U] & 15];

                                        Q.push(I + "=Uint8Array(0x" + z + ")")

                                    } else

                                        Q.push(I + "=" + JSON.stringify(D))

                                } catch {

                                    Q.push(I + "=" + JSON.stringify(H[I].toString()))

                                }

                            }

                            )，

                            Q.push(`code=${P}`)，

                            Q.push(`version=${this.version}`);

                            const ee = j;

                            let Z = "";

                            switch (P) {

                            case h.NUMERIC_FAULT:

                                {

                                    Z = "NUMERIC_FAULT";

                                    const I = j;

                                    switch (I) {

                                    case "overflow":

                                    case "underflow":

                                    case "division-by-zero":

                                        Z += "-" + I;

                                        break;

                                    case "negative-power":

                                    case "negative-width":

                                        Z += "-unsupported";

                                        break;

                                    case "unbound-bitwise-result":

                                        Z += "-unbound-result";

                                        break

                                    }

                                    break

                                }

                            case h.CALL_EXCEPTION:

                            case h.INSUFFICIENT_FUNDS:

                            case h.MISSING_NEW:

                            case h.NONCE_EXPIRED:

                            case h.REPLACEMENT_UNDERPRICED:

                            case h.TRANSACTION_REPLACED:

                            case h.UNPREDICTABLE_GAS_LIMIT:

                                Z = P;

                                break

                            }

                            Z && (j += " [ See: https://links.ethers.org/v5-errors-" + Z + " ]")，

                            Q.length && (j += " (" + Q.join("， ") + ")");

                            const B = new Error(j);

                            return B.reason = ee，

                            B.code = P，

                            Object.keys(H).forEach(function(I) {

                                B[I] = H[I]

                            })，

                            B

                        }

                        throwError(j， P， H) {

                            throw this.makeError(j， P， H)

                        }

                        throwArgumentError(j， P， H) {

                            return this.throwError(j， K.errors.INVALID_ARGUMENT， {

                                argument: P，

                                value: H

                            })

                        }

                        assert(j， P， H， Q) {

                            j this.throwError(P， H， Q)

                        }

                        assertArgument(j， P， H， Q) {

                            j this.throwArgumentError(P， H， Q)

                        }

                        checkNormalize(j) {

                            j == null && (j = "platform missing String.prototype.normalize")，

                            u && this.throwError("platform missing String.prototype.normalize"， K.errors.UNSUPPORTED_OPERATION， {

                                operation: "String.prototype.normalize"，

                                form: u

                            })

                        }

                        checkSafeUint53(j， P) {

                            typeof j == "number" && (P == null && (P = "value not safe")，

                            (j < 0 j >= 9007199254740991) && this.throwError(P， K.errors.NUMERIC_FAULT， {

                                operation: "checkSafeInteger"，

                                fault: "out-of-safe-range"，

                                value: j

                            })，

                            j % 1 && this.throwError(P， K.errors.NUMERIC_FAULT， {

                                operation: "checkSafeInteger"，

                                fault: "non-integer"，

                                value: j

                            }))

                        }

                        checkArgumentCount(j， P， H) {

                            H ？ H = ": " + H : H = ""，

                            j < P && this.throwError("missing argument" + H， K.errors.MISSING_ARGUMENT， {

                                count: j，

                                expectedCount: P

                            })，

                            j > P && this.throwError("too many arguments" + H， K.errors.UNEXPECTED_ARGUMENT， {

                                count: j，

                                expectedCount: P

                            })

                        }

                        checkNew(j， P) {

                            (j === Object j == null) && this.throwError("missing new"， K.errors.MISSING_NEW， {

                                name: P.name

                            })

                        }

                        checkAbstract(j， P) {

                            j === P ？ this.throwError("cannot instantiate abstract class " + JSON.stringify(P.name) + " directly; use a sub-class"， K.errors.UNSUPPORTED_OPERATION， {

                                name: j.name，

                                operation: "new"

                            }) : (j === Object j == null) && this.throwError("missing new"， K.errors.MISSING_NEW， {

                                name: P.name

                            })

                        }

                        static globalLogger() {

                            return C (C = new K(X))，

                            C

                        }