Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library SignedMath    - function max(int256 a, int256 b)    - function min(int256 a, int256 b)    - function average(int256 a, int256 b)    - function abs(int256 n) library Math    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(uint256 x, uint256 y, ...    - function mulDiv(uint256 x, uint256 y, ...    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ...    - function unsignedRoundsUp(Rounding ro ... library Strings    - function toString(uint256 value)    - function toStringSigned(int256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function equal(string memory a, strin ... library MessageHashUtils    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toDataWithIntendedValidatorH ...    - function toTypedDataHash(bytes32 doma ... library ECDSA    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes3 ...    - function tryRecover(    - function recover(bytes32 hash, uint8 ...    - function _throwError(RecoverError err ... interface IERC20Errors interface IERC721Errors interface IERC1155Errors    - function _msgSender()    - function _msgData()    - function _contextSuffixLength()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ... interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ...    - function _transfer(address from, addr ...    - function _update(address from, addres ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _approve(address owner, addr ...    - function _spendAllowance(address owne ...  contract EZSwapToken is ERC20, Own ... *    - function _validSignature(    - function claim(    - function sweep()    - function mintToDev()    - function updateClaimSigner(address ne ...    - function updateDevAddress(address new ...    - function updateDeadline(uint256 newDe ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-01-17
*/

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;


/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: contracts/EZSwapToken.sol


pragma solidity ^0.8.0;





/**
 * @title EZSwap Token Contract
 * @dev ERC20 Token with a capped supply and claimable functionality based on signatures.
 */
contract EZSwapToken is ERC20, Ownable {
    using ECDSA for bytes32;

    address public claimSigner; // The address authorized to sign claim messages.
    address public devAddress; // The developer's address for initial token allocation and sweeping unclaimed tokens.
    mapping(address => bool) public claimed; // Tracks whether an address has already claimed tokens.
    uint256 public deadline; // The block number after which no more tokens can be claimed.
    bool private devMinted = false; // Ensures the initial minting for the developer can only happen once.

    // Constants
    uint256 public constant DEV_SUPPLY = 900000000 * 10 ** 18; // 900,000,000 EZT for the developer.
    uint256 public constant MAX_SUPPLY = 1000000000 * 10 ** 18; // The total cap of 1 Billion EZT.

    /**
     * @dev Constructor for EZSwap initializing the token, roles, and supply.
     * @param _signer The address allowed to sign claim messages.
     * @param _devAddress The address of the developer for initial minting.
     * @param _deadline The block number after which no more tokens can be claimed.
     */
    constructor(
        address _signer,
        address _devAddress,
        uint256 _deadline
    ) ERC20("EZ", "EZ") Ownable(msg.sender) {
        require(
            _signer != address(0),
            "Signer address cannot be the zero address"
        );
        require(
            _devAddress != address(0),
            "Developer address cannot be the zero address"
        );
        require(_deadline > block.number, "New deadline must be in the future");

        claimSigner = _signer;
        devAddress = _devAddress;
        deadline = _deadline;
    }

    /**
     * @dev Internal function to validate if the provided signature matches the expected signer.
     * @param signature The provided signature to verify.
     * @param msgHash The hash of the original message that was signed.
     * @return bool Returns true if the signature is valid and from the expected signer.
     */
    function _validSignature(
        bytes memory signature,
        bytes32 msgHash
    ) internal view returns (bool) {
        return
            MessageHashUtils.toEthSignedMessageHash(msgHash).recover(
                signature
            ) == claimSigner;
    }

    /**
     * @dev Allows users to claim tokens if they have a valid signature.
     * @param user The address of the user claiming tokens.
     * @param amount The amount of tokens being claimed.
     * @param signature The signature proving the claim is valid.
     */
    function claim(
        address user,
        uint256 amount,
        bytes calldata signature
    ) external {
        require(block.number <= deadline, "Claim period is over");
        require(!claimed[user], "Tokens already claimed for this address");
        require(
            totalSupply() + amount <= MAX_SUPPLY,
            "Claim would exceed max supply"
        );

        bytes32 msgHash = keccak256(abi.encode(user, amount, address(this)));
        require(_validSignature(signature, msgHash), "Invalid signature");

        claimed[user] = true;
        _mint(user, amount);
    }

    /**
     * @dev Allows the owner to sweep unclaimed tokens after the deadline.
     * This moves all remaining unclaimed tokens to the developer's address.
     */
    function sweep() external onlyOwner {
        require(block.number > deadline, "The deadline has not passed yet");
        uint256 remainingSupply = MAX_SUPPLY - totalSupply();
        require(
            totalSupply() + remainingSupply <= MAX_SUPPLY,
            "Minting would exceed max supply"
        );
        _mint(devAddress, remainingSupply);
    }

    /**
     * @dev Allows the owner to mint tokens to the developer's address once.
     * This is meant for initial distribution to the developer.
     */
    function mintToDev() external onlyOwner {
        require(!devMinted, "Initial dev minting has already been done");
        require(
            totalSupply() + DEV_SUPPLY <= MAX_SUPPLY,
            "Minting would exceed max supply"
        );
        devMinted = true;
        _mint(devAddress, DEV_SUPPLY);
    }

    // Owner administrative functions

    /**
     * @dev Allows the owner to update the signer address.
     * @param newSigner The new signer address.
     */
    function updateClaimSigner(address newSigner) external onlyOwner {
        require(
            newSigner != address(0),
            "New signer cannot be the zero address"
        );
        claimSigner = newSigner;
    }

    /**
     * @dev Allows the owner to update the developer address.
     * @param newDevAddress The new developer address.
     */
    function updateDevAddress(address newDevAddress) external onlyOwner {
        require(
            newDevAddress != address(0),
            "New developer address cannot be the zero address"
        );
        devAddress = newDevAddress;
    }

    /**
     * @dev Allows the owner to update the deadline for claiming tokens.
     * @param newDeadline The new deadline (block number).
     */
    function updateDeadline(uint256 newDeadline) external onlyOwner {
        require(
            newDeadline > block.number,
            "New deadline must be in the future"
        );
        deadline = newDeadline;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_signer","type":"address"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"uint256","name":"_deadline","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEV_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadline","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintToDev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sweep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newSigner","type":"address"}],"name":"updateClaimSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newDeadline","type":"uint256"}],"name":"updateDeadline","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newDevAddress","type":"address"}],"name":"updateDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000738dbfaaa2d63134099d7e32a289291624e0773c00000000000000000000000091b2ead1684ad599e86b3691ab22adaa99198d28000000000000000000000000000000000000000000000000000000000123c235

-----Decoded View---------------
Arg [0] : _signer (address): 0x738DBfAAA2d63134099D7e32A289291624E0773C
Arg [1] : _devAddress (address): 0x91B2eaD1684AD599e86B3691AB22adAA99198d28
Arg [2] : _deadline (uint256): 19120693

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000738dbfaaa2d63134099d7e32a289291624e0773c
Arg [1] : 00000000000000000000000091b2ead1684ad599e86b3691ab22adaa99198d28
Arg [2] : 000000000000000000000000000000000000000000000000000000000123c235

57837:5461:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48298:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50591:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49400:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51359:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58220:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61789:322;;;:::i;:::-;;49251:84;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58543:58;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61253:367;;;:::i;:::-;;57998:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62287:228;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63069:226;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49562:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41911:103;;;:::i;:::-;;62660:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41236:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60460:613;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48508:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49885:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58441:57;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58117:39;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57915:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50130:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42169:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48298:91;48343:13;48376:5;48369:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48298:91;:::o;50591:190::-;50664:4;50681:13;50697:12;:10;:12::i;:::-;50681:28;;50720:31;50729:5;50736:7;50745:5;50720:8;:31::i;:::-;50769:4;50762:11;;;50591:190;;;;:::o;49400:99::-;49452:7;49479:12;;49472:19;;49400:99;:::o;51359:249::-;51446:4;51463:15;51481:12;:10;:12::i;:::-;51463:30;;51504:37;51520:4;51526:7;51535:5;51504:15;:37::i;:::-;51552:26;51562:4;51568:2;51572:5;51552:9;:26::i;:::-;51596:4;51589:11;;;51359:249;;;;;:::o;58220:23::-;;;;:::o;61789:322::-;41122:13;:11;:13::i;:::-;61849:9:::1;;;;;;;;;;;61848:10;61840:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;58580:21;58478:20;61937:13;:11;:13::i;:::-;:26;;;;:::i;:::-;:40;;61915:121;;;;;;;;;;;;:::i;:::-;;;;;;;;;62059:4;62047:9;;:16;;;;;;;;;;;;;;;;;;62074:29;62080:10;;;;;;;;;;;58478:20;62074:5;:29::i;:::-;61789:322::o:0;49251:84::-;49300:5;49325:2;49318:9;;49251:84;:::o;58543:58::-;58580:21;58543:58;:::o;61253:367::-;41122:13;:11;:13::i;:::-;61323:8:::1;;61308:12;:23;61300:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;61378:23;61417:13;:11;:13::i;:::-;58580:21;61404:26;;;;:::i;:::-;61378:52;;58580:21;61479:15;61463:13;:11;:13::i;:::-;:31;;;;:::i;:::-;:45;;61441:126;;;;;;;;;;;;:::i;:::-;;;;;;;;;61578:34;61584:10;;;;;;;;;;;61596:15;61578:5;:34::i;:::-;61289:331;61253:367::o:0;57998:25::-;;;;;;;;;;;;;:::o;62287:228::-;41122:13;:11;:13::i;:::-;62406:1:::1;62385:23;;:9;:23;;::::0;62363:110:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;62498:9;62484:11;;:23;;;;;;;;;;;;;;;;;;62287:228:::0;:::o;63069:226::-;41122:13;:11;:13::i;:::-;63180:12:::1;63166:11;:26;63144:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;63276:11;63265:8;:22;;;;63069:226:::0;:::o;49562:118::-;49627:7;49654:9;:18;49664:7;49654:18;;;;;;;;;;;;;;;;49647:25;;49562:118;;;:::o;41911:103::-;41122:13;:11;:13::i;:::-;41976:30:::1;42003:1;41976:18;:30::i;:::-;41911:103::o:0;62660:249::-;41122:13;:11;:13::i;:::-;62786:1:::1;62761:27;;:13;:27;;::::0;62739:125:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;62888:13;62875:10;;:26;;;;;;;;;;;;;;;;;;62660:249:::0;:::o;41236:87::-;41282:7;41309:6;;;;;;;;;;;41302:13;;41236:87;:::o;60460:613::-;60609:8;;60593:12;:24;;60585:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;60662:7;:13;60670:4;60662:13;;;;;;;;;;;;;;;;;;;;;;;;;60661:14;60653:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;58580:21;60768:6;60752:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:36;;60730:115;;;;;;;;;;;;:::i;:::-;;;;;;;;;60858:15;60897:4;60903:6;60919:4;60886:39;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60876:50;;;;;;60858:68;;60945:35;60961:9;;60945:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60972:7;60945:15;:35::i;:::-;60937:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;61031:4;61015:7;:13;61023:4;61015:13;;;;;;;;;;;;;;;;:20;;;;;;;;;;;;;;;;;;61046:19;61052:4;61058:6;61046:5;:19::i;:::-;60574:499;60460:613;;;;:::o;48508:95::-;48555:13;48588:7;48581:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48508:95;:::o;49885:182::-;49954:4;49971:13;49987:12;:10;:12::i;:::-;49971:28;;50010:27;50020:5;50027:2;50031:5;50010:9;:27::i;:::-;50055:4;50048:11;;;49885:182;;;;:::o;58441:57::-;58478:20;58441:57;:::o;58117:39::-;;;;;;;;;;;;;;;;;;;;;;:::o;57915:26::-;;;;;;;;;;;;;:::o;50130:142::-;50210:7;50237:11;:18;50249:5;50237:18;;;;;;;;;;;;;;;:27;50256:7;50237:27;;;;;;;;;;;;;;;;50230:34;;50130:142;;;;:::o;42169:220::-;41122:13;:11;:13::i;:::-;42274:1:::1;42254:22;;:8;:22;;::::0;42250:93:::1;;42328:1;42300:31;;;;;;;;;;;:::i;:::-;;;;;;;;42250:93;42353:28;42372:8;42353:18;:28::i;:::-;42169:220:::0;:::o;39245:98::-;39298:7;39325:10;39318:17;;39245:98;:::o;55418:130::-;55503:37;55512:5;55519:7;55528:5;55535:4;55503:8;:37::i;:::-;55418:130;;;:::o;57134:487::-;57234:24;57261:25;57271:5;57278:7;57261:9;:25::i;:::-;57234:52;;57321:17;57301:16;:37;57297:317;;57378:5;57359:16;:24;57355:132;;;57438:7;57447:16;57465:5;57411:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;57355:132;57530:57;57539:5;57546:7;57574:5;57555:16;:24;57581:5;57530:8;:57::i;:::-;57297:317;57223:398;57134:487;;;:::o;51993:308::-;52093:1;52077:18;;:4;:18;;;52073:88;;52146:1;52119:30;;;;;;;;;;;:::i;:::-;;;;;;;;52073:88;52189:1;52175:16;;:2;:16;;;52171:88;;52244:1;52215:32;;;;;;;;;;;:::i;:::-;;;;;;;;52171:88;52269:24;52277:4;52283:2;52287:5;52269:7;:24::i;:::-;51993:308;;;:::o;41401:166::-;41472:12;:10;:12::i;:::-;41461:23;;:7;:5;:7::i;:::-;:23;;;41457:103;;41535:12;:10;:12::i;:::-;41508:40;;;;;;;;;;;:::i;:::-;;;;;;;;41457:103;41401:166::o;54113:213::-;54203:1;54184:21;;:7;:21;;;54180:93;;54258:1;54229:32;;;;;;;;;;;:::i;:::-;;;;;;;;54180:93;54283:35;54299:1;54303:7;54312:5;54283:7;:35::i;:::-;54113:213;;:::o;42549:191::-;42623:16;42642:6;;;;;;;;;;;42623:25;;42668:8;42659:6;;:17;;;;;;;;;;;;;;;;;;42723:8;42692:40;;42713:8;42692:40;;;;;;;;;;;;42612:128;42549:191;:::o;59901:273::-;60015:4;60155:11;;;;;;;;;;;60052:114;;:99;60127:9;60052:48;60092:7;60052:39;:48::i;:::-;:56;;:99;;;;:::i;:::-;:114;;;60032:134;;59901:273;;;;:::o;56399:443::-;56529:1;56512:19;;:5;:19;;;56508:91;;56584:1;56555:32;;;;;;;;;;;:::i;:::-;;;;;;;;56508:91;56632:1;56613:21;;:7;:21;;;56609:92;;56686:1;56658:31;;;;;;;;;;;:::i;:::-;;;;;;;;56609:92;56741:5;56711:11;:18;56723:5;56711:18;;;;;;;;;;;;;;;:27;56730:7;56711:27;;;;;;;;;;;;;;;:35;;;;56761:9;56757:78;;;56808:7;56792:31;;56801:5;56792:31;;;56817:5;56792:31;;;;;;:::i;:::-;;;;;;;;56757:78;56399:443;;;;:::o;52625:1135::-;52731:1;52715:18;;:4;:18;;;52711:552;;52869:5;52853:12;;:21;;;;;;;:::i;:::-;;;;;;;;52711:552;;;52907:19;52929:9;:15;52939:4;52929:15;;;;;;;;;;;;;;;;52907:37;;52977:5;52963:11;:19;52959:117;;;53035:4;53041:11;53054:5;53010:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;52959:117;53231:5;53217:11;:19;53199:9;:15;53209:4;53199:15;;;;;;;;;;;;;;;:37;;;;52892:371;52711:552;53293:1;53279:16;;:2;:16;;;53275:435;;53461:5;53445:12;;:21;;;;;;;;;;;53275:435;;;53678:5;53661:9;:13;53671:2;53661:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;53275:435;53742:2;53727:25;;53736:4;53727:25;;;53746:5;53727:25;;;;;;:::i;:::-;;;;;;;;52625:1135;;;:::o;21285:467::-;21361:14;21469:34;21463:4;21456:48;21572:11;21566:4;21559:25;21665:4;21659;21649:21;21639:31;;21285:467;;;:::o;27703:259::-;27781:7;27802:17;27821:18;27841:16;27861:27;27872:4;27878:9;27861:10;:27::i;:::-;27801:87;;;;;;27899:28;27911:5;27918:8;27899:11;:28::i;:::-;27945:9;27938:16;;;;;27703:259;;;;:::o;26097:783::-;26178:7;26187:12;26201:7;26245:2;26225:9;:16;:22;26221:652;;26264:9;26288;26312:7;26569:4;26558:9;26554:20;26548:27;26543:32;;26619:4;26608:9;26604:20;26598:27;26593:32;;26677:4;26666:9;26662:20;26656:27;26653:1;26648:36;26643:41;;26720:25;26731:4;26737:1;26740;26743;26720:10;:25::i;:::-;26713:32;;;;;;;;;;;26221:652;26794:1;26798:35;26843:9;:16;26835:25;;26778:83;;;;;;26097:783;;;;;;:::o;31271:542::-;31367:20;31358:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;31354:452;31404:7;31354:452;31465:29;31456:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;31452:354;;31518:23;;;;;;;;;;;;;;31452:354;31572:35;31563:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;31559:247;;31667:8;31659:17;;31631:46;;;;;;;;;;;:::i;:::-;;;;;;;;31559:247;31708:30;31699:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;31695:111;;31785:8;31762:32;;;;;;;;;;;:::i;:::-;;;;;;;;31695:111;31271:542;;;:::o;29174:1556::-;29305:7;29314:12;29328:7;30248:66;30243:1;30235:10;;:79;30231:166;;;30347:1;30351:30;30383:1;30331:54;;;;;;;;30231:166;30494:14;30511:24;30521:4;30527:1;30530;30533;30511:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30494:41;;30568:1;30550:20;;:6;:20;;;30546:115;;30603:1;30607:29;30646:1;30638:10;;30587:62;;;;;;;;;30546:115;30681:6;30689:20;30719:1;30711:10;;30673:49;;;;;;;29174:1556;;;;;;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1553:117;1662:1;1659;1652:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:86::-;4458:7;4498:4;4491:5;4487:16;4476:27;;4423:86;;;:::o;4515:112::-;4598:22;4614:5;4598:22;:::i;:::-;4593:3;4586:35;4515:112;;:::o;4633:214::-;4722:4;4760:2;4749:9;4745:18;4737:26;;4773:67;4837:1;4826:9;4822:17;4813:6;4773:67;:::i;:::-;4633:214;;;;:::o;4853:118::-;4940:24;4958:5;4940:24;:::i;:::-;4935:3;4928:37;4853:118;;:::o;4977:222::-;5070:4;5108:2;5097:9;5093:18;5085:26;;5121:71;5189:1;5178:9;5174:17;5165:6;5121:71;:::i;:::-;4977:222;;;;:::o;5205:329::-;5264:6;5313:2;5301:9;5292:7;5288:23;5284:32;5281:119;;;5319:79;;:::i;:::-;5281:119;5439:1;5464:53;5509:7;5500:6;5489:9;5485:22;5464:53;:::i;:::-;5454:63;;5410:117;5205:329;;;;:::o;5540:::-;5599:6;5648:2;5636:9;5627:7;5623:23;5619:32;5616:119;;;5654:79;;:::i;:::-;5616:119;5774:1;5799:53;5844:7;5835:6;5824:9;5820:22;5799:53;:::i;:::-;5789:63;;5745:117;5540:329;;;;:::o;5875:117::-;5984:1;5981;5974:12;5998:117;6107:1;6104;6097:12;6121:117;6230:1;6227;6220:12;6257:552;6314:8;6324:6;6374:3;6367:4;6359:6;6355:17;6351:27;6341:122;;6382:79;;:::i;:::-;6341:122;6495:6;6482:20;6472:30;;6525:18;6517:6;6514:30;6511:117;;;6547:79;;:::i;:::-;6511:117;6661:4;6653:6;6649:17;6637:29;;6715:3;6707:4;6699:6;6695:17;6685:8;6681:32;6678:41;6675:128;;;6722:79;;:::i;:::-;6675:128;6257:552;;;;;:::o;6815:817::-;6903:6;6911;6919;6927;6976:2;6964:9;6955:7;6951:23;6947:32;6944:119;;;6982:79;;:::i;:::-;6944:119;7102:1;7127:53;7172:7;7163:6;7152:9;7148:22;7127:53;:::i;:::-;7117:63;;7073:117;7229:2;7255:53;7300:7;7291:6;7280:9;7276:22;7255:53;:::i;:::-;7245:63;;7200:118;7385:2;7374:9;7370:18;7357:32;7416:18;7408:6;7405:30;7402:117;;;7438:79;;:::i;:::-;7402:117;7551:64;7607:7;7598:6;7587:9;7583:22;7551:64;:::i;:::-;7533:82;;;;7328:297;6815:817;;;;;;;:::o;7638:474::-;7706:6;7714;7763:2;7751:9;7742:7;7738:23;7734:32;7731:119;;;7769:79;;:::i;:::-;7731:119;7889:1;7914:53;7959:7;7950:6;7939:9;7935:22;7914:53;:::i;:::-;7904:63;;7860:117;8016:2;8042:53;8087:7;8078:6;8067:9;8063:22;8042:53;:::i;:::-;8032:63;;7987:118;7638:474;;;;;:::o;8118:180::-;8166:77;8163:1;8156:88;8263:4;8260:1;8253:15;8287:4;8284:1;8277:15;8304:320;8348:6;8385:1;8379:4;8375:12;8365:22;;8432:1;8426:4;8422:12;8453:18;8443:81;;8509:4;8501:6;8497:17;8487:27;;8443:81;8571:2;8563:6;8560:14;8540:18;8537:38;8534:84;;8590:18;;:::i;:::-;8534:84;8355:269;8304:320;;;:::o;8630:228::-;8770:34;8766:1;8758:6;8754:14;8747:58;8839:11;8834:2;8826:6;8822:15;8815:36;8630:228;:::o;8864:366::-;9006:3;9027:67;9091:2;9086:3;9027:67;:::i;:::-;9020:74;;9103:93;9192:3;9103:93;:::i;:::-;9221:2;9216:3;9212:12;9205:19;;8864:366;;;:::o;9236:419::-;9402:4;9440:2;9429:9;9425:18;9417:26;;9489:9;9483:4;9479:20;9475:1;9464:9;9460:17;9453:47;9517:131;9643:4;9517:131;:::i;:::-;9509:139;;9236:419;;;:::o;9661:180::-;9709:77;9706:1;9699:88;9806:4;9803:1;9796:15;9830:4;9827:1;9820:15;9847:191;9887:3;9906:20;9924:1;9906:20;:::i;:::-;9901:25;;9940:20;9958:1;9940:20;:::i;:::-;9935:25;;9983:1;9980;9976:9;9969:16;;10004:3;10001:1;9998:10;9995:36;;;10011:18;;:::i;:::-;9995:36;9847:191;;;;:::o;10044:181::-;10184:33;10180:1;10172:6;10168:14;10161:57;10044:181;:::o;10231:366::-;10373:3;10394:67;10458:2;10453:3;10394:67;:::i;:::-;10387:74;;10470:93;10559:3;10470:93;:::i;:::-;10588:2;10583:3;10579:12;10572:19;;10231:366;;;:::o;10603:419::-;10769:4;10807:2;10796:9;10792:18;10784:26;;10856:9;10850:4;10846:20;10842:1;10831:9;10827:17;10820:47;10884:131;11010:4;10884:131;:::i;:::-;10876:139;;10603:419;;;:::o;11028:181::-;11168:33;11164:1;11156:6;11152:14;11145:57;11028:181;:::o;11215:366::-;11357:3;11378:67;11442:2;11437:3;11378:67;:::i;:::-;11371:74;;11454:93;11543:3;11454:93;:::i;:::-;11572:2;11567:3;11563:12;11556:19;;11215:366;;;:::o;11587:419::-;11753:4;11791:2;11780:9;11776:18;11768:26;;11840:9;11834:4;11830:20;11826:1;11815:9;11811:17;11804:47;11868:131;11994:4;11868:131;:::i;:::-;11860:139;;11587:419;;;:::o;12012:194::-;12052:4;12072:20;12090:1;12072:20;:::i;:::-;12067:25;;12106:20;12124:1;12106:20;:::i;:::-;12101:25;;12150:1;12147;12143:9;12135:17;;12174:1;12168:4;12165:11;12162:37;;;12179:18;;:::i;:::-;12162:37;12012:194;;;;:::o;12212:224::-;12352:34;12348:1;12340:6;12336:14;12329:58;12421:7;12416:2;12408:6;12404:15;12397:32;12212:224;:::o;12442:366::-;12584:3;12605:67;12669:2;12664:3;12605:67;:::i;:::-;12598:74;;12681:93;12770:3;12681:93;:::i;:::-;12799:2;12794:3;12790:12;12783:19;;12442:366;;;:::o;12814:419::-;12980:4;13018:2;13007:9;13003:18;12995:26;;13067:9;13061:4;13057:20;13053:1;13042:9;13038:17;13031:47;13095:131;13221:4;13095:131;:::i;:::-;13087:139;;12814:419;;;:::o;13239:221::-;13379:34;13375:1;13367:6;13363:14;13356:58;13448:4;13443:2;13435:6;13431:15;13424:29;13239:221;:::o;13466:366::-;13608:3;13629:67;13693:2;13688:3;13629:67;:::i;:::-;13622:74;;13705:93;13794:3;13705:93;:::i;:::-;13823:2;13818:3;13814:12;13807:19;;13466:366;;;:::o;13838:419::-;14004:4;14042:2;14031:9;14027:18;14019:26;;14091:9;14085:4;14081:20;14077:1;14066:9;14062:17;14055:47;14119:131;14245:4;14119:131;:::i;:::-;14111:139;;13838:419;;;:::o;14263:235::-;14403:34;14399:1;14391:6;14387:14;14380:58;14472:18;14467:2;14459:6;14455:15;14448:43;14263:235;:::o;14504:366::-;14646:3;14667:67;14731:2;14726:3;14667:67;:::i;:::-;14660:74;;14743:93;14832:3;14743:93;:::i;:::-;14861:2;14856:3;14852:12;14845:19;;14504:366;;;:::o;14876:419::-;15042:4;15080:2;15069:9;15065:18;15057:26;;15129:9;15123:4;15119:20;15115:1;15104:9;15100:17;15093:47;15157:131;15283:4;15157:131;:::i;:::-;15149:139;;14876:419;;;:::o;15301:170::-;15441:22;15437:1;15429:6;15425:14;15418:46;15301:170;:::o;15477:366::-;15619:3;15640:67;15704:2;15699:3;15640:67;:::i;:::-;15633:74;;15716:93;15805:3;15716:93;:::i;:::-;15834:2;15829:3;15825:12;15818:19;;15477:366;;;:::o;15849:419::-;16015:4;16053:2;16042:9;16038:18;16030:26;;16102:9;16096:4;16092:20;16088:1;16077:9;16073:17;16066:47;16130:131;16256:4;16130:131;:::i;:::-;16122:139;;15849:419;;;:::o;16274:226::-;16414:34;16410:1;16402:6;16398:14;16391:58;16483:9;16478:2;16470:6;16466:15;16459:34;16274:226;:::o;16506:366::-;16648:3;16669:67;16733:2;16728:3;16669:67;:::i;:::-;16662:74;;16745:93;16834:3;16745:93;:::i;:::-;16863:2;16858:3;16854:12;16847:19;;16506:366;;;:::o;16878:419::-;17044:4;17082:2;17071:9;17067:18;17059:26;;17131:9;17125:4;17121:20;17117:1;17106:9;17102:17;17095:47;17159:131;17285:4;17159:131;:::i;:::-;17151:139;;16878:419;;;:::o;17303:179::-;17443:31;17439:1;17431:6;17427:14;17420:55;17303:179;:::o;17488:366::-;17630:3;17651:67;17715:2;17710:3;17651:67;:::i;:::-;17644:74;;17727:93;17816:3;17727:93;:::i;:::-;17845:2;17840:3;17836:12;17829:19;;17488:366;;;:::o;17860:419::-;18026:4;18064:2;18053:9;18049:18;18041:26;;18113:9;18107:4;18103:20;18099:1;18088:9;18084:17;18077:47;18141:131;18267:4;18141:131;:::i;:::-;18133:139;;17860:419;;;:::o;18285:442::-;18434:4;18472:2;18461:9;18457:18;18449:26;;18485:71;18553:1;18542:9;18538:17;18529:6;18485:71;:::i;:::-;18566:72;18634:2;18623:9;18619:18;18610:6;18566:72;:::i;:::-;18648;18716:2;18705:9;18701:18;18692:6;18648:72;:::i;:::-;18285:442;;;;;;:::o;18733:167::-;18873:19;18869:1;18861:6;18857:14;18850:43;18733:167;:::o;18906:366::-;19048:3;19069:67;19133:2;19128:3;19069:67;:::i;:::-;19062:74;;19145:93;19234:3;19145:93;:::i;:::-;19263:2;19258:3;19254:12;19247:19;;18906:366;;;:::o;19278:419::-;19444:4;19482:2;19471:9;19467:18;19459:26;;19531:9;19525:4;19521:20;19517:1;19506:9;19502:17;19495:47;19559:131;19685:4;19559:131;:::i;:::-;19551:139;;19278:419;;;:::o;19703:442::-;19852:4;19890:2;19879:9;19875:18;19867:26;;19903:71;19971:1;19960:9;19956:17;19947:6;19903:71;:::i;:::-;19984:72;20052:2;20041:9;20037:18;20028:6;19984:72;:::i;:::-;20066;20134:2;20123:9;20119:18;20110:6;20066:72;:::i;:::-;19703:442;;;;;;:::o;20151:180::-;20199:77;20196:1;20189:88;20296:4;20293:1;20286:15;20320:4;20317:1;20310:15;20337:77;20374:7;20403:5;20392:16;;20337:77;;;:::o;20420:118::-;20507:24;20525:5;20507:24;:::i;:::-;20502:3;20495:37;20420:118;;:::o;20544:222::-;20637:4;20675:2;20664:9;20660:18;20652:26;;20688:71;20756:1;20745:9;20741:17;20732:6;20688:71;:::i;:::-;20544:222;;;;:::o;20772:545::-;20945:4;20983:3;20972:9;20968:19;20960:27;;20997:71;21065:1;21054:9;21050:17;21041:6;20997:71;:::i;:::-;21078:68;21142:2;21131:9;21127:18;21118:6;21078:68;:::i;:::-;21156:72;21224:2;21213:9;21209:18;21200:6;21156:72;:::i;:::-;21238;21306:2;21295:9;21291:18;21282:6;21238:72;:::i;:::-;20772:545;;;;;;;:::o

ipfs://e6fa4cc6bc32d971273ed7b80362292ecf3e9f396a2ae9a8e64f06a89b393398