Token

Mighty Gojiras (MightyGojiras)

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

ERC-721

Overview

Max Total Supply

2,233 MightyGojiras

Holders

630

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x9cc103edf0a60e07dd7a6fd4a16fd2cbf7981d92

Filtered by Token Holder

0x99ED1D0d8B8C932e35849ebD44A35254Ab2e5c99

Balance

2 MightyGojiras

0x99ED1D0d8B8C932e35849ebD44A35254Ab2e5c99

OVERVIEW

Mighty Gojiras is a collection of 2200 unique and digital collectibles rising on ethereum.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

mightygojirascontract

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-11-13
*/

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an applimightygojiraion
 * 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;
    }
}



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be

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




pragma solidity >=0.6.2 <0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;


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

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;


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

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

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



pragma solidity >=0.6.0 <0.8.0;

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



pragma solidity >=0.6.0 <0.8.0;


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

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

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

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

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




pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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



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

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

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

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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



pragma solidity >=0.6.0 <0.8.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--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}



pragma solidity >=0.6.0 <0.8.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 virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _holderTokens[owner].length();
    }

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

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



pragma solidity >=0.6.0 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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



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




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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indimightygojiraing the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

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

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

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

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

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

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

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

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

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applimightygojiraions that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

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



pragma solidity ^0.7.0;
pragma abicoder v2;

/**
 * @dev Token GOJ 
*/

interface IGOJ {
    function burn(address _from, uint256 _amount) external;
    function updateReward(address _from, address _to) external;
} 

/**
 * @dev mightygojiras
*/

contract mightygojirascontract is ERC721, Ownable {
    using SafeMath for uint256;
    string public mightygojira_PROVENANCE = "";
    address public  CityContractAddress;
    uint256 public  mightygojiraPrice =   50000000000000000; // 0.05ETH
    uint256 public  mightygojiraWLPrice = 40000000000000000; // 0.04ETH    
    uint public constant MAX_WL_PURCHASE = 3;
    uint public constant MAX_mightygojira_PURCHASE = 10;    
    uint256 public  MAX_mightygojiras = 9000;
    uint256 public maxGenesisCount = 3000;
    uint256 constant public BREED_PRICE = 500 ether;
    uint256 public NAME_CHANGE_PRICE = 100 ether;
    uint256 public bebeCount;

    bool public WhiteListIsActive = false;
    bool public composeIsActive = false;
    bool public MintSaleIsActive = false;

    IGOJ public GOJ;      //GOJ token
    mapping(uint => uint256) public mightyCityTypeid;
    mapping (address => bool) whitelist;
    mapping(address => uint256) public minted;
    mapping(uint256 => uint256) public babymightygojira;
    mapping (address => uint256) public balanceGenesis;
      
    // Reserve 100 mightygojira for giveaway,prize
    uint public mightygojiraReserve = 100;
    event mightyCityTypeidChange(address _by, uint _tokenId,  uint256 CityTypeId);
	event Newmightygojiraborn (uint256 tokenId, uint256 parent1, uint256 parent2);
	event mightygojiraRevealed(uint256 tokenId);
    event NameChanged(uint256 tokenId, string Name);
	
    constructor() ERC721("Mighty Gojiras", "MightyGojiras") { }
  
    modifier mightygojiraOwner(uint256 mightygojiraId) {
        require(ownerOf(mightygojiraId) == msg.sender, "You do not have this mightygojira");
        _;
    }
    
    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }
    
    function Reserve(address _to, uint256 _reserveAmount) public onlyOwner {        
        uint supply = totalSupply();
        require(_reserveAmount > 0 && supply.add(_reserveAmount) <= maxGenesisCount, "Not enough reserve left");
        for (uint i = 0; i < _reserveAmount; i++) {
            _safeMint(_to, supply + i);
            balanceGenesis[_to]++;
        }
        mightygojiraReserve = mightygojiraReserve.sub(_reserveAmount);
    }
    
    function setMintPrice(uint price) external onlyOwner {
        mightygojiraPrice = price;
    }
    
    function setWLMintPrice(uint price) external onlyOwner {
        mightygojiraWLPrice = price;
    }
    
    function setMaxmightygojiras(uint maxmightygojira) external onlyOwner {
        MAX_mightygojiras = maxmightygojira;
    }

    function setProvenanceHash(string memory provenanceHash) public onlyOwner {
        mightygojira_PROVENANCE = provenanceHash;
    }

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

    function flipWLSaleState() public onlyOwner {
        WhiteListIsActive = !WhiteListIsActive;
    }    

	function changeGOJNamePrice(uint256 _price) external onlyOwner {
		NAME_CHANGE_PRICE = _price;
	}
	
    function flipMintSaleState() public onlyOwner {
        MintSaleIsActive = !MintSaleIsActive;
    }

    function flipCityComposeState() public onlyOwner {
        composeIsActive = !composeIsActive;
    }    
    
	function breed(uint256 parent1, uint256 parent2) external {
		require(ownerOf(parent1) == msg.sender && ownerOf(parent2) == msg.sender);
        require(totalSupply() < MAX_mightygojiras,                "Cannot breed any more baby mightygojira");
        require(parent1 < maxGenesisCount && parent2 < maxGenesisCount,   "Cannot breed with baby mightygojira");
        require(parent1 != parent2,                               "Must select two unique parents");

		GOJ.burn(msg.sender, BREED_PRICE);
		uint256 id = maxGenesisCount + bebeCount;
		babymightygojira[id] = 1;
		bebeCount++;
		_safeMint(msg.sender, id);
		emit Newmightygojiraborn(id, parent1, parent2);
	}

    function reveal(uint256 tokenID) external mightygojiraOwner(tokenID) {
        babymightygojira[tokenID] = 2;
        emit mightygojiraRevealed(tokenID);
    }


	function setGOJTokenContract(address GOJAddress) external onlyOwner {
        GOJ = IGOJ(GOJAddress);
    }
	    
    function mintmightygojiras(uint numberOfTokens) public payable {
        require(MintSaleIsActive, "Sale must be active to mint mightygojira");
        require(numberOfTokens > 0 && numberOfTokens <= MAX_mightygojira_PURCHASE, "Can only mint 10 mightygojira at a time");
        require(totalSupply().add(numberOfTokens) <= maxGenesisCount, "Purchase would exceed max supply of mightygojiras");
        require(msg.value >= mightygojiraPrice.mul(numberOfTokens), "Ether value sent is not correct");

        for (uint i = 0; i < numberOfTokens; i++) {
            if (totalSupply() < maxGenesisCount) {
            _safeMint(msg.sender, totalSupply());
            balanceGenesis[msg.sender]++;
            }
        }
   }
  
    function presalemightygojiras(uint numberOfTokens) public payable {
        require(WhiteListIsActive, "Pre Sale must be active to mint mightygojira");
        require(numberOfTokens > 0 && numberOfTokens <= MAX_WL_PURCHASE, "Can only mint 3 mightygojira at a time");
        require(totalSupply().add(numberOfTokens) <= maxGenesisCount, "Purchase would exceed max supply of mightygojiras");
        require(msg.value >= mightygojiraWLPrice.mul(numberOfTokens), "Ether value sent is not correct");
        require(minted[msg.sender].add(numberOfTokens) <= MAX_WL_PURCHASE, "Max 3 mightygojira per wallet");
        require(whitelist[msg.sender], "You are not in whitelist");
 
        for (uint i = 0; i < numberOfTokens; i++) {
            if (totalSupply() < maxGenesisCount) {
            _safeMint(msg.sender, totalSupply());
             balanceGenesis[msg.sender]++;
             minted[msg.sender]++;
            }
        }
   }
     
   function composeCityWithGojira(address owner, uint256 CitytokenId, uint256 mightygojiratokenId, uint256 CityTypeId) public returns (bool) {
        require(msg.sender == address(CityContractAddress));
        require(composeIsActive, "Compose is not active at the moment");
        require(ERC721.ownerOf(mightygojiratokenId) == owner, "You do not have this mightygojira");
        ICity city = ICity(CityContractAddress);
        require(city.ownerOf(CitytokenId) == owner, "You do not have this city");

        mightyCityTypeid[mightygojiratokenId] = CityTypeId;
        emit mightyCityTypeidChange(msg.sender,  mightygojiratokenId, CityTypeId);
        return true;
    }

    function isEligiblePrivateSale(address _wallet) public view virtual returns (bool){
        return whitelist[_wallet];
    }

    function addWalletsToWhiteList(address[] memory _wallets) public onlyOwner{
        for(uint i = 0; i < _wallets.length; i++) {
            whitelist[_wallets[i]] = true;
        }
    }
    
   function setCityContractAddress(address contractAddress) public onlyOwner {
        CityContractAddress = contractAddress;
   }    

  function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }

  function transferFrom(address from, address to, uint256 tokenId) public override {
        if (tokenId < maxGenesisCount) {
            GOJ.updateReward(from, to);
            balanceGenesis[from]--;
            balanceGenesis[to]++;
        }
        ERC721.transferFrom(from, to, tokenId);
    }

  function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override {
        if (tokenId < maxGenesisCount) {
            GOJ.updateReward(from, to);
            balanceGenesis[from]--;
            balanceGenesis[to]++;
        }
        ERC721.safeTransferFrom(from, to, tokenId, data);
    }
    
}



