Token

(0xaf488234796ca27dba8ecf17f803ea1f4ab33e15)

This token is reported to have been spammed to a large number of addresses. Please treat it with caution.

ERC-721

Overview

Max Total Supply

169 ERC-721 TOKEN*

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xaf488234796ca27dba8ecf17f803ea1f4ab33e15

Filtered by Token Holder

0xA8DEFb2E1fe760f02f39E3D07A2BA0605fD8eb28

shiroi.eth

Balance

0 ERC-721 TOKEN*

0xa8defb2e1fe760f02f39e3d07a2ba0605fd8eb28

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Blockmon

Compiler Version

v0.6.2+commit.bacdbe57

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, GNU AGPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-10-16
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

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

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

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

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

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

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

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

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

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;


/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. 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;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    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 {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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 GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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.
 */
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 () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;


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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;


/**
 * @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/token/ERC721/IERC721Enumerable.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;


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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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/introspection/ERC165.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;


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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // 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(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(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(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(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

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

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

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

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

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

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

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

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

            MapEntry storage lastEntry = map._entries[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        return _get(map, key, "EnumerableMap: nonexistent key");
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
    }
}

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;












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

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Base URI
    string private _baseURI;

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

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

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

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

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

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

        return _holderTokens[owner].length();
    }

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

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

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

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

        string memory _tokenURI = _tokenURIs[tokenId];

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

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

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

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = 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 override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view 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 returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

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

// File: contracts/INFTStaker.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface INFTStaker is IERC165 {

  struct Reward {
    address minter;
    uint256 amount;
    uint256 startBlock;
    uint256 endBlock;
    bool isStaked;
  }

  function rewardRecords(uint256 id) external view returns (address, uint256, uint256, uint256, bool);

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

  /**
    * @dev Burns `tokenId`. See {ERC721-_burn}.
    *
    * Requirements:
    *
    * - The caller must own `tokenId` or be an approved operator.
    */
  function burn(uint256 tokenId) external; 
}

// File: contracts/Blockmon.sol

pragma solidity ^0.6.1;







