Token

TeenDACC (TeenDACC)

CRC-721

Overview

Max Total Supply

4,977 TeenDACC

Holders

207

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract

0x25ea0f16e3a52db95e31f8514917a0610270e7cd

Filtered by Token Holder

0x18F3Bd138B6A272180a5c173fFE25288DE9Fc366

Balance

11 TeenDACC

0x18f3bd138b6a272180a5c173ffe25288de9fc366

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:

TeenDaccNft

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at cronoscan.com on 2023-02-23
*/

// Sources flattened with hardhat v2.12.1 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

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


// File contracts/libs/UniversalERC20.sol


pragma solidity ^0.8.4;

// File: contracts/UniversalERC20.sol


library UniversalERC20 {
    using SafeERC20 for IERC20;
    using Address for address payable;

    IERC20 private constant ZERO_ADDRESS =
        IERC20(0x0000000000000000000000000000000000000000);
    IERC20 private constant ETH_ADDRESS =
        IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);

    function universalTransfer(
        IERC20 token,
        address to,
        uint256 amount
    ) internal returns (uint256) {
        if (amount == 0) {
            return 0;
        }

        if (isETH(token)) {
            payable(address(uint160(to))).sendValue(amount);
            return amount;
        } else {
            uint256 balanceBefore = token.balanceOf(to);
            token.safeTransfer(to, amount);
            uint256 balanceAfter = token.balanceOf(to);
            return balanceAfter - balanceBefore;
        }
    }

    function universalTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal returns (uint256) {
        if (amount == 0) {
            return 0;
        }

        if (isETH(token)) {
            require(
                from == msg.sender && msg.value >= amount,
                "Wrong usage of ETH.universalTransferFrom"
            );
            if (to != address(this)) {
                payable(address(uint160(to))).sendValue(amount);
            }
            if (msg.value > amount) {
                // refund redundant amount
                payable(msg.sender).sendValue(msg.value - amount);
            }
            return amount;
        } else {
            uint256 balanceBefore = token.balanceOf(to);
            token.safeTransferFrom(from, to, amount);
            uint256 balanceAfter = token.balanceOf(to);
            return balanceAfter - balanceBefore;
        }
    }

    function universalTransferFromSenderToThis(IERC20 token, uint256 amount)
        internal
        returns (uint256)
    {
        if (amount == 0) {
            return 0;
        }

        if (isETH(token)) {
            require(
                msg.value >= amount,
                "Wrong usage of ETH.universalTransferFromSenderToThis"
            );
            if (msg.value > amount) {
                // Return remainder if exist
                payable(msg.sender).sendValue(msg.value - amount);
            }
            return amount;
        } else {
            uint256 balanceBefore = token.balanceOf(address(this));
            token.safeTransferFrom(msg.sender, address(this), amount);
            uint256 balanceAfter = token.balanceOf(address(this));
            return balanceAfter - balanceBefore;
        }
    }

    function universalApprove(
        IERC20 token,
        address to,
        uint256 amount
    ) internal {
        if (!isETH(token)) {
            if (amount > 0 && token.allowance(address(this), to) > 0) {
                token.safeApprove(to, 0);
            }
            token.safeApprove(to, amount);
        }
    }

    function universalBalanceOf(IERC20 token, address who)
        internal
        view
        returns (uint256)
    {
        if (isETH(token)) {
            return who.balance;
        } else {
            return token.balanceOf(who);
        }
    }

    function universalDecimals(IERC20 token) internal view returns (uint256) {
        if (isETH(token)) {
            return 18;
        }

        (bool success, bytes memory data) = address(token).staticcall{
            gas: 10000
        }(abi.encodeWithSignature("decimals()"));
        if (!success || data.length == 0) {
            (success, data) = address(token).staticcall{gas: 10000}(
                abi.encodeWithSignature("DECIMALS()")
            );
        }

        return (success && data.length > 0) ? abi.decode(data, (uint256)) : 18;
    }

    function isETH(IERC20 token) internal pure returns (bool) {
        return (address(token) == address(ZERO_ADDRESS) ||
            address(token) == address(ETH_ADDRESS));
    }
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/security/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

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

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

    bool private _paused;

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

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

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

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


// File @openzeppelin/contracts/utils/cryptography/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev 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 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;







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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

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

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

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token 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: caller is not token owner nor approved");
        _safeTransfer(from, to, tokenId, data);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


// File contracts/nft/TeenDACCNft.sol



pragma solidity ^0.8.4;