/**
 * @dev City for GOJ
*/

abstract contract ICity {
  function ownerOf(uint256 tokenId) public virtual view returns (address);
  function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
  function balanceOf(address owner) external virtual view returns (uint256 balance);
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"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":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"Name","type":"string"}],"name":"NameChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"parent1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"parent2","type":"uint256"}],"name":"Newmightygojiraborn","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_by","type":"address"},{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"CityTypeId","type":"uint256"}],"name":"mightyCityTypeidChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mightygojiraRevealed","type":"event"},{"inputs":[],"name":"BREED_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CityContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GOJ","outputs":[{"internalType":"contract IGOJ","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_WL_PURCHASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_mightygojira_PURCHASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_mightygojiras","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MintSaleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME_CHANGE_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_reserveAmount","type":"uint256"}],"name":"Reserve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"WhiteListIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_wallets","type":"address[]"}],"name":"addWalletsToWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"babymightygojira","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceGenesis","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"bebeCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"parent1","type":"uint256"},{"internalType":"uint256","name":"parent2","type":"uint256"}],"name":"breed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"changeGOJNamePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"CitytokenId","type":"uint256"},{"internalType":"uint256","name":"mightygojiratokenId","type":"uint256"},{"internalType":"uint256","name":"CityTypeId","type":"uint256"}],"name":"composeCityWithGojira","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"composeIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipCityComposeState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipMintSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipWLSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"isEligiblePrivateSale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxGenesisCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mightyCityTypeid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mightygojiraPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mightygojiraReserve","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mightygojiraWLPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mightygojira_PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintmightygojiras","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"presalemightygojiras","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"}],"name":"setCityContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"GOJAddress","type":"address"}],"name":"setGOJTokenContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxmightygojira","type":"uint256"}],"name":"setMaxmightygojiras","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"provenanceHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"name":"setWLMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

