Token

Divinity (Div)

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

ERC-721

Overview

Max Total Supply

936 Div

Holders

127

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x0e2bdde5eee52d37930d28177edb721c52e85452

Filtered by Token Holder

0x28446A806BA4A4524d098503c2769BC40EEe1EcD

Balance

2 Div

0x28446A806BA4A4524d098503c2769BC40EEe1EcD

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DivinityCellNFT

Compiler Version

v0.8.2+commit.661d1103

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-30
*/

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

// SPDX-License-Identifier: MIT
// 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/Counters.sol

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/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

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/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/token/ERC721/extensions/IERC721Metadata.sol


pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/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/utils/Strings.sol


pragma solidity ^0.8.0;

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

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

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


pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: contracts/utility/ERC721.sol


pragma solidity ^0.8.0;







/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

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

    event Premint(address indexed _to, uint256 indexed start_id, uint256 indexed count);
    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

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

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

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

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _balances[to] += 1;
        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId);
    }

    function _mint_many(address to, uint256 first_tokenId, uint256 count) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(first_tokenId), "ERC721: token already minted");
        uint256 last_id = first_tokenId + count;

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

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

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

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId);
    }

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

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` 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 tokenId
    ) 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.
     * - `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 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/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/security/Pausable.sol


pragma solidity ^0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

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

    bool private _paused;

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

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

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

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

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

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: @openzeppelin/contracts/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/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: contracts/DivinityCellWhitelist.sol

pragma solidity ^0.8.0;


/**
 * @title Divinity Cell DivinityCellWhitelist Contract
 * @notice Part of the DivinityCellMinter
 * @author Apriorit
 */
contract DivinityCellWhitelist is Ownable {
    using EnumerableSet for EnumerableSet.AddressSet;
    EnumerableSet.AddressSet _whitelisted_users;

    /**
     * @notice Add toWhitelist address to the whitelist
     * @param toWhitelist The address of account to whitelist
     * @return Whether or not the transaction succeeded
     */
    function whitelist(address toWhitelist) external onlyOwner returns(bool) {
        require(!_whitelisted_users.contains(toWhitelist), "Address is already in whitelist");
        _whitelisted_users.add(toWhitelist);
        return true;
    }

    function getWhitelist() external view returns(address[] memory) {
        return _whitelisted_users.values();
    }

    /**
     * @notice Remove toUnWhitelist address from whitelist
     * @param toUnWhitelist The address of account to remove from whitelist
     * @return Whether or not the transaction succeeded
     */
    function unwhitelist(address toUnWhitelist) external onlyOwner returns(bool) {
        require(_whitelisted_users.contains(toUnWhitelist), "Address is not in whitelist");
        _whitelisted_users.remove(toUnWhitelist);
        return true;
    }

    /**
     * @notice Add toWhitelist list of addresses into whitelist
     * @param toWhitelist The addresses of accounts to add to the whitelist
     * @return Whether or not the transaction succeeded
     */
    function whitelistMany(address[] memory toWhitelist) external onlyOwner returns(bool) {
        for (uint i = 0; i < toWhitelist.length; i++) {
            _whitelisted_users.add(toWhitelist[i]);
        }
        return true;
    }

    /**
     * @notice Remove toUnWhitelist list of addresses from the whitelist
     * @param toUnWhitelist The addresses of accounts to remove from the whitelist
     * @return Whether or not the transaction succeeded
     */
    function unwhitelistMany(address[] memory toUnWhitelist) external onlyOwner returns(bool) {
        for (uint i = 0; i < toUnWhitelist.length; i++) {
            _whitelisted_users.remove(toUnWhitelist[i]);
        }
        return true;
    }

    /**
     * @notice Check if account whitelisted or not
     * @param account Account that we want to check
     * @return Whether or not the account in the whitelist
     */
    function is_whitelisted(address account) public view returns(bool) {
        return _whitelisted_users.contains(account);
    }
}

// File: contracts/DivinityCellMinter.sol

pragma solidity ^0.8.0;



/**
 * @title Divinity Cell DivinityCellMinter Contract
 * @notice Used for token presales
 * @author Apriorit
 */
