Token

JI Capital NFTs (JI)

ERC-721

Overview

Max Total Supply

500 JI

Holders

244

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xaa9a26a29a17360decbecec93a39972adf514030

Filtered by Token Holder

0xCAA5cB438BF0c46B57A054bd3E18C10b8eb3108f

035779.eth

Balance

1 JI

0xCAA5cB438BF0c46B57A054bd3E18C10b8eb3108f

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

JCN

Compiler Version

v0.6.8+commit.0bbfe453

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-02-04
*/

//SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity >=0.6.0 <0.8.0;

pragma experimental ABIEncoderV2;

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

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

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

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 returns (address) {
        return _owner;
    }

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

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

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

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

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, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

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

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

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

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

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

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

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

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

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

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

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

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

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

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

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

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
        override
        returns (bool)
    {
        return _supportedInterfaces[interfaceId];
    }

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

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

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

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

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

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(value)));
    }

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

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

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

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

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

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

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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

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

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

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;

    uint256 private _totalSupply;
    // 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_,
        uint256 totalSupply_
    ) public {
        _name = name_;
        _symbol = symbol_;
        _totalSupply = totalSupply_;
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

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

        return _holderTokens[owner].length();
    }

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

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

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

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

        // If there is no base URI, return the token URI.
        string memory _tokenURI = _tokenURIs[tokenId];
        if (bytes(_baseURI).length == 0 && bytes(_tokenURI).length == 0) {
            return "ipfs://QmdSBxcU7c64uRTZS59mEzi6mtQ7eZ38WYtHpnuzz4Mie5";
        }

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

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

pragma solidity ^0.6.0;

contract JCN is ERC721, Ownable {
    uint16 private constant mMax = 500;
    uint16 private constant mMintLimit = 2;
    uint256 private constant mPriceW = 0.1 ether;
    uint256 private constant mPrice = 0.18 ether;
    uint256 private mStartTime = 0;
    uint256 private mWhiteCount = 0;
    uint256 private mMintCount = 0;
    mapping(address => bool) private mWhites;
    mapping(address => uint8) private mHolders;
    struct Tiger {
        uint256 dna;
    }

    Tiger[] public mTigers;

    function _cread() internal virtual returns (uint256) {
        uint256 dna = _generateRandom();
        dna = (dna * (mMintCount + 1)) % 10000000000;
        mTigers.push(Tiger(dna));
        uint256 tokenid = mTigers.length - 1;
        return tokenid;
    }

    function _generateRandom() private view returns (uint256) {
        return
            uint256(
                keccak256(
                    abi.encodePacked(
                        (block.timestamp)
                            .add(block.difficulty)
                            .add(
                                (
                                    uint256(
                                        keccak256(
                                            abi.encodePacked(block.coinbase)
                                        )
                                    )
                                ) / (now)
                            )
                            .add(block.gaslimit)
                            .add(
                                (
                                    uint256(
                                        keccak256(abi.encodePacked(msg.sender))
                                    )
                                ) / (now)
                            )
                            .add(block.number)
                    )
                )
            ) % 1000000000000000000;
    }

    constructor() public ERC721("JI Capital NFTs", "JI", mMax) {
        //_setBaseURI("ipfs://");
    }

    modifier isMax() {
        require(mMintCount < mMax, "mint: End of sale");
        require(block.timestamp >= mStartTime, "mint: no start");
        require(mHolders[_msgSender()] < mMintLimit, "ERC721: MAX");
        _;
    }

    function mint() public payable isMax {
        require(mMintCount + mWhiteCount < mMax, "mint: End of public sale");
        require(msg.value >= mPrice, "mint: amount < price");
        _mint1();
    }

    function mintW() public payable isMax {
        require(mWhites[_msgSender()], "mint: no white");
        require(msg.value >= mPriceW, "mint: amount < price");
        mWhites[_msgSender()] = false;
        mWhiteCount = mWhiteCount.sub(1);
        _mint1();
    }


    function _mint1() private {
        mMintCount++;
        mHolders[_msgSender()]++;
        uint256 tokenid = _cread();
        _mint(_msgSender(), tokenid);
    }

    function setWhite(address[] memory _args, bool _bool) public onlyOwner {
        for (uint16 i = 0; i < _args.length; i++) {
            mWhites[_args[i]] = _bool;
        }
        _bool
            ? mWhiteCount = mWhiteCount.add(_args.length)
            : mWhiteCount = mWhiteCount.sub(_args.length);
    }

    function setTime(uint256 _day) public onlyOwner {
        mStartTime = _day;
    }

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

    function setTokenURIs(uint16[] memory _tokenid, string[] memory _url)
        public
        onlyOwner
    {
        require(_tokenid.length == _url.length, "ERC721: parameter exception");
        for (uint16 i = 0; i < _tokenid.length; i++) {
            _setTokenURI(_tokenid[i], _url[i]);
        }
    }

    function withdraw() public onlyOwner {
        address to = owner();
        (bool success, ) = to.call{value: address(this).balance}(new bytes(0));
        require(success, "TransferHelper: ETH_TRANSFER_FAILED");
    }

    function getInfo()
        public
        view
        returns (
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        return (mMintCount, mStartTime, mWhiteCount, block.timestamp);
    }
}

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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mTigers","outputs":[{"internalType":"uint256","name":"dna","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintW","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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_day","type":"uint256"}],"name":"setTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"_tokenid","type":"uint16[]"},{"internalType":"string[]","name":"_url","type":"string[]"}],"name":"setTokenURIs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_args","type":"address[]"},{"internalType":"bool","name":"_bool","type":"bool"}],"name":"setWhite","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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

