Token

ERC-20: EthereumM (ETHM)

ERC-20

Overview

Max Total Supply

1,000,000,000 ETHM

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x32f04bfc1e527d8b9da2a0f5c0a1e475cbe5b84e

Filtered by Token Holder

0xA910f92ACdAf488fa6eF02174fb86208Ad7722ba

Poloniex 4

Balance

18,000,000 ETHM

Value

$0.00

0xa910f92acdaf488fa6ef02174fb86208ad7722ba

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

EthereumM

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-09-04
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol


// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC3156FlashBorrower.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC3156 FlashBorrower, as defined in
 * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
 *
 * _Available since v4.1._
 */
interface IERC3156FlashBorrower {
    /**
     * @dev Receive a flash loan.
     * @param initiator The initiator of the loan.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @param fee The additional amount of tokens to repay.
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
     * @return The keccak256 hash of "IERC3156FlashBorrower.onFlashLoan"
     */
    function onFlashLoan(
        address initiator,
        address token,
        uint256 amount,
        uint256 fee,
        bytes calldata data
    ) external returns (bytes32);
}

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


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC3156FlashLender.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface of the ERC3156 FlashLender, as defined in
 * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
 *
 * _Available since v4.1._
 */
interface IERC3156FlashLender {
    /**
     * @dev The amount of currency available to be lended.
     * @param token The loan currency.
     * @return The amount of `token` that can be borrowed.
     */
    function maxFlashLoan(address token) external view returns (uint256);

    /**
     * @dev The fee to be charged for a given loan.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @return The amount of `token` to be charged for the loan, on top of the returned principal.
     */
    function flashFee(address token, uint256 amount) external view returns (uint256);

    /**
     * @dev Initiate a flash loan.
     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
     */
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) external returns (bool);
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        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_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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);
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @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,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode 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 {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]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        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);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode 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 {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        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]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        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.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // 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);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // 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);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @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) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/draft-EIP712.sol


// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;


/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic 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 their contracts 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].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // 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 _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @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) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, 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 ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @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.
 */
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].
     */
    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/Counters.sol


// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. It the number is not a perfect square, the value is rounded down.
     *
     * 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)`.
        // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
        // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
        // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
        // good first aproximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1;
        uint256 x = a;
        if (x >> 128 > 0) {
            x >>= 128;
            result <<= 64;
        }
        if (x >> 64 > 0) {
            x >>= 64;
            result <<= 32;
        }
        if (x >> 32 > 0) {
            x >>= 32;
            result <<= 16;
        }
        if (x >> 16 > 0) {
            x >>= 16;
            result <<= 8;
        }
        if (x >> 8 > 0) {
            x >>= 8;
            result <<= 4;
        }
        if (x >> 4 > 0) {
            x >>= 4;
            result <<= 2;
        }
        if (x >> 2 > 0) {
            result <<= 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) {
        uint256 result = sqrt(a);
        if (rounding == Rounding.Up && result * result < a) {
            result += 1;
        }
        return result;
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Arrays.sol)

pragma solidity ^0.8.0;


/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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.6.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.7.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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * 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}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * 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 value {ERC20} uses, unless this function is
     * 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;
        }
        _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;
        _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;
        }
        _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/ERC20FlashMint.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/extensions/ERC20FlashMint.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the ERC3156 Flash loans extension, as defined in
 * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
 *
 * Adds the {flashLoan} method, which provides flash loan support at the token
 * level. By default there is no fee, but this can be changed by overriding {flashFee}.
 *
 * _Available since v4.1._
 */
abstract contract ERC20FlashMint is ERC20, IERC3156FlashLender {
    bytes32 private constant _RETURN_VALUE = keccak256("ERC3156FlashBorrower.onFlashLoan");

    /**
     * @dev Returns the maximum amount of tokens available for loan.
     * @param token The address of the token that is requested.
     * @return The amount of token that can be loaned.
     */
    function maxFlashLoan(address token) public view virtual override returns (uint256) {
        return token == address(this) ? type(uint256).max - ERC20.totalSupply() : 0;
    }

    /**
     * @dev Returns the fee applied when doing flash loans. By default this
     * implementation has 0 fees. This function can be overloaded to make
     * the flash loan mechanism deflationary.
     * @param token The token to be flash loaned.
     * @param amount The amount of tokens to be loaned.
     * @return The fees applied to the corresponding flash loan.
     */
    function flashFee(address token, uint256 amount) public view virtual override returns (uint256) {
        require(token == address(this), "ERC20FlashMint: wrong token");
        // silence warning about unused variable without the addition of bytecode.
        amount;
        return 0;
    }

    /**
     * @dev Returns the receiver address of the flash fee. By default this
     * implementation returns the address(0) which means the fee amount will be burnt.
     * This function can be overloaded to change the fee receiver.
     * @return The address for which the flash fee will be sent to.
     */
    function _flashFeeReceiver() internal view virtual returns (address) {
        return address(0);
    }

    /**
     * @dev Performs a flash loan. New tokens are minted and sent to the
     * `receiver`, who is required to implement the {IERC3156FlashBorrower}
     * interface. By the end of the flash loan, the receiver is expected to own
     * amount + fee tokens and have them approved back to the token contract itself so
     * they can be burned.
     * @param receiver The receiver of the flash loan. Should implement the
     * {IERC3156FlashBorrower.onFlashLoan} interface.
     * @param token The token to be flash loaned. Only `address(this)` is
     * supported.
     * @param amount The amount of tokens to be loaned.
     * @param data An arbitrary datafield that is passed to the receiver.
     * @return `true` if the flash loan was successful.
     */
    // This function can reenter, but it doesn't pose a risk because it always preserves the property that the amount
    // minted at the beginning is always recovered and burned at the end, or else the entire function will revert.
    // slither-disable-next-line reentrancy-no-eth
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) public virtual override returns (bool) {
        require(amount <= maxFlashLoan(token), "ERC20FlashMint: amount exceeds maxFlashLoan");
        uint256 fee = flashFee(token, amount);
        _mint(address(receiver), amount);
        require(
            receiver.onFlashLoan(msg.sender, token, amount, fee, data) == _RETURN_VALUE,
            "ERC20FlashMint: invalid return value"
        );
        address flashFeeReceiver = _flashFeeReceiver();
        _spendAllowance(address(receiver), address(this), amount + fee);
        if (fee == 0 || flashFeeReceiver == address(0)) {
            _burn(address(receiver), amount + fee);
        } else {
            _burn(address(receiver), amount);
            _transfer(address(receiver), flashFeeReceiver, fee);
        }
        return true;
    }
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;






/**
 * @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.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.
     * However, to ensure consistency with the upgradeable transpiler, we will continue
     * to reserve a slot.
     * @custom:oz-renamed-from _PERMIT_TYPEHASH
     */
    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

    /**
     * @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") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired 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);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

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

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/extensions/ERC20Snapshot.sol)

pragma solidity ^0.8.0;




/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it
 * return `block.number` will trigger the creation of snapshot at the beginning of each new block. When overriding this
 * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract.
 *
 * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient
 * alternative consider {ERC20Votes}.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */

abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minime/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping(address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _getCurrentSnapshotId();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Get the current snapshotId
     */
    function _getCurrentSnapshotId() internal view virtual returns (uint256) {
        return _currentSnapshotId.current();
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) {
            // mint
            _updateAccountSnapshot(to);
            _updateTotalSupplySnapshot();
        } else if (to == address(0)) {
            // burn
            _updateAccountSnapshot(from);
            _updateTotalSupplySnapshot();
        } else {
            // transfer
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);
        }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _getCurrentSnapshotId();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

// File: ETH.sol


pragma solidity ^0.8.4;







/// @custom:security-contact [email protected]
contract EthereumM is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, ERC20Permit, ERC20FlashMint {
    constructor() ERC20("EthereumM", "ETHM") ERC20Permit("EthereumM") {
        _mint(msg.sender, 1000000000 * 10 ** decimals());
    }

    function snapshot() public onlyOwner {
        _snapshot();
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    // The following functions are overrides required by Solidity.

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        override(ERC20, ERC20Snapshot)
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"flashFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC3156FlashBorrower","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"flashLoan","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"token","type":"address"}],"name":"maxFlashLoan","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"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":"snapshot","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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

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

Deployed Bytecode Sourcemap

71035:693:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42456:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44807:201;;;;;;:::i;:::-;;:::i;:::-;;;5126:14:1;;5119:22;5101:41;;5089:2;5074:18;44807:201:0;4961:187:1;43576:108:0;43664:12;;43576:108;;;5299:25:1;;;5287:2;5272:18;43576:108:0;5153:177:1;45588:295:0;;;;;;:::i;:::-;;:::i;43418:93::-;;;43501:2;16594:36:1;;16582:2;16567:18;43418:93:0;16452:184:1;60337:115:0;;;:::i;46292:238::-;;;;;;:::i;:::-;;:::i;71354:95::-;;;;;;:::i;:::-;;:::i;:::-;;70335:91;;;;;;:::i;:::-;;:::i;65857:266::-;;;;;;:::i;:::-;;:::i;56552:959::-;;;;;;:::i;:::-;;:::i;54170:178::-;;;;;;:::i;:::-;;:::i;43747:127::-;;;;;;:::i;:::-;-1:-1:-1;;;;;43848:18:0;43821:7;43848:18;;;;;;;;;;;;43747:127;35879:103;;;:::i;70745:164::-;;;;;;:::i;:::-;;:::i;60079:128::-;;;;;;:::i;:::-;;:::i;35231:87::-;35304:6;;35231:87;;-1:-1:-1;;;;;35304:6:0;;;4160:51:1;;4148:2;4133:18;35231:87:0;4014:203:1;42675:104:0;;;:::i;71279:67::-;;;:::i;66227:234::-;;;;;;:::i;:::-;;:::i;47033:436::-;;;;;;:::i;:::-;;:::i;44080:193::-;;;;;;:::i;:::-;;:::i;59368:645::-;;;;;;:::i;:::-;;:::i;54747:297::-;;;;;;:::i;:::-;;:::i;44336:151::-;;;;;;:::i;:::-;;:::i;36137:201::-;;;;;;:::i;:::-;;:::i;42456:100::-;42510:13;42543:5;42536:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42456:100;:::o;44807:201::-;44890:4;33862:10;44946:32;33862:10;44962:7;44971:6;44946:8;:32::i;:::-;44996:4;44989:11;;;44807:201;;;;;:::o;45588:295::-;45719:4;33862:10;45777:38;45793:4;33862:10;45808:6;45777:15;:38::i;:::-;45826:27;45836:4;45842:2;45846:6;45826:9;:27::i;:::-;-1:-1:-1;45871:4:0;;45588:295;-1:-1:-1;;;;45588:295:0:o;60337:115::-;60397:7;60424:20;:18;:20::i;:::-;60417:27;;60337:115;:::o;46292:238::-;46380:4;33862:10;46436:64;33862:10;46452:7;46489:10;46461:25;33862:10;46452:7;46461:9;:25::i;:::-;:38;;;;:::i;:::-;46436:8;:64::i;71354:95::-;35117:13;:11;:13::i;:::-;71424:17:::1;71430:2;71434:6;71424:5;:17::i;:::-;71354:95:::0;;:::o;70335:91::-;70391:27;33862:10;70411:6;70391:5;:27::i;:::-;70335:91;:::o;65857:266::-;-1:-1:-1;;;;;66021:33:0;;65944:7;66021:33;;;:24;:33;;;;;65944:7;;;;66000:55;;66009:10;;66000:8;:55::i;:::-;65964:91;;;;66075:11;:40;;-1:-1:-1;;;;;43848:18:0;;43821:7;43848:18;;;;;;;;;;;66075:40;;;66089:5;66075:40;66068:47;65857:266;-1:-1:-1;;;;;65857:266:0:o;56552:959::-;56731:4;56766:19;56779:5;56766:12;:19::i;:::-;56756:6;:29;;56748:85;;;;-1:-1:-1;;;56748:85:0;;13730:2:1;56748:85:0;;;13712:21:1;13769:2;13749:18;;;13742:30;13808:34;13788:18;;;13781:62;-1:-1:-1;;;13859:18:1;;;13852:41;13910:19;;56748:85:0;;;;;;;;;56844:11;56858:23;56867:5;56874:6;56858:8;:23::i;:::-;56844:37;;56892:32;56906:8;56917:6;56892:5;:32::i;:::-;56957:58;;-1:-1:-1;;;56957:58:0;;53907:45;;-1:-1:-1;;;;;56957:20:0;;;;;:58;;56978:10;;56990:5;;56997:6;;57005:3;;57010:4;;;;56957:58;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:75;56935:161;;;;-1:-1:-1;;;56935:161:0;;11846:2:1;56935:161:0;;;11828:21:1;11885:2;11865:18;;;11858:30;11924:34;11904:18;;;11897:62;-1:-1:-1;;;11975:18:1;;;11968:34;12019:19;;56935:161:0;11644:400:1;56935:161:0;57107:24;57164:63;57188:8;57207:4;57214:12;57223:3;57214:6;:12;:::i;:::-;57164:15;:63::i;:::-;57242:8;;;:42;;-1:-1:-1;;;;;;57254:30:0;;;57242:42;57238:244;;;57301:38;57315:8;57326:12;57335:3;57326:6;:12;:::i;:::-;57301:5;:38::i;:::-;57238:244;;;57372:32;57386:8;57397:6;57372:5;:32::i;:::-;57419:51;57437:8;57448:16;57466:3;57419:9;:51::i;:::-;-1:-1:-1;57499:4:0;;56552:959;-1:-1:-1;;;;;;;56552:959:0:o;54170:178::-;54245:7;-1:-1:-1;;;;;54272:22:0;;54289:4;54272:22;:68;;54339:1;54272:68;;;43664:12;;54297:39;;-1:-1:-1;;54297:39:0;:::i;35879:103::-;35117:13;:11;:13::i;:::-;35944:30:::1;35971:1;35944:18;:30::i;:::-;35879:103::o:0;70745:164::-;70822:46;70838:7;33862:10;70861:6;70822:15;:46::i;:::-;70879:22;70885:7;70894:6;70879:5;:22::i;60079:128::-;-1:-1:-1;;;;;60175:14:0;;60148:7;60175:14;;;:7;:14;;;;;21948;60175:24;21856:114;42675:104;42731:13;42764:7;42757:14;;;;;:::i;71279:67::-;35117:13;:11;:13::i;:::-;71327:11:::1;:9;:11::i;66227:234::-:0;66299:7;66320:16;66338:13;66355:43;66364:10;66376:21;66355:8;:43::i;:::-;66319:79;;;;66418:11;:35;;43664:12;;66418:35;;;66432:5;66418:35;66411:42;66227:234;-1:-1:-1;;;;66227:234:0:o;47033:436::-;47126:4;33862:10;47126:4;47209:25;33862:10;47226:7;47209:9;:25::i;:::-;47182:52;;47273:15;47253:16;:35;;47245:85;;;;-1:-1:-1;;;47245:85:0;;15706:2:1;47245:85:0;;;15688:21:1;15745:2;15725:18;;;15718:30;15784:34;15764:18;;;15757:62;-1:-1:-1;;;15835:18:1;;;15828:35;15880:19;;47245:85:0;15504:401:1;47245:85:0;47366:60;47375:5;47382:7;47410:15;47391:16;:34;47366:8;:60::i;44080:193::-;44159:4;33862:10;44215:28;33862:10;44232:2;44236:6;44215:9;:28::i;59368:645::-;59612:8;59593:15;:27;;59585:69;;;;-1:-1:-1;;;59585:69:0;;10678:2:1;59585:69:0;;;10660:21:1;10717:2;10697:18;;;10690:30;10756:31;10736:18;;;10729:59;10805:18;;59585:69:0;10476:353:1;59585:69:0;59667:18;58543:95;59727:5;59734:7;59743:5;59750:16;59760:5;59750:9;:16::i;:::-;59698:79;;;;;;5622:25:1;;;;-1:-1:-1;;;;;5721:15:1;;;5701:18;;;5694:43;5773:15;;;;5753:18;;;5746:43;5805:18;;;5798:34;5848:19;;;5841:35;5892:19;;;5885:35;;;5594:19;;59698:79:0;;;;;;;;;;;;59688:90;;;;;;59667:111;;59791:12;59806:28;59823:10;59806:16;:28::i;:::-;59791:43;;59847:14;59864:28;59878:4;59884:1;59887;59890;59864:13;:28::i;:::-;59847:45;;59921:5;-1:-1:-1;;;;;59911:15:0;:6;-1:-1:-1;;;;;59911:15:0;;59903:58;;;;-1:-1:-1;;;59903:58:0;;13010:2:1;59903:58:0;;;12992:21:1;13049:2;13029:18;;;13022:30;13088:32;13068:18;;;13061:60;13138:18;;59903:58:0;12808:354:1;59903:58:0;59974:31;59983:5;59990:7;59999:5;59974:8;:31::i;:::-;59574:439;;;59368:645;;;;;;;:::o;54747:297::-;54834:7;-1:-1:-1;;;;;54862:22:0;;54879:4;54862:22;54854:62;;;;-1:-1:-1;;;54854:62:0;;12251:2:1;54854:62:0;;;12233:21:1;12290:2;12270:18;;;12263:30;12329:29;12309:18;;;12302:57;12376:18;;54854:62:0;12049:351:1;54854:62:0;-1:-1:-1;55035:1:0;54747:297;;;;:::o;44336:151::-;-1:-1:-1;;;;;44452:18:0;;;44425:7;44452:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;44336:151::o;36137:201::-;35117:13;:11;:13::i;:::-;-1:-1:-1;;;;;36226:22:0;::::1;36218:73;;;::::0;-1:-1:-1;;;36218:73:0;;9510:2:1;36218:73:0::1;::::0;::::1;9492:21:1::0;9549:2;9529:18;;;9522:30;9588:34;9568:18;;;9561:62;-1:-1:-1;;;9639:18:1;;;9632:36;9685:19;;36218:73:0::1;9308:402:1::0;36218:73:0::1;36302:28;36321:8;36302:18;:28::i;66678:622::-:0;-1:-1:-1;;;;;66882:18:0;;66878:415;;66938:26;66961:2;66938:22;:26::i;:::-;66979:28;:26;:28::i;:::-;66678:622;;;:::o;66878:415::-;-1:-1:-1;;;;;67029:16:0;;67025:268;;67083:28;67106:4;67083:22;:28::i;67025:268::-;67212:28;67235:4;67212:22;:28::i;:::-;67255:26;67278:2;67255:22;:26::i;21856:114::-;21948:14;;21856:114::o;50658:380::-;-1:-1:-1;;;;;50794:19:0;;50786:68;;;;-1:-1:-1;;;50786:68:0;;14950:2:1;50786:68:0;;;14932:21:1;14989:2;14969:18;;;14962:30;15028:34;15008:18;;;15001:62;-1:-1:-1;;;15079:18:1;;;15072:34;15123:19;;50786:68:0;14748:400:1;50786:68:0;-1:-1:-1;;;;;50873:21:0;;50865:68;;;;-1:-1:-1;;;50865:68:0;;9917:2:1;50865:68:0;;;9899:21:1;9956:2;9936:18;;;9929:30;9995:34;9975:18;;;9968:62;-1:-1:-1;;;10046:18:1;;;10039:32;10088:19;;50865:68:0;9715:398:1;50865:68:0;-1:-1:-1;;;;;50946:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;50998:32;;5299:25:1;;;50998:32:0;;5272:18:1;50998:32:0;;;;;;;50658:380;;;:::o;51329:453::-;51464:24;51491:25;51501:5;51508:7;51491:9;:25::i;:::-;51464:52;;-1:-1:-1;;51531:16:0;:37;51527:248;;51613:6;51593:16;:26;;51585:68;;;;-1:-1:-1;;;51585:68:0;;10320:2:1;51585:68:0;;;10302:21:1;10359:2;10339:18;;;10332:30;10398:31;10378:18;;;10371:59;10447:18;;51585:68:0;10118:353:1;51585:68:0;51697:51;51706:5;51713:7;51741:6;51722:16;:25;51697:8;:51::i;:::-;51453:329;51329:453;;;:::o;47939:671::-;-1:-1:-1;;;;;48070:18:0;;48062:68;;;;-1:-1:-1;;;48062:68:0;;14544:2:1;48062:68:0;;;14526:21:1;14583:2;14563:18;;;14556:30;14622:34;14602:18;;;14595:62;-1:-1:-1;;;14673:18:1;;;14666:35;14718:19;;48062:68:0;14342:401:1;48062:68:0;-1:-1:-1;;;;;48149:16:0;;48141:64;;;;-1:-1:-1;;;48141:64:0;;8343:2:1;48141:64:0;;;8325:21:1;8382:2;8362:18;;;8355:30;8421:34;8401:18;;;8394:62;-1:-1:-1;;;8472:18:1;;;8465:33;8515:19;;48141:64:0;8141:399:1;48141:64:0;48218:38;48239:4;48245:2;48249:6;48218:20;:38::i;:::-;-1:-1:-1;;;;;48291:15:0;;48269:19;48291:15;;;;;;;;;;;48325:21;;;;48317:72;;;;-1:-1:-1;;;48317:72:0;;11036:2:1;48317:72:0;;;11018:21:1;11075:2;11055:18;;;11048:30;11114:34;11094:18;;;11087:62;-1:-1:-1;;;11165:18:1;;;11158:36;11211:19;;48317:72:0;10834:402:1;48317:72:0;-1:-1:-1;;;;;48425:15:0;;;:9;:15;;;;;;;;;;;48443:20;;;48425:38;;48485:13;;;;;;;;:23;;48457:6;;48425:9;48485:23;;48457:6;;48485:23;:::i;:::-;;;;;;;;48541:2;-1:-1:-1;;;;;48526:26:0;48535:4;-1:-1:-1;;;;;48526:26:0;;48545:6;48526:26;;;;5299:25:1;;5287:2;5272:18;;5153:177;48526:26:0;;;;;;;;48565:37;66678:622;17218:314;17271:7;17303:4;-1:-1:-1;;;;;17312:12:0;17295:29;;:66;;;;;17345:16;17328:13;:33;17295:66;17291:234;;;-1:-1:-1;17385:24:0;;17218:314::o;17291:234::-;-1:-1:-1;17721:73:0;;;17471:10;17721:73;;;;6190:25:1;;;;17483:12:0;6231:18:1;;;6224:34;17497:15:0;6274:18:1;;;6267:34;17765:13:0;6317:18:1;;;6310:34;17788:4:0;6360:19:1;;;;6353:61;;;;17721:73:0;;;;;;;;;;6162:19:1;;;;17721:73:0;;;17711:84;;;;;;60337:115::o;35396:132::-;35304:6;;-1:-1:-1;;;;;35304:6:0;33862:10;35460:23;35452:68;;;;-1:-1:-1;;;35452:68:0;;13369:2:1;35452:68:0;;;13351:21:1;;;13388:18;;;13381:30;13447:34;13427:18;;;13420:62;13499:18;;35452:68:0;13167:356:1;48897:399:0;-1:-1:-1;;;;;48981:21:0;;48973:65;;;;-1:-1:-1;;;48973:65:0;;16112:2:1;48973:65:0;;;16094:21:1;16151:2;16131:18;;;16124:30;16190:33;16170:18;;;16163:61;16241:18;;48973:65:0;15910:355:1;48973:65:0;49051:49;49080:1;49084:7;49093:6;49051:20;:49::i;:::-;49129:6;49113:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;49146:18:0;;:9;:18;;;;;;;;;;:28;;49168:6;;49146:9;:28;;49168:6;;49146:28;:::i;:::-;;;;-1:-1:-1;;49190:37:0;;5299:25:1;;;-1:-1:-1;;;;;49190:37:0;;;49207:1;;49190:37;;5287:2:1;5272:18;49190:37:0;;;;;;;71354:95;;:::o;49629:591::-;-1:-1:-1;;;;;49713:21:0;;49705:67;;;;-1:-1:-1;;;49705:67:0;;14142:2:1;49705:67:0;;;14124:21:1;14181:2;14161:18;;;14154:30;14220:34;14200:18;;;14193:62;-1:-1:-1;;;14271:18:1;;;14264:31;14312:19;;49705:67:0;13940:397:1;49705:67:0;49785:49;49806:7;49823:1;49827:6;49785:20;:49::i;:::-;-1:-1:-1;;;;;49872:18:0;;49847:22;49872:18;;;;;;;;;;;49909:24;;;;49901:71;;;;-1:-1:-1;;;49901:71:0;;8747:2:1;49901:71:0;;;8729:21:1;8786:2;8766:18;;;8759:30;8825:34;8805:18;;;8798:62;-1:-1:-1;;;8876:18:1;;;8869:32;8918:19;;49901:71:0;8545:398:1;49901:71:0;-1:-1:-1;;;;;50008:18:0;;:9;:18;;;;;;;;;;50029:23;;;50008:44;;50074:12;:22;;50046:6;;50008:9;50074:22;;50046:6;;50074:22;:::i;:::-;;;;-1:-1:-1;;50114:37:0;;5299:25:1;;;50140:1:0;;-1:-1:-1;;;;;50114:37:0;;;;;5287:2:1;5272:18;50114:37:0;;;;;;;66678:622;;;:::o;67308:1619::-;67397:4;67403:7;67444:1;67431:10;:14;67423:49;;;;-1:-1:-1;;;67423:49:0;;15355:2:1;67423:49:0;;;15337:21:1;15394:2;15374:18;;;15367:30;-1:-1:-1;;;15413:18:1;;;15406:52;15475:18;;67423:49:0;15153:346:1;67423:49:0;67505:23;:21;:23::i;:::-;67491:10;:37;;67483:79;;;;-1:-1:-1;;;67483:79:0;;7985:2:1;67483:79:0;;;7967:21:1;8024:2;8004:18;;;7997:30;8063:31;8043:18;;;8036:59;8112:18;;67483:79:0;7783:353:1;67483:79:0;68701:13;68717:40;:9;68746:10;68717:28;:40::i;:::-;68783:20;;68701:56;;-1:-1:-1;68774:29:0;;68770:150;;;68828:5;68835:1;68820:17;;;;;;;68770:150;68878:4;68884:9;:16;;68901:5;68884:23;;;;;;;;:::i;:::-;;;;;;;;;68870:38;;;;;67308:1619;;;;;;:::o;36498:191::-;36591:6;;;-1:-1:-1;;;;;36608:17:0;;;-1:-1:-1;;;;;;36608:17:0;;;;;;;36641:40;;36591:6;;;36608:17;36591:6;;36641:40;;36572:16;;36641:40;36561:128;36498:191;:::o;65329:223::-;65376:7;65396:30;:18;22067:19;;22085:1;22067:19;;;21978:127;65396:30;65439:17;65459:23;:21;:23::i;:::-;65439:43;;65498:19;65507:9;65498:19;;;;5299:25:1;;5287:2;5272:18;;5153:177;65498:19:0;;;;;;;;65535:9;65329:223;-1:-1:-1;65329:223:0:o;60590:207::-;-1:-1:-1;;;;;60711:14:0;;60650:15;60711:14;;;:7;:14;;;;;21948;;22085:1;22067:19;;;;21948:14;60772:17;60667:130;60590:207;;;:::o;18445:167::-;18522:7;18549:55;18571:20;:18;:20::i;:::-;18593:10;13915:57;;-1:-1:-1;;;13915:57:0;;;3875:27:1;3918:11;;;3911:27;;;3954:12;;;3947:28;;;13878:7:0;;3991:12:1;;13915:57:0;;;;;;;;;;;;13905:68;;;;;;13898:75;;13785:196;;;;;12094:279;12222:7;12243:17;12262:18;12284:25;12295:4;12301:1;12304;12307;12284:10;:25::i;:::-;12242:67;;;;12320:18;12332:5;12320:11;:18::i;:::-;-1:-1:-1;12356:9:0;12094:279;-1:-1:-1;;;;;12094:279:0:o;68935:146::-;-1:-1:-1;;;;;69019:33:0;;;;;;:24;:33;;;;;;;;43848:18;;;;;;;;69003:70;;69019:33;69003:15;:70::i;69054:18::-;69003:15;:70::i;69089:118::-;69146:53;69162:21;69185:13;43664:12;;;43576:108;71527:198;71673:44;71700:4;71706:2;71710:6;71673:26;:44::i;65618:127::-;65682:7;65709:28;:18;21948:14;;21856:114;32178:918;32291:12;;32267:7;;32287:58;;-1:-1:-1;32332:1:0;32325:8;;32287:58;32398:12;;32357:11;;32423:424;32436:4;32430:3;:10;32423:424;;;32457:11;32471:23;32484:3;32489:4;32471:12;:23::i;:::-;32457:37;;32728:7;32715:5;32721:3;32715:10;;;;;;;;:::i;:::-;;;;;;;;;:20;32711:125;;;32763:3;32756:10;;32711:125;;;32813:7;:3;32819:1;32813:7;:::i;:::-;32807:13;;32711:125;32442:405;32423:424;;;32973:1;32967:3;:7;:36;;;;-1:-1:-1;32996:7:0;32978:5;32984:7;32990:1;32984:3;:7;:::i;:::-;32978:14;;;;;;;;:::i;:::-;;;;;;;;;:25;32967:36;32963:126;;;33027:7;33033:1;33027:3;:7;:::i;:::-;33020:14;;;;;;32963:126;-1:-1:-1;33074:3:0;-1:-1:-1;33067:10:0;;10323:1632;10454:7;;11388:66;11375:79;;11371:163;;;-1:-1:-1;11487:1:0;;-1:-1:-1;11491:30:0;11471:51;;11371:163;11548:1;:7;;11553:2;11548:7;;:18;;;;;11559:1;:7;;11564:2;11559:7;;11548:18;11544:102;;;-1:-1:-1;11599:1:0;;-1:-1:-1;11603:30:0;11583:51;;11544:102;11760:24;;;11743:14;11760:24;;;;;;;;;6652:25:1;;;6725:4;6713:17;;6693:18;;;6686:45;;;;6747:18;;;6740:34;;;6790:18;;;6783:34;;;11760:24:0;;6624:19:1;;11760:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11760:24:0;;-1:-1:-1;;11760:24:0;;;-1:-1:-1;;;;;;;11799:20:0;;11795:103;;11852:1;11856:29;11836:50;;;;;;;11795:103;11918:6;-1:-1:-1;11926:20:0;;-1:-1:-1;10323:1632:0;;;;;;;;:::o;5593:643::-;5671:20;5662:5;:29;;;;;;;;:::i;:::-;;5658:571;;;5593:643;:::o;5658:571::-;5769:29;5760:5;:38;;;;;;;;:::i;:::-;;5756:473;;;5815:34;;-1:-1:-1;;;5815:34:0;;7632:2:1;5815:34:0;;;7614:21:1;7671:2;7651:18;;;7644:30;7710:26;7690:18;;;7683:54;7754:18;;5815:34:0;7430:348:1;5756:473:0;5880:35;5871:5;:44;;;;;;;;:::i;:::-;;5867:362;;;5932:41;;-1:-1:-1;;;5932:41:0;;9150:2:1;5932:41:0;;;9132:21:1;9189:2;9169:18;;;9162:30;9228:33;9208:18;;;9201:61;9279:18;;5932:41:0;8948:355:1;5867:362:0;6004:30;5995:5;:39;;;;;;;;:::i;:::-;;5991:238;;;6051:44;;-1:-1:-1;;;6051:44:0;;11443:2:1;6051:44:0;;;11425:21:1;11482:2;11462:18;;;11455:30;11521:34;11501:18;;;11494:62;-1:-1:-1;;;11572:18:1;;;11565:32;11614:19;;6051:44:0;11241:398:1;5991:238:0;6126:30;6117:5;:39;;;;;;;;:::i;:::-;;6113:116;;;6173:44;;-1:-1:-1;;;6173:44:0;;12607:2:1;6173:44:0;;;12589:21:1;12646:2;12626:18;;;12619:30;12685:34;12665:18;;;12658:62;-1:-1:-1;;;12736:18:1;;;12729:32;12778:19;;6173:44:0;12405:398:1;69215:310:0;69310:17;69330:23;:21;:23::i;:::-;69310:43;-1:-1:-1;69310:43:0;69368:30;69384:9;69368:15;:30::i;:::-;:42;69364:154;;;69427:29;;;;;;;;-1:-1:-1;69427:29:0;;;;;;;;;;;;;;69471:16;;;:35;;;;;;;;;;;;;;;69215:310::o;23313:156::-;23375:7;23450:11;23460:1;23451:5;;;23450:11;:::i;:::-;23440:21;;23441:5;;;23440:21;:::i;:::-;23433:28;23313:156;-1:-1:-1;;;23313:156:0:o;69533:212::-;69627:10;;69603:7;;69623:115;;-1:-1:-1;69666:1:0;;69533:212;-1:-1:-1;69533:212:0:o;69623:115::-;69711:10;;69707:3;;69711:14;;69724:1;;69711:14;:::i;:::-;69707:19;;;;;;;;:::i;:::-;;;;;;;;;69700:26;;69533:212;;;:::o;14:247:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;200:31;225:5;200:31;:::i;266:388::-;334:6;342;395:2;383:9;374:7;370:23;366:32;363:52;;;411:1;408;401:12;363:52;450:9;437:23;469:31;494:5;469:31;:::i;:::-;519:5;-1:-1:-1;576:2:1;561:18;;548:32;589:33;548:32;589:33;:::i;:::-;641:7;631:17;;;266:388;;;;;:::o;659:456::-;736:6;744;752;805:2;793:9;784:7;780:23;776:32;773:52;;;821:1;818;811:12;773:52;860:9;847:23;879:31;904:5;879:31;:::i;:::-;929:5;-1:-1:-1;986:2:1;971:18;;958:32;999:33;958:32;999:33;:::i;:::-;659:456;;1051:7;;-1:-1:-1;;;1105:2:1;1090:18;;;;1077:32;;659:456::o;1120:829::-;1231:6;1239;1247;1255;1263;1271;1279;1332:3;1320:9;1311:7;1307:23;1303:33;1300:53;;;1349:1;1346;1339:12;1300:53;1388:9;1375:23;1407:31;1432:5;1407:31;:::i;:::-;1457:5;-1:-1:-1;1514:2:1;1499:18;;1486:32;1527:33;1486:32;1527:33;:::i;:::-;1579:7;-1:-1:-1;1633:2:1;1618:18;;1605:32;;-1:-1:-1;1684:2:1;1669:18;;1656:32;;-1:-1:-1;1740:3:1;1725:19;;1712:33;1789:4;1776:18;;1764:31;;1754:59;;1809:1;1806;1799:12;1754:59;1120:829;;;;-1:-1:-1;1120:829:1;;;;1832:7;1886:3;1871:19;;1858:33;;-1:-1:-1;1938:3:1;1923:19;;;1910:33;;1120:829;-1:-1:-1;;1120:829:1:o;1954:315::-;2022:6;2030;2083:2;2071:9;2062:7;2058:23;2054:32;2051:52;;;2099:1;2096;2089:12;2051:52;2138:9;2125:23;2157:31;2182:5;2157:31;:::i;:::-;2207:5;2259:2;2244:18;;;;2231:32;;-1:-1:-1;;;1954:315:1:o;2274:184::-;2344:6;2397:2;2385:9;2376:7;2372:23;2368:32;2365:52;;;2413:1;2410;2403:12;2365:52;-1:-1:-1;2436:16:1;;2274:184;-1:-1:-1;2274:184:1:o;2463:964::-;2588:6;2596;2604;2612;2620;2673:3;2661:9;2652:7;2648:23;2644:33;2641:53;;;2690:1;2687;2680:12;2641:53;2729:9;2716:23;2748:31;2773:5;2748:31;:::i;:::-;2798:5;-1:-1:-1;2855:2:1;2840:18;;2827:32;2868:33;2827:32;2868:33;:::i;:::-;2920:7;-1:-1:-1;2974:2:1;2959:18;;2946:32;;-1:-1:-1;3029:2:1;3014:18;;3001:32;3052:18;3082:14;;;3079:34;;;3109:1;3106;3099:12;3079:34;3147:6;3136:9;3132:22;3122:32;;3192:7;3185:4;3181:2;3177:13;3173:27;3163:55;;3214:1;3211;3204:12;3163:55;3254:2;3241:16;3280:2;3272:6;3269:14;3266:34;;;3296:1;3293;3286:12;3266:34;3341:7;3336:2;3327:6;3323:2;3319:15;3315:24;3312:37;3309:57;;;3362:1;3359;3352:12;3309:57;2463:964;;;;-1:-1:-1;2463:964:1;;-1:-1:-1;3393:2:1;3385:11;;3415:6;2463:964;-1:-1:-1;;;2463:964:1:o;3432:180::-;3491:6;3544:2;3532:9;3523:7;3519:23;3515:32;3512:52;;;3560:1;3557;3550:12;3512:52;-1:-1:-1;3583:23:1;;3432:180;-1:-1:-1;3432:180:1:o;4222:734::-;-1:-1:-1;;;;;4529:15:1;;;4511:34;;4581:15;;4576:2;4561:18;;4554:43;4628:2;4613:18;;4606:34;;;4671:2;4656:18;;4649:34;;;4491:3;4714;4699:19;;4692:32;;;4740:19;;4733:35;;;4454:4;4761:6;4811;4805:3;4790:19;;4777:49;4876:1;4870:3;4861:6;4850:9;4846:22;4842:32;4835:43;4946:3;4939:2;4935:7;4930:2;4922:6;4918:15;4914:29;4903:9;4899:45;4895:55;4887:63;;4222:734;;;;;;;;;:::o;6828:597::-;6940:4;6969:2;6998;6987:9;6980:21;7030:6;7024:13;7073:6;7068:2;7057:9;7053:18;7046:34;7098:1;7108:140;7122:6;7119:1;7116:13;7108:140;;;7217:14;;;7213:23;;7207:30;7183:17;;;7202:2;7179:26;7172:66;7137:10;;7108:140;;;7266:6;7263:1;7260:13;7257:91;;;7336:1;7331:2;7322:6;7311:9;7307:22;7303:31;7296:42;7257:91;-1:-1:-1;7409:2:1;7388:15;-1:-1:-1;;7384:29:1;7369:45;;;;7416:2;7365:54;;6828:597;-1:-1:-1;;;6828:597:1:o;16641:128::-;16681:3;16712:1;16708:6;16705:1;16702:13;16699:39;;;16718:18;;:::i;:::-;-1:-1:-1;16754:9:1;;16641:128::o;16774:217::-;16814:1;16840;16830:132;;16884:10;16879:3;16875:20;16872:1;16865:31;16919:4;16916:1;16909:15;16947:4;16944:1;16937:15;16830:132;-1:-1:-1;16976:9:1;;16774:217::o;16996:125::-;17036:4;17064:1;17061;17058:8;17055:34;;;17069:18;;:::i;:::-;-1:-1:-1;17106:9:1;;16996:125::o;17126:380::-;17205:1;17201:12;;;;17248;;;17269:61;;17323:4;17315:6;17311:17;17301:27;;17269:61;17376:2;17368:6;17365:14;17345:18;17342:38;17339:161;;;17422:10;17417:3;17413:20;17410:1;17403:31;17457:4;17454:1;17447:15;17485:4;17482:1;17475:15;17511:127;17572:10;17567:3;17563:20;17560:1;17553:31;17603:4;17600:1;17593:15;17627:4;17624:1;17617:15;17643:127;17704:10;17699:3;17695:20;17692:1;17685:31;17735:4;17732:1;17725:15;17759:4;17756:1;17749:15;17775:127;17836:10;17831:3;17827:20;17824:1;17817:31;17867:4;17864:1;17857:15;17891:4;17888:1;17881:15;17907:131;-1:-1:-1;;;;;17982:31:1;;17972:42;;17962:70;;18028:1;18025;18018:12

Swarm Source

ipfs://572416e97b69f57e4dee6db101a8633a890d9d3c899ceb8f84a995a9468b9c20

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