Token

SoldOutConsoles (SOLDOUT)

ERC-721

Overview

Max Total Supply

1,000 SOLDOUT

Holders

136

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x40f5a619e9626cac24217ab3c48d411979e0d06e

Filtered by Token Holder

0x456983A92BEC3B3Eb9442AE77AC3485828F6bCEB

*traderjoe’s.eth

Balance

11 SOLDOUT

0x456983a92bec3b3eb9442ae77ac3485828f6bceb

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SoldOutConsoles

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-10-09
*/

/**
 *Submitted for verification at Etherscan.io on 2021-10-05
*/

// SPDX-License-Identifier: MIT

pragma solidity >= 0.8.4;

/*
 * @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) {
        return msg.sender;
    }

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

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

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

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

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

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

/**
 * @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 () {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

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

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

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

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

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

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

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

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

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

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

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

            MapEntry storage lastEntry = map._entries[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

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

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

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

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Base URI
    string private _baseURI;

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

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

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

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

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

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

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

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

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

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

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

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

        
        
       // return string(abi.encodePacked(base, tokenId.toString()));
    }

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

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

/**
 * @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 () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

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

/**
 * @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract SoldOutConsoles is ERC721, Ownable {
    using SafeMath for uint256;

    uint256 public nftPrice = 15000000000000000; //0.015 eth
    uint public constant maxNftPurchase = 15;
    uint256 public maximumSupply;
    bool public saleIsActive = false;


   



    constructor() ERC721("SoldOutConsoles", "SOLDOUT") {
        maximumSupply = 1000;
    }



    function setNftPrice(uint256 price) external onlyOwner {
        nftPrice = price;
    }

    function withdraw() external onlyOwner {
        uint256 balance = address(this).balance;
        payable(owner()).transfer(balance);
    }




    function reserveNfts(uint256 _count) public onlyOwner {        
        uint supply = totalSupply();
        uint i;
        for (i = 0; i < _count; i++) {
            _safeMint(msg.sender, supply + i);
        }
    }

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

    /*
    * Pause sale if active, make active if paused
    */
    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }





    


    function mint(uint numberOfTokens) public payable {
        require(saleIsActive, "Sale must be active to mint.");
        require(numberOfTokens <= maxNftPurchase, "Can only mint 15 per transaction.");
        require(totalSupply().add(numberOfTokens) <= maximumSupply, "Purchase would exceed max supply.");
        require(nftPrice.mul(numberOfTokens) <= msg.value, "Wrong ether value sent.");
        
        for(uint i = 0; i < numberOfTokens; i++) {
            uint mintIndex = totalSupply();
            if (totalSupply() < maximumSupply) {
                _safeMint(msg.sender, mintIndex);
            }
        }
    }


}

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":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxNftPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maximumSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"reserveNfts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"name":"setNftPrice","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