66686:4309:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;19957:183:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;19957:183:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;52994:92;;5:9:-1;2:2;;;27:1;24;17:12;2:2;52994:92:0;;;:::i;:::-;;;;;;;;;;;;;;;;55901:291;;5:9:-1;2:2;;;27:1;24;17:12;2:2;55901:291:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;55431:404;;5:9:-1;2:2;;;27:1;24;17:12;2:2;55431:404:0;;;;;;;;;;;;;;;;:::i;:::-;;68990:206;;;:::i;:::-;;54893:194;;5:9:-1;2:2;;;27:1;24;17:12;2:2;54893:194:0;;;:::i;:::-;;;;;;;;;;;;;;;;56926:376;;5:9:-1;2:2;;;27:1;24;17:12;2:2;56926:376:0;;;;;;;;;;;;;;;;:::i;:::-;;70187:315;;5:9:-1;2:2;;;27:1;24;17:12;2:2;70187:315:0;;;;;;;;;;;;;;;;:::i;:::-;;54622:195;;5:9:-1;2:2;;;27:1;24;17:12;2:2;54622:195:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;69986:84;;5:9:-1;2:2;;;27:1;24;17:12;2:2;69986:84:0;;;;;;;;;;;;;;;;:::i;:::-;;70510:223;;5:9:-1;2:2;;;27:1;24;17:12;2:2;70510:223:0;;;:::i;:::-;;57373:185;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57373:185:0;;;;;;;;;;;;;;;;:::i;:::-;;55164:205;;5:9:-1;2:2;;;27:1;24;17:12;2:2;55164:205:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;70078:101;;5:9:-1;2:2;;;27:1;24;17:12;2:2;70078:101:0;;;;;;;;;;;;;;;;:::i;:::-;;70741:251;;5:9:-1;2:2;;;27:1;24;17:12;2:2;70741:251:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;52696:231;;5:9:-1;2:2;;;27:1;24;17:12;2:2;52696:231:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;54449:89;;5:9:-1;2:2;;;27:1;24;17:12;2:2;54449:89:0;;;:::i;:::-;;;;;;;;;;;;;;;;52382:252;;5:9:-1;2:2;;;27:1;24;17:12;2:2;52382:252:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2826:148;;5:9:-1;2:2;;;27:1;24;17:12;2:2;2826:148:0;;;:::i;:::-;;67172:22;;5:9:-1;2:2;;;27:1;24;17:12;2:2;67172:22:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2184:79;;5:9:-1;2:2;;;27:1;24;17:12;2:2;2184:79:0;;;:::i;:::-;;;;;;;;;;;;;;;;53155:96;;5:9:-1;2:2;;;27:1;24;17:12;2:2;53155:96:0;;;:::i;:::-;;;;;;;;;;;;;;;;56264:327;;5:9:-1;2:2;;;27:1;24;17:12;2:2;56264:327:0;;;;;;;;;;;;;;;;:::i;:::-;;69661:317;;5:9:-1;2:2;;;27:1;24;17:12;2:2;69661:317:0;;;;;;;;;;;;;;;;:::i;:::-;;69204:271;;;:::i;:::-;;57629:365;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57629:365:0;;;;;;;;;;;;;;;;:::i;:::-;;53322:884;;5:9:-1;2:2;;;27:1;24;17:12;2:2;53322:884:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;56662:197;;5:9:-1;2:2;;;27:1;24;17:12;2:2;56662:197:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;3129:281;;5:9:-1;2:2;;;27:1;24;17:12;2:2;3129:281:0;;;;;;;;;;;;;;;;:::i;:::-;;19957:183;20070:4;20099:20;:33;20120:11;20099:33;;;;;;;;;;;;;;;;;;;;;;;;;;;20092:40;;19957:183;;;:::o;52994:92::-;53040:13;53073:5;53066:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52994:92;:::o;55901:291::-;56005:7;56052:16;56060:7;56052;:16::i;:::-;56030:110;;;;;;;;;;;;;;;;;;;;;;56160:15;:24;56176:7;56160:24;;;;;;;;;;;;;;;;;;;;;56153:31;;55901:291;;;:::o;55431:404::-;55512:13;55528:16;55536:7;55528;:16::i;:::-;55512:32;;55569:5;55563:11;;:2;:11;;;;55555:57;;;;;;;;;;;;;;;;;;;;;;55663:5;55647:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;55672:37;55689:5;55696:12;:10;:12::i;:::-;55672:16;:37::i;:::-;55647:62;55625:168;;;;;;;;;;;;;;;;;;;;;;55806:21;55815:2;55819:7;55806:8;:21::i;:::-;55431:404;;;:::o;68990:206::-;66756:3;68786:17;;:10;;:17;68778:47;;;;;;;;;;;;;;;;;;;;;;68863:10;;68844:15;:29;;68836:56;;;;;;;;;;;;;;;;;;;;;;66803:1;68911:35;;:8;:22;68920:12;:10;:12::i;:::-;68911:22;;;;;;;;;;;;;;;;;;;;;;;;;:35;;;68903:59;;;;;;;;;;;;;;;;;;;;;;66756:3:::1;69046:31;;69059:11;;69046:10;;:24;:31;69038:68;;;;;;;;;;;;;;;;;;;;;;66896:10;69125:9;:19;;69117:52;;;;;;;;;;;;;;;;;;;;;;69180:8;:6;:8::i;:::-;68990:206::o:0;54893:194::-;54946:7;55067:12;;55060:19;;54893:194;:::o;56926:376::-;57135:41;57154:12;:10;:12::i;:::-;57168:7;57135:18;:41::i;:::-;57113:140;;;;;;;;;;;;;;;;;;;;;;57266:28;57276:4;57282:2;57286:7;57266:9;:28::i;:::-;56926:376;;;:::o;70187:315::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;70335:4:::1;:11;70316:8;:15;:30;70308:70;;;;;;;;;;;;;;;;;;;;;;70394:8;70405:1:::0;70394:12:::1;;70389:106;70412:8;:15;70408:1;:19;;;70389:106;;;70449:34;70462:8;70471:1;70462:11;;;;;;;;;;;;;;;;70449:34;;70475:4;70480:1;70475:7;;;;;;;;;;;;;;;;70449:12;:34::i;:::-;70429:3;;;;;;;70389:106;;;;70187:315:::0;;:::o;54622:195::-;54747:7;54779:30;54803:5;54779:13;:20;54793:5;54779:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;54772:37;;54622:195;;;;:::o;69986:84::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;70058:4:::1;70045:10;:17;;;;69986:84:::0;:::o;70510:223::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;70558:10:::1;70571:7;:5;:7::i;:::-;70558:20;;70590:12;70608:2;:7;;70623:21;70656:1;70646:12;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;70646:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;29:1:-1;21:6;17:14;124:4;108:14;100:6;87:42;155:4;147:6;143:17;133:27;;0:164;70646:12:0;;;;70608:51;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;70589:70:0;;;70678:7;70670:55;;;;;;;;;;;;;;;;;;;;;;2466:1;;70510:223::o:0;57373:185::-;57511:39;57528:4;57534:2;57538:7;57511:39;;;;;;;;;;;;:16;:39::i;:::-;57373:185;;;:::o;55164:205::-;55267:7;55293:15;55314:22;55330:5;55314:12;:15;;:22;;;;:::i;:::-;55292:44;;;55354:7;55347:14;;;55164:205;;;:::o;70078:101::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;70150:21:::1;70162:8;70150:11;:21::i;:::-;70078:101:::0;:::o;70741:251::-;70822:7;70844;70866;70888;70931:10;;70943;;70955:11;;70968:15;70923:61;;;;;;;;70741:251;;;;:::o;52696:231::-;52760:7;52800:119;52835:7;52800:119;;;;;;;;;;;;;;;;;:12;:16;;:119;;;;;:::i;:::-;52780:139;;52696:231;;;:::o;54449:89::-;54489:13;54522:8;54515:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54449:89;:::o;52382:252::-;52446:7;52505:1;52488:19;;:5;:19;;;;52466:111;;;;;;;;;;;;;;;;;;;;;;52597:29;:13;:20;52611:5;52597:20;;;;;;;;;;;;;;;:27;:29::i;:::-;52590:36;;52382:252;;;:::o;2826:148::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;2933:1:::1;2896:40;;2917:6;;;;;;;;;;;2896:40;;;;;;;;;;;;2964:1;2947:6;;:19;;;;;;;;;;;;;;;;;;2826:148::o:0;67172:22::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2184:79::-;2222:7;2249:6;;;;;;;;;;;2242:13;;2184:79;:::o;53155:96::-;53203:13;53236:7;53229:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53155:96;:::o;56264:327::-;56411:12;:10;:12::i;:::-;56399:24;;:8;:24;;;;56391:62;;;;;;;;;;;;;;;;;;;;;;56511:8;56466:18;:32;56485:12;:10;:12::i;:::-;56466:32;;;;;;;;;;;;;;;:42;56499:8;56466:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;56564:8;56535:48;;56550:12;:10;:12::i;:::-;56535:48;;;56574:8;56535:48;;;;;;;;;;;;;;;56264:327;;:::o;69661:317::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;69748:8:::1;69759:1:::0;69748:12:::1;;69743:94;69766:5;:12;69762:1;:16;;;69743:94;;;69820:5;69800:7;:17;69808:5;69814:1;69808:8;;;;;;;;;;;;;;;;69800:17;;;;;;;;;;;;;;;;:25;;;;;;;;;;;;;;;;;;69780:3;;;;;;;69743:94;;;;69847:5;:123;;69941:29;69957:5;:12;69941:11;;:15;;:29;;;;:::i;:::-;69927:11;:43;;;69847:123;;;69882:29;69898:5;:12;69882:11;;:15;;:29;;;;:::i;:::-;69868:11;:43;;;69847:123;;69661:317:::0;;:::o;69204:271::-;66756:3;68786:17;;:10;;:17;68778:47;;;;;;;;;;;;;;;;;;;;;;68863:10;;68844:15;:29;;68836:56;;;;;;;;;;;;;;;;;;;;;;66803:1;68911:35;;:8;:22;68920:12;:10;:12::i;:::-;68911:22;;;;;;;;;;;;;;;;;;;;;;;;;:35;;;68903:59;;;;;;;;;;;;;;;;;;;;;;69261:7:::1;:21;69269:12;:10;:12::i;:::-;69261:21;;;;;;;;;;;;;;;;;;;;;;;;;69253:48;;;;;;;;;;;;;;;;;;;;;;66846:9;69320;:20;;69312:53;;;;;;;;;;;;;;;;;;;;;;69400:5;69376:7;:21;69384:12;:10;:12::i;:::-;69376:21;;;;;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;69430:18;69446:1;69430:11;;:15;;:18;;;;:::i;:::-;69416:11;:32;;;;69459:8;:6;:8::i;:::-;69204:271::o:0;57629:365::-;57818:41;57837:12;:10;:12::i;:::-;57851:7;57818:18;:41::i;:::-;57796:140;;;;;;;;;;;;;;;;;;;;;;57947:39;57961:4;57967:2;57971:7;57980:5;57947:13;:39::i;:::-;57629:365;;;;:::o;53322:884::-;53423:13;53476:16;53484:7;53476;:16::i;:::-;53454:113;;;;;;;;;;;;;;;;;;;;;;53639:23;53665:10;:19;53676:7;53665:19;;;;;;;;;;;53639:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53725:1;53705:8;53699:22;;;;;;;;;;;;;;;;:27;:59;;;;;53757:1;53736:9;53730:23;:28;53699:59;53695:154;;;53775:62;;;;;;;;;;;;;;;;;;;;;;53695:154;53981:1;53961:9;53955:23;:27;53951:76;;;54006:9;53999:16;;;;;53951:76;54159:8;54169:18;:7;:16;:18::i;:::-;54142:55;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;54142:55:0;;;54128:70;;;53322:884;;;;:::o;56662:197::-;56787:4;56816:18;:25;56835:5;56816:25;;;;;;;;;;;;;;;:35;56842:8;56816:35;;;;;;;;;;;;;;;;;;;;;;;;;56809:42;;56662:197;;;;:::o;3129:281::-;2406:12;:10;:12::i;:::-;2396:22;;:6;;;;;;;;;;;:22;;;2388:67;;;;;;;;;;;;;;;;;;;;;;3252:1:::1;3232:22;;:8;:22;;;;3210:110;;;;;;;;;;;;;;;;;;;;;;3365:8;3336:38;;3357:6;;;;;;;;;;;3336:38;;;;;;;;;;;;3394:8;3385:6;;:17;;;;;;;;;;;;;;;;;;3129:281:::0;:::o;59541:119::-;59598:4;59622:30;59644:7;59622:12;:21;;:30;;;;:::i;:::-;59615:37;;59541:119;;;:::o;699:106::-;752:15;787:10;780:17;;699:106;:::o;65755:158::-;65848:2;65821:15;:24;65837:7;65821:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;65897:7;65893:2;65866:39;;65875:16;65883:7;65875;:16::i;:::-;65866:39;;;;;;;;;;;;65755:158;;:::o;69485:168::-;69522:10;;:12;;;;;;;;;;;;;69545:8;:22;69554:12;:10;:12::i;:::-;69545:22;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69580:15;69598:8;:6;:8::i;:::-;69580:26;;69617:28;69623:12;:10;:12::i;:::-;69637:7;69617:5;:28::i;:::-;69485:168;:::o;59827:428::-;59939:4;59983:16;59991:7;59983;:16::i;:::-;59961:110;;;;;;;;;;;;;;;;;;;;;;60082:13;60098:16;60106:7;60098;:16::i;:::-;60082:32;;60144:5;60133:16;;:7;:16;;;:64;;;;60190:7;60166:31;;:20;60178:7;60166:11;:20::i;:::-;:31;;;60133:64;:113;;;;60214:32;60231:5;60238:7;60214:16;:32::i;:::-;60133:113;60125:122;;;59827:428;;;;:::o;63082:645::-;63248:4;63228:24;;:16;63236:7;63228;:16::i;:::-;:24;;;63206:115;;;;;;;;;;;;;;;;;;;;;;63354:1;63340:16;;:2;:16;;;;63332:65;;;;;;;;;;;;;;;;;;;;;;63410:39;63431:4;63437:2;63441:7;63410:20;:39::i;:::-;63514:29;63531:1;63535:7;63514:8;:29::i;:::-;63556:35;63583:7;63556:13;:19;63570:4;63556:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;63602:30;63624:7;63602:13;:17;63616:2;63602:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;63645:29;63662:7;63671:2;63645:12;:16;;:29;;;;;:::i;:::-;;63711:7;63707:2;63692:27;;63701:4;63692:27;;;;;;;;;;;;63082:645;;;:::o;63883:275::-;64020:16;64028:7;64020;:16::i;:::-;63998:110;;;;;;;;;;;;;;;;;;;;;;64141:9;64119:10;:19;64130:7;64119:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;63883:275;;:::o;38301:169::-;38399:7;38439:22;38443:3;:10;;38455:5;38439:3;:22::i;:::-;38431:31;;38424:38;;38301:169;;;;:::o;46526:259::-;46633:7;46642;46668:11;46681:13;46698:22;46702:3;:10;;46714:5;46698:3;:22::i;:::-;46667:53;;;;46747:3;46739:12;;46769:5;46761:14;;46731:46;;;;;;;;;46526:259;;;;;:::o;64388:100::-;64472:8;64461;:19;;;;;;;;;;;;:::i;:::-;;64388:100;:::o;47252:238::-;47393:7;47436:44;47441:3;:10;;47461:3;47453:12;;47467;47436:4;:44::i;:::-;47428:53;;47413:69;;47252:238;;;;;:::o;37833:114::-;37893:7;37920:19;37928:3;:10;;37920:7;:19::i;:::-;37913:26;;37833:114;;;:::o;4810:136::-;4868:7;4895:43;4899:1;4902;4895:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4888:50;;4810:136;;;;:::o;4346:181::-;4404:7;4424:9;4440:1;4436;:5;4424:17;;4465:1;4460;:6;;4452:46;;;;;;;;;;;;;;;;;;;;;;4518:1;4511:8;;;4346:181;;;;:::o;58876:352::-;59033:28;59043:4;59049:2;59053:7;59033:9;:28::i;:::-;59094:48;59117:4;59123:2;59127:7;59136:5;59094:22;:48::i;:::-;59072:148;;;;;;;;;;;;;;;;;;;;;;58876:352;;;;:::o;47737:748::-;47793:13;48023:1;48014:5;:10;48010:53;;;48041:10;;;;;;;;;;;;;;;;;;;;;48010:53;48073:12;48088:5;48073:20;;48104:14;48129:78;48144:1;48136:4;:9;48129:78;;48162:8;;;;;;;48193:2;48185:10;;;;;;;;;48129:78;;;48217:19;48249:6;48239:17;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;48239:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;29:1:-1;21:6;17:14;124:4;108:14;100:6;87:42;155:4;147:6;143:17;133:27;;0:164;48239:17:0;;;;48217:39;;48267:13;48292:1;48283:6;:10;48267:26;;48311:5;48304:12;;48327:119;48342:1;48334:4;:9;48327:119;;48404:2;48397:4;:9;;;;;;48391:2;:16;48378:31;;48360:6;48367:7;;;;;;;48360:15;;;;;;;;;;;:49;;;;;;;;;;;48432:2;48424:10;;;;;;;;;48327:119;;;48470:6;48456:21;;;;;;47737:748;;;;:::o;45752:183::-;45863:4;45892:35;45902:3;:10;;45922:3;45914:12;;45892:9;:35::i;:::-;45885:42;;45752:183;;;;:::o;67203:265::-;67247:7;67267:11;67281:17;:15;:17::i;:::-;67267:31;;67342:11;67336:1;67323:10;;:14;67316:3;:22;67315:38;;;;;;67309:44;;67364:7;67377:10;;;;;;;;67383:3;67377:10;;;67364:24;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;67364:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67399:15;67434:1;67417:7;:14;;;;:18;67399:36;;67453:7;67446:14;;;;67203:265;:::o;61592:404::-;61686:1;61672:16;;:2;:16;;;;61664:61;;;;;;;;;;;;;;;;;;;;;;61745:16;61753:7;61745;:16::i;:::-;61744:17;61736:58;;;;;;;;;;;;;;;;;;;;;;61807:45;61836:1;61840:2;61844:7;61807:20;:45::i;:::-;61865:30;61887:7;61865:13;:17;61879:2;61865:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;61908:29;61925:7;61934:2;61908:12;:16;;:29;;;;;:::i;:::-;;61980:7;61976:2;61955:33;;61972:1;61955:33;;;;;;;;;;;;61592:404;;:::o;66526:126::-;;;;:::o;37323:160::-;37411:4;37440:35;37448:3;:10;;37468:5;37460:14;;37440:7;:35::i;:::-;37433:42;;37323:160;;;;:::o;37016:131::-;37083:4;37107:32;37112:3;:10;;37132:5;37124:14;;37107:4;:32::i;:::-;37100:39;;37016:131;;;;:::o;45127:210::-;45250:4;45274:55;45279:3;:10;;45299:3;45291:12;;45321:5;45313:14;;45305:23;;45274:4;:55::i;:::-;45267:62;;45127:210;;;;;:::o;33003:273::-;33097:7;33165:5;33144:3;:11;;:18;;;;:26;33122:110;;;;;;;;;;;;;;;;;;;;;;33250:3;:11;;33262:5;33250:18;;;;;;;;;;;;;;;;33243:25;;33003:273;;;;:::o;43679:348::-;43773:7;43782;43851:5;43829:3;:12;;:19;;;;:27;43807:111;;;;;;;;;;;;;;;;;;;;;;43931:22;43956:3;:12;;43969:5;43956:19;;;;;;;;;;;;;;;;;;43931:44;;43994:5;:10;;;44006:5;:12;;;43986:33;;;;;43679:348;;;;;:::o;44450:353::-;44578:7;44598:16;44617:3;:12;;:17;44630:3;44617:17;;;;;;;;;;;;44598:36;;44665:1;44653:8;:13;;44668:12;44645:36;;;;;;;;;;;;;;;;;;;;;;;;;44735:3;:12;;44759:1;44748:8;:12;44735:26;;;;;;;;;;;;;;;;;;:33;;;44728:40;;;44450:353;;;;;:::o;32540:109::-;32596:7;32623:3;:11;;:18;;;;32616:25;;32540:109;;;:::o;5249:226::-;5369:7;5402:1;5397;:6;;5405:12;5389:29;;;;;;;;;;;;;;;;;;;;;;;;;5429:9;5445:1;5441;:5;5429:17;;5466:1;5459:8;;;5249:226;;;;;:::o;65053:694::-;65208:4;65230:15;:2;:13;;;:15::i;:::-;65225:60;;65269:4;65262:11;;;;65225:60;65295:23;65321:313;65392:45;;;65456:12;:10;:12::i;:::-;65487:4;65510:7;65536:5;65351:205;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;65351:205:0;;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;65351:205:0;65321:313;;;;;;;;;;;;;;;;;:2;:15;;;;:313;;;;;:::i;:::-;65295:339;;65645:13;65672:10;65661:32;;;;;;;;;;;;;;65645:48;;49258:10;65722:16;;65712:26;;;:6;:26;;;;65704:35;;;;65053:694;;;;;;;:::o;42952:157::-;43050:4;43100:1;43079:3;:12;;:17;43092:3;43079:17;;;;;;;;;;;;:22;;43072:29;;42952:157;;;;:::o;67476:1156::-;67525:7;68605:19;67666:879;68532:12;67666:831;68462:3;68372:10;68355:28;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;68355:28:0;;;68345:39;;;;;;68295:128;;68256:210;;;;;;67666:521;68172:14;67666:471;68102:3;67966:14;67949:32;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;67949:32:0;;;67893:131;;;;;;67843:220;;67804:302;;;;;;67666:69;67718:16;67667:15;67666:51;;:69;;;;:::i;:::-;:103;;:471;;;;:::i;:::-;:505;;:521;;;;:::i;:::-;:555;;:831;;;;:::i;:::-;:865;;:879;;;;:::i;:::-;67623:945;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;67623:945:0;;;67591:996;;;;;;67565:1037;;:1059;;;;;;67545:1079;;67476:1156;:::o;30650:1557::-;30716:4;30834:18;30855:3;:12;;:19;30868:5;30855:19;;;;;;;;;;;;30834:40;;30905:1;30891:10;:15;30887:1313;;31266:21;31303:1;31290:10;:14;31266:38;;31319:17;31360:1;31339:3;:11;;:18;;;;:22;31319:42;;31606:17;31626:3;:11;;31638:9;31626:22;;;;;;;;;;;;;;;;31606:42;;31772:9;31743:3;:11;;31755:13;31743:26;;;;;;;;;;;;;;;:38;;;;31891:1;31875:13;:17;31849:3;:12;;:23;31862:9;31849:23;;;;;;;;;;;:43;;;;32001:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;32096:3;:12;;:19;32109:5;32096:19;;;;;;;;;;;32089:26;;;32139:4;32132:11;;;;;;;;30887:1313;32183:5;32176:12;;;30650:1557;;;;;:::o;30060:414::-;30123:4;30145:21;30155:3;30160:5;30145:9;:21::i;:::-;30140:327;;30183:3;:11;;30200:5;30183:23;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;30183:23:0;;;;;;;;;;;;;;;;;;;30366:3;:11;;:18;;;;30344:3;:12;;:19;30357:5;30344:19;;;;;;;;;;;:40;;;;30406:4;30399:11;;;;30140:327;30450:5;30443:12;;30060:414;;;;;:::o;40394:737::-;40504:4;40620:16;40639:3;:12;;:17;40652:3;40639:17;;;;;;;;;;;;40620:36;;40685:1;40673:8;:13;40669:455;;;40753:3;:12;;40771:36;;;;;;;;40787:3;40771:36;;;;40800:5;40771:36;;;40753:55;;39:1:-1;33:3;27:10;23:18;57:10;52:3;45:23;79:10;72:17;;0:93;40753:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40966:3;:12;;:19;;;;40946:3;:12;;:17;40959:3;40946:17;;;;;;;;;;;:39;;;;41007:4;41000:11;;;;;40669:455;41080:5;41044:3;:12;;41068:1;41057:8;:12;41044:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;41107:5;41100:12;;;40394:737;;;;;;:::o;21525:444::-;21585:4;21793:12;21917:7;21905:20;21897:28;;21960:1;21953:4;:8;21946:15;;;21525:444;;;:::o;24562:229::-;24699:12;24731:52;24753:6;24761:4;24767:1;24770:12;24731:21;:52::i;:::-;24724:59;;24562:229;;;;;:::o;32293:161::-;32393:4;32445:1;32422:3;:12;;:19;32435:5;32422:19;;;;;;;;;;;;:24;;32415:31;;32293:161;;;;:::o;25778:632::-;25948:12;26020:5;25995:21;:30;;25973:118;;;;;;;;;;;;;;;;;;;;;;26110:18;26121:6;26110:10;:18::i;:::-;26102:60;;;;;;;;;;;;;;;;;;;;;;26236:12;26250:23;26277:6;:11;;26296:5;26317:4;26277:55;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;26235:97:0;;;;26350:52;26368:7;26377:10;26389:12;26350:17;:52::i;:::-;26343:59;;;;25778:632;;;;;;:::o;27561:777::-;27711:12;27740:7;27736:595;;;27771:10;27764:17;;;;27736:595;27905:1;27885:10;:17;:21;27881:439;;;28148:10;28142:17;28209:15;28196:10;28192:2;28188:19;28181:44;28096:148;28291:12;28284:20;;;;;;;;;;;;;;;;;;;;27561:777;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;;85:6;72:20;63:29;;97:33;124:5;97:33;;;57:78;;;;;160:707;;277:3;270:4;262:6;258:17;254:27;244:2;;295:1;292;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;;;354:80;;;345:89;;451:5;476:6;469:5;462:21;506:4;498:6;494:17;484:27;;528:4;523:3;519:14;512:21;;581:6;628:3;620:4;612:6;608:17;603:3;599:27;596:36;593:2;;;645:1;642;635:12;593:2;670:1;655:206;680:6;677:1;674:13;655:206;;;738:3;760:37;793:3;781:10;760:37;;;755:3;748:50;821:4;816:3;812:14;805:21;;849:4;844:3;840:14;833:21;;712:149;702:1;699;695:9;690:14;;655:206;;;659:14;237:630;;;;;;;;892:708;;1019:3;1012:4;1004:6;1000:17;996:27;986:2;;1037:1;1034;1027:12;986:2;1074:6;1061:20;1096:90;1111:74;1178:6;1111:74;;;1096:90;;;1087:99;;1203:5;1228:6;1221:5;1214:21;1258:4;1250:6;1246:17;1236:27;;1280:4;1275:3;1271:14;1264:21;;1333:6;1366:1;1351:243;1376:6;1373:1;1370:13;1351:243;;;1459:3;1446:17;1438:6;1434:30;1483:47;1526:3;1514:10;1483:47;;;1478:3;1471:60;1554:4;1549:3;1545:14;1538:21;;1582:4;1577:3;1573:14;1566:21;;1408:186;1398:1;1395;1391:9;1386:14;;1351:243;;;1355:14;979:621;;;;;;;;1625:704;;1741:3;1734:4;1726:6;1722:17;1718:27;1708:2;;1759:1;1756;1749:12;1708:2;1796:6;1783:20;1818:79;1833:63;1889:6;1833:63;;;1818:79;;;1809:88;;1914:5;1939:6;1932:5;1925:21;1969:4;1961:6;1957:17;1947:27;;1991:4;1986:3;1982:14;1975:21;;2044:6;2091:3;2083:4;2075:6;2071:17;2066:3;2062:27;2059:36;2056:2;;;2108:1;2105;2098:12;2056:2;2133:1;2118:205;2143:6;2140:1;2137:13;2118:205;;;2201:3;2223:36;2255:3;2243:10;2223:36;;;2218:3;2211:49;2283:4;2278:3;2274:14;2267:21;;2311:4;2306:3;2302:14;2295:21;;2175:148;2165:1;2162;2158:9;2153:14;;2118:205;;;2122:14;1701:628;;;;;;;;2337:124;;2414:6;2401:20;2392:29;;2426:30;2450:5;2426:30;;;2386:75;;;;;2468:128;;2547:6;2534:20;2525:29;;2559:32;2585:5;2559:32;;;2519:77;;;;;2603:132;;2686:6;2680:13;2671:22;;2698:32;2724:5;2698:32;;;2665:70;;;;;2743:440;;2844:3;2837:4;2829:6;2825:17;2821:27;2811:2;;2862:1;2859;2852:12;2811:2;2899:6;2886:20;2921:64;2936:48;2977:6;2936:48;;;2921:64;;;2912:73;;3005:6;2998:5;2991:21;3041:4;3033:6;3029:17;3074:4;3067:5;3063:16;3109:3;3100:6;3095:3;3091:16;3088:25;3085:2;;;3126:1;3123;3116:12;3085:2;3136:41;3170:6;3165:3;3160;3136:41;;;2804:379;;;;;;;;3192:442;;3294:3;3287:4;3279:6;3275:17;3271:27;3261:2;;3312:1;3309;3302:12;3261:2;3349:6;3336:20;3371:65;3386:49;3428:6;3386:49;;;3371:65;;;3362:74;;3456:6;3449:5;3442:21;3492:4;3484:6;3480:17;3525:4;3518:5;3514:16;3560:3;3551:6;3546:3;3542:16;3539:25;3536:2;;;3577:1;3574;3567:12;3536:2;3587:41;3621:6;3616:3;3611;3587:41;;;3254:380;;;;;;;;3642:128;;3721:6;3708:20;3699:29;;3733:32;3759:5;3733:32;;;3693:77;;;;;3777:130;;3857:6;3844:20;3835:29;;3869:33;3896:5;3869:33;;;3829:78;;;;;3914:241;;4018:2;4006:9;3997:7;3993:23;3989:32;3986:2;;;4034:1;4031;4024:12;3986:2;4069:1;4086:53;4131:7;4122:6;4111:9;4107:22;4086:53;;;4076:63;;4048:97;3980:175;;;;;4162:366;;;4283:2;4271:9;4262:7;4258:23;4254:32;4251:2;;;4299:1;4296;4289:12;4251:2;4334:1;4351:53;4396:7;4387:6;4376:9;4372:22;4351:53;;;4341:63;;4313:97;4441:2;4459:53;4504:7;4495:6;4484:9;4480:22;4459:53;;;4449:63;;4420:98;4245:283;;;;;;4535:491;;;;4673:2;4661:9;4652:7;4648:23;4644:32;4641:2;;;4689:1;4686;4679:12;4641:2;4724:1;4741:53;4786:7;4777:6;4766:9;4762:22;4741:53;;;4731:63;;4703:97;4831:2;4849:53;4894:7;4885:6;4874:9;4870:22;4849:53;;;4839:63;;4810:98;4939:2;4957:53;5002:7;4993:6;4982:9;4978:22;4957:53;;;4947:63;;4918:98;4635:391;;;;;;5033:721;;;;;5197:3;5185:9;5176:7;5172:23;5168:33;5165:2;;;5214:1;5211;5204:12;5165:2;5249:1;5266:53;5311:7;5302:6;5291:9;5287:22;5266:53;;;5256:63;;5228:97;5356:2;5374:53;5419:7;5410:6;5399:9;5395:22;5374:53;;;5364:63;;5335:98;5464:2;5482:53;5527:7;5518:6;5507:9;5503:22;5482:53;;;5472:63;;5443:98;5600:2;5589:9;5585:18;5572:32;5624:18;5616:6;5613:30;5610:2;;;5656:1;5653;5646:12;5610:2;5676:62;5730:7;5721:6;5710:9;5706:22;5676:62;;;5666:72;;5551:193;5159:595;;;;;;;;5761:360;;;5879:2;5867:9;5858:7;5854:23;5850:32;5847:2;;;5895:1;5892;5885:12;5847:2;5930:1;5947:53;5992:7;5983:6;5972:9;5968:22;5947:53;;;5937:63;;5909:97;6037:2;6055:50;6097:7;6088:6;6077:9;6073:22;6055:50;;;6045:60;;6016:95;5841:280;;;;;;6128:366;;;6249:2;6237:9;6228:7;6224:23;6220:32;6217:2;;;6265:1;6262;6255:12;6217:2;6300:1;6317:53;6362:7;6353:6;6342:9;6338:22;6317:53;;;6307:63;;6279:97;6407:2;6425:53;6470:7;6461:6;6450:9;6446:22;6425:53;;;6415:63;;6386:98;6211:283;;;;;;6501:496;;;6644:2;6632:9;6623:7;6619:23;6615:32;6612:2;;;6660:1;6657;6650:12;6612:2;6723:1;6712:9;6708:17;6695:31;6746:18;6738:6;6735:30;6732:2;;;6778:1;6775;6768:12;6732:2;6798:78;6868:7;6859:6;6848:9;6844:22;6798:78;;;6788:88;;6674:208;6913:2;6931:50;6973:7;6964:6;6953:9;6949:22;6931:50;;;6921:60;;6892:95;6606:391;;;;;;7004:656;;;7184:2;7172:9;7163:7;7159:23;7155:32;7152:2;;;7200:1;7197;7190:12;7152:2;7263:1;7252:9;7248:17;7235:31;7286:18;7278:6;7275:30;7272:2;;;7318:1;7315;7308:12;7272:2;7338:77;7407:7;7398:6;7387:9;7383:22;7338:77;;;7328:87;;7214:207;7480:2;7469:9;7465:18;7452:32;7504:18;7496:6;7493:30;7490:2;;;7536:1;7533;7526:12;7490:2;7556:88;7636:7;7627:6;7616:9;7612:22;7556:88;;;7546:98;;7431:219;7146:514;;;;;;7667:239;;7770:2;7758:9;7749:7;7745:23;7741:32;7738:2;;;7786:1;7783;7776:12;7738:2;7821:1;7838:52;7882:7;7873:6;7862:9;7858:22;7838:52;;;7828:62;;7800:96;7732:174;;;;;7913:261;;8027:2;8015:9;8006:7;8002:23;7998:32;7995:2;;;8043:1;8040;8033:12;7995:2;8078:1;8095:63;8150:7;8141:6;8130:9;8126:22;8095:63;;;8085:73;;8057:107;7989:185;;;;;8181:347;;8295:2;8283:9;8274:7;8270:23;8266:32;8263:2;;;8311:1;8308;8301:12;8263:2;8374:1;8363:9;8359:17;8346:31;8397:18;8389:6;8386:30;8383:2;;;8429:1;8426;8419:12;8383:2;8449:63;8504:7;8495:6;8484:9;8480:22;8449:63;;;8439:73;;8325:193;8257:271;;;;;8535:241;;8639:2;8627:9;8618:7;8614:23;8610:32;8607:2;;;8655:1;8652;8645:12;8607:2;8690:1;8707:53;8752:7;8743:6;8732:9;8728:22;8707:53;;;8697:63;;8669:97;8601:175;;;;;8783:137;8882:32;8908:5;8882:32;;;8877:3;8870:45;8864:56;;;8927:184;9044:61;9072:32;9098:5;9072:32;;;9044:61;;;9039:3;9032:74;9026:85;;;9118:113;9201:24;9219:5;9201:24;;;9196:3;9189:37;9183:48;;;9238:104;9315:21;9330:5;9315:21;;;9310:3;9303:34;9297:45;;;9349:343;;9459:38;9491:5;9459:38;;;9509:70;9572:6;9567:3;9509:70;;;9502:77;;9584:52;9629:6;9624:3;9617:4;9610:5;9606:16;9584:52;;;9657:29;9679:6;9657:29;;;9652:3;9648:39;9641:46;;9439:253;;;;;;9699:356;;9827:38;9859:5;9827:38;;;9877:88;9958:6;9953:3;9877:88;;;9870:95;;9970:52;10015:6;10010:3;10003:4;9996:5;9992:16;9970:52;;;10043:6;10038:3;10034:16;10027:23;;9807:248;;;;;;10062:347;;10174:39;10207:5;10174:39;;;10225:71;10289:6;10284:3;10225:71;;;10218:78;;10301:52;10346:6;10341:3;10334:4;10327:5;10323:16;10301:52;;;10374:29;10396:6;10374:29;;;10369:3;10365:39;10358:46;;10154:255;;;;;;10416:360;;10546:39;10579:5;10546:39;;;10597:89;10679:6;10674:3;10597:89;;;10590:96;;10691:52;10736:6;10731:3;10724:4;10717:5;10713:16;10691:52;;;10764:6;10759:3;10755:16;10748:23;;10526:250;;;;;;10808:884;;10945:5;10939:12;10979:1;10968:9;10964:17;10992:1;10987:268;;;;11266:1;11261:425;;;;10957:729;;10987:268;11065:4;11061:1;11050:9;11046:17;11042:28;11084:89;11166:6;11161:3;11084:89;;;11077:96;;11211:4;11207:9;11196;11192:25;11187:3;11180:38;11241:6;11236:3;11232:16;11225:23;;10994:261;10987:268;;11261:425;11330:1;11319:9;11315:17;11346:89;11428:6;11423:3;11346:89;;;11339:96;;11457:38;11489:5;11457:38;;;11511:1;11519:130;11533:6;11530:1;11527:13;11519:130;;;11598:7;11592:14;11588:1;11583:3;11579:11;11572:35;11639:1;11630:7;11626:15;11615:26;;11555:4;11552:1;11548:12;11543:17;;11519:130;;;11672:6;11667:3;11663:16;11656:23;;11268:418;;;10957:729;;10915:777;;;;;;11701:371;;11861:67;11925:2;11920:3;11861:67;;;11854:74;;11961:34;11957:1;11952:3;11948:11;11941:55;12030:4;12025:2;12020:3;12016:12;12009:26;12063:2;12058:3;12054:12;12047:19;;11847:225;;;;12081:311;;12241:67;12305:2;12300:3;12241:67;;;12234:74;;12341:13;12337:1;12332:3;12328:11;12321:34;12383:2;12378:3;12374:12;12367:19;;12227:165;;;;12401:324;;12561:67;12625:2;12620:3;12561:67;;;12554:74;;12661:26;12657:1;12652:3;12648:11;12641:47;12716:2;12711:3;12707:12;12700:19;;12547:178;;;;12734:387;;12894:67;12958:2;12953:3;12894:67;;;12887:74;;12994:34;12990:1;12985:3;12981:11;12974:55;13063:20;13058:2;13053:3;13049:12;13042:42;13112:2;13107:3;13103:12;13096:19;;12880:241;;;;13130:327;;13290:67;13354:2;13349:3;13290:67;;;13283:74;;13390:29;13386:1;13381:3;13377:11;13370:50;13448:2;13443:3;13439:12;13432:19;;13276:181;;;;13466:375;;13626:67;13690:2;13685:3;13626:67;;;13619:74;;13726:34;13722:1;13717:3;13713:11;13706:55;13795:8;13790:2;13785:3;13781:12;13774:30;13832:2;13827:3;13823:12;13816:19;;13612:229;;;;13850:328;;14010:67;14074:2;14069:3;14010:67;;;14003:74;;14110:30;14106:1;14101:3;14097:11;14090:51;14169:2;14164:3;14160:12;14153:19;;13996:182;;;;14187:327;;14347:67;14411:2;14406:3;14347:67;;;14340:74;;14447:29;14443:1;14438:3;14434:11;14427:50;14505:2;14500:3;14496:12;14489:19;;14333:181;;;;14523:373;;14683:67;14747:2;14742:3;14683:67;;;14676:74;;14783:34;14779:1;14774:3;14770:11;14763:55;14852:6;14847:2;14842:3;14838:12;14831:28;14887:2;14882:3;14878:12;14871:19;;14669:227;;;;14905:325;;15065:67;15129:2;15124:3;15065:67;;;15058:74;;15165:27;15161:1;15156:3;15152:11;15145:48;15221:2;15216:3;15212:12;15205:19;;15051:179;;;;15239:375;;15399:67;15463:2;15458:3;15399:67;;;15392:74;;15499:34;15495:1;15490:3;15486:11;15479:55;15568:8;15563:2;15558:3;15554:12;15547:30;15605:2;15600:3;15596:12;15589:19;;15385:229;;;;15623:381;;15783:67;15847:2;15842:3;15783:67;;;15776:74;;15883:34;15879:1;15874:3;15870:11;15863:55;15952:14;15947:2;15942:3;15938:12;15931:36;15995:2;15990:3;15986:12;15979:19;;15769:235;;;;16013:320;;16173:67;16237:2;16232:3;16173:67;;;16166:74;;16273:22;16269:1;16264:3;16260:11;16253:43;16324:2;16319:3;16315:12;16308:19;;16159:174;;;;16342:393;;16502:67;16566:2;16561:3;16502:67;;;16495:74;;16602:34;16598:1;16593:3;16589:11;16582:55;16671:26;16666:2;16661:3;16657:12;16650:48;16726:2;16721:3;16717:12;16710:19;;16488:247;;;;16744:379;;16904:67;16968:2;16963:3;16904:67;;;16897:74;;17004:34;17000:1;16995:3;16991:11;16984:55;17073:12;17068:2;17063:3;17059:12;17052:34;17114:2;17109:3;17105:12;17098:19;;16890:233;;;;17132:371;;17292:67;17356:2;17351:3;17292:67;;;17285:74;;17392:34;17388:1;17383:3;17379:11;17372:55;17461:4;17456:2;17451:3;17447:12;17440:26;17494:2;17489:3;17485:12;17478:19;;17278:225;;;;17512:332;;17672:67;17736:2;17731:3;17672:67;;;17665:74;;17772:34;17768:1;17763:3;17759:11;17752:55;17835:2;17830:3;17826:12;17819:19;;17658:186;;;;17853:314;;18013:67;18077:2;18072:3;18013:67;;;18006:74;;18113:16;18109:1;18104:3;18100:11;18093:37;18158:2;18153:3;18149:12;18142:19;;17999:168;;;;18176:381;;18336:67;18400:2;18395:3;18336:67;;;18329:74;;18436:34;18432:1;18427:3;18423:11;18416:55;18505:14;18500:2;18495:3;18491:12;18484:36;18548:2;18543:3;18539:12;18532:19;;18322:235;;;;18566:339;;18744:84;18826:1;18821:3;18744:84;;;18737:91;;18861:7;18857:1;18852:3;18848:11;18841:28;18897:1;18892:3;18888:11;18881:18;;18730:175;;;;18914:381;;19074:67;19138:2;19133:3;19074:67;;;19067:74;;19174:34;19170:1;19165:3;19161:11;19154:55;19243:14;19238:2;19233:3;19229:12;19222:36;19286:2;19281:3;19277:12;19270:19;;19060:235;;;;19304:332;;19464:67;19528:2;19523:3;19464:67;;;19457:74;;19564:34;19560:1;19555:3;19551:11;19544:55;19627:2;19622:3;19618:12;19611:19;;19450:186;;;;19645:378;;19805:67;19869:2;19864:3;19805:67;;;19798:74;;19905:34;19901:1;19896:3;19892:11;19885:55;19974:11;19969:2;19964:3;19960:12;19953:33;20014:2;20009:3;20005:12;19998:19;;19791:232;;;;20032:384;;20192:67;20256:2;20251:3;20192:67;;;20185:74;;20292:34;20288:1;20283:3;20279:11;20272:55;20361:17;20356:2;20351:3;20347:12;20340:39;20407:2;20402:3;20398:12;20391:19;;20178:238;;;;20425:370;;20585:67;20649:2;20644:3;20585:67;;;20578:74;;20685:34;20681:1;20676:3;20672:11;20665:55;20754:3;20749:2;20744:3;20740:12;20733:25;20786:2;20781:3;20777:12;20770:19;;20571:224;;;;20804:386;;20964:67;21028:2;21023:3;20964:67;;;20957:74;;21064:34;21060:1;21055:3;21051:11;21044:55;21133:19;21128:2;21123:3;21119:12;21112:41;21181:2;21176:3;21172:12;21165:19;;20950:240;;;;21199:329;;21359:67;21423:2;21418:3;21359:67;;;21352:74;;21459:31;21455:1;21450:3;21446:11;21439:52;21519:2;21514:3;21510:12;21503:19;;21345:183;;;;21537:372;;21697:67;21761:2;21756:3;21697:67;;;21690:74;;21797:34;21793:1;21788:3;21784:11;21777:55;21866:5;21861:2;21856:3;21852:12;21845:27;21900:2;21895:3;21891:12;21884:19;;21683:226;;;;21918:314;;22078:67;22142:2;22137:3;22078:67;;;22071:74;;22178:16;22174:1;22169:3;22165:11;22158:37;22223:2;22218:3;22214:12;22207:19;;22064:168;;;;22241:317;;22401:67;22465:2;22460:3;22401:67;;;22394:74;;22501:19;22497:1;22492:3;22488:11;22481:40;22549:2;22544:3;22540:12;22533:19;;22387:171;;;;22566:113;22649:24;22667:5;22649:24;;;22644:3;22637:37;22631:48;;;22686:152;22787:45;22807:24;22825:5;22807:24;;;22787:45;;;22782:3;22775:58;22769:69;;;22845:285;;22989:91;23076:3;23067:6;22989:91;;;23102:2;23097:3;23093:12;23086:19;;23122:3;23115:10;;22977:153;;;;;23137:271;;23290:93;23379:3;23370:6;23290:93;;;23283:100;;23400:3;23393:10;;23271:137;;;;;23415:697;;23716:92;23804:3;23795:6;23716:92;;;23709:99;;23826:95;23917:3;23908:6;23826:95;;;23819:102;;23939:148;24083:3;23939:148;;;23932:155;;24104:3;24097:10;;23697:415;;;;;;24119:253;;24247:75;24318:3;24309:6;24247:75;;;24344:2;24339:3;24335:12;24328:19;;24364:3;24357:10;;24235:137;;;;;24379:222;;24506:2;24495:9;24491:18;24483:26;;24520:71;24588:1;24577:9;24573:17;24564:6;24520:71;;;24477:124;;;;;24608:672;;24853:3;24842:9;24838:19;24830:27;;24868:87;24952:1;24941:9;24937:17;24928:6;24868:87;;;24966:72;25034:2;25023:9;25019:18;25010:6;24966:72;;;25049;25117:2;25106:9;25102:18;25093:6;25049:72;;;25169:9;25163:4;25159:20;25154:2;25143:9;25139:18;25132:48;25194:76;25265:4;25256:6;25194:76;;;25186:84;;24824:456;;;;;;;;25287:210;;25408:2;25397:9;25393:18;25385:26;;25422:65;25484:1;25473:9;25469:17;25460:6;25422:65;;;25379:118;;;;;25504:310;;25651:2;25640:9;25636:18;25628:26;;25701:9;25695:4;25691:20;25687:1;25676:9;25672:17;25665:47;25726:78;25799:4;25790:6;25726:78;;;25718:86;;25622:192;;;;;25821:416;;26021:2;26010:9;26006:18;25998:26;;26071:9;26065:4;26061:20;26057:1;26046:9;26042:17;26035:47;26096:131;26222:4;26096:131;;;26088:139;;25992:245;;;;26244:416;;26444:2;26433:9;26429:18;26421:26;;26494:9;26488:4;26484:20;26480:1;26469:9;26465:17;26458:47;26519:131;26645:4;26519:131;;;26511:139;;26415:245;;;;26667:416;;26867:2;26856:9;26852:18;26844:26;;26917:9;26911:4;26907:20;26903:1;26892:9;26888:17;26881:47;26942:131;27068:4;26942:131;;;26934:139;;26838:245;;;;27090:416;;27290:2;27279:9;27275:18;27267:26;;27340:9;27334:4;27330:20;27326:1;27315:9;27311:17;27304:47;27365:131;27491:4;27365:131;;;27357:139;;27261:245;;;;27513:416;;27713:2;27702:9;27698:18;27690:26;;27763:9;27757:4;27753:20;27749:1;27738:9;27734:17;27727:47;27788:131;27914:4;27788:131;;;27780:139;;27684:245;;;;27936:416;;28136:2;28125:9;28121:18;28113:26;;28186:9;28180:4;28176:20;28172:1;28161:9;28157:17;28150:47;28211:131;28337:4;28211:131;;;28203:139;;28107:245;;;;28359:416;;28559:2;28548:9;28544:18;28536:26;;28609:9;28603:4;28599:20;28595:1;28584:9;28580:17;28573:47;28634:131;28760:4;28634:131;;;28626:139;;28530:245;;;;28782:416;;28982:2;28971:9;28967:18;28959:26;;29032:9;29026:4;29022:20;29018:1;29007:9;29003:17;28996:47;29057:131;29183:4;29057:131;;;29049:139;;28953:245;;;;29205:416;;29405:2;29394:9;29390:18;29382:26;;29455:9;29449:4;29445:20;29441:1;29430:9;29426:17;29419:47;29480:131;29606:4;29480:131;;;29472:139;;29376:245;;;;29628:416;;29828:2;29817:9;29813:18;29805:26;;29878:9;29872:4;29868:20;29864:1;29853:9;29849:17;29842:47;29903:131;30029:4;29903:131;;;29895:139;;29799:245;;;;30051:416;;30251:2;30240:9;30236:18;30228:26;;30301:9;30295:4;30291:20;30287:1;30276:9;30272:17;30265:47;30326:131;30452:4;30326:131;;;30318:139;;30222:245;;;;30474:416;;30674:2;30663:9;30659:18;30651:26;;30724:9;30718:4;30714:20;30710:1;30699:9;30695:17;30688:47;30749:131;30875:4;30749:131;;;30741:139;;30645:245;;;;30897:416;;31097:2;31086:9;31082:18;31074:26;;31147:9;31141:4;31137:20;31133:1;31122:9;31118:17;31111:47;31172:131;31298:4;31172:131;;;31164:139;;31068:245;;;;31320:416;;31520:2;31509:9;31505:18;31497:26;;31570:9;31564:4;31560:20;31556:1;31545:9;31541:17;31534:47;31595:131;31721:4;31595:131;;;31587:139;;31491:245;;;;31743:416;;31943:2;31932:9;31928:18;31920:26;;31993:9;31987:4;31983:20;31979:1;31968:9;31964:17;31957:47;32018:131;32144:4;32018:131;;;32010:139;;31914:245;;;;32166:416;;32366:2;32355:9;32351:18;32343:26;;32416:9;32410:4;32406:20;32402:1;32391:9;32387:17;32380:47;32441:131;32567:4;32441:131;;;32433:139;;32337:245;;;;32589:416;;32789:2;32778:9;32774:18;32766:26;;32839:9;32833:4;32829:20;32825:1;32814:9;32810:17;32803:47;32864:131;32990:4;32864:131;;;32856:139;;32760:245;;;;33012:416;;33212:2;33201:9;33197:18;33189:26;;33262:9;33256:4;33252:20;33248:1;33237:9;33233:17;33226:47;33287:131;33413:4;33287:131;;;33279:139;;33183:245;;;;33435:416;;33635:2;33624:9;33620:18;33612:26;;33685:9;33679:4;33675:20;33671:1;33660:9;33656:17;33649:47;33710:131;33836:4;33710:131;;;33702:139;;33606:245;;;;33858:416;;34058:2;34047:9;34043:18;34035:26;;34108:9;34102:4;34098:20;34094:1;34083:9;34079:17;34072:47;34133:131;34259:4;34133:131;;;34125:139;;34029:245;;;;34281:416;;34481:2;34470:9;34466:18;34458:26;;34531:9;34525:4;34521:20;34517:1;34506:9;34502:17;34495:47;34556:131;34682:4;34556:131;;;34548:139;;34452:245;;;;34704:416;;34904:2;34893:9;34889:18;34881:26;;34954:9;34948:4;34944:20;34940:1;34929:9;34925:17;34918:47;34979:131;35105:4;34979:131;;;34971:139;;34875:245;;;;35127:416;;35327:2;35316:9;35312:18;35304:26;;35377:9;35371:4;35367:20;35363:1;35352:9;35348:17;35341:47;35402:131;35528:4;35402:131;;;35394:139;;35298:245;;;;35550:416;;35750:2;35739:9;35735:18;35727:26;;35800:9;35794:4;35790:20;35786:1;35775:9;35771:17;35764:47;35825:131;35951:4;35825:131;;;35817:139;;35721:245;;;;35973:416;;36173:2;36162:9;36158:18;36150:26;;36223:9;36217:4;36213:20;36209:1;36198:9;36194:17;36187:47;36248:131;36374:4;36248:131;;;36240:139;;36144:245;;;;36396:416;;36596:2;36585:9;36581:18;36573:26;;36646:9;36640:4;36636:20;36632:1;36621:9;36617:17;36610:47;36671:131;36797:4;36671:131;;;36663:139;;36567:245;;;;36819:416;;37019:2;37008:9;37004:18;36996:26;;37069:9;37063:4;37059:20;37055:1;37044:9;37040:17;37033:47;37094:131;37220:4;37094:131;;;37086:139;;36990:245;;;;37242:416;;37442:2;37431:9;37427:18;37419:26;;37492:9;37486:4;37482:20;37478:1;37467:9;37463:17;37456:47;37517:131;37643:4;37517:131;;;37509:139;;37413:245;;;;37665:416;;37865:2;37854:9;37850:18;37842:26;;37915:9;37909:4;37905:20;37901:1;37890:9;37886:17;37879:47;37940:131;38066:4;37940:131;;;37932:139;;37836:245;;;;38088:222;;38215:2;38204:9;38200:18;38192:26;;38229:71;38297:1;38286:9;38282:17;38273:6;38229:71;;;38186:124;;;;;38317:556;;38528:3;38517:9;38513:19;38505:27;;38543:71;38611:1;38600:9;38596:17;38587:6;38543:71;;;38625:72;38693:2;38682:9;38678:18;38669:6;38625:72;;;38708;38776:2;38765:9;38761:18;38752:6;38708:72;;;38791;38859:2;38848:9;38844:18;38835:6;38791:72;;;38499:374;;;;;;;;38880:256;;38942:2;38936:9;38926:19;;38980:4;38972:6;38968:17;39079:6;39067:10;39064:22;39043:18;39031:10;39028:34;39025:62;39022:2;;;39100:1;39097;39090:12;39022:2;39120:10;39116:2;39109:22;38920:216;;;;;39143:304;;39302:18;39294:6;39291:30;39288:2;;;39334:1;39331;39324:12;39288:2;39369:4;39361:6;39357:17;39349:25;;39432:4;39426;39422:15;39414:23;;39225:222;;;;39454:314;;39623:18;39615:6;39612:30;39609:2;;;39655:1;39652;39645:12;39609:2;39690:4;39682:6;39678:17;39670:25;;39753:4;39747;39743:15;39735:23;;39546:222;;;;39775:303;;39933:18;39925:6;39922:30;39919:2;;;39965:1;39962;39955:12;39919:2;40000:4;39992:6;39988:17;39980:25;;40063:4;40057;40053:15;40045:23;;39856:222;;;;40085:321;;40228:18;40220:6;40217:30;40214:2;;;40260:1;40257;40250:12;40214:2;40327:4;40323:9;40316:4;40308:6;40304:17;40300:33;40292:41;;40391:4;40385;40381:15;40373:23;;40151:255;;;;40413:322;;40557:18;40549:6;40546:30;40543:2;;;40589:1;40586;40579:12;40543:2;40656:4;40652:9;40645:4;40637:6;40633:17;40629:33;40621:41;;40720:4;40714;40710:15;40702:23;;40480:255;;;;40742:158;;40810:3;40802:11;;40847:3;40844:1;40837:14;40879:4;40876:1;40866:18;40858:26;;40796:104;;;;40907:121;;41000:5;40994:12;40984:22;;40965:63;;;;41035:122;;41129:5;41123:12;41113:22;;41094:63;;;;41165:162;;41279:6;41274:3;41267:19;41316:4;41311:3;41307:14;41292:29;;41260:67;;;;;41336:144;;41471:3;41456:18;;41449:31;;;;;41489:163;;41604:6;41599:3;41592:19;41641:4;41636:3;41632:14;41617:29;;41585:67;;;;;41661:145;;41797:3;41782:18;;41775:31;;;;;41814:91;;41876:24;41894:5;41876:24;;;41865:35;;41859:46;;;;41912:99;;41982:24;42000:5;41982:24;;;41971:35;;41965:46;;;;42018:85;;42091:5;42084:13;42077:21;42066:32;;42060:43;;;;42110:144;;42182:66;42175:5;42171:78;42160:89;;42154:100;;;;42261:84;;42333:6;42326:5;42322:18;42311:29;;42305:40;;;;42352:121;;42425:42;42418:5;42414:54;42403:65;;42397:76;;;;42480:72;;42542:5;42531:16;;42525:27;;;;42560:145;42641:6;42636:3;42631;42618:30;42697:1;42688:6;42683:3;42679:16;42672:27;42611:94;;;;42714:268;42779:1;42786:101;42800:6;42797:1;42794:13;42786:101;;;42876:1;42871:3;42867:11;42861:18;42857:1;42852:3;42848:11;42841:39;42822:2;42819:1;42815:10;42810:15;;42786:101;;;42902:6;42899:1;42896:13;42893:2;;;42967:1;42958:6;42953:3;42949:16;42942:27;42893:2;42763:219;;;;;42990:103;;43062:26;43082:5;43062:26;;;43051:37;;43045:48;;;;43100:89;;43164:20;43178:5;43164:20;;;43153:31;;43147:42;;;;43196:74;;43260:5;43249:16;;43243:27;;;;43277:97;;43365:2;43361:7;43356:2;43349:5;43345:14;43341:28;43331:38;;43325:49;;;;43382:94;;43460:5;43456:2;43452:14;43430:36;;43424:52;;;;43484:117;43553:24;43571:5;43553:24;;;43546:5;43543:35;43533:2;;43592:1;43589;43582:12;43533:2;43527:74;;43608:111;43674:21;43689:5;43674:21;;;43667:5;43664:32;43654:2;;43710:1;43707;43700:12;43654:2;43648:71;;43726:115;43794:23;43811:5;43794:23;;;43787:5;43784:34;43774:2;;43832:1;43829;43822:12;43774:2;43768:73;;43848:115;43916:23;43933:5;43916:23;;;43909:5;43906:34;43896:2;;43954:1;43951;43944:12;43896:2;43890:73;;43970:117;44039:24;44057:5;44039:24;;;44032:5;44029:35;44019:2;;44078:1;44075;44068:12;44019:2;44013:74;

Swarm Source

ipfs://fb23bb545380ce85bcdd2a77aaf7bfddd5a0988f64ed3d76c168ecb07a2e7bb5

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