Token

DimToken (DIM)

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

ERC-20

Overview

Max Total Supply

26,184.2427901256 DIM

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xef19fe9cbabe8410d903a4cd3173ae28b61bc7e7

Filtered by Token Holder

0x5792CDA9c9AE5d647a3E377A0CD448dd3FbFD04D

Balance

1,576.93600446 DIM

Value

$0.00

0x5792CDA9c9AE5d647a3E377A0CD448dd3FbFD04D

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DimToken

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-03-01
*/

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


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

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

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

            if (lastIndex != toDeleteIndex) {
                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] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // 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) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // 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 Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
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) {
        unchecked {
            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) {
        unchecked {
            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) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

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

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

    /**
     * @dev Returns the 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) {
        return a + b;
    }

    /**
     * @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) {
        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) {
        return a * b;
    }

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

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


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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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


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

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

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

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

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

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

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

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


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

pragma solidity ^0.8.0;



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

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

// File: test.sol


pragma solidity ^0.8.0;









contract DimToken is ERC20Burnable, Ownable, IERC721Receiver, ReentrancyGuard {
    using EnumerableSet for EnumerableSet.UintSet; 
    
    //addresses 
    address nullAddress = 0x0000000000000000000000000000000000000000;
    address public dimAddress = 0x1a4C4B22fA54b65A0BCE5F4eA4a33378c007726E;

    //uint256's 
    uint256 public expiration; 
    uint256 public rate = 348837200000000; 
  
    // mappings 
    mapping(address => EnumerableSet.UintSet) private _deposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;

    constructor() ERC20("DimToken", "DIM") 
    {
        expiration = block.number + 1000000000000;
    }

  /* Tokens */

    uint256 public teamMintValue;
    mapping(address => bool) private whitelist;

    function setWhitelist(address[] calldata minters) external onlyOwner {
        for (uint256 i; i < minters.length; i++) {
            whitelist[minters[i]] = true;
        }

        whitelist[address(this)] = true;
    }

    function mint(address account, uint256 amount) external {
        require(whitelist[msg.sender], 'NOT WHITELISTED');
        _mint(account, amount);
    }

    function teamMint(address account, uint256 amount) external onlyOwner {
        require((totalSupply() + amount) / (teamMintValue + amount) >= 10,'TOO MUCH STACK');
        _mint(account, amount);
        teamMintValue += amount;
    }



    //alter rate and expiration 
    function setRateExpiration(uint256 _rate, uint256 _expiration) public onlyOwner() {
      rate = _rate; 
      expiration = _expiration;
    }

    //check deposit amount. 
    function depositsOf(address account)
      external 
      view 
      returns (uint256[] memory)
    {
      EnumerableSet.UintSet storage depositSet = _deposits[account];
      uint256[] memory tokenIds = new uint256[] (depositSet.length());

      for (uint256 i; i<depositSet.length(); i++) {
        tokenIds[i] = depositSet.at(i);
      }

      return tokenIds;
    }

    //reward amount by address/tokenIds[]
    function calculateRewards(address account, uint256[] memory tokenIds) 
      public 
      view 
      returns (uint256[] memory rewards) 
    {
      rewards = new uint256[](tokenIds.length);

      for (uint256 i; i < tokenIds.length; i++) {
        uint256 tokenId = tokenIds[i];

        rewards[i] = 
          rate * 
          (_deposits[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _depositBlocks[account][tokenId]);
      }

      return rewards;
    }

    //reward claim function 
    function claimRewards(uint256[] calldata tokenIds) public {
      uint256 reward; 
      uint256 thisblock = Math.min(block.number, expiration);

      uint256[] memory rewards = calculateRewards(msg.sender, tokenIds);

      for (uint256 i; i < tokenIds.length; i++) {
        if (_depositBlocks[msg.sender][tokenIds[i]] == thisblock) { continue; }
          
        reward += rewards[i];
        _depositBlocks[msg.sender][tokenIds[i]] = thisblock;
      }

      if (reward > 0) {
        _mint(msg.sender, reward);
      }
    }

    //deposit function. 
    function deposit(uint256[] calldata tokenIds) external {
        claimRewards(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(dimAddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIds[i],
                ''
            );

            _deposits[msg.sender].add(tokenIds[i]);
        }
    }

    //withdrawal function.
    function withdraw(uint256[] calldata tokenIds) external nonReentrant() {
        claimRewards(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _deposits[msg.sender].contains(tokenIds[i]),
                'Staking: token not deposited'
            );

            _deposits[msg.sender].remove(tokenIds[i]);

            IERC721(dimAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                ''
            );
        }
    }


    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"_depositBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"calculateRewards","outputs":[{"internalType":"uint256[]","name":"rewards","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"depositsOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dimAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setRateExpiration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"minters","type":"address[]"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"teamMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"teamMintValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

52758:4479:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54855:534;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40733:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43084:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57015:219;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41853:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43865:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53121:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41695:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44569:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53784:157;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52111:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53088:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56010:395;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55427:549;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54234:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42024:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34156:103;;;:::i;:::-;;52521:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53463:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33505:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40952:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56441:564;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45312:438;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42357:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53949:239;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53254:69;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42613:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54417:387;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34414:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53549:227;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52991:70;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54855:534;54970:24;55035:8;:15;55021:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55011:40;;55067:9;55062:295;55082:8;:15;55078:1;:19;55062:295;;;55115:15;55133:8;55142:1;55133:11;;;;;;;;:::i;:::-;;;;;;;;55115:29;;55314:14;:23;55329:7;55314:23;;;;;;;;;;;;;;;:32;55338:7;55314:32;;;;;;;;;;;;55263:34;55272:12;55286:10;;55263:8;:34::i;:::-;:83;;;;:::i;:::-;55202:36;55230:7;55202:9;:18;55212:7;55202:18;;;;;;;;;;;;;;;:27;;:36;;;;:::i;:::-;:44;;55245:1;55202:44;;;55241:1;55202:44;55182:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;55157:7;55165:1;55157:10;;;;;;;;:::i;:::-;;;;;;;:190;;;;;55104:253;55099:3;;;;;:::i;:::-;;;;55062:295;;;;54855:534;;;;:::o;40733:100::-;40787:13;40820:5;40813:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40733:100;:::o;43084:201::-;43167:4;43184:13;43200:12;:10;:12::i;:::-;43184:28;;43223:32;43232:5;43239:7;43248:6;43223:8;:32::i;:::-;43273:4;43266:11;;;43084:201;;;;:::o;57015:219::-;57159:6;57185:41;;;57178:48;;57015:219;;;;;;;:::o;41853:108::-;41914:7;41941:12;;41934:19;;41853:108;:::o;43865:295::-;43996:4;44013:15;44031:12;:10;:12::i;:::-;44013:30;;44054:38;44070:4;44076:7;44085:6;44054:15;:38::i;:::-;44103:27;44113:4;44119:2;44123:6;44103:9;:27::i;:::-;44148:4;44141:11;;;43865:295;;;;;:::o;53121:37::-;;;;:::o;41695:93::-;41753:5;41778:2;41771:9;;41695:93;:::o;44569:240::-;44657:4;44674:13;44690:12;:10;:12::i;:::-;44674:28;;44713:66;44722:5;44729:7;44768:10;44738:11;:18;44750:5;44738:18;;;;;;;;;;;;;;;:27;44757:7;44738:27;;;;;;;;;;;;;;;;:40;;;;:::i;:::-;44713:8;:66::i;:::-;44797:4;44790:11;;;44569:240;;;;:::o;53784:157::-;53859:9;:21;53869:10;53859:21;;;;;;;;;;;;;;;;;;;;;;;;;53851:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;53911:22;53917:7;53926:6;53911:5;:22::i;:::-;53784:157;;:::o;52111:91::-;52167:27;52173:12;:10;:12::i;:::-;52187:6;52167:5;:27::i;:::-;52111:91;:::o;53088:25::-;;;;:::o;56010:395::-;56076:22;56089:8;;56076:12;:22::i;:::-;56116:9;56111:287;56131:8;;:15;;56127:1;:19;56111:287;;;56176:10;;;;;;;;;;;56168:36;;;56223:10;56260:4;56284:8;;56293:1;56284:11;;;;;;;:::i;:::-;;;;;;;;56168:163;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56348:38;56374:8;;56383:1;56374:11;;;;;;;:::i;:::-;;;;;;;;56348:9;:21;56358:10;56348:21;;;;;;;;;;;;;;;:25;;:38;;;;:::i;:::-;;56148:3;;;;;:::i;:::-;;;;56111:287;;;;56010:395;;:::o;55427:549::-;55494:14;55518:17;55538:34;55547:12;55561:10;;55538:8;:34::i;:::-;55518:54;;55583:24;55610:38;55627:10;55639:8;;55610:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:16;:38::i;:::-;55583:65;;55664:9;55659:238;55679:8;;:15;;55675:1;:19;55659:238;;;55759:9;55716:14;:26;55731:10;55716:26;;;;;;;;;;;;;;;:39;55743:8;;55752:1;55743:11;;;;;;;:::i;:::-;;;;;;;;55716:39;;;;;;;;;;;;:52;55712:71;;;55772:8;;55712:71;55815:7;55823:1;55815:10;;;;;;;;:::i;:::-;;;;;;;;55805:20;;;;;:::i;:::-;;;55878:9;55836:14;:26;55851:10;55836:26;;;;;;;;;;;;;;;:39;55863:8;;55872:1;55863:11;;;;;;;:::i;:::-;;;;;;;;55836:39;;;;;;;;;;;:51;;;;55659:238;55696:3;;;;;:::i;:::-;;;;55659:238;;;;55920:1;55911:6;:10;55907:62;;;55934:25;55940:10;55952:6;55934:5;:25::i;:::-;55907:62;55485:491;;;55427:549;;:::o;54234:145::-;33736:12;:10;:12::i;:::-;33725:23;;:7;:5;:7::i;:::-;:23;;;33717:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54332:5:::1;54325:4;:12;;;;54360:11;54347:10;:24;;;;54234:145:::0;;:::o;42024:127::-;42098:7;42125:9;:18;42135:7;42125:18;;;;;;;;;;;;;;;;42118:25;;42024:127;;;:::o;34156:103::-;33736:12;:10;:12::i;:::-;33725:23;;:7;:5;:7::i;:::-;:23;;;33717:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;34221:30:::1;34248:1;34221:18;:30::i;:::-;34156:103::o:0;52521:164::-;52598:46;52614:7;52623:12;:10;:12::i;:::-;52637:6;52598:15;:46::i;:::-;52655:22;52661:7;52670:6;52655:5;:22::i;:::-;52521:164;;:::o;53463:28::-;;;;:::o;33505:87::-;33551:7;33578:6;;;;;;;;;;;33571:13;;33505:87;:::o;40952:104::-;41008:13;41041:7;41034:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40952:104;:::o;56441:564::-;3109:1;3707:7;;:19;;3699:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;3109:1;3840:7;:18;;;;56523:22:::1;56536:8;;56523:12;:22::i;:::-;56563:9;56558:440;56578:8;;:15;;56574:1;:19;56558:440;;;56641:43;56672:8;;56681:1;56672:11;;;;;;;:::i;:::-;;;;;;;;56641:9;:21;56651:10;56641:21;;;;;;;;;;;;;;;:30;;:43;;;;:::i;:::-;56615:133;;;;;;;;;;;;:::i;:::-;;;;;;;;;56765:41;56794:8;;56803:1;56794:11;;;;;;;:::i;:::-;;;;;;;;56765:9;:21;56775:10;56765:21;;;;;;;;;;;;;;;:28;;:41;;;;:::i;:::-;;56831:10;;;;;;;;;;;56823:36;;;56886:4;56910:10;56939:8;;56948:1;56939:11;;;;;;;:::i;:::-;;;;;;;;56823:163;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;56595:3;;;;;:::i;:::-;;;;56558:440;;;;3065:1:::0;4019:7;:22;;;;56441:564;;:::o;45312:438::-;45405:4;45422:13;45438:12;:10;:12::i;:::-;45422:28;;45461:24;45488:11;:18;45500:5;45488:18;;;;;;;;;;;;;;;:27;45507:7;45488:27;;;;;;;;;;;;;;;;45461:54;;45554:15;45534:16;:35;;45526:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;45647:60;45656:5;45663:7;45691:15;45672:16;:34;45647:8;:60::i;:::-;45738:4;45731:11;;;;45312:438;;;;:::o;42357:193::-;42436:4;42453:13;42469:12;:10;:12::i;:::-;42453:28;;42492;42502:5;42509:2;42513:6;42492:9;:28::i;:::-;42538:4;42531:11;;;42357:193;;;;:::o;53949:239::-;33736:12;:10;:12::i;:::-;33725:23;;:7;:5;:7::i;:::-;:23;;;33717:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54093:2:::1;54082:6;54066:13;;:22;;;;:::i;:::-;54055:6;54039:13;:11;:13::i;:::-;:22;;;;:::i;:::-;54038:51;;;;:::i;:::-;:57;;54030:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;54124:22;54130:7;54139:6;54124:5;:22::i;:::-;54174:6;54157:13;;:23;;;;;;;:::i;:::-;;;;;;;;53949:239:::0;;:::o;53254:69::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;42613:151::-;42702:7;42729:11;:18;42741:5;42729:18;;;;;;;;;;;;;;;:27;42748:7;42729:27;;;;;;;;;;;;;;;;42722:34;;42613:151;;;;:::o;54417:387::-;54500:16;54532:40;54575:9;:18;54585:7;54575:18;;;;;;;;;;;;;;;54532:61;;54602:25;54645:19;:10;:17;:19::i;:::-;54630:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54602:63;;54681:9;54676:95;54694:19;:10;:17;:19::i;:::-;54692:1;:21;54676:95;;;54745:16;54759:1;54745:10;:13;;:16;;;;:::i;:::-;54731:8;54740:1;54731:11;;;;;;;;:::i;:::-;;;;;;;:30;;;;;54715:3;;;;;:::i;:::-;;;;54676:95;;;;54788:8;54781:15;;;;54417:387;;;:::o;34414:201::-;33736:12;:10;:12::i;:::-;33725:23;;:7;:5;:7::i;:::-;:23;;;33717:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;34523:1:::1;34503:22;;:8;:22;;;;34495:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;34579:28;34598:8;34579:18;:28::i;:::-;34414:201:::0;:::o;53549:227::-;33736:12;:10;:12::i;:::-;33725:23;;:7;:5;:7::i;:::-;:23;;;33717:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;53634:9:::1;53629:96;53649:7;;:14;;53645:1;:18;53629:96;;;53709:4;53685:9;:21;53695:7;;53703:1;53695:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;53685:21;;;;;;;;;;;;;;;;:28;;;;;;;;;;;;;;;;;;53665:3;;;;;:::i;:::-;;;;53629:96;;;;53764:4;53737:9;:24;53755:4;53737:24;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;53549:227:::0;;:::o;52991:70::-;;;;;;;;;;;;;:::o;505:106::-;563:7;594:1;590;:5;:13;;602:1;590:13;;;598:1;590:13;583:20;;505:106;;;;:::o;14976:146::-;15053:4;15077:37;15087:3;:10;;15107:5;15099:14;;15077:9;:37::i;:::-;15070:44;;14976:146;;;;:::o;32229:98::-;32282:7;32309:10;32302:17;;32229:98;:::o;48948:380::-;49101:1;49084:19;;:5;:19;;;;49076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49182:1;49163:21;;:7;:21;;;;49155:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49266:6;49236:11;:18;49248:5;49236:18;;;;;;;;;;;;;;;:27;49255:7;49236:27;;;;;;;;;;;;;;;:36;;;;49304:7;49288:32;;49297:5;49288:32;;;49313:6;49288:32;;;;;;:::i;:::-;;;;;;;;48948:380;;;:::o;49615:453::-;49750:24;49777:25;49787:5;49794:7;49777:9;:25::i;:::-;49750:52;;49837:17;49817:16;:37;49813:248;;49899:6;49879:16;:26;;49871:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49983:51;49992:5;49999:7;50027:6;50008:16;:25;49983:8;:51::i;:::-;49813:248;49739:329;49615:453;;;:::o;46229:671::-;46376:1;46360:18;;:4;:18;;;;46352:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;46453:1;46439:16;;:2;:16;;;;46431:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;46508:38;46529:4;46535:2;46539:6;46508:20;:38::i;:::-;46559:19;46581:9;:15;46591:4;46581:15;;;;;;;;;;;;;;;;46559:37;;46630:6;46615:11;:21;;46607:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;46747:6;46733:11;:20;46715:9;:15;46725:4;46715:15;;;;;;;;;;;;;;;:38;;;;46792:6;46775:9;:13;46785:2;46775:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;46831:2;46816:26;;46825:4;46816:26;;;46835:6;46816:26;;;;;;:::i;:::-;;;;;;;;46855:37;46875:4;46881:2;46885:6;46855:19;:37::i;:::-;46341:559;46229:671;;;:::o;47187:399::-;47290:1;47271:21;;:7;:21;;;;47263:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;47341:49;47370:1;47374:7;47383:6;47341:20;:49::i;:::-;47419:6;47403:12;;:22;;;;;;;:::i;:::-;;;;;;;;47458:6;47436:9;:18;47446:7;47436:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;47501:7;47480:37;;47497:1;47480:37;;;47510:6;47480:37;;;;;;:::i;:::-;;;;;;;;47530:48;47558:1;47562:7;47571:6;47530:19;:48::i;:::-;47187:399;;:::o;47919:591::-;48022:1;48003:21;;:7;:21;;;;47995:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;48075:49;48096:7;48113:1;48117:6;48075:20;:49::i;:::-;48137:22;48162:9;:18;48172:7;48162:18;;;;;;;;;;;;;;;;48137:43;;48217:6;48199:14;:24;;48191:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;48336:6;48319:14;:23;48298:9;:18;48308:7;48298:18;;;;;;;;;;;;;;;:44;;;;48380:6;48364:12;;:22;;;;;;;:::i;:::-;;;;;;;;48430:1;48404:37;;48413:7;48404:37;;;48434:6;48404:37;;;;;;:::i;:::-;;;;;;;;48454:48;48474:7;48491:1;48495:6;48454:19;:48::i;:::-;47984:526;47919:591;;:::o;14446:131::-;14513:4;14537:32;14542:3;:10;;14562:5;14554:14;;14537:4;:32::i;:::-;14530:39;;14446:131;;;;:::o;34775:191::-;34849:16;34868:6;;;;;;;;;;;34849:25;;34894:8;34885:6;;:17;;;;;;;;;;;;;;;;;;34949:8;34918:40;;34939:8;34918:40;;;;;;;;;;;;34838:128;34775:191;:::o;14753:137::-;14823:4;14847:35;14855:3;:10;;14875:5;14867:14;;14847:7;:35::i;:::-;14840:42;;14753:137;;;;:::o;15208:114::-;15268:7;15295:19;15303:3;:10;;15295:7;:19::i;:::-;15288:26;;15208:114;;;:::o;15676:137::-;15747:7;15782:22;15786:3;:10;;15798:5;15782:3;:22::i;:::-;15774:31;;15767:38;;15676:137;;;;:::o;7939:129::-;8012:4;8059:1;8036:3;:12;;:19;8049:5;8036:19;;;;;;;;;;;;:24;;8029:31;;7939:129;;;;:::o;50668:125::-;;;;:::o;51397:124::-;;;;:::o;5843:414::-;5906:4;5928:21;5938:3;5943:5;5928:9;:21::i;:::-;5923:327;;5966:3;:11;;5983:5;5966:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6149:3;:11;;:18;;;;6127:3;:12;;:19;6140:5;6127:19;;;;;;;;;;;:40;;;;6189:4;6182:11;;;;5923:327;6233:5;6226:12;;5843:414;;;;;:::o;6433:1420::-;6499:4;6617:18;6638:3;:12;;:19;6651:5;6638:19;;;;;;;;;;;;6617:40;;6688:1;6674:10;:15;6670:1176;;7049:21;7086:1;7073:10;:14;;;;:::i;:::-;7049:38;;7102:17;7143:1;7122:3;:11;;:18;;;;:22;;;;:::i;:::-;7102:42;;7178:13;7165:9;:26;7161:405;;7212:17;7232:3;:11;;7244:9;7232:22;;;;;;;;:::i;:::-;;;;;;;;;;7212:42;;7386:9;7357:3;:11;;7369:13;7357:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;7497:10;7471:3;:12;;:23;7484:9;7471:23;;;;;;;;;;;:36;;;;7193:373;7161:405;7647:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;7742:3;:12;;:19;7755:5;7742:19;;;;;;;;;;;7735:26;;;7785:4;7778:11;;;;;;;6670:1176;7829:5;7822:12;;;6433:1420;;;;;:::o;8154:109::-;8210:7;8237:3;:11;;:18;;;;8230:25;;8154:109;;;:::o;8617:120::-;8684:7;8711:3;:11;;8723:5;8711:18;;;;;;;;:::i;:::-;;;;;;;;;;8704:25;;8617:120;;;;:::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:139::-;798:5;836:6;823:20;814:29;;852:33;879:5;852:33;:::i;:::-;752:139;;;;:::o;914:568::-;987:8;997:6;1047:3;1040:4;1032:6;1028:17;1024:27;1014:122;;1055:79;;:::i;:::-;1014:122;1168:6;1155:20;1145:30;;1198:18;1190:6;1187:30;1184:117;;;1220:79;;:::i;:::-;1184:117;1334:4;1326:6;1322:17;1310:29;;1388:3;1380:4;1372:6;1368:17;1358:8;1354:32;1351:41;1348:128;;;1395:79;;:::i;:::-;1348:128;914:568;;;;;:::o;1505:::-;1578:8;1588:6;1638:3;1631:4;1623:6;1619:17;1615:27;1605:122;;1646:79;;:::i;:::-;1605:122;1759:6;1746:20;1736:30;;1789:18;1781:6;1778:30;1775:117;;;1811:79;;:::i;:::-;1775:117;1925:4;1917:6;1913:17;1901:29;;1979:3;1971:4;1963:6;1959:17;1949:8;1945:32;1942:41;1939:128;;;1986:79;;:::i;:::-;1939:128;1505:568;;;;;:::o;2096:370::-;2167:5;2216:3;2209:4;2201:6;2197:17;2193:27;2183:122;;2224:79;;:::i;:::-;2183:122;2341:6;2328:20;2366:94;2456:3;2448:6;2441:4;2433:6;2429:17;2366:94;:::i;:::-;2357:103;;2173:293;2096:370;;;;:::o;2485:552::-;2542:8;2552:6;2602:3;2595:4;2587:6;2583:17;2579:27;2569:122;;2610:79;;:::i;:::-;2569:122;2723:6;2710:20;2700:30;;2753:18;2745:6;2742:30;2739:117;;;2775:79;;:::i;:::-;2739:117;2889:4;2881:6;2877:17;2865:29;;2943:3;2935:4;2927:6;2923:17;2913:8;2909:32;2906:41;2903:128;;;2950:79;;:::i;:::-;2903:128;2485:552;;;;;:::o;3043:139::-;3089:5;3127:6;3114:20;3105:29;;3143:33;3170:5;3143:33;:::i;:::-;3043:139;;;;:::o;3188:329::-;3247:6;3296:2;3284:9;3275:7;3271:23;3267:32;3264:119;;;3302:79;;:::i;:::-;3264:119;3422:1;3447:53;3492:7;3483:6;3472:9;3468:22;3447:53;:::i;:::-;3437:63;;3393:117;3188:329;;;;:::o;3523:474::-;3591:6;3599;3648:2;3636:9;3627:7;3623:23;3619:32;3616:119;;;3654:79;;:::i;:::-;3616:119;3774:1;3799:53;3844:7;3835:6;3824:9;3820:22;3799:53;:::i;:::-;3789:63;;3745:117;3901:2;3927:53;3972:7;3963:6;3952:9;3948:22;3927:53;:::i;:::-;3917:63;;3872:118;3523:474;;;;;:::o;4003:619::-;4080:6;4088;4096;4145:2;4133:9;4124:7;4120:23;4116:32;4113:119;;;4151:79;;:::i;:::-;4113:119;4271:1;4296:53;4341:7;4332:6;4321:9;4317:22;4296:53;:::i;:::-;4286:63;;4242:117;4398:2;4424:53;4469:7;4460:6;4449:9;4445:22;4424:53;:::i;:::-;4414:63;;4369:118;4526:2;4552:53;4597:7;4588:6;4577:9;4573:22;4552:53;:::i;:::-;4542:63;;4497:118;4003:619;;;;;:::o;4628:963::-;4725:6;4733;4741;4749;4757;4806:3;4794:9;4785:7;4781:23;4777:33;4774:120;;;4813:79;;:::i;:::-;4774:120;4933:1;4958:53;5003:7;4994:6;4983:9;4979:22;4958:53;:::i;:::-;4948:63;;4904:117;5060:2;5086:53;5131:7;5122:6;5111:9;5107:22;5086:53;:::i;:::-;5076:63;;5031:118;5188:2;5214:53;5259:7;5250:6;5239:9;5235:22;5214:53;:::i;:::-;5204:63;;5159:118;5344:2;5333:9;5329:18;5316:32;5375:18;5367:6;5364:30;5361:117;;;5397:79;;:::i;:::-;5361:117;5510:64;5566:7;5557:6;5546:9;5542:22;5510:64;:::i;:::-;5492:82;;;;5287:297;4628:963;;;;;;;;:::o;5597:684::-;5690:6;5698;5747:2;5735:9;5726:7;5722:23;5718:32;5715:119;;;5753:79;;:::i;:::-;5715:119;5873:1;5898:53;5943:7;5934:6;5923:9;5919:22;5898:53;:::i;:::-;5888:63;;5844:117;6028:2;6017:9;6013:18;6000:32;6059:18;6051:6;6048:30;6045:117;;;6081:79;;:::i;:::-;6045:117;6186:78;6256:7;6247:6;6236:9;6232:22;6186:78;:::i;:::-;6176:88;;5971:303;5597:684;;;;;:::o;6287:474::-;6355:6;6363;6412:2;6400:9;6391:7;6387:23;6383:32;6380:119;;;6418:79;;:::i;:::-;6380:119;6538:1;6563:53;6608:7;6599:6;6588:9;6584:22;6563:53;:::i;:::-;6553:63;;6509:117;6665:2;6691:53;6736:7;6727:6;6716:9;6712:22;6691:53;:::i;:::-;6681:63;;6636:118;6287:474;;;;;:::o;6767:559::-;6853:6;6861;6910:2;6898:9;6889:7;6885:23;6881:32;6878:119;;;6916:79;;:::i;:::-;6878:119;7064:1;7053:9;7049:17;7036:31;7094:18;7086:6;7083:30;7080:117;;;7116:79;;:::i;:::-;7080:117;7229:80;7301:7;7292:6;7281:9;7277:22;7229:80;:::i;:::-;7211:98;;;;7007:312;6767:559;;;;;:::o;7332:::-;7418:6;7426;7475:2;7463:9;7454:7;7450:23;7446:32;7443:119;;;7481:79;;:::i;:::-;7443:119;7629:1;7618:9;7614:17;7601:31;7659:18;7651:6;7648:30;7645:117;;;7681:79;;:::i;:::-;7645:117;7794:80;7866:7;7857:6;7846:9;7842:22;7794:80;:::i;:::-;7776:98;;;;7572:312;7332:559;;;;;:::o;7897:329::-;7956:6;8005:2;7993:9;7984:7;7980:23;7976:32;7973:119;;;8011:79;;:::i;:::-;7973:119;8131:1;8156:53;8201:7;8192:6;8181:9;8177:22;8156:53;:::i;:::-;8146:63;;8102:117;7897:329;;;;:::o;8232:474::-;8300:6;8308;8357:2;8345:9;8336:7;8332:23;8328:32;8325:119;;;8363:79;;:::i;:::-;8325:119;8483:1;8508:53;8553:7;8544:6;8533:9;8529:22;8508:53;:::i;:::-;8498:63;;8454:117;8610:2;8636:53;8681:7;8672:6;8661:9;8657:22;8636:53;:::i;:::-;8626:63;;8581:118;8232:474;;;;;:::o;8712:179::-;8781:10;8802:46;8844:3;8836:6;8802:46;:::i;:::-;8880:4;8875:3;8871:14;8857:28;;8712:179;;;;:::o;8897:118::-;8984:24;9002:5;8984:24;:::i;:::-;8979:3;8972:37;8897:118;;:::o;9051:732::-;9170:3;9199:54;9247:5;9199:54;:::i;:::-;9269:86;9348:6;9343:3;9269:86;:::i;:::-;9262:93;;9379:56;9429:5;9379:56;:::i;:::-;9458:7;9489:1;9474:284;9499:6;9496:1;9493:13;9474:284;;;9575:6;9569:13;9602:63;9661:3;9646:13;9602:63;:::i;:::-;9595:70;;9688:60;9741:6;9688:60;:::i;:::-;9678:70;;9534:224;9521:1;9518;9514:9;9509:14;;9474:284;;;9478:14;9774:3;9767:10;;9175:608;;;9051:732;;;;:::o;9789:109::-;9870:21;9885:5;9870:21;:::i;:::-;9865:3;9858:34;9789:109;;:::o;9904:115::-;9989:23;10006:5;9989:23;:::i;:::-;9984:3;9977:36;9904:115;;:::o;10025:364::-;10113:3;10141:39;10174:5;10141:39;:::i;:::-;10196:71;10260:6;10255:3;10196:71;:::i;:::-;10189:78;;10276:52;10321:6;10316:3;10309:4;10302:5;10298:16;10276:52;:::i;:::-;10353:29;10375:6;10353:29;:::i;:::-;10348:3;10344:39;10337:46;;10117:272;10025:364;;;;:::o;10395:366::-;10537:3;10558:67;10622:2;10617:3;10558:67;:::i;:::-;10551:74;;10634:93;10723:3;10634:93;:::i;:::-;10752:2;10747:3;10743:12;10736:19;;10395:366;;;:::o;10767:::-;10909:3;10930:67;10994:2;10989:3;10930:67;:::i;:::-;10923:74;;11006:93;11095:3;11006:93;:::i;:::-;11124:2;11119:3;11115:12;11108:19;;10767:366;;;:::o;11139:::-;11281:3;11302:67;11366:2;11361:3;11302:67;:::i;:::-;11295:74;;11378:93;11467:3;11378:93;:::i;:::-;11496:2;11491:3;11487:12;11480:19;;11139:366;;;:::o;11511:::-;11653:3;11674:67;11738:2;11733:3;11674:67;:::i;:::-;11667:74;;11750:93;11839:3;11750:93;:::i;:::-;11868:2;11863:3;11859:12;11852:19;;11511:366;;;:::o;11883:::-;12025:3;12046:67;12110:2;12105:3;12046:67;:::i;:::-;12039:74;;12122:93;12211:3;12122:93;:::i;:::-;12240:2;12235:3;12231:12;12224:19;;11883:366;;;:::o;12255:::-;12397:3;12418:67;12482:2;12477:3;12418:67;:::i;:::-;12411:74;;12494:93;12583:3;12494:93;:::i;:::-;12612:2;12607:3;12603:12;12596:19;;12255:366;;;:::o;12627:::-;12769:3;12790:67;12854:2;12849:3;12790:67;:::i;:::-;12783:74;;12866:93;12955:3;12866:93;:::i;:::-;12984:2;12979:3;12975:12;12968:19;;12627:366;;;:::o;12999:::-;13141:3;13162:67;13226:2;13221:3;13162:67;:::i;:::-;13155:74;;13238:93;13327:3;13238:93;:::i;:::-;13356:2;13351:3;13347:12;13340:19;;12999:366;;;:::o;13371:::-;13513:3;13534:67;13598:2;13593:3;13534:67;:::i;:::-;13527:74;;13610:93;13699:3;13610:93;:::i;:::-;13728:2;13723:3;13719:12;13712:19;;13371:366;;;:::o;13743:::-;13885:3;13906:67;13970:2;13965:3;13906:67;:::i;:::-;13899:74;;13982:93;14071:3;13982:93;:::i;:::-;14100:2;14095:3;14091:12;14084:19;;13743:366;;;:::o;14115:::-;14257:3;14278:67;14342:2;14337:3;14278:67;:::i;:::-;14271:74;;14354:93;14443:3;14354:93;:::i;:::-;14472:2;14467:3;14463:12;14456:19;;14115:366;;;:::o;14487:::-;14629:3;14650:67;14714:2;14709:3;14650:67;:::i;:::-;14643:74;;14726:93;14815:3;14726:93;:::i;:::-;14844:2;14839:3;14835:12;14828:19;;14487:366;;;:::o;14859:362::-;15000:3;15021:65;15084:1;15079:3;15021:65;:::i;:::-;15014:72;;15095:93;15184:3;15095:93;:::i;:::-;15213:1;15208:3;15204:11;15197:18;;14859:362;;;:::o;15227:366::-;15369:3;15390:67;15454:2;15449:3;15390:67;:::i;:::-;15383:74;;15466:93;15555:3;15466:93;:::i;:::-;15584:2;15579:3;15575:12;15568:19;;15227:366;;;:::o;15599:::-;15741:3;15762:67;15826:2;15821:3;15762:67;:::i;:::-;15755:74;;15838:93;15927:3;15838:93;:::i;:::-;15956:2;15951:3;15947:12;15940:19;;15599:366;;;:::o;15971:::-;16113:3;16134:67;16198:2;16193:3;16134:67;:::i;:::-;16127:74;;16210:93;16299:3;16210:93;:::i;:::-;16328:2;16323:3;16319:12;16312:19;;15971:366;;;:::o;16343:::-;16485:3;16506:67;16570:2;16565:3;16506:67;:::i;:::-;16499:74;;16582:93;16671:3;16582:93;:::i;:::-;16700:2;16695:3;16691:12;16684:19;;16343:366;;;:::o;16715:108::-;16792:24;16810:5;16792:24;:::i;:::-;16787:3;16780:37;16715:108;;:::o;16829:118::-;16916:24;16934:5;16916:24;:::i;:::-;16911:3;16904:37;16829:118;;:::o;16953:112::-;17036:22;17052:5;17036:22;:::i;:::-;17031:3;17024:35;16953:112;;:::o;17071:222::-;17164:4;17202:2;17191:9;17187:18;17179:26;;17215:71;17283:1;17272:9;17268:17;17259:6;17215:71;:::i;:::-;17071:222;;;;:::o;17299:748::-;17548:4;17586:3;17575:9;17571:19;17563:27;;17600:71;17668:1;17657:9;17653:17;17644:6;17600:71;:::i;:::-;17681:72;17749:2;17738:9;17734:18;17725:6;17681:72;:::i;:::-;17763;17831:2;17820:9;17816:18;17807:6;17763:72;:::i;:::-;17882:9;17876:4;17872:20;17867:2;17856:9;17852:18;17845:48;17910:130;18035:4;17910:130;:::i;:::-;17902:138;;17299:748;;;;;;:::o;18053:373::-;18196:4;18234:2;18223:9;18219:18;18211:26;;18283:9;18277:4;18273:20;18269:1;18258:9;18254:17;18247:47;18311:108;18414:4;18405:6;18311:108;:::i;:::-;18303:116;;18053:373;;;;:::o;18432:210::-;18519:4;18557:2;18546:9;18542:18;18534:26;;18570:65;18632:1;18621:9;18617:17;18608:6;18570:65;:::i;:::-;18432:210;;;;:::o;18648:218::-;18739:4;18777:2;18766:9;18762:18;18754:26;;18790:69;18856:1;18845:9;18841:17;18832:6;18790:69;:::i;:::-;18648:218;;;;:::o;18872:313::-;18985:4;19023:2;19012:9;19008:18;19000:26;;19072:9;19066:4;19062:20;19058:1;19047:9;19043:17;19036:47;19100:78;19173:4;19164:6;19100:78;:::i;:::-;19092:86;;18872:313;;;;:::o;19191:419::-;19357:4;19395:2;19384:9;19380:18;19372:26;;19444:9;19438:4;19434:20;19430:1;19419:9;19415:17;19408:47;19472:131;19598:4;19472:131;:::i;:::-;19464:139;;19191:419;;;:::o;19616:::-;19782:4;19820:2;19809:9;19805:18;19797:26;;19869:9;19863:4;19859:20;19855:1;19844:9;19840:17;19833:47;19897:131;20023:4;19897:131;:::i;:::-;19889:139;;19616:419;;;:::o;20041:::-;20207:4;20245:2;20234:9;20230:18;20222:26;;20294:9;20288:4;20284:20;20280:1;20269:9;20265:17;20258:47;20322:131;20448:4;20322:131;:::i;:::-;20314:139;;20041:419;;;:::o;20466:::-;20632:4;20670:2;20659:9;20655:18;20647:26;;20719:9;20713:4;20709:20;20705:1;20694:9;20690:17;20683:47;20747:131;20873:4;20747:131;:::i;:::-;20739:139;;20466:419;;;:::o;20891:::-;21057:4;21095:2;21084:9;21080:18;21072:26;;21144:9;21138:4;21134:20;21130:1;21119:9;21115:17;21108:47;21172:131;21298:4;21172:131;:::i;:::-;21164:139;;20891:419;;;:::o;21316:::-;21482:4;21520:2;21509:9;21505:18;21497:26;;21569:9;21563:4;21559:20;21555:1;21544:9;21540:17;21533:47;21597:131;21723:4;21597:131;:::i;:::-;21589:139;;21316:419;;;:::o;21741:::-;21907:4;21945:2;21934:9;21930:18;21922:26;;21994:9;21988:4;21984:20;21980:1;21969:9;21965:17;21958:47;22022:131;22148:4;22022:131;:::i;:::-;22014:139;;21741:419;;;:::o;22166:::-;22332:4;22370:2;22359:9;22355:18;22347:26;;22419:9;22413:4;22409:20;22405:1;22394:9;22390:17;22383:47;22447:131;22573:4;22447:131;:::i;:::-;22439:139;;22166:419;;;:::o;22591:::-;22757:4;22795:2;22784:9;22780:18;22772:26;;22844:9;22838:4;22834:20;22830:1;22819:9;22815:17;22808:47;22872:131;22998:4;22872:131;:::i;:::-;22864:139;;22591:419;;;:::o;23016:::-;23182:4;23220:2;23209:9;23205:18;23197:26;;23269:9;23263:4;23259:20;23255:1;23244:9;23240:17;23233:47;23297:131;23423:4;23297:131;:::i;:::-;23289:139;;23016:419;;;:::o;23441:::-;23607:4;23645:2;23634:9;23630:18;23622:26;;23694:9;23688:4;23684:20;23680:1;23669:9;23665:17;23658:47;23722:131;23848:4;23722:131;:::i;:::-;23714:139;;23441:419;;;:::o;23866:::-;24032:4;24070:2;24059:9;24055:18;24047:26;;24119:9;24113:4;24109:20;24105:1;24094:9;24090:17;24083:47;24147:131;24273:4;24147:131;:::i;:::-;24139:139;;23866:419;;;:::o;24291:::-;24457:4;24495:2;24484:9;24480:18;24472:26;;24544:9;24538:4;24534:20;24530:1;24519:9;24515:17;24508:47;24572:131;24698:4;24572:131;:::i;:::-;24564:139;;24291:419;;;:::o;24716:::-;24882:4;24920:2;24909:9;24905:18;24897:26;;24969:9;24963:4;24959:20;24955:1;24944:9;24940:17;24933:47;24997:131;25123:4;24997:131;:::i;:::-;24989:139;;24716:419;;;:::o;25141:::-;25307:4;25345:2;25334:9;25330:18;25322:26;;25394:9;25388:4;25384:20;25380:1;25369:9;25365:17;25358:47;25422:131;25548:4;25422:131;:::i;:::-;25414:139;;25141:419;;;:::o;25566:::-;25732:4;25770:2;25759:9;25755:18;25747:26;;25819:9;25813:4;25809:20;25805:1;25794:9;25790:17;25783:47;25847:131;25973:4;25847:131;:::i;:::-;25839:139;;25566:419;;;:::o;25991:222::-;26084:4;26122:2;26111:9;26107:18;26099:26;;26135:71;26203:1;26192:9;26188:17;26179:6;26135:71;:::i;:::-;25991:222;;;;:::o;26219:214::-;26308:4;26346:2;26335:9;26331:18;26323:26;;26359:67;26423:1;26412:9;26408:17;26399:6;26359:67;:::i;:::-;26219:214;;;;:::o;26439:129::-;26473:6;26500:20;;:::i;:::-;26490:30;;26529:33;26557:4;26549:6;26529:33;:::i;:::-;26439:129;;;:::o;26574:75::-;26607:6;26640:2;26634:9;26624:19;;26574:75;:::o;26655:311::-;26732:4;26822:18;26814:6;26811:30;26808:56;;;26844:18;;:::i;:::-;26808:56;26894:4;26886:6;26882:17;26874:25;;26954:4;26948;26944:15;26936:23;;26655:311;;;:::o;26972:132::-;27039:4;27062:3;27054:11;;27092:4;27087:3;27083:14;27075:22;;26972:132;;;:::o;27110:114::-;27177:6;27211:5;27205:12;27195:22;;27110:114;;;:::o;27230:99::-;27282:6;27316:5;27310:12;27300:22;;27230:99;;;:::o;27335:113::-;27405:4;27437;27432:3;27428:14;27420:22;;27335:113;;;:::o;27454:184::-;27553:11;27587:6;27582:3;27575:19;27627:4;27622:3;27618:14;27603:29;;27454:184;;;;:::o;27644:168::-;27727:11;27761:6;27756:3;27749:19;27801:4;27796:3;27792:14;27777:29;;27644:168;;;;:::o;27818:169::-;27902:11;27936:6;27931:3;27924:19;27976:4;27971:3;27967:14;27952:29;;27818:169;;;;:::o;27993:305::-;28033:3;28052:20;28070:1;28052:20;:::i;:::-;28047:25;;28086:20;28104:1;28086:20;:::i;:::-;28081:25;;28240:1;28172:66;28168:74;28165:1;28162:81;28159:107;;;28246:18;;:::i;:::-;28159:107;28290:1;28287;28283:9;28276:16;;27993:305;;;;:::o;28304:185::-;28344:1;28361:20;28379:1;28361:20;:::i;:::-;28356:25;;28395:20;28413:1;28395:20;:::i;:::-;28390:25;;28434:1;28424:35;;28439:18;;:::i;:::-;28424:35;28481:1;28478;28474:9;28469:14;;28304:185;;;;:::o;28495:348::-;28535:7;28558:20;28576:1;28558:20;:::i;:::-;28553:25;;28592:20;28610:1;28592:20;:::i;:::-;28587:25;;28780:1;28712:66;28708:74;28705:1;28702:81;28697:1;28690:9;28683:17;28679:105;28676:131;;;28787:18;;:::i;:::-;28676:131;28835:1;28832;28828:9;28817:20;;28495:348;;;;:::o;28849:191::-;28889:4;28909:20;28927:1;28909:20;:::i;:::-;28904:25;;28943:20;28961:1;28943:20;:::i;:::-;28938:25;;28982:1;28979;28976:8;28973:34;;;28987:18;;:::i;:::-;28973:34;29032:1;29029;29025:9;29017:17;;28849:191;;;;:::o;29046:96::-;29083:7;29112:24;29130:5;29112:24;:::i;:::-;29101:35;;29046:96;;;:::o;29148:90::-;29182:7;29225:5;29218:13;29211:21;29200:32;;29148:90;;;:::o;29244:149::-;29280:7;29320:66;29313:5;29309:78;29298:89;;29244:149;;;:::o;29399:126::-;29436:7;29476:42;29469:5;29465:54;29454:65;;29399:126;;;:::o;29531:77::-;29568:7;29597:5;29586:16;;29531:77;;;:::o;29614:86::-;29649:7;29689:4;29682:5;29678:16;29667:27;;29614:86;;;:::o;29706:307::-;29774:1;29784:113;29798:6;29795:1;29792:13;29784:113;;;29883:1;29878:3;29874:11;29868:18;29864:1;29859:3;29855:11;29848:39;29820:2;29817:1;29813:10;29808:15;;29784:113;;;29915:6;29912:1;29909:13;29906:101;;;29995:1;29986:6;29981:3;29977:16;29970:27;29906:101;29755:258;29706:307;;;:::o;30019:320::-;30063:6;30100:1;30094:4;30090:12;30080:22;;30147:1;30141:4;30137:12;30168:18;30158:81;;30224:4;30216:6;30212:17;30202:27;;30158:81;30286:2;30278:6;30275:14;30255:18;30252:38;30249:84;;;30305:18;;:::i;:::-;30249:84;30070:269;30019:320;;;:::o;30345:281::-;30428:27;30450:4;30428:27;:::i;:::-;30420:6;30416:40;30558:6;30546:10;30543:22;30522:18;30510:10;30507:34;30504:62;30501:88;;;30569:18;;:::i;:::-;30501:88;30609:10;30605:2;30598:22;30388:238;30345:281;;:::o;30632:233::-;30671:3;30694:24;30712:5;30694:24;:::i;:::-;30685:33;;30740:66;30733:5;30730:77;30727:103;;;30810:18;;:::i;:::-;30727:103;30857:1;30850:5;30846:13;30839:20;;30632:233;;;:::o;30871:180::-;30919:77;30916:1;30909:88;31016:4;31013:1;31006:15;31040:4;31037:1;31030:15;31057:180;31105:77;31102:1;31095:88;31202:4;31199:1;31192:15;31226:4;31223:1;31216:15;31243:180;31291:77;31288:1;31281:88;31388:4;31385:1;31378:15;31412:4;31409:1;31402:15;31429:180;31477:77;31474:1;31467:88;31574:4;31571:1;31564:15;31598:4;31595:1;31588:15;31615:180;31663:77;31660:1;31653:88;31760:4;31757:1;31750:15;31784:4;31781:1;31774:15;31801:180;31849:77;31846:1;31839:88;31946:4;31943:1;31936:15;31970:4;31967:1;31960:15;31987:117;32096:1;32093;32086:12;32110:117;32219:1;32216;32209:12;32233:117;32342:1;32339;32332:12;32356:117;32465:1;32462;32455:12;32479:117;32588:1;32585;32578:12;32602:102;32643:6;32694:2;32690:7;32685:2;32678:5;32674:14;32670:28;32660:38;;32602:102;;;:::o;32710:222::-;32850:34;32846:1;32838:6;32834:14;32827:58;32919:5;32914:2;32906:6;32902:15;32895:30;32710:222;:::o;32938:221::-;33078:34;33074:1;33066:6;33062:14;33055:58;33147:4;33142:2;33134:6;33130:15;33123:29;32938:221;:::o;33165:164::-;33305:16;33301:1;33293:6;33289:14;33282:40;33165:164;:::o;33335:225::-;33475:34;33471:1;33463:6;33459:14;33452:58;33544:8;33539:2;33531:6;33527:15;33520:33;33335:225;:::o;33566:221::-;33706:34;33702:1;33694:6;33690:14;33683:58;33775:4;33770:2;33762:6;33758:15;33751:29;33566:221;:::o;33793:179::-;33933:31;33929:1;33921:6;33917:14;33910:55;33793:179;:::o;33978:225::-;34118:34;34114:1;34106:6;34102:14;34095:58;34187:8;34182:2;34174:6;34170:15;34163:33;33978:225;:::o;34209:165::-;34349:17;34345:1;34337:6;34333:14;34326:41;34209:165;:::o;34380:182::-;34520:34;34516:1;34508:6;34504:14;34497:58;34380:182;:::o;34568:178::-;34708:30;34704:1;34696:6;34692:14;34685:54;34568:178;:::o;34752:220::-;34892:34;34888:1;34880:6;34876:14;34869:58;34961:3;34956:2;34948:6;34944:15;34937:28;34752:220;:::o;34978:224::-;35118:34;35114:1;35106:6;35102:14;35095:58;35187:7;35182:2;35174:6;35170:15;35163:32;34978:224;:::o;35208:114::-;;:::o;35328:223::-;35468:34;35464:1;35456:6;35452:14;35445:58;35537:6;35532:2;35524:6;35520:15;35513:31;35328:223;:::o;35557:181::-;35697:33;35693:1;35685:6;35681:14;35674:57;35557:181;:::o;35744:224::-;35884:34;35880:1;35872:6;35868:14;35861:58;35953:7;35948:2;35940:6;35936:15;35929:32;35744:224;:::o;35974:181::-;36114:33;36110:1;36102:6;36098:14;36091:57;35974:181;:::o;36161:122::-;36234:24;36252:5;36234:24;:::i;:::-;36227:5;36224:35;36214:63;;36273:1;36270;36263:12;36214:63;36161:122;:::o;36289:::-;36362:24;36380:5;36362:24;:::i;:::-;36355:5;36352:35;36342:63;;36401:1;36398;36391:12;36342:63;36289:122;:::o

Swarm Source

ipfs://82966798a936a912d3811a6c2ac9e554ee1f92e9ae04c2296bfb57cb2fd986b6

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