contract DivinityCellMinter is ReentrancyGuard, Ownable, Pausable, DivinityCellWhitelist {
    using SafeMath for uint256;

    uint256 public tokens_limit;
    
    uint256 public tokens_this_sale = 0;
    uint32 public buy_limit;
    uint32 current_sale_id = 0;
    uint256 public mint_price;

    uint256 public sale_end_timestamp = 0;
    uint256 public sale_start_timestamp = 0;

    bool public is_sell_private = true;

    mapping(uint => mapping(address => uint)) bought_current_sell;
    address nft_contract;

    /**
     * @notice Return bought count for the current sale
     * @param account Account that we want to check
     * @return Count of bought tokens for the current sale
     */
    function boughtCurrentSale(address account) public view returns(uint) {
        return bought_current_sell[current_sale_id][account];
    }

    /**
     * @notice If current sale is private, ensures that it still continues and sender is whitelisted
     */
    modifier minterAllowed {
        if (is_sell_private) {
            require(block.timestamp < sale_end_timestamp, "DivinityCellAuction: Sale ended");
            require(is_whitelisted(msg.sender), "DivinityCellAuction: Account is not whitelisted");
        }
        _;
    }

    /**
     * @notice Ensures that there is no other sale. If last sale was public, ensures that all tokens sold
     */
    modifier onlyIfNoSale {
        require(sale_start_timestamp < block.timestamp, "DivinityCellAuction: New sale is about to start");

        if (tokens_this_sale != 0) {
            require(sale_end_timestamp < block.timestamp, "DivinityCellAuction: Private sale still continues");
        }
        _;
    }

    /**
     * @notice Sets new mint price for token mint. Can be called only by contract owner
     * @param nft address of NFT tokens contract, used for minting
     * @param tokens_count Amount of tokens to be minted
     * @param initial_mint_price Initial minting price
     */
    constructor(address nft, uint32 tokens_count, uint256 initial_mint_price) {
        tokens_limit = tokens_count;
        nft_contract = nft;
        mint_price = initial_mint_price;
    }

    /**
     * @notice Send all eth collected by contract to _to account. Can be called only by contract owner
     * @param _to The account that will revieve contract ETH
     * @return Whether or not the transaction succeeded
     */
    function collectETH(address payable _to) external onlyOwner payable returns(bool) {
        (bool sent,) = _to.call{value: address(this).balance}("");
        require(sent, "DivinityCellAuction: Failed to send Ether");
        return true;
    }

    /**
     * @notice Sets new mint price for token mint. Can be called only by contract owner
     * @param new_mint_price New mint price
     * @return Whether or not the transaction succeeded
     */
    function setPrice(uint256 new_mint_price) external onlyOwner returns(bool) {
        mint_price = new_mint_price;
        return true;
    }

    /**
     * @notice Starts private token sale. Can be called only by contract owner and only if other sale is not running
     * @param per_user_limitation Number of tokens that be bought by accounts this sale
     * @param tokens_count Number of tokens that will be sold this sale
     * @param new_sale_end_timestamp Sale start timestamp
     * @param new_sale_start_timestamp Sale end timestamp
     * @return Whether or not the transaction succeeded
     */
    function startPrivateSale(uint32 per_user_limitation, uint256 tokens_count, uint256 new_sale_start_timestamp, uint256 new_sale_end_timestamp) external onlyOwner onlyIfNoSale returns(bool) {
        require(tokens_limit >= tokens_count, "DivinityCellAuction: Cant sell that much tokens");
        require(new_sale_end_timestamp > block.timestamp, "DivinityCellAuction: Wrong timestamp passed");
        require(new_sale_start_timestamp < new_sale_end_timestamp, "DivinityCellAuction: Start date should be less than end date");
        require(per_user_limitation > 0, "DivinityCellAuction: Wrong limitation passed");
        require(tokens_count > 0, "DivinityCellAuction: Wrong token count passed");

        tokens_this_sale = tokens_count;
        buy_limit  = per_user_limitation;
        sale_end_timestamp = new_sale_end_timestamp;
        sale_start_timestamp = new_sale_start_timestamp;
        current_sale_id += 1;
        is_sell_private = true;
        
        return true;
    }
    
    /**
     * @notice Changes sale start and end timestamps.
     * @param new_sale_end_timestamp New sale start timestamp
     * @param new_sale_start_timestamp New sale end timestamp
     * @return Whether or not the transaction succeeded
     */
    function reschedulePrivateSale(uint256 new_sale_start_timestamp, uint256 new_sale_end_timestamp) external onlyOwner returns(bool) {
        require(new_sale_start_timestamp < new_sale_end_timestamp, "DivinityCellAuction: Start date should be less than end date");
        require(tokens_this_sale > 0, "DivinityCellAuction: No tokens left");

        sale_end_timestamp = new_sale_end_timestamp;
        sale_start_timestamp = new_sale_start_timestamp;

        return true;
    } 
    
    /**
     * @notice Starts public token sale. Can be called only by contract owner and only if other sale is not running.
     * Unlike private one, this will end only after all tokens are bought
     * @param per_user_limitation Number of tokens that be bought by accounts this sale
     * @param new_sale_start_timestamp Sale start timestamp
     * @return Whether or not the transaction succeeded
     */
    function startPublicSale(uint256 new_sale_start_timestamp, uint32 per_user_limitation) external onlyOwner onlyIfNoSale returns(bool) {
        require(tokens_limit > 0, "DivinityCellAuction: Cant sell that much tokens");
        require(per_user_limitation > 0, "DivinityCellAuction: Wrong limitation passed");
        
        tokens_this_sale = tokens_limit;
        sale_start_timestamp = new_sale_start_timestamp;
        buy_limit  = per_user_limitation;
        current_sale_id += 1;
        is_sell_private = false;
        
        return true;
    }
    
    /**
     * @notice Changes sale start timestamp.
     * @param new_sale_start_timestamp New start end timestamp
     * @return Whether or not the transaction succeeded
     */
    function reschedulePublicSale(uint256 new_sale_start_timestamp) external onlyOwner returns(bool) {
        require(sale_end_timestamp < block.timestamp, "DivinityCellAuction: Private sale continues");
        require(tokens_this_sale > 0, "DivinityCellAuction: No tokens left");

        sale_start_timestamp = new_sale_start_timestamp;

        return true;
    } 
    
    /**
     * @notice pause current sale. Emits pause event
     */
    function pause() public onlyOwner {
        Pausable._pause();
    }

    /**
     * @notice unpause current sale. Emits unpause event
     */
    function unpause() public onlyOwner {
        Pausable._unpause();
    }

    /**
     * @notice Mints token for transaction sender. Can't be called if sale is not started
     * @return ID of minted token
     */
    function mint(uint256 amount) public payable whenNotPaused minterAllowed nonReentrant returns(bool) {
        uint256 userLimit = buy_limit - boughtCurrentSale(msg.sender);
        require(userLimit > 0, "DivinityCellAuction: This recipient cant buy more tokens this sale");
        require(amount > 0, "DivinityCellAuction: Invalid amount");
        require(block.timestamp >= sale_start_timestamp, "DivinityCellAuction: Sale hasn't started yet");

        uint256 count = Math.min(amount, userLimit);
        require(msg.value == mint_price * count, "DivinityCellAuction: Wrong amount of eth sent");
        require(tokens_this_sale >= count, "DivinityCellAuction: Nothing to sell");
        require(tokens_limit >= count, "DivinityCellAuction: Nothing to sell");

        bool isMinted = DivinityCellNFT(nft_contract).premint(msg.sender, count);
        require(isMinted, "DivinityCellAuction: mint failed");
        bought_current_sell[current_sale_id][msg.sender] += count;
        tokens_this_sale -= count;
        tokens_limit -= count;

        return isMinted;
    }
    
    /**
     * @notice Mint count tokens for account. Can be called only by contract owner
     * @param account The address of account that will recieve tokens
     * @param count Count of tokens to mint
     * @return Whether or not the transaction succeeded
     */
    function premint(address account, uint256 count) external onlyOwner nonReentrant returns(bool) {
        require(tokens_limit >= count, "DivinityCellAuction: can't mint that much tokens");
        bool is_premnt_successful = DivinityCellNFT(nft_contract).premint(account, count);
        require(is_premnt_successful, "DivinityCellAuction: premint was unsuccessful");
        tokens_limit -= count;
        return is_premnt_successful;
    }
}

// File: @openzeppelin/contracts/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: contracts/DivinityCellNFT.sol

pragma solidity ^0.8.0;




contract OwnableDelegateProxy {}

contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

/**
 * @title Divinity Cell DivinityCellNFT Contract
 * @author Apriorit
 */