80157:8425:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9872:150;;;;;;;;;;-1:-1:-1;9872:150:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80597:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;50941:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;53745:221::-;;;;;;;;;;-1:-1:-1;53745:221:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;53275:404::-;;;;;;;;;;-1:-1:-1;53275:404:0;;;;;:::i;:::-;;:::i;:::-;;82836:133;;;;;;;;;;-1:-1:-1;82836:133:0;;;;;:::i;:::-;;:::i;83194:99::-;;;;;;;;;;-1:-1:-1;83194:99:0;;;;;:::i;:::-;;:::i;52753:211::-;;;;;;;;;;;;;:::i;84505:735::-;;;;;;:::i;:::-;;:::i;81093:41::-;;;;;;;;;;-1:-1:-1;81093:41:0;;;;;:::i;:::-;;:::i;87926:304::-;;;;;;;;;;-1:-1:-1;87926:304:0;;;;;:::i;:::-;;:::i;80912:36::-;;;;;;;;;;;;;:::i;52515:162::-;;;;;;;;;;-1:-1:-1;52515:162:0;;;;;:::i;:::-;;:::i;81875:131::-;;;;;;;;;;;;;:::i;55011:151::-;;;;;;;;;;-1:-1:-1;55011:151:0;;;;;:::i;:::-;;:::i;80338:55::-;;;;;;;;;;;;;:::i;53041:172::-;;;;;;;;;;-1:-1:-1;53041:172:0;;;;;:::i;:::-;;:::i;80742:44::-;;;;;;;;;;;;;:::i;82977:99::-;;;;;;;;;;-1:-1:-1;82977:99:0;;;;;:::i;:::-;;:::i;80826:37::-;;;;;;;;;;;;;:::i;82018:452::-;;;;;;;;;;-1:-1:-1;82018:452:0;;;;;:::i;:::-;;:::i;50697:177::-;;;;;;;;;;-1:-1:-1;50697:177:0;;;;;:::i;:::-;;:::i;87241:129::-;;;;;;;;;;-1:-1:-1;87241:129:0;;;;;:::i;:::-;;:::i;52334:97::-;;;;;;;;;;;;;:::i;82704:124::-;;;;;;;;;;-1:-1:-1;82704:124:0;;;;;:::i;:::-;;:::i;50414:221::-;;;;;;;;;;-1:-1:-1;50414:221:0;;;;;:::i;:::-;;:::i;65615:148::-;;;;;;;;;;;;;:::i;80644:37::-;;;;;;;;;;;;;:::i;80247:42::-;;;;;;;;;;;;;:::i;85250:951::-;;;;;;:::i;:::-;;:::i;87380:540::-;;;;;;;;;;-1:-1:-1;87380:540:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;80535:51::-;;;;;;;;;;;;;:::i;80996:48::-;;;;;;;;;;-1:-1:-1;80996:48:0;;;;;:::i;:::-;;:::i;64964:87::-;;;;;;;;;;;;;:::i;51110:104::-;;;;;;;;;;;;;:::i;86213:685::-;;;;;;;;;;-1:-1:-1;86213:685:0;;;;;:::i;:::-;;:::i;54038:295::-;;;;;;;;;;-1:-1:-1;54038:295:0;;;;;:::i;:::-;;:::i;83302:101::-;;;;;;;;;;;;;:::i;80488:40::-;;;;;;;;;;;;;:::i;86906:126::-;;;;;;;;;;-1:-1:-1;86906:126:0;;;;;:::i;:::-;;:::i;83411:102::-;;;;;;;;;;;;;:::i;80870:35::-;;;;;;;;;;;;;:::i;88236:337::-;;;;;;;;;;-1:-1:-1;88236:337:0;;;;;:::i;:::-;;:::i;80411:55::-;;;;;;;;;;;;;:::i;81141:51::-;;;;;;;;;;-1:-1:-1;81141:51:0;;;;;:::i;:::-;;:::i;80688:47::-;;;;;;;;;;;;;:::i;81316:37::-;;;;;;;;;;;;;:::i;84214:162::-;;;;;;;;;;-1:-1:-1;84214:162:0;;;;;:::i;:::-;;:::i;51285:810::-;;;;;;;;;;-1:-1:-1;51285:810:0;;;;;:::i;:::-;;:::i;80296:35::-;;;;;;;;;;;;;:::i;84383:109::-;;;;;;;;;;-1:-1:-1;84383:109:0;;;;;:::i;:::-;;:::i;83526:680::-;;;;;;;;;;-1:-1:-1;83526:680:0;;;;;:::i;:::-;;:::i;82591:101::-;;;;;;;;;;-1:-1:-1;82591:101:0;;;;;:::i;:::-;;:::i;81199:50::-;;;;;;;;;;-1:-1:-1;81199:50:0;;;;;:::i;:::-;;:::i;87040:190::-;;;;;;;;;;-1:-1:-1;87040:190:0;;;;;:::i;:::-;;:::i;80957:15::-;;;;;;;;;;;;;:::i;54404:164::-;;;;;;;;;;-1:-1:-1;54404:164:0;;;;;:::i;:::-;;:::i;65918:244::-;;;;;;;;;;-1:-1:-1;65918:244:0;;;;;:::i;:::-;;:::i;82482:97::-;;;;;;;;;;-1:-1:-1;82482:97:0;;;;;:::i;:::-;;:::i;80793:24::-;;;;;;;;;;;;;:::i;83084:101::-;;;;;;;;;;;;;:::i;9872:150::-;-1:-1:-1;;;;;;9981:33:0;;9957:4;9981:33;;;;;;;;;;;;;9872:150;;;;:::o;80597:40::-;;;;:::o;50941:100::-;51028:5;51021:12;;;;;;;;-1:-1:-1;;51021:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50995:13;;51021:12;;51028:5;;51021:12;;51028:5;51021:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50941:100;:::o;53745:221::-;53821:7;53849:16;53857:7;53849;:16::i;:::-;53841:73;;;;-1:-1:-1;;;53841:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;53934:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;53934:24:0;;53745:221::o;53275:404::-;53356:13;53372:23;53387:7;53372:14;:23::i;:::-;53356:39;;53420:5;-1:-1:-1;;;;;53414:11:0;:2;-1:-1:-1;;;;;53414:11:0;;;53406:57;;;;-1:-1:-1;;;53406:57:0;;;;;;;:::i;:::-;53500:5;-1:-1:-1;;;;;53484:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;53484:21:0;;:69;;;;53509:44;53533:5;53540:12;:10;:12::i;53509:44::-;53476:161;;;;-1:-1:-1;;;53476:161:0;;;;;;;:::i;:::-;53650:21;53659:2;53663:7;53650:8;:21::i;:::-;53275:404;;;:::o;82836:133::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;82921:40;;::::1;::::0;:23:::1;::::0;:40:::1;::::0;::::1;::::0;::::1;:::i;:::-;;82836:133:::0;:::o;83194:99::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;83262:17:::1;:26:::0;83194:99::o;52753:211::-;52814:7;52935:21;:12;:19;:21::i;:::-;52928:28;;52753:211;:::o;84505:735::-;84587:16;;;;;;;84579:69;;;;-1:-1:-1;;;84579:69:0;;;;;;;:::i;:::-;84684:1;84667:14;:18;:65;;;;;80584:2;84689:14;:43;;84667:65;84659:117;;;;-1:-1:-1;;;84659:117:0;;;;;;;:::i;:::-;84832:15;;84795:33;84813:14;84795:13;:11;:13::i;:::-;:17;;:33::i;:::-;:52;;84787:114;;;;-1:-1:-1;;;84787:114:0;;;;;;;:::i;:::-;84933:17;;:37;;84955:14;84933:21;:37::i;:::-;84920:9;:50;;84912:94;;;;-1:-1:-1;;;84912:94:0;;;;;;;:::i;:::-;85024:6;85019:215;85040:14;85036:1;:18;85019:215;;;85096:15;;85080:13;:11;:13::i;:::-;:31;85076:147;;;85128:36;85138:10;85150:13;:11;:13::i;:::-;85128:9;:36::i;:::-;85194:10;85179:26;;;;:14;:26;;;;;:28;;;;;;85076:147;85056:3;;85019:215;;81093:41;;;;;;;;;;;;;:::o;87926:304::-;88032:15;;88022:7;:25;88018:156;;;88064:3;;:26;;-1:-1:-1;;;88064:26:0;;:3;;;;-1:-1:-1;;;;;88064:3:0;;:16;;:26;;88081:4;;88087:2;;88064:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;88105:20:0;;;;;;;:14;:20;;;;;;:22;;-1:-1:-1;;88105:22:0;;;88142:18;;;;;;:20;;88105:22;88142:20;;;-1:-1:-1;88018:156:0;88184:38;88204:4;88210:2;88214:7;88184:19;:38::i;80912:36::-;;;;;;;;;:::o;52515:162::-;-1:-1:-1;;;;;52639:20:0;;52612:7;52639:20;;;:13;:20;;;;;:30;;52663:5;52639:23;:30::i;:::-;52632:37;;52515:162;;;;;:::o;81875:131::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;81970:28:::1;::::0;81938:21:::1;::::0;81970:10:::1;::::0;:28;::::1;;;::::0;81938:21;;81923:12:::1;81970:28:::0;81923:12;81970:28;81938:21;81970:10;:28;::::1;;;;;;;;;;;;;::::0;::::1;;;;55011:151:::0;55115:39;55132:4;55138:2;55142:7;55115:39;;;;;;;;;;;;:16;:39::i;80338:55::-;;;;:::o;53041:172::-;53116:7;;53158:22;:12;53174:5;53158:15;:22::i;:::-;-1:-1:-1;53136:44:0;53041:172;-1:-1:-1;;;53041:172:0:o;80742:44::-;;;;:::o;82977:99::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;83048:20:::1;83060:7;83048:11;:20::i;:::-;82977:99:::0;:::o;80826:37::-;;;;;;:::o;82018:452::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;82108:11:::1;82122:13;:11;:13::i;:::-;82108:27;;82171:1;82154:14;:18;:67;;;;-1:-1:-1::0;82206:15:0::1;::::0;82176:26:::1;:6:::0;82187:14;82176:10:::1;:26::i;:::-;:45;;82154:67;82146:103;;;;-1:-1:-1::0;;;82146:103:0::1;;;;;;;:::i;:::-;82265:6;82260:131;82281:14;82277:1;:18;82260:131;;;82317:26;82327:3;82341:1;82332:6;:10;82317:9;:26::i;:::-;-1:-1:-1::0;;;;;82358:19:0;::::1;;::::0;;;:14:::1;:19;::::0;;;;:21;;::::1;::::0;;::::1;::::0;;;82297:3:::1;82260:131;;;-1:-1:-1::0;82423:19:0::1;::::0;:39:::1;::::0;82447:14;82423:23:::1;:39::i;:::-;82401:19;:61:::0;-1:-1:-1;;;82018:452:0:o;50697:177::-;50769:7;50796:70;50813:7;50796:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;87241:129::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;87326:19:::1;:37:::0;;-1:-1:-1;;;;;;87326:37:0::1;-1:-1:-1::0;;;;;87326:37:0;;;::::1;::::0;;;::::1;::::0;;87241:129::o;52334:97::-;52415:8;52408:15;;;;;;;;-1:-1:-1;;52408:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52382:13;;52408:15;;52415:8;;52408:15;;52415:8;52408:15;;;;;;;;;;;;;;;;;;;;;;;;82704:124;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;82785:17:::1;:35:::0;82704:124::o;50414:221::-;50486:7;-1:-1:-1;;;;;50514:19:0;;50506:74;;;;-1:-1:-1;;;50506:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50598:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;65615:148::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;65706:6:::1;::::0;65685:40:::1;::::0;65722:1:::1;::::0;-1:-1:-1;;;;;65706:6:0::1;::::0;65685:40:::1;::::0;65722:1;;65685:40:::1;65736:6;:19:::0;;-1:-1:-1;;;;;;65736:19:0::1;::::0;;65615:148::o;80644:37::-;;;;:::o;80247:42::-;;;;;;;;;;;;;;;-1:-1:-1;;80247:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;85250:951::-;85335:17;;;;85327:74;;;;-1:-1:-1;;;85327:74:0;;;;;;;:::i;:::-;85437:1;85420:14;:18;:55;;;;;80527:1;85442:14;:33;;85420:55;85412:106;;;;-1:-1:-1;;;85412:106:0;;;;;;;:::i;:::-;85574:15;;85537:33;85555:14;85537:13;:11;:13::i;:33::-;:52;;85529:114;;;;-1:-1:-1;;;85529:114:0;;;;;;;:::i;:::-;85675:19;;:39;;85699:14;85675:23;:39::i;:::-;85662:9;:52;;85654:96;;;;-1:-1:-1;;;85654:96:0;;;;;;;:::i;:::-;85776:10;85769:18;;;;:6;:18;;;;;;80527:1;;85769:38;;85792:14;85769:22;:38::i;:::-;:57;;85761:99;;;;-1:-1:-1;;;85761:99:0;;;;;;;:::i;:::-;85889:10;85879:21;;;;:9;:21;;;;;;;;85871:58;;;;-1:-1:-1;;;85871:58:0;;;;;;;:::i;:::-;85948:6;85943:252;85964:14;85960:1;:18;85943:252;;;86020:15;;86004:13;:11;:13::i;:::-;:31;86000:184;;;86052:36;86062:10;86074:13;:11;:13::i;86052:36::-;86119:10;86104:26;;;;:14;:26;;;;;;;;:28;;;;;;;;;86148:6;:18;;;;;;:20;;;;;;;86000:184;85980:3;;85943:252;;87380:540;87441:16;87471:18;87492:17;87502:6;87492:9;:17::i;:::-;87471:38;-1:-1:-1;87524:15:0;87520:393;;-1:-1:-1;;87601:16:0;;;87615:1;87601:16;;;;;;;;87594:23;;87520:393;87650:23;87690:10;87676:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;87676:25:0;;87650:51;;87716:13;87744:130;87768:10;87760:5;:18;87744:130;;;87824:34;87844:6;87852:5;87824:19;:34::i;:::-;87808:6;87815:5;87808:13;;;;;;;;;;;;;;;;;:50;87780:7;;87744:130;;;-1:-1:-1;87895:6:0;-1:-1:-1;87888:13:0;;-1:-1:-1;87888:13:0;80535:51;80584:2;80535:51;:::o;80996:48::-;;;;;;;;;;;;;:::o;64964:87::-;65037:6;;-1:-1:-1;;;;;65037:6:0;64964:87;:::o;51110:104::-;51199:7;51192:14;;;;;;;;-1:-1:-1;;51192:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51166:13;;51192:14;;51199:7;;51192:14;;51199:7;51192:14;;;;;;;;;;;;;;;;;;;;;;;;86213:685;86392:19;;86345:4;;-1:-1:-1;;;;;86392:19:0;86370:10;:42;86362:51;;;;;;86432:15;;;;;;;86424:63;;;;-1:-1:-1;;;86424:63:0;;;;;;;:::i;:::-;86545:5;-1:-1:-1;;;;;86506:44:0;:35;86521:19;86506:14;:35::i;:::-;-1:-1:-1;;;;;86506:44:0;;86498:90;;;;-1:-1:-1;;;86498:90:0;;;;;;;:::i;:::-;86618:19;;86657:25;;-1:-1:-1;;;86657:25:0;;-1:-1:-1;;;;;86618:19:0;;;;86657:34;;;86618:19;;86657:12;;:25;;86670:11;;86657:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;86657:34:0;;86649:72;;;;-1:-1:-1;;;86649:72:0;;;;;;;:::i;:::-;86734:37;;;;:16;:37;;;;;;;:50;;;86800:68;;;;;86823:10;;86751:19;;86774:10;;86800:68;:::i;:::-;;;;;;;;86886:4;86879:11;;;86213:685;;;;;;;:::o;54038:295::-;54153:12;:10;:12::i;:::-;-1:-1:-1;;;;;54141:24:0;:8;-1:-1:-1;;;;;54141:24:0;;;54133:62;;;;-1:-1:-1;;;54133:62:0;;;;;;;:::i;:::-;54253:8;54208:18;:32;54227:12;:10;:12::i;:::-;-1:-1:-1;;;;;54208:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;54208:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;54208:53:0;;;;;;;;;;;54292:12;:10;:12::i;:::-;-1:-1:-1;;;;;54277:48:0;;54316:8;54277:48;;;;;;:::i;:::-;;;;;;;;54038:295;;:::o;83302:101::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;83379:16:::1;::::0;;-1:-1:-1;;83359:36:0;::::1;83379:16:::0;;;;::::1;;;83378:17;83359:36:::0;;::::1;;::::0;;83302:101::o;80488:40::-;80527:1;80488:40;:::o;86906:126::-;-1:-1:-1;;;;;87006:18:0;86983:4;87006:18;;;:9;:18;;;;;;;;;86906:126::o;83411:102::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;83490:15:::1;::::0;;-1:-1:-1;;83471:34:0;::::1;83490:15;::::0;;;::::1;;;83489:16;83471:34:::0;;::::1;;::::0;;83411:102::o;80870:35::-;;;;;;;;;:::o;88236:337::-;88365:15;;88355:7;:25;88351:156;;;88397:3;;:26;;-1:-1:-1;;;88397:26:0;;:3;;;;-1:-1:-1;;;;;88397:3:0;;:16;;:26;;88414:4;;88420:2;;88397:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;88438:20:0;;;;;;;:14;:20;;;;;;:22;;-1:-1:-1;;88438:22:0;;;88475:18;;;;;;:20;;88438:22;88475:20;;;-1:-1:-1;88351:156:0;88517:48;88541:4;88547:2;88551:7;88560:4;88517:23;:48::i;:::-;88236:337;;;;:::o;80411:55::-;;;;:::o;81141:51::-;;;;;;;;;;;;;:::o;80688:47::-;80726:9;80688:47;:::o;81316:37::-;;;;:::o;84214:162::-;84274:7;81795:10;81768:23;84274:7;81768;:23::i;:::-;-1:-1:-1;;;;;81768:37:0;;81760:83;;;;-1:-1:-1;;;81760:83:0;;;;;;;:::i;:::-;84294:25:::1;::::0;;;:16:::1;:25;::::0;;;;;;84322:1:::1;84294:29:::0;;84339;::::1;::::0;::::1;::::0;84311:7;;84339:29:::1;:::i;:::-;;;;;;;;84214:162:::0;;:::o;51285:810::-;51358:13;51392:16;51400:7;51392;:16::i;:::-;51384:76;;;;-1:-1:-1;;;51384:76:0;;;;;;;:::i;:::-;51473:23;51499:19;;;:10;:19;;;;;;;;51473:45;;;;;;;;;;;-1:-1:-1;;51473:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;51499:19;;51473:45;;;51499:19;51473:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51529:18;51550:9;:7;:9::i;:::-;51529:30;;51641:4;51635:18;51657:1;51635:23;51631:72;;;-1:-1:-1;51682:9:0;-1:-1:-1;51675:16:0;;51631:72;51816:23;;:27;51812:108;;51891:4;51897:9;51874:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;51860:48;;;;;;51812:108;52061:4;52067:18;:7;:16;:18::i;:::-;52044:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52030:57;;;;51285:810;;;:::o;80296:35::-;;;-1:-1:-1;;;;;80296:35:0;;:::o;84383:109::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;84462:3:::1;:22:::0;;-1:-1:-1;;;;;84462:22:0;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;84462:22:0;;::::1;::::0;;;::::1;::::0;;84383:109::o;83526:680::-;83617:10;83597:16;83605:7;83597;:16::i;:::-;-1:-1:-1;;;;;83597:30:0;;:64;;;;-1:-1:-1;83651:10:0;83631:16;83639:7;83631;:16::i;:::-;-1:-1:-1;;;;;83631:30:0;;83597:64;83589:73;;;;;;83697:17;;83681:13;:11;:13::i;:::-;:33;83673:100;;;;-1:-1:-1;;;83673:100:0;;;;;;;:::i;:::-;83802:15;;83792:7;:25;:54;;;;;83831:15;;83821:7;:25;83792:54;83784:104;;;;-1:-1:-1;;;83784:104:0;;;;;;;:::i;:::-;83918:7;83907;:18;;83899:91;;;;-1:-1:-1;;;83899:91:0;;;;;;;:::i;:::-;83997:3;;:33;;-1:-1:-1;;;83997:33:0;;:3;;;;-1:-1:-1;;;;;83997:3:0;;:8;;:33;;84006:10;;80726:9;;83997:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;84066:9:0;;;84048:15;;:27;84035:10;84080:20;;;:16;:20;;;;;84103:1;84080:24;;;;84109:11;;;;;;84048:27;-1:-1:-1;84125:25:0;;-1:-1:-1;84135:10:0;84048:27;84125:9;:25::i;:::-;84160:41;84180:2;84184:7;84193;84160:41;;;;;;;;:::i;:::-;;;;;;;;83526:680;;;:::o;82591:101::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;82657:19:::1;:27:::0;82591:101::o;81199:50::-;;;;;;;;;;;;;:::o;87040:190::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;87129:6:::1;87125:98;87145:8;:15;87141:1;:19;87125:98;;;87207:4;87182:9;:22;87192:8;87201:1;87192:11;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;87182:22:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;87182:22:0;:29;;-1:-1:-1;;87182:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;-1:-1:-1;87162:3:0::1;87125:98;;80957:15:::0;;;;;;-1:-1:-1;;;;;80957:15:0;;:::o;54404:164::-;-1:-1:-1;;;;;54525:25:0;;;54501:4;54525:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;54404:164::o;65918:244::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66007:22:0;::::1;65999:73;;;;-1:-1:-1::0;;;65999:73:0::1;;;;;;;:::i;:::-;66109:6;::::0;66088:38:::1;::::0;-1:-1:-1;;;;;66088:38:0;;::::1;::::0;66109:6:::1;::::0;66088:38:::1;::::0;66109:6:::1;::::0;66088:38:::1;66137:6;:17:::0;;-1:-1:-1;;;;;;66137:17:0::1;-1:-1:-1::0;;;;;66137:17:0;;;::::1;::::0;;;::::1;::::0;;65918:244::o;82482:97::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;82546:17:::1;:25:::0;82482:97::o;80793:24::-;;;;:::o;83084:101::-;65195:12;:10;:12::i;:::-;-1:-1:-1;;;;;65184:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65184:23:0;;65176:68;;;;-1:-1:-1;;;65176:68:0;;;;;;;:::i;:::-;83160:17:::1;::::0;;-1:-1:-1;;83139:38:0;::::1;83160:17;::::0;;::::1;83159:18;83139:38;::::0;;83084:101::o;56985:127::-;57050:4;57074:30;:12;57096:7;57074:21;:30::i;622:106::-;710:10;622:106;:::o;63003:192::-;63078:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63078:29:0;-1:-1:-1;;;;;63078:29:0;;;;;;;;:24;;63132:23;63078:24;63132:14;:23::i;:::-;-1:-1:-1;;;;;63123:46:0;;;;;;;;;;;63003:192;;:::o;43795:123::-;43864:7;43891:19;43899:3;43891:7;:19::i;13391:179::-;13449:7;13481:5;;;13505:6;;;;13497:46;;;;-1:-1:-1;;;13497:46:0;;;;;;;:::i;14288:229::-;14346:7;14370:6;14366:20;;-1:-1:-1;14385:1:0;14378:8;;14366:20;14409:5;;;14413:1;14409;:5;:1;14433:5;;;;;:10;14425:65;;;;-1:-1:-1;;;14425:65:0;;;;;;;:::i;57977:110::-;58053:26;58063:2;58067:7;58053:26;;;;;;;;;;;;:9;:26::i;54635:305::-;54796:41;54815:12;:10;:12::i;:::-;54829:7;54796:18;:41::i;:::-;54788:103;;;;-1:-1:-1;;;54788:103:0;;;;;;;:::i;:::-;54904:28;54914:4;54920:2;54924:7;54904:9;:28::i;35628:137::-;35699:7;35734:22;35738:3;35750:5;35734:3;:22::i;44257:236::-;44337:7;;;;44397:22;44401:3;44413:5;44397:3;:22::i;:::-;44366:53;;;;-1:-1:-1;44257:236:0;-1:-1:-1;;;;;44257:236:0:o;61615:100::-;61688:19;;;;:8;;:19;;;;;:::i;13853:158::-;13911:7;13944:1;13939;:6;;13931:49;;;;-1:-1:-1;;;13931:49:0;;;;;;;:::i;:::-;-1:-1:-1;13998:5:0;;;13853:158::o;45561:213::-;45668:7;45719:44;45724:3;45744;45750:12;45719:4;:44::i;:::-;45711:53;-1:-1:-1;45561:213:0;;;;;;:::o;55233:285::-;55365:41;55384:12;:10;:12::i;:::-;55398:7;55365:18;:41::i;:::-;55357:103;;;;-1:-1:-1;;;55357:103:0;;;;;;;:::i;:::-;55471:39;55485:4;55491:2;55495:7;55504:5;55471:13;:39::i;45971:746::-;46027:13;46248:10;46244:53;;-1:-1:-1;46275:10:0;;;;;;;;;;;;-1:-1:-1;;;46275:10:0;;;;;;46244:53;46322:5;46307:12;46363:78;46370:9;;46363:78;;46396:8;;46427:2;46419:10;;;;46363:78;;;46451:19;46483:6;46473:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46473:17:0;-1:-1:-1;46545:5:0;;-1:-1:-1;46451:39:0;-1:-1:-1;;;46517:10:0;;46561:117;46568:9;;46561:117;;46637:2;46630:4;:9;46625:2;:14;46612:29;;46594:6;46601:7;;;;;;;46594:15;;;;;;;;;;;:47;-1:-1:-1;;;;;46594:47:0;;;;;;;;-1:-1:-1;46664:2:0;46656:10;;;;46561:117;;;-1:-1:-1;46702:6:0;45971:746;-1:-1:-1;;;;45971:746:0:o;43556:151::-;43640:4;43664:35;43674:3;43694;43664:9;:35::i;40356:110::-;40439:19;;40356:110::o;58314:250::-;58410:18;58416:2;58420:7;58410:5;:18::i;:::-;58447:54;58478:1;58482:2;58486:7;58495:5;58447:22;:54::i;:::-;58439:117;;;;-1:-1:-1;;;58439:117:0;;;;;;;:::i;57279:355::-;57372:4;57397:16;57405:7;57397;:16::i;:::-;57389:73;;;;-1:-1:-1;;;57389:73:0;;;;;;;:::i;:::-;57473:13;57489:23;57504:7;57489:14;:23::i;:::-;57473:39;;57542:5;-1:-1:-1;;;;;57531:16:0;:7;-1:-1:-1;;;;;57531:16:0;;:51;;;;57575:7;-1:-1:-1;;;;;57551:31:0;:20;57563:7;57551:11;:20::i;:::-;-1:-1:-1;;;;;57551:31:0;;57531:51;:94;;;;57586:39;57610:5;57617:7;57586:23;:39::i;60415:599::-;60540:4;-1:-1:-1;;;;;60513:31:0;:23;60528:7;60513:14;:23::i;:::-;-1:-1:-1;;;;;60513:31:0;;60505:85;;;;-1:-1:-1;;;60505:85:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;60627:16:0;;60619:65;;;;-1:-1:-1;;;60619:65:0;;;;;;;:::i;:::-;60697:39;60718:4;60724:2;60728:7;60697:20;:39::i;:::-;60801:29;60818:1;60822:7;60801:8;:29::i;:::-;-1:-1:-1;;;;;60843:19:0;;;;;;:13;:19;;;;;:35;;60870:7;60843:26;:35::i;:::-;-1:-1:-1;;;;;;60889:17:0;;;;;;:13;:17;;;;;:30;;60911:7;60889:21;:30::i;:::-;-1:-1:-1;60932:29:0;:12;60949:7;60958:2;60932:16;:29::i;:::-;;60998:7;60994:2;-1:-1:-1;;;;;60979:27:0;60988:4;-1:-1:-1;;;;;60979:27:0;;;;;;;;;;;60415:599;;;:::o;30666:204::-;30761:18;;30733:7;;30761:26;-1:-1:-1;30753:73:0;;;;-1:-1:-1;;;30753:73:0;;;;;;;:::i;:::-;30844:3;:11;;30856:5;30844:18;;;;;;;;;;;;;;;;30837:25;;30666:204;;;;:::o;40821:279::-;40925:19;;40888:7;;;;40925:27;-1:-1:-1;40917:74:0;;;;-1:-1:-1;;;40917:74:0;;;;;;;:::i;:::-;41004:22;41029:3;:12;;41042:5;41029:19;;;;;;;;;;;;;;;;;;41004:44;;41067:5;:10;;;41079:5;:12;;;41059:33;;;;;40821:279;;;;;:::o;42336:319::-;42430:7;42469:17;;;:12;;;:17;;;;;;42520:12;42505:13;42497:36;;;;-1:-1:-1;;;42497:36:0;;;;;;;;:::i;:::-;;42587:3;:12;;42611:1;42600:8;:12;42587:26;;;;;;;;;;;;;;;;;;:33;;;42580:40;;;42336:319;;;;;:::o;56400:272::-;56514:28;56524:4;56530:2;56534:7;56514:9;:28::i;:::-;56561:48;56584:4;56590:2;56594:7;56603:5;56561:22;:48::i;:::-;56553:111;;;;-1:-1:-1;;;56553:111:0;;;;;;;:::i;40136:125::-;40207:4;40231:17;;;:12;;;;;:17;;;;;;:22;;;40136:125::o;58900:404::-;-1:-1:-1;;;;;58980:16:0;;58972:61;;;;-1:-1:-1;;;58972:61:0;;;;;;;:::i;:::-;59053:16;59061:7;59053;:16::i;:::-;59052:17;59044:58;;;;-1:-1:-1;;;59044:58:0;;;;;;;:::i;:::-;59115:45;59144:1;59148:2;59152:7;59115:20;:45::i;:::-;-1:-1:-1;;;;;59173:17:0;;;;;;:13;:17;;;;;:30;;59195:7;59173:21;:30::i;:::-;-1:-1:-1;59216:29:0;:12;59233:7;59242:2;59216:16;:29::i;:::-;-1:-1:-1;59263:33:0;;59288:7;;-1:-1:-1;;;;;59263:33:0;;;59280:1;;59263:33;;59280:1;;59263:33;58900:404;;:::o;62280:604::-;62401:4;62428:15;:2;-1:-1:-1;;;;;62428:13:0;;:15::i;:::-;62423:60;;-1:-1:-1;62467:4:0;62460:11;;62423:60;62493:23;62519:252;-1:-1:-1;;;62632:12:0;:10;:12::i;:::-;62659:4;62678:7;62700:5;62535:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;62535:181:0;;;;;;;-1:-1:-1;;;;;62535:181:0;;;;;;;;;;;62519:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;62519:15:0;;;:252;:15;:252::i;:::-;62493:278;;62782:13;62809:10;62798:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;62849:26:0;-1:-1:-1;;;62849:26:0;;-1:-1:-1;;;62280:604:0;;;;;;:::o;34715:137::-;34785:4;34809:35;34817:3;34837:5;34809:7;:35::i;34408:131::-;34475:4;34499:32;34504:3;34524:5;34499:4;:32::i;42979:185::-;43068:4;43092:64;43097:3;43117;-1:-1:-1;;;;;43131:23:0;;43092:4;:64::i;18859:422::-;19226:20;19265:8;;;18859:422::o;21777:195::-;21880:12;21912:52;21934:6;21942:4;21948:1;21951:12;21912:21;:52::i;28368:1544::-;28434:4;28573:19;;;:12;;;:19;;;;;;28609:15;;28605:1300;;29044:18;;-1:-1:-1;;28995:14:0;;;;29044:22;;;;28971:21;;29044:3;;:22;;29331;;;;;;;;;;;;;;29311:42;;29477:9;29448:3;:11;;29460:13;29448:26;;;;;;;;;;;;;;;;;;;:38;;;;29554:23;;;29596:1;29554:12;;;:23;;;;;;29580:17;;;29554:43;;29706:17;;29554:3;;29706:17;;;;;;;;;;;;;;;;;;;;;;29801:3;:12;;:19;29814:5;29801:19;;;;;;;;;;;29794:26;;;29844:4;29837:11;;;;;;;;28605:1300;29888:5;29881:12;;;;;27778:414;27841:4;27863:21;27873:3;27878:5;27863:9;:21::i;:::-;27858:327;;-1:-1:-1;27901:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;28084:18;;28062:19;;;:12;;;:19;;;;;;:40;;;;28117:11;;27858:327;-1:-1:-1;28168:5:0;28161:12;;37636:692;37712:4;37847:17;;;:12;;;:17;;;;;;37881:13;37877:444;;-1:-1:-1;;37966:38:0;;;;;;;;;;;;;;;;;;37948:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;38163:19;;38143:17;;;:12;;;:17;;;;;;;:39;38197:11;;37877:444;38277:5;38241:3;:12;;38265:1;38254:8;:12;38241:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;38304:5;38297:12;;;;;22829:530;22956:12;23014:5;22989:21;:30;;22981:81;;;;-1:-1:-1;;;22981:81:0;;;;;;;:::i;:::-;23081:18;23092:6;23081:10;:18::i;:::-;23073:60;;;;-1:-1:-1;;;23073:60:0;;;;;;;:::i;:::-;23207:12;23221:23;23248:6;-1:-1:-1;;;;;23248:11:0;23268:5;23276:4;23248:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23206:75;;;;23299:52;23317:7;23326:10;23338:12;23299:17;:52::i;:::-;23292:59;22829:530;-1:-1:-1;;;;;;;22829:530:0:o;25369:742::-;25484:12;25513:7;25509:595;;;-1:-1:-1;25544:10:0;25537:17;;25509:595;25658:17;;:21;25654:439;;25921:10;25915:17;25982:15;25969:10;25965:2;25961:19;25954:44;25869:148;26064:12;26057:20;;-1:-1:-1;;;26057:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:400:1;;114:18;106:6;103:30;100:2;;;136:9;100:2;165:58;211:2;188:17;;-1:-1:-1;;184:31:1;217:4;180:42;165:58;:::i;:::-;156:67;;246:6;239:5;232:21;286:3;277:6;272:3;268:16;265:25;262:2;;;303:1;300;293:12;262:2;352:6;347:3;340:4;333:5;329:16;316:43;406:1;399:4;390:6;383:5;379:18;375:29;368:40;90:324;;;;;:::o;419:259::-;;531:2;519:9;510:7;506:23;502:32;499:2;;;552:6;544;537:22;499:2;596:9;583:23;615:33;642:5;615:33;:::i;683:263::-;;806:2;794:9;785:7;781:23;777:32;774:2;;;827:6;819;812:22;774:2;864:9;858:16;883:33;910:5;883:33;:::i;951:402::-;;;1080:2;1068:9;1059:7;1055:23;1051:32;1048:2;;;1101:6;1093;1086:22;1048:2;1145:9;1132:23;1164:33;1191:5;1164:33;:::i;:::-;1216:5;-1:-1:-1;1273:2:1;1258:18;;1245:32;1286:35;1245:32;1286:35;:::i;:::-;1340:7;1330:17;;;1038:315;;;;;:::o;1358:470::-;;;;1504:2;1492:9;1483:7;1479:23;1475:32;1472:2;;;1525:6;1517;1510:22;1472:2;1569:9;1556:23;1588:33;1615:5;1588:33;:::i;:::-;1640:5;-1:-1:-1;1697:2:1;1682:18;;1669:32;1710:35;1669:32;1710:35;:::i;:::-;1462:366;;1764:7;;-1:-1:-1;;;1818:2:1;1803:18;;;;1790:32;;1462:366::o;1833:830::-;;;;;2005:3;1993:9;1984:7;1980:23;1976:33;1973:2;;;2027:6;2019;2012:22;1973:2;2071:9;2058:23;2090:33;2117:5;2090:33;:::i;:::-;2142:5;-1:-1:-1;2199:2:1;2184:18;;2171:32;2212:35;2171:32;2212:35;:::i;:::-;2266:7;-1:-1:-1;2320:2:1;2305:18;;2292:32;;-1:-1:-1;2375:2:1;2360:18;;2347:32;2402:18;2391:30;;2388:2;;;2439:6;2431;2424:22;2388:2;2467:22;;2520:4;2512:13;;2508:27;-1:-1:-1;2498:2:1;;2554:6;2546;2539:22;2498:2;2582:75;2649:7;2644:2;2631:16;2626:2;2622;2618:11;2582:75;:::i;:::-;2572:85;;;1963:700;;;;;;;:::o;2668:438::-;;;2794:2;2782:9;2773:7;2769:23;2765:32;2762:2;;;2815:6;2807;2800:22;2762:2;2859:9;2846:23;2878:33;2905:5;2878:33;:::i;:::-;2930:5;-1:-1:-1;2987:2:1;2972:18;;2959:32;3029:15;;3022:23;3010:36;;3000:2;;3065:6;3057;3050:22;3111:327;;;3240:2;3228:9;3219:7;3215:23;3211:32;3208:2;;;3261:6;3253;3246:22;3208:2;3305:9;3292:23;3324:33;3351:5;3324:33;:::i;:::-;3376:5;3428:2;3413:18;;;;3400:32;;-1:-1:-1;;;3198:240:1:o;3443:464::-;;;;;3606:3;3594:9;3585:7;3581:23;3577:33;3574:2;;;3628:6;3620;3613:22;3574:2;3672:9;3659:23;3691:33;3718:5;3691:33;:::i;:::-;3743:5;3795:2;3780:18;;3767:32;;-1:-1:-1;3846:2:1;3831:18;;3818:32;;3897:2;3882:18;3869:32;;-1:-1:-1;3564:343:1;-1:-1:-1;;;3564:343:1:o;3912:1070::-;;4027:2;4070;4058:9;4049:7;4045:23;4041:32;4038:2;;;4091:6;4083;4076:22;4038:2;4136:9;4123:23;4165:18;4206:2;4198:6;4195:14;4192:2;;;4227:6;4219;4212:22;4192:2;4270:6;4259:9;4255:22;4245:32;;4315:7;4308:4;4304:2;4300:13;4296:27;4286:2;;4342:6;4334;4327:22;4286:2;4383;4370:16;4405:2;4401;4398:10;4395:2;;;4411:9;4395:2;4449;4445;4441:11;4431:21;;4472:27;4495:2;4491;4487:11;4472:27;:::i;:::-;4533:15;;;4564:12;;;;4596:11;;;4626;;;4622:20;;4619:33;-1:-1:-1;4616:2:1;;;4670:6;4662;4655:22;4616:2;4697:6;4688:15;;4712:240;4726:2;4723:1;4720:9;4712:240;;;4797:3;4784:17;4771:30;;4814:33;4841:5;4814:33;:::i;:::-;4860:18;;;4744:1;4737:9;;;;;4898:12;;;;4930;;4712:240;;;-1:-1:-1;4971:5:1;4007:975;-1:-1:-1;;;;;;;;4007:975:1:o;4987:257::-;;5098:2;5086:9;5077:7;5073:23;5069:32;5066:2;;;5119:6;5111;5104:22;5066:2;5163:9;5150:23;5182:32;5208:5;5182:32;:::i;5249:261::-;;5371:2;5359:9;5350:7;5346:23;5342:32;5339:2;;;5392:6;5384;5377:22;5339:2;5429:9;5423:16;5448:32;5474:5;5448:32;:::i;5515:482::-;;5637:2;5625:9;5616:7;5612:23;5608:32;5605:2;;;5658:6;5650;5643:22;5605:2;5703:9;5690:23;5736:18;5728:6;5725:30;5722:2;;;5773:6;5765;5758:22;5722:2;5801:22;;5854:4;5846:13;;5842:27;-1:-1:-1;5832:2:1;;5888:6;5880;5873:22;5832:2;5916:75;5983:7;5978:2;5965:16;5960:2;5956;5952:11;5916:75;:::i;6002:190::-;;6114:2;6102:9;6093:7;6089:23;6085:32;6082:2;;;6135:6;6127;6120:22;6082:2;-1:-1:-1;6163:23:1;;6072:120;-1:-1:-1;6072:120:1:o;6197:258::-;;;6326:2;6314:9;6305:7;6301:23;6297:32;6294:2;;;6347:6;6339;6332:22;6294:2;-1:-1:-1;;6375:23:1;;;6445:2;6430:18;;;6417:32;;-1:-1:-1;6284:171:1:o;6460:259::-;;6541:5;6535:12;6568:6;6563:3;6556:19;6584:63;6640:6;6633:4;6628:3;6624:14;6617:4;6610:5;6606:16;6584:63;:::i;:::-;6701:2;6680:15;-1:-1:-1;;6676:29:1;6667:39;;;;6708:4;6663:50;;6511:208;-1:-1:-1;;6511:208:1:o;6724:274::-;;6891:6;6885:13;6907:53;6953:6;6948:3;6941:4;6933:6;6929:17;6907:53;:::i;:::-;6976:16;;;;;6861:137;-1:-1:-1;;6861:137:1:o;7003:470::-;;7220:6;7214:13;7236:53;7282:6;7277:3;7270:4;7262:6;7258:17;7236:53;:::i;:::-;7352:13;;7311:16;;;;7374:57;7352:13;7311:16;7408:4;7396:17;;7374:57;:::i;:::-;7447:20;;7190:283;-1:-1:-1;;;;7190:283:1:o;7478:203::-;-1:-1:-1;;;;;7642:32:1;;;;7624:51;;7612:2;7597:18;;7579:102::o;7686:506::-;-1:-1:-1;;;;;7971:15:1;;;7953:34;;8023:15;;8018:2;8003:18;;7996:43;8070:2;8055:18;;8048:34;;;8118:3;8113:2;8098:18;;8091:31;;;7686:506;;8139:47;;8166:19;;8158:6;8139:47;:::i;:::-;8131:55;7905:287;-1:-1:-1;;;;;;7905:287:1:o;8197:282::-;-1:-1:-1;;;;;8397:32:1;;;;8379:51;;8461:2;8446:18;;8439:34;8367:2;8352:18;;8334:145::o;8484:353::-;-1:-1:-1;;;;;8712:32:1;;;;8694:51;;8776:2;8761:18;;8754:34;;;;8819:2;8804:18;;8797:34;8682:2;8667:18;;8649:188::o;8842:304::-;-1:-1:-1;;;;;9072:15:1;;;9054:34;;9124:15;;9119:2;9104:18;;9097:43;9004:2;8989:18;;8971:175::o;9151:635::-;9322:2;9374:21;;;9444:13;;9347:18;;;9466:22;;;9151:635;;9322:2;9545:15;;;;9519:2;9504:18;;;9151:635;9591:169;9605:6;9602:1;9599:13;9591:169;;;9666:13;;9654:26;;9735:15;;;;9700:12;;;;9627:1;9620:9;9591:169;;;-1:-1:-1;9777:3:1;;9302:484;-1:-1:-1;;;;;;9302:484:1:o;9791:187::-;9956:14;;9949:22;9931:41;;9919:2;9904:18;;9886:92::o;10204:221::-;;10353:2;10342:9;10335:21;10373:46;10415:2;10404:9;10400:18;10392:6;10373:46;:::i;10430:398::-;10632:2;10614:21;;;10671:2;10651:18;;;10644:30;10710:34;10705:2;10690:18;;10683:62;-1:-1:-1;;;10776:2:1;10761:18;;10754:32;10818:3;10803:19;;10604:224::o;10833:414::-;11035:2;11017:21;;;11074:2;11054:18;;;11047:30;11113:34;11108:2;11093:18;;11086:62;-1:-1:-1;;;11179:2:1;11164:18;;11157:48;11237:3;11222:19;;11007:240::o;11252:354::-;11454:2;11436:21;;;11493:2;11473:18;;;11466:30;11532:32;11527:2;11512:18;;11505:60;11597:2;11582:18;;11426:180::o;11611:402::-;11813:2;11795:21;;;11852:2;11832:18;;;11825:30;11891:34;11886:2;11871:18;;11864:62;-1:-1:-1;;;11957:2:1;11942:18;;11935:36;12003:3;11988:19;;11785:228::o;12018:352::-;12220:2;12202:21;;;12259:2;12239:18;;;12232:30;12298;12293:2;12278:18;;12271:58;12361:2;12346:18;;12192:178::o;12375:349::-;12577:2;12559:21;;;12616:2;12596:18;;;12589:30;12655:27;12650:2;12635:18;;12628:55;12715:2;12700:18;;12549:175::o;12729:406::-;12931:2;12913:21;;;12970:2;12950:18;;;12943:30;13009:34;13004:2;12989:18;;12982:62;-1:-1:-1;;;13075:2:1;13060:18;;13053:40;13125:3;13110:19;;12903:232::o;13140:351::-;13342:2;13324:21;;;13381:2;13361:18;;;13354:30;13420:29;13415:2;13400:18;;13393:57;13482:2;13467:18;;13314:177::o;13496:399::-;13698:2;13680:21;;;13737:2;13717:18;;;13710:30;13776:34;13771:2;13756:18;;13749:62;-1:-1:-1;;;13842:2:1;13827:18;;13820:33;13885:3;13870:19;;13670:225::o;13900:400::-;14102:2;14084:21;;;14141:2;14121:18;;;14114:30;14180:34;14175:2;14160:18;;14153:62;-1:-1:-1;;;14246:2:1;14231:18;;14224:34;14290:3;14275:19;;14074:226::o;14305:349::-;14507:2;14489:21;;;14546:2;14526:18;;;14519:30;14585:27;14580:2;14565:18;;14558:55;14645:2;14630:18;;14479:175::o;14659:355::-;14861:2;14843:21;;;14900:2;14880:18;;;14873:30;14939:33;14934:2;14919:18;;14912:61;15005:2;14990:18;;14833:181::o;15019:354::-;15221:2;15203:21;;;15260:2;15240:18;;;15233:30;15299:32;15294:2;15279:18;;15272:60;15364:2;15349:18;;15193:180::o;15378:348::-;15580:2;15562:21;;;15619:2;15599:18;;;15592:30;15658:26;15653:2;15638:18;;15631:54;15717:2;15702:18;;15552:174::o;15731:402::-;15933:2;15915:21;;;15972:2;15952:18;;;15945:30;16011:34;16006:2;15991:18;;15984:62;-1:-1:-1;;;16077:2:1;16062:18;;16055:36;16123:3;16108:19;;15905:228::o;16138:408::-;16340:2;16322:21;;;16379:2;16359:18;;;16352:30;16418:34;16413:2;16398:18;;16391:62;-1:-1:-1;;;16484:2:1;16469:18;;16462:42;16536:3;16521:19;;16312:234::o;16551:420::-;16753:2;16735:21;;;16792:2;16772:18;;;16765:30;16831:34;16826:2;16811:18;;16804:62;16902:26;16897:2;16882:18;;16875:54;16961:3;16946:19;;16725:246::o;16976:353::-;17178:2;17160:21;;;17217:2;17197:18;;;17190:30;17256:31;17251:2;17236:18;;17229:59;17320:2;17305:18;;17150:179::o;17334:406::-;17536:2;17518:21;;;17575:2;17555:18;;;17548:30;17614:34;17609:2;17594:18;;17587:62;-1:-1:-1;;;17680:2:1;17665:18;;17658:40;17730:3;17715:19;;17508:232::o;17745:408::-;17947:2;17929:21;;;17986:2;17966:18;;;17959:30;18025:34;18020:2;18005:18;;17998:62;-1:-1:-1;;;18091:2:1;18076:18;;18069:42;18143:3;18128:19;;17919:234::o;18158:404::-;18360:2;18342:21;;;18399:2;18379:18;;;18372:30;18438:34;18433:2;18418:18;;18411:62;-1:-1:-1;;;18504:2:1;18489:18;;18482:38;18552:3;18537:19;;18332:230::o;18567:397::-;18769:2;18751:21;;;18808:2;18788:18;;;18781:30;18847:34;18842:2;18827:18;;18820:62;-1:-1:-1;;;18913:2:1;18898:18;;18891:31;18954:3;18939:19;;18741:223::o;18969:398::-;19171:2;19153:21;;;19210:2;19190:18;;;19183:30;19249:34;19244:2;19229:18;;19222:62;-1:-1:-1;;;19315:2:1;19300:18;;19293:32;19357:3;19342:19;;19143:224::o;19372:356::-;19574:2;19556:21;;;19593:18;;;19586:30;19652:34;19647:2;19632:18;;19625:62;19719:2;19704:18;;19546:182::o;19733:408::-;19935:2;19917:21;;;19974:2;19954:18;;;19947:30;20013:34;20008:2;19993:18;;19986:62;-1:-1:-1;;;20079:2:1;20064:18;;20057:42;20131:3;20116:19;;19907:234::o;20146:356::-;20348:2;20330:21;;;20367:18;;;20360:30;20426:34;20421:2;20406:18;;20399:62;20493:2;20478:18;;20320:182::o;20507:405::-;20709:2;20691:21;;;20748:2;20728:18;;;20721:30;20787:34;20782:2;20767:18;;20760:62;-1:-1:-1;;;20853:2:1;20838:18;;20831:39;20902:3;20887:19;;20681:231::o;20917:411::-;21119:2;21101:21;;;21158:2;21138:18;;;21131:30;21197:34;21192:2;21177:18;;21170:62;-1:-1:-1;;;21263:2:1;21248:18;;21241:45;21318:3;21303:19;;21091:237::o;21333:347::-;21535:2;21517:21;;;21574:2;21554:18;;;21547:30;21613:25;21608:2;21593:18;;21586:53;21671:2;21656:18;;21507:173::o;21685:403::-;21887:2;21869:21;;;21926:2;21906:18;;;21899:30;21965:34;21960:2;21945:18;;21938:62;-1:-1:-1;;;22031:2:1;22016:18;;22009:37;22078:3;22063:19;;21859:229::o;22093:399::-;22295:2;22277:21;;;22334:2;22314:18;;;22307:30;22373:34;22368:2;22353:18;;22346:62;-1:-1:-1;;;22439:2:1;22424:18;;22417:33;22482:3;22467:19;;22267:225::o;22497:397::-;22699:2;22681:21;;;22738:2;22718:18;;;22711:30;22777:34;22772:2;22757:18;;22750:62;-1:-1:-1;;;22843:2:1;22828:18;;22821:31;22884:3;22869:19;;22671:223::o;22899:402::-;23101:2;23083:21;;;23140:2;23120:18;;;23113:30;23179:34;23174:2;23159:18;;23152:62;-1:-1:-1;;;23245:2:1;23230:18;;23223:36;23291:3;23276:19;;23073:228::o;23306:413::-;23508:2;23490:21;;;23547:2;23527:18;;;23520:30;23586:34;23581:2;23566:18;;23559:62;-1:-1:-1;;;23652:2:1;23637:18;;23630:47;23709:3;23694:19;;23480:239::o;23724:413::-;23926:2;23908:21;;;23965:2;23945:18;;;23938:30;24004:34;23999:2;23984:18;;23977:62;-1:-1:-1;;;24070:2:1;24055:18;;24048:47;24127:3;24112:19;;23898:239::o;24142:353::-;24344:2;24326:21;;;24383:2;24363:18;;;24356:30;24422:31;24417:2;24402:18;;24395:59;24486:2;24471:18;;24316:179::o;24500:403::-;24702:2;24684:21;;;24741:2;24721:18;;;24714:30;24780:34;24775:2;24760:18;;24753:62;-1:-1:-1;;;24846:2:1;24831:18;;24824:37;24893:3;24878:19;;24674:229::o;24908:177::-;25054:25;;;25042:2;25027:18;;25009:76::o;25090:319::-;25292:25;;;25348:2;25333:18;;25326:34;;;;25391:2;25376:18;;25369:34;25280:2;25265:18;;25247:162::o;25414:242::-;25484:2;25478:9;25514:17;;;25561:18;25546:34;;25582:22;;;25543:62;25540:2;;;25608:9;25540:2;25635;25628:22;25458:198;;-1:-1:-1;25458:198:1:o;25661:258::-;25733:1;25743:113;25757:6;25754:1;25751:13;25743:113;;;25833:11;;;25827:18;25814:11;;;25807:39;25779:2;25772:10;25743:113;;;25874:6;25871:1;25868:13;25865:2;;;-1:-1:-1;;25909:1:1;25891:16;;25884:27;25714:205::o;25924:133::-;-1:-1:-1;;;;;26001:31:1;;25991:42;;25981:2;;26047:1;26044;26037:12;26062:133;-1:-1:-1;;;;;;26138:32:1;;26128:43;;26118:2;;26185:1;26182;26175:12

Swarm Source

ipfs://93fbf3ab6f1da163317b7b28fa738cb098bf07cbb4f7cbca91e163cb6a9cb11a

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