contract TeenDaccNft is Ownable, Pausable, ERC721Enumerable {
    using UniversalERC20 for IERC20;
    using Strings for uint256;

    enum MINT_CASE {
        FREE,
        WHITELIST,
        PUBLIC
    }

    /// @notice Tokens to be paid for minting NFTs
    address public constant CRO = address(0); // CRO
    address public constant CANDY = 0x06C04B0AD236e7Ca3B3189b1d049FE80109C7977; // CANDY

    /// @notice NFTs for granting whitelisted mint
    address public constant BoredCandyNft =
        0xE1049178296ce004996AFb16B0816c5A95aC8482;
    address public constant CsqmNft =
        0x333580e4B59E74243451c531c29121c02F8E3102;
    address public constant DaccNft =
        0x7aEBFd662494299CE53feb533BFE80a749e656BC;
    address public constant MoonwolfNft =
        0xEFA293ecD55e378aa614710C2Aee81886B3F84e0;
    address public constant FpcNft = 0xCf185Cb08c62Ff969D258FBA18F92dabb278A8A9;

    // Merkle root for identifying free mint members
    bytes32 private _freeMerkleRoot;

    /// @notice Last minted token id (we store this because there is burning feature which reduces total supply)
    uint256 private _lastMintId;

    /// @notice Max supply of this collection
    uint256 private _maxSupply = 7777;

    /// @notice Mint dates
    uint256 private _freeStartAt = 1677236400; // February 24, 2023 11:00:00 AM
    uint256 private _sellStartAt = 1677322800; // February 25, 2023 11:00:00 PM

    // Token uri parameters
    string private _baseUri;
    string private _unrevealUri;

    /// @notice Mint prices are different per mint case (free / whitelisted / public) and tokens (CRO / CANDY)
    /// So we are going to store it in a mapping, key is the hash of mint case and token, value is the price
    mapping(bytes32 => uint256) private _mintPrices;

    /// @notice Minted count per user and mint case
    /// key is the hash of mint case and token, value is the minted count
    mapping(bytes32 => uint256) private _mintCountPerUser;

    /// @notice Minted count per mint case
    mapping(MINT_CASE => uint256) private _mintCountPerCase;

    event BaseUriUpdated(string uri);
    event UnrevealUriUpdated(string uri);

    error ExceedMaxSupply();
    error FreeMintDisabled();
    error InvalidFundToken();
    error InvalidParams();
    error InvalidTokenId();
    error NotOpened();
    error NotOwnedNft();

    modifier onlyFundToken(address token_) {
        if (token_ != CRO && token_ != CANDY) revert InvalidFundToken();
        _;
    }

    constructor(
        string memory name_,
        string memory symbol_
    ) ERC721(name_, symbol_) {
        _mintPrices[hash(CRO, uint8(MINT_CASE.WHITELIST))] = 200 ether;
        _mintPrices[hash(CANDY, uint8(MINT_CASE.WHITELIST))] = 325 ether;
        _mintPrices[hash(CRO, uint8(MINT_CASE.PUBLIC))] = 300 ether;
        _mintPrices[hash(CANDY, uint8(MINT_CASE.PUBLIC))] = 490 ether;
    }

    /**
     * @notice Mint nfts
     */
    function mint(
        address token_,
        uint256 index_,
        uint256 amount_,
        bytes32[] calldata proof_
    ) external payable whenNotPaused onlyFundToken(token_) {
        if (block.timestamp < _freeStartAt) revert NotOpened();

        MINT_CASE mintCase = MINT_CASE.PUBLIC;
        /// Check free mint condition
        if (block.timestamp < _sellStartAt) {
            if (
                !MerkleProof.verify(
                    proof_,
                    _freeMerkleRoot,
                    keccak256(abi.encodePacked(index_, _msgSender(), amount_)) // Free mint has amount limit as well
                )
            ) revert FreeMintDisabled();

            mintCase = MINT_CASE.FREE;
            /// This one will be failed when user already minted more than amount in the merkle tree
            amount_ -= _mintCountPerUser[hash(_msgSender(), uint8(mintCase))];
        }
        /// Check whitelisted mint condition
        else if (whitelisted(_msgSender())) mintCase = MINT_CASE.WHITELIST;

        uint256 nftPrice = _mintPrices[hash(token_, uint8(mintCase))];
        IERC20(token_).universalTransferFromSenderToThis(nftPrice * amount_);

        _mintLoop(_msgSender(), amount_);

        _mintCountPerUser[hash(_msgSender(), uint8(mintCase))] += amount_;
        _mintCountPerCase[mintCase] += amount_;
    }

    /**
     * @notice Burn nft token
     * @param tokenId id of nft token to be burnt
     */
    function burn(uint256 tokenId) external {
        if (ownerOf(tokenId) != _msgSender()) revert NotOwnedNft();
        super._burn(tokenId);
    }

    /**
     * @notice Admin airdrop nfts to the users
     */
    function airdrop(
        uint256[] calldata numberOfTokens_,
        address[] calldata recipients_
    ) external onlyOwner {
        if (numberOfTokens_.length != recipients_.length)
            revert InvalidParams();

        for (uint256 i = 0; i < recipients_.length; i++)
            _mintLoop(recipients_[i], numberOfTokens_[i]);
    }

    function _mintLoop(address to_, uint256 amount_) internal {
        if (_maxSupply > 0 && totalSupply() + amount_ > _maxSupply)
            revert ExceedMaxSupply();
        uint256 lastMintId = _lastMintId;
        for (uint256 i = 0; i < amount_; i++) _safeMint(to_, ++lastMintId);
        _lastMintId = lastMintId;
    }

    /// @notice Check if the given account is allowed for the whitelisted mint
    function whitelisted(address account_) public view returns (bool) {
        if (IERC721(BoredCandyNft).balanceOf(account_) > 0) return true;
        if (IERC721(CsqmNft).balanceOf(account_) > 0) return true;
        if (IERC721(DaccNft).balanceOf(account_) > 6) return true;
        if (IERC721(MoonwolfNft).balanceOf(account_) > 0) return true;
        if (IERC721(FpcNft).balanceOf(account_) > 0) return true;
        return false;
    }

    /**
     * @notice View minted nft count per user
     *
     * It returns free mint count, whitelistd mint count, public mint count
     */
    function userMintedCount(
        address account_
    )
        external
        view
        returns (
            uint256, // freeMintCount
            uint256, // whitelistedMintCount
            uint256 // publicMintCount
        )
    {
        return (
            _mintCountPerUser[hash(account_, uint8(MINT_CASE.FREE))],
            _mintCountPerUser[hash(account_, uint8(MINT_CASE.WHITELIST))],
            _mintCountPerUser[hash(account_, uint8(MINT_CASE.PUBLIC))]
        );
    }

    /**
     * @notice View minted nft count per cases
     *
     * It returns free minted count, whitelist minted count, public minted count
     */
    function caseMintedCount()
        external
        view
        returns (uint256, uint256, uint256)
    {
        return (
            _mintCountPerCase[MINT_CASE.FREE],
            _mintCountPerCase[MINT_CASE.WHITELIST],
            _mintCountPerCase[MINT_CASE.PUBLIC]
        );
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function pauseMint() external onlyOwner {
        super._pause();
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function unpauseMint() external onlyOwner {
        super._unpause();
    }

    /**
     * @notice Update mint price for the mint case and minting token
     */
    function updateMintPrice(
        address token_,
        MINT_CASE case_,
        uint256 price_
    ) external onlyOwner onlyFundToken(token_) {
        _mintPrices[hash(token_, uint8(case_))] = price_;
    }

    /**
     * @notice View mint price for the mint case and minting token
     */
    function mintPrice(
        address token_,
        MINT_CASE case_
    ) external view onlyFundToken(token_) returns (uint256) {
        return _mintPrices[hash(token_, uint8(case_))];
    }

    /// @notice Get hashed value of inputted params
    function hash(
        address param1_,
        uint8 param2_
    ) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(param1_, param2_));
    }

    /**
     * @notice Set mint dates for each mint type
     */
    function setMintDates(
        uint256 freeStartAt_,
        uint256 sellStartAt_
    ) external onlyOwner {
        if (freeStartAt_ > sellStartAt_) revert InvalidParams();

        _freeStartAt = freeStartAt_;
        _sellStartAt = sellStartAt_;
    }

    /**
     * @notice View mint dates for each mint type
     */
    function mintDates() external view returns (uint256, uint256) {
        return (_freeStartAt, _sellStartAt);
    }

    /**
     * @notice Set merkle roots for the free & whitelisted mint
     */
    function setFreeMerkleRoot(bytes32 freeMerkleRoot_) external onlyOwner {
        _freeMerkleRoot = freeMerkleRoot_;
    }

    /**
     * @notice View free & whitelisted merkle root
     */
    function freeMerkleRoot() external view returns (bytes32) {
        return _freeMerkleRoot;
    }

    /**
     * @notice Set max supply
     */
    function setMaxSupply(uint256 maxSupply_) external onlyOwner {
        _maxSupply = maxSupply_;
    }

    /**
     * @notice View max supply
     */
    function maxSupply() external view returns (uint256) {
        return _maxSupply;
    }

    /**
     * @notice Set base URI
     */
    function setBaseUri(string memory uri_) external onlyOwner {
        _baseUri = uri_;
        emit BaseUriUpdated(uri_);
    }

    function baseUri() external view returns (string memory) {
        return _baseUri;
    }

    /**
     * @notice Set unreveal URI
     */
    function setUnrevealUri(string memory uri_) external onlyOwner {
        _unrevealUri = uri_;
        emit UnrevealUriUpdated(uri_);
    }

    function unrevealUri() external view returns (string memory) {
        return _unrevealUri;
    }

    function _baseURI() internal view override returns (string memory) {
        return _baseUri;
    }

    /**
     * @notice Get token uri for token id
     */
    function tokenURI(
        uint256 tokenId_
    ) public view override returns (string memory) {
        if (!_exists(tokenId_)) revert InvalidTokenId();

        return
            bytes(_baseUri).length > 0
                ? string(abi.encodePacked(_baseUri, tokenId_.toString()))
                : _unrevealUri;
    }

    /// @notice to recieve ETH
    receive() external payable {}

    // The following functions are overrides required by Solidity.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override(ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view override(ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    /**
     * @notice It allows to withdraw tokens to the owner account
     * @param token_: the address of the token to withdraw
     * @param amount_: the number of tokens to withdraw
     */
    function withdrawToken(address token_, uint256 amount_) external {
        IERC20(token_).universalTransfer(owner(), amount_);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ExceedMaxSupply","type":"error"},{"inputs":[],"name":"FreeMintDisabled","type":"error"},{"inputs":[],"name":"InvalidFundToken","type":"error"},{"inputs":[],"name":"InvalidParams","type":"error"},{"inputs":[],"name":"InvalidTokenId","type":"error"},{"inputs":[],"name":"NotOpened","type":"error"},{"inputs":[],"name":"NotOwnedNft","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"uri","type":"string"}],"name":"BaseUriUpdated","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"uri","type":"string"}],"name":"UnrevealUriUpdated","type":"event"},{"inputs":[],"name":"BoredCandyNft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CANDY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CRO","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CsqmNft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DaccNft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FpcNft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MoonwolfNft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"numberOfTokens_","type":"uint256[]"},{"internalType":"address[]","name":"recipients_","type":"address[]"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"caseMintedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"uint256","name":"index_","type":"uint256"},{"internalType":"uint256","name":"amount_","type":"uint256"},{"internalType":"bytes32[]","name":"proof_","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintDates","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"enum TeenDaccNft.MINT_CASE","name":"case_","type":"uint8"}],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri_","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"freeMerkleRoot_","type":"bytes32"}],"name":"setFreeMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxSupply_","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"freeStartAt_","type":"uint256"},{"internalType":"uint256","name":"sellStartAt_","type":"uint256"}],"name":"setMintDates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri_","type":"string"}],"name":"setUnrevealUri","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":"unpauseMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unrevealUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"enum TeenDaccNft.MINT_CASE","name":"case_","type":"uint8"},{"internalType":"uint256","name":"price_","type":"uint256"}],"name":"updateMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account_","type":"address"}],"name":"userMintedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account_","type":"address"}],"name":"whitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000085465656e4441434300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000085465656e44414343000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): TeenDACC
Arg [1] : symbol_ (string): TeenDACC

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [3] : 5465656e44414343000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 5465656e44414343000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