66872:1808:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9602:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67067:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51408:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54414:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53944:404;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66958:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53422:211;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67512:224;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55304:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53184:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67918:89;;;;;;;;;;;;;:::i;:::-;;67356:142;;;;;;;;;;;;;:::i;:::-;;55680:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53710:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67744:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51164:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53003:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50881:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66236:148;;;;;;;;;;;;;:::i;:::-;;67258:90;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65585:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51577:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68033:640;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54707:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55902:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67020:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51752:1012;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55073:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67102:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66539:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;9602:150;9687:4;9711:20;:33;9732:11;9711:33;;;;;;;;;;;;;;;;;;;;;;;;;;;9704:40;;9602:150;;;:::o;67067:28::-;;;;:::o;51408:100::-;51462:13;51495:5;51488:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51408:100;:::o;54414:221::-;54490:7;54518:16;54526:7;54518;:16::i;:::-;54510:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;54603:15;:24;54619:7;54603:24;;;;;;;;;;;;;;;;;;;;;54596:31;;54414:221;;;:::o;53944:404::-;54025:13;54041:23;54056:7;54041:14;:23::i;:::-;54025:39;;54089:5;54083:11;;:2;:11;;;;54075:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;54169:5;54153:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;54178:44;54202:5;54209:12;:10;:12::i;:::-;54178:23;:44::i;:::-;54153:69;54145:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;54319:21;54328:2;54332:7;54319:8;:21::i;:::-;53944:404;;;:::o;66958:43::-;;;;:::o;53422:211::-;53483:7;53604:21;:12;:19;:21::i;:::-;53597:28;;53422:211;:::o;67512:224::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67585:11:::1;67599:13;:11;:13::i;:::-;67585:27;;67623:6;67640:89;67656:6;67652:1;:10;67640:89;;;67684:33;67694:10;67715:1;67706:6;:10;;;;:::i;:::-;67684:9;:33::i;:::-;67664:3;;;;;:::i;:::-;;;;67640:89;;;65876:1;;67512:224:::0;:::o;55304:305::-;55465:41;55484:12;:10;:12::i;:::-;55498:7;55465:18;:41::i;:::-;55457:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;55573:28;55583:4;55589:2;55593:7;55573:9;:28::i;:::-;55304:305;;;:::o;53184:162::-;53281:7;53308:30;53332:5;53308:13;:20;53322:5;53308:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;53301:37;;53184:162;;;;:::o;67918:89::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67987:12:::1;;;;;;;;;;;67986:13;67971:12;;:28;;;;;;;;;;;;;;;;;;67918:89::o:0;67356:142::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67406:15:::1;67424:21;67406:39;;67464:7;:5;:7::i;:::-;67456:25;;:34;67482:7;67456:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;65876:1;67356:142::o:0;55680:151::-;55784:39;55801:4;55807:2;55811:7;55784:39;;;;;;;;;;;;:16;:39::i;:::-;55680:151;;;:::o;53710:172::-;53785:7;53806:15;53827:22;53843:5;53827:12;:15;;:22;;;;:::i;:::-;53805:44;;;53867:7;53860:14;;;53710:172;;;:::o;67744:99::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67815:20:::1;67827:7;67815:11;:20::i;:::-;67744:99:::0;:::o;51164:177::-;51236:7;51263:70;51280:7;51263:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;51256:77;;51164:177;;;:::o;53003:97::-;53051:13;53084:8;53077:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53003:97;:::o;50881:221::-;50953:7;50998:1;50981:19;;:5;:19;;;;50973:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;51065:29;:13;:20;51079:5;51065:20;;;;;;;;;;;;;;;:27;:29::i;:::-;51058:36;;50881:221;;;:::o;66236:148::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66343:1:::1;66306:40;;66327:6;;;;;;;;;;;66306:40;;;;;;;;;;;;66374:1;66357:6;;:19;;;;;;;;;;;;;;;;;;66236:148::o:0;67258:90::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67335:5:::1;67324:8;:16;;;;67258:90:::0;:::o;65585:87::-;65631:7;65658:6;;;;;;;;;;;65651:13;;65585:87;:::o;51577:104::-;51633:13;51666:7;51659:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51577:104;:::o;68033:640::-;68102:12;;;;;;;;;;;68094:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;67058:2;68166:14;:32;;68158:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;68292:13;;68255:33;68273:14;68255:13;:11;:13::i;:::-;:17;;:33;;;;:::i;:::-;:50;;68247:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;68394:9;68362:28;68375:14;68362:8;;:12;;:28;;;;:::i;:::-;:41;;68354:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;68456:6;68452:214;68472:14;68468:1;:18;68452:214;;;68508:14;68525:13;:11;:13::i;:::-;68508:30;;68573:13;;68557;:11;:13::i;:::-;:29;68553:102;;;68607:32;68617:10;68629:9;68607;:32::i;:::-;68553:102;68452:214;68488:3;;;;;:::i;:::-;;;;68452:214;;;;68033:640;:::o;54707:295::-;54822:12;:10;:12::i;:::-;54810:24;;:8;:24;;;;54802:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;54922:8;54877:18;:32;54896:12;:10;:12::i;:::-;54877:32;;;;;;;;;;;;;;;:42;54910:8;54877:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;54975:8;54946:48;;54961:12;:10;:12::i;:::-;54946:48;;;54985:8;54946:48;;;;;;:::i;:::-;;;;;;;;54707:295;;:::o;55902:285::-;56034:41;56053:12;:10;:12::i;:::-;56067:7;56034:18;:41::i;:::-;56026:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;56140:39;56154:4;56160:2;56164:7;56173:5;56140:13;:39::i;:::-;55902:285;;;;:::o;67020:40::-;67058:2;67020:40;:::o;51752:1012::-;51825:13;51859:16;51867:7;51859;:16::i;:::-;51851:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;51940:23;51966:10;:19;51977:7;51966:19;;;;;;;;;;;51940:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51996:18;52017:9;:7;:9::i;:::-;51996:30;;52124:1;52108:4;52102:18;:23;52098:72;;;52149:9;52142:16;;;;;;52098:72;52300:1;52280:9;52274:23;:27;52270:108;;;52349:4;52355:9;52332:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52318:48;;;;;;52270:108;52499:1;52494;52483:7;:12;;;;:::i;:::-;:17;52479:176;;;52544:4;52527:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;52513:48;;;;;;52479:176;52625:4;52608:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;52594:45;;;;51752:1012;;;;:::o;55073:164::-;55170:4;55194:18;:25;55213:5;55194:25;;;;;;;;;;;;;;;:35;55220:8;55194:35;;;;;;;;;;;;;;;;;;;;;;;;;55187:42;;55073:164;;;;:::o;67102:32::-;;;;;;;;;;;;;:::o;66539:244::-;65816:12;:10;:12::i;:::-;65805:23;;:7;:5;:7::i;:::-;:23;;;65797:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66648:1:::1;66628:22;;:8;:22;;;;66620:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;66738:8;66709:38;;66730:6;;;;;;;;;;;66709:38;;;;;;;;;;;;66767:8;66758:6;;:17;;;;;;;;;;;;;;;;;;66539:244:::0;:::o;57654:127::-;57719:4;57743:30;57765:7;57743:12;:21;;:30;;;;:::i;:::-;57736:37;;57654:127;;;:::o;678:98::-;731:7;758:10;751:17;;678:98;:::o;63672:192::-;63774:2;63747:15;:24;63763:7;63747:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;63830:7;63826:2;63792:46;;63801:23;63816:7;63801:14;:23::i;:::-;63792:46;;;;;;;;;;;;63672:192;;:::o;43292:123::-;43361:7;43388:19;43396:3;:10;;43388:7;:19::i;:::-;43381:26;;43292:123;;;:::o;58646:110::-;58722:26;58732:2;58736:7;58722:26;;;;;;;;;;;;:9;:26::i;:::-;58646:110;;:::o;57948:355::-;58041:4;58066:16;58074:7;58066;:16::i;:::-;58058:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58142:13;58158:23;58173:7;58158:14;:23::i;:::-;58142:39;;58211:5;58200:16;;:7;:16;;;:51;;;;58244:7;58220:31;;:20;58232:7;58220:11;:20::i;:::-;:31;;;58200:51;:94;;;;58255:39;58279:5;58286:7;58255:23;:39::i;:::-;58200:94;58192:103;;;57948:355;;;;:::o;61084:599::-;61209:4;61182:31;;:23;61197:7;61182:14;:23::i;:::-;:31;;;61174:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;61310:1;61296:16;;:2;:16;;;;61288:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;61366:39;61387:4;61393:2;61397:7;61366:20;:39::i;:::-;61470:29;61487:1;61491:7;61470:8;:29::i;:::-;61512:35;61539:7;61512:13;:19;61526:4;61512:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;61558:30;61580:7;61558:13;:17;61572:2;61558:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;61601:29;61618:7;61627:2;61601:12;:16;;:29;;;;;:::i;:::-;;61667:7;61663:2;61648:27;;61657:4;61648:27;;;;;;;;;;;;61084:599;;;:::o;35182:137::-;35253:7;35288:22;35292:3;:10;;35304:5;35288:3;:22::i;:::-;35280:31;;35273:38;;35182:137;;;;:::o;43754:236::-;43834:7;43843;43864:11;43877:13;43894:22;43898:3;:10;;43910:5;43894:3;:22::i;:::-;43863:53;;;;43943:3;43935:12;;43973:5;43965:14;;43927:55;;;;;;43754:236;;;;;:::o;62284:100::-;62368:8;62357;:19;;;;;;;;;;;;:::i;:::-;;62284:100;:::o;45040:213::-;45147:7;45198:44;45203:3;:10;;45223:3;45215:12;;45229;45198:4;:44::i;:::-;45190:53;;45167:78;;45040:213;;;;;:::o;34724:114::-;34784:7;34811:19;34819:3;:10;;34811:7;:19::i;:::-;34804:26;;34724:114;;;:::o;13071:179::-;13129:7;13149:9;13165:1;13161;:5;;;;:::i;:::-;13149:17;;13190:1;13185;:6;;13177:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;13241:1;13234:8;;;13071:179;;;;:::o;13950:220::-;14008:7;14037:1;14032;:6;14028:20;;;14047:1;14040:8;;;;14028:20;14059:9;14075:1;14071;:5;;;;:::i;:::-;14059:17;;14104:1;14099;14095;:5;;;;:::i;:::-;:10;14087:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;14161:1;14154:8;;;13950:220;;;;;:::o;57069:272::-;57183:28;57193:4;57199:2;57203:7;57183:9;:28::i;:::-;57230:48;57253:4;57259:2;57263:7;57272:5;57230:22;:48::i;:::-;57222:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;57069:272;;;;:::o;43053:151::-;43137:4;43161:35;43171:3;:10;;43191:3;43183:12;;43161:9;:35::i;:::-;43154:42;;43053:151;;;;:::o;39871:110::-;39927:7;39954:3;:12;;:19;;;;39947:26;;39871:110;;;:::o;58983:250::-;59079:18;59085:2;59089:7;59079:5;:18::i;:::-;59116:54;59147:1;59151:2;59155:7;59164:5;59116:22;:54::i;:::-;59108:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;58983:250;;;:::o;64477:93::-;;;;:::o;34269:137::-;34339:4;34363:35;34371:3;:10;;34391:5;34383:14;;34363:7;:35::i;:::-;34356:42;;34269:137;;;;:::o;33962:131::-;34029:4;34053:32;34058:3;:10;;34078:5;34070:14;;34053:4;:32::i;:::-;34046:39;;33962:131;;;;:::o;42476:185::-;42565:4;42589:64;42594:3;:10;;42614:3;42606:12;;42644:5;42628:23;;42620:32;;42589:4;:64::i;:::-;42582:71;;42476:185;;;;;:::o;30220:204::-;30287:7;30336:5;30315:3;:11;;:18;;;;:26;30307:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;30398:3;:11;;30410:5;30398:18;;;;;;;;;;;;;;;;;;;;;;;;30391:25;;30220:204;;;;:::o;40336:279::-;40403:7;40412;40462:5;40440:3;:12;;:19;;;;:27;40432:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;40519:22;40544:3;:12;;40557:5;40544:19;;;;;;;;;;;;;;;;;;;;;;;;;;40519:44;;40582:5;:10;;;40594:5;:12;;;40574:33;;;;;40336:279;;;;;:::o;41833:319::-;41927:7;41947:16;41966:3;:12;;:17;41979:3;41966:17;;;;;;;;;;;;41947:36;;42014:1;42002:8;:13;;42017:12;41994:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;42084:3;:12;;42108:1;42097:8;:12;;;;:::i;:::-;42084:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;;42077:40;;;41833:319;;;;;:::o;29767:109::-;29823:7;29850:3;:11;;:18;;;;29843:25;;29767:109;;;:::o;62949:604::-;63070:4;63097:15;:2;:13;;;:15::i;:::-;63092:60;;63136:4;63129:11;;;;63092:60;63162:23;63188:252;63241:45;;;63301:12;:10;:12::i;:::-;63328:4;63347:7;63369:5;63204:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63188:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;63162:278;;63451:13;63478:10;63467:32;;;;;;;;;;;;:::i;:::-;63451:48;;47884:10;63528:16;;63518:26;;;:6;:26;;;;63510:35;;;;62949:604;;;;;;;:::o;39651:125::-;39722:4;39767:1;39746:3;:12;;:17;39759:3;39746:17;;;;;;;;;;;;:22;;39739:29;;39651:125;;;;:::o;59569:404::-;59663:1;59649:16;;:2;:16;;;;59641:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;59722:16;59730:7;59722;:16::i;:::-;59721:17;59713:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;59784:45;59813:1;59817:2;59821:7;59784:20;:45::i;:::-;59842:30;59864:7;59842:13;:17;59856:2;59842:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;59885:29;59902:7;59911:2;59885:12;:16;;:29;;;;;:::i;:::-;;59957:7;59953:2;59932:33;;59949:1;59932:33;;;;;;;;;;;;59569:404;;:::o;27922:1544::-;27988:4;28106:18;28127:3;:12;;:19;28140:5;28127:19;;;;;;;;;;;;28106:40;;28177:1;28163:10;:15;28159:1300;;28525:21;28562:1;28549:10;:14;;;;:::i;:::-;28525:38;;28578:17;28619:1;28598:3;:11;;:18;;;;:22;;;;:::i;:::-;28578:42;;28865:17;28885:3;:11;;28897:9;28885:22;;;;;;;;;;;;;;;;;;;;;;;;28865:42;;29031:9;29002:3;:11;;29014:13;29002:26;;;;;;;;;;;;;;;;;;;;;;;:38;;;;29150:1;29134:13;:17;;;;:::i;:::-;29108:3;:12;;:23;29121:9;29108:23;;;;;;;;;;;:43;;;;29260:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29355:3;:12;;:19;29368:5;29355:19;;;;;;;;;;;29348:26;;;29398:4;29391:11;;;;;;;;28159:1300;29442:5;29435:12;;;27922:1544;;;;;:::o;27332:414::-;27395:4;27417:21;27427:3;27432:5;27417:9;:21::i;:::-;27412:327;;27455:3;:11;;27472:5;27455:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27638:3;:11;;:18;;;;27616:3;:12;;:19;27629:5;27616:19;;;;;;;;;;;:40;;;;27678:4;27671:11;;;;27412:327;27722:5;27715:12;;27332:414;;;;;:::o;37151:692::-;37227:4;37343:16;37362:3;:12;;:17;37375:3;37362:17;;;;;;;;;;;;37343:36;;37408:1;37396:8;:13;37392:444;;;37463:3;:12;;37481:38;;;;;;;;37498:3;37481:38;;;;37511:5;37481:38;;;37463:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37678:3;:12;;:19;;;;37658:3;:12;;:17;37671:3;37658:17;;;;;;;;;;;:39;;;;37719:4;37712:11;;;;;37392:444;37792:5;37756:3;:12;;37780:1;37769:8;:12;;;;:::i;:::-;37756:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;:41;;;;37819:5;37812:12;;;37151:692;;;;;;:::o;18419:422::-;18479:4;18687:12;18798:7;18786:20;18778:28;;18832:1;18825:4;:8;18818:15;;;18419:422;;;:::o;21368:195::-;21471:12;21503:52;21525:6;21533:4;21539:1;21542:12;21503:21;:52::i;:::-;21496:59;;21368:195;;;;;:::o;29552:129::-;29625:4;29672:1;29649:3;:12;;:19;29662:5;29649:19;;;;;;;;;;;;:24;;29642:31;;29552:129;;;;:::o;22420:530::-;22547:12;22605:5;22580:21;:30;;22572:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;22672:18;22683:6;22672:10;:18::i;:::-;22664:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;22798:12;22812:23;22839:6;:11;;22859:5;22867:4;22839:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22797:75;;;;22890:52;22908:7;22917:10;22929:12;22890:17;:52::i;:::-;22883:59;;;;22420:530;;;;;;:::o;24960:742::-;25075:12;25104:7;25100:595;;;25135:10;25128:17;;;;25100:595;25269:1;25249:10;:17;:21;25245:439;;;25512:10;25506:17;25573:15;25560:10;25556:2;25552:19;25545:44;25460:148;25655:12;25648:20;;;;;;;;;;;:::i;:::-;;;;;;;;24960:742;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:343:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:2;;;290:1;287;280:12;249:2;303:41;337:6;332:3;327;303:41;:::i;:::-;90:260;;;;;;:::o;356:345::-;434:5;459:66;475:49;517:6;475:49;:::i;:::-;459:66;:::i;:::-;450:75;;548:6;541:5;534:21;586:4;579:5;575:16;624:3;615:6;610:3;606:16;603:25;600:2;;;641:1;638;631:12;600:2;654:41;688:6;683:3;678;654:41;:::i;:::-;440:261;;;;;;:::o;707:139::-;753:5;791:6;778:20;769:29;;807:33;834:5;807:33;:::i;:::-;759:87;;;;:::o;852:133::-;895:5;933:6;920:20;911:29;;949:30;973:5;949:30;:::i;:::-;901:84;;;;:::o;991:137::-;1036:5;1074:6;1061:20;1052:29;;1090:32;1116:5;1090:32;:::i;:::-;1042:86;;;;:::o;1134:141::-;1190:5;1221:6;1215:13;1206:22;;1237:32;1263:5;1237:32;:::i;:::-;1196:79;;;;:::o;1294:271::-;1349:5;1398:3;1391:4;1383:6;1379:17;1375:27;1365:2;;1416:1;1413;1406:12;1365:2;1456:6;1443:20;1481:78;1555:3;1547:6;1540:4;1532:6;1528:17;1481:78;:::i;:::-;1472:87;;1355:210;;;;;:::o;1585:273::-;1641:5;1690:3;1683:4;1675:6;1671:17;1667:27;1657:2;;1708:1;1705;1698:12;1657:2;1748:6;1735:20;1773:79;1848:3;1840:6;1833:4;1825:6;1821:17;1773:79;:::i;:::-;1764:88;;1647:211;;;;;:::o;1864:139::-;1910:5;1948:6;1935:20;1926:29;;1964:33;1991:5;1964:33;:::i;:::-;1916:87;;;;:::o;2009:262::-;2068:6;2117:2;2105:9;2096:7;2092:23;2088:32;2085:2;;;2133:1;2130;2123:12;2085:2;2176:1;2201:53;2246:7;2237:6;2226:9;2222:22;2201:53;:::i;:::-;2191:63;;2147:117;2075:196;;;;:::o;2277:407::-;2345:6;2353;2402:2;2390:9;2381:7;2377:23;2373:32;2370:2;;;2418:1;2415;2408:12;2370:2;2461:1;2486:53;2531:7;2522:6;2511:9;2507:22;2486:53;:::i;:::-;2476:63;;2432:117;2588:2;2614:53;2659:7;2650:6;2639:9;2635:22;2614:53;:::i;:::-;2604:63;;2559:118;2360:324;;;;;:::o;2690:552::-;2767:6;2775;2783;2832:2;2820:9;2811:7;2807:23;2803:32;2800:2;;;2848:1;2845;2838:12;2800:2;2891:1;2916:53;2961:7;2952:6;2941:9;2937:22;2916:53;:::i;:::-;2906:63;;2862:117;3018:2;3044:53;3089:7;3080:6;3069:9;3065:22;3044:53;:::i;:::-;3034:63;;2989:118;3146:2;3172:53;3217:7;3208:6;3197:9;3193:22;3172:53;:::i;:::-;3162:63;;3117:118;2790:452;;;;;:::o;3248:809::-;3343:6;3351;3359;3367;3416:3;3404:9;3395:7;3391:23;3387:33;3384:2;;;3433:1;3430;3423:12;3384:2;3476:1;3501:53;3546:7;3537:6;3526:9;3522:22;3501:53;:::i;:::-;3491:63;;3447:117;3603:2;3629:53;3674:7;3665:6;3654:9;3650:22;3629:53;:::i;:::-;3619:63;;3574:118;3731:2;3757:53;3802:7;3793:6;3782:9;3778:22;3757:53;:::i;:::-;3747:63;;3702:118;3887:2;3876:9;3872:18;3859:32;3918:18;3910:6;3907:30;3904:2;;;3950:1;3947;3940:12;3904:2;3978:62;4032:7;4023:6;4012:9;4008:22;3978:62;:::i;:::-;3968:72;;3830:220;3374:683;;;;;;;:::o;4063:401::-;4128:6;4136;4185:2;4173:9;4164:7;4160:23;4156:32;4153:2;;;4201:1;4198;4191:12;4153:2;4244:1;4269:53;4314:7;4305:6;4294:9;4290:22;4269:53;:::i;:::-;4259:63;;4215:117;4371:2;4397:50;4439:7;4430:6;4419:9;4415:22;4397:50;:::i;:::-;4387:60;;4342:115;4143:321;;;;;:::o;4470:407::-;4538:6;4546;4595:2;4583:9;4574:7;4570:23;4566:32;4563:2;;;4611:1;4608;4601:12;4563:2;4654:1;4679:53;4724:7;4715:6;4704:9;4700:22;4679:53;:::i;:::-;4669:63;;4625:117;4781:2;4807:53;4852:7;4843:6;4832:9;4828:22;4807:53;:::i;:::-;4797:63;;4752:118;4553:324;;;;;:::o;4883:260::-;4941:6;4990:2;4978:9;4969:7;4965:23;4961:32;4958:2;;;5006:1;5003;4996:12;4958:2;5049:1;5074:52;5118:7;5109:6;5098:9;5094:22;5074:52;:::i;:::-;5064:62;;5020:116;4948:195;;;;:::o;5149:282::-;5218:6;5267:2;5255:9;5246:7;5242:23;5238:32;5235:2;;;5283:1;5280;5273:12;5235:2;5326:1;5351:63;5406:7;5397:6;5386:9;5382:22;5351:63;:::i;:::-;5341:73;;5297:127;5225:206;;;;:::o;5437:375::-;5506:6;5555:2;5543:9;5534:7;5530:23;5526:32;5523:2;;;5571:1;5568;5561:12;5523:2;5642:1;5631:9;5627:17;5614:31;5672:18;5664:6;5661:30;5658:2;;;5704:1;5701;5694:12;5658:2;5732:63;5787:7;5778:6;5767:9;5763:22;5732:63;:::i;:::-;5722:73;;5585:220;5513:299;;;;:::o;5818:262::-;5877:6;5926:2;5914:9;5905:7;5901:23;5897:32;5894:2;;;5942:1;5939;5932:12;5894:2;5985:1;6010:53;6055:7;6046:6;6035:9;6031:22;6010:53;:::i;:::-;6000:63;;5956:117;5884:196;;;;:::o;6086:118::-;6173:24;6191:5;6173:24;:::i;:::-;6168:3;6161:37;6151:53;;:::o;6210:109::-;6291:21;6306:5;6291:21;:::i;:::-;6286:3;6279:34;6269:50;;:::o;6325:360::-;6411:3;6439:38;6471:5;6439:38;:::i;:::-;6493:70;6556:6;6551:3;6493:70;:::i;:::-;6486:77;;6572:52;6617:6;6612:3;6605:4;6598:5;6594:16;6572:52;:::i;:::-;6649:29;6671:6;6649:29;:::i;:::-;6644:3;6640:39;6633:46;;6415:270;;;;;:::o;6691:373::-;6795:3;6823:38;6855:5;6823:38;:::i;:::-;6877:88;6958:6;6953:3;6877:88;:::i;:::-;6870:95;;6974:52;7019:6;7014:3;7007:4;7000:5;6996:16;6974:52;:::i;:::-;7051:6;7046:3;7042:16;7035:23;;6799:265;;;;;:::o;7070:364::-;7158:3;7186:39;7219:5;7186:39;:::i;:::-;7241:71;7305:6;7300:3;7241:71;:::i;:::-;7234:78;;7321:52;7366:6;7361:3;7354:4;7347:5;7343:16;7321:52;:::i;:::-;7398:29;7420:6;7398:29;:::i;:::-;7393:3;7389:39;7382:46;;7162:272;;;;;:::o;7440:377::-;7546:3;7574:39;7607:5;7574:39;:::i;:::-;7629:89;7711:6;7706:3;7629:89;:::i;:::-;7622:96;;7727:52;7772:6;7767:3;7760:4;7753:5;7749:16;7727:52;:::i;:::-;7804:6;7799:3;7795:16;7788:23;;7550:267;;;;;:::o;7823:366::-;7965:3;7986:67;8050:2;8045:3;7986:67;:::i;:::-;7979:74;;8062:93;8151:3;8062:93;:::i;:::-;8180:2;8175:3;8171:12;8164:19;;7969:220;;;:::o;8195:366::-;8337:3;8358:67;8422:2;8417:3;8358:67;:::i;:::-;8351:74;;8434:93;8523:3;8434:93;:::i;:::-;8552:2;8547:3;8543:12;8536:19;;8341:220;;;:::o;8567:366::-;8709:3;8730:67;8794:2;8789:3;8730:67;:::i;:::-;8723:74;;8806:93;8895:3;8806:93;:::i;:::-;8924:2;8919:3;8915:12;8908:19;;8713:220;;;:::o;8939:366::-;9081:3;9102:67;9166:2;9161:3;9102:67;:::i;:::-;9095:74;;9178:93;9267:3;9178:93;:::i;:::-;9296:2;9291:3;9287:12;9280:19;;9085:220;;;:::o;9311:366::-;9453:3;9474:67;9538:2;9533:3;9474:67;:::i;:::-;9467:74;;9550:93;9639:3;9550:93;:::i;:::-;9668:2;9663:3;9659:12;9652:19;;9457:220;;;:::o;9683:366::-;9825:3;9846:67;9910:2;9905:3;9846:67;:::i;:::-;9839:74;;9922:93;10011:3;9922:93;:::i;:::-;10040:2;10035:3;10031:12;10024:19;;9829:220;;;:::o;10055:366::-;10197:3;10218:67;10282:2;10277:3;10218:67;:::i;:::-;10211:74;;10294:93;10383:3;10294:93;:::i;:::-;10412:2;10407:3;10403:12;10396:19;;10201:220;;;:::o;10427:366::-;10569:3;10590:67;10654:2;10649:3;10590:67;:::i;:::-;10583:74;;10666:93;10755:3;10666:93;:::i;:::-;10784:2;10779:3;10775:12;10768:19;;10573:220;;;:::o;10799:366::-;10941:3;10962:67;11026:2;11021:3;10962:67;:::i;:::-;10955:74;;11038:93;11127:3;11038:93;:::i;:::-;11156:2;11151:3;11147:12;11140:19;;10945:220;;;:::o;11171:366::-;11313:3;11334:67;11398:2;11393:3;11334:67;:::i;:::-;11327:74;;11410:93;11499:3;11410:93;:::i;:::-;11528:2;11523:3;11519:12;11512:19;;11317:220;;;:::o;11543:366::-;11685:3;11706:67;11770:2;11765:3;11706:67;:::i;:::-;11699:74;;11782:93;11871:3;11782:93;:::i;:::-;11900:2;11895:3;11891:12;11884:19;;11689:220;;;:::o;11915:366::-;12057:3;12078:67;12142:2;12137:3;12078:67;:::i;:::-;12071:74;;12154:93;12243:3;12154:93;:::i;:::-;12272:2;12267:3;12263:12;12256:19;;12061:220;;;:::o;12287:366::-;12429:3;12450:67;12514:2;12509:3;12450:67;:::i;:::-;12443:74;;12526:93;12615:3;12526:93;:::i;:::-;12644:2;12639:3;12635:12;12628:19;;12433:220;;;:::o;12659:366::-;12801:3;12822:67;12886:2;12881:3;12822:67;:::i;:::-;12815:74;;12898:93;12987:3;12898:93;:::i;:::-;13016:2;13011:3;13007:12;13000:19;;12805:220;;;:::o;13031:366::-;13173:3;13194:67;13258:2;13253:3;13194:67;:::i;:::-;13187:74;;13270:93;13359:3;13270:93;:::i;:::-;13388:2;13383:3;13379:12;13372:19;;13177:220;;;:::o;13403:366::-;13545:3;13566:67;13630:2;13625:3;13566:67;:::i;:::-;13559:74;;13642:93;13731:3;13642:93;:::i;:::-;13760:2;13755:3;13751:12;13744:19;;13549:220;;;:::o;13775:366::-;13917:3;13938:67;14002:2;13997:3;13938:67;:::i;:::-;13931:74;;14014:93;14103:3;14014:93;:::i;:::-;14132:2;14127:3;14123:12;14116:19;;13921:220;;;:::o;14147:366::-;14289:3;14310:67;14374:2;14369:3;14310:67;:::i;:::-;14303:74;;14386:93;14475:3;14386:93;:::i;:::-;14504:2;14499:3;14495:12;14488:19;;14293:220;;;:::o;14519:366::-;14661:3;14682:67;14746:2;14741:3;14682:67;:::i;:::-;14675:74;;14758:93;14847:3;14758:93;:::i;:::-;14876:2;14871:3;14867:12;14860:19;;14665:220;;;:::o;14891:366::-;15033:3;15054:67;15118:2;15113:3;15054:67;:::i;:::-;15047:74;;15130:93;15219:3;15130:93;:::i;:::-;15248:2;15243:3;15239:12;15232:19;;15037:220;;;:::o;15263:366::-;15405:3;15426:67;15490:2;15485:3;15426:67;:::i;:::-;15419:74;;15502:93;15591:3;15502:93;:::i;:::-;15620:2;15615:3;15611:12;15604:19;;15409:220;;;:::o;15635:366::-;15777:3;15798:67;15862:2;15857:3;15798:67;:::i;:::-;15791:74;;15874:93;15963:3;15874:93;:::i;:::-;15992:2;15987:3;15983:12;15976:19;;15781:220;;;:::o;16007:366::-;16149:3;16170:67;16234:2;16229:3;16170:67;:::i;:::-;16163:74;;16246:93;16335:3;16246:93;:::i;:::-;16364:2;16359:3;16355:12;16348:19;;16153:220;;;:::o;16379:366::-;16521:3;16542:67;16606:2;16601:3;16542:67;:::i;:::-;16535:74;;16618:93;16707:3;16618:93;:::i;:::-;16736:2;16731:3;16727:12;16720:19;;16525:220;;;:::o;16751:366::-;16893:3;16914:67;16978:2;16973:3;16914:67;:::i;:::-;16907:74;;16990:93;17079:3;16990:93;:::i;:::-;17108:2;17103:3;17099:12;17092:19;;16897:220;;;:::o;17123:400::-;17283:3;17304:84;17386:1;17381:3;17304:84;:::i;:::-;17297:91;;17397:93;17486:3;17397:93;:::i;:::-;17515:1;17510:3;17506:11;17499:18;;17287:236;;;:::o;17529:400::-;17689:3;17710:84;17792:1;17787:3;17710:84;:::i;:::-;17703:91;;17803:93;17892:3;17803:93;:::i;:::-;17921:1;17916:3;17912:11;17905:18;;17693:236;;;:::o;17935:118::-;18022:24;18040:5;18022:24;:::i;:::-;18017:3;18010:37;18000:53;;:::o;18059:271::-;18189:3;18211:93;18300:3;18291:6;18211:93;:::i;:::-;18204:100;;18321:3;18314:10;;18193:137;;;;:::o;18336:435::-;18516:3;18538:95;18629:3;18620:6;18538:95;:::i;:::-;18531:102;;18650:95;18741:3;18732:6;18650:95;:::i;:::-;18643:102;;18762:3;18755:10;;18520:251;;;;;:::o;18777:541::-;19010:3;19032:95;19123:3;19114:6;19032:95;:::i;:::-;19025:102;;19144:148;19288:3;19144:148;:::i;:::-;19137:155;;19309:3;19302:10;;19014:304;;;;:::o;19324:541::-;19557:3;19579:95;19670:3;19661:6;19579:95;:::i;:::-;19572:102;;19691:148;19835:3;19691:148;:::i;:::-;19684:155;;19856:3;19849:10;;19561:304;;;;:::o;19871:222::-;19964:4;20002:2;19991:9;19987:18;19979:26;;20015:71;20083:1;20072:9;20068:17;20059:6;20015:71;:::i;:::-;19969:124;;;;:::o;20099:640::-;20294:4;20332:3;20321:9;20317:19;20309:27;;20346:71;20414:1;20403:9;20399:17;20390:6;20346:71;:::i;:::-;20427:72;20495:2;20484:9;20480:18;20471:6;20427:72;:::i;:::-;20509;20577:2;20566:9;20562:18;20553:6;20509:72;:::i;:::-;20628:9;20622:4;20618:20;20613:2;20602:9;20598:18;20591:48;20656:76;20727:4;20718:6;20656:76;:::i;:::-;20648:84;;20299:440;;;;;;;:::o;20745:210::-;20832:4;20870:2;20859:9;20855:18;20847:26;;20883:65;20945:1;20934:9;20930:17;20921:6;20883:65;:::i;:::-;20837:118;;;;:::o;20961:313::-;21074:4;21112:2;21101:9;21097:18;21089:26;;21161:9;21155:4;21151:20;21147:1;21136:9;21132:17;21125:47;21189:78;21262:4;21253:6;21189:78;:::i;:::-;21181:86;;21079:195;;;;:::o;21280:419::-;21446:4;21484:2;21473:9;21469:18;21461:26;;21533:9;21527:4;21523:20;21519:1;21508:9;21504:17;21497:47;21561:131;21687:4;21561:131;:::i;:::-;21553:139;;21451:248;;;:::o;21705:419::-;21871:4;21909:2;21898:9;21894:18;21886:26;;21958:9;21952:4;21948:20;21944:1;21933:9;21929:17;21922:47;21986:131;22112:4;21986:131;:::i;:::-;21978:139;;21876:248;;;:::o;22130:419::-;22296:4;22334:2;22323:9;22319:18;22311:26;;22383:9;22377:4;22373:20;22369:1;22358:9;22354:17;22347:47;22411:131;22537:4;22411:131;:::i;:::-;22403:139;;22301:248;;;:::o;22555:419::-;22721:4;22759:2;22748:9;22744:18;22736:26;;22808:9;22802:4;22798:20;22794:1;22783:9;22779:17;22772:47;22836:131;22962:4;22836:131;:::i;:::-;22828:139;;22726:248;;;:::o;22980:419::-;23146:4;23184:2;23173:9;23169:18;23161:26;;23233:9;23227:4;23223:20;23219:1;23208:9;23204:17;23197:47;23261:131;23387:4;23261:131;:::i;:::-;23253:139;;23151:248;;;:::o;23405:419::-;23571:4;23609:2;23598:9;23594:18;23586:26;;23658:9;23652:4;23648:20;23644:1;23633:9;23629:17;23622:47;23686:131;23812:4;23686:131;:::i;:::-;23678:139;;23576:248;;;:::o;23830:419::-;23996:4;24034:2;24023:9;24019:18;24011:26;;24083:9;24077:4;24073:20;24069:1;24058:9;24054:17;24047:47;24111:131;24237:4;24111:131;:::i;:::-;24103:139;;24001:248;;;:::o;24255:419::-;24421:4;24459:2;24448:9;24444:18;24436:26;;24508:9;24502:4;24498:20;24494:1;24483:9;24479:17;24472:47;24536:131;24662:4;24536:131;:::i;:::-;24528:139;;24426:248;;;:::o;24680:419::-;24846:4;24884:2;24873:9;24869:18;24861:26;;24933:9;24927:4;24923:20;24919:1;24908:9;24904:17;24897:47;24961:131;25087:4;24961:131;:::i;:::-;24953:139;;24851:248;;;:::o;25105:419::-;25271:4;25309:2;25298:9;25294:18;25286:26;;25358:9;25352:4;25348:20;25344:1;25333:9;25329:17;25322:47;25386:131;25512:4;25386:131;:::i;:::-;25378:139;;25276:248;;;:::o;25530:419::-;25696:4;25734:2;25723:9;25719:18;25711:26;;25783:9;25777:4;25773:20;25769:1;25758:9;25754:17;25747:47;25811:131;25937:4;25811:131;:::i;:::-;25803:139;;25701:248;;;:::o;25955:419::-;26121:4;26159:2;26148:9;26144:18;26136:26;;26208:9;26202:4;26198:20;26194:1;26183:9;26179:17;26172:47;26236:131;26362:4;26236:131;:::i;:::-;26228:139;;26126:248;;;:::o;26380:419::-;26546:4;26584:2;26573:9;26569:18;26561:26;;26633:9;26627:4;26623:20;26619:1;26608:9;26604:17;26597:47;26661:131;26787:4;26661:131;:::i;:::-;26653:139;;26551:248;;;:::o;26805:419::-;26971:4;27009:2;26998:9;26994:18;26986:26;;27058:9;27052:4;27048:20;27044:1;27033:9;27029:17;27022:47;27086:131;27212:4;27086:131;:::i;:::-;27078:139;;26976:248;;;:::o;27230:419::-;27396:4;27434:2;27423:9;27419:18;27411:26;;27483:9;27477:4;27473:20;27469:1;27458:9;27454:17;27447:47;27511:131;27637:4;27511:131;:::i;:::-;27503:139;;27401:248;;;:::o;27655:419::-;27821:4;27859:2;27848:9;27844:18;27836:26;;27908:9;27902:4;27898:20;27894:1;27883:9;27879:17;27872:47;27936:131;28062:4;27936:131;:::i;:::-;27928:139;;27826:248;;;:::o;28080:419::-;28246:4;28284:2;28273:9;28269:18;28261:26;;28333:9;28327:4;28323:20;28319:1;28308:9;28304:17;28297:47;28361:131;28487:4;28361:131;:::i;:::-;28353:139;;28251:248;;;:::o;28505:419::-;28671:4;28709:2;28698:9;28694:18;28686:26;;28758:9;28752:4;28748:20;28744:1;28733:9;28729:17;28722:47;28786:131;28912:4;28786:131;:::i;:::-;28778:139;;28676:248;;;:::o;28930:419::-;29096:4;29134:2;29123:9;29119:18;29111:26;;29183:9;29177:4;29173:20;29169:1;29158:9;29154:17;29147:47;29211:131;29337:4;29211:131;:::i;:::-;29203:139;;29101:248;;;:::o;29355:419::-;29521:4;29559:2;29548:9;29544:18;29536:26;;29608:9;29602:4;29598:20;29594:1;29583:9;29579:17;29572:47;29636:131;29762:4;29636:131;:::i;:::-;29628:139;;29526:248;;;:::o;29780:419::-;29946:4;29984:2;29973:9;29969:18;29961:26;;30033:9;30027:4;30023:20;30019:1;30008:9;30004:17;29997:47;30061:131;30187:4;30061:131;:::i;:::-;30053:139;;29951:248;;;:::o;30205:419::-;30371:4;30409:2;30398:9;30394:18;30386:26;;30458:9;30452:4;30448:20;30444:1;30433:9;30429:17;30422:47;30486:131;30612:4;30486:131;:::i;:::-;30478:139;;30376:248;;;:::o;30630:419::-;30796:4;30834:2;30823:9;30819:18;30811:26;;30883:9;30877:4;30873:20;30869:1;30858:9;30854:17;30847:47;30911:131;31037:4;30911:131;:::i;:::-;30903:139;;30801:248;;;:::o;31055:419::-;31221:4;31259:2;31248:9;31244:18;31236:26;;31308:9;31302:4;31298:20;31294:1;31283:9;31279:17;31272:47;31336:131;31462:4;31336:131;:::i;:::-;31328:139;;31226:248;;;:::o;31480:419::-;31646:4;31684:2;31673:9;31669:18;31661:26;;31733:9;31727:4;31723:20;31719:1;31708:9;31704:17;31697:47;31761:131;31887:4;31761:131;:::i;:::-;31753:139;;31651:248;;;:::o;31905:222::-;31998:4;32036:2;32025:9;32021:18;32013:26;;32049:71;32117:1;32106:9;32102:17;32093:6;32049:71;:::i;:::-;32003:124;;;;:::o;32133:129::-;32167:6;32194:20;;:::i;:::-;32184:30;;32223:33;32251:4;32243:6;32223:33;:::i;:::-;32174:88;;;:::o;32268:75::-;32301:6;32334:2;32328:9;32318:19;;32308:35;:::o;32349:307::-;32410:4;32500:18;32492:6;32489:30;32486:2;;;32522:18;;:::i;:::-;32486:2;32560:29;32582:6;32560:29;:::i;:::-;32552:37;;32644:4;32638;32634:15;32626:23;;32415:241;;;:::o;32662:308::-;32724:4;32814:18;32806:6;32803:30;32800:2;;;32836:18;;:::i;:::-;32800:2;32874:29;32896:6;32874:29;:::i;:::-;32866:37;;32958:4;32952;32948:15;32940:23;;32729:241;;;:::o;32976:98::-;33027:6;33061:5;33055:12;33045:22;;33034:40;;;:::o;33080:99::-;33132:6;33166:5;33160:12;33150:22;;33139:40;;;:::o;33185:168::-;33268:11;33302:6;33297:3;33290:19;33342:4;33337:3;33333:14;33318:29;;33280:73;;;;:::o;33359:147::-;33460:11;33497:3;33482:18;;33472:34;;;;:::o;33512:169::-;33596:11;33630:6;33625:3;33618:19;33670:4;33665:3;33661:14;33646:29;;33608:73;;;;:::o;33687:148::-;33789:11;33826:3;33811:18;;33801:34;;;;:::o;33841:305::-;33881:3;33900:20;33918:1;33900:20;:::i;:::-;33895:25;;33934:20;33952:1;33934:20;:::i;:::-;33929:25;;34088:1;34020:66;34016:74;34013:1;34010:81;34007:2;;;34094:18;;:::i;:::-;34007:2;34138:1;34135;34131:9;34124:16;;33885:261;;;;:::o;34152:185::-;34192:1;34209:20;34227:1;34209:20;:::i;:::-;34204:25;;34243:20;34261:1;34243:20;:::i;:::-;34238:25;;34282:1;34272:2;;34287:18;;:::i;:::-;34272:2;34329:1;34326;34322:9;34317:14;;34194:143;;;;:::o;34343:348::-;34383:7;34406:20;34424:1;34406:20;:::i;:::-;34401:25;;34440:20;34458:1;34440:20;:::i;:::-;34435:25;;34628:1;34560:66;34556:74;34553:1;34550:81;34545:1;34538:9;34531:17;34527:105;34524:2;;;34635:18;;:::i;:::-;34524:2;34683:1;34680;34676:9;34665:20;;34391:300;;;;:::o;34697:191::-;34737:4;34757:20;34775:1;34757:20;:::i;:::-;34752:25;;34791:20;34809:1;34791:20;:::i;:::-;34786:25;;34830:1;34827;34824:8;34821:2;;;34835:18;;:::i;:::-;34821:2;34880:1;34877;34873:9;34865:17;;34742:146;;;;:::o;34894:96::-;34931:7;34960:24;34978:5;34960:24;:::i;:::-;34949:35;;34939:51;;;:::o;34996:90::-;35030:7;35073:5;35066:13;35059:21;35048:32;;35038:48;;;:::o;35092:149::-;35128:7;35168:66;35161:5;35157:78;35146:89;;35136:105;;;:::o;35247:126::-;35284:7;35324:42;35317:5;35313:54;35302:65;;35292:81;;;:::o;35379:77::-;35416:7;35445:5;35434:16;;35424:32;;;:::o;35462:154::-;35546:6;35541:3;35536;35523:30;35608:1;35599:6;35594:3;35590:16;35583:27;35513:103;;;:::o;35622:307::-;35690:1;35700:113;35714:6;35711:1;35708:13;35700:113;;;35799:1;35794:3;35790:11;35784:18;35780:1;35775:3;35771:11;35764:39;35736:2;35733:1;35729:10;35724:15;;35700:113;;;35831:6;35828:1;35825:13;35822:2;;;35911:1;35902:6;35897:3;35893:16;35886:27;35822:2;35671:258;;;;:::o;35935:320::-;35979:6;36016:1;36010:4;36006:12;35996:22;;36063:1;36057:4;36053:12;36084:18;36074:2;;36140:4;36132:6;36128:17;36118:27;;36074:2;36202;36194:6;36191:14;36171:18;36168:38;36165:2;;;36221:18;;:::i;:::-;36165:2;35986:269;;;;:::o;36261:281::-;36344:27;36366:4;36344:27;:::i;:::-;36336:6;36332:40;36474:6;36462:10;36459:22;36438:18;36426:10;36423:34;36420:62;36417:2;;;36485:18;;:::i;:::-;36417:2;36525:10;36521:2;36514:22;36304:238;;;:::o;36548:233::-;36587:3;36610:24;36628:5;36610:24;:::i;:::-;36601:33;;36656:66;36649:5;36646:77;36643:2;;;36726:18;;:::i;:::-;36643:2;36773:1;36766:5;36762:13;36755:20;;36591:190;;;:::o;36787:176::-;36819:1;36836:20;36854:1;36836:20;:::i;:::-;36831:25;;36870:20;36888:1;36870:20;:::i;:::-;36865:25;;36909:1;36899:2;;36914:18;;:::i;:::-;36899:2;36955:1;36952;36948:9;36943:14;;36821:142;;;;:::o;36969:180::-;37017:77;37014:1;37007:88;37114:4;37111:1;37104:15;37138:4;37135:1;37128:15;37155:180;37203:77;37200:1;37193:88;37300:4;37297:1;37290:15;37324:4;37321:1;37314:15;37341:180;37389:77;37386:1;37379:88;37486:4;37483:1;37476:15;37510:4;37507:1;37500:15;37527:180;37575:77;37572:1;37565:88;37672:4;37669:1;37662:15;37696:4;37693:1;37686:15;37713:102;37754:6;37805:2;37801:7;37796:2;37789:5;37785:14;37781:28;37771:38;;37761:54;;;:::o;37821:221::-;37961:34;37957:1;37949:6;37945:14;37938:58;38030:4;38025:2;38017:6;38013:15;38006:29;37927:115;:::o;38048:237::-;38188:34;38184:1;38176:6;38172:14;38165:58;38257:20;38252:2;38244:6;38240:15;38233:45;38154:131;:::o;38291:225::-;38431:34;38427:1;38419:6;38415:14;38408:58;38500:8;38495:2;38487:6;38483:15;38476:33;38397:119;:::o;38522:178::-;38662:30;38658:1;38650:6;38646:14;38639:54;38628:72;:::o;38706:177::-;38846:29;38842:1;38834:6;38830:14;38823:53;38812:71;:::o;38889:223::-;39029:34;39025:1;39017:6;39013:14;39006:58;39098:6;39093:2;39085:6;39081:15;39074:31;38995:117;:::o;39118:175::-;39258:27;39254:1;39246:6;39242:14;39235:51;39224:69;:::o;39299:225::-;39439:34;39435:1;39427:6;39423:14;39416:58;39508:8;39503:2;39495:6;39491:15;39484:33;39405:119;:::o;39530:231::-;39670:34;39666:1;39658:6;39654:14;39647:58;39739:14;39734:2;39726:6;39722:15;39715:39;39636:125;:::o;39767:178::-;39907:30;39903:1;39895:6;39891:14;39884:54;39873:72;:::o;39951:243::-;40091:34;40087:1;40079:6;40075:14;40068:58;40160:26;40155:2;40147:6;40143:15;40136:51;40057:137;:::o;40200:229::-;40340:34;40336:1;40328:6;40324:14;40317:58;40409:12;40404:2;40396:6;40392:15;40385:37;40306:123;:::o;40435:221::-;40575:34;40571:1;40563:6;40559:14;40552:58;40644:4;40639:2;40631:6;40627:15;40620:29;40541:115;:::o;40662:220::-;40802:34;40798:1;40790:6;40786:14;40779:58;40871:3;40866:2;40858:6;40854:15;40847:28;40768:114;:::o;40888:182::-;41028:34;41024:1;41016:6;41012:14;41005:58;40994:76;:::o;41076:220::-;41216:34;41212:1;41204:6;41200:14;41193:58;41285:3;41280:2;41272:6;41268:15;41261:28;41182:114;:::o;41302:231::-;41442:34;41438:1;41430:6;41426:14;41419:58;41511:14;41506:2;41498:6;41494:15;41487:39;41408:125;:::o;41539:173::-;41679:25;41675:1;41667:6;41663:14;41656:49;41645:67;:::o;41718:182::-;41858:34;41854:1;41846:6;41842:14;41835:58;41824:76;:::o;41906:228::-;42046:34;42042:1;42034:6;42030:14;42023:58;42115:11;42110:2;42102:6;42098:15;42091:36;42012:122;:::o;42140:220::-;42280:34;42276:1;42268:6;42264:14;42257:58;42349:3;42344:2;42336:6;42332:15;42325:28;42246:114;:::o;42366:234::-;42506:34;42502:1;42494:6;42490:14;42483:58;42575:17;42570:2;42562:6;42558:15;42551:42;42472:128;:::o;42606:220::-;42746:34;42742:1;42734:6;42730:14;42723:58;42815:3;42810:2;42802:6;42798:15;42791:28;42712:114;:::o;42832:236::-;42972:34;42968:1;42960:6;42956:14;42949:58;43041:19;43036:2;43028:6;43024:15;43017:44;42938:130;:::o;43074:179::-;43214:31;43210:1;43202:6;43198:14;43191:55;43180:73;:::o;43259:154::-;43399:6;43395:1;43387:6;43383:14;43376:30;43365:48;:::o;43419:157::-;43559:9;43555:1;43547:6;43543:14;43536:33;43525:51;:::o;43582:122::-;43655:24;43673:5;43655:24;:::i;:::-;43648:5;43645:35;43635:2;;43694:1;43691;43684:12;43635:2;43625:79;:::o;43710:116::-;43780:21;43795:5;43780:21;:::i;:::-;43773:5;43770:32;43760:2;;43816:1;43813;43806:12;43760:2;43750:76;:::o;43832:120::-;43904:23;43921:5;43904:23;:::i;:::-;43897:5;43894:34;43884:2;;43942:1;43939;43932:12;43884:2;43874:78;:::o;43958:122::-;44031:24;44049:5;44031:24;:::i;:::-;44024:5;44021:35;44011:2;;44070:1;44067;44060:12;44011:2;44001:79;:::o

Swarm Source

ipfs://7955d1d9ab53e286252606ff84e5b52e1194c9521859f96661b6240610e5c472

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