contract DivinityCellNFT is ERC721, Ownable {
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    string base_url;
    address burner;
    address _minter;
    address proxyRegistryAddress;
    Counters.Counter _nextTokenId;
    
    /**
     * @notice Ensures that sender has burn rights
     */
    modifier onlyBurner {
        require(msg.sender == burner, "DivinityCellNFT: Sender must have burner role");
        _;
    }

    /**
     * @notice Ensures that sender has mint rights
     */
    modifier onlyMinter {
        require(msg.sender == _minter, "DivinityCellNFT: Sender is not auction");
        _;
    }

    /**
     * @param _name Token name
     * @param _symbol Token syumbol
     * @param token_url Token base URI 
     * @param _proxyRegistryAddress OpenSea existring proxy registry. On Mainnet it is 0xa5409ec958c83c3f309868babaca7c86dcb077c1 
     */
    constructor(
        string memory _name,
        string memory _symbol,
        string memory token_url,
        address _proxyRegistryAddress
    ) ERC721(_name, _symbol) {
        base_url = token_url;
        proxyRegistryAddress = _proxyRegistryAddress;
    }

    /**
     * @notice Check if account is owner of tokenId
     * @param account The address of account that we want to check
     * @param tokenId ID that we are checking 
     * @return Whether or not the account is owner of tokenId
     */
    function isTokenOwner(uint256 tokenId, address account) external view returns(bool) {
        return ERC721.ownerOf(tokenId) == account;
    }

    /**
     * @notice Mint token for recipient. Can be called only by _minter
     * @param recipient The address of account that will recieve token
     * @return Minted token ID
     */
    function mintTo(address recipient) external onlyMinter returns(uint256) {
        uint256 currentTokenId = _nextTokenId.current();
        _nextTokenId.increment();
        _safeMint(recipient, currentTokenId);
        return currentTokenId;
    }
     
    /**
     * @notice Mint count tokens for account. Can be called only by contract owner
     * @param account The address of account that will recieve tokens
     * @param count Count of tokens to mint
     * @return Whether or not the transaction succeeded
     */
    function premint(address account, uint256 count) external onlyMinter returns(bool) {
        uint256 currentTokenId = _nextTokenId.current();
        ERC721._mint_many(account, currentTokenId, count);
        _nextTokenId._value += count;
        return true;
    }
    
    /**
     * @notice Set new _minter. Only owner can call this. Can be called only by contract owner
     * @param minter The address of new minter
     * @return Whether or not the transaction succeeded
     */
    function registerMinterContract(address minter) external onlyOwner returns(bool){
        _minter = minter;
        return true;
    }

    /**
     * @notice Get current last token ID + 1.(total amount)
     * @return Current amount of tokens
     */
    function totalSupply() external view returns (uint256) {
        return _nextTokenId.current();
    }

    /**
     * @notice Set new token URI. Can be called only by contract owner
     * @param baseUrl New token URL
     * @return Whether or not the transaction succeeded
     */
    function setURI(string memory baseUrl) external onlyOwner returns (bool) {
        base_url = baseUrl;

        return true;
    }

    /**
     * @notice Get token URI
     * @return Current token URI
     */
    function URI() public view returns (string memory) {
        return base_url;
    }

    /**
     * @notice Get _tokenId URI
     * @param _tokenId Token for which we want to get URI
     * @return Token URI
     */
    function tokenURI(uint256 _tokenId) override public view returns (string memory) {
        return string(abi.encodePacked(URI(), Strings.toString(_tokenId)));
    }

    /**
     * @notice Set new token burner. Can be called only by contract owner
     * @param newBurner New burner account
     * @return Whether or not the transaction succeeded
     */
    function setBurner(address newBurner) external onlyOwner returns(bool) {
        burner = newBurner;
        return true;
    }

    /**
     * @notice Set new token burner. Can be called only by contract burner
     * @param tokenId Token to be burned
     * @return Whether or not the transaction succeeded
     */
    function burn(uint256 tokenId) external onlyBurner returns(bool) {
        _burn(tokenId);
        return true;
    } 
    
    /**
     * @notice Checks if token with given id exists
     * @param tokenId Checked token
     * @return Whether or not the token exists
     */
    function exists(uint256 tokenId) external view returns(bool) {
        return ERC721._exists(tokenId);
    }

    /**
     * @notice Checks if operator can perform actions for owner
     * @param owner Tokens owner
     * @param operator Account that want perform actions for owner
     * @return Whether or not the transaction succeeded
     */
    function isApprovedForAll(address owner, address operator)
        override
        public
        view
        returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(owner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"token_url","type":"string"},{"internalType":"address","name":"_proxyRegistryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":true,"internalType":"uint256","name":"start_id","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"count","type":"uint256"}],"name":"Premint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"URI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"isTokenOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"mintTo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"premint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"registerMinterContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newBurner","type":"address"}],"name":"setBurner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseUrl","type":"string"}],"name":"setURI","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c10000000000000000000000000000000000000000000000000000000000000008446976696e69747900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034469760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002e68747470733a2f2f6170692e646976696e69747963656c6c732e636f6d2f6170692f76312f6d657461646174612f000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Divinity
Arg [1] : _symbol (string): Div
Arg [2] : token_url (string): https://api.divinitycells.com/api/v1/metadata/
Arg [3] : _proxyRegistryAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 446976696e697479000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 4469760000000000000000000000000000000000000000000000000000000000
Arg [8] : 000000000000000000000000000000000000000000000000000000000000002e
Arg [9] : 68747470733a2f2f6170692e646976696e69747963656c6c732e636f6d2f6170
Arg [10] : 692f76312f6d657461646174612f000000000000000000000000000000000000

Deployed Bytecode Sourcemap

