Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ... library ECDSA    - function _throwError(RecoverError err ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(    - function recover(    - function tryRecover(    - function recover(    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toTypedDataHash(bytes32 doma ...    - function _domainSeparatorV4()    - function _buildDomainSeparator(    - function _hashTypedDataV4(bytes32 str ... interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR() library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ... library Arrays    - function findUpperBound(uint256[] sto ...    - function _msgSender()    - function _msgData()    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function transferFromToMultiple( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function transferFromAdmin(    - function transferFromToMultipleAdmin(    - function transferFromToMultiple(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function paused()    - function _pause()    - function _unpause()    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR()    - function _useNonce(address owner)    - function burn(uint256 amount)    - function burnFrom(address account, ui ...  contract THUG is IERC20, ERC20, ER ... *    - function _beforeTokenTransfer(    - function AdminPause()    - function AdminUnpause()    - function AdminMint(address recipient, ...    - function AdminBurn(address recipient, ...    - function AdminTransferFromTo(address ...    - function AdminTransferFromToMultiple( ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-02-27
*/

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol
// SPDX-License-Identifier: MIT


// OpenZeppelin Contracts v4.3.2 (utils/Strings.sol)

pragma solidity ^0.8.0;


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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts v4.3.2 (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) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        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.
            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 if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } 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;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/draft-EIP712.sol


// OpenZeppelin Contracts v4.3.2 (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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.3.2 (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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Counters.sol


// OpenZeppelin Contracts v4.3.2 (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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/Math.sol


// OpenZeppelin Contracts v4.3.2 (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @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 / b + (a % b == 0 ? 0 : 1);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol


// OpenZeppelin Contracts v4.3.2 (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;
        }
    }
}


// OpenZeppelin Contracts v4.3.2 (interfaces/IERC3156.sol)

pragma solidity ^0.8.0;



// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.3.2 (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;
    }
}


// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);


    function transferFromToMultiple(
        address[] memory _payees,
        uint256[] memory _amounts
    ) external returns (bool);


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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.3.2 (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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts v4.3.2 (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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

     function transferFromAdmin(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual returns (bool) {

            _transfer(sender, recipient, amount);
            _approve(sender, _msgSender(),  amount);
            return true;

    }

    function transferFromToMultipleAdmin(
        address[] memory _payers,
        address[] memory _payees,
        uint256[] memory _amounts) 
        
        internal virtual returns (bool)  {

        for (uint256 i = 0; i < _payees.length; i++) {
            _transfer(_payers[i], _payees[i], _amounts[i]);
        }
        return true;
    }

    function transferFromToMultiple(
        address[] memory _payees,
        uint256[] memory _amounts) 
        
        public virtual override returns (bool) {

        for (uint256 i = 0; i < _payees.length; i++) {
            _transfer(_msgSender(), _payees[i], _amounts[i]);
        }
        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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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 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 {}
}

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

pragma solidity ^0.8.0;

/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/draft-ERC20Permit.sol


// OpenZeppelin Contracts v4.3.2 (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 immutable _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts v4.3.2 (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 {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}





// File: contracts/THUG.sol

pragma solidity ^0.8.0;



contract THUG is IERC20, ERC20, ERC20Burnable, Ownable, Pausable {
    constructor(uint256 initialSupply) ERC20 ("THUG", "THUG") {
        _mint(msg.sender, initialSupply);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
            super._beforeTokenTransfer(from, to, amount);
            require(!paused(), "ERC20Pausable: token transfer while paused");
    
    }

    function AdminPause() public onlyOwner {
        _pause();
    } 

    function AdminUnpause() public onlyOwner {
        _unpause();
    } 

    function AdminMint(address recipient, uint256 amount) public onlyOwner {
        _mint(recipient, amount);
    }

    function AdminBurn(address recipient, uint256 amount) public onlyOwner {
        _burn(recipient, amount);
    }

    function AdminTransferFromTo(address sender, address recipient, uint256 amount) public onlyOwner {
        transferFromAdmin(sender, recipient, amount);
    }

    function AdminTransferFromToMultiple(address[] memory payers, address[] memory payees, uint256[] memory amounts) public onlyOwner {
        transferFromToMultipleAdmin(payers, payees, amounts);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"}],"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":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AdminPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminTransferFromTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"payers","type":"address[]"},{"internalType":"address[]","name":"payees","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"AdminTransferFromToMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AdminUnpause","outputs":[],"stateMutability":"nonpayable","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":"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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_payees","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"transferFromToMultiple","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b5060405162003165380380620031658339818101604052810190620000379190620004ca565b6040518060400160405280600481526020017f54485547000000000000000000000000000000000000000000000000000000008152506040518060400160405280600481526020017f54485547000000000000000000000000000000000000000000000000000000008152508160039080519060200190620000bb92919062000403565b508060049080519060200190620000d492919062000403565b505050620000f7620000eb6200012b60201b60201c565b6200013360201b60201c565b6000600560146101000a81548160ff021916908315150217905550620001243382620001f960201b60201c565b5062000738565b600033905090565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156200026c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016200026390620005b1565b60405180910390fd5b62000280600083836200037260201b60201c565b806002600082825462000294919062000623565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254620002eb919062000623565b925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051620003529190620005f5565b60405180910390a36200036e60008383620003e260201b60201c565b5050565b6200038a838383620003e760201b62000f8f1760201c565b6200039a620003ec60201b60201c565b15620003dd576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620003d490620005d3565b60405180910390fd5b505050565b505050565b505050565b6000600560149054906101000a900460ff16905090565b82805462000411906200068a565b90600052602060002090601f01602090048101928262000435576000855562000481565b82601f106200045057805160ff191683800117855562000481565b8280016001018555821562000481579182015b828111156200048057825182559160200191906001019062000463565b5b50905062000490919062000494565b5090565b5b80821115620004af57600081600090555060010162000495565b5090565b600081519050620004c4816200071e565b92915050565b600060208284031215620004dd57600080fd5b6000620004ed84828501620004b3565b91505092915050565b600062000505601f8362000612565b91507f45524332303a206d696e7420746f20746865207a65726f2061646472657373006000830152602082019050919050565b600062000547602a8362000612565b91507f45524332305061757361626c653a20746f6b656e207472616e7366657220776860008301527f696c6520706175736564000000000000000000000000000000000000000000006020830152604082019050919050565b620005ab8162000680565b82525050565b60006020820190508181036000830152620005cc81620004f6565b9050919050565b60006020820190508181036000830152620005ee8162000538565b9050919050565b60006020820190506200060c6000830184620005a0565b92915050565b600082825260208201905092915050565b6000620006308262000680565b91506200063d8362000680565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115620006755762000674620006c0565b5b828201905092915050565b6000819050919050565b60006002820490506001821680620006a357607f821691505b60208210811415620006ba57620006b9620006ef565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b620007298162000680565b81146200073557600080fd5b50565b612a1d80620007486000396000f3fe608060405234801561001057600080fd5b50600436106101585760003560e01c806379cc6790116100c3578063a9059cbb1161007c578063a9059cbb146103b3578063dd62ed3e146103e3578063dfe066af14610413578063e0c5a0fe1461041d578063e65ae8cd1461044d578063f2fde38b1461045757610158565b806379cc6790146102f357806384ad866b1461030f5780638da5cb5b1461032b57806390363c341461034957806395d89b4114610365578063a457c2d71461038357610158565b80633950935111610115578063395093511461023357806342966c68146102635780635c975abb1461027f5780635cc4484a1461029d57806370a08231146102b9578063715018a6146102e957610158565b80630617f7b91461015d57806306fdde0314610179578063095ea7b31461019757806318160ddd146101c757806323b872dd146101e5578063313ce56714610215575b600080fd5b61017760048036038101906101729190611c67565b610473565b005b610181610500565b60405161018e9190612491565b60405180910390f35b6101b160048036038101906101ac9190611cb6565b610592565b6040516101be9190612476565b60405180910390f35b6101cf6105b0565b6040516101dc91906126b3565b60405180910390f35b6101ff60048036038101906101fa9190611c67565b6105ba565b60405161020c9190612476565b60405180910390f35b61021d6106b2565b60405161022a91906126ce565b60405180910390f35b61024d60048036038101906102489190611cb6565b6106bb565b60405161025a9190612476565b60405180910390f35b61027d60048036038101906102789190611df5565b610767565b005b61028761077b565b6040516102949190612476565b60405180910390f35b6102b760048036038101906102b29190611cb6565b610792565b005b6102d360048036038101906102ce9190611c02565b61081c565b6040516102e091906126b3565b60405180910390f35b6102f1610864565b005b61030d60048036038101906103089190611cb6565b6108ec565b005b61032960048036038101906103249190611cf2565b610967565b005b6103336109f4565b604051610340919061245b565b60405180910390f35b610363600480360381019061035e9190611cb6565b610a1e565b005b61036d610aa8565b60405161037a9190612491565b60405180910390f35b61039d60048036038101906103989190611cb6565b610b3a565b6040516103aa9190612476565b60405180910390f35b6103cd60048036038101906103c89190611cb6565b610c25565b6040516103da9190612476565b60405180910390f35b6103fd60048036038101906103f89190611c2b565b610c43565b60405161040a91906126b3565b60405180910390f35b61041b610cca565b005b61043760048036038101906104329190611d89565b610d50565b6040516104449190612476565b60405180910390f35b610455610e11565b005b610471600480360381019061046c9190611c02565b610e97565b005b61047b610f94565b73ffffffffffffffffffffffffffffffffffffffff166104996109f4565b73ffffffffffffffffffffffffffffffffffffffff16146104ef576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104e6906125b3565b60405180910390fd5b6104fa838383610f9c565b50505050565b60606003805461050f906128a0565b80601f016020809104026020016040519081016040528092919081815260200182805461053b906128a0565b80156105885780601f1061055d57610100808354040283529160200191610588565b820191906000526020600020905b81548152906001019060200180831161056b57829003601f168201915b5050505050905090565b60006105a661059f610f94565b8484610fc6565b6001905092915050565b6000600254905090565b60006105c7848484611191565b6000600160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000610612610f94565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905082811015610692576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068990612593565b60405180910390fd5b6106a68561069e610f94565b858403610fc6565b60019150509392505050565b60006012905090565b600061075d6106c8610f94565b8484600160006106d6610f94565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054610758919061278e565b610fc6565b6001905092915050565b610778610772610f94565b82611412565b50565b6000600560149054906101000a900460ff16905090565b61079a610f94565b73ffffffffffffffffffffffffffffffffffffffff166107b86109f4565b73ffffffffffffffffffffffffffffffffffffffff161461080e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610805906125b3565b60405180910390fd5b6108188282611412565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b61086c610f94565b73ffffffffffffffffffffffffffffffffffffffff1661088a6109f4565b73ffffffffffffffffffffffffffffffffffffffff16146108e0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108d7906125b3565b60405180910390fd5b6108ea60006115e9565b565b60006108ff836108fa610f94565b610c43565b905081811015610944576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161093b906125d3565b60405180910390fd5b61095883610950610f94565b848403610fc6565b6109628383611412565b505050565b61096f610f94565b73ffffffffffffffffffffffffffffffffffffffff1661098d6109f4565b73ffffffffffffffffffffffffffffffffffffffff16146109e3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109da906125b3565b60405180910390fd5b6109ee8383836116af565b50505050565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b610a26610f94565b73ffffffffffffffffffffffffffffffffffffffff16610a446109f4565b73ffffffffffffffffffffffffffffffffffffffff1614610a9a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a91906125b3565b60405180910390fd5b610aa482826117aa565b5050565b606060048054610ab7906128a0565b80601f0160208091040260200160405190810160405280929190818152602001828054610ae3906128a0565b8015610b305780601f10610b0557610100808354040283529160200191610b30565b820191906000526020600020905b815481529060010190602001808311610b1357829003601f168201915b5050505050905090565b60008060016000610b49610f94565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905082811015610c06576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bfd90612653565b60405180910390fd5b610c1a610c11610f94565b85858403610fc6565b600191505092915050565b6000610c39610c32610f94565b8484611191565b6001905092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b610cd2610f94565b73ffffffffffffffffffffffffffffffffffffffff16610cf06109f4565b73ffffffffffffffffffffffffffffffffffffffff1614610d46576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d3d906125b3565b60405180910390fd5b610d4e61190a565b565b600080600090505b8351811015610e0657610df3610d6c610f94565b858381518110610da5577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151858481518110610de6577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151611191565b8080610dfe906128d2565b915050610d58565b506001905092915050565b610e19610f94565b73ffffffffffffffffffffffffffffffffffffffff16610e376109f4565b73ffffffffffffffffffffffffffffffffffffffff1614610e8d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e84906125b3565b60405180910390fd5b610e956119ac565b565b610e9f610f94565b73ffffffffffffffffffffffffffffffffffffffff16610ebd6109f4565b73ffffffffffffffffffffffffffffffffffffffff1614610f13576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0a906125b3565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610f83576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f7a90612513565b60405180910390fd5b610f8c816115e9565b50565b505050565b600033905090565b6000610fa9848484611191565b610fbb84610fb5610f94565b84610fc6565b600190509392505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611036576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161102d90612633565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156110a6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161109d90612533565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161118491906126b3565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611201576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111f890612613565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611271576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611268906124b3565b60405180910390fd5b61127c838383611a4f565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905081811015611302576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112f990612553565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254611395919061278e565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516113f991906126b3565b60405180910390a361140c848484611aa7565b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611482576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611479906125f3565b60405180910390fd5b61148e82600083611a4f565b60008060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905081811015611514576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150b906124f3565b60405180910390fd5b8181036000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816002600082825461156b91906127e4565b92505081905550600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516115d091906126b3565b60405180910390a36115e483600084611aa7565b505050565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b600080600090505b835181101561179e5761178b8582815181106116fc577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b602002602001015185838151811061173d577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b602002602001015185848151811061177e577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151611191565b8080611796906128d2565b9150506116b7565b50600190509392505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561181a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161181190612673565b60405180910390fd5b61182660008383611a4f565b8060026000828254611838919061278e565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825461188d919061278e565b925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516118f291906126b3565b60405180910390a361190660008383611aa7565b5050565b61191261077b565b611951576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611948906124d3565b60405180910390fd5b6000600560146101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa611995610f94565b6040516119a2919061245b565b60405180910390a1565b6119b461077b565b156119f4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119eb90612573565b60405180910390fd5b6001600560146101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258611a38610f94565b604051611a45919061245b565b60405180910390a1565b611a5a838383610f8f565b611a6261077b565b15611aa2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a9990612693565b60405180910390fd5b505050565b505050565b6000611abf611aba8461271a565b6126e9565b90508083825260208201905082856020860282011115611ade57600080fd5b60005b85811015611b0e5781611af48882611b84565b845260208401935060208301925050600181019050611ae1565b5050509392505050565b6000611b2b611b2684612746565b6126e9565b90508083825260208201905082856020860282011115611b4a57600080fd5b60005b85811015611b7a5781611b608882611bed565b845260208401935060208301925050600181019050611b4d565b5050509392505050565b600081359050611b93816129b9565b92915050565b600082601f830112611baa57600080fd5b8135611bba848260208601611aac565b91505092915050565b600082601f830112611bd457600080fd5b8135611be4848260208601611b18565b91505092915050565b600081359050611bfc816129d0565b92915050565b600060208284031215611c1457600080fd5b6000611c2284828501611b84565b91505092915050565b60008060408385031215611c3e57600080fd5b6000611c4c85828601611b84565b9250506020611c5d85828601611b84565b9150509250929050565b600080600060608486031215611c7c57600080fd5b6000611c8a86828701611b84565b9350506020611c9b86828701611b84565b9250506040611cac86828701611bed565b9150509250925092565b60008060408385031215611cc957600080fd5b6000611cd785828601611b84565b9250506020611ce885828601611bed565b9150509250929050565b600080600060608486031215611d0757600080fd5b600084013567ffffffffffffffff811115611d2157600080fd5b611d2d86828701611b99565b935050602084013567ffffffffffffffff811115611d4a57600080fd5b611d5686828701611b99565b925050604084013567ffffffffffffffff811115611d7357600080fd5b611d7f86828701611bc3565b9150509250925092565b60008060408385031215611d9c57600080fd5b600083013567ffffffffffffffff811115611db657600080fd5b611dc285828601611b99565b925050602083013567ffffffffffffffff811115611ddf57600080fd5b611deb85828601611bc3565b9150509250929050565b600060208284031215611e0757600080fd5b6000611e1584828501611bed565b91505092915050565b611e2781612818565b82525050565b611e368161282a565b82525050565b6000611e4782612772565b611e51818561277d565b9350611e6181856020860161286d565b611e6a816129a8565b840191505092915050565b6000611e8260238361277d565b91507f45524332303a207472616e7366657220746f20746865207a65726f206164647260008301527f65737300000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000611ee860148361277d565b91507f5061757361626c653a206e6f74207061757365640000000000000000000000006000830152602082019050919050565b6000611f2860228361277d565b91507f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60008301527f63650000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000611f8e60268361277d565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000611ff460228361277d565b91507f45524332303a20617070726f766520746f20746865207a65726f20616464726560008301527f73730000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b600061205a60268361277d565b91507f45524332303a207472616e7366657220616d6f756e742065786365656473206260008301527f616c616e636500000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006120c060108361277d565b91507f5061757361626c653a20706175736564000000000000000000000000000000006000830152602082019050919050565b600061210060288361277d565b91507f45524332303a207472616e7366657220616d6f756e742065786365656473206160008301527f6c6c6f77616e63650000000000000000000000000000000000000000000000006020830152604082019050919050565b600061216660208361277d565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b60006121a660248361277d565b91507f45524332303a206275726e20616d6f756e74206578636565647320616c6c6f7760008301527f616e6365000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b600061220c60218361277d565b91507f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360008301527f73000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b600061227260258361277d565b91507f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008301527f64726573730000000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006122d860248361277d565b91507f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008301527f72657373000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b600061233e60258361277d565b91507f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008301527f207a65726f0000000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006123a4601f8361277d565b91507f45524332303a206d696e7420746f20746865207a65726f2061646472657373006000830152602082019050919050565b60006123e4602a8361277d565b91507f45524332305061757361626c653a20746f6b656e207472616e7366657220776860008301527f696c6520706175736564000000000000000000000000000000000000000000006020830152604082019050919050565b61244681612856565b82525050565b61245581612860565b82525050565b60006020820190506124706000830184611e1e565b92915050565b600060208201905061248b6000830184611e2d565b92915050565b600060208201905081810360008301526124ab8184611e3c565b905092915050565b600060208201905081810360008301526124cc81611e75565b9050919050565b600060208201905081810360008301526124ec81611edb565b9050919050565b6000602082019050818103600083015261250c81611f1b565b9050919050565b6000602082019050818103600083015261252c81611f81565b9050919050565b6000602082019050818103600083015261254c81611fe7565b9050919050565b6000602082019050818103600083015261256c8161204d565b9050919050565b6000602082019050818103600083015261258c816120b3565b9050919050565b600060208201905081810360008301526125ac816120f3565b9050919050565b600060208201905081810360008301526125cc81612159565b9050919050565b600060208201905081810360008301526125ec81612199565b9050919050565b6000602082019050818103600083015261260c816121ff565b9050919050565b6000602082019050818103600083015261262c81612265565b9050919050565b6000602082019050818103600083015261264c816122cb565b9050919050565b6000602082019050818103600083015261266c81612331565b9050919050565b6000602082019050818103600083015261268c81612397565b9050919050565b600060208201905081810360008301526126ac816123d7565b9050919050565b60006020820190506126c8600083018461243d565b92915050565b60006020820190506126e3600083018461244c565b92915050565b6000604051905081810181811067ffffffffffffffff821117156127105761270f612979565b5b8060405250919050565b600067ffffffffffffffff82111561273557612734612979565b5b602082029050602081019050919050565b600067ffffffffffffffff82111561276157612760612979565b5b602082029050602081019050919050565b600081519050919050565b600082825260208201905092915050565b600061279982612856565b91506127a483612856565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156127d9576127d861291b565b5b828201905092915050565b60006127ef82612856565b91506127fa83612856565b92508282101561280d5761280c61291b565b5b828203905092915050565b600061282382612836565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b8381101561288b578082015181840152602081019050612870565b8381111561289a576000848401525b50505050565b600060028204905060018216806128b857607f821691505b602082108114156128cc576128cb61294a565b5b50919050565b60006128dd82612856565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156129105761290f61291b565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000601f19601f8301169050919050565b6129c281612818565b81146129cd57600080fd5b50565b6129d981612856565b81146129e457600080fd5b5056fea2646970667358221220f884bce57013246d456999bf31f9fa9374ac82accb332f7e9a58314d971596b964736f6c634300080000330000000000000000000000000000000000000001431e0fae6d7217caa0000000

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

0000000000000000000000000000000000000001431e0fae6d7217caa0000000

-----Decoded View---------------
Arg [0] : initialSupply (uint256): 100000000000000000000000000000

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000001431e0fae6d7217caa0000000

50486:1253:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51365:160;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;33008:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35175:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34128:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35826:492;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33970:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37725:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49631:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44884:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51243:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34299:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26122:103;;;:::i;:::-;;50041:368;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51533:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;25471:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51121:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;33227:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38443:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34639:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34877:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51042:70;;;:::i;:::-;;36987:325;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50967:66;;;:::i;:::-;;26380:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51365:160;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51473:44:::1;51491:6;51499:9;51510:6;51473:17;:44::i;:::-;;51365:160:::0;;;:::o;33008:100::-;33062:13;33095:5;33088:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33008:100;:::o;35175:169::-;35258:4;35275:39;35284:12;:10;:12::i;:::-;35298:7;35307:6;35275:8;:39::i;:::-;35332:4;35325:11;;35175:169;;;;:::o;34128:108::-;34189:7;34216:12;;34209:19;;34128:108;:::o;35826:492::-;35966:4;35983:36;35993:6;36001:9;36012:6;35983:9;:36::i;:::-;36032:24;36059:11;:19;36071:6;36059:19;;;;;;;;;;;;;;;:33;36079:12;:10;:12::i;:::-;36059:33;;;;;;;;;;;;;;;;36032:60;;36131:6;36111:16;:26;;36103:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;36218:57;36227:6;36235:12;:10;:12::i;:::-;36268:6;36249:16;:25;36218:8;:57::i;:::-;36306:4;36299:11;;;35826:492;;;;;:::o;33970:93::-;34028:5;34053:2;34046:9;;33970:93;:::o;37725:215::-;37813:4;37830:80;37839:12;:10;:12::i;:::-;37853:7;37899:10;37862:11;:25;37874:12;:10;:12::i;:::-;37862:25;;;;;;;;;;;;;;;:34;37888:7;37862:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;37830:8;:80::i;:::-;37928:4;37921:11;;37725:215;;;;:::o;49631:91::-;49687:27;49693:12;:10;:12::i;:::-;49707:6;49687:5;:27::i;:::-;49631:91;:::o;44884:86::-;44931:4;44955:7;;;;;;;;;;;44948:14;;44884:86;:::o;51243:114::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51325:24:::1;51331:9;51342:6;51325:5;:24::i;:::-;51243:114:::0;;:::o;34299:127::-;34373:7;34400:9;:18;34410:7;34400:18;;;;;;;;;;;;;;;;34393:25;;34299:127;;;:::o;26122:103::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26187:30:::1;26214:1;26187:18;:30::i;:::-;26122:103::o:0;50041:368::-;50118:24;50145:32;50155:7;50164:12;:10;:12::i;:::-;50145:9;:32::i;:::-;50118:59;;50216:6;50196:16;:26;;50188:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;50299:58;50308:7;50317:12;:10;:12::i;:::-;50350:6;50331:16;:25;50299:8;:58::i;:::-;50379:22;50385:7;50394:6;50379:5;:22::i;:::-;50041:368;;;:::o;51533:201::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51674:52:::1;51702:6;51710;51718:7;51674:27;:52::i;:::-;;51533:201:::0;;;:::o;25471:87::-;25517:7;25544:6;;;;;;;;;;;25537:13;;25471:87;:::o;51121:114::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51203:24:::1;51209:9;51220:6;51203:5;:24::i;:::-;51121:114:::0;;:::o;33227:104::-;33283:13;33316:7;33309:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33227:104;:::o;38443:413::-;38536:4;38553:24;38580:11;:25;38592:12;:10;:12::i;:::-;38580:25;;;;;;;;;;;;;;;:34;38606:7;38580:34;;;;;;;;;;;;;;;;38553:61;;38653:15;38633:16;:35;;38625:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;38746:67;38755:12;:10;:12::i;:::-;38769:7;38797:15;38778:16;:34;38746:8;:67::i;:::-;38844:4;38837:11;;;38443:413;;;;:::o;34639:175::-;34725:4;34742:42;34752:12;:10;:12::i;:::-;34766:9;34777:6;34742:9;:42::i;:::-;34802:4;34795:11;;34639:175;;;;:::o;34877:151::-;34966:7;34993:11;:18;35005:5;34993:18;;;;;;;;;;;;;;;:27;35012:7;34993:27;;;;;;;;;;;;;;;;34986:34;;34877:151;;;;:::o;51042:70::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51094:10:::1;:8;:10::i;:::-;51042:70::o:0;36987:325::-;37144:4;37168:9;37180:1;37168:13;;37163:120;37187:7;:14;37183:1;:18;37163:120;;;37223:48;37233:12;:10;:12::i;:::-;37247:7;37255:1;37247:10;;;;;;;;;;;;;;;;;;;;;;37259:8;37268:1;37259:11;;;;;;;;;;;;;;;;;;;;;;37223:9;:48::i;:::-;37203:3;;;;;:::i;:::-;;;;37163:120;;;;37300:4;37293:11;;36987:325;;;;:::o;50967:66::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51017:8:::1;:6;:8::i;:::-;50967:66::o:0;26380:201::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26489:1:::1;26469:22;;:8;:22;;;;26461:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;26545:28;26564:8;26545:18;:28::i;:::-;26380:201:::0;:::o;43107:125::-;;;;:::o;24252:98::-;24305:7;24332:10;24325:17;;24252:98;:::o;36327:287::-;36465:4;36488:36;36498:6;36506:9;36517:6;36488:9;:36::i;:::-;36539:39;36548:6;36556:12;:10;:12::i;:::-;36571:6;36539:8;:39::i;:::-;36600:4;36593:11;;36327:287;;;;;:::o;42127:380::-;42280:1;42263:19;;:5;:19;;;;42255:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;42361:1;42342:21;;:7;:21;;;;42334:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;42445:6;42415:11;:18;42427:5;42415:18;;;;;;;;;;;;;;;:27;42434:7;42415:27;;;;;;;;;;;;;;;:36;;;;42483:7;42467:32;;42476:5;42467:32;;;42492:6;42467:32;;;;;;:::i;:::-;;;;;;;;42127:380;;;:::o;39346:733::-;39504:1;39486:20;;:6;:20;;;;39478:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;39588:1;39567:23;;:9;:23;;;;39559:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;39643:47;39664:6;39672:9;39683:6;39643:20;:47::i;:::-;39703:21;39727:9;:17;39737:6;39727:17;;;;;;;;;;;;;;;;39703:41;;39780:6;39763:13;:23;;39755:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;39901:6;39885:13;:22;39865:9;:17;39875:6;39865:17;;;;;;;;;;;;;;;:42;;;;39953:6;39929:9;:20;39939:9;39929:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;39994:9;39977:35;;39986:6;39977:35;;;40005:6;39977:35;;;;;;:::i;:::-;;;;;;;;40025:46;40045:6;40053:9;40064:6;40025:19;:46::i;:::-;39346:733;;;;:::o;41098:591::-;41201:1;41182:21;;:7;:21;;;;41174:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;41254:49;41275:7;41292:1;41296:6;41254:20;:49::i;:::-;41316:22;41341:9;:18;41351:7;41341:18;;;;;;;;;;;;;;;;41316:43;;41396:6;41378:14;:24;;41370:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;41515:6;41498:14;:23;41477:9;:18;41487:7;41477:18;;;;;;;;;;;;;;;:44;;;;41559:6;41543:12;;:22;;;;;;;:::i;:::-;;;;;;;;41609:1;41583:37;;41592:7;41583:37;;;41613:6;41583:37;;;;;;:::i;:::-;;;;;;;;41633:48;41653:7;41670:1;41674:6;41633:19;:48::i;:::-;41098:591;;;:::o;26741:191::-;26815:16;26834:6;;;;;;;;;;;26815:25;;26860:8;26851:6;;:17;;;;;;;;;;;;;;;;;;26915:8;26884:40;;26905:8;26884:40;;;;;;;;;;;;26741:191;;:::o;36622:357::-;36812:4;36837:9;36849:1;36837:13;;36832:118;36856:7;:14;36852:1;:18;36832:118;;;36892:46;36902:7;36910:1;36902:10;;;;;;;;;;;;;;;;;;;;;;36914:7;36922:1;36914:10;;;;;;;;;;;;;;;;;;;;;;36926:8;36935:1;36926:11;;;;;;;;;;;;;;;;;;;;;;36892:9;:46::i;:::-;36872:3;;;;;:::i;:::-;;;;36832:118;;;;36967:4;36960:11;;36622:357;;;;;:::o;40366:399::-;40469:1;40450:21;;:7;:21;;;;40442:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;40520:49;40549:1;40553:7;40562:6;40520:20;:49::i;:::-;40598:6;40582:12;;:22;;;;;;;:::i;:::-;;;;;;;;40637:6;40615:9;:18;40625:7;40615:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;40680:7;40659:37;;40676:1;40659:37;;;40689:6;40659:37;;;;;;:::i;:::-;;;;;;;;40709:48;40737:1;40741:7;40750:6;40709:19;:48::i;:::-;40366:399;;:::o;45943:120::-;45487:8;:6;:8::i;:::-;45479:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;46012:5:::1;46002:7;;:15;;;;;;;;;;;;;;;;;;46033:22;46042:12;:10;:12::i;:::-;46033:22;;;;;;:::i;:::-;;;;;;;;45943:120::o:0;45684:118::-;45210:8;:6;:8::i;:::-;45209:9;45201:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;45754:4:::1;45744:7;;:14;;;;;;;;;;;;;;;;;;45774:20;45781:12;:10;:12::i;:::-;45774:20;;;;;;:::i;:::-;;;;;;;;45684:118::o:0;50675:284::-;50822:44;50849:4;50855:2;50859:6;50822:26;:44::i;:::-;50890:8;:6;:8::i;:::-;50889:9;50881:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;50675:284;;;:::o;43836:124::-;;;;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;669:622::-;;790:80;805:64;862:6;805:64;:::i;:::-;790:80;:::i;:::-;781:89;;890:5;918:6;911:5;904:21;944:4;937:5;933:16;926:23;;969:6;1019:3;1011:4;1003:6;999:17;994:3;990:27;987:36;984:2;;;1036:1;1033;1026:12;984:2;1064:1;1049:236;1074:6;1071:1;1068:13;1049:236;;;1141:3;1169:37;1202:3;1190:10;1169:37;:::i;:::-;1164:3;1157:50;1236:4;1231:3;1227:14;1220:21;;1270:4;1265:3;1261:14;1254:21;;1109:176;1096:1;1093;1089:9;1084:14;;1049:236;;;1053:14;771:520;;;;;;;:::o;1297:139::-;;1381:6;1368:20;1359:29;;1397:33;1424:5;1397:33;:::i;:::-;1349:87;;;;:::o;1459:303::-;;1579:3;1572:4;1564:6;1560:17;1556:27;1546:2;;1597:1;1594;1587:12;1546:2;1637:6;1624:20;1662:94;1752:3;1744:6;1737:4;1729:6;1725:17;1662:94;:::i;:::-;1653:103;;1536:226;;;;;:::o;1785:303::-;;1905:3;1898:4;1890:6;1886:17;1882:27;1872:2;;1923:1;1920;1913:12;1872:2;1963:6;1950:20;1988:94;2078:3;2070:6;2063:4;2055:6;2051:17;1988:94;:::i;:::-;1979:103;;1862:226;;;;;:::o;2094:139::-;;2178:6;2165:20;2156:29;;2194:33;2221:5;2194:33;:::i;:::-;2146:87;;;;:::o;2239:262::-;;2347:2;2335:9;2326:7;2322:23;2318:32;2315:2;;;2363:1;2360;2353:12;2315:2;2406:1;2431:53;2476:7;2467:6;2456:9;2452:22;2431:53;:::i;:::-;2421:63;;2377:117;2305:196;;;;:::o;2507:407::-;;;2632:2;2620:9;2611:7;2607:23;2603:32;2600:2;;;2648:1;2645;2638:12;2600:2;2691:1;2716:53;2761:7;2752:6;2741:9;2737:22;2716:53;:::i;:::-;2706:63;;2662:117;2818:2;2844:53;2889:7;2880:6;2869:9;2865:22;2844:53;:::i;:::-;2834:63;;2789:118;2590:324;;;;;:::o;2920:552::-;;;;3062:2;3050:9;3041:7;3037:23;3033:32;3030:2;;;3078:1;3075;3068:12;3030:2;3121:1;3146:53;3191:7;3182:6;3171:9;3167:22;3146:53;:::i;:::-;3136:63;;3092:117;3248:2;3274:53;3319:7;3310:6;3299:9;3295:22;3274:53;:::i;:::-;3264:63;;3219:118;3376:2;3402:53;3447:7;3438:6;3427:9;3423:22;3402:53;:::i;:::-;3392:63;;3347:118;3020:452;;;;;:::o;3478:407::-;;;3603:2;3591:9;3582:7;3578:23;3574:32;3571:2;;;3619:1;3616;3609:12;3571:2;3662:1;3687:53;3732:7;3723:6;3712:9;3708:22;3687:53;:::i;:::-;3677:63;;3633:117;3789:2;3815:53;3860:7;3851:6;3840:9;3836:22;3815:53;:::i;:::-;3805:63;;3760:118;3561:324;;;;;:::o;3891:981::-;;;;4108:2;4096:9;4087:7;4083:23;4079:32;4076:2;;;4124:1;4121;4114:12;4076:2;4195:1;4184:9;4180:17;4167:31;4225:18;4217:6;4214:30;4211:2;;;4257:1;4254;4247:12;4211:2;4285:78;4355:7;4346:6;4335:9;4331:22;4285:78;:::i;:::-;4275:88;;4138:235;4440:2;4429:9;4425:18;4412:32;4471:18;4463:6;4460:30;4457:2;;;4503:1;4500;4493:12;4457:2;4531:78;4601:7;4592:6;4581:9;4577:22;4531:78;:::i;:::-;4521:88;;4383:236;4686:2;4675:9;4671:18;4658:32;4717:18;4709:6;4706:30;4703:2;;;4749:1;4746;4739:12;4703:2;4777:78;4847:7;4838:6;4827:9;4823:22;4777:78;:::i;:::-;4767:88;;4629:236;4066:806;;;;;:::o;4878:693::-;;;5053:2;5041:9;5032:7;5028:23;5024:32;5021:2;;;5069:1;5066;5059:12;5021:2;5140:1;5129:9;5125:17;5112:31;5170:18;5162:6;5159:30;5156:2;;;5202:1;5199;5192:12;5156:2;5230:78;5300:7;5291:6;5280:9;5276:22;5230:78;:::i;:::-;5220:88;;5083:235;5385:2;5374:9;5370:18;5357:32;5416:18;5408:6;5405:30;5402:2;;;5448:1;5445;5438:12;5402:2;5476:78;5546:7;5537:6;5526:9;5522:22;5476:78;:::i;:::-;5466:88;;5328:236;5011:560;;;;;:::o;5577:262::-;;5685:2;5673:9;5664:7;5660:23;5656:32;5653:2;;;5701:1;5698;5691:12;5653:2;5744:1;5769:53;5814:7;5805:6;5794:9;5790:22;5769:53;:::i;:::-;5759:63;;5715:117;5643:196;;;;:::o;5845:118::-;5932:24;5950:5;5932:24;:::i;:::-;5927:3;5920:37;5910:53;;:::o;5969:109::-;6050:21;6065:5;6050:21;:::i;:::-;6045:3;6038:34;6028:50;;:::o;6084:364::-;;6200:39;6233:5;6200:39;:::i;:::-;6255:71;6319:6;6314:3;6255:71;:::i;:::-;6248:78;;6335:52;6380:6;6375:3;6368:4;6361:5;6357:16;6335:52;:::i;:::-;6412:29;6434:6;6412:29;:::i;:::-;6407:3;6403:39;6396:46;;6176:272;;;;;:::o;6454:367::-;;6617:67;6681:2;6676:3;6617:67;:::i;:::-;6610:74;;6714:34;6710:1;6705:3;6701:11;6694:55;6780:5;6775:2;6770:3;6766:12;6759:27;6812:2;6807:3;6803:12;6796:19;;6600:221;;;:::o;6827:318::-;;6990:67;7054:2;7049:3;6990:67;:::i;:::-;6983:74;;7087:22;7083:1;7078:3;7074:11;7067:43;7136:2;7131:3;7127:12;7120:19;;6973:172;;;:::o;7151:366::-;;7314:67;7378:2;7373:3;7314:67;:::i;:::-;7307:74;;7411:34;7407:1;7402:3;7398:11;7391:55;7477:4;7472:2;7467:3;7463:12;7456:26;7508:2;7503:3;7499:12;7492:19;;7297:220;;;:::o;7523:370::-;;7686:67;7750:2;7745:3;7686:67;:::i;:::-;7679:74;;7783:34;7779:1;7774:3;7770:11;7763:55;7849:8;7844:2;7839:3;7835:12;7828:30;7884:2;7879:3;7875:12;7868:19;;7669:224;;;:::o;7899:366::-;;8062:67;8126:2;8121:3;8062:67;:::i;:::-;8055:74;;8159:34;8155:1;8150:3;8146:11;8139:55;8225:4;8220:2;8215:3;8211:12;8204:26;8256:2;8251:3;8247:12;8240:19;;8045:220;;;:::o;8271:370::-;;8434:67;8498:2;8493:3;8434:67;:::i;:::-;8427:74;;8531:34;8527:1;8522:3;8518:11;8511:55;8597:8;8592:2;8587:3;8583:12;8576:30;8632:2;8627:3;8623:12;8616:19;;8417:224;;;:::o;8647:314::-;;8810:67;8874:2;8869:3;8810:67;:::i;:::-;8803:74;;8907:18;8903:1;8898:3;8894:11;8887:39;8952:2;8947:3;8943:12;8936:19;;8793:168;;;:::o;8967:372::-;;9130:67;9194:2;9189:3;9130:67;:::i;:::-;9123:74;;9227:34;9223:1;9218:3;9214:11;9207:55;9293:10;9288:2;9283:3;9279:12;9272:32;9330:2;9325:3;9321:12;9314:19;;9113:226;;;:::o;9345:330::-;;9508:67;9572:2;9567:3;9508:67;:::i;:::-;9501:74;;9605:34;9601:1;9596:3;9592:11;9585:55;9666:2;9661:3;9657:12;9650:19;;9491:184;;;:::o;9681:368::-;;9844:67;9908:2;9903:3;9844:67;:::i;:::-;9837:74;;9941:34;9937:1;9932:3;9928:11;9921:55;10007:6;10002:2;9997:3;9993:12;9986:28;10040:2;10035:3;10031:12;10024:19;;9827:222;;;:::o;10055:365::-;;10218:67;10282:2;10277:3;10218:67;:::i;:::-;10211:74;;10315:34;10311:1;10306:3;10302:11;10295:55;10381:3;10376:2;10371:3;10367:12;10360:25;10411:2;10406:3;10402:12;10395:19;;10201:219;;;:::o;10426:369::-;;10589:67;10653:2;10648:3;10589:67;:::i;:::-;10582:74;;10686:34;10682:1;10677:3;10673:11;10666:55;10752:7;10747:2;10742:3;10738:12;10731:29;10786:2;10781:3;10777:12;10770:19;;10572:223;;;:::o;10801:368::-;;10964:67;11028:2;11023:3;10964:67;:::i;:::-;10957:74;;11061:34;11057:1;11052:3;11048:11;11041:55;11127:6;11122:2;11117:3;11113:12;11106:28;11160:2;11155:3;11151:12;11144:19;;10947:222;;;:::o;11175:369::-;;11338:67;11402:2;11397:3;11338:67;:::i;:::-;11331:74;;11435:34;11431:1;11426:3;11422:11;11415:55;11501:7;11496:2;11491:3;11487:12;11480:29;11535:2;11530:3;11526:12;11519:19;;11321:223;;;:::o;11550:329::-;;11713:67;11777:2;11772:3;11713:67;:::i;:::-;11706:74;;11810:33;11806:1;11801:3;11797:11;11790:54;11870:2;11865:3;11861:12;11854:19;;11696:183;;;:::o;11885:374::-;;12048:67;12112:2;12107:3;12048:67;:::i;:::-;12041:74;;12145:34;12141:1;12136:3;12132:11;12125:55;12211:12;12206:2;12201:3;12197:12;12190:34;12250:2;12245:3;12241:12;12234:19;;12031:228;;;:::o;12265:118::-;12352:24;12370:5;12352:24;:::i;:::-;12347:3;12340:37;12330:53;;:::o;12389:112::-;12472:22;12488:5;12472:22;:::i;:::-;12467:3;12460:35;12450:51;;:::o;12507:222::-;;12638:2;12627:9;12623:18;12615:26;;12651:71;12719:1;12708:9;12704:17;12695:6;12651:71;:::i;:::-;12605:124;;;;:::o;12735:210::-;;12860:2;12849:9;12845:18;12837:26;;12873:65;12935:1;12924:9;12920:17;12911:6;12873:65;:::i;:::-;12827:118;;;;:::o;12951:313::-;;13102:2;13091:9;13087:18;13079:26;;13151:9;13145:4;13141:20;13137:1;13126:9;13122:17;13115:47;13179:78;13252:4;13243:6;13179:78;:::i;:::-;13171:86;;13069:195;;;;:::o;13270:419::-;;13474:2;13463:9;13459:18;13451:26;;13523:9;13517:4;13513:20;13509:1;13498:9;13494:17;13487:47;13551:131;13677:4;13551:131;:::i;:::-;13543:139;;13441:248;;;:::o;13695:419::-;;13899:2;13888:9;13884:18;13876:26;;13948:9;13942:4;13938:20;13934:1;13923:9;13919:17;13912:47;13976:131;14102:4;13976:131;:::i;:::-;13968:139;;13866:248;;;:::o;14120:419::-;;14324:2;14313:9;14309:18;14301:26;;14373:9;14367:4;14363:20;14359:1;14348:9;14344:17;14337:47;14401:131;14527:4;14401:131;:::i;:::-;14393:139;;14291:248;;;:::o;14545:419::-;;14749:2;14738:9;14734:18;14726:26;;14798:9;14792:4;14788:20;14784:1;14773:9;14769:17;14762:47;14826:131;14952:4;14826:131;:::i;:::-;14818:139;;14716:248;;;:::o;14970:419::-;;15174:2;15163:9;15159:18;15151:26;;15223:9;15217:4;15213:20;15209:1;15198:9;15194:17;15187:47;15251:131;15377:4;15251:131;:::i;:::-;15243:139;;15141:248;;;:::o;15395:419::-;;15599:2;15588:9;15584:18;15576:26;;15648:9;15642:4;15638:20;15634:1;15623:9;15619:17;15612:47;15676:131;15802:4;15676:131;:::i;:::-;15668:139;;15566:248;;;:::o;15820:419::-;;16024:2;16013:9;16009:18;16001:26;;16073:9;16067:4;16063:20;16059:1;16048:9;16044:17;16037:47;16101:131;16227:4;16101:131;:::i;:::-;16093:139;;15991:248;;;:::o;16245:419::-;;16449:2;16438:9;16434:18;16426:26;;16498:9;16492:4;16488:20;16484:1;16473:9;16469:17;16462:47;16526:131;16652:4;16526:131;:::i;:::-;16518:139;;16416:248;;;:::o;16670:419::-;;16874:2;16863:9;16859:18;16851:26;;16923:9;16917:4;16913:20;16909:1;16898:9;16894:17;16887:47;16951:131;17077:4;16951:131;:::i;:::-;16943:139;;16841:248;;;:::o;17095:419::-;;17299:2;17288:9;17284:18;17276:26;;17348:9;17342:4;17338:20;17334:1;17323:9;17319:17;17312:47;17376:131;17502:4;17376:131;:::i;:::-;17368:139;;17266:248;;;:::o;17520:419::-;;17724:2;17713:9;17709:18;17701:26;;17773:9;17767:4;17763:20;17759:1;17748:9;17744:17;17737:47;17801:131;17927:4;17801:131;:::i;:::-;17793:139;;17691:248;;;:::o;17945:419::-;;18149:2;18138:9;18134:18;18126:26;;18198:9;18192:4;18188:20;18184:1;18173:9;18169:17;18162:47;18226:131;18352:4;18226:131;:::i;:::-;18218:139;;18116:248;;;:::o;18370:419::-;;18574:2;18563:9;18559:18;18551:26;;18623:9;18617:4;18613:20;18609:1;18598:9;18594:17;18587:47;18651:131;18777:4;18651:131;:::i;:::-;18643:139;;18541:248;;;:::o;18795:419::-;;18999:2;18988:9;18984:18;18976:26;;19048:9;19042:4;19038:20;19034:1;19023:9;19019:17;19012:47;19076:131;19202:4;19076:131;:::i;:::-;19068:139;;18966:248;;;:::o;19220:419::-;;19424:2;19413:9;19409:18;19401:26;;19473:9;19467:4;19463:20;19459:1;19448:9;19444:17;19437:47;19501:131;19627:4;19501:131;:::i;:::-;19493:139;;19391:248;;;:::o;19645:419::-;;19849:2;19838:9;19834:18;19826:26;;19898:9;19892:4;19888:20;19884:1;19873:9;19869:17;19862:47;19926:131;20052:4;19926:131;:::i;:::-;19918:139;;19816:248;;;:::o;20070:222::-;;20201:2;20190:9;20186:18;20178:26;;20214:71;20282:1;20271:9;20267:17;20258:6;20214:71;:::i;:::-;20168:124;;;;:::o;20298:214::-;;20425:2;20414:9;20410:18;20402:26;;20438:67;20502:1;20491:9;20487:17;20478:6;20438:67;:::i;:::-;20392:120;;;;:::o;20518:283::-;;20584:2;20578:9;20568:19;;20626:4;20618:6;20614:17;20733:6;20721:10;20718:22;20697:18;20685:10;20682:34;20679:62;20676:2;;;20744:18;;:::i;:::-;20676:2;20784:10;20780:2;20773:22;20558:243;;;;:::o;20807:311::-;;20974:18;20966:6;20963:30;20960:2;;;20996:18;;:::i;:::-;20960:2;21046:4;21038:6;21034:17;21026:25;;21106:4;21100;21096:15;21088:23;;20889:229;;;:::o;21124:311::-;;21291:18;21283:6;21280:30;21277:2;;;21313:18;;:::i;:::-;21277:2;21363:4;21355:6;21351:17;21343:25;;21423:4;21417;21413:15;21405:23;;21206:229;;;:::o;21441:99::-;;21527:5;21521:12;21511:22;;21500:40;;;:::o;21546:169::-;;21664:6;21659:3;21652:19;21704:4;21699:3;21695:14;21680:29;;21642:73;;;;:::o;21721:305::-;;21780:20;21798:1;21780:20;:::i;:::-;21775:25;;21814:20;21832:1;21814:20;:::i;:::-;21809:25;;21968:1;21900:66;21896:74;21893:1;21890:81;21887:2;;;21974:18;;:::i;:::-;21887:2;22018:1;22015;22011:9;22004:16;;21765:261;;;;:::o;22032:191::-;;22092:20;22110:1;22092:20;:::i;:::-;22087:25;;22126:20;22144:1;22126:20;:::i;:::-;22121:25;;22165:1;22162;22159:8;22156:2;;;22170:18;;:::i;:::-;22156:2;22215:1;22212;22208:9;22200:17;;22077:146;;;;:::o;22229:96::-;;22295:24;22313:5;22295:24;:::i;:::-;22284:35;;22274:51;;;:::o;22331:90::-;;22408:5;22401:13;22394:21;22383:32;;22373:48;;;:::o;22427:126::-;;22504:42;22497:5;22493:54;22482:65;;22472:81;;;:::o;22559:77::-;;22625:5;22614:16;;22604:32;;;:::o;22642:86::-;;22717:4;22710:5;22706:16;22695:27;;22685:43;;;:::o;22734:307::-;22802:1;22812:113;22826:6;22823:1;22820:13;22812:113;;;22911:1;22906:3;22902:11;22896:18;22892:1;22887:3;22883:11;22876:39;22848:2;22845:1;22841:10;22836:15;;22812:113;;;22943:6;22940:1;22937:13;22934:2;;;23023:1;23014:6;23009:3;23005:16;22998:27;22934:2;22783:258;;;;:::o;23047:320::-;;23128:1;23122:4;23118:12;23108:22;;23175:1;23169:4;23165:12;23196:18;23186:2;;23252:4;23244:6;23240:17;23230:27;;23186:2;23314;23306:6;23303:14;23283:18;23280:38;23277:2;;;23333:18;;:::i;:::-;23277:2;23098:269;;;;:::o;23373:233::-;;23435:24;23453:5;23435:24;:::i;:::-;23426:33;;23481:66;23474:5;23471:77;23468:2;;;23551:18;;:::i;:::-;23468:2;23598:1;23591:5;23587:13;23580:20;;23416:190;;;:::o;23612:180::-;23660:77;23657:1;23650:88;23757:4;23754:1;23747:15;23781:4;23778:1;23771:15;23798:180;23846:77;23843:1;23836:88;23943:4;23940:1;23933:15;23967:4;23964:1;23957:15;23984:180;24032:77;24029:1;24022:88;24129:4;24126:1;24119:15;24153:4;24150:1;24143:15;24170:102;;24262:2;24258:7;24253:2;24246:5;24242:14;24238:28;24228:38;;24218:54;;;:::o;24278:122::-;24351:24;24369:5;24351:24;:::i;:::-;24344:5;24341:35;24331:2;;24390:1;24387;24380:12;24331:2;24321:79;:::o;24406:122::-;24479:24;24497:5;24479:24;:::i;:::-;24472:5;24469:35;24459:2;;24518:1;24515;24508:12;24459:2;24449:79;:::o

ipfs://f884bce57013246d456999bf31f9fa9374ac82accb332f7e9a58314d971596b9