contract Blockmon is ERC721, Ownable {

  using SafeERC20 for IERC20;
  using Counters for Counters.Counter;

  Counters.Counter private _rewardIds;

  string public _contractURI;

  IERC20 public token;
  INFTStaker public nft;

  // number of created mons (not counting merges)
  uint256 public numMonsCreated;

  // tinkerable variables
  uint256 public minStakeTime;
  uint256 public minStakeAmt;
  uint256 public tokenPrice;
  uint256 public series;
  uint256 public maxMons;
  uint256 public mergePrice;
  uint256 public mergeTime;
  uint256 public genMergeLag;

  bool public canMerge;

  struct Mon {
    address miner;
    uint256 unlockBlock;
    uint256 parent1;
    uint256 parent2;
    uint256 gen;
    uint256 amount;
    uint256 duration;
    uint256 powerBits;
    uint256 series;
  }
  mapping(uint256 => Mon) public monRecords;

  constructor(string memory name, 
              string memory symbol) ERC721(name, symbol) public {
    minStakeAmt = 1;
    minStakeTime = 10000;
    tokenPrice = 1e18;
  }

  function _createNewMonster(address to,
                             uint256 unlockBlock,
                             uint256 parent1,
                             uint256 parent2,
                             uint256 gen,
                             uint256 amount, 
                             uint256 duration
                             // series is a global variable so no need to pass it in
                             ) private {
    _rewardIds.increment();
    uint256 currId = _rewardIds.current();
    monRecords[currId] = Mon(
      to,
      unlockBlock,
      parent1,
      parent2,
      gen,
      amount,
      duration,
      uint256(blockhash(block.number-1))+amount+duration,
      series
    );
    _safeMint(to, currId);
  }

  // Burn gem to get a new monster
  function mineMonster(uint256 gemId) public {
    require(nft.ownerOf(gemId) == msg.sender, "must use nft you own");

    (, uint256 amount, uint256 start, uint256 end, ) = nft.rewardRecords(gemId);
    if (end == 0) {
      end = block.number;
    }

    require((end-start) >= minStakeTime, "nft is not ready");
    require(amount >= minStakeAmt, "staked amt is not high enough");
    require(numMonsCreated < maxMons, "no new mons out yet");

    _createNewMonster(msg.sender,
                      0,
                      0,
                      0,
                      0,
                      amount, 
                      end-start);
    numMonsCreated += 1;
    nft.burn(gemId);
  }

  // Directly purchase monster with the set token
  function buyMonster() public {
    require(numMonsCreated < maxMons, "no new mons out yet");
    token.safeTransferFrom(msg.sender, address(this), tokenPrice);
    _createNewMonster(msg.sender,
                      0,
                      0,
                      0,
                      0,
                      0, 
                      0);
    numMonsCreated += 1;
  }
 
  // Breed a monster
  // Only allowed during certain times
  function mergeMonsters(uint256 id1, uint256 id2) public {
    require(canMerge == true, "can't merge yet");
    require(id1 != id2, "can't merge the same monster");

    // get refs to structs
    Mon memory mon1 = monRecords[id1];
    Mon memory mon2 = monRecords[id2];

    // ensure they are valid for merging
    require(mon1.unlockBlock < block.number, "not ready yet");
    require(mon2.unlockBlock < block.number, "not ready yet");
    require(ownerOf(id1) == msg.sender, "need to own monster");
    require(ownerOf(id2) == msg.sender, "need to own monster");

    // set both parent monsters to the new unlock date
    monRecords[id1].unlockBlock = block.number + mergeTime + mon1.gen*genMergeLag;
    monRecords[id2].unlockBlock = block.number + mergeTime + mon2.gen*genMergeLag;

    // set numAncestors1 to be the minimum of both
    uint256 gen1 = mon1.gen;
    uint256 gen2 = mon2.gen;
    if (gen2 < gen1) {
      gen1 = gen2;
    }

    // mint the user their merged monster
    _createNewMonster(
      msg.sender,
      block.number + mergeTime + gen1*genMergeLag,
      id1,
      id2,
      gen1+1,
      mon1.amount + mon2.amount,
      mon1.duration + mon2.duration
    );

    // Pay the merge fee
    token.safeTransferFrom(msg.sender, address(this), mergePrice);
  }

  function setMinStakeAmt(uint256 a) public onlyOwner {
    minStakeAmt = a;
  }

  function setMinStakeTime(uint256 t) public onlyOwner {
    minStakeTime = t;
  }

  function setTokenPrice(uint256 p) public onlyOwner {
    tokenPrice = p;
  }

  function setSeries(uint256 s) public onlyOwner {
    series = s;
  }

  function setMaxMons(uint256 m) public onlyOwner {
    maxMons = m;
  }

  function setMergePrice(uint256 p) public onlyOwner {
    mergePrice = p;
  }

  function setMergeTime(uint256 t) public onlyOwner {
    mergeTime = t;
  }

  function setGenMergeLag(uint256 g) public onlyOwner {
    genMergeLag = g;
  }

  function setCanMerge(bool b) public onlyOwner{
    canMerge = b;
  }

  function setTokenAddress(address tokenAddress) public onlyOwner {
    token = IERC20(tokenAddress);
  }

  function setNFTAddress(address nftAddress) public onlyOwner {
    nft = INFTStaker(nftAddress);
  }

  function setBaseURI(string memory uri) public onlyOwner {
    _setBaseURI(uri);
  }

  function setContractURI(string memory uri) public onlyOwner {
    _contractURI = uri;
  }

  function moveTokens(address tokenAddress, address to, uint256 numTokens) public onlyOwner {
    IERC20 _token = IERC20(tokenAddress);
    _token.safeTransfer(to, numTokens);
  }

  function contractURI() public view returns (string memory) {
    return _contractURI;
  }

  function getTotalMons() public view returns (uint256) {
    return _rewardIds.current();
  }
}

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"}],"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":"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":"_contractURI","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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyMonster","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"canMerge","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"genMergeLag","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalMons","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"maxMons","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id1","type":"uint256"},{"internalType":"uint256","name":"id2","type":"uint256"}],"name":"mergeMonsters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mergePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mergeTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minStakeAmt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minStakeTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"gemId","type":"uint256"}],"name":"mineMonster","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"monRecords","outputs":[{"internalType":"address","name":"miner","type":"address"},{"internalType":"uint256","name":"unlockBlock","type":"uint256"},{"internalType":"uint256","name":"parent1","type":"uint256"},{"internalType":"uint256","name":"parent2","type":"uint256"},{"internalType":"uint256","name":"gen","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint256","name":"powerBits","type":"uint256"},{"internalType":"uint256","name":"series","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"numTokens","type":"uint256"}],"name":"moveTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"contract INFTStaker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numMonsCreated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[],"name":"series","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"b","type":"bool"}],"name":"setCanMerge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"g","type":"uint256"}],"name":"setGenMergeLag","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"m","type":"uint256"}],"name":"setMaxMons","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"p","type":"uint256"}],"name":"setMergePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"t","type":"uint256"}],"name":"setMergeTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"}],"name":"setMinStakeAmt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"t","type":"uint256"}],"name":"setMinStakeTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"nftAddress","type":"address"}],"name":"setNFTAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"s","type":"uint256"}],"name":"setSeries","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"setTokenAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"p","type":"uint256"}],"name":"setTokenPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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)

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000530786d6f6e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034d4f4e0000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): 0xmon
Arg [1] : symbol (string): MON

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 30786d6f6e000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [5] : 4d4f4e0000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

