Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function _msgSender()    - function _msgData()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(    - function functionCallWithValue(    - function functionCallWithValue(    - function functionStaticCall(address t ...    - function functionStaticCall(    - function functionDelegateCall(address ...    - function functionDelegateCall(    - function verifyCallResultFromTarget(    - function verifyCallResult(    - function _revert(bytes memory returnd ... interface IERC721Receiver    - function onERC721Received( interface IERC165    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(    - function safeTransferFrom(    - function transferFrom(    - function approve(address to, uint256 ...    - function setApprovalForAll(address op ...    - function getApproved(uint256 tokenId)    - function isApprovedForAll(address own ... interface IERC721Metadata is IERC721    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)  contract ERC721 is Context, ERC165 ...    - function supportsInterface(bytes4 int ...    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _baseURI()    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function _safeTransfer(    - function _ownerOf(uint256 tokenId)    - function _exists(uint256 tokenId)    - function _isApprovedOrOwner(address s ...    - function _safeMint(address to, uint25 ...    - function _safeMint(    - function _mint(address to, uint256 to ...    - function _burn(uint256 tokenId)    - function _transfer(    - function _approve(address to, uint256 ...    - function _setApprovalForAll(    - function _requireMinted(uint256 token ...    - function _checkOnERC721Received(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(  contract Y0 is ERC721, Ownable *    - function unpause()    - function pause()    - function totalSupply()    - function _baseURI()    - function updateBaseURI(string memory ...    - function lockMetadata()    - function _mintLoopPublic(address _to, ...    - function _mintLoop(address _to, uint2 ...    - function claimTo(address _to, uint256 ...    - function price(CarType _carType)    - function unclaimedSupply(CarType _car ...    - function mintByOwner(address _to, uin ...    - function withdraw()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-11-23
*/

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


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

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

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


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

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _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) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _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/utils/Context.sol


// 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/Ownable.sol


// 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/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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/ERC721/IERC721Receiver.sol


// 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/IERC165.sol


// 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/utils/introspection/ERC165.sol


// 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/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.8.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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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/extensions/IERC721Metadata.sol


// 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/ERC721.sol


// OpenZeppelin Contracts (last updated v4.8.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 = _ownerOf(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 or 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 or 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 or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

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

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

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @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. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

// File: Y0.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

// @title:  Y0 NFT CARS
// @desc:   3D NFT CONCEPT CARS
// @team:   https://twitter.com/y0_nft
// @url:    https://y0nft.com

/*
██╗░░░██╗░█████╗░
╚██╗░██╔╝██╔══██╗
░╚████╔╝░██║░░██║
░░╚██╔╝░░██║░░██║
░░░██║░░░╚█████╔╝
░░░╚═╝░░░░╚════╝░
███╗░░██╗███████╗████████╗
████╗░██║██╔════╝╚══██╔══╝
██╔██╗██║█████╗░░░░░██║░░░
██║╚████║██╔══╝░░░░░██║░░░
██║░╚███║██║░░░░░░░░██║░░░
╚═╝░░╚══╝╚═╝░░░░░░░░╚═╝░░░
░█████╗░░█████╗░██████╗░░██████╗
██╔══██╗██╔══██╗██╔══██╗██╔════╝
██║░░╚═╝███████║██████╔╝╚█████╗░
██║░░██╗██╔══██║██╔══██╗░╚═══██╗
╚█████╔╝██║░░██║██║░░██║██████╔╝
░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═════╝░
*/




contract Y0 is ERC721, Ownable {
    using Counters for Counters.Counter;

    uint256 public constant NORMAL_CAR_PRICE = 0.5 ether;
    uint256 public constant RARE_CAR_PRICE = 1 ether;
    uint256 public constant SUPER_CAR_PRICE = 2 ether;
    uint256 public constant EXTRA_CAR_PRICE = 4 ether;

    address public constant LEDGER1 = 0x2482c0A3196fafA2C88769087bfb7b9C2e80b1dd; 
    address public constant LEDGER2 = 0x20ADB97C2b2C67FCc2B8BcA8c54825379597681f;
    address public constant DEV = 0x0CA051175A0DEba6635Df8D6E2Cd8cEb8014Bda4;

    uint256 public constant MAX_SUPPLY_NORMAL = 4000;
    uint256 public constant MAX_SUPPLY_RARE = 3000;
    uint256 public constant MAX_SUPPLY_SUPER = 2000;
    uint256 public constant MAX_SUPPLY_EXTRA = 1000;

    uint256 public constant MAX_MINT_PER_TX = 10;

    bool public isPaused = true;
    bool public isMetadataLocked = false;

    Counters.Counter private _totalSupply;

    string private _baseTokenURI;

    // -------- Cars --------
    enum CarType { NORMAL, RARE, SUPER, EXTRA }

    struct Car {
        uint256 price;
        uint256 pad;
        uint256 maxSupply;
        uint256 supply;
    }
    
    mapping(CarType => Car) public cars;

    // -------- Events --------
    event Unpaused();
    event Paused();
    event MetadataUpdated(string indexed _newBaseURI);
    event MetadataLocked();

    constructor (string memory baseURI) ERC721("Y0", "Y0") {
        updateBaseURI(baseURI);

        cars[CarType.NORMAL] = Car(NORMAL_CAR_PRICE, MAX_SUPPLY_RARE + MAX_SUPPLY_SUPER + MAX_SUPPLY_EXTRA, MAX_SUPPLY_NORMAL, 0);
        cars[CarType.RARE]   = Car(RARE_CAR_PRICE, MAX_SUPPLY_SUPER + MAX_SUPPLY_EXTRA, MAX_SUPPLY_RARE, 0);
        cars[CarType.SUPER]  = Car(SUPER_CAR_PRICE, MAX_SUPPLY_EXTRA, MAX_SUPPLY_SUPER, 0);
        cars[CarType.EXTRA]  = Car(EXTRA_CAR_PRICE, 0, MAX_SUPPLY_EXTRA, 0);
    }

    /**
      * @notice Unset the isPaused flag to activate the mint capability 
     */
    function unpause() external onlyOwner {
        isPaused = false;
        emit Unpaused();
    }

    /**
      * @notice Set the isPaused flag to deactivate the mint capability 
     */
    function pause() external onlyOwner {
        isPaused = true;
        emit Paused();
    }

    /**
      * @notice Return the total supply of tokens
     */
    function totalSupply() external view returns (uint256) {
        return _totalSupply.current();
    }

    /**
      * @notice Return the base URI of the token
     */
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }

    /**
      * @notice Update metadata base URI
     */
    function updateBaseURI(string memory _newBaseURI) public onlyOwner {
        require(!isMetadataLocked, "Metadata ownership renounced!");
        _baseTokenURI = _newBaseURI;
        emit MetadataUpdated(_baseTokenURI);
    }

    /**
      * @notice Lock update metadata functionality
     */
    function lockMetadata() external onlyOwner {
        isMetadataLocked = true;
        emit MetadataLocked();
    }

    /**
      * @notice Mint `_num` tokens for public
     */
    function _mintLoopPublic(address _to, uint256 _num, CarType _carType) internal {
        require(msg.value >= cars[_carType].price * _num, 'Ether Value sent is not the right amount');
        _mintLoop(_to, _num, _carType);
    }

    /**
      * @notice Mint `_num` tokens
     */
    function _mintLoop(address _to, uint256 _num, CarType _carType) internal {
        require(cars[_carType].supply + _num <= cars[_carType].maxSupply, 'Exceeded total supply of NFTs of this tier');

        for (uint256 i = 0; i < _num; i++) {
            cars[_carType].supply++;
            _totalSupply.increment();
            _safeMint(_to, cars[_carType].supply + cars[_carType].pad);     
        }
    }

    /**
      * @notice Public Mint function(This mint function can call in Ethereum and credit card payment ways both. In paper.xyz card way, mint function name must be `claimTo`.)
      * @param _to {address} address
      * @param _num {uint256} number of mint for this transaction
      * @param _carType {CarType} mint type (0: normal, 1: rare, 2: super, 3: extra)
     */
    function claimTo(address _to, uint256 _num, CarType _carType) external payable {
        require(!isPaused, 'Mint is not active');
        require(_num > 0 && _num <= MAX_MINT_PER_TX, 'Number of mint cannot be less than 1 and more than maximal number of mint per transaction');
        _mintLoopPublic(_to, _num, _carType);
    }

    /**
      * Public Price function(this function must need paper card way.)
      * @notice Checks the price of the NFT
      * @param _carType {CarType} mint type (0: normal, 1: rare, 2: super, 3: extra)
      * @return {unit256} The price of a single NFT in Wei.
     */
    function price(CarType _carType) public view returns (uint256) {
        return cars[_carType].price;
    }

    /**
      * @notice Checks the total amount of NFTs left to be claimed(This function must need paper card way.)
      * @param _carType {CarType} mint type (0: normal, 1: rare, 2: super, 3: extra)
      * @return uint256 The number of NFTs left to be claimed
     */
    function unclaimedSupply(CarType _carType) public view returns (uint256) {
        return cars[_carType].maxSupply - cars[_carType].supply;
    }

    /**
      * Mint By Owner (for airdrops)
      * @param _to {address} address
      * @param _num {uint256} number of mint for this transaction
      * @param _carType {CarType} mint type (0: normal, 1: rare, 2: super, 3: extra)
     */
    function mintByOwner(address _to, uint256 _num, CarType _carType) external onlyOwner {
        require(!isPaused, 'Mint is not active');
        require(_num > 0 && _num <= MAX_MINT_PER_TX, 'Number of mint cannot be less than 1 and more than maximal number of mint per transaction');
        _mintLoop(_to, _num, _carType);
    }

    /**
      * @notice Function to withdraw collected amount during minting by the team
     */
    function withdraw() external {
        require(msg.sender == LEDGER1 || msg.sender == LEDGER2, "Only Team can withdraw");

        uint256 balance = address(this).balance;

        uint256 SLEDGER1 = (balance * 47 / 100); // 47%
        uint256 SDEV = (balance * 5 / 100); // 5% - Developer payout        
        uint256 SLEDGER2 = balance - SLEDGER1 - SDEV; // 48%
        (bool os1, ) = payable(LEDGER1).call{value: SLEDGER1}("");
        require(os1);
        (bool os2, ) = payable(LEDGER2).call{value: SLEDGER2}("");
        require(os2);
        (bool os3, ) = payable(DEV).call{value: SDEV}("");
        require(os3);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[],"name":"MetadataLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"MetadataUpdated","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":[],"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":[],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEV","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EXTRA_CAR_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LEDGER1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LEDGER2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_MINT_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY_EXTRA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY_NORMAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY_RARE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY_SUPER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NORMAL_CAR_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RARE_CAR_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SUPER_CAR_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum Y0.CarType","name":"","type":"uint8"}],"name":"cars","outputs":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"pad","type":"uint256"},{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"uint256","name":"supply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_num","type":"uint256"},{"internalType":"enum Y0.CarType","name":"_carType","type":"uint8"}],"name":"claimTo","outputs":[],"stateMutability":"payable","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":"isMetadataLocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockMetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_num","type":"uint256"},{"internalType":"enum Y0.CarType","name":"_carType","type":"uint8"}],"name":"mintByOwner","outputs":[],"stateMutability":"nonpayable","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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum Y0.CarType","name":"_carType","type":"uint8"}],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"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":"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":[{"internalType":"enum Y0.CarType","name":"_carType","type":"uint8"}],"name":"unclaimedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"updateBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005746573742f000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : baseURI (string): test/

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [2] : 746573742f000000000000000000000000000000000000000000000000000000

57461:6860:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58127:47;;;;;;;;;;;;58170:4;58127:47;;;;;160:25:1;;;148:2;133:18;58127:47:0;;;;;;;;40009:305;;;;;;;;;;-1:-1:-1;40009:305:0;;;;;:::i;:::-;;:::i;:::-;;;747:14:1;;740:22;722:41;;710:2;695:18;40009:305:0;582:187:1;57602:48:0;;;;;;;;;;;;57643:7;57602:48;;40937:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;42449:171::-;;;;;;;;;;-1:-1:-1;42449:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1879:32:1;;;1861:51;;1849:2;1834:18;42449:171:0;1715:203:1;41967:416:0;;;;;;;;;;-1:-1:-1;41967:416:0;;;;;:::i;:::-;;:::i;:::-;;59853:103;;;;;;;;;;;;;:::i;43149:335::-;;;;;;;;;;-1:-1:-1;43149:335:0;;;;;:::i;:::-;;:::i;57771:76::-;;;;;;;;;;;;57805:42;57771:76;;57543:52;;;;;;;;;;;;57586:9;57543:52;;63673:645;;;;;;;;;;;;;:::i;59483:99::-;;;;;;;;;;;;;:::i;57713:49::-;;;;;;;;;;;;57755:7;57713:49;;43555:185;;;;;;;;;;-1:-1:-1;43555:185:0;;;;;:::i;:::-;;:::i;63232:333::-;;;;;;;;;;-1:-1:-1;63232:333:0;;;;;:::i;:::-;;:::i;57855:76::-;;;;;;;;;;;;57889:42;57855:76;;40647:223;;;;;;;;;;-1:-1:-1;40647:223:0;;;;;:::i;:::-;;:::i;40378:207::-;;;;;;;;;;-1:-1:-1;40378:207:0;;;;;:::i;:::-;;:::i;58181:47::-;;;;;;;;;;;;58224:4;58181:47;;19440:103;;;;;;;;;;;;;:::i;59682:94::-;;;;;;;;;;;;;:::i;58019:48::-;;;;;;;;;;;;58063:4;58019:48;;18792:87;;;;;;;;;;-1:-1:-1;18865:6:0;;-1:-1:-1;;;;;18865:6:0;18792:87;;58237:44;;;;;;;;;;;;58279:2;58237:44;;58074:46;;;;;;;;;;;;58116:4;58074:46;;60214:229;;;;;;;;;;-1:-1:-1;60214:229:0;;;;;:::i;:::-;;:::i;41106:104::-;;;;;;;;;;;;;:::i;60521:117::-;;;;;;;;;;;;;:::i;42692:155::-;;;;;;;;;;-1:-1:-1;42692:155:0;;;;;:::i;:::-;;:::i;61814:333::-;;;;;;:::i;:::-;;:::i;58290:27::-;;;;;;;;;;-1:-1:-1;58290:27:0;;;;-1:-1:-1;;;58290:27:0;;;;;;62830:147;;;;;;;;;;-1:-1:-1;62830:147:0;;;;;:::i;:::-;;:::i;62437:109::-;;;;;;;;;;-1:-1:-1;62437:109:0;;;;;:::i;:::-;;:::i;43811:322::-;;;;;;;;;;-1:-1:-1;43811:322:0;;;;;:::i;:::-;;:::i;57938:72::-;;;;;;;;;;;;57968:42;57938:72;;58664:35;;;;;;;;;;-1:-1:-1;58664:35:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6075:25:1;;;6131:2;6116:18;;6109:34;;;;6159:18;;;6152:34;6217:2;6202:18;;6195:34;6062:3;6047:19;58664:35:0;5844:391:1;41281:281:0;;;;;;;;;;-1:-1:-1;41281:281:0;;;;;:::i;:::-;;:::i;58324:36::-;;;;;;;;;;-1:-1:-1;58324:36:0;;;;-1:-1:-1;;;58324:36:0;;;;;;42918:164;;;;;;;;;;-1:-1:-1;42918:164:0;;;;;:::i;:::-;;:::i;19698:201::-;;;;;;;;;;-1:-1:-1;19698:201:0;;;;;:::i;:::-;;:::i;57657:49::-;;;;;;;;;;;;57699:7;57657:49;;40009:305;40111:4;-1:-1:-1;;;;;;40148:40:0;;-1:-1:-1;;;40148:40:0;;:105;;-1:-1:-1;;;;;;;40205:48:0;;-1:-1:-1;;;40205:48:0;40148:105;:158;;;-1:-1:-1;;;;;;;;;;32630:40:0;;;40270:36;40128:178;40009:305;-1:-1:-1;;40009:305:0:o;40937:100::-;40991:13;41024:5;41017:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40937:100;:::o;42449:171::-;42525:7;42545:23;42560:7;42545:14;:23::i;:::-;-1:-1:-1;42588:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;42588:24:0;;42449:171::o;41967:416::-;42048:13;42064:23;42079:7;42064:14;:23::i;:::-;42048:39;;42112:5;-1:-1:-1;;;;;42106:11:0;:2;-1:-1:-1;;;;;42106:11:0;;42098:57;;;;-1:-1:-1;;;42098:57:0;;7092:2:1;42098:57:0;;;7074:21:1;7131:2;7111:18;;;7104:30;7170:34;7150:18;;;7143:62;-1:-1:-1;;;7221:18:1;;;7214:31;7262:19;;42098:57:0;;;;;;;;;17423:10;-1:-1:-1;;;;;42190:21:0;;;;:62;;-1:-1:-1;42215:37:0;42232:5;17423:10;42918:164;:::i;42215:37::-;42168:173;;;;-1:-1:-1;;;42168:173:0;;7494:2:1;42168:173:0;;;7476:21:1;7533:2;7513:18;;;7506:30;7572:34;7552:18;;;7545:62;7643:31;7623:18;;;7616:59;7692:19;;42168:173:0;7292:425:1;42168:173:0;42354:21;42363:2;42367:7;42354:8;:21::i;:::-;42037:346;41967:416;;:::o;59853:103::-;59899:7;59926:22;:12;964:14;;872:114;59926:22;59919:29;;59853:103;:::o;43149:335::-;43344:41;17423:10;43377:7;43344:18;:41::i;:::-;43336:99;;;;-1:-1:-1;;;43336:99:0;;;;;;;:::i;:::-;43448:28;43458:4;43464:2;43468:7;43448:9;:28::i;63673:645::-;63721:10;57805:42;63721:21;;:46;;-1:-1:-1;63746:10:0;57889:42;63746:21;63721:46;63713:81;;;;-1:-1:-1;;;63713:81:0;;8338:2:1;63713:81:0;;;8320:21:1;8377:2;8357:18;;;8350:30;-1:-1:-1;;;8396:18:1;;;8389:52;8458:18;;63713:81:0;8136:346:1;63713:81:0;63825:21;63807:15;63894:3;63879:12;63825:21;63889:2;63879:12;:::i;:::-;:18;;;;:::i;:::-;63859:39;-1:-1:-1;63916:12:0;63946:3;63932:11;:7;63942:1;63932:11;:::i;:::-;:17;;;;:::i;:::-;63916:34;-1:-1:-1;63994:16:0;63916:34;64013:18;64023:8;64013:7;:18;:::i;:::-;:25;;;;:::i;:::-;64071:42;;63994:44;;-1:-1:-1;64057:8:0;;57805:42;;64100:8;;64057;64071:42;64057:8;64071:42;64100:8;57805:42;64071;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64056:57;;;64132:3;64124:12;;;;;;64162:42;;64148:8;;57889:42;;64191:8;;64148;64162:42;64148:8;64162:42;64191:8;57889:42;64162;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64147:57;;;64223:3;64215:12;;;;;;64253:34;;64239:8;;57968:42;;64278:4;;64239:8;64253:34;64239:8;64253:34;64278:4;57968:42;64253:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64238:49;;;64306:3;64298:12;;;;;;63702:616;;;;;;;63673:645::o;59483:99::-;18678:13;:11;:13::i;:::-;59532:8:::1;:16:::0;;-1:-1:-1;;;;59532:16:0::1;::::0;;59564:10:::1;::::0;::::1;::::0;59543:5:::1;::::0;59564:10:::1;59483:99::o:0;43555:185::-;43693:39;43710:4;43716:2;43720:7;43693:39;;;;;;;;;;;;:16;:39::i;63232:333::-;18678:13;:11;:13::i;:::-;63337:8:::1;::::0;-1:-1:-1;;;63337:8:0;::::1;;;63336:9;63328:40;;;::::0;-1:-1:-1;;;63328:40:0;;9691:2:1;63328:40:0::1;::::0;::::1;9673:21:1::0;9730:2;9710:18;;;9703:30;-1:-1:-1;;;9749:18:1;;;9742:48;9807:18;;63328:40:0::1;9489:342:1::0;63328:40:0::1;63394:1;63387:4;:8;:35;;;;;58279:2;63399:4;:23;;63387:35;63379:137;;;;-1:-1:-1::0;;;63379:137:0::1;;;;;;;:::i;:::-;63527:30;63537:3;63542:4;63548:8;63527:9;:30::i;40647:223::-:0;40719:7;45534:16;;;:7;:16;;;;;;-1:-1:-1;;;;;45534:16:0;;40783:56;;;;-1:-1:-1;;;40783:56:0;;10536:2:1;40783:56:0;;;10518:21:1;10575:2;10555:18;;;10548:30;-1:-1:-1;;;10594:18:1;;;10587:54;10658:18;;40783:56:0;10334:348:1;40378:207:0;40450:7;-1:-1:-1;;;;;40478:19:0;;40470:73;;;;-1:-1:-1;;;40470:73:0;;10889:2:1;40470:73:0;;;10871:21:1;10928:2;10908:18;;;10901:30;10967:34;10947:18;;;10940:62;-1:-1:-1;;;11018:18:1;;;11011:39;11067:19;;40470:73:0;10687:405:1;40470:73:0;-1:-1:-1;;;;;;40561:16:0;;;;;:9;:16;;;;;;;40378:207::o;19440:103::-;18678:13;:11;:13::i;:::-;19505:30:::1;19532:1;19505:18;:30::i;:::-;19440:103::o:0;59682:94::-;18678:13;:11;:13::i;:::-;59729:8:::1;:15:::0;;-1:-1:-1;;;;59729:15:0::1;-1:-1:-1::0;;;59729:15:0::1;::::0;;59760:8:::1;::::0;::::1;::::0;59729:15;;59760:8:::1;59682:94::o:0;60214:229::-;18678:13;:11;:13::i;:::-;60301:16:::1;::::0;-1:-1:-1;;;60301:16:0;::::1;;;60300:17;60292:59;;;::::0;-1:-1:-1;;;60292:59:0;;11299:2:1;60292:59:0::1;::::0;::::1;11281:21:1::0;11338:2;11318:18;;;11311:30;11377:31;11357:18;;;11350:59;11426:18;;60292:59:0::1;11097:353:1::0;60292:59:0::1;60362:13;:27;60378:11:::0;60362:13;:27:::1;:::i;:::-;;60421:13;60405:30;;;;;;:::i;:::-;;::::0;;;;::::1;::::0;;;::::1;::::0;;;::::1;60214:229:::0;:::o;41106:104::-;41162:13;41195:7;41188:14;;;;;:::i;60521:117::-;18678:13;:11;:13::i;:::-;60575:16:::1;:23:::0;;-1:-1:-1;;;;60575:23:0::1;-1:-1:-1::0;;;60575:23:0::1;::::0;;60614:16:::1;::::0;::::1;::::0;60575:23;;60614:16:::1;60521:117::o:0;42692:155::-;42787:52;17423:10;42820:8;42830;42787:18;:52::i;:::-;42692:155;;:::o;61814:333::-;61913:8;;-1:-1:-1;;;61913:8:0;;;;61912:9;61904:40;;;;-1:-1:-1;;;61904:40:0;;9691:2:1;61904:40:0;;;9673:21:1;9730:2;9710:18;;;9703:30;-1:-1:-1;;;9749:18:1;;;9742:48;9807:18;;61904:40:0;9489:342:1;61904:40:0;61970:1;61963:4;:8;:35;;;;;58279:2;61975:4;:23;;61963:35;61955:137;;;;-1:-1:-1;;;61955:137:0;;;;;;;:::i;:::-;62103:36;62119:3;62124:4;62130:8;62103:15;:36::i;62830:147::-;62894:7;62948:4;:14;62953:8;62948:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:21;;;62921:4;:14;62926:8;62921:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:24;;;:48;;;;:::i;62437:109::-;62491:7;62518:4;:14;62523:8;62518:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;62518:14:0;:20;;62437:109;-1:-1:-1;;62437:109:0:o;43811:322::-;43985:41;17423:10;44018:7;43985:18;:41::i;:::-;43977:99;;;;-1:-1:-1;;;43977:99:0;;;;;;;:::i;:::-;44087:38;44101:4;44107:2;44111:7;44120:4;44087:13;:38::i;:::-;43811:322;;;;:::o;41281:281::-;41354:13;41380:23;41395:7;41380:14;:23::i;:::-;41416:21;41440:10;:8;:10::i;:::-;41416:34;;41492:1;41474:7;41468:21;:25;:86;;;;;;;;;;;;;;;;;41520:7;41529:18;:7;:16;:18::i;:::-;41503:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;41468:86;41461:93;41281:281;-1:-1:-1;;;41281:281:0:o;42918:164::-;-1:-1:-1;;;;;43039:25:0;;;43015:4;43039:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;42918:164::o;19698:201::-;18678:13;:11;:13::i;:::-;-1:-1:-1;;;;;19787:22:0;::::1;19779:73;;;::::0;-1:-1:-1;;;19779:73:0;;15341:2:1;19779:73:0::1;::::0;::::1;15323:21:1::0;15380:2;15360:18;;;15353:30;15419:34;15399:18;;;15392:62;-1:-1:-1;;;15470:18:1;;;15463:36;15516:19;;19779:73:0::1;15139:402:1::0;19779:73:0::1;19863:28;19882:8;19863:18;:28::i;:::-;19698:201:::0;:::o;52268:135::-;45936:4;45534:16;;;:7;:16;;;;;;-1:-1:-1;;;;;45534:16:0;52342:53;;;;-1:-1:-1;;;52342:53:0;;10536:2:1;52342:53:0;;;10518:21:1;10575:2;10555:18;;;10548:30;-1:-1:-1;;;10594:18:1;;;10587:54;10658:18;;52342:53:0;10334:348:1;51547:174:0;51622:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;51622:29:0;-1:-1:-1;;;;;51622:29:0;;;;;;;;:24;;51676:23;51622:24;51676:14;:23::i;:::-;-1:-1:-1;;;;;51667:46:0;;;;;;;;;;;51547:174;;:::o;46166:264::-;46259:4;46276:13;46292:23;46307:7;46292:14;:23::i;:::-;46276:39;;46345:5;-1:-1:-1;;;;;46334:16:0;:7;-1:-1:-1;;;;;46334:16:0;;:52;;;;46354:32;46371:5;46378:7;46354:16;:32::i;:::-;46334:87;;;;46414:7;-1:-1:-1;;;;;46390:31:0;:20;46402:7;46390:11;:20::i;:::-;-1:-1:-1;;;;;46390:31:0;;46334:87;46326:96;46166:264;-1:-1:-1;;;;46166:264:0:o;50165:1263::-;50324:4;-1:-1:-1;;;;;50297:31:0;:23;50312:7;50297:14;:23::i;:::-;-1:-1:-1;;;;;50297:31:0;;50289:81;;;;-1:-1:-1;;;50289:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50389:16:0;;50381:65;;;;-1:-1:-1;;;50381:65:0;;16154:2:1;50381:65:0;;;16136:21:1;16193:2;16173:18;;;16166:30;16232:34;16212:18;;;16205:62;-1:-1:-1;;;16283:18:1;;;16276:34;16327:19;;50381:65:0;15952:400:1;50381:65:0;50459:42;50480:4;50486:2;50490:7;50499:1;50459:20;:42::i;:::-;50631:4;-1:-1:-1;;;;;50604:31:0;:23;50619:7;50604:14;:23::i;:::-;-1:-1:-1;;;;;50604:31:0;;50596:81;;;;-1:-1:-1;;;50596:81:0;;;;;;;:::i;:::-;50749:24;;;;:15;:24;;;;;;;;50742:31;;-1:-1:-1;;;;;;50742:31:0;;;;;;-1:-1:-1;;;;;51225:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;51225:20:0;;;51260:13;;;;;;;;;:18;;50742:31;51260:18;;;51300:16;;;:7;:16;;;;;;:21;;;;;;;;;;51339:27;;50765:7;;51339:27;;;42037:346;41967:416;;:::o;18957:132::-;18865:6;;-1:-1:-1;;;;;18865:6:0;17423:10;19021:23;19013:68;;;;-1:-1:-1;;;19013:68:0;;16559:2:1;19013:68:0;;;16541:21:1;;;16578:18;;;16571:30;16637:34;16617:18;;;16610:62;16689:18;;19013:68:0;16357:356:1;61005:417:0;61129:4;:14;61134:8;61129:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:24;;;61121:4;61097;:14;61102:8;61097:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:21;;;:28;;;;:::i;:::-;:56;;61089:111;;;;-1:-1:-1;;;61089:111:0;;17050:2:1;61089:111:0;;;17032:21:1;17089:2;17069:18;;;17062:30;17128:34;17108:18;;;17101:62;-1:-1:-1;;;17179:18:1;;;17172:40;17229:19;;61089:111:0;16848:406:1;61089:111:0;61218:9;61213:202;61237:4;61233:1;:8;61213:202;;;61263:4;:14;61268:8;61263:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:21;;;:23;;;;;;;;;:::i;:::-;;;;;;61301:24;:12;1083:19;;1101:1;1083:19;;;994:127;61301:24;61340:58;61350:3;61379:4;:14;61384:8;61379:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:18;;;61355:4;:14;61360:8;61355:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:21;;;:42;;;;:::i;:::-;61340:9;:58::i;:::-;61243:3;;;;:::i;:::-;;;;61213:202;;20059:191;20152:6;;;-1:-1:-1;;;;;20169:17:0;;;-1:-1:-1;;;;;;20169:17:0;;;;;;;20202:40;;20152:6;;;20169:17;20152:6;;20202:40;;20133:16;;20202:40;20122:128;20059:191;:::o;51864:315::-;52019:8;-1:-1:-1;;;;;52010:17:0;:5;-1:-1:-1;;;;;52010:17:0;;52002:55;;;;-1:-1:-1;;;52002:55:0;;17601:2:1;52002:55:0;;;17583:21:1;17640:2;17620:18;;;17613:30;17679:27;17659:18;;;17652:55;17724:18;;52002:55:0;17399:349:1;52002:55:0;-1:-1:-1;;;;;52068:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;52068:46:0;;;;;;;;;;52130:41;;722::1;;;52130::0;;695:18:1;52130:41:0;;;;;;;51864:315;;;:::o;60711:232::-;60845:4;60822;:14;60827:8;60822:14;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:20;;;:27;;;;:::i;:::-;60809:9;:40;;60801:93;;;;-1:-1:-1;;;60801:93:0;;17955:2:1;60801:93:0;;;17937:21:1;17994:2;17974:18;;;17967:30;18033:34;18013:18;;;18006:62;-1:-1:-1;;;18084:18:1;;;18077:38;18132:19;;60801:93:0;17753:404:1;45014:313:0;45170:28;45180:4;45186:2;45190:7;45170:9;:28::i;:::-;45217:47;45240:4;45246:2;45250:7;45259:4;45217:22;:47::i;:::-;45209:110;;;;-1:-1:-1;;;45209:110:0;;;;;;;:::i;60032:114::-;60092:13;60125;60118:20;;;;;:::i;14770:716::-;14826:13;14877:14;14894:17;14905:5;14894:10;:17::i;:::-;14914:1;14894:21;14877:38;;14930:20;14964:6;14953:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14953:18:0;-1:-1:-1;14930:41:0;-1:-1:-1;15095:28:0;;;15111:2;15095:28;15152:288;-1:-1:-1;;15184:5:0;-1:-1:-1;;;15321:2:0;15310:14;;15305:30;15184:5;15292:44;15382:2;15373:11;;;-1:-1:-1;15403:21:0;15152:288;15403:21;-1:-1:-1;15461:6:0;14770:716;-1:-1:-1;;;14770:716:0:o;54552:410::-;54742:1;54730:9;:13;54726:229;;;-1:-1:-1;;;;;54764:18:0;;;54760:87;;-1:-1:-1;;;;;54803:15:0;;;;;;:9;:15;;;;;:28;;54822:9;;54803:15;:28;;54822:9;;54803:28;:::i;:::-;;;;-1:-1:-1;;54760:87:0;-1:-1:-1;;;;;54865:16:0;;;54861:83;;-1:-1:-1;;;;;54902:13:0;;;;;;:9;:13;;;;;:26;;54919:9;;54902:13;:26;;54919:9;;54902:26;:::i;:::-;;;;-1:-1:-1;;54552:410:0;;;;:::o;46772:110::-;46848:26;46858:2;46862:7;46848:26;;;;;;;;;;;;:9;:26::i;52967:853::-;53121:4;-1:-1:-1;;;;;53142:13:0;;21785:19;:23;53138:675;;53178:71;;-1:-1:-1;;;53178:71:0;;-1:-1:-1;;;;;53178:36:0;;;;;:71;;17423:10;;53229:4;;53235:7;;53244:4;;53178:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53178:71:0;;;;;;;;-1:-1:-1;;53178:71:0;;;;;;;;;;;;:::i;:::-;;;53174:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53419:6;:13;53436:1;53419:18;53415:328;;53462:60;;-1:-1:-1;;;53462:60:0;;;;;;;:::i;53415:328::-;53693:6;53687:13;53678:6;53674:2;53670:15;53663:38;53174:584;-1:-1:-1;;;;;;53300:51:0;-1:-1:-1;;;53300:51:0;;-1:-1:-1;53293:58:0;;53138:675;-1:-1:-1;53797:4:0;52967:853;;;;;;:::o;11636:922::-;11689:7;;-1:-1:-1;;;11767:15:0;;11763:102;;-1:-1:-1;;;11803:15:0;;;-1:-1:-1;11847:2:0;11837:12;11763:102;11892:6;11883:5;:15;11879:102;;11928:6;11919:15;;;-1:-1:-1;11963:2:0;11953:12;11879:102;12008:6;11999:5;:15;11995:102;;12044:6;12035:15;;;-1:-1:-1;12079:2:0;12069:12;11995:102;12124:5;12115;:14;12111:99;;12159:5;12150:14;;;-1:-1:-1;12193:1:0;12183:11;12111:99;12237:5;12228;:14;12224:99;;12272:5;12263:14;;;-1:-1:-1;12306:1:0;12296:11;12224:99;12350:5;12341;:14;12337:99;;12385:5;12376:14;;;-1:-1:-1;12419:1:0;12409:11;12337:99;12463:5;12454;:14;12450:66;;12499:1;12489:11;12544:6;11636:922;-1:-1:-1;;11636:922:0:o;47109:319::-;47238:18;47244:2;47248:7;47238:5;:18::i;:::-;47289:53;47320:1;47324:2;47328:7;47337:4;47289:22;:53::i;:::-;47267:153;;;;-1:-1:-1;;;47267:153:0;;;;;;;:::i;47764:942::-;-1:-1:-1;;;;;47844:16:0;;47836:61;;;;-1:-1:-1;;;47836:61:0;;19531:2:1;47836:61:0;;;19513:21:1;;;19550:18;;;19543:30;19609:34;19589:18;;;19582:62;19661:18;;47836:61:0;19329:356:1;47836:61:0;45936:4;45534:16;;;:7;:16;;;;;;-1:-1:-1;;;;;45534:16:0;45960:31;47908:58;;;;-1:-1:-1;;;47908:58:0;;19892:2:1;47908:58:0;;;19874:21:1;19931:2;19911:18;;;19904:30;19970;19950:18;;;19943:58;20018:18;;47908:58:0;19690:352:1;47908:58:0;47979:48;48008:1;48012:2;48016:7;48025:1;47979:20;:48::i;:::-;45936:4;45534:16;;;:7;:16;;;;;;-1:-1:-1;;;;;45534:16:0;45960:31;48117:58;;;;-1:-1:-1;;;48117:58:0;;19892:2:1;48117:58:0;;;19874:21:1;19931:2;19911:18;;;19904:30;19970;19950:18;;;19943:58;20018:18;;48117:58:0;19690:352:1;48117:58:0;-1:-1:-1;;;;;48524:13:0;;;;;;:9;:13;;;;;;;;:18;;48541:1;48524:18;;;48566:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;48566:21:0;;;;;48605:33;48574:7;;48524:13;;48605:33;;48524:13;;48605:33;42692:155;;:::o;196:131:1:-;-1:-1:-1;;;;;;270:32:1;;260:43;;250:71;;317:1;314;307:12;332:245;390:6;443:2;431:9;422:7;418:23;414:32;411:52;;;459:1;456;449:12;411:52;498:9;485:23;517:30;541:5;517:30;:::i;774:250::-;859:1;869:113;883:6;880:1;877:13;869:113;;;959:11;;;953:18;940:11;;;933:39;905:2;898:10;869:113;;;-1:-1:-1;;1016:1:1;998:16;;991:27;774:250::o;1029:271::-;1071:3;1109:5;1103:12;1136:6;1131:3;1124:19;1152:76;1221:6;1214:4;1209:3;1205:14;1198:4;1191:5;1187:16;1152:76;:::i;:::-;1282:2;1261:15;-1:-1:-1;;1257:29:1;1248:39;;;;1289:4;1244:50;;1029:271;-1:-1:-1;;1029:271:1:o;1305:220::-;1454:2;1443:9;1436:21;1417:4;1474:45;1515:2;1504:9;1500:18;1492:6;1474:45;:::i;1530:180::-;1589:6;1642:2;1630:9;1621:7;1617:23;1613:32;1610:52;;;1658:1;1655;1648:12;1610:52;-1:-1:-1;1681:23:1;;1530:180;-1:-1:-1;1530:180:1:o;1923:173::-;1991:20;;-1:-1:-1;;;;;2040:31:1;;2030:42;;2020:70;;2086:1;2083;2076:12;2020:70;1923:173;;;:::o;2101:254::-;2169:6;2177;2230:2;2218:9;2209:7;2205:23;2201:32;2198:52;;;2246:1;2243;2236:12;2198:52;2269:29;2288:9;2269:29;:::i;:::-;2259:39;2345:2;2330:18;;;;2317:32;;-1:-1:-1;;;2101:254:1:o;2360:328::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2545:29;2564:9;2545:29;:::i;:::-;2535:39;;2593:38;2627:2;2616:9;2612:18;2593:38;:::i;:::-;2583:48;;2678:2;2667:9;2663:18;2650:32;2640:42;;2360:328;;;;;:::o;2693:148::-;2766:20;;2815:1;2805:12;;2795:40;;2831:1;2828;2821:12;2846:345;2935:6;2943;2951;3004:2;2992:9;2983:7;2979:23;2975:32;2972:52;;;3020:1;3017;3010:12;2972:52;3043:29;3062:9;3043:29;:::i;:::-;3033:39;;3119:2;3108:9;3104:18;3091:32;3081:42;;3142:43;3181:2;3170:9;3166:18;3142:43;:::i;:::-;3132:53;;2846:345;;;;;:::o;3196:186::-;3255:6;3308:2;3296:9;3287:7;3283:23;3279:32;3276:52;;;3324:1;3321;3314:12;3276:52;3347:29;3366:9;3347:29;:::i;3387:127::-;3448:10;3443:3;3439:20;3436:1;3429:31;3479:4;3476:1;3469:15;3503:4;3500:1;3493:15;3519:632;3584:5;3614:18;3655:2;3647:6;3644:14;3641:40;;;3661:18;;:::i;:::-;3736:2;3730:9;3704:2;3790:15;;-1:-1:-1;;3786:24:1;;;3812:2;3782:33;3778:42;3766:55;;;3836:18;;;3856:22;;;3833:46;3830:72;;;3882:18;;:::i;:::-;3922:10;3918:2;3911:22;3951:6;3942:15;;3981:6;3973;3966:22;4021:3;4012:6;4007:3;4003:16;4000:25;3997:45;;;4038:1;4035;4028:12;3997:45;4088:6;4083:3;4076:4;4068:6;4064:17;4051:44;4143:1;4136:4;4127:6;4119;4115:19;4111:30;4104:41;;;;3519:632;;;;;:::o;4156:451::-;4225:6;4278:2;4266:9;4257:7;4253:23;4249:32;4246:52;;;4294:1;4291;4284:12;4246:52;4334:9;4321:23;4367:18;4359:6;4356:30;4353:50;;;4399:1;4396;4389:12;4353:50;4422:22;;4475:4;4467:13;;4463:27;-1:-1:-1;4453:55:1;;4504:1;4501;4494:12;4453:55;4527:74;4593:7;4588:2;4575:16;4570:2;4566;4562:11;4527:74;:::i;4612:347::-;4677:6;4685;4738:2;4726:9;4717:7;4713:23;4709:32;4706:52;;;4754:1;4751;4744:12;4706:52;4777:29;4796:9;4777:29;:::i;:::-;4767:39;;4856:2;4845:9;4841:18;4828:32;4903:5;4896:13;4889:21;4882:5;4879:32;4869:60;;4925:1;4922;4915:12;4869:60;4948:5;4938:15;;;4612:347;;;;;:::o;4964:203::-;5035:6;5088:2;5076:9;5067:7;5063:23;5059:32;5056:52;;;5104:1;5101;5094:12;5056:52;5127:34;5151:9;5127:34;:::i;5172:667::-;5267:6;5275;5283;5291;5344:3;5332:9;5323:7;5319:23;5315:33;5312:53;;;5361:1;5358;5351:12;5312:53;5384:29;5403:9;5384:29;:::i;:::-;5374:39;;5432:38;5466:2;5455:9;5451:18;5432:38;:::i;:::-;5422:48;;5517:2;5506:9;5502:18;5489:32;5479:42;;5572:2;5561:9;5557:18;5544:32;5599:18;5591:6;5588:30;5585:50;;;5631:1;5628;5621:12;5585:50;5654:22;;5707:4;5699:13;;5695:27;-1:-1:-1;5685:55:1;;5736:1;5733;5726:12;5685:55;5759:74;5825:7;5820:2;5807:16;5802:2;5798;5794:11;5759:74;:::i;:::-;5749:84;;;5172:667;;;;;;;:::o;6240:260::-;6308:6;6316;6369:2;6357:9;6348:7;6344:23;6340:32;6337:52;;;6385:1;6382;6375:12;6337:52;6408:29;6427:9;6408:29;:::i;:::-;6398:39;;6456:38;6490:2;6479:9;6475:18;6456:38;:::i;:::-;6446:48;;6240:260;;;;;:::o;6505:380::-;6584:1;6580:12;;;;6627;;;6648:61;;6702:4;6694:6;6690:17;6680:27;;6648:61;6755:2;6747:6;6744:14;6724:18;6721:38;6718:161;;6801:10;6796:3;6792:20;6789:1;6782:31;6836:4;6833:1;6826:15;6864:4;6861:1;6854:15;6718:161;;6505:380;;;:::o;7722:409::-;7924:2;7906:21;;;7963:2;7943:18;;;7936:30;8002:34;7997:2;7982:18;;7975:62;-1:-1:-1;;;8068:2:1;8053:18;;8046:43;8121:3;8106:19;;7722:409::o;8487:127::-;8548:10;8543:3;8539:20;8536:1;8529:31;8579:4;8576:1;8569:15;8603:4;8600:1;8593:15;8619:168;8692:9;;;8723;;8740:15;;;8734:22;;8720:37;8710:71;;8761:18;;:::i;8924:217::-;8964:1;8990;8980:132;;9034:10;9029:3;9025:20;9022:1;9015:31;9069:4;9066:1;9059:15;9097:4;9094:1;9087:15;8980:132;-1:-1:-1;9126:9:1;;8924:217::o;9146:128::-;9213:9;;;9234:11;;;9231:37;;;9248:18;;:::i;9836:493::-;10038:2;10020:21;;;10077:2;10057:18;;;10050:30;10116:34;10111:2;10096:18;;10089:62;10187:34;10182:2;10167:18;;10160:62;10259:27;10253:3;10238:19;;10231:56;10319:3;10304:19;;9836:493::o;11581:545::-;11683:2;11678:3;11675:11;11672:448;;;11719:1;11744:5;11740:2;11733:17;11789:4;11785:2;11775:19;11859:2;11847:10;11843:19;11840:1;11836:27;11830:4;11826:38;11895:4;11883:10;11880:20;11877:47;;;-1:-1:-1;11918:4:1;11877:47;11973:2;11968:3;11964:12;11961:1;11957:20;11951:4;11947:31;11937:41;;12028:82;12046:2;12039:5;12036:13;12028:82;;;12091:17;;;12072:1;12061:13;12028:82;;;12032:3;;;11581:545;;;:::o;12302:1352::-;12428:3;12422:10;12455:18;12447:6;12444:30;12441:56;;;12477:18;;:::i;:::-;12506:97;12596:6;12556:38;12588:4;12582:11;12556:38;:::i;:::-;12550:4;12506:97;:::i;:::-;12658:4;;12722:2;12711:14;;12739:1;12734:663;;;;13441:1;13458:6;13455:89;;;-1:-1:-1;13510:19:1;;;13504:26;13455:89;-1:-1:-1;;12259:1:1;12255:11;;;12251:24;12247:29;12237:40;12283:1;12279:11;;;12234:57;13557:81;;12704:944;;12734:663;11528:1;11521:14;;;11565:4;11552:18;;-1:-1:-1;;12770:20:1;;;12888:236;12902:7;12899:1;12896:14;12888:236;;;12991:19;;;12985:26;12970:42;;13083:27;;;;13051:1;13039:14;;;;12918:19;;12888:236;;;12892:3;13152:6;13143:7;13140:19;13137:201;;;13213:19;;;13207:26;-1:-1:-1;;13296:1:1;13292:14;;;13308:3;13288:24;13284:37;13280:42;13265:58;13250:74;;13137:201;-1:-1:-1;;;;;13384:1:1;13368:14;;;13364:22;13351:36;;-1:-1:-1;12302:1352:1:o;13659:842::-;13787:3;13816:1;13849:6;13843:13;13879:36;13905:9;13879:36;:::i;:::-;13934:1;13951:18;;;13978:133;;;;14125:1;14120:356;;;;13944:532;;13978:133;-1:-1:-1;;14011:24:1;;13999:37;;14084:14;;14077:22;14065:35;;14056:45;;;-1:-1:-1;13978:133:1;;14120:356;14151:6;14148:1;14141:17;14181:4;14226:2;14223:1;14213:16;14251:1;14265:165;14279:6;14276:1;14273:13;14265:165;;;14357:14;;14344:11;;;14337:35;14400:16;;;;14294:10;;14265:165;;;14269:3;;;14459:6;14454:3;14450:16;14443:23;;13944:532;-1:-1:-1;14492:3:1;;13659:842;-1:-1:-1;;;;;;13659:842:1:o;14506:127::-;14567:10;14562:3;14558:20;14555:1;14548:31;14598:4;14595:1;14588:15;14622:4;14619:1;14612:15;14638:496;14817:3;14855:6;14849:13;14871:66;14930:6;14925:3;14918:4;14910:6;14906:17;14871:66;:::i;:::-;15000:13;;14959:16;;;;15022:70;15000:13;14959:16;15069:4;15057:17;;15022:70;:::i;:::-;15108:20;;14638:496;-1:-1:-1;;;;14638:496:1:o;15546:401::-;15748:2;15730:21;;;15787:2;15767:18;;;15760:30;15826:34;15821:2;15806:18;;15799:62;-1:-1:-1;;;15892:2:1;15877:18;;15870:35;15937:3;15922:19;;15546:401::o;16718:125::-;16783:9;;;16804:10;;;16801:36;;;16817:18;;:::i;17259:135::-;17298:3;17319:17;;;17316:43;;17339:18;;:::i;:::-;-1:-1:-1;17386:1:1;17375:13;;17259:135::o;18162:414::-;18364:2;18346:21;;;18403:2;18383:18;;;18376:30;18442:34;18437:2;18422:18;;18415:62;-1:-1:-1;;;18508:2:1;18493:18;;18486:48;18566:3;18551:19;;18162:414::o;18581:489::-;-1:-1:-1;;;;;18850:15:1;;;18832:34;;18902:15;;18897:2;18882:18;;18875:43;18949:2;18934:18;;18927:34;;;18997:3;18992:2;18977:18;;18970:31;;;18775:4;;19018:46;;19044:19;;19036:6;19018:46;:::i;:::-;19010:54;18581:489;-1:-1:-1;;;;;;18581:489:1:o;19075:249::-;19144:6;19197:2;19185:9;19176:7;19172:23;19168:32;19165:52;;;19213:1;19210;19203:12;19165:52;19245:9;19239:16;19264:30;19288:5;19264:30;:::i

ipfs://616ef829d5e6f139e384761cae93810a23e332f6908a93e905da57ab1fcd74c7