Token

ERC-20: Mineable Token Coinpass (MTC)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

18 MTC

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x55d56228875d35c034befe1461c22c51179a6386

Filtered by Token Holder

0x4A73a4cb2794962cC908068B3FF6b50EDD5081B9

Balance

1 MTC

0x4a73a4cb2794962cc908068b3ff6b50edd5081b9

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

AirdropToken

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-09-08
*/

pragma solidity ^0.8.0;

 

/*
 
*/



/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];           

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}



/*
 * @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 GSN 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 payable) {
        return payable(msg.sender);
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}
 

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}



/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

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

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

    // Mapping from token ID to approved address
    mapping (uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping (uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId); // internal owner

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
    }

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

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

   /**
    * @dev Returns the element stored at position `index` in the set. O(1).
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}



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

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

contract AirdropToken is ERC721 {
    
    
   
    bytes32 internal _merkleRoot;
                                         
    uint256 internal nextTokenId = 0;

    mapping(address => bool) public hasClaimed;

    address public _animationToken;

    uint256 constant LEVEL_TWO_AMOUNT = 2100 * (10**8);

    uint256 constant LEVEL_THREE_AMOUNT = 21000 * (10**8);


    constructor(string memory name, string memory symbol, bytes32 merkleRoot, address animationToken) ERC721(name, symbol) {
        _merkleRoot = merkleRoot;
        _animationToken = animationToken;
    }  

 

    /**
    * @dev Mints new NFTs
    */
    function mintWithProof(bytes32[] memory merkleProof ) public {
 
        require( MerkleProof.verify(merkleProof, _merkleRoot, keccak256( abi.encodePacked(msg.sender)) ) , 'proof failure');

        require(hasClaimed[msg.sender] == false, 'already claimed');

        hasClaimed[msg.sender]=true;
        
        _mint(msg.sender, nextTokenId++); 
    }

    function getAnimationLevel(uint256 tokenId) public view returns (uint256) {
        address owner = ownerOf(tokenId);

        if( IERC20(_animationToken).balanceOf(owner) >= LEVEL_THREE_AMOUNT ){
            return 3;
        }

        if( IERC20(_animationToken).balanceOf(owner) >= LEVEL_TWO_AMOUNT ){
            return 2;
        }

        return 1;
    }
    

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        if(getAnimationLevel(tokenId) == 3){
            return "ipfs://QmbLrLMf8e7VZTcKcq4pjkv7yjLEN7RG8NqKQ4NGPtPuc3";
        }

        if(getAnimationLevel(tokenId) == 2){
            return "ipfs://QmYeMoscWkT25PEeKSh73TZZQKxJ14ZvFE1QavGrebYgkT";
        }

        return "ipfs://Qmah3iL7vaTteRoKeZKG39fP7ECVKNvQSXekf1GkgRunYb";
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"address","name":"animationToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_animationToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getAnimationLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"mintWithProof","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","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":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106101375760003560e01c80636c0360eb116100b8578063a22cb4651161007c578063a22cb46514610388578063b88d4fde146103a4578063c87b56dd146103c0578063d338b03c146103f0578063e985e9c51461040c578063fb6e5cf11461043c57610137565b80636c0360eb146102bc57806370a08231146102da57806373b2e80e1461030a57806395d89b411461033a5780639e701adc1461035857610137565b806323b872dd116100ff57806323b872dd146101f45780632f745c591461021057806342842e0e146102405780634f6ccce71461025c5780636352211e1461028c57610137565b806301ffc9a71461013c57806306fdde031461016c578063081812fc1461018a578063095ea7b3146101ba57806318160ddd146101d6575b600080fd5b61015660048036038101906101519190612379565b61045a565b6040516101639190612898565b60405180910390f35b6101746104c1565b60405161018191906128b3565b60405180910390f35b6101a4600480360381019061019f91906123d3565b610553565b6040516101b19190612831565b60405180910390f35b6101d460048036038101906101cf91906122f0565b6105d8565b005b6101de6106f0565b6040516101eb9190612b35565b60405180910390f35b61020e600480360381019061020991906121da565b610701565b005b61022a600480360381019061022591906122f0565b610761565b6040516102379190612b35565b60405180910390f35b61025a600480360381019061025591906121da565b6107bc565b005b610276600480360381019061027191906123d3565b6107dc565b6040516102839190612b35565b60405180910390f35b6102a660048036038101906102a191906123d3565b6107ff565b6040516102b39190612831565b60405180910390f35b6102c4610836565b6040516102d191906128b3565b60405180910390f35b6102f460048036038101906102ef919061216d565b6108c8565b6040516103019190612b35565b60405180910390f35b610324600480360381019061031f919061216d565b610987565b6040516103319190612898565b60405180910390f35b6103426109a7565b60405161034f91906128b3565b60405180910390f35b610372600480360381019061036d91906123d3565b610a39565b60405161037f9190612b35565b60405180910390f35b6103a2600480360381019061039d91906122b0565b610bd3565b005b6103be60048036038101906103b9919061222d565b610d54565b005b6103da60048036038101906103d591906123d3565b610db6565b6040516103e791906128b3565b60405180910390f35b61040a60048036038101906104059190612330565b610e83565b005b6104266004803603810190610421919061219a565b611003565b6040516104339190612898565b60405180910390f35b610444611097565b6040516104519190612831565b60405180910390f35b6000806000837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060009054906101000a900460ff169050919050565b6060600680546104d090612d71565b80601f01602080910402602001604051908101604052809291908181526020018280546104fc90612d71565b80156105495780601f1061051e57610100808354040283529160200191610549565b820191906000526020600020905b81548152906001019060200180831161052c57829003601f168201915b5050505050905090565b600061055e826110bd565b61059d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161059490612a75565b60405180910390fd5b6004600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b60006105e3826107ff565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610654576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064b90612ad5565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166106736110da565b73ffffffffffffffffffffffffffffffffffffffff1614806106a257506106a18161069c6110da565b611003565b5b6106e1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106d8906129f5565b60405180910390fd5b6106eb83836110e2565b505050565b60006106fc600261119b565b905090565b61071261070c6110da565b826111b0565b610751576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161074890612af5565b60405180910390fd5b61075c83838361128e565b505050565b60006107b482600160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206114a590919063ffffffff16565b905092915050565b6107d783838360405180602001604052806000815250610d54565b505050565b6000806107f38360026114bf90919063ffffffff16565b50905080915050919050565b600061082f826040518060600160405280602981526020016135416029913960026114eb9092919063ffffffff16565b9050919050565b60606009805461084590612d71565b80601f016020809104026020016040519081016040528092919081815260200182805461087190612d71565b80156108be5780601f10610893576101008083540402835291602001916108be565b820191906000526020600020905b8154815290600101906020018083116108a157829003601f168201915b5050505050905090565b60008073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610939576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161093090612a15565b60405180910390fd5b610980600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061150a565b9050919050565b600c6020528060005260406000206000915054906101000a900460ff1681565b6060600780546109b690612d71565b80601f01602080910402602001604051908101604052809291908181526020018280546109e290612d71565b8015610a2f5780601f10610a0457610100808354040283529160200191610a2f565b820191906000526020600020905b815481529060010190602001808311610a1257829003601f168201915b5050505050905090565b600080610a45836107ff565b90506501e8f1c10800600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231836040518263ffffffff1660e01b8152600401610aa99190612831565b60206040518083038186803b158015610ac157600080fd5b505afa158015610ad5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610af99190612400565b10610b08576003915050610bce565b6430e4f9b400600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231836040518263ffffffff1660e01b8152600401610b699190612831565b60206040518083038186803b158015610b8157600080fd5b505afa158015610b95573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bb99190612400565b10610bc8576002915050610bce565b60019150505b919050565b610bdb6110da565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610c49576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c4090612995565b60405180910390fd5b8060056000610c566110da565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff16610d036110da565b73ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051610d489190612898565b60405180910390a35050565b610d65610d5f6110da565b836111b0565b610da4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d9b90612af5565b60405180910390fd5b610db08484848461151f565b50505050565b6060610dc1826110bd565b610e00576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610df790612ab5565b60405180910390fd5b6003610e0b83610a39565b1415610e315760405180606001604052806035815260200161350c603591399050610e7e565b6002610e3c83610a39565b1415610e625760405180606001604052806035815260200161359f603591399050610e7e565b60405180606001604052806035815260200161356a6035913990505b919050565b610eb681600a5433604051602001610e9b91906127d3565b6040516020818303038152906040528051906020012061157b565b610ef5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eec90612955565b60405180910390fd5b60001515600c60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16151514610f88576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f7f90612935565b60405180910390fd5b6001600c60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff02191690831515021790555061100033600b6000815480929190610ff790612dd4565b91905055611631565b50565b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60006110d38260026117bf90919063ffffffff16565b9050919050565b600033905090565b816004600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff16611155836107ff565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60006111a9826000016117d9565b9050919050565b60006111bb826110bd565b6111fa576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111f1906129d5565b60405180910390fd5b6000611205836107ff565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16148061127457508373ffffffffffffffffffffffffffffffffffffffff1661125c84610553565b73ffffffffffffffffffffffffffffffffffffffff16145b8061128557506112848185611003565b5b91505092915050565b8273ffffffffffffffffffffffffffffffffffffffff166112ae826107ff565b73ffffffffffffffffffffffffffffffffffffffff1614611304576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112fb90612a95565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611374576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161136b90612975565b60405180910390fd5b61137f8383836117ea565b61138a6000826110e2565b6113db81600160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206117ef90919063ffffffff16565b5061142d81600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061180990919063ffffffff16565b50611444818360026118239092919063ffffffff16565b50808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b60006114b48360000183611858565b60001c905092915050565b6000806000806114d286600001866118cc565b915091508160001c8160001c9350935050509250929050565b60006114fe846000018460001b84611956565b60001c90509392505050565b6000611518826000016119f7565b9050919050565b61152a84848461128e565b61153684848484611a08565b611575576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161156c906128f5565b60405180910390fd5b50505050565b60008082905060005b85518110156116235760008682815181106115a2576115a1612ed8565b5b602002602001015190508083116115e35782816040516020016115c69291906127ee565b60405160208183030381529060405280519060200120925061160f565b80836040516020016115f69291906127ee565b6040516020818303038152906040528051906020012092505b50808061161b90612dd4565b915050611584565b508381149150509392505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156116a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161169890612a55565b60405180910390fd5b6116aa816110bd565b156116ea576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e190612915565b60405180910390fd5b6116f6600083836117ea565b61174781600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061180990919063ffffffff16565b5061175e818360026118239092919063ffffffff16565b50808273ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45050565b60006117d1836000018360001b611b6c565b905092915050565b600081600001805490509050919050565b505050565b6000611801836000018360001b611b8f565b905092915050565b600061181b836000018360001b611ca7565b905092915050565b600061184f846000018460001b8473ffffffffffffffffffffffffffffffffffffffff1660001b611d17565b90509392505050565b6000818360000180549050116118a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161189a906128d5565b60405180910390fd5b8260000182815481106118b9576118b8612ed8565b5b9060005260206000200154905092915050565b60008082846000018054905011611918576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161190f90612a35565b60405180910390fd5b60008460000184815481106119305761192f612ed8565b5b906000526020600020906002020190508060000154816001015492509250509250929050565b600080846001016000858152602001908152602001600020549050600081141583906119b8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119af91906128b3565b60405180910390fd5b50846000016001826119ca9190612c6b565b815481106119db576119da612ed8565b5b9060005260206000209060020201600101549150509392505050565b600081600001805490509050919050565b6000611a298473ffffffffffffffffffffffffffffffffffffffff16611e03565b611a365760019050611b64565b6000611afd63150b7a0260e01b611a4b6110da565b888787604051602401611a61949392919061284c565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506040518060600160405280603281526020016134da603291398773ffffffffffffffffffffffffffffffffffffffff16611e169092919063ffffffff16565b9050600081806020019051810190611b1591906123a6565b905063150b7a0260e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614925050505b949350505050565b600080836001016000848152602001908152602001600020541415905092915050565b60008083600101600084815260200190815260200160002054905060008114611c9b576000600182611bc19190612c6b565b9050600060018660000180549050611bd99190612c6b565b90506000866000018281548110611bf357611bf2612ed8565b5b9060005260206000200154905080876000018481548110611c1757611c16612ed8565b5b9060005260206000200181905550600183611c329190612c15565b8760010160008381526020019081526020016000208190555086600001805480611c5f57611c5e612ea9565b5b60019003818190600052602060002001600090559055866001016000878152602001908152602001600020600090556001945050505050611ca1565b60009150505b92915050565b6000611cb38383611e2e565b611d0c578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050611d11565b600090505b92915050565b6000808460010160008581526020019081526020016000205490506000811415611dbe57846000016040518060400160405280868152602001858152509080600181540180825580915050600190039060005260206000209060020201600090919091909150600082015181600001556020820151816001015550508460000180549050856001016000868152602001908152602001600020819055506001915050611dfc565b8285600001600183611dd09190612c6b565b81548110611de157611de0612ed8565b5b90600052602060002090600202016001018190555060009150505b9392505050565b600080823b905060008111915050919050565b6060611e258484600085611e51565b90509392505050565b600080836001016000848152602001908152602001600020541415905092915050565b606082471015611e96576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e8d906129b5565b60405180910390fd5b611e9f85611e03565b611ede576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ed590612b15565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051611f07919061281a565b60006040518083038185875af1925050503d8060008114611f44576040519150601f19603f3d011682016040523d82523d6000602084013e611f49565b606091505b5091509150611f59828286611f65565b92505050949350505050565b60608315611f7557829050611fc5565b600083511115611f885782518084602001fd5b816040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611fbc91906128b3565b60405180910390fd5b9392505050565b6000611fdf611fda84612b75565b612b50565b9050808382526020820190508285602086028201111561200257612001612f3b565b5b60005b85811015612032578161201888826120d6565b845260208401935060208301925050600181019050612005565b5050509392505050565b600061204f61204a84612ba1565b612b50565b90508281526020810184848401111561206b5761206a612f40565b5b612076848285612d2f565b509392505050565b60008135905061208d81613466565b92915050565b600082601f8301126120a8576120a7612f36565b5b81356120b8848260208601611fcc565b91505092915050565b6000813590506120d08161347d565b92915050565b6000813590506120e581613494565b92915050565b6000813590506120fa816134ab565b92915050565b60008151905061210f816134ab565b92915050565b600082601f83011261212a57612129612f36565b5b813561213a84826020860161203c565b91505092915050565b600081359050612152816134c2565b92915050565b600081519050612167816134c2565b92915050565b60006020828403121561218357612182612f4a565b5b60006121918482850161207e565b91505092915050565b600080604083850312156121b1576121b0612f4a565b5b60006121bf8582860161207e565b92505060206121d08582860161207e565b9150509250929050565b6000806000606084860312156121f3576121f2612f4a565b5b60006122018682870161207e565b93505060206122128682870161207e565b925050604061222386828701612143565b9150509250925092565b6000806000806080858703121561224757612246612f4a565b5b60006122558782880161207e565b94505060206122668782880161207e565b935050604061227787828801612143565b925050606085013567ffffffffffffffff81111561229857612297612f45565b5b6122a487828801612115565b91505092959194509250565b600080604083850312156122c7576122c6612f4a565b5b60006122d58582860161207e565b92505060206122e6858286016120c1565b9150509250929050565b6000806040838503121561230757612306612f4a565b5b60006123158582860161207e565b925050602061232685828601612143565b9150509250929050565b60006020828403121561234657612345612f4a565b5b600082013567ffffffffffffffff81111561236457612363612f45565b5b61237084828501612093565b91505092915050565b60006020828403121561238f5761238e612f4a565b5b600061239d848285016120eb565b91505092915050565b6000602082840312156123bc576123bb612f4a565b5b60006123ca84828501612100565b91505092915050565b6000602082840312156123e9576123e8612f4a565b5b60006123f784828501612143565b91505092915050565b60006020828403121561241657612415612f4a565b5b600061242484828501612158565b91505092915050565b61243681612cb1565b82525050565b61244581612c9f565b82525050565b61245c61245782612c9f565b612e1d565b82525050565b61246b81612cc3565b82525050565b61248261247d82612ccf565b612e2f565b82525050565b600061249382612bd2565b61249d8185612be8565b93506124ad818560208601612d3e565b6124b681612f4f565b840191505092915050565b60006124cc82612bd2565b6124d68185612bf9565b93506124e6818560208601612d3e565b80840191505092915050565b60006124fd82612bdd565b6125078185612c04565b9350612517818560208601612d3e565b61252081612f4f565b840191505092915050565b6000612538602283612c04565b915061254382612f6d565b604082019050919050565b600061255b603283612c04565b915061256682612fbc565b604082019050919050565b600061257e601c83612c04565b91506125898261300b565b602082019050919050565b60006125a1600f83612c04565b91506125ac82613034565b602082019050919050565b60006125c4600d83612c04565b91506125cf8261305d565b602082019050919050565b60006125e7602483612c04565b91506125f282613086565b604082019050919050565b600061260a601983612c04565b9150612615826130d5565b602082019050919050565b600061262d602683612c04565b9150612638826130fe565b604082019050919050565b6000612650602c83612c04565b915061265b8261314d565b604082019050919050565b6000612673603883612c04565b915061267e8261319c565b604082019050919050565b6000612696602a83612c04565b91506126a1826131eb565b604082019050919050565b60006126b9602283612c04565b91506126c48261323a565b604082019050919050565b60006126dc602083612c04565b91506126e782613289565b602082019050919050565b60006126ff602c83612c04565b915061270a826132b2565b604082019050919050565b6000612722602983612c04565b915061272d82613301565b604082019050919050565b6000612745602f83612c04565b915061275082613350565b604082019050919050565b6000612768602183612c04565b91506127738261339f565b604082019050919050565b600061278b603183612c04565b9150612796826133ee565b604082019050919050565b60006127ae601d83612c04565b91506127b98261343d565b602082019050919050565b6127cd81612d25565b82525050565b60006127df828461244b565b60148201915081905092915050565b60006127fa8285612471565b60208201915061280a8284612471565b6020820191508190509392505050565b600061282682846124c1565b915081905092915050565b6000602082019050612846600083018461243c565b92915050565b6000608082019050612861600083018761242d565b61286e602083018661243c565b61287b60408301856127c4565b818103606083015261288d8184612488565b905095945050505050565b60006020820190506128ad6000830184612462565b92915050565b600060208201905081810360008301526128cd81846124f2565b905092915050565b600060208201905081810360008301526128ee8161252b565b9050919050565b6000602082019050818103600083015261290e8161254e565b9050919050565b6000602082019050818103600083015261292e81612571565b9050919050565b6000602082019050818103600083015261294e81612594565b9050919050565b6000602082019050818103600083015261296e816125b7565b9050919050565b6000602082019050818103600083015261298e816125da565b9050919050565b600060208201905081810360008301526129ae816125fd565b9050919050565b600060208201905081810360008301526129ce81612620565b9050919050565b600060208201905081810360008301526129ee81612643565b9050919050565b60006020820190508181036000830152612a0e81612666565b9050919050565b60006020820190508181036000830152612a2e81612689565b9050919050565b60006020820190508181036000830152612a4e816126ac565b9050919050565b60006020820190508181036000830152612a6e816126cf565b9050919050565b60006020820190508181036000830152612a8e816126f2565b9050919050565b60006020820190508181036000830152612aae81612715565b9050919050565b60006020820190508181036000830152612ace81612738565b9050919050565b60006020820190508181036000830152612aee8161275b565b9050919050565b60006020820190508181036000830152612b0e8161277e565b9050919050565b60006020820190508181036000830152612b2e816127a1565b9050919050565b6000602082019050612b4a60008301846127c4565b92915050565b6000612b5a612b6b565b9050612b668282612da3565b919050565b6000604051905090565b600067ffffffffffffffff821115612b9057612b8f612f07565b5b602082029050602081019050919050565b600067ffffffffffffffff821115612bbc57612bbb612f07565b5b612bc582612f4f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612c2082612d25565b9150612c2b83612d25565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115612c6057612c5f612e4b565b5b828201905092915050565b6000612c7682612d25565b9150612c8183612d25565b925082821015612c9457612c93612e4b565b5b828203905092915050565b6000612caa82612d05565b9050919050565b6000612cbc82612d05565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015612d5c578082015181840152602081019050612d41565b83811115612d6b576000848401525b50505050565b60006002820490506001821680612d8957607f821691505b60208210811415612d9d57612d9c612e7a565b5b50919050565b612dac82612f4f565b810181811067ffffffffffffffff82111715612dcb57612dca612f07565b5b80604052505050565b6000612ddf82612d25565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff821415612e1257612e11612e4b565b5b600182019050919050565b6000612e2882612e39565b9050919050565b6000819050919050565b6000612e4482612f60565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e60008201527f6473000000000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560008201527f63656976657220696d706c656d656e7465720000000000000000000000000000602082015250565b7f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000600082015250565b7f616c726561647920636c61696d65640000000000000000000000000000000000600082015250565b7f70726f6f66206661696c75726500000000000000000000000000000000000000600082015250565b7f4552433732313a207472616e7366657220746f20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a20617070726f766520746f2063616c6c657200000000000000600082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860008201527f697374656e7420746f6b656e0000000000000000000000000000000000000000602082015250565b7f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760008201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000602082015250565b7f4552433732313a2062616c616e636520717565727920666f7220746865207a6560008201527f726f206164647265737300000000000000000000000000000000000000000000602082015250565b7f456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e60008201527f6473000000000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a206d696e7420746f20746865207a65726f2061646472657373600082015250565b7f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860008201527f697374656e7420746f6b656e0000000000000000000000000000000000000000602082015250565b7f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960008201527f73206e6f74206f776e0000000000000000000000000000000000000000000000602082015250565b7f4552433732314d657461646174613a2055524920717565727920666f72206e6f60008201527f6e6578697374656e7420746f6b656e0000000000000000000000000000000000602082015250565b7f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560008201527f7200000000000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60008201527f776e6572206e6f7220617070726f766564000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b61346f81612c9f565b811461347a57600080fd5b50565b61348681612cc3565b811461349157600080fd5b50565b61349d81612ccf565b81146134a857600080fd5b50565b6134b481612cd9565b81146134bf57600080fd5b50565b6134cb81612d25565b81146134d657600080fd5b5056fe4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e746572697066733a2f2f516d624c724c4d66386537565a54634b637134706a6b7637796a4c454e375247384e714b51344e475074507563334552433732313a206f776e657220717565727920666f72206e6f6e6578697374656e7420746f6b656e697066733a2f2f516d616833694c377661547465526f4b655a4b4733396650374543564b4e76515358656b6631476b6752756e5962697066733a2f2f516d59654d6f7363576b5432355045654b53683733545a5a514b784a31345a764645315161764772656259676b54a2646970667358221220c4dc3fcbca51cdb0e5965158b18b867836ff82206b47362d82607af67e40c2dc64736f6c63430008070033

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0c2ea70ed0d861a2536d5a15b3c4acbb72dcd577b4d75d8c07743c716d813bf4d000000000000000000000000b6ed7644c69416d67b522e20bc294a9a9b405b3100000000000000000000000000000000000000000000000000000000000000174d696e6561626c6520546f6b656e20436f696e7061737300000000000000000000000000000000000000000000000000000000000000000000000000000000034d54430000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Mineable Token Coinpass
Arg [1] : symbol (string): MTC
Arg [2] : merkleRoot (bytes32): 0xc2ea70ed0d861a2536d5a15b3c4acbb72dcd577b4d75d8c07743c716d813bf4d
Arg [3] : animationToken (address): 0xB6eD7644C69416d67B522e20bC294A9a9B405B31

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : c2ea70ed0d861a2536d5a15b3c4acbb72dcd577b4d75d8c07743c716d813bf4d
Arg [3] : 000000000000000000000000b6ed7644c69416d67b522e20bc294a9a9b405b31
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000017
Arg [5] : 4d696e6561626c6520546f6b656e20436f696e70617373000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 4d54430000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

