Contract 0x45b586ba38ba1008e2c648aee067b9f02f565349 1

/**
 *Submitted for verification at polygonscan.com on 2022-07-05
*/

// SPDX-License-Identifier: MIT
// 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.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/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/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


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

pragma solidity ^0.8.0;

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

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

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


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

pragma solidity ^0.8.0;




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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/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: contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;








error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    /**
     * @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) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

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

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _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 {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex &&
            !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// File: @openzeppelin/contracts/finance/PaymentSplitter.sol


// OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;




/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned. The distribution of shares is set at the
 * time of contract deployment and can't be updated thereafter.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Getter for the amount of payee's releasable Ether.
     */
    function releasable(address account) public view returns (uint256) {
        uint256 totalReceived = address(this).balance + totalReleased();
        return _pendingPayment(account, totalReceived, released(account));
    }

    /**
     * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    function releasable(IERC20 token, address account) public view returns (uint256) {
        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        return _pendingPayment(account, totalReceived, released(token, account));
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(token, account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// 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: contracts/Doodlesdino2.sol


pragma solidity ^0.8.12;

//@author Krillmeed_NFT
//@title Doodles Dino 2.0






contract NFTERC721A is Ownable, ERC721A, PaymentSplitter {

    using Strings for uint;

    enum Step {
        Before,
        WhitelistSale,
        PublicSale,
        SoldOut,
        Reveal
    }

    string public baseURI;

    Step public sellingStep;

    uint private constant MAX_SUPPLY = 3333;
    uint private constant MAX_WHITELIST = 0;
    uint private constant MAX_PUBLIC = 3000;
    uint private constant MAX_GIFT = 333;

    uint public wlSalePrice = 15 ether;
    uint public publicSalePrice = 20 ether;

    bytes32 public merkleRoot;

    uint public saleStartTime = 1646737200;

    mapping(address => uint) public amountNFTsperWalletWhitelistSale;

    uint private teamLength;

    constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _merkleRoot, string memory _baseURI) ERC721A("Doodles Dino 2.0", "DD2")
    PaymentSplitter(_team, _teamShares) {
        merkleRoot = _merkleRoot;
        baseURI = _baseURI;
        teamLength = _team.length;
    }

    modifier callerIsUser() {
        require(tx.origin == msg.sender, "The caller is another contract");
        _;
    }

    function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
        uint price = wlSalePrice;
        require(price != 0, "Price is 0");
        require(currentTime() >= saleStartTime, "Whitelist Sale has not started yet");
        require(currentTime() < saleStartTime + 300 minutes, "Whitelist Sale is finished");
        require(sellingStep == Step.WhitelistSale, "Whitelist sale is not activated");
        require(isWhiteListed(msg.sender, _proof), "Not whitelisted");
        require(amountNFTsperWalletWhitelistSale[msg.sender] + _quantity <= 1, "You can only get 1 NFT on the Whitelist Sale");
        require(totalSupply() + _quantity <= MAX_WHITELIST, "Max supply exceeded");
        require(msg.value >= price * _quantity, "Not enought funds");
        amountNFTsperWalletWhitelistSale[msg.sender] += _quantity;
        _safeMint(_account, _quantity);
    }

    function publicSaleMint(address _account, uint _quantity) external payable callerIsUser {
        uint price = publicSalePrice;
        require(price != 0, "Price is 0");
        require(sellingStep == Step.PublicSale, "Public sale is not activated");
        require(totalSupply() + _quantity <= MAX_WHITELIST + MAX_PUBLIC, "Max supply exceeded");
        require(msg.value >= price * _quantity, "Not enought funds");
        _safeMint(_account, _quantity);
    }

    function gift(address _to, uint _quantity) external onlyOwner {
        require(sellingStep > Step.PublicSale, "Gift is after the public sale");
        require(totalSupply() + _quantity <= MAX_SUPPLY, "Reached max Supply");
        _safeMint(_to, _quantity);
    }

    function setSaleStartTime(uint _saleStartTime) external onlyOwner {
        saleStartTime = _saleStartTime;
    }

    function setBaseUri(string memory _baseURI) external onlyOwner {
        baseURI = _baseURI;
    }

    function currentTime() internal view returns(uint) {
        return block.timestamp;
    }

    function setStep(uint _step) external onlyOwner {
        sellingStep = Step(_step);
    }

    function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
        require(_exists(_tokenId), "URI query for nonexistent token");

        return string(abi.encodePacked(baseURI, _tokenId.toString(), ".json"));
    }

    //Whitelist
    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
    }

    function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
        return _verify(leaf(_account), _proof);
    }

    function leaf(address _account) internal pure returns(bytes32) {
        return keccak256(abi.encodePacked(_account));
    }

    function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
        return MerkleProof.verify(_proof, merkleRoot, _leaf);
    }

    //ReleaseALL
    function releaseAll() external {
        for(uint i = 0 ; i < teamLength ; i++) {
            release(payable(payee(i)));
        }
    }

    receive() override external payable {
        revert('Only if you mint');
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[]","name":"_team","type":"address[]"},{"internalType":"uint256[]","name":"_teamShares","type":"uint256[]"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"string","name":"_baseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"amountNFTsperWalletWhitelistSale","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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"gift","outputs":[],"stateMutability":"nonpayable","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":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"publicSaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicSalePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"releaseAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","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":[],"name":"saleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sellingStep","outputs":[{"internalType":"enum NFTERC721A.Step","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_saleStartTime","type":"uint256"}],"name":"setSaleStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_step","type":"uint256"}],"name":"setStep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"wlSalePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000001a048e11ffeaba50c0143e40082086333e27f3eece6301a8e3f2eeaf2a1719c34d100000000000000000000000000000000000000000000000000000000000002c00000000000000000000000000000000000000000000000000000000000000008000000000000000000000000bb895f5a52e656aa01f10ce24d1aa902772ff3ae0000000000000000000000000218ed62195095f410a6934bc2cf5b2f092529760000000000000000000000007b5b696af4db4d346391b887bf698777fdeaba83000000000000000000000000f1fd084be09fe6c10d287b43ff9155b61ffc64a4000000000000000000000000a1c49869493ab396221a89e5c9d2f0f897df0bdf0000000000000000000000000c357583dd7f9b6a8d50233cdef821a52daef4a40000000000000000000000007252e7107bc9816620340cc3bac59dbb8fa1edba0000000000000000000000002c52b7d83e01a2c2920f62f384e43227f8ea1a6000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000007697066733a2f2f00000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _team (address[]): 0xbb895f5a52e656aa01f10ce24d1aa902772ff3ae,0x0218ed62195095f410a6934bc2cf5b2f09252976,0x7b5b696af4db4d346391b887bf698777fdeaba83,0xf1fd084be09fe6c10d287b43ff9155b61ffc64a4,0xa1c49869493ab396221a89e5c9d2f0f897df0bdf,0x0c357583dd7f9b6a8d50233cdef821a52daef4a4,0x7252e7107bc9816620340cc3bac59dbb8fa1edba,0x2c52b7d83e01a2c2920f62f384e43227f8ea1a60
Arg [1] : _teamShares (uint256[]): 16,12,12,12,12,12,12,12
Arg [2] : _merkleRoot (bytes32): 0x48e11ffeaba50c0143e40082086333e27f3eece6301a8e3f2eeaf2a1719c34d1
Arg [3] : _baseURI (string): ipfs://

-----Encoded View---------------
24 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [2] : 48e11ffeaba50c0143e40082086333e27f3eece6301a8e3f2eeaf2a1719c34d1
Arg [3] : 00000000000000000000000000000000000000000000000000000000000002c0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 000000000000000000000000bb895f5a52e656aa01f10ce24d1aa902772ff3ae
Arg [6] : 0000000000000000000000000218ed62195095f410a6934bc2cf5b2f09252976
Arg [7] : 0000000000000000000000007b5b696af4db4d346391b887bf698777fdeaba83
Arg [8] : 000000000000000000000000f1fd084be09fe6c10d287b43ff9155b61ffc64a4
Arg [9] : 000000000000000000000000a1c49869493ab396221a89e5c9d2f0f897df0bdf
Arg [10] : 0000000000000000000000000c357583dd7f9b6a8d50233cdef821a52daef4a4
Arg [11] : 0000000000000000000000007252e7107bc9816620340cc3bac59dbb8fa1edba
Arg [12] : 0000000000000000000000002c52b7d83e01a2c2920f62f384e43227f8ea1a60
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000010
Arg [15] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [16] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [17] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [18] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [19] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [20] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [21] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [22] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [23] : 697066733a2f2f00000000000000000000000000000000000000000000000000

72208:4398:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76567:26;;-1:-1:-1;;;76567:26:0;;216:2:1;76567:26:0;;;198:21:1;255:2;235:18;;;228:30;-1:-1:-1;;;274:18:1;;;267:46;330:18;;76567:26:0;;;;;;;;72208:4398;;;;43398:305;;;;;;;;;;-1:-1:-1;43398:305:0;;;;;:::i;:::-;;:::i;:::-;;;910:14:1;;903:22;885:41;;873:2;858:18;43398:305:0;;;;;;;;46511:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;48014:204::-;;;;;;;;;;-1:-1:-1;48014:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2059:32:1;;;2041:51;;2029:2;2014:18;48014:204:0;1895:203:1;47577:371:0;;;;;;;;;;-1:-1:-1;47577:371:0;;;;;:::i;:::-;;:::i;:::-;;42647:303;;;;;;;;;;-1:-1:-1;42901:12:0;;42885:13;;:28;42647:303;;;2705:25:1;;;2693:2;2678:18;42647:303:0;2559:177:1;67042:453:0;;;;;;;;;;-1:-1:-1;67042:453:0;;;;;:::i;:::-;;:::i;72794:38::-;;;;;;;;;;;;;;;;48879:170;;;;;;;;;;-1:-1:-1;48879:170:0;;;;;:::i;:::-;;:::i;72760:25::-;;;;;;;;;;;;;;;;64652:91;;;;;;;;;;-1:-1:-1;64723:12:0;;64652:91;;65781:135;;;;;;;;;;-1:-1:-1;65781:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;65878:21:0;;;65851:7;65878:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;65781:135;49120:185;;;;;;;;;;-1:-1:-1;49120:185:0;;;;;:::i;:::-;;:::i;67763:514::-;;;;;;;;;;-1:-1:-1;67763:514:0;;;;;:::i;:::-;;:::i;73375:936::-;;;;;;:::i;:::-;;:::i;75075:115::-;;;;;;;;;;-1:-1:-1;75075:115:0;;;;;:::i;:::-;;:::i;76371:141::-;;;;;;;;;;;;;:::i;46319:125::-;;;;;;;;;;-1:-1:-1;46319:125:0;;;;;:::i;:::-;;:::i;72427:21::-;;;;;;;;;;;;;:::i;43767:206::-;;;;;;;;;;-1:-1:-1;43767:206:0;;;;;:::i;:::-;;:::i;71258:103::-;;;;;;;;;;;;;:::i;72672:34::-;;;;;;;;;;;;;;;;75780:106;;;;;;;;;;-1:-1:-1;75780:106:0;;;;;:::i;:::-;;:::i;66007:100::-;;;;;;;;;;-1:-1:-1;66007:100:0;;;;;:::i;:::-;;:::i;70610:87::-;;;;;;;;;;-1:-1:-1;70656:7:0;70683:6;-1:-1:-1;;;;;70683:6:0;70610:87;;46680:104;;;;;;;;;;;;;:::i;65503:109::-;;;;;;;;;;-1:-1:-1;65503:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;65586:18:0;65559:7;65586:18;;;:9;:18;;;;;;;65503:109;72841:64;;;;;;;;;;-1:-1:-1;72841:64:0;;;;;:::i;:::-;;;;;;;;;;;;;;72713:38;;;;;;;;;;;;;;;;75198:100;;;;;;;;;;-1:-1:-1;75198:100:0;;;;;:::i;:::-;;:::i;48290:287::-;;;;;;;;;;-1:-1:-1;48290:287:0;;;;;:::i;:::-;;:::i;66197:225::-;;;;;;;;;;-1:-1:-1;66197:225:0;;;;;:::i;:::-;;:::i;74319:471::-;;;;;;:::i;:::-;;:::i;49376:369::-;;;;;;;;;;-1:-1:-1;49376:369:0;;;;;:::i;:::-;;:::i;66582:260::-;;;;;;;;;;-1:-1:-1;66582:260:0;;;;;:::i;:::-;;:::i;75506:249::-;;;;;;;;;;-1:-1:-1;75506:249:0;;;;;:::i;:::-;;:::i;72457:23::-;;;;;;;;;;-1:-1:-1;72457:23:0;;;;;;;;;;;;;;;:::i;74798:269::-;;;;;;;;;;-1:-1:-1;74798:269:0;;;;;:::i;:::-;;:::i;65299:105::-;;;;;;;;;;-1:-1:-1;65299:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;65380:16:0;65353:7;65380:16;;;:7;:16;;;;;;;65299:105;65089:119;;;;;;;;;;-1:-1:-1;65089:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;65174:26:0;65147:7;65174:26;;;:19;:26;;;;;;;65089:119;64837:95;;;;;;;;;;-1:-1:-1;64910:14:0;;64837:95;;48648:164;;;;;;;;;;-1:-1:-1;48648:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;48769:25:0;;;48745:4;48769:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;48648:164;71516:201;;;;;;;;;;-1:-1:-1;71516:201:0;;;;;:::i;:::-;;:::i;75406:92::-;;;;;;;;;;-1:-1:-1;75406:92:0;;;;;:::i;:::-;;:::i;43398:305::-;43500:4;-1:-1:-1;;;;;;43537:40:0;;-1:-1:-1;;;43537:40:0;;:105;;-1:-1:-1;;;;;;;43594:48:0;;-1:-1:-1;;;43594:48:0;43537:105;:158;;;-1:-1:-1;;;;;;;;;;2978:40:0;;;43659:36;43517:178;43398:305;-1:-1:-1;;43398:305:0:o;46511:100::-;46565:13;46598:5;46591:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46511:100;:::o;48014:204::-;48082:7;48107:16;48115:7;48107;:16::i;:::-;48102:64;;48132:34;;-1:-1:-1;;;48132:34:0;;;;;;;;;;;48102:64;-1:-1:-1;48186:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;48186:24:0;;48014:204::o;47577:371::-;47650:13;47666:24;47682:7;47666:15;:24::i;:::-;47650:40;;47711:5;-1:-1:-1;;;;;47705:11:0;:2;-1:-1:-1;;;;;47705:11:0;;47701:48;;;47725:24;;-1:-1:-1;;;47725:24:0;;;;;;;;;;;47701:48;39002:10;-1:-1:-1;;;;;47766:21:0;;;;;;:63;;-1:-1:-1;47792:37:0;47809:5;39002:10;48648:164;:::i;47792:37::-;47791:38;47766:63;47762:138;;;47853:35;;-1:-1:-1;;;47853:35:0;;;;;;;;;;;47762:138;47912:28;47921:2;47925:7;47934:5;47912:8;:28::i;:::-;47639:309;47577:371;;:::o;67042:453::-;-1:-1:-1;;;;;67118:16:0;;67137:1;67118:16;;;:7;:16;;;;;;67110:71;;;;-1:-1:-1;;;67110:71:0;;;;;;;:::i;:::-;67194:15;67212:19;67223:7;67212:10;:19::i;:::-;67194:37;-1:-1:-1;67252:12:0;67244:68;;;;-1:-1:-1;;;67244:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67325:18:0;;;;;;:9;:18;;;;;:29;;67347:7;;67325:18;:29;;67347:7;;67325:29;:::i;:::-;;;;;;;;67383:7;67365:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;67403:35:0;;-1:-1:-1;67421:7:0;67430;67403:17;:35::i;:::-;67454:33;;;-1:-1:-1;;;;;10648:32:1;;10630:51;;10712:2;10697:18;;10690:34;;;67454:33:0;;10603:18:1;67454:33:0;;;;;;;67099:396;67042:453;:::o;48879:170::-;49013:28;49023:4;49029:2;49033:7;49013:9;:28::i;49120:185::-;49258:39;49275:4;49281:2;49285:7;49258:39;;;;;;;;;;;;:16;:39::i;67763:514::-;-1:-1:-1;;;;;67845:16:0;;67864:1;67845:16;;;:7;:16;;;;;;67837:71;;;;-1:-1:-1;;;67837:71:0;;;;;;;:::i;:::-;67921:15;67939:26;67950:5;67957:7;67939:10;:26::i;:::-;67921:44;-1:-1:-1;67986:12:0;67978:68;;;;-1:-1:-1;;;67978:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68059:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;;;:41;;68093:7;;68059:21;:41;;68093:7;;68059:41;:::i;:::-;;;;-1:-1:-1;;;;;;;68111:26:0;;;;;;:19;:26;;;;;:37;;68141:7;;68111:26;:37;;68141:7;;68111:37;:::i;:::-;;;;-1:-1:-1;68161:47:0;;-1:-1:-1;68184:5:0;68191:7;68200;68161:22;:47::i;:::-;68224:45;;;-1:-1:-1;;;;;10648:32:1;;;10630:51;;10712:2;10697:18;;10690:34;;;68224:45:0;;;;;10603:18:1;68224:45:0;;;;;;;67826:451;67763:514;;:::o;73375:936::-;73289:9;73302:10;73289:23;73281:66;;;;-1:-1:-1;;;73281:66:0;;11216:2:1;73281:66:0;;;11198:21:1;11255:2;11235:18;;;11228:30;11294:32;11274:18;;;11267:60;11344:18;;73281:66:0;11014:354:1;73281:66:0;73513:11:::1;::::0;73543:10;73535:33:::1;;;::::0;-1:-1:-1;;;73535:33:0;;11575:2:1;73535:33:0::1;::::0;::::1;11557:21:1::0;11614:2;11594:18;;;11587:30;-1:-1:-1;;;11633:18:1;;;11626:40;11683:18;;73535:33:0::1;11373:334:1::0;73535:33:0::1;73604:13;::::0;75375:15;73587:30:::1;;73579:77;;;::::0;-1:-1:-1;;;73579:77:0;;11914:2:1;73579:77:0::1;::::0;::::1;11896:21:1::0;11953:2;11933:18;;;11926:30;11992:34;11972:18;;;11965:62;-1:-1:-1;;;12043:18:1;;;12036:32;12085:19;;73579:77:0::1;11712:398:1::0;73579:77:0::1;73691:13;::::0;:27:::1;::::0;73707:11:::1;73691:27;:::i;:::-;75375:15:::0;73675:43:::1;73667:82;;;::::0;-1:-1:-1;;;73667:82:0;;12317:2:1;73667:82:0::1;::::0;::::1;12299:21:1::0;12356:2;12336:18;;;12329:30;12395:28;12375:18;;;12368:56;12441:18;;73667:82:0::1;12115:350:1::0;73667:82:0::1;73783:18;73768:11;::::0;::::1;;:33;::::0;::::1;;;;;;:::i;:::-;;73760:77;;;::::0;-1:-1:-1;;;73760:77:0;;12672:2:1;73760:77:0::1;::::0;::::1;12654:21:1::0;12711:2;12691:18;;;12684:30;12750:33;12730:18;;;12723:61;12801:18;;73760:77:0::1;12470:355:1::0;73760:77:0::1;73856:33;73870:10;73882:6;;73856:13;:33::i;:::-;73848:61;;;::::0;-1:-1:-1;;;73848:61:0;;13032:2:1;73848:61:0::1;::::0;::::1;13014:21:1::0;13071:2;13051:18;;;13044:30;-1:-1:-1;;;13090:18:1;;;13083:45;13145:18;;73848:61:0::1;12830:339:1::0;73848:61:0::1;73961:10;73928:44;::::0;;;:32:::1;:44;::::0;;;;;73988:1:::1;::::0;73928:56:::1;::::0;73975:9;;73928:56:::1;:::i;:::-;:61;;73920:118;;;::::0;-1:-1:-1;;;73920:118:0;;13376:2:1;73920:118:0::1;::::0;::::1;13358:21:1::0;13415:2;13395:18;;;13388:30;13454:34;13434:18;;;13427:62;-1:-1:-1;;;13505:18:1;;;13498:42;13557:19;;73920:118:0::1;13174:408:1::0;73920:118:0::1;72573:1;74073:9;74057:13;42901:12:::0;;42885:13;;:28;;42647:303;74057:13:::1;:25;;;;:::i;:::-;:42;;74049:74;;;::::0;-1:-1:-1;;;74049:74:0;;13789:2:1;74049:74:0::1;::::0;::::1;13771:21:1::0;13828:2;13808:18;;;13801:30;-1:-1:-1;;;13847:18:1;;;13840:49;13906:18;;74049:74:0::1;13587:343:1::0;74049:74:0::1;74155:17;74163:9:::0;74155:5;:17:::1;:::i;:::-;74142:9;:30;;74134:60;;;::::0;-1:-1:-1;;;74134:60:0;;14310:2:1;74134:60:0::1;::::0;::::1;14292:21:1::0;14349:2;14329:18;;;14322:30;-1:-1:-1;;;14368:18:1;;;14361:47;14425:18;;74134:60:0::1;14108:341:1::0;74134:60:0::1;74238:10;74205:44;::::0;;;:32:::1;:44;::::0;;;;:57;;74253:9;;74205:44;:57:::1;::::0;74253:9;;74205:57:::1;:::i;:::-;::::0;;;-1:-1:-1;74273:30:0::1;::::0;-1:-1:-1;74283:8:0;74293:9;74273::::1;:30::i;:::-;73489:822;73375:936:::0;;;;:::o;75075:115::-;70496:13;:11;:13::i;:::-;75152::::1;:30:::0;75075:115::o;76371:141::-;76417:6;76413:92;76434:10;;76430:1;:14;76413:92;;;76467:26;76483:8;76489:1;76483:5;:8::i;76467:26::-;76447:3;;;;:::i;:::-;;;;76413:92;;;;76371:141::o;46319:125::-;46383:7;46410:21;46423:7;46410:12;:21::i;:::-;:26;;46319:125;-1:-1:-1;;46319:125:0:o;72427:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43767:206::-;43831:7;-1:-1:-1;;;;;43855:19:0;;43851:60;;43883:28;;-1:-1:-1;;;43883:28:0;;;;;;;;;;;43851:60;-1:-1:-1;;;;;;43937:19:0;;;;;:12;:19;;;;;:27;;;;43767:206::o;71258:103::-;70496:13;:11;:13::i;:::-;71323:30:::1;71350:1;71323:18;:30::i;:::-;71258:103::o:0;75780:106::-;70496:13;:11;:13::i;:::-;75854:10:::1;:24:::0;75780:106::o;66007:100::-;66058:7;66085;66093:5;66085:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;66085:14:0;;66007:100;-1:-1:-1;;66007:100:0:o;46680:104::-;46736:13;46769:7;46762:14;;;;;:::i;75198:100::-;70496:13;:11;:13::i;:::-;75272:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;75198:100:::0;:::o;48290:287::-;-1:-1:-1;;;;;48389:24:0;;39002:10;48389:24;48385:54;;;48422:17;;-1:-1:-1;;;48422:17:0;;;;;;;;;;;48385:54;39002:10;48452:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;48452:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;48452:53:0;;;;;;;;;;48521:48;;885:41:1;;;48452:42:0;;39002:10;48521:48;;858:18:1;48521:48:0;;;;;;;48290:287;;:::o;66197:225::-;66255:7;66275:21;66323:15;64910:14;;;64837:95;66323:15;66299:39;;:21;:39;:::i;:::-;66275:63;;66356:58;66372:7;66381:13;66396:17;66405:7;-1:-1:-1;;;;;65586:18:0;65559:7;65586:18;;;:9;:18;;;;;;;65503:109;66396:17;66356:15;:58::i;:::-;66349:65;66197:225;-1:-1:-1;;;66197:225:0:o;74319:471::-;73289:9;73302:10;73289:23;73281:66;;;;-1:-1:-1;;;73281:66:0;;11216:2:1;73281:66:0;;;11198:21:1;11255:2;11235:18;;;11228:30;11294:32;11274:18;;;11267:60;11344:18;;73281:66:0;11014:354:1;73281:66:0;74431:15:::1;::::0;74465:10;74457:33:::1;;;::::0;-1:-1:-1;;;74457:33:0;;11575:2:1;74457:33:0::1;::::0;::::1;11557:21:1::0;11614:2;11594:18;;;11587:30;-1:-1:-1;;;11633:18:1;;;11626:40;11683:18;;74457:33:0::1;11373:334:1::0;74457:33:0::1;74524:15;74509:11;::::0;::::1;;:30;::::0;::::1;;;;;;:::i;:::-;;74501:71;;;::::0;-1:-1:-1;;;74501:71:0;;14928:2:1;74501:71:0::1;::::0;::::1;14910:21:1::0;14967:2;14947:18;;;14940:30;15006;14986:18;;;14979:58;15054:18;;74501:71:0::1;14726:352:1::0;74501:71:0::1;74620:26;72616:4;72573:1;74620:26;:::i;:::-;74607:9;74591:13;42901:12:::0;;42885:13;;:28;;42647:303;74591:13:::1;:25;;;;:::i;:::-;:55;;74583:87;;;::::0;-1:-1:-1;;;74583:87:0;;13789:2:1;74583:87:0::1;::::0;::::1;13771:21:1::0;13828:2;13808:18;;;13801:30;-1:-1:-1;;;13847:18:1;;;13840:49;13906:18;;74583:87:0::1;13587:343:1::0;74583:87:0::1;74702:17;74710:9:::0;74702:5;:17:::1;:::i;:::-;74689:9;:30;;74681:60;;;::::0;-1:-1:-1;;;74681:60:0;;14310:2:1;74681:60:0::1;::::0;::::1;14292:21:1::0;14349:2;14329:18;;;14322:30;-1:-1:-1;;;14368:18:1;;;14361:47;14425:18;;74681:60:0::1;14108:341:1::0;74681:60:0::1;74752:30;74762:8;74772:9;74752;:30::i;49376:369::-:0;49543:28;49553:4;49559:2;49563:7;49543:9;:28::i;:::-;-1:-1:-1;;;;;49586:13:0;;12745:19;:23;;49586:76;;;;;49606:56;49637:4;49643:2;49647:7;49656:5;49606:30;:56::i;:::-;49605:57;49586:76;49582:156;;;49686:40;;-1:-1:-1;;;49686:40:0;;;;;;;;;;;49582:156;49376:369;;;;:::o;66582:260::-;-1:-1:-1;;;;;65174:26:0;;66654:7;65174:26;;;:19;:26;;;;;;66654:7;;66698:30;;-1:-1:-1;;;66698:30:0;;66722:4;66698:30;;;2041:51:1;-1:-1:-1;;;;;66698:15:0;;;;;2014:18:1;;66698:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;-1:-1:-1;;;;;65878:21:0;;;65851:7;65878:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;66674:77;;-1:-1:-1;66769:65:0;;66785:7;;66674:77;;66356:15;:58::i;66769:65::-;66762:72;66582:260;-1:-1:-1;;;;66582:260:0:o;75506:249::-;75577:13;75611:17;75619:8;75611:7;:17::i;:::-;75603:61;;;;-1:-1:-1;;;75603:61:0;;15474:2:1;75603:61:0;;;15456:21:1;15513:2;15493:18;;;15486:30;15552:33;15532:18;;;15525:61;15603:18;;75603:61:0;15272:355:1;75603:61:0;75708:7;75717:19;:8;:17;:19::i;:::-;75691:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75677:70;;75506:249;;;:::o;74798:269::-;70496:13;:11;:13::i;:::-;74893:15:::1;74879:11;::::0;::::1;;:29;::::0;::::1;;;;;;:::i;:::-;;74871:71;;;::::0;-1:-1:-1;;;74871:71:0;;17574:2:1;74871:71:0::1;::::0;::::1;17556:21:1::0;17613:2;17593:18;;;17586:30;17652:31;17632:18;;;17625:59;17701:18;;74871:71:0::1;17372:353:1::0;74871:71:0::1;72524:4;74977:9;74961:13;42901:12:::0;;42885:13;;:28;;42647:303;74961:13:::1;:25;;;;:::i;:::-;:39;;74953:70;;;::::0;-1:-1:-1;;;74953:70:0;;17932:2:1;74953:70:0::1;::::0;::::1;17914:21:1::0;17971:2;17951:18;;;17944:30;-1:-1:-1;;;17990:18:1;;;17983:48;18048:18;;74953:70:0::1;17730:342:1::0;74953:70:0::1;75034:25;75044:3;75049:9;75034;:25::i;71516:201::-:0;70496:13;:11;:13::i;:::-;-1:-1:-1;;;;;71605:22:0;::::1;71597:73;;;::::0;-1:-1:-1;;;71597:73:0;;18279:2:1;71597:73:0::1;::::0;::::1;18261:21:1::0;18318:2;18298:18;;;18291:30;18357:34;18337:18;;;18330:62;-1:-1:-1;;;18408:18:1;;;18401:36;18454:19;;71597:73:0::1;18077:402:1::0;71597:73:0::1;71681:28;71700:8;71681:18;:28::i;75406:92::-:0;70496:13;:11;:13::i;:::-;75484:5:::1;75479:11;;;;;;;;:::i;:::-;75465;:25:::0;;-1:-1:-1;;75465:25:0::1;::::0;;::::1;::::0;::::1;;;;;;:::i;:::-;;;;;;75406:92:::0;:::o;50000:187::-;50057:4;50121:13;;50111:7;:23;50081:98;;;;-1:-1:-1;;50152:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;50152:27:0;;;;50151:28;;50000:187::o;58170:196::-;58285:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;58285:29:0;-1:-1:-1;;;;;58285:29:0;;;;;;;;;58330:28;;58285:24;;58330:28;;;;;;;58170:196;;;:::o;13711:317::-;13826:6;13801:21;:31;;13793:73;;;;-1:-1:-1;;;13793:73:0;;18686:2:1;13793:73:0;;;18668:21:1;18725:2;18705:18;;;18698:30;18764:31;18744:18;;;18737:59;18813:18;;13793:73:0;18484:353:1;13793:73:0;13880:12;13898:9;-1:-1:-1;;;;;13898:14:0;13920:6;13898:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13879:52;;;13950:7;13942:78;;;;-1:-1:-1;;;13942:78:0;;19254:2:1;13942:78:0;;;19236:21:1;19293:2;19273:18;;;19266:30;19332:34;19312:18;;;19305:62;19403:28;19383:18;;;19376:56;19449:19;;13942:78:0;19052:422:1;53113:2130:0;53228:35;53266:21;53279:7;53266:12;:21::i;:::-;53228:59;;53326:4;-1:-1:-1;;;;;53304:26:0;:13;:18;;;-1:-1:-1;;;;;53304:26:0;;53300:67;;53339:28;;-1:-1:-1;;;53339:28:0;;;;;;;;;;;53300:67;53380:22;39002:10;-1:-1:-1;;;;;53406:20:0;;;;:73;;-1:-1:-1;53443:36:0;53460:4;39002:10;48648:164;:::i;53443:36::-;53406:126;;;-1:-1:-1;39002:10:0;53496:20;53508:7;53496:11;:20::i;:::-;-1:-1:-1;;;;;53496:36:0;;53406:126;53380:153;;53551:17;53546:66;;53577:35;;-1:-1:-1;;;53577:35:0;;;;;;;;;;;53546:66;-1:-1:-1;;;;;53627:16:0;;53623:52;;53652:23;;-1:-1:-1;;;53652:23:0;;;;;;;;;;;53623:52;53796:35;53813:1;53817:7;53826:4;53796:8;:35::i;:::-;-1:-1:-1;;;;;54127:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;54127:31:0;;;;;;;-1:-1:-1;;54127:31:0;;;;;;;54173:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;54173:29:0;;;;;;;;;;;54253:20;;;:11;:20;;;;;;54288:18;;-1:-1:-1;;;;;;54321:49:0;;;;-1:-1:-1;;;54354:15:0;54321:49;;;;;;;;;;54644:11;;54704:24;;;;;54747:13;;54253:20;;54704:24;;54747:13;54743:384;;54957:13;;54942:11;:28;54938:174;;54995:20;;55064:28;;;;55038:54;;-1:-1:-1;;;55038:54:0;-1:-1:-1;;;;;;55038:54:0;;;-1:-1:-1;;;;;54995:20:0;;55038:54;;;;54938:174;54102:1036;;;55174:7;55170:2;-1:-1:-1;;;;;55155:27:0;55164:4;-1:-1:-1;;;;;55155:27:0;;;;;;;;;;;55193:42;49376:369;25728:211;25872:58;;;-1:-1:-1;;;;;10648:32:1;;25872:58:0;;;10630:51:1;10697:18;;;;10690:34;;;25872:58:0;;;;;;;;;;10603:18:1;;;;25872:58:0;;;;;;;;-1:-1:-1;;;;;25872:58:0;-1:-1:-1;;;25872:58:0;;;25845:86;;25865:5;;25845:19;:86::i;75894:153::-;75984:4;76008:31;76016:14;76021:8;76146:26;;-1:-1:-1;;21913:2:1;21909:15;;;21905:53;76146:26:0;;;21893:66:1;76109:7:0;;21975:12:1;;76146:26:0;;;;;;;;;;;;76136:37;;;;;;76129:44;;76055:126;;;;76016:14;76032:6;;76008:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76008:7:0;;-1:-1:-1;;;76008:31:0:i;50195:104::-;50264:27;50274:2;50278:8;50264:27;;;;;;;;;;;;:9;:27::i;70775:132::-;70656:7;70683:6;-1:-1:-1;;;;;70683:6:0;39002:10;70839:23;70831:68;;;;-1:-1:-1;;;70831:68:0;;19681:2:1;70831:68:0;;;19663:21:1;;;19700:18;;;19693:30;19759:34;19739:18;;;19732:62;19811:18;;70831:68:0;19479:356:1;45148:1109:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;45259:7:0;45342:13;;45335:4;:20;45304:886;;;45376:31;45410:17;;;:11;:17;;;;;;;;;45376:51;;;;;;;;;-1:-1:-1;;;;;45376:51:0;;;;-1:-1:-1;;;45376:51:0;;;;;;;;;;;-1:-1:-1;;;45376:51:0;;;;;;;;;;;;;;45446:729;;45496:14;;-1:-1:-1;;;;;45496:28:0;;45492:101;;45560:9;45148:1109;-1:-1:-1;;;45148:1109:0:o;45492:101::-;-1:-1:-1;;;45935:6:0;45980:17;;;;:11;:17;;;;;;;;;45968:29;;;;;;;;;-1:-1:-1;;;;;45968:29:0;;;;;-1:-1:-1;;;45968:29:0;;;;;;;;;;;-1:-1:-1;;;45968:29:0;;;;;;;;;;;;;46028:28;46024:109;;46096:9;45148:1109;-1:-1:-1;;;45148:1109:0:o;46024:109::-;45895:261;;;45357:833;45304:886;46218:31;;-1:-1:-1;;;46218:31:0;;;;;;;;;;;71877:191;71951:16;71970:6;;-1:-1:-1;;;;;71987:17:0;;;-1:-1:-1;;;;;;71987:17:0;;;;;;72020:40;;71970:6;;;;;;;72020:40;;71951:16;72020:40;71940:128;71877:191;:::o;68455:248::-;68665:12;;-1:-1:-1;;;;;68645:16:0;;68601:7;68645:16;;;:7;:16;;;;;;68601:7;;68680:15;;68629:32;;:13;:32;:::i;:::-;68628:49;;;;:::i;:::-;:67;;;;:::i;58858:667::-;59042:72;;-1:-1:-1;;;59042:72:0;;59021:4;;-1:-1:-1;;;;;59042:36:0;;;;;:72;;39002:10;;59093:4;;59099:7;;59108:5;;59042:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59042:72:0;;;;;;;;-1:-1:-1;;59042:72:0;;;;;;;;;;;;:::i;:::-;;;59038:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59276:13:0;;59272:235;;59322:40;;-1:-1:-1;;;59322:40:0;;;;;;;;;;;59272:235;59465:6;59459:13;59450:6;59446:2;59442:15;59435:38;59038:480;-1:-1:-1;;;;;;59161:55:0;-1:-1:-1;;;59161:55:0;;-1:-1:-1;58858:667:0;;;;;;:::o;9150:723::-;9206:13;9427:10;9423:53;;-1:-1:-1;;9454:10:0;;;;;;;;;;;;-1:-1:-1;;;9454:10:0;;;;;9150:723::o;9423:53::-;9501:5;9486:12;9542:78;9549:9;;9542:78;;9575:8;;;;:::i;:::-;;-1:-1:-1;9598:10:0;;-1:-1:-1;9606:2:0;9598:10;;:::i;:::-;;;9542:78;;;9630:19;9662:6;9652:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9652:17:0;;9630:39;;9680:154;9687:10;;9680:154;;9714:11;9724:1;9714:11;;:::i;:::-;;-1:-1:-1;9783:10:0;9791:2;9783:5;:10;:::i;:::-;9770:24;;:2;:24;:::i;:::-;9757:39;;9740:6;9747;9740:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;9740:56:0;;;;;;;;-1:-1:-1;9811:11:0;9820:2;9811:11;;:::i;:::-;;;9680:154;;28795:716;29219:23;29245:69;29273:4;29245:69;;;;;;;;;;;;;;;;;29253:5;-1:-1:-1;;;;;29245:27:0;;;:69;;;;;:::i;:::-;29329:17;;29219:95;;-1:-1:-1;29329:21:0;29325:179;;29426:10;29415:30;;;;;;;;;;;;:::i;:::-;29407:85;;;;-1:-1:-1;;;29407:85:0;;21555:2:1;29407:85:0;;;21537:21:1;21594:2;21574:18;;;21567:30;21633:34;21613:18;;;21606:62;-1:-1:-1;;;21684:18:1;;;21677:40;21734:19;;29407:85:0;21353:406:1;76189:156:0;76268:4;76292:45;76311:6;76319:10;;76331:5;76292:18;:45::i;50662:163::-;50785:32;50791:2;50795:8;50805:5;50812:4;50785:5;:32::i;15195:229::-;15332:12;15364:52;15386:6;15394:4;15400:1;15403:12;15364:21;:52::i;30737:190::-;30862:4;30915;30886:25;30899:5;30906:4;30886:12;:25::i;:::-;:33;;30737:190;-1:-1:-1;;;;30737:190:0:o;51084:1775::-;51246:13;;-1:-1:-1;;;;;51274:16:0;;51270:48;;51299:19;;-1:-1:-1;;;51299:19:0;;;;;;;;;;;51270:48;51333:13;51329:44;;51355:18;;-1:-1:-1;;;51355:18:0;;;;;;;;;;;51329:44;-1:-1:-1;;;;;51724:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;51783:49:0;;51724:44;;;;;;;;51783:49;;;;-1:-1:-1;;51724:44:0;;;;;;51783:49;;;;;;;;;;;;;;;;51849:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;51899:66:0;;;;-1:-1:-1;;;51949:15:0;51899:66;;;;;;;;;;51849:25;52046:23;;;52090:4;:23;;;;-1:-1:-1;;;;;;52098:13:0;;12745:19;:23;;52098:15;52086:641;;;52134:314;52165:38;;52190:12;;-1:-1:-1;;;;;52165:38:0;;;52182:1;;52165:38;;52182:1;;52165:38;52231:69;52270:1;52274:2;52278:14;;;;;;52294:5;52231:30;:69::i;:::-;52226:174;;52336:40;;-1:-1:-1;;;52336:40:0;;;;;;;;;;;52226:174;52443:3;52427:12;:19;;52134:314;;52529:12;52512:13;;:29;52508:43;;52543:8;;;52508:43;52086:641;;;52592:120;52623:40;;52648:14;;;;;-1:-1:-1;;;;;52623:40:0;;;52640:1;;52623:40;;52640:1;;52623:40;52707:3;52691:12;:19;;52592:120;;52086:641;-1:-1:-1;52741:13:0;:28;52791:60;49376:369;16315:510;16485:12;16543:5;16518:21;:30;;16510:81;;;;-1:-1:-1;;;16510:81:0;;22200:2:1;16510:81:0;;;22182:21:1;22239:2;22219:18;;;22212:30;22278:34;22258:18;;;22251:62;-1:-1:-1;;;22329:18:1;;;22322:36;22375:19;;16510:81:0;21998:402:1;16510:81:0;-1:-1:-1;;;;;12745:19:0;;;16602:60;;;;-1:-1:-1;;;16602:60:0;;22607:2:1;16602:60:0;;;22589:21:1;22646:2;22626:18;;;22619:30;22685:31;22665:18;;;22658:59;22734:18;;16602:60:0;22405:353:1;16602:60:0;16676:12;16690:23;16717:6;-1:-1:-1;;;;;16717:11:0;16736:5;16743:4;16717:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16675:73;;;;16766:51;16783:7;16792:10;16804:12;16766:16;:51::i;:::-;16759:58;16315:510;-1:-1:-1;;;;;;;16315:510:0:o;31604:296::-;31687:7;31730:4;31687:7;31745:118;31769:5;:12;31765:1;:16;31745:118;;;31818:33;31828:12;31842:5;31848:1;31842:8;;;;;;;;:::i;:::-;;;;;;;31818:9;:33::i;:::-;31803:48;-1:-1:-1;31783:3:0;;;;:::i;:::-;;;;31745:118;;;-1:-1:-1;31880:12:0;31604:296;-1:-1:-1;;;31604:296:0:o;19001:762::-;19151:12;19180:7;19176:580;;;-1:-1:-1;19211:10:0;19204:17;;19176:580;19325:17;;:21;19321:424;;19573:10;19567:17;19634:15;19621:10;19617:2;19613:19;19606:44;19321:424;19716:12;19709:20;;-1:-1:-1;;;19709:20:0;;;;;;;;:::i;37811:149::-;37874:7;37905:1;37901;:5;:51;;38036:13;38130:15;;;38166:4;38159:15;;;38213:4;38197:21;;37901:51;;;38036:13;38130:15;;;38166:4;38159:15;;;38213:4;38197:21;;37909:20;37968:268;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;359:131:1;-1:-1:-1;;;;;;433:32:1;;423:43;;413:71;;480:1;477;470:12;495:245;553:6;606:2;594:9;585:7;581:23;577:32;574:52;;;622:1;619;612:12;574:52;661:9;648:23;680:30;704:5;680:30;:::i;937:258::-;1009:1;1019:113;1033:6;1030:1;1027:13;1019:113;;;1109:11;;;1103:18;1090:11;;;1083:39;1055:2;1048:10;1019:113;;;1150:6;1147:1;1144:13;1141:48;;;-1:-1:-1;;1185:1:1;1167:16;;1160:27;937:258::o;1200:269::-;1253:3;1291:5;1285:12;1318:6;1313:3;1306:19;1334:63;1390:6;1383:4;1378:3;1374:14;1367:4;1360:5;1356:16;1334:63;:::i;:::-;1451:2;1430:15;-1:-1:-1;;1426:29:1;1417:39;;;;1458:4;1413:50;;1200:269;-1:-1:-1;;1200:269:1:o;1474:231::-;1623:2;1612:9;1605:21;1586:4;1643:56;1695:2;1684:9;1680:18;1672:6;1643:56;:::i;1710:180::-;1769:6;1822:2;1810:9;1801:7;1797:23;1793:32;1790:52;;;1838:1;1835;1828:12;1790:52;-1:-1:-1;1861:23:1;;1710:180;-1:-1:-1;1710:180:1:o;2103:131::-;-1:-1:-1;;;;;2178:31:1;;2168:42;;2158:70;;2224:1;2221;2214:12;2239:315;2307:6;2315;2368:2;2356:9;2347:7;2343:23;2339:32;2336:52;;;2384:1;2381;2374:12;2336:52;2423:9;2410:23;2442:31;2467:5;2442:31;:::i;:::-;2492:5;2544:2;2529:18;;;;2516:32;;-1:-1:-1;;;2239:315:1:o;2741:255::-;2808:6;2861:2;2849:9;2840:7;2836:23;2832:32;2829:52;;;2877:1;2874;2867:12;2829:52;2916:9;2903:23;2935:31;2960:5;2935:31;:::i;3001:456::-;3078:6;3086;3094;3147:2;3135:9;3126:7;3122:23;3118:32;3115:52;;;3163:1;3160;3153:12;3115:52;3202:9;3189:23;3221:31;3246:5;3221:31;:::i;:::-;3271:5;-1:-1:-1;3328:2:1;3313:18;;3300:32;3341:33;3300:32;3341:33;:::i;:::-;3001:456;;3393:7;;-1:-1:-1;;;3447:2:1;3432:18;;;;3419:32;;3001:456::o;3644:402::-;3726:6;3734;3787:2;3775:9;3766:7;3762:23;3758:32;3755:52;;;3803:1;3800;3793:12;3755:52;3842:9;3829:23;3861:31;3886:5;3861:31;:::i;:::-;3911:5;-1:-1:-1;3968:2:1;3953:18;;3940:32;3981:33;3940:32;3981:33;:::i;:::-;4033:7;4023:17;;;3644:402;;;;;:::o;4051:818::-;4155:6;4163;4171;4179;4232:2;4220:9;4211:7;4207:23;4203:32;4200:52;;;4248:1;4245;4238:12;4200:52;4287:9;4274:23;4306:31;4331:5;4306:31;:::i;:::-;4356:5;-1:-1:-1;4408:2:1;4393:18;;4380:32;;-1:-1:-1;4463:2:1;4448:18;;4435:32;4486:18;4516:14;;;4513:34;;;4543:1;4540;4533:12;4513:34;4581:6;4570:9;4566:22;4556:32;;4626:7;4619:4;4615:2;4611:13;4607:27;4597:55;;4648:1;4645;4638:12;4597:55;4688:2;4675:16;4714:2;4706:6;4703:14;4700:34;;;4730:1;4727;4720:12;4700:34;4783:7;4778:2;4768:6;4765:1;4761:14;4757:2;4753:23;4749:32;4746:45;4743:65;;;4804:1;4801;4794:12;4743:65;4051:818;;;;-1:-1:-1;;4835:2:1;4827:11;;-1:-1:-1;;;4051:818:1:o;5311:127::-;5372:10;5367:3;5363:20;5360:1;5353:31;5403:4;5400:1;5393:15;5427:4;5424:1;5417:15;5443:632;5508:5;5538:18;5579:2;5571:6;5568:14;5565:40;;;5585:18;;:::i;:::-;5660:2;5654:9;5628:2;5714:15;;-1:-1:-1;;5710:24:1;;;5736:2;5706:33;5702:42;5690:55;;;5760:18;;;5780:22;;;5757:46;5754:72;;;5806:18;;:::i;:::-;5846:10;5842:2;5835:22;5875:6;5866:15;;5905:6;5897;5890:22;5945:3;5936:6;5931:3;5927:16;5924:25;5921:45;;;5962:1;5959;5952:12;5921:45;6012:6;6007:3;6000:4;5992:6;5988:17;5975:44;6067:1;6060:4;6051:6;6043;6039:19;6035:30;6028:41;;;;5443:632;;;;;:::o;6080:451::-;6149:6;6202:2;6190:9;6181:7;6177:23;6173:32;6170:52;;;6218:1;6215;6208:12;6170:52;6258:9;6245:23;6291:18;6283:6;6280:30;6277:50;;;6323:1;6320;6313:12;6277:50;6346:22;;6399:4;6391:13;;6387:27;-1:-1:-1;6377:55:1;;6428:1;6425;6418:12;6377:55;6451:74;6517:7;6512:2;6499:16;6494:2;6490;6486:11;6451:74;:::i;6536:118::-;6622:5;6615:13;6608:21;6601:5;6598:32;6588:60;;6644:1;6641;6634:12;6659:382;6724:6;6732;6785:2;6773:9;6764:7;6760:23;6756:32;6753:52;;;6801:1;6798;6791:12;6753:52;6840:9;6827:23;6859:31;6884:5;6859:31;:::i;:::-;6909:5;-1:-1:-1;6966:2:1;6951:18;;6938:32;6979:30;6938:32;6979:30;:::i;7046:795::-;7141:6;7149;7157;7165;7218:3;7206:9;7197:7;7193:23;7189:33;7186:53;;;7235:1;7232;7225:12;7186:53;7274:9;7261:23;7293:31;7318:5;7293:31;:::i;:::-;7343:5;-1:-1:-1;7400:2:1;7385:18;;7372:32;7413:33;7372:32;7413:33;:::i;:::-;7465:7;-1:-1:-1;7519:2:1;7504:18;;7491:32;;-1:-1:-1;7574:2:1;7559:18;;7546:32;7601:18;7590:30;;7587:50;;;7633:1;7630;7623:12;7587:50;7656:22;;7709:4;7701:13;;7697:27;-1:-1:-1;7687:55:1;;7738:1;7735;7728:12;7687:55;7761:74;7827:7;7822:2;7809:16;7804:2;7800;7796:11;7761:74;:::i;:::-;7751:84;;;7046:795;;;;;;;:::o;7846:127::-;7907:10;7902:3;7898:20;7895:1;7888:31;7938:4;7935:1;7928:15;7962:4;7959:1;7952:15;7978:337;8119:2;8104:18;;8152:1;8141:13;;8131:144;;8197:10;8192:3;8188:20;8185:1;8178:31;8232:4;8229:1;8222:15;8260:4;8257:1;8250:15;8131:144;8284:25;;;7978:337;:::o;8979:380::-;9058:1;9054:12;;;;9101;;;9122:61;;9176:4;9168:6;9164:17;9154:27;;9122:61;9229:2;9221:6;9218:14;9198:18;9195:38;9192:161;;;9275:10;9270:3;9266:20;9263:1;9256:31;9310:4;9307:1;9300:15;9338:4;9335:1;9328:15;9192:161;;8979:380;;;:::o;9364:402::-;9566:2;9548:21;;;9605:2;9585:18;;;9578:30;9644:34;9639:2;9624:18;;9617:62;-1:-1:-1;;;9710:2:1;9695:18;;9688:36;9756:3;9741:19;;9364:402::o;9771:407::-;9973:2;9955:21;;;10012:2;9992:18;;;9985:30;10051:34;10046:2;10031:18;;10024:62;-1:-1:-1;;;10117:2:1;10102:18;;10095:41;10168:3;10153:19;;9771:407::o;10183:127::-;10244:10;10239:3;10235:20;10232:1;10225:31;10275:4;10272:1;10265:15;10299:4;10296:1;10289:15;10315:128;10355:3;10386:1;10382:6;10379:1;10376:13;10373:39;;;10392:18;;:::i;:::-;-1:-1:-1;10428:9:1;;10315:128::o;13935:168::-;13975:7;14041:1;14037;14033:6;14029:14;14026:1;14023:21;14018:1;14011:9;14004:17;14000:45;13997:71;;;14048:18;;:::i;:::-;-1:-1:-1;14088:9:1;;13935:168::o;14454:135::-;14493:3;-1:-1:-1;;14514:17:1;;14511:43;;;14534:18;;:::i;:::-;-1:-1:-1;14581:1:1;14570:13;;14454:135::o;14594:127::-;14655:10;14650:3;14646:20;14643:1;14636:31;14686:4;14683:1;14676:15;14710:4;14707:1;14700:15;15083:184;15153:6;15206:2;15194:9;15185:7;15181:23;15177:32;15174:52;;;15222:1;15219;15212:12;15174:52;-1:-1:-1;15245:16:1;;15083:184;-1:-1:-1;15083:184:1:o;15758:185::-;15800:3;15838:5;15832:12;15853:52;15898:6;15893:3;15886:4;15879:5;15875:16;15853:52;:::i;:::-;15921:16;;;;;15758:185;-1:-1:-1;;15758:185:1:o;16066:1301::-;16343:3;16372:1;16405:6;16399:13;16435:3;16457:1;16485:9;16481:2;16477:18;16467:28;;16545:2;16534:9;16530:18;16567;16557:61;;16611:4;16603:6;16599:17;16589:27;;16557:61;16637:2;16685;16677:6;16674:14;16654:18;16651:38;16648:165;;;-1:-1:-1;;;16712:33:1;;16768:4;16765:1;16758:15;16798:4;16719:3;16786:17;16648:165;16829:18;16856:104;;;;16974:1;16969:320;;;;16822:467;;16856:104;-1:-1:-1;;16889:24:1;;16877:37;;16934:16;;;;-1:-1:-1;16856:104:1;;16969:320;15705:1;15698:14;;;15742:4;15729:18;;17064:1;17078:165;17092:6;17089:1;17086:13;17078:165;;;17170:14;;17157:11;;;17150:35;17213:16;;;;17107:10;;17078:165;;;17082:3;;17272:6;17267:3;17263:16;17256:23;;16822:467;;;;;;;17305:56;17330:30;17356:3;17348:6;17330:30;:::i;:::-;-1:-1:-1;;;16008:20:1;;16053:1;16044:11;;15948:113;17305:56;17298:63;16066:1301;-1:-1:-1;;;;;16066:1301:1:o;19840:127::-;19901:10;19896:3;19892:20;19889:1;19882:31;19932:4;19929:1;19922:15;19956:4;19953:1;19946:15;19972:120;20012:1;20038;20028:35;;20043:18;;:::i;:::-;-1:-1:-1;20077:9:1;;19972:120::o;20097:125::-;20137:4;20165:1;20162;20159:8;20156:34;;;20170:18;;:::i;:::-;-1:-1:-1;20207:9:1;;20097:125::o;20227:500::-;-1:-1:-1;;;;;20496:15:1;;;20478:34;;20548:15;;20543:2;20528:18;;20521:43;20595:2;20580:18;;20573:34;;;20643:3;20638:2;20623:18;;20616:31;;;20421:4;;20664:57;;20701:19;;20693:6;20664:57;:::i;:::-;20656:65;20227:500;-1:-1:-1;;;;;;20227:500:1:o;20732:249::-;20801:6;20854:2;20842:9;20833:7;20829:23;20825:32;20822:52;;;20870:1;20867;20860:12;20822:52;20902:9;20896:16;20921:30;20945:5;20921:30;:::i;20986:112::-;21018:1;21044;21034:35;;21049:18;;:::i;:::-;-1:-1:-1;21083:9:1;;20986:112::o;21103:245::-;21170:6;21223:2;21211:9;21202:7;21198:23;21194:32;21191:52;;;21239:1;21236;21229:12;21191:52;21271:9;21265:16;21290:28;21312:5;21290:28;:::i;22763:274::-;22892:3;22930:6;22924:13;22946:53;22992:6;22987:3;22980:4;22972:6;22968:17;22946:53;:::i;:::-;23015:16;;;;;22763:274;-1:-1:-1;;22763:274:1:o

ipfs://bfb648a27831268122469ccd066a65c59fe866b64288a9c6cfb2605cd1665128