71813:11553:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82841:179;;;;;;;;;;-1:-1:-1;82841:179:0;;;;;:::i;:::-;;:::i;:::-;;;12118:14:1;;12111:22;12093:41;;12081:2;12066:18;82841:179:0;;;;;;;;51227:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;52740:171::-;;;;;;;;;;-1:-1:-1;52740:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;10746:32:1;;;10728:51;;10716:2;10701:18;52740:171:0;10683:102:1;52257:417:0;;;;;;;;;;-1:-1:-1;52257:417:0;;;;;:::i;:::-;;:::i;:::-;;66225:113;;;;;;;;;;-1:-1:-1;66313:10:0;:17;66225:113;;;12291:25:1;;;12279:2;12264:18;66225:113:0;12246:76:1;79241:77:0;;;;;;;;;;;;;:::i;53440:336::-;;;;;;;;;;-1:-1:-1;53440:336:0;;;;;:::i;:::-;;:::i;72382:85::-;;;;;;;;;;;;72425:42;72382:85;;65893:256;;;;;;;;;;-1:-1:-1;65893:256:0;;;;;:::i;:::-;;:::i;72566:89::-;;;;;;;;;;;;72613:42;72566:89;;53847:185;;;;;;;;;;-1:-1:-1;53847:185:0;;;;;:::i;:::-;;:::i;76310:148::-;;;;;;;;;;-1:-1:-1;76310:148:0;;;;;:::i;:::-;;:::i;81875:99::-;;;;;;;;;;;;;:::i;66415:233::-;;;;;;;;;;-1:-1:-1;66415:233:0;;;;;:::i;:::-;;:::i;74822:1380::-;;;;;;:::i;:::-;;:::i;27946:86::-;;;;;;;;;;-1:-1:-1;27993:4:0;28017:7;-1:-1:-1;;;28017:7:0;;;;27946:86;;50938:222;;;;;;;;;;-1:-1:-1;50938:222:0;;;;;:::i;:::-;;:::i;80777:123::-;;;;;;;;;;-1:-1:-1;80777:123:0;;;;;:::i;:::-;;:::i;76532:353::-;;;;;;;;;;-1:-1:-1;76532:353:0;;;;;:::i;:::-;;:::i;81134:103::-;;;;;;;;;;-1:-1:-1;81134:103:0;;;;;:::i;:::-;;:::i;50669:207::-;;;;;;;;;;-1:-1:-1;50669:207:0;;;;;:::i;:::-;;:::i;25450:103::-;;;;;;;;;;;;;:::i;72086:40::-;;;;;;;;;;;;72124:1;72086:40;;80231:262;;;;;;;;;;-1:-1:-1;80231:262:0;;;;;:::i;:::-;;:::i;72662:75::-;;;;;;;;;;;;72695:42;72662:75;;24802:87;;;;;;;;;;-1:-1:-1;24848:7:0;24875:6;-1:-1:-1;;;;;24875:6:0;24802:87;;51396:104;;;;;;;;;;;;;:::i;81726:141::-;;;;;;;;;;-1:-1:-1;81726:141:0;;;;;:::i;:::-;;:::i;81576:91::-;;;;;;;;;;;;;:::i;72474:85::-;;;;;;;;;;;;72517:42;72474:85;;83229:134;;;;;;;;;;-1:-1:-1;83229:134:0;;;;;:::i;:::-;;:::i;81439:129::-;;;;;;;;;;-1:-1:-1;81439:129:0;;;;;:::i;:::-;;:::i;52983:155::-;;;;;;;;;;-1:-1:-1;52983:155:0;;;;;:::i;:::-;;:::i;54103:323::-;;;;;;;;;;-1:-1:-1;54103:323:0;;;;;:::i;:::-;;:::i;80978:99::-;;;;;;;;;;-1:-1:-1;81054:15:0;;80978:99;;78586:297;;;;;;;;;;-1:-1:-1;78728:17:0;:33;;;;78776:38;;78847:16;78663:7;78829:35;;;78586:297;;;;22181:25:1;;;22237:2;22222:18;;22215:34;;;;22265:18;;;22258:34;22169:2;22154:18;78586:297:0;22136:162:1;82152:329:0;;;;;;;;;;-1:-1:-1;82152:329:0;;;;;:::i;:::-;;:::i;79027:73::-;;;;;;;;;;;;;:::i;81295:89::-;;;;;;;;;;-1:-1:-1;81366:10:0;;81295:89;;77310:446;;;;;;;;;;-1:-1:-1;77310:446:0;;;;;:::i;:::-;;:::i;79414:216::-;;;;;;;;;;-1:-1:-1;79414:216:0;;;;;:::i;:::-;;:::i;53209:164::-;;;;;;;;;;-1:-1:-1;53209:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;53330:25:0;;;53306:4;53330:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;53209:164;25708:201;;;;;;;;;;-1:-1:-1;25708:201:0;;;;;:::i;:::-;;:::i;77914:508::-;;;;;;;;;;-1:-1:-1;77914:508:0;;;;;:::i;:::-;;:::i;80570:116::-;;;;;;;;;;-1:-1:-1;80651:12:0;;80665;;80570:116;;;21900:25:1;;;21956:2;21941:18;;21934:34;;;;21873:18;80570:116:0;21855:119:1;72284:91:0;;;;;;;;;;;;72333:42;72284:91;;79724:196;;;;;;;;;;-1:-1:-1;79724:196:0;;;;;:::i;:::-;;:::i;72140:74::-;;;;;;;;;;;;72172:42;72140:74;;82841:179;82952:4;82976:36;83000:11;82976:23;:36::i;:::-;82969:43;82841:179;-1:-1:-1;;82841:179:0:o;51227:100::-;51281:13;51314:5;51307:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51227:100;:::o;52740:171::-;52816:7;52836:23;52851:7;52836:14;:23::i;:::-;-1:-1:-1;52879:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;52879:24:0;;52740:171::o;52257:417::-;52338:13;52354:23;52369:7;52354:14;:23::i;:::-;52338:39;;52402:5;-1:-1:-1;;;;;52396:11:0;:2;-1:-1:-1;;;;;52396:11:0;;;52388:57;;;;-1:-1:-1;;;52388:57:0;;19326:2:1;52388:57:0;;;19308:21:1;19365:2;19345:18;;;19338:30;19404:34;19384:18;;;19377:62;-1:-1:-1;;;19455:18:1;;;19448:31;19496:19;;52388:57:0;;;;;;;;;23427:10;-1:-1:-1;;;;;52480:21:0;;;;:62;;-1:-1:-1;52505:37:0;52522:5;23427:10;53209:164;:::i;52505:37::-;52458:174;;;;-1:-1:-1;;;52458:174:0;;17820:2:1;52458:174:0;;;17802:21:1;17859:2;17839:18;;;17832:30;17898:34;17878:18;;;17871:62;17969:32;17949:18;;;17942:60;18019:19;;52458:174:0;17792:252:1;52458:174:0;52645:21;52654:2;52658:7;52645:8;:21::i;:::-;52257:417;;;:::o;79241:77::-;24688:13;:11;:13::i;:::-;79294:16:::1;:14;:16::i;:::-;79241:77::o:0;53440:336::-;53635:41;23427:10;53668:7;53635:18;:41::i;:::-;53627:100;;;;-1:-1:-1;;;53627:100:0;;;;;;;:::i;:::-;53740:28;53750:4;53756:2;53760:7;53740:9;:28::i;65893:256::-;65990:7;66026:23;66043:5;66026:16;:23::i;:::-;66018:5;:31;66010:87;;;;-1:-1:-1;;;66010:87:0;;13113:2:1;66010:87:0;;;13095:21:1;13152:2;13132:18;;;13125:30;13191:34;13171:18;;;13164:62;-1:-1:-1;;;13242:18:1;;;13235:41;13293:19;;66010:87:0;13085:233:1;66010:87:0;-1:-1:-1;;;;;;66115:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;65893:256::o;53847:185::-;53985:39;54002:4;54008:2;54012:7;53985:39;;;;;;;;;;;;:16;:39::i;76310:148::-;23427:10;76365:16;76373:7;76365;:16::i;:::-;-1:-1:-1;;;;;76365:32:0;;76361:58;;76406:13;;-1:-1:-1;;;76406:13:0;;;;;;;;;;;76361:58;76430:20;76442:7;76430:11;:20::i;:::-;76310:148;:::o;81875:99::-;81921:13;81954:12;81947:19;;;;;:::i;66415:233::-;66490:7;66526:30;66313:10;:17;;66225:113;66526:30;66518:5;:38;66510:95;;;;-1:-1:-1;;;66510:95:0;;20086:2:1;66510:95:0;;;20068:21:1;20125:2;20105:18;;;20098:30;20164:34;20144:18;;;20137:62;-1:-1:-1;;;20215:18:1;;;20208:42;20267:19;;66510:95:0;20058:234:1;66510:95:0;66623:10;66634:5;66623:17;;;;;;-1:-1:-1;;;66623:17:0;;;;;;;;;;;;;;;;;66616:24;;66415:233;;;:::o;74822:1380::-;27551:19;:17;:19::i;:::-;75000:6;-1:-1:-1;;;;;74281:13:0;::::1;::::0;;::::1;::::0;:32:::1;;-1:-1:-1::0;;;;;;74298:15:0;::::1;72172:42;74298:15;;74281:32;74277:63;;;74322:18;;-1:-1:-1::0;;;74322:18:0::1;;;;;;;;;;;74277:63;75041:12:::2;;75023:15;:30;75019:54;;;75062:11;;-1:-1:-1::0;;;75062:11:0::2;;;;;;;;;;;75019:54;75195:12;::::0;75107:16:::2;::::0;75177:15:::2;:30;75173:696;;;75247:223;75288:6;;75247:223;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;75317:15:0::2;::::0;75365:47:::2;::::0;;::::2;::::0;::::2;10403:19:1::0;;;-1:-1:-1;;23427:10:0;10460:2:1;10456:15;10452:53;10438:12;;;10431:75;;;;10522:12;;;10515:28;;;75317:15:0;;-1:-1:-1;10559:12:1;;;-1:-1:-1;75365:47:0::2;;;;;;;;;;;;75355:58;;;;;;75247:18;:223::i;:::-;75224:287;;75493:18;;-1:-1:-1::0;;;75493:18:0::2;;;;;;;;;;;75224:287;-1:-1:-1::0;75539:14:0::2;75681:17;75539:14:::0;75699:35:::2;23427:10:::0;75539:14;75699:4:::2;:35::i;75718:15::-;75699:4;:35::i;:::-;75681:54;;;;;;;;;;;;75670:65;;;;;:::i;:::-;;;75173:696;;;75812:25;23427:10:::0;77310:446;:::i;75812:25::-:2;75808:61;;;-1:-1:-1::0;75850:19:0::2;75808:61;75882:16;75901:11;:42;75913:29;75918:6;75932:8;75926:15;;;;;;-1:-1:-1::0;;;75926:15:0::2;;;;;;;;75913:29;75901:42;;;;;;;;;;;;75882:61;;75954:68;76014:7;76003:8;:18;;;;:::i;:::-;-1:-1:-1::0;;;;;75954:48:0;::::2;::::0;::::2;:68::i;:::-;-1:-1:-1::0;76035:32:0::2;23427:10:::0;76059:7:::2;76035:9;:32::i;:::-;76138:7:::0;76080:17:::2;:54;76098:35;23427:10:::0;76123:8:::2;76117:15;;;;;;-1:-1:-1::0;;;76117:15:0::2;;;;;;;;76098:35;76080:54;;;;;;;;;;;;:65;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;76187:7:0;;-1:-1:-1;76156:17:0::2;:27;76174:8:::0;76156:27:::2;::::0;::::2;;;;-1:-1:-1::0;;;76156:27:0::2;;;;;;;;;;;;;;;-1:-1:-1::0;;;76156:27:0::2;;;;;;;;;;;;;;;;;;;;;:38;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;;;;74822:1380:0:o;50938:222::-;51010:7;51046:16;;;:7;:16;;;;;;-1:-1:-1;;;;;51046:16:0;51081:19;51073:56;;;;-1:-1:-1;;;51073:56:0;;18973:2:1;51073:56:0;;;18955:21:1;19012:2;18992:18;;;18985:30;-1:-1:-1;;;19031:18:1;;;19024:54;19095:18;;51073:56:0;18945:174:1;80777:123:0;24688:13;:11;:13::i;:::-;80859:15:::1;:33:::0;80777:123::o;76532:353::-;24688:13;:11;:13::i;:::-;76676:44;;::::1;76672:85;;76742:15;;-1:-1:-1::0;;;76742:15:0::1;;;;;;;;;;;76672:85;76775:9;76770:107;76790:22:::0;;::::1;76770:107;;;76832:45;76842:11;;76854:1;76842:14;;;;;-1:-1:-1::0;;;76842:14:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76858:15;;76874:1;76858:18;;;;;-1:-1:-1::0;;;76858:18:0::1;;;;;;;;;;;;;;;76832:9;:45::i;:::-;76814:3:::0;::::1;::::0;::::1;:::i;:::-;;;;76770:107;;;;76532:353:::0;;;;:::o;81134:103::-;24688:13;:11;:13::i;:::-;81206:10:::1;:23:::0;81134:103::o;50669:207::-;50741:7;-1:-1:-1;;;;;50769:19:0;;50761:73;;;;-1:-1:-1;;;50761:73:0;;17410:2:1;50761:73:0;;;17392:21:1;17449:2;17429:18;;;17422:30;17488:34;17468:18;;;17461:62;-1:-1:-1;;;17539:18:1;;;17532:39;17588:19;;50761:73:0;17382:231:1;50761:73:0;-1:-1:-1;;;;;;50852:16:0;;;;;:9;:16;;;;;;;50669:207::o;25450:103::-;24688:13;:11;:13::i;:::-;25515:30:::1;25542:1;25515:18;:30::i;80231:262::-:0;24688:13;:11;:13::i;:::-;80371:12:::1;80356;:27;80352:55;;;80392:15;;-1:-1:-1::0;;;80392:15:0::1;;;;;;;;;;;80352:55;80420:12;:27:::0;;;;80458:12:::1;:27:::0;80231:262::o;51396:104::-;51452:13;51485:7;51478:14;;;;;:::i;81726:141::-;24688:13;:11;:13::i;:::-;81800:19;;::::1;::::0;:12:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;:::-;;81835:24;81854:4;81835:24;;;;;;:::i;:::-;;;;;;;;81726:141:::0;:::o;81576:91::-;81618:13;81651:8;81644:15;;;;;:::i;83229:134::-;83305:50;83338:7;24848;24875:6;-1:-1:-1;;;;;24875:6:0;;24802:87;83338:7;-1:-1:-1;;;;;83305:32:0;;;83347:7;83305:32;:50::i;81439:129::-;24688:13;:11;:13::i;:::-;81509:15;;::::1;::::0;:8:::1;::::0;:15:::1;::::0;::::1;::::0;::::1;:::i;:::-;;81540:20;81555:4;81540:20;;;;;;:::i;52983:155::-:0;53078:52;23427:10;53111:8;53121;53078:18;:52::i;:::-;52983:155;;:::o;54103:323::-;54277:41;23427:10;54310:7;54277:18;:41::i;:::-;54269:100;;;;-1:-1:-1;;;54269:100:0;;;;;;;:::i;:::-;54380:38;54394:4;54400:2;54404:7;54413:4;54380:13;:38::i;:::-;54103:323;;;;:::o;82152:329::-;55998:4;56022:16;;;:7;:16;;;;;;82234:13;;-1:-1:-1;;;;;56022:16:0;82260:47;;82291:16;;-1:-1:-1;;;82291:16:0;;;;;;;;;;;82260:47;82365:1;82346:8;82340:22;;;;;:::i;:::-;;;:26;:133;;82461:12;82340:133;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82410:8;82420:19;:8;:17;:19::i;:::-;82393:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;82320:153;82152:329;-1:-1:-1;;82152:329:0:o;79027:73::-;24688:13;:11;:13::i;:::-;79078:14:::1;:12;:14::i;77310:446::-:0;77391:42;;-1:-1:-1;;;77391:42:0;;-1:-1:-1;;;;;10746:32:1;;77391:42:0;;;10728:51:1;77370:4:0;;;;72333:42;;77391:32;;10701:18:1;;77391:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:46;77387:63;;;-1:-1:-1;77446:4:0;;77310:446;-1:-1:-1;77310:446:0:o;77387:63::-;77465:36;;-1:-1:-1;;;77465:36:0;;-1:-1:-1;;;;;10746:32:1;;77465:36:0;;;10728:51:1;77504:1:0;;72425:42;;77465:26;;10701:18:1;;77465:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;77461:57;;;-1:-1:-1;77514:4:0;;77310:446;-1:-1:-1;77310:446:0:o;77461:57::-;77533:36;;-1:-1:-1;;;77533:36:0;;-1:-1:-1;;;;;10746:32:1;;77533:36:0;;;10728:51:1;77572:1:0;;72517:42;;77533:26;;10701:18:1;;77533:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;77529:57;;;-1:-1:-1;77582:4:0;;77310:446;-1:-1:-1;77310:446:0:o;77529:57::-;77601:40;;-1:-1:-1;;;77601:40:0;;-1:-1:-1;;;;;10746:32:1;;77601:40:0;;;10728:51:1;77644:1:0;;72613:42;;77601:30;;10701:18:1;;77601:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;77597:61;;;-1:-1:-1;77654:4:0;;77310:446;-1:-1:-1;77310:446:0:o;77597:61::-;77673:35;;-1:-1:-1;;;77673:35:0;;-1:-1:-1;;;;;10746:32:1;;77673:35:0;;;10728:51:1;77711:1:0;;72695:42;;77673:25;;10701:18:1;;77673:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:39;77669:56;;;-1:-1:-1;77721:4:0;;77310:446;-1:-1:-1;77310:446:0:o;77669:56::-;-1:-1:-1;77743:5:0;;77310:446;-1:-1:-1;77310:446:0:o;79414:216::-;24688:13;:11;:13::i;:::-;79555:6;-1:-1:-1;;;;;74281:13:0;::::1;::::0;;::::1;::::0;:32:::1;;-1:-1:-1::0;;;;;;74298:15:0;::::1;72172:42;74298:15;;74281:32;74277:63;;;74322:18;;-1:-1:-1::0;;;74322:18:0::1;;;;;;;;;;;74277:63;79616:6:::2;79574:11;:39;79586:26;79591:6;79605:5;79599:12;;;;;;-1:-1:-1::0;;;79599:12:0::2;;;;;;;;79586:26;79574:39:::0;;::::2;::::0;::::2;::::0;;;;;;-1:-1:-1;79574:39:0;:48;-1:-1:-1;;;;79414:216:0:o;25708:201::-;24688:13;:11;:13::i;:::-;-1:-1:-1;;;;;25797:22:0;::::1;25789:73;;;::::0;-1:-1:-1;;;25789:73:0;;13944:2:1;25789:73:0::1;::::0;::::1;13926:21:1::0;13983:2;13963:18;;;13956:30;14022:34;14002:18;;;13995:62;-1:-1:-1;;;14073:18:1;;;14066:36;14119:19;;25789:73:0::1;13916:228:1::0;25789:73:0::1;25873:28;25892:8;25873:18;:28::i;77914:508::-:0;78037:7;;;78198:17;78037:7;78216:37;78221:8;78037:7;75699:4:::2;:35::i;78216:37::-:0;78198:56;;;;;;;;;;;;78269:17;:61;78287:42;78292:8;78308:19;78302:26;;;;;;-1:-1:-1;;;78302:26:0;;;;;;;;78287:42;78269:61;;;;;;;;;;;;78345:17;:58;78363:39;78368:8;78384:16;78378:23;;;;;;-1:-1:-1;;;78378:23:0;;;;;;;;78363:39;78345:58;;;;;;;;;;;;78176:238;;;;;;77914:508;;;;;:::o;79724:196::-;79846:7;79829:6;-1:-1:-1;;;;;74281:13:0;;;;;;:32;;-1:-1:-1;;;;;;74298:15:0;;72172:42;74298:15;;74281:32;74277:63;;;74322:18;;-1:-1:-1;;;74322:18:0;;;;;;;;;;;74277:63;79873:11:::1;:39;79885:26;79890:6;79904:5;79898:12;;;;;;-1:-1:-1::0;;;79898:12:0::1;;;;;;;;79885:26;79873:39;;;;;;;;;;;;79866:46;;79724:196:::0;;;;;:::o;65585:224::-;65687:4;-1:-1:-1;;;;;;65711:50:0;;-1:-1:-1;;;65711:50:0;;:90;;;65765:36;65789:11;65765:23;:36::i;60715:135::-;55998:4;56022:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56022:16:0;60789:53;;;;-1:-1:-1;;;60789:53:0;;18973:2:1;60789:53:0;;;18955:21:1;19012:2;18992:18;;;18985:30;-1:-1:-1;;;19031:18:1;;;19024:54;19095:18;;60789:53:0;18945:174:1;59994::0;60069:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;60069:29:0;-1:-1:-1;;;;;60069:29:0;;;;;;;;:24;;60123:23;60069:24;60123:14;:23::i;:::-;-1:-1:-1;;;;;60114:46:0;;;;;;;;;;;59994:174;;:::o;24967:132::-;24848:7;24875:6;-1:-1:-1;;;;;24875:6:0;23427:10;25031:23;25023:68;;;;-1:-1:-1;;;25023:68:0;;18612:2:1;25023:68:0;;;18594:21:1;;;18631:18;;;18624:30;18690:34;18670:18;;;18663:62;18742:18;;25023:68:0;18584:182:1;28801:120:0;27810:16;:14;:16::i;:::-;28870:5:::1;28860:15:::0;;-1:-1:-1;;;;28860:15:0::1;::::0;;28891:22:::1;23427:10:::0;28900:12:::1;28891:22;::::0;-1:-1:-1;;;;;10746:32:1;;;10728:51;;10716:2;10701:18;28891:22:0::1;;;;;;;28801:120::o:0;56227:264::-;56320:4;56337:13;56353:23;56368:7;56353:14;:23::i;:::-;56337:39;;56406:5;-1:-1:-1;;;;;56395:16:0;:7;-1:-1:-1;;;;;56395:16:0;;:52;;;-1:-1:-1;;;;;;53330:25:0;;;53306:4;53330:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;56415:32;56395:87;;;;56475:7;-1:-1:-1;;;;;56451:31:0;:20;56463:7;56451:11;:20::i;:::-;-1:-1:-1;;;;;56451:31:0;;56395:87;56387:96;56227:264;-1:-1:-1;;;;56227:264:0:o;59250:625::-;59409:4;-1:-1:-1;;;;;59382:31:0;:23;59397:7;59382:14;:23::i;:::-;-1:-1:-1;;;;;59382:31:0;;59374:81;;;;-1:-1:-1;;;59374:81:0;;14351:2:1;59374:81:0;;;14333:21:1;14390:2;14370:18;;;14363:30;14429:34;14409:18;;;14402:62;-1:-1:-1;;;14480:18:1;;;14473:35;14525:19;;59374:81:0;14323:227:1;59374:81:0;-1:-1:-1;;;;;59474:16:0;;59466:65;;;;-1:-1:-1;;;59466:65:0;;15114:2:1;59466:65:0;;;15096:21:1;15153:2;15133:18;;;15126:30;15192:34;15172:18;;;15165:62;-1:-1:-1;;;15243:18:1;;;15236:34;15287:19;;59466:65:0;15086:226:1;59466:65:0;59544:39;59565:4;59571:2;59575:7;59544:20;:39::i;:::-;59648:29;59665:1;59669:7;59648:8;:29::i;:::-;-1:-1:-1;;;;;59690:15:0;;;;;;:9;:15;;;;;:20;;59709:1;;59690:15;:20;;59709:1;;59690:20;:::i;:::-;;;;-1:-1:-1;;;;;;;59721:13:0;;;;;;:9;:13;;;;;:18;;59738:1;;59721:13;:18;;59738:1;;59721:18;:::i;:::-;;;;-1:-1:-1;;59750:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;59750:21:0;-1:-1:-1;;;;;59750:21:0;;;;;;;;;59789:27;;59750:16;;59789:27;;;;;;;52257:417;;;:::o;58493:420::-;58553:13;58569:23;58584:7;58569:14;:23::i;:::-;58553:39;;58605:48;58626:5;58641:1;58645:7;58605:20;:48::i;:::-;58694:29;58711:1;58715:7;58694:8;:29::i;:::-;-1:-1:-1;;;;;58736:16:0;;;;;;:9;:16;;;;;:21;;58756:1;;58736:16;:21;;58756:1;;58736:21;:::i;:::-;;;;-1:-1:-1;;58775:16:0;;;;:7;:16;;;;;;58768:23;;-1:-1:-1;;;;;;58768:23:0;;;58809:36;58783:7;;58775:16;-1:-1:-1;;;;;58809:36:0;;;;;58775:16;;58809:36;52983:155;;:::o;28105:108::-;27993:4;28017:7;-1:-1:-1;;;28017:7:0;;;;28175:9;28167:38;;;;-1:-1:-1;;;28167:38:0;;17065:2:1;28167:38:0;;;17047:21:1;17104:2;17084:18;;;17077:30;-1:-1:-1;;;17123:18:1;;;17116:46;17179:18;;28167:38:0;17037:166:1;30155:190:0;30280:4;30333;30304:25;30317:5;30324:4;30304:12;:25::i;:::-;:33;30297:40;;30155:190;;;;;;:::o;79981:174::-;80112:34;;-1:-1:-1;;8395:2:1;8391:15;;;8387:53;80112:34:0;;;8375:66:1;-1:-1:-1;;;;;;8497:3:1;8475:16;;;8471:36;8457:12;;;8450:58;80075:7:0;;8524:12:1;;80112:34:0;;;;;;;;;;;;80102:45;;;;;;80095:52;;79981:174;;;;:::o;20416:856::-;20525:7;20554:11;20550:52;;-1:-1:-1;20589:1:0;20582:8;;20550:52;20618:12;20624:5;20618;:12::i;:::-;20614:651;;;20686:6;20673:9;:19;;20647:133;;;;-1:-1:-1;;;20647:133:0;;21325:2:1;20647:133:0;;;21307:21:1;21364:2;21344:18;;;21337:30;21403:34;21383:18;;;21376:62;-1:-1:-1;;;21454:18:1;;;21447:50;21514:19;;20647:133:0;21297:242:1;20647:133:0;20811:6;20799:9;:18;20795:154;;;20884:49;20914:18;20926:6;20914:9;:18;:::i;:::-;20892:10;;20884:29;:49::i;:::-;-1:-1:-1;20970:6:0;20963:13;;20614:651;21033:30;;-1:-1:-1;;;21033:30:0;;21057:4;21033:30;;;10728:51:1;21009:21:0;;-1:-1:-1;;;;;21033:15:0;;;;;10701:18:1;;21033:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21009:54;-1:-1:-1;21078:57:0;-1:-1:-1;;;;;21078:22:0;;21101:10;21121:4;21128:6;21078:22;:57::i;:::-;21173:30;;-1:-1:-1;;;21173:30:0;;21197:4;21173:30;;;10728:51:1;21150:20:0;;-1:-1:-1;;;;;21173:15:0;;;;;10701:18:1;;21173:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21150:53;-1:-1:-1;21225:28:0;21240:13;21150:53;21225:28;:::i;:::-;21218:35;;;;;;76893:329;76979:1;76966:10;;:14;:54;;;;;77010:10;;77000:7;76984:13;66313:10;:17;;66225:113;76984:13;:23;;;;:::i;:::-;:36;76966:54;76962:97;;;77042:17;;-1:-1:-1;;;77042:17:0;;;;;;;;;;;76962:97;77091:11;;77070:18;77113:66;77137:7;77133:1;:11;77113:66;;;77151:28;77161:3;77166:12;;;:::i;:::-;;;;77151:9;:28::i;:::-;77146:3;;;;:::i;:::-;;;;77113:66;;;-1:-1:-1;77190:11:0;:24;-1:-1:-1;;76893:329:0:o;26069:191::-;26143:16;26162:6;;-1:-1:-1;;;;;26179:17:0;;;-1:-1:-1;;;;;;26179:17:0;;;;;;26212:40;;26162:6;;;;;;;26212:40;;26143:16;26212:40;26069:191;;:::o;18860:560::-;18981:7;19005:11;19001:52;;-1:-1:-1;19040:1:0;19033:8;;19001:52;19069:12;19075:5;19069;:12::i;:::-;19065:348;;;19098:47;-1:-1:-1;;;;;19098:39:0;;19138:6;19098:39;:47::i;:::-;-1:-1:-1;19167:6:0;19160:13;;19065:348;19230:19;;-1:-1:-1;;;19230:19:0;;-1:-1:-1;;;;;10746:32:1;;;19230:19:0;;;10728:51:1;19206:21:0;;19230:15;;;;;;10701:18:1;;19230:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19206:43;-1:-1:-1;19264:30:0;-1:-1:-1;;;;;19264:18:0;;19283:2;19287:6;19264:18;:30::i;:::-;19332:19;;-1:-1:-1;;;19332:19:0;;-1:-1:-1;;;;;10746:32:1;;;19332:19:0;;;10728:51:1;19309:20:0;;19332:15;;;;;;10701:18:1;;19332:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19309:42;-1:-1:-1;19373:28:0;19388:13;19309:42;19373:28;:::i;:::-;19366:35;;;;;;60311:315;60466:8;-1:-1:-1;;;;;60457:17:0;:5;-1:-1:-1;;;;;60457:17:0;;;60449:55;;;;-1:-1:-1;;;60449:55:0;;15519:2:1;60449:55:0;;;15501:21:1;15558:2;15538:18;;;15531:30;15597:27;15577:18;;;15570:55;15642:18;;60449:55:0;15491:175:1;60449:55:0;-1:-1:-1;;;;;60515:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;60515:46:0;;;;;;;;;;60577:41;;12093::1;;;60577::0;;12066:18:1;60577:41:0;;;;;;;60311:315;;;:::o;55307:313::-;55463:28;55473:4;55479:2;55483:7;55463:9;:28::i;:::-;55510:47;55533:4;55539:2;55543:7;55552:4;55510:22;:47::i;:::-;55502:110;;;;-1:-1:-1;;;55502:110:0;;;;;;;:::i;46001:723::-;46057:13;46278:10;46274:53;;-1:-1:-1;;46305:10:0;;;;;;;;;;;;-1:-1:-1;;;46305:10:0;;;;;46001:723::o;46274:53::-;46352:5;46337:12;46393:78;46400:9;;46393:78;;46426:8;;;;:::i;:::-;;-1:-1:-1;46449:10:0;;-1:-1:-1;46457:2:0;46449:10;;:::i;:::-;;;46393:78;;;46481:19;46513:6;46503:17;;;;;;-1:-1:-1;;;46503:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46503:17:0;;46481:39;;46531:154;46538:10;;46531:154;;46565:11;46575:1;46565:11;;:::i;:::-;;-1:-1:-1;46634:10:0;46642:2;46634:5;:10;:::i;:::-;46621:24;;:2;:24;:::i;:::-;46608:39;;46591:6;46598;46591:14;;;;;;-1:-1:-1;;;46591:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;46591:56:0;;;;;;;;-1:-1:-1;46662:11:0;46671:2;46662:11;;:::i;:::-;;;46531:154;;28542:118;27551:19;:17;:19::i;:::-;28602:7:::1;:14:::0;;-1:-1:-1;;;;28602:14:0::1;-1:-1:-1::0;;;28602:14:0::1;::::0;;28632:20:::1;28639:12;23427:10:::0;;23347:98;50300:305;50402:4;-1:-1:-1;;;;;;50439:40:0;;-1:-1:-1;;;50439:40:0;;:105;;-1:-1:-1;;;;;;;50496:48:0;;-1:-1:-1;;;50496:48:0;50439:105;:158;;;-1:-1:-1;;;;;;;;;;45508:40:0;;;50561:36;45399:157;28290:108;27993:4;28017:7;-1:-1:-1;;;28017:7:0;;;;28349:41;;;;-1:-1:-1;;;28349:41:0;;12764:2:1;28349:41:0;;;12746:21:1;12803:2;12783:18;;;12776:30;-1:-1:-1;;;12822:18:1;;;12815:50;12882:18;;28349:41:0;12736:170:1;82626:207:0;82780:45;82807:4;82813:2;82817:7;82780:26;:45::i;31022:296::-;31105:7;31148:4;31105:7;31163:118;31187:5;:12;31183:1;:16;31163:118;;;31236:33;31246:12;31260:5;31266:1;31260:8;;;;;;-1:-1:-1;;;31260:8:0;;;;;;;;;;;;;;;31236:9;:33::i;:::-;31221:48;-1:-1:-1;31201:3:0;;;;:::i;:::-;;;;31163:118;;;-1:-1:-1;31298:12:0;31022:296;-1:-1:-1;;;31022:296:0:o;22473:180::-;22525:4;-1:-1:-1;;;;;22550:39:0;;;;:94;;-1:-1:-1;;;;;;22606:38:0;;18808:42;22606:38;22542:103;22473:180;-1:-1:-1;;22473:180:0:o;2596:317::-;2711:6;2686:21;:31;;2678:73;;;;-1:-1:-1;;;2678:73:0;;16300:2:1;2678:73:0;;;16282:21:1;16339:2;16319:18;;;16312:30;16378:31;16358:18;;;16351:59;16427:18;;2678:73:0;16272:179:1;2678:73:0;2765:12;2783:9;-1:-1:-1;;;;;2783:14:0;2805:6;2783:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2764:52;;;2835:7;2827:78;;;;-1:-1:-1;;;2827:78:0;;15873:2:1;2827:78:0;;;15855:21:1;15912:2;15892:18;;;15885:30;15951:34;15931:18;;;15924:62;16022:28;16002:18;;;15995:56;16068:19;;2827:78:0;15845:248:1;14854::0;15025:68;;-1:-1:-1;;;;;11048:15:1;;;15025:68:0;;;11030:34:1;11100:15;;11080:18;;;11073:43;11132:18;;;11125:34;;;14998:96:0;;15018:5;;-1:-1:-1;;;15048:27:0;10965:18:1;;15025:68:0;;;;-1:-1:-1;;15025:68:0;;;;;;;;;;;;;;-1:-1:-1;;;;;15025:68:0;-1:-1:-1;;;;;;15025:68:0;;;;;;;;;;14998:19;:96::i;56833:110::-;56909:26;56919:2;56923:7;56909:26;;;;;;;;;;;;:9;:26::i;14635:211::-;14779:58;;-1:-1:-1;;;;;11866:32:1;;14779:58:0;;;11848:51:1;11915:18;;;11908:34;;;14752:86:0;;14772:5;;-1:-1:-1;;;14802:23:0;11821:18:1;;14779:58:0;11803:145:1;61414:853:0;61568:4;-1:-1:-1;;;;;61589:13:0;;1630:19;:23;61585:675;;61625:71;;-1:-1:-1;;;61625:71:0;;-1:-1:-1;;;;;61625:36:0;;;;;:71;;23427:10;;61676:4;;61682:7;;61691:4;;61625:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61625:71:0;;;;;;;;-1:-1:-1;;61625:71:0;;;;;;;;;;;;:::i;:::-;;;61621:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61866:13:0;;61862:328;;61909:60;;-1:-1:-1;;;61909:60:0;;;;;;;:::i;61862:328::-;62140:6;62134:13;62125:6;62121:2;62117:15;62110:38;61621:584;-1:-1:-1;;;;;;61747:51:0;-1:-1:-1;;;61747:51:0;;-1:-1:-1;61740:58:0;;61585:675;-1:-1:-1;62244:4:0;61414:853;;;;;;:::o;67261:589::-;-1:-1:-1;;;;;67467:18:0;;67463:187;;67502:40;67534:7;68677:10;:17;;68650:24;;;;:15;:24;;;;;:44;;;68705:24;;;;;;;;;;;;68573:164;67502:40;67463:187;;;67572:2;-1:-1:-1;;;;;67564:10:0;:4;-1:-1:-1;;;;;67564:10:0;;67560:90;;67591:47;67624:4;67630:7;67591:32;:47::i;:::-;-1:-1:-1;;;;;67664:16:0;;67660:183;;67697:45;67734:7;67697:36;:45::i;67660:183::-;67770:4;-1:-1:-1;;;;;67764:10:0;:2;-1:-1:-1;;;;;67764:10:0;;67760:83;;67791:40;67819:2;67823:7;67791:27;:40::i;37229:149::-;37292:7;37323:1;37319;:5;:51;;37454:13;37548:15;;;37584:4;37577:15;;;37631:4;37615:21;;37319:51;;;-1:-1:-1;37454:13:0;37548:15;;;37584:4;37577:15;37631:4;37615:21;;;37229:149::o;17702:716::-;18126:23;18152:69;18180:4;18152:69;;;;;;;;;;;;;;;;;18160:5;-1:-1:-1;;;;;18152:27:0;;;:69;;;;;:::i;:::-;18236:17;;18126:95;;-1:-1:-1;18236:21:0;18232:179;;18333:10;18322:30;;;;;;;;;;;;:::i;:::-;18314:85;;;;-1:-1:-1;;;18314:85:0;;20499:2:1;18314:85:0;;;20481:21:1;20538:2;20518:18;;;20511:30;20577:34;20557:18;;;20550:62;-1:-1:-1;;;20628:18:1;;;20621:40;20678:19;;18314:85:0;20471:232:1;57170:319:0;57299:18;57305:2;57309:7;57299:5;:18::i;:::-;57350:53;57381:1;57385:2;57389:7;57398:4;57350:22;:53::i;:::-;57328:153;;;;-1:-1:-1;;;57328:153:0;;;;;;;:::i;69364:988::-;69630:22;69680:1;69655:22;69672:4;69655:16;:22::i;:::-;:26;;;;:::i;:::-;69692:18;69713:26;;;:17;:26;;;;;;69630:51;;-1:-1:-1;69846:28:0;;;69842:328;;-1:-1:-1;;;;;69913:18:0;;69891:19;69913:18;;;:12;:18;;;;;;;;:34;;;;;;;;;69964:30;;;;;;:44;;;70081:30;;:17;:30;;;;;:43;;;69842:328;-1:-1:-1;70266:26:0;;;;:17;:26;;;;;;;;70259:33;;;-1:-1:-1;;;;;70310:18:0;;;;;:12;:18;;;;;:34;;;;;;;70303:41;69364:988::o;70647:1079::-;70925:10;:17;70900:22;;70925:21;;70945:1;;70925:21;:::i;:::-;70957:18;70978:24;;;:15;:24;;;;;;71351:10;:26;;70900:46;;-1:-1:-1;70978:24:0;;70900:46;;71351:26;;;;-1:-1:-1;;;71351:26:0;;;;;;;;;;;;;;;;;71329:48;;71415:11;71390:10;71401;71390:22;;;;;;-1:-1:-1;;;71390:22:0;;;;;;;;;;;;;;;;;;;;:36;;;;71495:28;;;:15;:28;;;;;;;:41;;;71667:24;;;;;71660:31;71702:10;:16;;;;;-1:-1:-1;;;71702:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;70647:1079;;;;:::o;68151:221::-;68236:14;68253:20;68270:2;68253:16;:20::i;:::-;-1:-1:-1;;;;;68284:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;68329:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;68151:221:0:o;4080:229::-;4217:12;4249:52;4271:6;4279:4;4285:1;4288:12;4249:21;:52::i;57825:439::-;-1:-1:-1;;;;;57905:16:0;;57897:61;;;;-1:-1:-1;;;57897:61:0;;18251:2:1;57897:61:0;;;18233:21:1;;;18270:18;;;18263:30;18329:34;18309:18;;;18302:62;18381:18;;57897:61:0;18223:182:1;57897:61:0;55998:4;56022:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56022:16:0;:30;57969:58;;;;-1:-1:-1;;;57969:58:0;;14757:2:1;57969:58:0;;;14739:21:1;14796:2;14776:18;;;14769:30;14835;14815:18;;;14808:58;14883:18;;57969:58:0;14729:178:1;57969:58:0;58040:45;58069:1;58073:2;58077:7;58040:20;:45::i;:::-;-1:-1:-1;;;;;58098:13:0;;;;;;:9;:13;;;;;:18;;58115:1;;58098:13;:18;;58115:1;;58098:18;:::i;:::-;;;;-1:-1:-1;;58127:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;58127:21:0;-1:-1:-1;;;;;58127:21:0;;;;;;;;58166:33;;58127:16;;;58166:33;;58127:16;;58166:33;52983:155;;:::o;5200:510::-;5370:12;5428:5;5403:21;:30;;5395:81;;;;-1:-1:-1;;;5395:81:0;;16658:2:1;5395:81:0;;;16640:21:1;16697:2;16677:18;;;16670:30;16736:34;16716:18;;;16709:62;-1:-1:-1;;;16787:18:1;;;16780:36;16833:19;;5395:81:0;16630:228:1;5395:81:0;-1:-1:-1;;;;;1630:19:0;;;5487:60;;;;-1:-1:-1;;;5487:60:0;;19728:2:1;5487:60:0;;;19710:21:1;19767:2;19747:18;;;19740:30;19806:31;19786:18;;;19779:59;19855:18;;5487:60:0;19700:179:1;5487:60:0;5561:12;5575:23;5602:6;-1:-1:-1;;;;;5602:11:0;5621:5;5628:4;5602:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5560:73;;;;5651:51;5668:7;5677:10;5689:12;5651:16;:51::i;:::-;5644:58;5200:510;-1:-1:-1;;;;;;;5200:510:0:o;7886:762::-;8036:12;8065:7;8061:580;;;-1:-1:-1;8096:10:0;8089:17;;8061:580;8210:17;;:21;8206:424;;8458:10;8452:17;8519:15;8506:10;8502:2;8498:19;8491:44;8406:148;8601:12;8594:20;;-1:-1:-1;;;8594:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:2;;813:1;810;803:12;747:2;699:124;;;:::o;828:391::-;891:8;901:6;955:3;948:4;940:6;936:17;932:27;922:2;;978:6;970;963:22;922:2;-1:-1:-1;1006:20:1;;1049:18;1038:30;;1035:2;;;1088:8;1078;1071:26;1035:2;1132:4;1124:6;1120:17;1108:29;;1192:3;1185:4;1175:6;1172:1;1168:14;1160:6;1156:27;1152:38;1149:47;1146:2;;;1209:1;1206;1199:12;1146:2;912:307;;;;;:::o;1224:150::-;1299:20;;1348:1;1338:12;;1328:2;;1364:1;1361;1354:12;1379:196;1438:6;1491:2;1479:9;1470:7;1466:23;1462:32;1459:2;;;1512:6;1504;1497:22;1459:2;1540:29;1559:9;1540:29;:::i;1580:270::-;1648:6;1656;1709:2;1697:9;1688:7;1684:23;1680:32;1677:2;;;1730:6;1722;1715:22;1677:2;1758:29;1777:9;1758:29;:::i;:::-;1748:39;;1806:38;1840:2;1829:9;1825:18;1806:38;:::i;:::-;1796:48;;1667:183;;;;;:::o;1855:338::-;1932:6;1940;1948;2001:2;1989:9;1980:7;1976:23;1972:32;1969:2;;;2022:6;2014;2007:22;1969:2;2050:29;2069:9;2050:29;:::i;:::-;2040:39;;2098:38;2132:2;2121:9;2117:18;2098:38;:::i;:::-;2088:48;;2183:2;2172:9;2168:18;2155:32;2145:42;;1959:234;;;;;:::o;2198:696::-;2293:6;2301;2309;2317;2370:3;2358:9;2349:7;2345:23;2341:33;2338:2;;;2392:6;2384;2377:22;2338:2;2420:29;2439:9;2420:29;:::i;:::-;2410:39;;2468:38;2502:2;2491:9;2487:18;2468:38;:::i;:::-;2458:48;;2553:2;2542:9;2538:18;2525:32;2515:42;;2608:2;2597:9;2593:18;2580:32;2635:18;2627:6;2624:30;2621:2;;;2672:6;2664;2657:22;2621:2;2700:22;;2753:4;2745:13;;2741:27;-1:-1:-1;2731:2:1;;2787:6;2779;2772:22;2731:2;2815:73;2880:7;2875:2;2862:16;2857:2;2853;2849:11;2815:73;:::i;:::-;2805:83;;;2328:566;;;;;;;:::o;2899:325::-;2964:6;2972;3025:2;3013:9;3004:7;3000:23;2996:32;2993:2;;;3046:6;3038;3031:22;2993:2;3074:29;3093:9;3074:29;:::i;:::-;3064:39;;3153:2;3142:9;3138:18;3125:32;3166:28;3188:5;3166:28;:::i;:::-;3213:5;3203:15;;;2983:241;;;;;:::o;3229:291::-;3311:6;3319;3372:2;3360:9;3351:7;3347:23;3343:32;3340:2;;;3393:6;3385;3378:22;3340:2;3421:29;3440:9;3421:29;:::i;:::-;3411:39;;3469:45;3510:2;3499:9;3495:18;3469:45;:::i;3525:359::-;3616:6;3624;3632;3685:2;3673:9;3664:7;3660:23;3656:32;3653:2;;;3706:6;3698;3691:22;3653:2;3734:29;3753:9;3734:29;:::i;:::-;3724:39;;3782:45;3823:2;3812:9;3808:18;3782:45;:::i;3889:264::-;3957:6;3965;4018:2;4006:9;3997:7;3993:23;3989:32;3986:2;;;4039:6;4031;4024:22;3986:2;4067:29;4086:9;4067:29;:::i;:::-;4057:39;4143:2;4128:18;;;;4115:32;;-1:-1:-1;;;3976:177:1:o;4158:668::-;4271:6;4279;4287;4295;4303;4356:3;4344:9;4335:7;4331:23;4327:33;4324:2;;;4378:6;4370;4363:22;4324:2;4406:29;4425:9;4406:29;:::i;:::-;4396:39;;4482:2;4471:9;4467:18;4454:32;4444:42;;4533:2;4522:9;4518:18;4505:32;4495:42;;4588:2;4577:9;4573:18;4560:32;4615:18;4607:6;4604:30;4601:2;;;4652:6;4644;4637:22;4601:2;4696:70;4758:7;4749:6;4738:9;4734:22;4696:70;:::i;:::-;4314:512;;;;-1:-1:-1;4314:512:1;;-1:-1:-1;4785:8:1;;4670:96;4314:512;-1:-1:-1;;;4314:512:1:o;4831:803::-;4953:6;4961;4969;4977;5030:2;5018:9;5009:7;5005:23;5001:32;4998:2;;;5051:6;5043;5036:22;4998:2;5096:9;5083:23;5125:18;5166:2;5158:6;5155:14;5152:2;;;5187:6;5179;5172:22;5152:2;5231:70;5293:7;5284:6;5273:9;5269:22;5231:70;:::i;:::-;5320:8;;-1:-1:-1;5205:96:1;-1:-1:-1;5408:2:1;5393:18;;5380:32;;-1:-1:-1;5424:16:1;;;5421:2;;;5458:6;5450;5443:22;5421:2;;5502:72;5566:7;5555:8;5544:9;5540:24;5502:72;:::i;:::-;4988:646;;;;-1:-1:-1;5593:8:1;-1:-1:-1;;;;4988:646:1:o;5639:255::-;5706:6;5759:2;5747:9;5738:7;5734:23;5730:32;5727:2;;;5780:6;5772;5765:22;5727:2;5817:9;5811:16;5836:28;5858:5;5836:28;:::i;5899:190::-;5958:6;6011:2;5999:9;5990:7;5986:23;5982:32;5979:2;;;6032:6;6024;6017:22;5979:2;-1:-1:-1;6060:23:1;;5969:120;-1:-1:-1;5969:120:1:o;6094:255::-;6152:6;6205:2;6193:9;6184:7;6180:23;6176:32;6173:2;;;6226:6;6218;6211:22;6173:2;6270:9;6257:23;6289:30;6313:5;6289:30;:::i;6354:259::-;6423:6;6476:2;6464:9;6455:7;6451:23;6447:32;6444:2;;;6497:6;6489;6482:22;6444:2;6534:9;6528:16;6553:30;6577:5;6553:30;:::i;6618:480::-;6687:6;6740:2;6728:9;6719:7;6715:23;6711:32;6708:2;;;6761:6;6753;6746:22;6708:2;6806:9;6793:23;6839:18;6831:6;6828:30;6825:2;;;6876:6;6868;6861:22;6825:2;6904:22;;6957:4;6949:13;;6945:27;-1:-1:-1;6935:2:1;;6991:6;6983;6976:22;6935:2;7019:73;7084:7;7079:2;7066:16;7061:2;7057;7053:11;7019:73;:::i;7298:194::-;7368:6;7421:2;7409:9;7400:7;7396:23;7392:32;7389:2;;;7442:6;7434;7427:22;7389:2;-1:-1:-1;7470:16:1;;7379:113;-1:-1:-1;7379:113:1:o;7497:258::-;7565:6;7573;7626:2;7614:9;7605:7;7601:23;7597:32;7594:2;;;7647:6;7639;7632:22;7594:2;-1:-1:-1;;7675:23:1;;;7745:2;7730:18;;;7717:32;;-1:-1:-1;7584:171:1:o;7760:268::-;7812:3;7850:5;7844:12;7877:6;7872:3;7865:19;7893:63;7949:6;7942:4;7937:3;7933:14;7926:4;7919:5;7915:16;7893:63;:::i;:::-;8010:2;7989:15;-1:-1:-1;;7985:29:1;7976:39;;;;8017:4;7972:50;;7820:208;-1:-1:-1;;7820:208:1:o;8033:184::-;8074:3;8112:5;8106:12;8127:52;8172:6;8167:3;8160:4;8153:5;8149:16;8127:52;:::i;:::-;8195:16;;;;;8082:135;-1:-1:-1;;8082:135:1:o;8547:274::-;8676:3;8714:6;8708:13;8730:53;8776:6;8771:3;8764:4;8756:6;8752:17;8730:53;:::i;:::-;8799:16;;;;;8684:137;-1:-1:-1;;8684:137:1:o;8826:1177::-;9002:3;9031;9066:6;9060:13;9096:3;9118:1;9146:9;9142:2;9138:18;9128:28;;9206:2;9195:9;9191:18;9228;9218:2;;9272:4;9264:6;9260:17;9250:27;;9218:2;9298;9346;9338:6;9335:14;9315:18;9312:38;9309:2;;;-1:-1:-1;;;9373:33:1;;9429:4;9426:1;9419:15;9459:4;9380:3;9447:17;9309:2;9490:18;9517:104;;;;9635:1;9630:322;;;;9483:469;;9517:104;-1:-1:-1;;9550:24:1;;9538:37;;9595:16;;;;-1:-1:-1;9517:104:1;;9630:322;22350:4;22369:17;;;22419:4;22403:21;;9725:3;9741:165;9755:6;9752:1;9749:13;9741:165;;;9833:14;;9820:11;;;9813:35;9876:16;;;;9770:10;;9741:165;;;9745:3;;9935:6;9930:3;9926:16;9919:23;;9483:469;;;;;;;9968:29;9993:3;9985:6;9968:29;:::i;:::-;9961:36;9010:993;-1:-1:-1;;;;;9010:993:1:o;11170:499::-;-1:-1:-1;;;;;11439:15:1;;;11421:34;;11491:15;;11486:2;11471:18;;11464:43;11538:2;11523:18;;11516:34;;;11586:3;11581:2;11566:18;;11559:31;;;11364:4;;11607:56;;11643:19;;11635:6;11607:56;:::i;:::-;11599:64;11373:296;-1:-1:-1;;;;;;11373:296:1:o;12327:230::-;12476:2;12465:9;12458:21;12439:4;12496:55;12547:2;12536:9;12532:18;12524:6;12496:55;:::i;13323:414::-;13525:2;13507:21;;;13564:2;13544:18;;;13537:30;13603:34;13598:2;13583:18;;13576:62;-1:-1:-1;;;13669:2:1;13654:18;;13647:48;13727:3;13712:19;;13497:240::o;20708:410::-;20910:2;20892:21;;;20949:2;20929:18;;;20922:30;20988:34;20983:2;20968:18;;20961:62;-1:-1:-1;;;21054:2:1;21039:18;;21032:44;21108:3;21093:19;;20882:236::o;22435:128::-;22475:3;22506:1;22502:6;22499:1;22496:13;22493:2;;;22512:18;;:::i;:::-;-1:-1:-1;22548:9:1;;22483:80::o;22568:120::-;22608:1;22634;22624:2;;22639:18;;:::i;:::-;-1:-1:-1;22673:9:1;;22614:74::o;22693:168::-;22733:7;22799:1;22795;22791:6;22787:14;22784:1;22781:21;22776:1;22769:9;22762:17;22758:45;22755:2;;;22806:18;;:::i;:::-;-1:-1:-1;22846:9:1;;22745:116::o;22866:125::-;22906:4;22934:1;22931;22928:8;22925:2;;;22939:18;;:::i;:::-;-1:-1:-1;22976:9:1;;22915:76::o;22996:258::-;23068:1;23078:113;23092:6;23089:1;23086:13;23078:113;;;23168:11;;;23162:18;23149:11;;;23142:39;23114:2;23107:10;23078:113;;;23209:6;23206:1;23203:13;23200:2;;;-1:-1:-1;;23244:1:1;23226:16;;23219:27;23049:205::o;23259:380::-;23338:1;23334:12;;;;23381;;;23402:2;;23456:4;23448:6;23444:17;23434:27;;23402:2;23509;23501:6;23498:14;23478:18;23475:38;23472:2;;;23555:10;23550:3;23546:20;23543:1;23536:31;23590:4;23587:1;23580:15;23618:4;23615:1;23608:15;23472:2;;23314:325;;;:::o;23644:135::-;23683:3;-1:-1:-1;;23704:17:1;;23701:2;;;23724:18;;:::i;:::-;-1:-1:-1;23771:1:1;23760:13;;23691:88::o;23784:112::-;23816:1;23842;23832:2;;23847:18;;:::i;:::-;-1:-1:-1;23881:9:1;;23822:74::o;23901:127::-;23962:10;23957:3;23953:20;23950:1;23943:31;23993:4;23990:1;23983:15;24017:4;24014:1;24007:15;24033:127;24094:10;24089:3;24085:20;24082:1;24075:31;24125:4;24122:1;24115:15;24149:4;24146:1;24139:15;24165:127;24226:10;24221:3;24217:20;24214:1;24207:31;24257:4;24254:1;24247:15;24281:4;24278:1;24271:15;24297:118;24383:5;24376:13;24369:21;24362:5;24359:32;24349:2;;24405:1;24402;24395:12;24420:131;-1:-1:-1;;;;;;24494:32:1;;24484:43;;24474:2;;24541:1;24538;24531:12

Swarm Source

ipfs://c1a24adb4d1e98ad065b6d441ffca0241a14c25f0ad086c19021ea984a017473

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