72840:5972:0:-:0;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;72840:5972:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32344:142;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;32344:142:0;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;55131:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;55131:92:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57818:213;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;57818:213:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;73374:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;57362:390;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;57362:390:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;73135:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;56856:203;;;:::i;:::-;;;;;;;;;;;;;;;;;;;73198:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;73436:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;58692:305;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;58692:305:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77620:72;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77620:72:0;;;;;;;;;;;;;;;;;:::i;:::-;;78026:105;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;78026:105:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;74727:714;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;74727:714:0;;;;;;;;;;;;;;;;;:::i;:::-;;77698:78;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77698:78:0;;;;;;;;;;;;;;;;;:::i;:::-;;77864:80;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77864:80:0;;;;;;;;;;;;;;;;;:::i;:::-;;56626:154;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;56626:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;78715:94;;;:::i;:::-;;;;;;;;;;;;;;;;;;;77782:76;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77782:76:0;;;;;;;;;;;;;;;;;:::i;:::-;;73403:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59068:151;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;59068:151:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;73056:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;73230:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;73344:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;57136:164;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;57136:164:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;77544:70;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77544:70:0;;;;;;;;;;;;;;;;;:::i;:::-;;78244:85;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;78244:85:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;78244:85:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;78244:85:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;78244:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;78244:85:0;;;;;;;;;;;;;;;:::i;:::-;;54895:169;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;54895:169:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;75952:1328;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;75952:1328:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;78137:101;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;78137:101:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;77460:78;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77460:78:0;;;;;;;;;;;;;;;;;:::i;:::-;;56453:89;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;56453:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78432:180;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;78432:180:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54618:215;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;54618:215:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22444:148;;;:::i;:::-;;73261:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21802:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;75498:385;;;:::i;:::-;;78335:91;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;78335:91:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;78335:91:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;78335:91:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;78335:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;78335:91:0;;;;;;;;;;;;;;;:::i;:::-;;55292:96;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;55292:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58103:295;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;58103:295:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77286:80;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77286:80:0;;;;;;;;;;;;;;;;;:::i;:::-;;73317:22;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59290:285;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;59290:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;59290:285:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;59290:285:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;59290:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;59290:285:0;;;;;;;;;;;;;;;:::i;:::-;;72999:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;72999:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55459:755;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;55459:755:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;55459:755:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77372:82;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77372:82:0;;;;;;;;;;;;;;;;;:::i;:::-;;73681:41;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;73681:41:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78618:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;78618:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58469:156;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;58469:156:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;73291:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22747:244;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;22747:244:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;77950:70;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;77950:70:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;73032:19;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;32344:142;32421:4;32445:20;:33;32466:11;32445:33;;;;;;;;;;;;;;;;;;;;;;;;;;;32438:40;;32344:142;;;:::o;55131:92::-;55177:13;55210:5;55203:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55131:92;:::o;57818:213::-;57886:7;57914:16;57922:7;57914;:16::i;:::-;57906:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57999:15;:24;58015:7;57999:24;;;;;;;;;;;;;;;;;;;;;57992:31;;57818:213;;;:::o;73374:24::-;;;;:::o;57362:390::-;57443:13;57459:16;57467:7;57459;:16::i;:::-;57443:32;;57500:5;57494:11;;:2;:11;;;;57486:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57580:5;57564:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;57589:37;57606:5;57613:12;:10;:12::i;:::-;57589:16;:37::i;:::-;57564:62;57556:154;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57723:21;57732:2;57736:7;57723:8;:21::i;:::-;57362:390;;;:::o;73135:29::-;;;;:::o;56856:203::-;56909:7;57030:21;:12;:19;:21::i;:::-;57023:28;;56856:203;:::o;73198:27::-;;;;:::o;73436:20::-;;;;;;;;;;;;;:::o;58692:305::-;58853:41;58872:12;:10;:12::i;:::-;58886:7;58853:18;:41::i;:::-;58845:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58961:28;58971:4;58977:2;58981:7;58961:9;:28::i;:::-;58692:305;;;:::o;77620:72::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77685:1:::1;77675:7;:11;;;;77620:72:::0;:::o;78026:105::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78112:12:::1;78097:5;;:28;;;;;;;;;;;;;;;;;;78026:105:::0;:::o;74727:714::-;74807:10;74785:32;;:3;;;;;;;;;;;:11;;;74797:5;74785:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74785:18:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;74785:18:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;74785:18:0;;;;;;;;;;;;;;;;:32;;;74777:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74854:14;74870:13;74885:11;74902:3;;;;;;;;;;;:17;;;74920:5;74902:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;74902:24:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;74902:24:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;74902:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74851:75;;;;;;;;74944:1;74937:3;:8;74933:49;;;74962:12;74956:18;;74933:49;75013:12;;75003:5;74999:3;:9;74998:27;;74990:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75071:11;;75061:6;:21;;75053:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75148:7;;75131:14;;:24;75123:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75188:199;75206:10;75241:1;75267;75293;75319;75345:6;75381:5;75377:3;:9;75188:17;:199::i;:::-;75412:1;75394:14;;:19;;;;;;;;;;;75420:3;;;;;;;;;;;:8;;;75429:5;75420:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;75420:15:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;75420:15:0;;;;74727:714;;;;:::o;77698:78::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77769:1:::1;77756:10;:14;;;;77698:78:::0;:::o;77864:80::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77937:1:::1;77923:11;:15;;;;77864:80:::0;:::o;56626:154::-;56715:7;56742:30;56766:5;56742:13;:20;56756:5;56742:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;56735:37;;56626:154;;;;:::o;78715:94::-;78760:7;78783:20;:10;:18;:20::i;:::-;78776:27;;78715:94;:::o;77782:76::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77851:1:::1;77839:9;:13;;;;77782:76:::0;:::o;73403:26::-;;;;:::o;59068:151::-;59172:39;59189:4;59195:2;59199:7;59172:39;;;;;;;;;;;;:16;:39::i;:::-;59068:151;;;:::o;73056:21::-;;;;;;;;;;;;;:::o;73230:26::-;;;;:::o;73344:25::-;;;;:::o;57136:164::-;57203:7;57224:15;57245:22;57261:5;57245:12;:15;;:22;;;;:::i;:::-;57223:44;;;57285:7;57278:14;;;57136:164;;;:::o;77544:70::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77607:1:::1;77598:6;:10;;;;77544:70:::0;:::o;78244:85::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78307:16:::1;78319:3;78307:11;:16::i;:::-;78244:85:::0;:::o;54895:169::-;54959:7;54986:70;55003:7;54986:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;54979:77;;54895:169;;;:::o;75952:1328::-;76035:4;76023:16;;:8;;;;;;;;;;;:16;;;76015:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76081:3;76074;:10;;76066:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76154:15;;:::i;:::-;76172:10;:15;76183:3;76172:15;;;;;;;;;;;76154:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76194:15;;:::i;:::-;76212:10;:15;76223:3;76212:15;;;;;;;;;;;76194:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76305:12;76286:4;:16;;;:31;76278:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76369:12;76350:4;:16;;;:31;76342:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76430:10;76414:26;;:12;76422:3;76414:7;:12::i;:::-;:26;;;76406:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76495:10;76479:26;;:12;76487:3;76479:7;:12::i;:::-;:26;;;76471:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76660:11;;76651:4;:8;;;:20;76639:9;;76624:12;:24;:47;76594:10;:15;76605:3;76594:15;;;;;;;;;;;:27;;:77;;;;76744:11;;76735:4;:8;;;:20;76723:9;;76708:12;:24;:47;76678:10;:15;76689:3;76678:15;;;;;;;;;;;:27;;:77;;;;76816:12;76831:4;:8;;;76816:23;;76846:12;76861:4;:8;;;76846:23;;76887:4;76880;:11;76876:45;;;76909:4;76902:11;;76876:45;76972:206;76998:10;77049:11;;77044:4;:16;77032:9;;77017:12;:24;:43;77069:3;77081;77098:1;77093:4;:6;77122:4;:11;;;77108:4;:11;;;:25;77158:4;:13;;;77142:4;:13;;;:29;76972:17;:206::i;:::-;77213:61;77236:10;77256:4;77263:10;;77213:5;;;;;;;;;;;:22;;;;:61;;;;;;:::i;:::-;75952:1328;;;;;;:::o;78137:101::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78221:10:::1;78204:3;;:28;;;;;;;;;;;;;;;;;;78137:101:::0;:::o;77460:78::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77531:1:::1;77518:10;:14;;;;77460:78:::0;:::o;56453:89::-;56493:13;56526:8;56519:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56453:89;:::o;78432:180::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78529:13:::1;78552:12;78529:36;;78572:34;78592:2;78596:9;78572:6;:19;;;;:34;;;;;:::i;:::-;22084:1;78432:180:::0;;;:::o;54618:215::-;54682:7;54727:1;54710:19;;:5;:19;;;;54702:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54796:29;:13;:20;54810:5;54796:20;;;;;;;;;;;;;;;:27;:29::i;:::-;54789:36;;54618:215;;;:::o;22444:148::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22551:1:::1;22514:40;;22535:6;;;;;;;;;;;22514:40;;;;;;;;;;;;22582:1;22565:6;;:19;;;;;;;;;;;;;;;;;;22444:148::o:0;73261:25::-;;;;:::o;21802:79::-;21840:7;21867:6;;;;;;;;;;;21860:13;;21802:79;:::o;75498:385::-;75559:7;;75542:14;;:24;75534:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75597:61;75620:10;75640:4;75647:10;;75597:5;;;;;;;;;;;:22;;;;:61;;;;;;:::i;:::-;75665:186;75683:10;75718:1;75744;75770;75796;75822;75849;75665:17;:186::i;:::-;75876:1;75858:14;;:19;;;;;;;;;;;75498:385::o;78335:91::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78417:3:::1;78402:12;:18;;;;;;;;;;;;:::i;:::-;;78335:91:::0;:::o;55292:96::-;55340:13;55373:7;55366:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55292:96;:::o;58103:295::-;58218:12;:10;:12::i;:::-;58206:24;;:8;:24;;;;58198:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58318:8;58273:18;:32;58292:12;:10;:12::i;:::-;58273:32;;;;;;;;;;;;;;;:42;58306:8;58273:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;58371:8;58342:48;;58357:12;:10;:12::i;:::-;58342:48;;;58381:8;58342:48;;;;;;;;;;;;;;;;;;;;;;58103:295;;:::o;77286:80::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77359:1:::1;77345:11;:15;;;;77286:80:::0;:::o;73317:22::-;;;;:::o;59290:285::-;59422:41;59441:12;:10;:12::i;:::-;59455:7;59422:18;:41::i;:::-;59414:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59528:39;59542:4;59548:2;59552:7;59561:5;59528:13;:39::i;:::-;59290:285;;;;:::o;72999:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55459:755::-;55524:13;55558:16;55566:7;55558;:16::i;:::-;55550:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55639:23;55665:10;:19;55676:7;55665:19;;;;;;;;;;;55639:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55786:1;55766:8;55760:22;;;;;;;;;;;;;;;;:27;55756:76;;;55811:9;55804:16;;;;;55756:76;55962:1;55942:9;55936:23;:27;55932:112;;;56011:8;56021:9;55994:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;55994:37:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;55994:37:0;;;55980:52;;;;;55932:112;56176:8;56186:18;:7;:16;:18::i;:::-;56159:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;56159:46:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;56159:46:0;;;56145:61;;;55459:755;;;;:::o;77372:82::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77447:1:::1;77432:12;:16;;;;77372:82:::0;:::o;73681:41::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;78618:91::-;78662:13;78691:12;78684:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78618:91;:::o;58469:156::-;58558:4;58582:18;:25;58601:5;58582:25;;;;;;;;;;;;;;;:35;58608:8;58582:35;;;;;;;;;;;;;;;;;;;;;;;;;58575:42;;58469:156;;;;:::o;73291:21::-;;;;:::o;22747:244::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22856:1:::1;22836:22;;:8;:22;;;;22828:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22946:8;22917:38;;22938:6;;;;;;;;;;;22917:38;;;;;;;;;;;;22975:8;22966:6;;:17;;;;;;;;;;;;;;;;;;22747:244:::0;:::o;77950:70::-;22024:12;:10;:12::i;:::-;22014:22;;:6;;;;;;;;;;;:22;;;22006:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78013:1:::1;78002:8;;:12;;;;;;;;;;;;;;;;;;77950:70:::0;:::o;73032:19::-;;;;;;;;;;;;;:::o;61042:119::-;61099:4;61123:30;61145:7;61123:12;:21;;:30;;;;:::i;:::-;61116:37;;61042:119;;;:::o;20323:106::-;20376:15;20411:10;20404:17;;20323:106;:::o;66869:158::-;66962:2;66935:15;:24;66951:7;66935:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;67011:7;67007:2;66980:39;;66989:16;66997:7;66989;:16::i;:::-;66980:39;;;;;;;;;;;;66869:158;;:::o;48477:123::-;48546:7;48573:19;48581:3;:10;;48573:7;:19::i;:::-;48566:26;;48477:123;;;:::o;61328:333::-;61413:4;61438:16;61446:7;61438;:16::i;:::-;61430:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61514:13;61530:16;61538:7;61530;:16::i;:::-;61514:32;;61576:5;61565:16;;:7;:16;;;:51;;;;61609:7;61585:31;;:20;61597:7;61585:11;:20::i;:::-;:31;;;61565:51;:87;;;;61620:32;61637:5;61644:7;61620:16;:32::i;:::-;61565:87;61557:96;;;61328:333;;;;:::o;64417:574::-;64535:4;64515:24;;:16;64523:7;64515;:16::i;:::-;:24;;;64507:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64618:1;64604:16;;:2;:16;;;;64596:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64674:39;64695:4;64701:2;64705:7;64674:20;:39::i;:::-;64778:29;64795:1;64799:7;64778:8;:29::i;:::-;64820:35;64847:7;64820:13;:19;64834:4;64820:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;64866:30;64888:7;64866:13;:17;64880:2;64866:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;64909:29;64926:7;64935:2;64909:12;:16;;:29;;;;;:::i;:::-;;64975:7;64971:2;64956:27;;64965:4;64956:27;;;;;;;;;;;;64417:574;;;:::o;73912:773::-;74366:22;:10;:20;:22::i;:::-;74395:14;74412:20;:10;:18;:20::i;:::-;74395:37;;74460:191;;;;;;;;74472:2;74460:191;;;;;;74483:11;74460:191;;;;74503:7;74460:191;;;;74519:7;74460:191;;;;74535:3;74460:191;;;;74547:6;74460:191;;;;74562:8;74460:191;;;;74621:8;74614:6;74610:1;74597:12;:14;74587:25;74579:34;;:41;:50;74460:191;;;;74638:6;;74460:191;;;74439:10;:18;74450:6;74439:18;;;;;;;;;;;:212;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74658:21;74668:2;74672:6;74658:9;:21::i;:::-;73912:773;;;;;;;;:::o;41049:137::-;41120:7;41155:22;41159:3;:10;;41171:5;41155:3;:22::i;:::-;41147:31;;41140:38;;41049:137;;;;:::o;19238:114::-;19303:7;19330;:14;;;19323:21;;19238:114;;;:::o;48939:227::-;49019:7;49028;49049:11;49062:13;49079:22;49083:3;:10;;49095:5;49079:3;:22::i;:::-;49048:53;;;;49128:3;49120:12;;49150:5;49142:14;;49112:46;;;;;;;;;48939:227;;;;;:::o;65592:100::-;65676:8;65665;:19;;;;;;;;;;;;:::i;:::-;;65592:100;:::o;49601:204::-;49708:7;49751:44;49756:3;:10;;49776:3;49768:12;;49782;49751:4;:44::i;:::-;49743:53;;49728:69;;49601:204;;;;;:::o;15202:205::-;15303:96;15323:5;15353:27;;;15382:4;15388:2;15392:5;15330:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;15330:68:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;15330:68:0;15303:19;:96::i;:::-;15202:205;;;;:::o;15017:177::-;15100:86;15120:5;15150:23;;;15175:2;15179:5;15127:58;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;15127:58:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;15127:58:0;15100:19;:86::i;:::-;15017:177;;;:::o;40591:114::-;40651:7;40678:19;40686:3;:10;;40678:7;:19::i;:::-;40671:26;;40591:114;;;:::o;60457:272::-;60571:28;60581:4;60587:2;60591:7;60571:9;:28::i;:::-;60618:48;60641:4;60647:2;60651:7;60660:5;60618:22;:48::i;:::-;60610:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60457:272;;;;:::o;50079:744::-;50135:13;50365:1;50356:5;:10;50352:53;;;50383:10;;;;;;;;;;;;;;;;;;;;;50352:53;50415:12;50430:5;50415:20;;50446:14;50471:78;50486:1;50478:4;:9;50471:78;;50504:8;;;;;;;50535:2;50527:10;;;;;;;;;50471:78;;;50559:19;50591:6;50581:17;;;;;;;;;;;;;;;;;;;;;;;;;29:1:-1;21:6;17:14;116:4;104:10;96:6;87:34;147:4;139:6;135:17;125:27;;0:156;50581:17:0;;;;50559:39;;50609:13;50634:1;50625:6;:10;50609:26;;50653:5;50646:12;;50669:115;50684:1;50676:4;:9;50669:115;;50743:2;50736:4;:9;;;;;;50731:2;:14;50720:27;;50702:6;50709:7;;;;;;;50702:15;;;;;;;;;;;:45;;;;;;;;;;;50770:2;50762:10;;;;;;;;;50669:115;;;50808:6;50794:21;;;;;;50079:744;;;;:::o;48238:151::-;48322:4;48346:35;48356:3;:10;;48376:3;48368:12;;48346:9;:35::i;:::-;48339:42;;48238:151;;;;:::o;45860:110::-;45916:7;45943:3;:12;;:19;;;;45936:26;;45860:110;;;:::o;67640:93::-;;;;:::o;40136:137::-;40206:4;40230:35;40238:3;:10;;40258:5;40250:14;;40230:7;:35::i;:::-;40223:42;;40136:137;;;;:::o;39829:131::-;39896:4;39920:32;39925:3;:10;;39945:5;39937:14;;39920:4;:32::i;:::-;39913:39;;39829:131;;;;:::o;47670:176::-;47759:4;47783:55;47788:3;:10;;47808:3;47800:12;;47830:5;47822:14;;47814:23;;47783:4;:55::i;:::-;47776:62;;47670:176;;;;;:::o;19360:181::-;19532:1;19514:7;:14;;;:19;;;;;;;;;;;19360:181;:::o;62004:110::-;62080:26;62090:2;62094:7;62080:26;;;;;;;;;;;;:9;:26::i;:::-;62004:110;;:::o;37713:204::-;37780:7;37829:5;37808:3;:11;;:18;;;;:26;37800:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37891:3;:11;;37903:5;37891:18;;;;;;;;;;;;;;;;37884:25;;37713:204;;;;:::o;46325:279::-;46392:7;46401;46451:5;46429:3;:12;;:19;;;;:27;46421:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46508:22;46533:3;:12;;46546:5;46533:19;;;;;;;;;;;;;;;;;;46508:44;;46571:5;:10;;;46583:5;:12;;;46563:33;;;;;46325:279;;;;;:::o;47027:319::-;47121:7;47141:16;47160:3;:12;;:17;47173:3;47160:17;;;;;;;;;;;;47141:36;;47208:1;47196:8;:13;;47211:12;47188:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;47188:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47278:3;:12;;47302:1;47291:8;:12;47278:26;;;;;;;;;;;;;;;;;;:33;;;47271:40;;;47027:319;;;;;:::o;17322:761::-;17746:23;17772:69;17800:4;17772:69;;;;;;;;;;;;;;;;;17780:5;17772:27;;;;:69;;;;;:::i;:::-;17746:95;;17876:1;17856:10;:17;:21;17852:224;;;17998:10;17987:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;17987:30:0;;;;;;;;;;;;;;;;17979:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17852:224;17322:761;;;:::o;37260:109::-;37316:7;37343:3;:11;;:18;;;;37336:25;;37260:109;;;:::o;66257:604::-;66378:4;66405:15;:2;:13;;;:15::i;:::-;66400:60;;66444:4;66437:11;;;;66400:60;66470:23;66496:252;66549:45;;;66609:12;:10;:12::i;:::-;66636:4;66655:7;66677:5;66512:181;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;66512:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;66512:181:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;66512:181:0;66496:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;66470:278;;66759:13;66786:10;66775:32;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;66775:32:0;;;;;;;;;;;;;;;;66759:48;;51619:10;66836:16;;66826:26;;;:6;:26;;;;66818:35;;;;66257:604;;;;;;;:::o;45640:125::-;45711:4;45756:1;45735:3;:12;;:17;45748:3;45735:17;;;;;;;;;;;;:22;;45728:29;;45640:125;;;;:::o;35415:1544::-;35481:4;35599:18;35620:3;:12;;:19;35633:5;35620:19;;;;;;;;;;;;35599:40;;35670:1;35656:10;:15;35652:1300;;36018:21;36055:1;36042:10;:14;36018:38;;36071:17;36112:1;36091:3;:11;;:18;;;;:22;36071:42;;36358:17;36378:3;:11;;36390:9;36378:22;;;;;;;;;;;;;;;;36358:42;;36524:9;36495:3;:11;;36507:13;36495:26;;;;;;;;;;;;;;;:38;;;;36643:1;36627:13;:17;36601:3;:12;;:23;36614:9;36601:23;;;;;;;;;;;:43;;;;36753:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;36848:3;:12;;:19;36861:5;36848:19;;;;;;;;;;;36841:26;;;36891:4;36884:11;;;;;;;;35652:1300;36935:5;36928:12;;;35415:1544;;;;;:::o;34825:414::-;34888:4;34910:21;34920:3;34925:5;34910:9;:21::i;:::-;34905:327;;34948:3;:11;;34965:5;34948:23;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;34948:23:0;;;;;;;;;;;;;;;;;;;35131:3;:11;;:18;;;;35109:3;:12;;:19;35122:5;35109:19;;;;;;;;;;;:40;;;;35171:4;35164:11;;;;34905:327;35215:5;35208:12;;34825:414;;;;;:::o;43140:692::-;43216:4;43332:16;43351:3;:12;;:17;43364:3;43351:17;;;;;;;;;;;;43332:36;;43397:1;43385:8;:13;43381:444;;;43452:3;:12;;43470:38;;;;;;;;43487:3;43470:38;;;;43500:5;43470:38;;;43452:57;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;43452:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43667:3;:12;;:19;;;;43647:3;:12;;:17;43660:3;43647:17;;;;;;;;;;;:39;;;;43708:4;43701:11;;;;;43381:444;43781:5;43745:3;:12;;43769:1;43758:8;:12;43745:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;43808:5;43801:12;;;43140:692;;;;;;:::o;62341:250::-;62437:18;62443:2;62447:7;62437:5;:18::i;:::-;62474:54;62505:1;62509:2;62513:7;62522:5;62474:22;:54::i;:::-;62466:117;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62341:250;;;:::o;11965:196::-;12068:12;12100:53;12123:6;12131:4;12137:1;12140:12;12100:22;:53::i;:::-;12093:60;;11965:196;;;;;:::o;9047:422::-;9107:4;9315:12;9426:7;9414:20;9406:28;;9460:1;9453:4;:8;9446:15;;;9047:422;;;:::o;37045:129::-;37118:4;37165:1;37142:3;:12;;:19;37155:5;37142:19;;;;;;;;;;;;:24;;37135:31;;37045:129;;;;:::o;62927:404::-;63021:1;63007:16;;:2;:16;;;;62999:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63080:16;63088:7;63080;:16::i;:::-;63079:17;63071:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63142:45;63171:1;63175:2;63179:7;63142:20;:45::i;:::-;63200:30;63222:7;63200:13;:17;63214:2;63200:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;63243:29;63260:7;63269:2;63243:12;:16;;:29;;;;;:::i;:::-;;63315:7;63311:2;63290:33;;63307:1;63290:33;;;;;;;;;;;;62927:404;;:::o;13342:979::-;13472:12;13505:18;13516:6;13505:10;:18::i;:::-;13497:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13631:12;13645:23;13672:6;:11;;13692:8;13703:4;13672:36;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;13672:36:0;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;13630:78:0;;;;13723:7;13719:595;;;13754:10;13747:17;;;;;;13719:595;13888:1;13868:10;:17;:21;13864:439;;;14131:10;14125:17;14192:15;14179:10;14175:2;14171:19;14164:44;14079:148;14274:12;14267:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;14267:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13342:979;;;;;;;:::o;72840:5972::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

Swarm Source

ipfs://97c3de05f9ee7da11763c7d1c91c3cde14542804c2f3878500d79f4baf6f6ca3

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