67416:1939:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4199:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22622:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25408:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24938:404;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24416:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26298:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24178:162;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26674:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24704:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22378:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23997:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22095:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67591:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22791:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68440:374;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25701:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26896:285;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68828:522;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68068:364;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26067:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67642:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4199:150;4284:4;4308:20;:33;4329:11;4308:33;;;;;;;;;;;;;;;;;;;;;;;;;;;4301:40;;4199:150;;;:::o;22622:100::-;22676:13;22709:5;22702:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22622:100;:::o;25408:221::-;25484:7;25512:16;25520:7;25512;:16::i;:::-;25504:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;25597:15;:24;25613:7;25597:24;;;;;;;;;;;;;;;;;;;;;25590:31;;25408:221;;;:::o;24938:404::-;25019:13;25035:23;25050:7;25035:14;:23::i;:::-;25019:39;;25083:5;25077:11;;:2;:11;;;;25069:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;25163:5;25147:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;25172:44;25196:5;25203:12;:10;:12::i;:::-;25172:23;:44::i;:::-;25147:69;25139:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;25313:21;25322:2;25326:7;25313:8;:21::i;:::-;25008:334;24938:404;;:::o;24416:211::-;24477:7;24598:21;:12;:19;:21::i;:::-;24591:28;;24416:211;:::o;26298:305::-;26459:41;26478:12;:10;:12::i;:::-;26492:7;26459:18;:41::i;:::-;26451:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;26567:28;26577:4;26583:2;26587:7;26567:9;:28::i;:::-;26298:305;;;:::o;24178:162::-;24275:7;24302:30;24326:5;24302:13;:20;24316:5;24302:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;24295:37;;24178:162;;;;:::o;26674:151::-;26778:39;26795:4;26801:2;26805:7;26778:39;;;;;;;;;;;;:16;:39::i;:::-;26674:151;;;:::o;24704:172::-;24779:7;24800:15;24821:22;24837:5;24821:12;:15;;:22;;;;:::i;:::-;24799:44;;;24861:7;24854:14;;;24704:172;;;:::o;22378:177::-;22450:7;22477:70;22494:7;22477:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;22470:77;;22378:177;;;:::o;23997:97::-;24045:13;24078:8;24071:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23997:97;:::o;22095:221::-;22167:7;22212:1;22195:19;;:5;:19;;;;22187:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;22279:29;:13;:20;22293:5;22279:20;;;;;;;;;;;;;;;:27;:29::i;:::-;22272:36;;22095:221;;;:::o;67591:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;22791:104::-;22847:13;22880:7;22873:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22791:104;:::o;68440:374::-;68505:7;68525:13;68541:16;68549:7;68541;:16::i;:::-;68525:32;;67778:15;68581;;;;;;;;;;;68574:33;;;68608:5;68574:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:62;68570:103;;68660:1;68653:8;;;;;68570:103;67717:14;68696:15;;;;;;;;;;;68689:33;;;68723:5;68689:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:60;68685:101;;68773:1;68766:8;;;;;68685:101;68805:1;68798:8;;;68440:374;;;;:::o;25701:295::-;25816:12;:10;:12::i;:::-;25804:24;;:8;:24;;;;25796:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;25916:8;25871:18;:32;25890:12;:10;:12::i;:::-;25871:32;;;;;;;;;;;;;;;:42;25904:8;25871:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;25969:8;25940:48;;25955:12;:10;:12::i;:::-;25940:48;;;25979:8;25940:48;;;;;;:::i;:::-;;;;;;;;25701:295;;:::o;26896:285::-;27028:41;27047:12;:10;:12::i;:::-;27061:7;27028:18;:41::i;:::-;27020:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;27134:39;27148:4;27154:2;27158:7;27167:5;27134:13;:39::i;:::-;26896:285;;;;:::o;68828:522::-;68893:13;68927:16;68935:7;68927;:16::i;:::-;68919:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;69041:1;69011:26;69029:7;69011:17;:26::i;:::-;:31;69008:124;;;69058:62;;;;;;;;;;;;;;;;;;;;;69008:124;69177:1;69147:26;69165:7;69147:17;:26::i;:::-;:31;69144:124;;;69194:62;;;;;;;;;;;;;;;;;;;;;69144:124;69280:62;;;;;;;;;;;;;;;;;;;68828:522;;;;:::o;68068:364::-;68152:87;68171:11;68184;;68225:10;68208:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;68197:40;;;;;;68152:18;:87::i;:::-;68143:115;;;;;;;;;;;;:::i;:::-;;;;;;;;;68305:5;68279:31;;:10;:22;68290:10;68279:22;;;;;;;;;;;;;;;;;;;;;;;;;:31;;;68271:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;68366:4;68343:10;:22;68354:10;68343:22;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;68391:32;68397:10;68409:11;;:13;;;;;;;;;:::i;:::-;;;;;68391:5;:32::i;:::-;68068:364;:::o;26067:164::-;26164:4;26188:18;:25;26207:5;26188:25;;;;;;;;;;;;;;;:35;26214:8;26188:35;;;;;;;;;;;;;;;;;;;;;;;;;26181:42;;26067:164;;;;:::o;67642:30::-;;;;;;;;;;;;;:::o;28648:127::-;28713:4;28737:30;28759:7;28737:12;:21;;:30;;;;:::i;:::-;28730:37;;28648:127;;;:::o;2179:115::-;2232:15;2275:10;2260:26;;2179:115;:::o;34555:183::-;34648:2;34621:15;:24;34637:7;34621:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;34704:7;34700:2;34666:46;;34675:23;34690:7;34675:14;:23::i;:::-;34666:46;;;;;;;;;;;;34555:183;;:::o;52176:123::-;52245:7;52272:19;52280:3;:10;;52272:7;:19::i;:::-;52265:26;;52176:123;;;:::o;28942:355::-;29035:4;29060:16;29068:7;29060;:16::i;:::-;29052:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;29136:13;29152:23;29167:7;29152:14;:23::i;:::-;29136:39;;29205:5;29194:16;;:7;:16;;;:51;;;;29238:7;29214:31;;:20;29226:7;29214:11;:20::i;:::-;:31;;;29194:51;:94;;;;29249:39;29273:5;29280:7;29249:23;:39::i;:::-;29194:94;29186:103;;;28942:355;;;;:::o;32078:599::-;32203:4;32176:31;;:23;32191:7;32176:14;:23::i;:::-;:31;;;32168:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;32304:1;32290:16;;:2;:16;;;;32282:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;32360:39;32381:4;32387:2;32391:7;32360:20;:39::i;:::-;32464:29;32481:1;32485:7;32464:8;:29::i;:::-;32506:35;32533:7;32506:13;:19;32520:4;32506:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;32552:30;32574:7;32552:13;:17;32566:2;32552:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;32595:29;32612:7;32621:2;32595:12;:16;;:29;;;;;:::i;:::-;;32661:7;32657:2;32642:27;;32651:4;32642:27;;;;;;;;;;;;32078:599;;;:::o;63617:137::-;63688:7;63723:22;63727:3;:10;;63739:5;63723:3;:22::i;:::-;63715:31;;63708:38;;63617:137;;;;:::o;52638:236::-;52718:7;52727;52748:11;52761:13;52778:22;52782:3;:10;;52794:5;52778:3;:22::i;:::-;52747:53;;;;52827:3;52819:12;;52857:5;52849:14;;52811:55;;;;;;52638:236;;;;;:::o;53924:213::-;54031:7;54082:44;54087:3;:10;;54107:3;54099:12;;54113;54082:4;:44::i;:::-;54074:53;;54051:78;;53924:213;;;;;:::o;63159:114::-;63219:7;63246:19;63254:3;:10;;63246:7;:19::i;:::-;63239:26;;63159:114;;;:::o;28063:272::-;28177:28;28187:4;28193:2;28197:7;28177:9;:28::i;:::-;28224:48;28247:4;28253:2;28257:7;28266:5;28224:22;:48::i;:::-;28216:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;28063:272;;;;:::o;784:841::-;909:4;926:20;949:4;926:27;;971:9;966:536;990:5;:12;986:1;:16;966:536;;;1024:20;1047:5;1053:1;1047:8;;;;;;;;:::i;:::-;;;;;;;;1024:31;;1103:12;1087;:28;1083:408;;1257:12;1271;1240:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1230:55;;;;;;1215:70;;1083:408;;;1447:12;1461;1430:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1420:55;;;;;;1405:70;;1083:408;1009:493;1004:3;;;;;:::i;:::-;;;;966:536;;;;1613:4;1597:12;:20;1590:27;;;784:841;;;;;:::o;30563:404::-;30657:1;30643:16;;:2;:16;;;;30635:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;30716:16;30724:7;30716;:16::i;:::-;30715:17;30707:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;30778:45;30807:1;30811:2;30815:7;30778:20;:45::i;:::-;30836:30;30858:7;30836:13;:17;30850:2;30836:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;30879:29;30896:7;30905:2;30879:12;:16;;:29;;;;;:::i;:::-;;30951:7;30947:2;30926:33;;30943:1;30926:33;;;;;;;;;;;;30563:404;;:::o;51937:151::-;52021:4;52045:35;52055:3;:10;;52075:3;52067:12;;52045:9;:35::i;:::-;52038:42;;51937:151;;;;:::o;48755:110::-;48811:7;48838:3;:12;;:19;;;;48831:26;;48755:110;;;:::o;35351:93::-;;;;:::o;62704:137::-;62774:4;62798:35;62806:3;:10;;62826:5;62818:14;;62798:7;:35::i;:::-;62791:42;;62704:137;;;;:::o;62397:131::-;62464:4;62488:32;62493:3;:10;;62513:5;62505:14;;62488:4;:32::i;:::-;62481:39;;62397:131;;;;:::o;51360:185::-;51449:4;51473:64;51478:3;:10;;51498:3;51490:12;;51528:5;51512:23;;51504:32;;51473:4;:64::i;:::-;51466:71;;51360:185;;;;;:::o;58655:204::-;58722:7;58771:5;58750:3;:11;;:18;;;;:26;58742:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58833:3;:11;;58845:5;58833:18;;;;;;;;:::i;:::-;;;;;;;;;;58826:25;;58655:204;;;;:::o;49220:279::-;49287:7;49296;49346:5;49324:3;:12;;:19;;;;:27;49316:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;49403:22;49428:3;:12;;49441:5;49428:19;;;;;;;;:::i;:::-;;;;;;;;;;;;49403:44;;49466:5;:10;;;49478:5;:12;;;49458:33;;;;;49220:279;;;;;:::o;50717:319::-;50811:7;50831:16;50850:3;:12;;:17;50863:3;50850:17;;;;;;;;;;;;50831:36;;50898:1;50886:8;:13;;50901:12;50878:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;50968:3;:12;;50992:1;50981:8;:12;;;;:::i;:::-;50968:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:33;;;50961:40;;;50717:319;;;;;:::o;58202:109::-;58258:7;58285:3;:11;;:18;;;;58278:25;;58202:109;;;:::o;33943:604::-;34064:4;34091:15;:2;:13;;;:15::i;:::-;34086:60;;34130:4;34123:11;;;;34086:60;34156:23;34182:252;34235:45;;;34295:12;:10;:12::i;:::-;34322:4;34341:7;34363:5;34198:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34182:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;34156:278;;34445:13;34472:10;34461:32;;;;;;;;;;;;:::i;:::-;34445:48;;19092:10;34522:16;;34512:26;;;:6;:26;;;;34504:35;;;;33943:604;;;;;;;:::o;48535:125::-;48606:4;48651:1;48630:3;:12;;:17;48643:3;48630:17;;;;;;;;;;;;:22;;48623:29;;48535:125;;;;:::o;56357:1544::-;56423:4;56541:18;56562:3;:12;;:19;56575:5;56562:19;;;;;;;;;;;;56541:40;;56612:1;56598:10;:15;56594:1300;;56960:21;56997:1;56984:10;:14;;;;:::i;:::-;56960:38;;57013:17;57054:1;57033:3;:11;;:18;;;;:22;;;;:::i;:::-;57013:42;;57300:17;57320:3;:11;;57332:9;57320:22;;;;;;;;:::i;:::-;;;;;;;;;;57300:42;;57466:9;57437:3;:11;;57449:13;57437:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;57585:1;57569:13;:17;;;;:::i;:::-;57543:3;:12;;:23;57556:9;57543:23;;;;;;;;;;;:43;;;;57695:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;57790:3;:12;;:19;57803:5;57790:19;;;;;;;;;;;57783:26;;;57833:4;57826:11;;;;;;;;56594:1300;57877:5;57870:12;;;56357:1544;;;;;:::o;55767:414::-;55830:4;55852:21;55862:3;55867:5;55852:9;:21::i;:::-;55847:327;;55890:3;:11;;55907:5;55890:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56073:3;:11;;:18;;;;56051:3;:12;;:19;56064:5;56051:19;;;;;;;;;;;:40;;;;56113:4;56106:11;;;;55847:327;56157:5;56150:12;;55767:414;;;;;:::o;46035:692::-;46111:4;46227:16;46246:3;:12;;:17;46259:3;46246:17;;;;;;;;;;;;46227:36;;46292:1;46280:8;:13;46276:444;;;46347:3;:12;;46365:38;;;;;;;;46382:3;46365:38;;;;46395:5;46365:38;;;46347:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46562:3;:12;;:19;;;;46542:3;:12;;:17;46555:3;46542:17;;;;;;;;;;;:39;;;;46603:4;46596:11;;;;;46276:444;46676:5;46640:3;:12;;46664:1;46653:8;:12;;;;:::i;:::-;46640:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:33;;:41;;;;46703:5;46696:12;;;46035:692;;;;;;:::o;36951:422::-;37011:4;37219:12;37330:7;37318:20;37310:28;;37364:1;37357:4;:8;37350:15;;;36951:422;;;:::o;39869:195::-;39972:12;40004:52;40026:6;40034:4;40040:1;40043:12;40004:21;:52::i;:::-;39997:59;;39869:195;;;;;:::o;57987:129::-;58060:4;58107:1;58084:3;:12;;:19;58097:5;58084:19;;;;;;;;;;;;:24;;58077:31;;57987:129;;;;:::o;40921:530::-;41048:12;41106:5;41081:21;:30;;41073:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;41173:18;41184:6;41173:10;:18::i;:::-;41165:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;41299:12;41313:23;41340:6;:11;;41360:5;41368:4;41340:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41298:75;;;;41391:52;41409:7;41418:10;41430:12;41391:17;:52::i;:::-;41384:59;;;;40921:530;;;;;;:::o;43461:742::-;43576:12;43605:7;43601:595;;;43636:10;43629:17;;;;43601:595;43770:1;43750:10;:17;:21;43746:439;;;44013:10;44007:17;44074:15;44061:10;44057:2;44053:19;44046:44;43746:439;44156:12;44149:20;;;;;;;;;;;:::i;:::-;;;;;;;;43461:742;;;;;;:::o;24:722:1:-;120:5;145:81;161:64;218:6;161:64;:::i;:::-;145:81;:::i;:::-;136:90;;246:5;275:6;268:5;261:21;309:4;302:5;298:16;291:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:143;;;404:79;;:::i;:::-;350:143;517:1;502:238;527:6;524:1;521:13;502:238;;;595:3;624:37;657:3;645:10;624:37;:::i;:::-;619:3;612:50;691:4;686:3;682:14;675:21;;725:4;720:3;716:14;709:21;;562:178;549:1;546;542:9;537:14;;502:238;;;506:14;126:620;;24:722;;;;;:::o;752:410::-;829:5;854:65;870:48;911:6;870:48;:::i;:::-;854:65;:::i;:::-;845:74;;942:6;935:5;928:21;980:4;973:5;969:16;1018:3;1009:6;1004:3;1000:16;997:25;994:112;;;1025:79;;:::i;:::-;994:112;1115:41;1149:6;1144:3;1139;1115:41;:::i;:::-;835:327;752:410;;;;;:::o;1168:139::-;1214:5;1252:6;1239:20;1230:29;;1268:33;1295:5;1268:33;:::i;:::-;1168:139;;;;:::o;1330:370::-;1401:5;1450:3;1443:4;1435:6;1431:17;1427:27;1417:122;;1458:79;;:::i;:::-;1417:122;1575:6;1562:20;1600:94;1690:3;1682:6;1675:4;1667:6;1663:17;1600:94;:::i;:::-;1591:103;;1407:293;1330:370;;;;:::o;1706:133::-;1749:5;1787:6;1774:20;1765:29;;1803:30;1827:5;1803:30;:::i;:::-;1706:133;;;;:::o;1845:139::-;1891:5;1929:6;1916:20;1907:29;;1945:33;1972:5;1945:33;:::i;:::-;1845:139;;;;:::o;1990:137::-;2035:5;2073:6;2060:20;2051:29;;2089:32;2115:5;2089:32;:::i;:::-;1990:137;;;;:::o;2133:141::-;2189:5;2220:6;2214:13;2205:22;;2236:32;2262:5;2236:32;:::i;:::-;2133:141;;;;:::o;2293:338::-;2348:5;2397:3;2390:4;2382:6;2378:17;2374:27;2364:122;;2405:79;;:::i;:::-;2364:122;2522:6;2509:20;2547:78;2621:3;2613:6;2606:4;2598:6;2594:17;2547:78;:::i;:::-;2538:87;;2354:277;2293:338;;;;:::o;2637:139::-;2683:5;2721:6;2708:20;2699:29;;2737:33;2764:5;2737:33;:::i;:::-;2637:139;;;;:::o;2782:143::-;2839:5;2870:6;2864:13;2855:22;;2886:33;2913:5;2886:33;:::i;:::-;2782:143;;;;:::o;2931:329::-;2990:6;3039:2;3027:9;3018:7;3014:23;3010:32;3007:119;;;3045:79;;:::i;:::-;3007:119;3165:1;3190:53;3235:7;3226:6;3215:9;3211:22;3190:53;:::i;:::-;3180:63;;3136:117;2931:329;;;;:::o;3266:474::-;3334:6;3342;3391:2;3379:9;3370:7;3366:23;3362:32;3359:119;;;3397:79;;:::i;:::-;3359:119;3517:1;3542:53;3587:7;3578:6;3567:9;3563:22;3542:53;:::i;:::-;3532:63;;3488:117;3644:2;3670:53;3715:7;3706:6;3695:9;3691:22;3670:53;:::i;:::-;3660:63;;3615:118;3266:474;;;;;:::o;3746:619::-;3823:6;3831;3839;3888:2;3876:9;3867:7;3863:23;3859:32;3856:119;;;3894:79;;:::i;:::-;3856:119;4014:1;4039:53;4084:7;4075:6;4064:9;4060:22;4039:53;:::i;:::-;4029:63;;3985:117;4141:2;4167:53;4212:7;4203:6;4192:9;4188:22;4167:53;:::i;:::-;4157:63;;4112:118;4269:2;4295:53;4340:7;4331:6;4320:9;4316:22;4295:53;:::i;:::-;4285:63;;4240:118;3746:619;;;;;:::o;4371:943::-;4466:6;4474;4482;4490;4539:3;4527:9;4518:7;4514:23;4510:33;4507:120;;;4546:79;;:::i;:::-;4507:120;4666:1;4691:53;4736:7;4727:6;4716:9;4712:22;4691:53;:::i;:::-;4681:63;;4637:117;4793:2;4819:53;4864:7;4855:6;4844:9;4840:22;4819:53;:::i;:::-;4809:63;;4764:118;4921:2;4947:53;4992:7;4983:6;4972:9;4968:22;4947:53;:::i;:::-;4937:63;;4892:118;5077:2;5066:9;5062:18;5049:32;5108:18;5100:6;5097:30;5094:117;;;5130:79;;:::i;:::-;5094:117;5235:62;5289:7;5280:6;5269:9;5265:22;5235:62;:::i;:::-;5225:72;;5020:287;4371:943;;;;;;;:::o;5320:468::-;5385:6;5393;5442:2;5430:9;5421:7;5417:23;5413:32;5410:119;;;5448:79;;:::i;:::-;5410:119;5568:1;5593:53;5638:7;5629:6;5618:9;5614:22;5593:53;:::i;:::-;5583:63;;5539:117;5695:2;5721:50;5763:7;5754:6;5743:9;5739:22;5721:50;:::i;:::-;5711:60;;5666:115;5320:468;;;;;:::o;5794:474::-;5862:6;5870;5919:2;5907:9;5898:7;5894:23;5890:32;5887:119;;;5925:79;;:::i;:::-;5887:119;6045:1;6070:53;6115:7;6106:6;6095:9;6091:22;6070:53;:::i;:::-;6060:63;;6016:117;6172:2;6198:53;6243:7;6234:6;6223:9;6219:22;6198:53;:::i;:::-;6188:63;;6143:118;5794:474;;;;;:::o;6274:539::-;6358:6;6407:2;6395:9;6386:7;6382:23;6378:32;6375:119;;;6413:79;;:::i;:::-;6375:119;6561:1;6550:9;6546:17;6533:31;6591:18;6583:6;6580:30;6577:117;;;6613:79;;:::i;:::-;6577:117;6718:78;6788:7;6779:6;6768:9;6764:22;6718:78;:::i;:::-;6708:88;;6504:302;6274:539;;;;:::o;6819:327::-;6877:6;6926:2;6914:9;6905:7;6901:23;6897:32;6894:119;;;6932:79;;:::i;:::-;6894:119;7052:1;7077:52;7121:7;7112:6;7101:9;7097:22;7077:52;:::i;:::-;7067:62;;7023:116;6819:327;;;;:::o;7152:349::-;7221:6;7270:2;7258:9;7249:7;7245:23;7241:32;7238:119;;;7276:79;;:::i;:::-;7238:119;7396:1;7421:63;7476:7;7467:6;7456:9;7452:22;7421:63;:::i;:::-;7411:73;;7367:127;7152:349;;;;:::o;7507:329::-;7566:6;7615:2;7603:9;7594:7;7590:23;7586:32;7583:119;;;7621:79;;:::i;:::-;7583:119;7741:1;7766:53;7811:7;7802:6;7791:9;7787:22;7766:53;:::i;:::-;7756:63;;7712:117;7507:329;;;;:::o;7842:351::-;7912:6;7961:2;7949:9;7940:7;7936:23;7932:32;7929:119;;;7967:79;;:::i;:::-;7929:119;8087:1;8112:64;8168:7;8159:6;8148:9;8144:22;8112:64;:::i;:::-;8102:74;;8058:128;7842:351;;;;:::o;8199:142::-;8302:32;8328:5;8302:32;:::i;:::-;8297:3;8290:45;8199:142;;:::o;8347:118::-;8434:24;8452:5;8434:24;:::i;:::-;8429:3;8422:37;8347:118;;:::o;8471:157::-;8576:45;8596:24;8614:5;8596:24;:::i;:::-;8576:45;:::i;:::-;8571:3;8564:58;8471:157;;:::o;8634:109::-;8715:21;8730:5;8715:21;:::i;:::-;8710:3;8703:34;8634:109;;:::o;8749:157::-;8854:45;8874:24;8892:5;8874:24;:::i;:::-;8854:45;:::i;:::-;8849:3;8842:58;8749:157;;:::o;8912:360::-;8998:3;9026:38;9058:5;9026:38;:::i;:::-;9080:70;9143:6;9138:3;9080:70;:::i;:::-;9073:77;;9159:52;9204:6;9199:3;9192:4;9185:5;9181:16;9159:52;:::i;:::-;9236:29;9258:6;9236:29;:::i;:::-;9231:3;9227:39;9220:46;;9002:270;8912:360;;;;:::o;9278:373::-;9382:3;9410:38;9442:5;9410:38;:::i;:::-;9464:88;9545:6;9540:3;9464:88;:::i;:::-;9457:95;;9561:52;9606:6;9601:3;9594:4;9587:5;9583:16;9561:52;:::i;:::-;9638:6;9633:3;9629:16;9622:23;;9386:265;9278:373;;;;:::o;9657:364::-;9745:3;9773:39;9806:5;9773:39;:::i;:::-;9828:71;9892:6;9887:3;9828:71;:::i;:::-;9821:78;;9908:52;9953:6;9948:3;9941:4;9934:5;9930:16;9908:52;:::i;:::-;9985:29;10007:6;9985:29;:::i;:::-;9980:3;9976:39;9969:46;;9749:272;9657:364;;;;:::o;10027:366::-;10169:3;10190:67;10254:2;10249:3;10190:67;:::i;:::-;10183:74;;10266:93;10355:3;10266:93;:::i;:::-;10384:2;10379:3;10375:12;10368:19;;10027:366;;;:::o;10399:::-;10541:3;10562:67;10626:2;10621:3;10562:67;:::i;:::-;10555:74;;10638:93;10727:3;10638:93;:::i;:::-;10756:2;10751:3;10747:12;10740:19;;10399:366;;;:::o;10771:::-;10913:3;10934:67;10998:2;10993:3;10934:67;:::i;:::-;10927:74;;11010:93;11099:3;11010:93;:::i;:::-;11128:2;11123:3;11119:12;11112:19;;10771:366;;;:::o;11143:::-;11285:3;11306:67;11370:2;11365:3;11306:67;:::i;:::-;11299:74;;11382:93;11471:3;11382:93;:::i;:::-;11500:2;11495:3;11491:12;11484:19;;11143:366;;;:::o;11515:::-;11657:3;11678:67;11742:2;11737:3;11678:67;:::i;:::-;11671:74;;11754:93;11843:3;11754:93;:::i;:::-;11872:2;11867:3;11863:12;11856:19;;11515:366;;;:::o;11887:::-;12029:3;12050:67;12114:2;12109:3;12050:67;:::i;:::-;12043:74;;12126:93;12215:3;12126:93;:::i;:::-;12244:2;12239:3;12235:12;12228:19;;11887:366;;;:::o;12259:::-;12401:3;12422:67;12486:2;12481:3;12422:67;:::i;:::-;12415:74;;12498:93;12587:3;12498:93;:::i;:::-;12616:2;12611:3;12607:12;12600:19;;12259:366;;;:::o;12631:::-;12773:3;12794:67;12858:2;12853:3;12794:67;:::i;:::-;12787:74;;12870:93;12959:3;12870:93;:::i;:::-;12988:2;12983:3;12979:12;12972:19;;12631:366;;;:::o;13003:::-;13145:3;13166:67;13230:2;13225:3;13166:67;:::i;:::-;13159:74;;13242:93;13331:3;13242:93;:::i;:::-;13360:2;13355:3;13351:12;13344:19;;13003:366;;;:::o;13375:::-;13517:3;13538:67;13602:2;13597:3;13538:67;:::i;:::-;13531:74;;13614:93;13703:3;13614:93;:::i;:::-;13732:2;13727:3;13723:12;13716:19;;13375:366;;;:::o;13747:::-;13889:3;13910:67;13974:2;13969:3;13910:67;:::i;:::-;13903:74;;13986:93;14075:3;13986:93;:::i;:::-;14104:2;14099:3;14095:12;14088:19;;13747:366;;;:::o;14119:::-;14261:3;14282:67;14346:2;14341:3;14282:67;:::i;:::-;14275:74;;14358:93;14447:3;14358:93;:::i;:::-;14476:2;14471:3;14467:12;14460:19;;14119:366;;;:::o;14491:::-;14633:3;14654:67;14718:2;14713:3;14654:67;:::i;:::-;14647:74;;14730:93;14819:3;14730:93;:::i;:::-;14848:2;14843:3;14839:12;14832:19;;14491:366;;;:::o;14863:::-;15005:3;15026:67;15090:2;15085:3;15026:67;:::i;:::-;15019:74;;15102:93;15191:3;15102:93;:::i;:::-;15220:2;15215:3;15211:12;15204:19;;14863:366;;;:::o;15235:::-;15377:3;15398:67;15462:2;15457:3;15398:67;:::i;:::-;15391:74;;15474:93;15563:3;15474:93;:::i;:::-;15592:2;15587:3;15583:12;15576:19;;15235:366;;;:::o;15607:::-;15749:3;15770:67;15834:2;15829:3;15770:67;:::i;:::-;15763:74;;15846:93;15935:3;15846:93;:::i;:::-;15964:2;15959:3;15955:12;15948:19;;15607:366;;;:::o;15979:::-;16121:3;16142:67;16206:2;16201:3;16142:67;:::i;:::-;16135:74;;16218:93;16307:3;16218:93;:::i;:::-;16336:2;16331:3;16327:12;16320:19;;15979:366;;;:::o;16351:::-;16493:3;16514:67;16578:2;16573:3;16514:67;:::i;:::-;16507:74;;16590:93;16679:3;16590:93;:::i;:::-;16708:2;16703:3;16699:12;16692:19;;16351:366;;;:::o;16723:::-;16865:3;16886:67;16950:2;16945:3;16886:67;:::i;:::-;16879:74;;16962:93;17051:3;16962:93;:::i;:::-;17080:2;17075:3;17071:12;17064:19;;16723:366;;;:::o;17095:118::-;17182:24;17200:5;17182:24;:::i;:::-;17177:3;17170:37;17095:118;;:::o;17219:256::-;17331:3;17346:75;17417:3;17408:6;17346:75;:::i;:::-;17446:2;17441:3;17437:12;17430:19;;17466:3;17459:10;;17219:256;;;;:::o;17481:397::-;17621:3;17636:75;17707:3;17698:6;17636:75;:::i;:::-;17736:2;17731:3;17727:12;17720:19;;17749:75;17820:3;17811:6;17749:75;:::i;:::-;17849:2;17844:3;17840:12;17833:19;;17869:3;17862:10;;17481:397;;;;;:::o;17884:271::-;18014:3;18036:93;18125:3;18116:6;18036:93;:::i;:::-;18029:100;;18146:3;18139:10;;17884:271;;;;:::o;18161:222::-;18254:4;18292:2;18281:9;18277:18;18269:26;;18305:71;18373:1;18362:9;18358:17;18349:6;18305:71;:::i;:::-;18161:222;;;;:::o;18389:672::-;18600:4;18638:3;18627:9;18623:19;18615:27;;18652:87;18736:1;18725:9;18721:17;18712:6;18652:87;:::i;:::-;18749:72;18817:2;18806:9;18802:18;18793:6;18749:72;:::i;:::-;18831;18899:2;18888:9;18884:18;18875:6;18831:72;:::i;:::-;18950:9;18944:4;18940:20;18935:2;18924:9;18920:18;18913:48;18978:76;19049:4;19040:6;18978:76;:::i;:::-;18970:84;;18389:672;;;;;;;:::o;19067:210::-;19154:4;19192:2;19181:9;19177:18;19169:26;;19205:65;19267:1;19256:9;19252:17;19243:6;19205:65;:::i;:::-;19067:210;;;;:::o;19283:313::-;19396:4;19434:2;19423:9;19419:18;19411:26;;19483:9;19477:4;19473:20;19469:1;19458:9;19454:17;19447:47;19511:78;19584:4;19575:6;19511:78;:::i;:::-;19503:86;;19283:313;;;;:::o;19602:419::-;19768:4;19806:2;19795:9;19791:18;19783:26;;19855:9;19849:4;19845:20;19841:1;19830:9;19826:17;19819:47;19883:131;20009:4;19883:131;:::i;:::-;19875:139;;19602:419;;;:::o;20027:::-;20193:4;20231:2;20220:9;20216:18;20208:26;;20280:9;20274:4;20270:20;20266:1;20255:9;20251:17;20244:47;20308:131;20434:4;20308:131;:::i;:::-;20300:139;;20027:419;;;:::o;20452:::-;20618:4;20656:2;20645:9;20641:18;20633:26;;20705:9;20699:4;20695:20;20691:1;20680:9;20676:17;20669:47;20733:131;20859:4;20733:131;:::i;:::-;20725:139;;20452:419;;;:::o;20877:::-;21043:4;21081:2;21070:9;21066:18;21058:26;;21130:9;21124:4;21120:20;21116:1;21105:9;21101:17;21094:47;21158:131;21284:4;21158:131;:::i;:::-;21150:139;;20877:419;;;:::o;21302:::-;21468:4;21506:2;21495:9;21491:18;21483:26;;21555:9;21549:4;21545:20;21541:1;21530:9;21526:17;21519:47;21583:131;21709:4;21583:131;:::i;:::-;21575:139;;21302:419;;;:::o;21727:::-;21893:4;21931:2;21920:9;21916:18;21908:26;;21980:9;21974:4;21970:20;21966:1;21955:9;21951:17;21944:47;22008:131;22134:4;22008:131;:::i;:::-;22000:139;;21727:419;;;:::o;22152:::-;22318:4;22356:2;22345:9;22341:18;22333:26;;22405:9;22399:4;22395:20;22391:1;22380:9;22376:17;22369:47;22433:131;22559:4;22433:131;:::i;:::-;22425:139;;22152:419;;;:::o;22577:::-;22743:4;22781:2;22770:9;22766:18;22758:26;;22830:9;22824:4;22820:20;22816:1;22805:9;22801:17;22794:47;22858:131;22984:4;22858:131;:::i;:::-;22850:139;;22577:419;;;:::o;23002:::-;23168:4;23206:2;23195:9;23191:18;23183:26;;23255:9;23249:4;23245:20;23241:1;23230:9;23226:17;23219:47;23283:131;23409:4;23283:131;:::i;:::-;23275:139;;23002:419;;;:::o;23427:::-;23593:4;23631:2;23620:9;23616:18;23608:26;;23680:9;23674:4;23670:20;23666:1;23655:9;23651:17;23644:47;23708:131;23834:4;23708:131;:::i;:::-;23700:139;;23427:419;;;:::o;23852:::-;24018:4;24056:2;24045:9;24041:18;24033:26;;24105:9;24099:4;24095:20;24091:1;24080:9;24076:17;24069:47;24133:131;24259:4;24133:131;:::i;:::-;24125:139;;23852:419;;;:::o;24277:::-;24443:4;24481:2;24470:9;24466:18;24458:26;;24530:9;24524:4;24520:20;24516:1;24505:9;24501:17;24494:47;24558:131;24684:4;24558:131;:::i;:::-;24550:139;;24277:419;;;:::o;24702:::-;24868:4;24906:2;24895:9;24891:18;24883:26;;24955:9;24949:4;24945:20;24941:1;24930:9;24926:17;24919:47;24983:131;25109:4;24983:131;:::i;:::-;24975:139;;24702:419;;;:::o;25127:::-;25293:4;25331:2;25320:9;25316:18;25308:26;;25380:9;25374:4;25370:20;25366:1;25355:9;25351:17;25344:47;25408:131;25534:4;25408:131;:::i;:::-;25400:139;;25127:419;;;:::o;25552:::-;25718:4;25756:2;25745:9;25741:18;25733:26;;25805:9;25799:4;25795:20;25791:1;25780:9;25776:17;25769:47;25833:131;25959:4;25833:131;:::i;:::-;25825:139;;25552:419;;;:::o;25977:::-;26143:4;26181:2;26170:9;26166:18;26158:26;;26230:9;26224:4;26220:20;26216:1;26205:9;26201:17;26194:47;26258:131;26384:4;26258:131;:::i;:::-;26250:139;;25977:419;;;:::o;26402:::-;26568:4;26606:2;26595:9;26591:18;26583:26;;26655:9;26649:4;26645:20;26641:1;26630:9;26626:17;26619:47;26683:131;26809:4;26683:131;:::i;:::-;26675:139;;26402:419;;;:::o;26827:::-;26993:4;27031:2;27020:9;27016:18;27008:26;;27080:9;27074:4;27070:20;27066:1;27055:9;27051:17;27044:47;27108:131;27234:4;27108:131;:::i;:::-;27100:139;;26827:419;;;:::o;27252:::-;27418:4;27456:2;27445:9;27441:18;27433:26;;27505:9;27499:4;27495:20;27491:1;27480:9;27476:17;27469:47;27533:131;27659:4;27533:131;:::i;:::-;27525:139;;27252:419;;;:::o;27677:222::-;27770:4;27808:2;27797:9;27793:18;27785:26;;27821:71;27889:1;27878:9;27874:17;27865:6;27821:71;:::i;:::-;27677:222;;;;:::o;27905:129::-;27939:6;27966:20;;:::i;:::-;27956:30;;27995:33;28023:4;28015:6;27995:33;:::i;:::-;27905:129;;;:::o;28040:75::-;28073:6;28106:2;28100:9;28090:19;;28040:75;:::o;28121:311::-;28198:4;28288:18;28280:6;28277:30;28274:56;;;28310:18;;:::i;:::-;28274:56;28360:4;28352:6;28348:17;28340:25;;28420:4;28414;28410:15;28402:23;;28121:311;;;:::o;28438:307::-;28499:4;28589:18;28581:6;28578:30;28575:56;;;28611:18;;:::i;:::-;28575:56;28649:29;28671:6;28649:29;:::i;:::-;28641:37;;28733:4;28727;28723:15;28715:23;;28438:307;;;:::o;28751:98::-;28802:6;28836:5;28830:12;28820:22;;28751:98;;;:::o;28855:99::-;28907:6;28941:5;28935:12;28925:22;;28855:99;;;:::o;28960:168::-;29043:11;29077:6;29072:3;29065:19;29117:4;29112:3;29108:14;29093:29;;28960:168;;;;:::o;29134:147::-;29235:11;29272:3;29257:18;;29134:147;;;;:::o;29287:169::-;29371:11;29405:6;29400:3;29393:19;29445:4;29440:3;29436:14;29421:29;;29287:169;;;;:::o;29462:305::-;29502:3;29521:20;29539:1;29521:20;:::i;:::-;29516:25;;29555:20;29573:1;29555:20;:::i;:::-;29550:25;;29709:1;29641:66;29637:74;29634:1;29631:81;29628:107;;;29715:18;;:::i;:::-;29628:107;29759:1;29756;29752:9;29745:16;;29462:305;;;;:::o;29773:191::-;29813:4;29833:20;29851:1;29833:20;:::i;:::-;29828:25;;29867:20;29885:1;29867:20;:::i;:::-;29862:25;;29906:1;29903;29900:8;29897:34;;;29911:18;;:::i;:::-;29897:34;29956:1;29953;29949:9;29941:17;;29773:191;;;;:::o;29970:96::-;30007:7;30036:24;30054:5;30036:24;:::i;:::-;30025:35;;29970:96;;;:::o;30072:104::-;30117:7;30146:24;30164:5;30146:24;:::i;:::-;30135:35;;30072:104;;;:::o;30182:90::-;30216:7;30259:5;30252:13;30245:21;30234:32;;30182:90;;;:::o;30278:77::-;30315:7;30344:5;30333:16;;30278:77;;;:::o;30361:149::-;30397:7;30437:66;30430:5;30426:78;30415:89;;30361:149;;;:::o;30516:126::-;30553:7;30593:42;30586:5;30582:54;30571:65;;30516:126;;;:::o;30648:77::-;30685:7;30714:5;30703:16;;30648:77;;;:::o;30731:154::-;30815:6;30810:3;30805;30792:30;30877:1;30868:6;30863:3;30859:16;30852:27;30731:154;;;:::o;30891:307::-;30959:1;30969:113;30983:6;30980:1;30977:13;30969:113;;;31068:1;31063:3;31059:11;31053:18;31049:1;31044:3;31040:11;31033:39;31005:2;31002:1;30998:10;30993:15;;30969:113;;;31100:6;31097:1;31094:13;31091:101;;;31180:1;31171:6;31166:3;31162:16;31155:27;31091:101;30940:258;30891:307;;;:::o;31204:320::-;31248:6;31285:1;31279:4;31275:12;31265:22;;31332:1;31326:4;31322:12;31353:18;31343:81;;31409:4;31401:6;31397:17;31387:27;;31343:81;31471:2;31463:6;31460:14;31440:18;31437:38;31434:84;;;31490:18;;:::i;:::-;31434:84;31255:269;31204:320;;;:::o;31530:281::-;31613:27;31635:4;31613:27;:::i;:::-;31605:6;31601:40;31743:6;31731:10;31728:22;31707:18;31695:10;31692:34;31689:62;31686:88;;;31754:18;;:::i;:::-;31686:88;31794:10;31790:2;31783:22;31573:238;31530:281;;:::o;31817:233::-;31856:3;31879:24;31897:5;31879:24;:::i;:::-;31870:33;;31925:66;31918:5;31915:77;31912:103;;;31995:18;;:::i;:::-;31912:103;32042:1;32035:5;32031:13;32024:20;;31817:233;;;:::o;32056:100::-;32095:7;32124:26;32144:5;32124:26;:::i;:::-;32113:37;;32056:100;;;:::o;32162:79::-;32201:7;32230:5;32219:16;;32162:79;;;:::o;32247:94::-;32286:7;32315:20;32329:5;32315:20;:::i;:::-;32304:31;;32247:94;;;:::o;32347:180::-;32395:77;32392:1;32385:88;32492:4;32489:1;32482:15;32516:4;32513:1;32506:15;32533:180;32581:77;32578:1;32571:88;32678:4;32675:1;32668:15;32702:4;32699:1;32692:15;32719:180;32767:77;32764:1;32757:88;32864:4;32861:1;32854:15;32888:4;32885:1;32878:15;32905:180;32953:77;32950:1;32943:88;33050:4;33047:1;33040:15;33074:4;33071:1;33064:15;33091:180;33139:77;33136:1;33129:88;33236:4;33233:1;33226:15;33260:4;33257:1;33250:15;33277:117;33386:1;33383;33376:12;33400:117;33509:1;33506;33499:12;33523:117;33632:1;33629;33622:12;33646:117;33755:1;33752;33745:12;33769:117;33878:1;33875;33868:12;33892:102;33933:6;33984:2;33980:7;33975:2;33968:5;33964:14;33960:28;33950:38;;33892:102;;;:::o;34000:94::-;34033:8;34081:5;34077:2;34073:14;34052:35;;34000:94;;;:::o;34100:221::-;34240:34;34236:1;34228:6;34224:14;34217:58;34309:4;34304:2;34296:6;34292:15;34285:29;34100:221;:::o;34327:237::-;34467:34;34463:1;34455:6;34451:14;34444:58;34536:20;34531:2;34523:6;34519:15;34512:45;34327:237;:::o;34570:178::-;34710:30;34706:1;34698:6;34694:14;34687:54;34570:178;:::o;34754:165::-;34894:17;34890:1;34882:6;34878:14;34871:41;34754:165;:::o;34925:163::-;35065:15;35061:1;35053:6;35049:14;35042:39;34925:163;:::o;35094:223::-;35234:34;35230:1;35222:6;35218:14;35211:58;35303:6;35298:2;35290:6;35286:15;35279:31;35094:223;:::o;35323:175::-;35463:27;35459:1;35451:6;35447:14;35440:51;35323:175;:::o;35504:225::-;35644:34;35640:1;35632:6;35628:14;35621:58;35713:8;35708:2;35700:6;35696:15;35689:33;35504:225;:::o;35735:231::-;35875:34;35871:1;35863:6;35859:14;35852:58;35944:14;35939:2;35931:6;35927:15;35920:39;35735:231;:::o;35972:243::-;36112:34;36108:1;36100:6;36096:14;36089:58;36181:26;36176:2;36168:6;36164:15;36157:51;35972:243;:::o;36221:229::-;36361:34;36357:1;36349:6;36345:14;36338:58;36430:12;36425:2;36417:6;36413:15;36406:37;36221:229;:::o;36456:221::-;36596:34;36592:1;36584:6;36580:14;36573:58;36665:4;36660:2;36652:6;36648:15;36641:29;36456:221;:::o;36683:182::-;36823:34;36819:1;36811:6;36807:14;36800:58;36683:182;:::o;36871:231::-;37011:34;37007:1;36999:6;36995:14;36988:58;37080:14;37075:2;37067:6;37063:15;37056:39;36871:231;:::o;37108:228::-;37248:34;37244:1;37236:6;37232:14;37225:58;37317:11;37312:2;37304:6;37300:15;37293:36;37108:228;:::o;37342:234::-;37482:34;37478:1;37470:6;37466:14;37459:58;37551:17;37546:2;37538:6;37534:15;37527:42;37342:234;:::o;37582:220::-;37722:34;37718:1;37710:6;37706:14;37699:58;37791:3;37786:2;37778:6;37774:15;37767:28;37582:220;:::o;37808:236::-;37948:34;37944:1;37936:6;37932:14;37925:58;38017:19;38012:2;38004:6;38000:15;37993:44;37808:236;:::o;38050:179::-;38190:31;38186:1;38178:6;38174:14;38167:55;38050:179;:::o;38235:122::-;38308:24;38326:5;38308:24;:::i;:::-;38301:5;38298:35;38288:63;;38347:1;38344;38337:12;38288:63;38235:122;:::o;38363:116::-;38433:21;38448:5;38433:21;:::i;:::-;38426:5;38423:32;38413:60;;38469:1;38466;38459:12;38413:60;38363:116;:::o;38485:122::-;38558:24;38576:5;38558:24;:::i;:::-;38551:5;38548:35;38538:63;;38597:1;38594;38587:12;38538:63;38485:122;:::o;38613:120::-;38685:23;38702:5;38685:23;:::i;:::-;38678:5;38675:34;38665:62;;38723:1;38720;38713:12;38665:62;38613:120;:::o;38739:122::-;38812:24;38830:5;38812:24;:::i;:::-;38805:5;38802:35;38792:63;;38851:1;38848;38841:12;38792:63;38739:122;:::o

Swarm Source

ipfs://c4dc3fcbca51cdb0e5965158b18b867836ff82206b47362d82607af67e40c2dc

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

Tools & Services