76499:5664:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29483:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79914:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30428:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31987:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31510:411;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79354:137;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80138:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79619:103;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32737:339;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;78853:270;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33147:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;81066:120;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81355:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30122:239;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29852:208;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44657:103;;;:::i;:::-;;78313:252;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44006:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30597:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32280:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80735:130;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33403:328;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80367:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77967:144;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81715:445;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44915:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29483:305;29585:4;29637:25;29622:40;;;:11;:40;;;;:105;;;;29694:33;29679:48;;;:11;:48;;;;29622:105;:158;;;;29744:36;29768:11;29744:23;:36::i;:::-;29622:158;29602:178;;29483:305;;;:::o;79914:134::-;79981:4;44237:12;:10;:12::i;:::-;44226:23;;:7;:5;:7::i;:::-;:23;;;44218:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;80009:7:::1;79998:8;:18;;;;;;;;;;;;:::i;:::-;;80036:4;80029:11;;79914:134:::0;;;:::o;30428:100::-;30482:13;30515:5;30508:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30428:100;:::o;31987:221::-;32063:7;32091:16;32099:7;32091;:16::i;:::-;32083:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;32176:15;:24;32192:7;32176:24;;;;;;;;;;;;;;;;;;;;;32169:31;;31987:221;;;:::o;31510:411::-;31591:13;31607:23;31622:7;31607:14;:23::i;:::-;31591:39;;31655:5;31649:11;;:2;:11;;;;31641:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;31749:5;31733:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;31758:37;31775:5;31782:12;:10;:12::i;:::-;31758:16;:37::i;:::-;31733:62;31711:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;31892:21;31901:2;31905:7;31892:8;:21::i;:::-;31510:411;;;:::o;79354:137::-;79429:4;44237:12;:10;:12::i;:::-;44226:23;;:7;:5;:7::i;:::-;:23;;;44218:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;79455:6:::1;79445:7;;:16;;;;;;;;;;;;;;;;;;79479:4;79472:11;;79354:137:::0;;;:::o;80138:85::-;80174:13;80207:8;80200:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80138:85;:::o;79619:103::-;79665:7;79692:22;:12;:20;:22::i;:::-;79685:29;;79619:103;:::o;32737:339::-;32932:41;32951:12;:10;:12::i;:::-;32965:7;32932:18;:41::i;:::-;32924:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;33040:28;33050:4;33056:2;33060:7;33040:9;:28::i;:::-;32737:339;;;:::o;78853:270::-;78930:4;77099:7;;;;;;;;;;;77085:21;;:10;:21;;;77077:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;78947:22:::1;78972;:12;:20;:22::i;:::-;78947:47;;79005:49;79023:7;79032:14;79048:5;79005:17;:49::i;:::-;79088:5;79065:12;:19;;;:28;;;;;;;:::i;:::-;;;;;;;;79111:4;79104:11;;;78853:270:::0;;;;:::o;33147:185::-;33285:39;33302:4;33308:2;33312:7;33285:39;;;;;;;;;;;;:16;:39::i;:::-;33147:185;;;:::o;81066:120::-;81125:4;76892:6;;;;;;;;;;;76878:20;;:10;:20;;;76870:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;81142:14:::1;81148:7;81142:5;:14::i;:::-;81174:4;81167:11;;81066:120:::0;;;:::o;81355:110::-;81410:4;81434:23;81449:7;81434:14;:23::i;:::-;81427:30;;81355:110;;;:::o;30122:239::-;30194:7;30214:13;30230:7;:16;30238:7;30230:16;;;;;;;;;;;;;;;;;;;;;30214:32;;30282:1;30265:19;;:5;:19;;;;30257:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;30348:5;30341:12;;;30122:239;;;:::o;29852:208::-;29924:7;29969:1;29952:19;;:5;:19;;;;29944:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;30036:9;:16;30046:5;30036:16;;;;;;;;;;;;;;;;30029:23;;29852:208;;;:::o;44657:103::-;44237:12;:10;:12::i;:::-;44226:23;;:7;:5;:7::i;:::-;:23;;;44218:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;44722:30:::1;44749:1;44722:18;:30::i;:::-;44657:103::o:0;78313:252::-;78376:7;77099;;;;;;;;;;;77085:21;;:10;:21;;;77077:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;78396:22:::1;78421;:12;:20;:22::i;:::-;78396:47;;78454:24;:12;:22;:24::i;:::-;78489:36;78499:9;78510:14;78489:9;:36::i;:::-;78543:14;78536:21;;;78313:252:::0;;;:::o;44006:87::-;44052:7;44079:6;;;;;;;;;;;44072:13;;44006:87;:::o;30597:104::-;30653:13;30686:7;30679:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30597:104;:::o;32280:155::-;32375:52;32394:12;:10;:12::i;:::-;32408:8;32418;32375:18;:52::i;:::-;32280:155;;:::o;80735:130::-;80800:4;44237:12;:10;:12::i;:::-;44226:23;;:7;:5;:7::i;:::-;:23;;;44218:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;80826:9:::1;80817:6;;:18;;;;;;;;;;;;;;;;;;80853:4;80846:11;;80735:130:::0;;;:::o;33403:328::-;33578:41;33597:12;:10;:12::i;:::-;33611:7;33578:18;:41::i;:::-;33570:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;33684:39;33698:4;33704:2;33708:7;33717:5;33684:13;:39::i;:::-;33403:328;;;;:::o;80367:166::-;80433:13;80490:5;:3;:5::i;:::-;80497:26;80514:8;80497:16;:26::i;:::-;80473:51;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80459:66;;80367:166;;;:::o;77967:144::-;78045:4;78096:7;78069:34;;:23;78084:7;78069:14;:23::i;:::-;:34;;;78062:41;;77967:144;;;;:::o;81715:445::-;81840:4;81925:27;81969:20;;;;;;;;;;;81925:65;;82046:8;82005:49;;82013:13;:21;;;82035:5;82013:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;82005:49;;;82001:93;;;82078:4;82071:11;;;;;82001:93;82113:39;82136:5;82143:8;82113:22;:39::i;:::-;82106:46;;;81715:445;;;;;:::o;44915:201::-;44237:12;:10;:12::i;:::-;44226:23;;:7;:5;:7::i;:::-;:23;;;44218:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;45024:1:::1;45004:22;;:8;:22;;;;44996:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;45080:28;45099:8;45080:18;:28::i;:::-;44915:201:::0;:::o;27920:157::-;28005:4;28044:25;28029:40;;;:11;:40;;;;28022:47;;27920:157;;;:::o;24844:98::-;24897:7;24924:10;24917:17;;24844:98;:::o;35241:127::-;35306:4;35358:1;35330:30;;:7;:16;35338:7;35330:16;;;;;;;;;;;;;;;;;;;;;:30;;;;35323:37;;35241:127;;;:::o;39793:174::-;39895:2;39868:15;:24;39884:7;39868:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;39951:7;39947:2;39913:46;;39922:23;39937:7;39922:14;:23::i;:::-;39913:46;;;;;;;;;;;;39793:174;;:::o;7871:114::-;7936:7;7963;:14;;;7956:21;;7871:114;;;:::o;35535:348::-;35628:4;35653:16;35661:7;35653;:16::i;:::-;35645:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;35729:13;35745:23;35760:7;35745:14;:23::i;:::-;35729:39;;35798:5;35787:16;;:7;:16;;;:51;;;;35831:7;35807:31;;:20;35819:7;35807:11;:20::i;:::-;:31;;;35787:51;:87;;;;35842:32;35859:5;35866:7;35842:16;:32::i;:::-;35787:87;35779:96;;;35535:348;;;;:::o;39050:625::-;39209:4;39182:31;;:23;39197:7;39182:14;:23::i;:::-;:31;;;39174:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;39288:1;39274:16;;:2;:16;;;;39266:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;39344:39;39365:4;39371:2;39375:7;39344:20;:39::i;:::-;39448:29;39465:1;39469:7;39448:8;:29::i;:::-;39509:1;39490:9;:15;39500:4;39490:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;39538:1;39521:9;:13;39531:2;39521:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;39569:2;39550:7;:16;39558:7;39550:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;39608:7;39604:2;39589:27;;39598:4;39589:27;;;;;;;;;;;;39629:38;39649:4;39655:2;39659:7;39629:19;:38::i;:::-;39050:625;;;:::o;37666:394::-;37786:1;37772:16;;:2;:16;;;;37764:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;37845:22;37853:13;37845:7;:22::i;:::-;37844:23;37836:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;37911:15;37945:5;37929:13;:21;;;;:::i;:::-;37911:39;;37968:9;37980:13;37968:25;;37963:90;38000:7;37995:1;:12;37963:90;;;38029:12;38035:2;38039:1;38029:5;:12::i;:::-;38009:3;;;;;:::i;:::-;;;;37963:90;;;;37666:394;;;;:::o;38293:420::-;38353:13;38369:23;38384:7;38369:14;:23::i;:::-;38353:39;;38405:48;38426:5;38441:1;38445:7;38405:20;:48::i;:::-;38494:29;38511:1;38515:7;38494:8;:29::i;:::-;38556:1;38536:9;:16;38546:5;38536:16;;;;;;;;;;;;;;;;:21;;;;;;;:::i;:::-;;;;;;;;38575:7;:16;38583:7;38575:16;;;;;;;;;;;;38568:23;;;;;;;;;;;38637:7;38633:1;38609:36;;38618:5;38609:36;;;;;;;;;;;;38658:47;38678:5;38693:1;38697:7;38658:19;:47::i;:::-;38293:420;;:::o;45276:191::-;45350:16;45369:6;;;;;;;;;;;45350:25;;45395:8;45386:6;;:17;;;;;;;;;;;;;;;;;;45450:8;45419:40;;45440:8;45419:40;;;;;;;;;;;;45276:191;;:::o;7993:127::-;8100:1;8082:7;:14;;;:19;;;;;;;;;;;7993:127;:::o;36225:110::-;36301:26;36311:2;36315:7;36301:26;;;;;;;;;;;;:9;:26::i;:::-;36225:110;;:::o;40109:315::-;40264:8;40255:17;;:5;:17;;;;40247:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;40351:8;40313:18;:25;40332:5;40313:25;;;;;;;;;;;;;;;:35;40339:8;40313:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;40397:8;40375:41;;40390:5;40375:41;;;40407:8;40375:41;;;;;;:::i;:::-;;;;;;;;40109:315;;;:::o;34613:::-;34770:28;34780:4;34786:2;34790:7;34770:9;:28::i;:::-;34817:48;34840:4;34846:2;34850:7;34859:5;34817:22;:48::i;:::-;34809:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;34613:315;;;;:::o;25367:723::-;25423:13;25653:1;25644:5;:10;25640:53;;;25671:10;;;;;;;;;;;;;;;;;;;;;25640:53;25703:12;25718:5;25703:20;;25734:14;25759:78;25774:1;25766:4;:9;25759:78;;25792:8;;;;;:::i;:::-;;;;25823:2;25815:10;;;;;:::i;:::-;;;25759:78;;;25847:19;25879:6;25869:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25847:39;;25897:154;25913:1;25904:5;:10;25897:154;;25941:1;25931:11;;;;;:::i;:::-;;;26008:2;26000:5;:10;;;;:::i;:::-;25987:2;:24;;;;:::i;:::-;25974:39;;25957:6;25964;25957:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;26037:2;26028:11;;;;;:::i;:::-;;;25897:154;;;26075:6;26061:21;;;;;25367:723;;;;:::o;32506:164::-;32603:4;32627:18;:25;32646:5;32627:25;;;;;;;;;;;;;;;:35;32653:8;32627:35;;;;;;;;;;;;;;;;;;;;;;;;;32620:42;;32506:164;;;;:::o;42360:126::-;;;;:::o;42871:125::-;;;;:::o;37219:439::-;37313:1;37299:16;;:2;:16;;;;37291:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;37372:16;37380:7;37372;:16::i;:::-;37371:17;37363:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;37434:45;37463:1;37467:2;37471:7;37434:20;:45::i;:::-;37509:1;37492:9;:13;37502:2;37492:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;37540:2;37521:7;:16;37529:7;37521:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;37585:7;37581:2;37560:33;;37577:1;37560:33;;;;;;;;;;;;37606:44;37634:1;37638:2;37642:7;37606:19;:44::i;:::-;37219:439;;:::o;36562:321::-;36692:18;36698:2;36702:7;36692:5;:18::i;:::-;36743:54;36774:1;36778:2;36782:7;36791:5;36743:22;:54::i;:::-;36721:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;36562:321;;;:::o;40989:799::-;41144:4;41165:15;:2;:13;;;:15::i;:::-;41161:620;;;41217:2;41201:36;;;41238:12;:10;:12::i;:::-;41252:4;41258:7;41267:5;41201:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;41197:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41460:1;41443:6;:13;:18;41439:272;;;41486:60;;;;;;;;;;:::i;:::-;;;;;;;;41439:272;41661:6;41655:13;41646:6;41642:2;41638:15;41631:38;41197:529;41334:41;;;41324:51;;;:6;:51;;;;41317:58;;;;;41161:620;41765:4;41758:11;;40989:799;;;;;;;:::o;16951:326::-;17011:4;17268:1;17246:7;:19;;;:23;17239:30;;16951:326;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:343:1:-;;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:2;;;290:1;287;280:12;249:2;303:41;337:6;332:3;327;303:41;:::i;:::-;90:260;;;;;;:::o;356:345::-;;459:66;475:49;517:6;475:49;:::i;:::-;459:66;:::i;:::-;450:75;;548:6;541:5;534:21;586:4;579:5;575:16;624:3;615:6;610:3;606:16;603:25;600:2;;;641:1;638;631:12;600:2;654:41;688:6;683:3;678;654:41;:::i;:::-;440:261;;;;;;:::o;707:139::-;;791:6;778:20;769:29;;807:33;834:5;807:33;:::i;:::-;759:87;;;;:::o;852:133::-;;933:6;920:20;911:29;;949:30;973:5;949:30;:::i;:::-;901:84;;;;:::o;991:137::-;;1074:6;1061:20;1052:29;;1090:32;1116:5;1090:32;:::i;:::-;1042:86;;;;:::o;1134:141::-;;1221:6;1215:13;1206:22;;1237:32;1263:5;1237:32;:::i;:::-;1196:79;;;;:::o;1294:271::-;;1398:3;1391:4;1383:6;1379:17;1375:27;1365:2;;1416:1;1413;1406:12;1365:2;1456:6;1443:20;1481:78;1555:3;1547:6;1540:4;1532:6;1528:17;1481:78;:::i;:::-;1472:87;;1355:210;;;;;:::o;1571:201::-;;1688:6;1682:13;1673:22;;1704:62;1760:5;1704:62;:::i;:::-;1663:109;;;;:::o;1792:273::-;;1897:3;1890:4;1882:6;1878:17;1874:27;1864:2;;1915:1;1912;1905:12;1864:2;1955:6;1942:20;1980:79;2055:3;2047:6;2040:4;2032:6;2028:17;1980:79;:::i;:::-;1971:88;;1854:211;;;;;:::o;2071:139::-;;2155:6;2142:20;2133:29;;2171:33;2198:5;2171:33;:::i;:::-;2123:87;;;;:::o;2216:262::-;;2324:2;2312:9;2303:7;2299:23;2295:32;2292:2;;;2340:1;2337;2330:12;2292:2;2383:1;2408:53;2453:7;2444:6;2433:9;2429:22;2408:53;:::i;:::-;2398:63;;2354:117;2282:196;;;;:::o;2484:407::-;;;2609:2;2597:9;2588:7;2584:23;2580:32;2577:2;;;2625:1;2622;2615:12;2577:2;2668:1;2693:53;2738:7;2729:6;2718:9;2714:22;2693:53;:::i;:::-;2683:63;;2639:117;2795:2;2821:53;2866:7;2857:6;2846:9;2842:22;2821:53;:::i;:::-;2811:63;;2766:118;2567:324;;;;;:::o;2897:552::-;;;;3039:2;3027:9;3018:7;3014:23;3010:32;3007:2;;;3055:1;3052;3045:12;3007:2;3098:1;3123:53;3168:7;3159:6;3148:9;3144:22;3123:53;:::i;:::-;3113:63;;3069:117;3225:2;3251:53;3296:7;3287:6;3276:9;3272:22;3251:53;:::i;:::-;3241:63;;3196:118;3353:2;3379:53;3424:7;3415:6;3404:9;3400:22;3379:53;:::i;:::-;3369:63;;3324:118;2997:452;;;;;:::o;3455:809::-;;;;;3623:3;3611:9;3602:7;3598:23;3594:33;3591:2;;;3640:1;3637;3630:12;3591:2;3683:1;3708:53;3753:7;3744:6;3733:9;3729:22;3708:53;:::i;:::-;3698:63;;3654:117;3810:2;3836:53;3881:7;3872:6;3861:9;3857:22;3836:53;:::i;:::-;3826:63;;3781:118;3938:2;3964:53;4009:7;4000:6;3989:9;3985:22;3964:53;:::i;:::-;3954:63;;3909:118;4094:2;4083:9;4079:18;4066:32;4125:18;4117:6;4114:30;4111:2;;;4157:1;4154;4147:12;4111:2;4185:62;4239:7;4230:6;4219:9;4215:22;4185:62;:::i;:::-;4175:72;;4037:220;3581:683;;;;;;;:::o;4270:401::-;;;4392:2;4380:9;4371:7;4367:23;4363:32;4360:2;;;4408:1;4405;4398:12;4360:2;4451:1;4476:53;4521:7;4512:6;4501:9;4497:22;4476:53;:::i;:::-;4466:63;;4422:117;4578:2;4604:50;4646:7;4637:6;4626:9;4622:22;4604:50;:::i;:::-;4594:60;;4549:115;4350:321;;;;;:::o;4677:407::-;;;4802:2;4790:9;4781:7;4777:23;4773:32;4770:2;;;4818:1;4815;4808:12;4770:2;4861:1;4886:53;4931:7;4922:6;4911:9;4907:22;4886:53;:::i;:::-;4876:63;;4832:117;4988:2;5014:53;5059:7;5050:6;5039:9;5035:22;5014:53;:::i;:::-;5004:63;;4959:118;4760:324;;;;;:::o;5090:260::-;;5197:2;5185:9;5176:7;5172:23;5168:32;5165:2;;;5213:1;5210;5203:12;5165:2;5256:1;5281:52;5325:7;5316:6;5305:9;5301:22;5281:52;:::i;:::-;5271:62;;5227:116;5155:195;;;;:::o;5356:282::-;;5474:2;5462:9;5453:7;5449:23;5445:32;5442:2;;;5490:1;5487;5480:12;5442:2;5533:1;5558:63;5613:7;5604:6;5593:9;5589:22;5558:63;:::i;:::-;5548:73;;5504:127;5432:206;;;;:::o;5644:342::-;;5792:2;5780:9;5771:7;5767:23;5763:32;5760:2;;;5808:1;5805;5798:12;5760:2;5851:1;5876:93;5961:7;5952:6;5941:9;5937:22;5876:93;:::i;:::-;5866:103;;5822:157;5750:236;;;;:::o;5992:375::-;;6110:2;6098:9;6089:7;6085:23;6081:32;6078:2;;;6126:1;6123;6116:12;6078:2;6197:1;6186:9;6182:17;6169:31;6227:18;6219:6;6216:30;6213:2;;;6259:1;6256;6249:12;6213:2;6287:63;6342:7;6333:6;6322:9;6318:22;6287:63;:::i;:::-;6277:73;;6140:220;6068:299;;;;:::o;6373:262::-;;6481:2;6469:9;6460:7;6456:23;6452:32;6449:2;;;6497:1;6494;6487:12;6449:2;6540:1;6565:53;6610:7;6601:6;6590:9;6586:22;6565:53;:::i;:::-;6555:63;;6511:117;6439:196;;;;:::o;6641:407::-;;;6766:2;6754:9;6745:7;6741:23;6737:32;6734:2;;;6782:1;6779;6772:12;6734:2;6825:1;6850:53;6895:7;6886:6;6875:9;6871:22;6850:53;:::i;:::-;6840:63;;6796:117;6952:2;6978:53;7023:7;7014:6;7003:9;6999:22;6978:53;:::i;:::-;6968:63;;6923:118;6724:324;;;;;:::o;7054:118::-;7141:24;7159:5;7141:24;:::i;:::-;7136:3;7129:37;7119:53;;:::o;7178:109::-;7259:21;7274:5;7259:21;:::i;:::-;7254:3;7247:34;7237:50;;:::o;7293:360::-;;7407:38;7439:5;7407:38;:::i;:::-;7461:70;7524:6;7519:3;7461:70;:::i;:::-;7454:77;;7540:52;7585:6;7580:3;7573:4;7566:5;7562:16;7540:52;:::i;:::-;7617:29;7639:6;7617:29;:::i;:::-;7612:3;7608:39;7601:46;;7383:270;;;;;:::o;7659:364::-;;7775:39;7808:5;7775:39;:::i;:::-;7830:71;7894:6;7889:3;7830:71;:::i;:::-;7823:78;;7910:52;7955:6;7950:3;7943:4;7936:5;7932:16;7910:52;:::i;:::-;7987:29;8009:6;7987:29;:::i;:::-;7982:3;7978:39;7971:46;;7751:272;;;;;:::o;8029:377::-;;8163:39;8196:5;8163:39;:::i;:::-;8218:89;8300:6;8295:3;8218:89;:::i;:::-;8211:96;;8316:52;8361:6;8356:3;8349:4;8342:5;8338:16;8316:52;:::i;:::-;8393:6;8388:3;8384:16;8377:23;;8139:267;;;;;:::o;8412:366::-;;8575:67;8639:2;8634:3;8575:67;:::i;:::-;8568:74;;8651:93;8740:3;8651:93;:::i;:::-;8769:2;8764:3;8760:12;8753:19;;8558:220;;;:::o;8784:366::-;;8947:67;9011:2;9006:3;8947:67;:::i;:::-;8940:74;;9023:93;9112:3;9023:93;:::i;:::-;9141:2;9136:3;9132:12;9125:19;;8930:220;;;:::o;9156:366::-;;9319:67;9383:2;9378:3;9319:67;:::i;:::-;9312:74;;9395:93;9484:3;9395:93;:::i;:::-;9513:2;9508:3;9504:12;9497:19;;9302:220;;;:::o;9528:366::-;;9691:67;9755:2;9750:3;9691:67;:::i;:::-;9684:74;;9767:93;9856:3;9767:93;:::i;:::-;9885:2;9880:3;9876:12;9869:19;;9674:220;;;:::o;9900:366::-;;10063:67;10127:2;10122:3;10063:67;:::i;:::-;10056:74;;10139:93;10228:3;10139:93;:::i;:::-;10257:2;10252:3;10248:12;10241:19;;10046:220;;;:::o;10272:366::-;;10435:67;10499:2;10494:3;10435:67;:::i;:::-;10428:74;;10511:93;10600:3;10511:93;:::i;:::-;10629:2;10624:3;10620:12;10613:19;;10418:220;;;:::o;10644:366::-;;10807:67;10871:2;10866:3;10807:67;:::i;:::-;10800:74;;10883:93;10972:3;10883:93;:::i;:::-;11001:2;10996:3;10992:12;10985:19;;10790:220;;;:::o;11016:366::-;;11179:67;11243:2;11238:3;11179:67;:::i;:::-;11172:74;;11255:93;11344:3;11255:93;:::i;:::-;11373:2;11368:3;11364:12;11357:19;;11162:220;;;:::o;11388:366::-;;11551:67;11615:2;11610:3;11551:67;:::i;:::-;11544:74;;11627:93;11716:3;11627:93;:::i;:::-;11745:2;11740:3;11736:12;11729:19;;11534:220;;;:::o;11760:366::-;;11923:67;11987:2;11982:3;11923:67;:::i;:::-;11916:74;;11999:93;12088:3;11999:93;:::i;:::-;12117:2;12112:3;12108:12;12101:19;;11906:220;;;:::o;12132:366::-;;12295:67;12359:2;12354:3;12295:67;:::i;:::-;12288:74;;12371:93;12460:3;12371:93;:::i;:::-;12489:2;12484:3;12480:12;12473:19;;12278:220;;;:::o;12504:366::-;;12667:67;12731:2;12726:3;12667:67;:::i;:::-;12660:74;;12743:93;12832:3;12743:93;:::i;:::-;12861:2;12856:3;12852:12;12845:19;;12650:220;;;:::o;12876:366::-;;13039:67;13103:2;13098:3;13039:67;:::i;:::-;13032:74;;13115:93;13204:3;13115:93;:::i;:::-;13233:2;13228:3;13224:12;13217:19;;13022:220;;;:::o;13248:366::-;;13411:67;13475:2;13470:3;13411:67;:::i;:::-;13404:74;;13487:93;13576:3;13487:93;:::i;:::-;13605:2;13600:3;13596:12;13589:19;;13394:220;;;:::o;13620:366::-;;13783:67;13847:2;13842:3;13783:67;:::i;:::-;13776:74;;13859:93;13948:3;13859:93;:::i;:::-;13977:2;13972:3;13968:12;13961:19;;13766:220;;;:::o;13992:366::-;;14155:67;14219:2;14214:3;14155:67;:::i;:::-;14148:74;;14231:93;14320:3;14231:93;:::i;:::-;14349:2;14344:3;14340:12;14333:19;;14138:220;;;:::o;14364:366::-;;14527:67;14591:2;14586:3;14527:67;:::i;:::-;14520:74;;14603:93;14692:3;14603:93;:::i;:::-;14721:2;14716:3;14712:12;14705:19;;14510:220;;;:::o;14736:118::-;14823:24;14841:5;14823:24;:::i;:::-;14818:3;14811:37;14801:53;;:::o;14860:435::-;;15062:95;15153:3;15144:6;15062:95;:::i;:::-;15055:102;;15174:95;15265:3;15256:6;15174:95;:::i;:::-;15167:102;;15286:3;15279:10;;15044:251;;;;;:::o;15301:222::-;;15432:2;15421:9;15417:18;15409:26;;15445:71;15513:1;15502:9;15498:17;15489:6;15445:71;:::i;:::-;15399:124;;;;:::o;15529:640::-;;15762:3;15751:9;15747:19;15739:27;;15776:71;15844:1;15833:9;15829:17;15820:6;15776:71;:::i;:::-;15857:72;15925:2;15914:9;15910:18;15901:6;15857:72;:::i;:::-;15939;16007:2;15996:9;15992:18;15983:6;15939:72;:::i;:::-;16058:9;16052:4;16048:20;16043:2;16032:9;16028:18;16021:48;16086:76;16157:4;16148:6;16086:76;:::i;:::-;16078:84;;15729:440;;;;;;;:::o;16175:210::-;;16300:2;16289:9;16285:18;16277:26;;16313:65;16375:1;16364:9;16360:17;16351:6;16313:65;:::i;:::-;16267:118;;;;:::o;16391:313::-;;16542:2;16531:9;16527:18;16519:26;;16591:9;16585:4;16581:20;16577:1;16566:9;16562:17;16555:47;16619:78;16692:4;16683:6;16619:78;:::i;:::-;16611:86;;16509:195;;;;:::o;16710:419::-;;16914:2;16903:9;16899:18;16891:26;;16963:9;16957:4;16953:20;16949:1;16938:9;16934:17;16927:47;16991:131;17117:4;16991:131;:::i;:::-;16983:139;;16881:248;;;:::o;17135:419::-;;17339:2;17328:9;17324:18;17316:26;;17388:9;17382:4;17378:20;17374:1;17363:9;17359:17;17352:47;17416:131;17542:4;17416:131;:::i;:::-;17408:139;;17306:248;;;:::o;17560:419::-;;17764:2;17753:9;17749:18;17741:26;;17813:9;17807:4;17803:20;17799:1;17788:9;17784:17;17777:47;17841:131;17967:4;17841:131;:::i;:::-;17833:139;;17731:248;;;:::o;17985:419::-;;18189:2;18178:9;18174:18;18166:26;;18238:9;18232:4;18228:20;18224:1;18213:9;18209:17;18202:47;18266:131;18392:4;18266:131;:::i;:::-;18258:139;;18156:248;;;:::o;18410:419::-;;18614:2;18603:9;18599:18;18591:26;;18663:9;18657:4;18653:20;18649:1;18638:9;18634:17;18627:47;18691:131;18817:4;18691:131;:::i;:::-;18683:139;;18581:248;;;:::o;18835:419::-;;19039:2;19028:9;19024:18;19016:26;;19088:9;19082:4;19078:20;19074:1;19063:9;19059:17;19052:47;19116:131;19242:4;19116:131;:::i;:::-;19108:139;;19006:248;;;:::o;19260:419::-;;19464:2;19453:9;19449:18;19441:26;;19513:9;19507:4;19503:20;19499:1;19488:9;19484:17;19477:47;19541:131;19667:4;19541:131;:::i;:::-;19533:139;;19431:248;;;:::o;19685:419::-;;19889:2;19878:9;19874:18;19866:26;;19938:9;19932:4;19928:20;19924:1;19913:9;19909:17;19902:47;19966:131;20092:4;19966:131;:::i;:::-;19958:139;;19856:248;;;:::o;20110:419::-;;20314:2;20303:9;20299:18;20291:26;;20363:9;20357:4;20353:20;20349:1;20338:9;20334:17;20327:47;20391:131;20517:4;20391:131;:::i;:::-;20383:139;;20281:248;;;:::o;20535:419::-;;20739:2;20728:9;20724:18;20716:26;;20788:9;20782:4;20778:20;20774:1;20763:9;20759:17;20752:47;20816:131;20942:4;20816:131;:::i;:::-;20808:139;;20706:248;;;:::o;20960:419::-;;21164:2;21153:9;21149:18;21141:26;;21213:9;21207:4;21203:20;21199:1;21188:9;21184:17;21177:47;21241:131;21367:4;21241:131;:::i;:::-;21233:139;;21131:248;;;:::o;21385:419::-;;21589:2;21578:9;21574:18;21566:26;;21638:9;21632:4;21628:20;21624:1;21613:9;21609:17;21602:47;21666:131;21792:4;21666:131;:::i;:::-;21658:139;;21556:248;;;:::o;21810:419::-;;22014:2;22003:9;21999:18;21991:26;;22063:9;22057:4;22053:20;22049:1;22038:9;22034:17;22027:47;22091:131;22217:4;22091:131;:::i;:::-;22083:139;;21981:248;;;:::o;22235:419::-;;22439:2;22428:9;22424:18;22416:26;;22488:9;22482:4;22478:20;22474:1;22463:9;22459:17;22452:47;22516:131;22642:4;22516:131;:::i;:::-;22508:139;;22406:248;;;:::o;22660:419::-;;22864:2;22853:9;22849:18;22841:26;;22913:9;22907:4;22903:20;22899:1;22888:9;22884:17;22877:47;22941:131;23067:4;22941:131;:::i;:::-;22933:139;;22831:248;;;:::o;23085:419::-;;23289:2;23278:9;23274:18;23266:26;;23338:9;23332:4;23328:20;23324:1;23313:9;23309:17;23302:47;23366:131;23492:4;23366:131;:::i;:::-;23358:139;;23256:248;;;:::o;23510:419::-;;23714:2;23703:9;23699:18;23691:26;;23763:9;23757:4;23753:20;23749:1;23738:9;23734:17;23727:47;23791:131;23917:4;23791:131;:::i;:::-;23783:139;;23681:248;;;:::o;23935:222::-;;24066:2;24055:9;24051:18;24043:26;;24079:71;24147:1;24136:9;24132:17;24123:6;24079:71;:::i;:::-;24033:124;;;;:::o;24163:129::-;;24224:20;;:::i;:::-;24214:30;;24253:33;24281:4;24273:6;24253:33;:::i;:::-;24204:88;;;:::o;24298:75::-;;24364:2;24358:9;24348:19;;24338:35;:::o;24379:307::-;;24530:18;24522:6;24519:30;24516:2;;;24552:18;;:::i;:::-;24516:2;24590:29;24612:6;24590:29;:::i;:::-;24582:37;;24674:4;24668;24664:15;24656:23;;24445:241;;;:::o;24692:308::-;;24844:18;24836:6;24833:30;24830:2;;;24866:18;;:::i;:::-;24830:2;24904:29;24926:6;24904:29;:::i;:::-;24896:37;;24988:4;24982;24978:15;24970:23;;24759:241;;;:::o;25006:98::-;;25091:5;25085:12;25075:22;;25064:40;;;:::o;25110:99::-;;25196:5;25190:12;25180:22;;25169:40;;;:::o;25215:168::-;;25332:6;25327:3;25320:19;25372:4;25367:3;25363:14;25348:29;;25310:73;;;;:::o;25389:169::-;;25507:6;25502:3;25495:19;25547:4;25542:3;25538:14;25523:29;;25485:73;;;;:::o;25564:148::-;;25703:3;25688:18;;25678:34;;;;:::o;25718:305::-;;25777:20;25795:1;25777:20;:::i;:::-;25772:25;;25811:20;25829:1;25811:20;:::i;:::-;25806:25;;25965:1;25897:66;25893:74;25890:1;25887:81;25884:2;;;25971:18;;:::i;:::-;25884:2;26015:1;26012;26008:9;26001:16;;25762:261;;;;:::o;26029:185::-;;26086:20;26104:1;26086:20;:::i;:::-;26081:25;;26120:20;26138:1;26120:20;:::i;:::-;26115:25;;26159:1;26149:2;;26164:18;;:::i;:::-;26149:2;26206:1;26203;26199:9;26194:14;;26071:143;;;;:::o;26220:191::-;;26280:20;26298:1;26280:20;:::i;:::-;26275:25;;26314:20;26332:1;26314:20;:::i;:::-;26309:25;;26353:1;26350;26347:8;26344:2;;;26358:18;;:::i;:::-;26344:2;26403:1;26400;26396:9;26388:17;;26265:146;;;;:::o;26417:96::-;;26483:24;26501:5;26483:24;:::i;:::-;26472:35;;26462:51;;;:::o;26519:90::-;;26596:5;26589:13;26582:21;26571:32;;26561:48;;;:::o;26615:149::-;;26691:66;26684:5;26680:78;26669:89;;26659:105;;;:::o;26770:125::-;;26865:24;26883:5;26865:24;:::i;:::-;26854:35;;26844:51;;;:::o;26901:126::-;;26978:42;26971:5;26967:54;26956:65;;26946:81;;;:::o;27033:77::-;;27099:5;27088:16;;27078:32;;;:::o;27116:154::-;27200:6;27195:3;27190;27177:30;27262:1;27253:6;27248:3;27244:16;27237:27;27167:103;;;:::o;27276:307::-;27344:1;27354:113;27368:6;27365:1;27362:13;27354:113;;;27453:1;27448:3;27444:11;27438:18;27434:1;27429:3;27425:11;27418:39;27390:2;27387:1;27383:10;27378:15;;27354:113;;;27485:6;27482:1;27479:13;27476:2;;;27565:1;27556:6;27551:3;27547:16;27540:27;27476:2;27325:258;;;;:::o;27589:320::-;;27670:1;27664:4;27660:12;27650:22;;27717:1;27711:4;27707:12;27738:18;27728:2;;27794:4;27786:6;27782:17;27772:27;;27728:2;27856;27848:6;27845:14;27825:18;27822:38;27819:2;;;27875:18;;:::i;:::-;27819:2;27640:269;;;;:::o;27915:281::-;27998:27;28020:4;27998:27;:::i;:::-;27990:6;27986:40;28128:6;28116:10;28113:22;28092:18;28080:10;28077:34;28074:62;28071:2;;;28139:18;;:::i;:::-;28071:2;28179:10;28175:2;28168:22;27958:238;;;:::o;28202:233::-;;28264:24;28282:5;28264:24;:::i;:::-;28255:33;;28310:66;28303:5;28300:77;28297:2;;;28380:18;;:::i;:::-;28297:2;28427:1;28420:5;28416:13;28409:20;;28245:190;;;:::o;28441:176::-;;28490:20;28508:1;28490:20;:::i;:::-;28485:25;;28524:20;28542:1;28524:20;:::i;:::-;28519:25;;28563:1;28553:2;;28568:18;;:::i;:::-;28553:2;28609:1;28606;28602:9;28597:14;;28475:142;;;;:::o;28623:180::-;28671:77;28668:1;28661:88;28768:4;28765:1;28758:15;28792:4;28789:1;28782:15;28809:180;28857:77;28854:1;28847:88;28954:4;28951:1;28944:15;28978:4;28975:1;28968:15;28995:180;29043:77;29040:1;29033:88;29140:4;29137:1;29130:15;29164:4;29161:1;29154:15;29181:180;29229:77;29226:1;29219:88;29326:4;29323:1;29316:15;29350:4;29347:1;29340:15;29367:102;;29459:2;29455:7;29450:2;29443:5;29439:14;29435:28;29425:38;;29415:54;;;:::o;29475:237::-;29615:34;29611:1;29603:6;29599:14;29592:58;29684:20;29679:2;29671:6;29667:15;29660:45;29581:131;:::o;29718:225::-;29858:34;29854:1;29846:6;29842:14;29835:58;29927:8;29922:2;29914:6;29910:15;29903:33;29824:119;:::o;29949:224::-;30089:34;30085:1;30077:6;30073:14;30066:58;30158:7;30153:2;30145:6;30141:15;30134:32;30055:118;:::o;30179:178::-;30319:30;30315:1;30307:6;30303:14;30296:54;30285:72;:::o;30363:223::-;30503:34;30499:1;30491:6;30487:14;30480:58;30572:6;30567:2;30559:6;30555:15;30548:31;30469:117;:::o;30592:175::-;30732:27;30728:1;30720:6;30716:14;30709:51;30698:69;:::o;30773:225::-;30913:34;30909:1;30901:6;30897:14;30890:58;30982:8;30977:2;30969:6;30965:15;30958:33;30879:119;:::o;31004:231::-;31144:34;31140:1;31132:6;31128:14;31121:58;31213:14;31208:2;31200:6;31196:15;31189:39;31110:125;:::o;31241:243::-;31381:34;31377:1;31369:6;31365:14;31358:58;31450:26;31445:2;31437:6;31433:15;31426:51;31347:137;:::o;31490:229::-;31630:34;31626:1;31618:6;31614:14;31607:58;31699:12;31694:2;31686:6;31682:15;31675:37;31596:123;:::o;31725:228::-;31865:34;31861:1;31853:6;31849:14;31842:58;31934:11;31929:2;31921:6;31917:15;31910:36;31831:122;:::o;31959:182::-;32099:34;32095:1;32087:6;32083:14;32076:58;32065:76;:::o;32147:231::-;32287:34;32283:1;32275:6;32271:14;32264:58;32356:14;32351:2;32343:6;32339:15;32332:39;32253:125;:::o;32384:182::-;32524:34;32520:1;32512:6;32508:14;32501:58;32490:76;:::o;32572:220::-;32712:34;32708:1;32700:6;32696:14;32689:58;32781:3;32776:2;32768:6;32764:15;32757:28;32678:114;:::o;32798:236::-;32938:34;32934:1;32926:6;32922:14;32915:58;33007:19;33002:2;32994:6;32990:15;32983:44;32904:130;:::o;33040:232::-;33180:34;33176:1;33168:6;33164:14;33157:58;33249:15;33244:2;33236:6;33232:15;33225:40;33146:126;:::o;33278:122::-;33351:24;33369:5;33351:24;:::i;:::-;33344:5;33341:35;33331:2;;33390:1;33387;33380:12;33331:2;33321:79;:::o;33406:116::-;33476:21;33491:5;33476:21;:::i;:::-;33469:5;33466:32;33456:2;;33512:1;33509;33502:12;33456:2;33446:76;:::o;33528:120::-;33600:23;33617:5;33600:23;:::i;:::-;33593:5;33590:34;33580:2;;33638:1;33635;33628:12;33580:2;33570:78;:::o;33654:180::-;33756:53;33803:5;33756:53;:::i;:::-;33749:5;33746:64;33736:2;;33824:1;33821;33814:12;33736:2;33726:108;:::o;33840:122::-;33913:24;33931:5;33913:24;:::i;:::-;33906:5;33903:35;33893:2;;33952:1;33949;33942:12;33893:2;33883:79;:::o

Swarm Source

ipfs://51fd98d26b69cb5458d1e052f1f2e76f0cbe184ac0479b0b985950e6b48be768

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