Contract Source Code (Solidity)

IDE

• Blockscan IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• interface IERC4906 is IERC165, IERC72 ...
• interface IERC20Errors
• interface IERC721Errors
• interface IERC1155Errors
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• interface IERC721Receiver
•    - function onERC721Received(
• library ERC721Utils
•    - function checkOnERC721Received(
•    - function supportsInterface(bytes4 int ...
• library SafeCast
•    - function toUint248(uint256 value)
•    - function toUint240(uint256 value)
•    - function toUint232(uint256 value)
•    - function toUint224(uint256 value)
•    - function toUint216(uint256 value)
•    - function toUint208(uint256 value)
•    - function toUint200(uint256 value)
•    - function toUint192(uint256 value)
•    - function toUint176(uint256 value)
•    - function toUint168(uint256 value)
•    - function toUint160(uint256 value)
•    - function toUint152(uint256 value)
•    - function toUint144(uint256 value)
•    - function toUint136(uint256 value)
•    - function toUint128(uint256 value)
•    - function toUint120(uint256 value)
•    - function toUint112(uint256 value)
•    - function toUint104(uint256 value)
•    - function toUint96(uint256 value)
•    - function toUint88(uint256 value)
•    - function toUint80(uint256 value)
•    - function toUint72(uint256 value)
•    - function toUint64(uint256 value)
•    - function toUint56(uint256 value)
•    - function toUint48(uint256 value)
•    - function toUint40(uint256 value)
•    - function toUint32(uint256 value)
•    - function toUint24(uint256 value)
•    - function toUint16(uint256 value)
•    - function toUint8(uint256 value)
•    - function toUint256(int256 value)
•    - function toInt248(int256 value)
•    - function toInt240(int256 value)
•    - function toInt232(int256 value)
•    - function toInt224(int256 value)
•    - function toInt216(int256 value)
•    - function toInt208(int256 value)
•    - function toInt200(int256 value)
•    - function toInt192(int256 value)
•    - function toInt184(int256 value)
•    - function toInt176(int256 value)
•    - function toInt168(int256 value)
•    - function toInt160(int256 value)
•    - function toInt152(int256 value)
•    - function toInt144(int256 value)
•    - function toInt136(int256 value)
•    - function toInt128(int256 value)
•    - function toInt120(int256 value)
•    - function toInt112(int256 value)
•    - function toInt104(int256 value)
•    - function toInt96(int256 value)
•    - function toInt88(int256 value)
•    - function toInt80(int256 value)
•    - function toInt72(int256 value)
•    - function toInt64(int256 value)
•    - function toInt56(int256 value)
•    - function toInt48(int256 value)
•    - function toInt40(int256 value)
•    - function toInt32(int256 value)
•    - function toInt24(int256 value)
•    - function toInt16(int256 value)
•    - function toInt8(int256 value)
•    - function toInt256(uint256 value)
•    - function toUint(bool b)
• library Panic
•    - function panic(uint256 code)
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function ternary(bool condition, uint ...
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function invMod(uint256 a, uint256 n)
•    - function invModPrime(uint256 a, uint2 ...
•    - function modExp(uint256 b, uint256 e, ...
•    - function tryModExp(uint256 b, uint256 ...
•    - function modExp(bytes memory b, bytes ...
•    - function tryModExp(
•    - function _zeroBytes(bytes memory byte ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• library SignedMath
•    - function ternary(bool condition, int2 ...
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• library Strings
•    - function toString(uint256 value)
•    - function toStringSigned(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function toChecksumHexString(address ...
•    - function equal(string memory a, strin ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _ownerOf(uint256 tokenId)
•    - function _getApproved(uint256 tokenId ...
•    - function _isAuthorized(address owner, ...
•    - function _checkAuthorized(address own ...
•    - function _increaseBalance(address acc ...
•    - function _update(address to, uint256 ...
•    - function _mint(address to, uint256 to ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(address from, addr ...
•    - function _safeTransfer(address from, ...
•    - function _safeTransfer(address from, ...
•    - function _approve(address to, uint256 ...
•    - function _approve(address to, uint256 ...
•    - function _setApprovalForAll(address o ...
•    - function _requireOwned(uint256 tokenI ...
•    - function supportsInterface(bytes4 int ...
•    - function tokenURI(uint256 tokenId)
•    - function _setTokenURI(uint256 tokenId ...
•    - function paused()
•    - function _requireNotPaused()
•    - function _requirePaused()
•    - function _pause()
•    - function _unpause()
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
•  contract tg_ac3 is ERC721URIStorag ... *
•    - function pause()
•    - function unpause()
•    - function safeMint(address to, string ...
•    - function setMintPrice(uint256 newPric ...
•    - function withdrawAPE()
•    - function supportsInterface(bytes4 int ...

More Options

• Similar
• Compare

/**
 *Submitted for verification at curtis.apescan.io on 2025-03-12
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}


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

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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


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

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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/interfaces/[email protected]




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

/**
 * @dev Required interface of an ERC-721 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 ERC-721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

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

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * 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/interfaces/[email protected]




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

/// @title ERC-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
    /// @dev This event emits when the metadata of a token is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFT.
    event MetadataUpdate(uint256 _tokenId);

    /// @dev This event emits when the metadata of a range of tokens is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFTs.
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}


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

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`'s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator's approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator's approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}


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

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

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

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


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

/**
 * @title ERC-721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC-721 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/token/ERC721/utils/[email protected]

/**
 * @dev Library that provide common ERC-721 utility functions.
 *
 * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].
 *
 * _Available since v5.1._
 */
library ERC721Utils {
    /**
     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC721Received(
        address operator,
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    // Token rejected
                    revert IERC721Errors.ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC721Receiver implementer
                    revert IERC721Errors.ERC721InvalidReceiver(to);
                } else {
                    assembly ("memory-safe") {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}


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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


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

/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }

    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}


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

/**
 * @dev Helper library for emitting standardized panic codes.
 *
 * ```solidity
 * contract Example {
 *      using Panic for uint256;
 *
 *      // Use any of the declared internal constants
 *      function foo() { Panic.GENERIC.panic(); }
 *
 *      // Alternatively
 *      function foo() { Panic.panic(Panic.GENERIC); }
 * }
 * ```
 *
 * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
 *
 * _Available since v5.1._
 */
// slither-disable-next-line unused-state
library Panic {
    /// @dev generic / unspecified error
    uint256 internal constant GENERIC = 0x00;
    /// @dev used by the assert() builtin
    uint256 internal constant ASSERT = 0x01;
    /// @dev arithmetic underflow or overflow
    uint256 internal constant UNDER_OVERFLOW = 0x11;
    /// @dev division or modulo by zero
    uint256 internal constant DIVISION_BY_ZERO = 0x12;
    /// @dev enum conversion error
    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    /// @dev invalid encoding in storage
    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    /// @dev empty array pop
    uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    /// @dev array out of bounds access
    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    /// @dev resource error (too large allocation or too large array)
    uint256 internal constant RESOURCE_ERROR = 0x41;
    /// @dev calling invalid internal function
    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;

    /// @dev Reverts with a panic code. Recommended to use with
    /// the internal constants with predefined codes.
    function panic(uint256 code) internal pure {
        assembly ("memory-safe") {
            mstore(0x00, 0x4e487b71)
            mstore(0x20, code)
            revert(0x1c, 0x24)
        }
    }
}


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

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

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

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

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

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
            if (denominator <= prod1) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
            }

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

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

    /**
     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 exp;
        unchecked {
            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
            value >>= exp;
            result += exp;

            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
            value >>= exp;
            result += exp;

            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
            value >>= exp;
            result += exp;

            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
            value >>= exp;
            result += exp;

            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
            value >>= exp;
            result += exp;

            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
            value >>= exp;
            result += exp;

            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
            value >>= exp;
            result += exp;

            result += SafeCast.toUint(value > 1);
        }
        return result;
    }

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

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

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

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 isGt;
        unchecked {
            isGt = SafeCast.toUint(value > (1 << 128) - 1);
            value >>= isGt * 128;
            result += isGt * 16;

            isGt = SafeCast.toUint(value > (1 << 64) - 1);
            value >>= isGt * 64;
            result += isGt * 8;

            isGt = SafeCast.toUint(value > (1 << 32) - 1);
            value >>= isGt * 32;
            result += isGt * 4;

            isGt = SafeCast.toUint(value > (1 << 16) - 1);
            value >>= isGt * 16;
            result += isGt * 2;

            result += SafeCast.toUint(value > (1 << 8) - 1);
        }
        return result;
    }

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

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}


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

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
        }
    }

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
            // taking advantage of the most significant (or "sign" bit) in two's complement representation.
            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
            int256 mask = n >> 255;

            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
            return uint256((n + mask) ^ mask);
        }
    }
}


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

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            assembly ("memory-safe") {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                assembly ("memory-safe") {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
     * representation, according to EIP-55.
     */
    function toChecksumHexString(address addr) internal pure returns (string memory) {
        bytes memory buffer = bytes(toHexString(addr));

        // hash the hex part of buffer (skip length + 2 bytes, length 40)
        uint256 hashValue;
        assembly ("memory-safe") {
            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
        }

        for (uint256 i = 41; i > 1; --i) {
            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
                // case shift by xoring with 0x20
                buffer[i] ^= 0x20;
            }
            hashValue >>= 4;
        }
        return string(buffer);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}


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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

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

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

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

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

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

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

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

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

        return _getApproved(tokenId);
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if:
     * - `spender` does not have approval from `owner` for `tokenId`.
     * - `spender` does not have approval to manage all of `owner`'s assets.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

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

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }
}


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

/**
 * @dev ERC-721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is IERC4906, ERC721 {
    using Strings for uint256;

    // Interface ID as defined in ERC-4906. This does not correspond to a traditional interface ID as ERC-4906 only
    // defines events and does not include any external function.
    bytes4 private constant ERC4906_INTERFACE_ID = bytes4(0x49064906);

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

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

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

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

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via string.concat).
        if (bytes(_tokenURI).length > 0) {
            return string.concat(base, _tokenURI);
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Emits {MetadataUpdate}.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        _tokenURIs[tokenId] = _tokenURI;
        emit MetadataUpdate(tokenId);
    }
}


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

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

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

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

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

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

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

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

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


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

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}


// File contracts/tg_ac3.sol

contract tg_ac3 is ERC721URIStorage, Ownable, ReentrancyGuard, Pausable {
    uint256 private _tokenIdCounter;
    uint256 public mintPrice = 288000000000000; // 0.000288 APE
    address public immutable APE_TOKEN;

    event MintPriceUpdated(uint256 oldPrice, uint256 newPrice);
    event APEWithdrawn(uint256 amount);

    constructor(address apeToken) ERC721("Telegram", "TG") Ownable(msg.sender) {
        require(apeToken != address(0), "Invalid APE token address");
        APE_TOKEN = apeToken;
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function safeMint(address to, string memory uri) public payable nonReentrant whenNotPaused {
        require(to != address(0), "Invalid recipient address");
        require(bytes(uri).length > 0, "URI cannot be empty");
        require(msg.value == mintPrice, "Incorrect APE amount sent");
        
        uint256 tokenId = _tokenIdCounter;
        _tokenIdCounter += 1;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    function setMintPrice(uint256 newPrice) public onlyOwner {
        require(newPrice > 0, "Price must be greater than 0");
        uint256 oldPrice = mintPrice;
        mintPrice = newPrice;
        emit MintPriceUpdated(oldPrice, newPrice);
    }

    function withdrawAPE() public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No APE to withdraw");
        
        (bool success, ) = owner().call{value: balance}("");
        require(success, "APE withdrawal failed");
        emit APEWithdrawn(balance);
    }

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

[{"inputs":[{"internalType":"address","name":"apeToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"APEWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"MetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"MintPriceUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"APE_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"name":"safeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAPE","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000006cb8cc1e323357af5da49d90fcb7160b7f09e6cd

-----Decoded View---------------
Arg [0] : apeToken (address): 0x6Cb8Cc1e323357Af5da49d90FCb7160B7f09e6Cd

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000006cb8cc1e323357af5da49d90fcb7160b7f09e6cd

118833:1916:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120542:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;96213:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;97385:158;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;97204:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;98054:588;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;119428:65;;;;;;;;;;;;;:::i;:::-;;98713:134;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;114368:86;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;96026:120;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118950:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;95751:213;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3231:103;;;;;;;;;;;;;:::i;:::-;;119359:61;;;;;;;;;;;;;:::i;:::-;;2556:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;119015:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;96373:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;97615:146;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;120222:312;;;;;;;;;;;;;:::i;:::-;;98918:236;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;111652:609;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;119501:454;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;97832:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3489:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;119963:251;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;120542:204;120673:4;120702:36;120726:11;120702:23;:36::i;:::-;120695:43;;120542:204;;;:::o;96213:91::-;96258:13;96291:5;96284:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96213:91;:::o;97385:158::-;97452:7;97472:22;97486:7;97472:13;:22::i;:::-;;97514:21;97527:7;97514:12;:21::i;:::-;97507:28;;97385:158;;;:::o;97204:115::-;97276:35;97285:2;97289:7;97298:12;:10;:12::i;:::-;97276:8;:35::i;:::-;97204:115;;:::o;98054:588::-;98163:1;98149:16;;:2;:16;;;98145:89;;98219:1;98189:33;;;;;;;;;;;:::i;:::-;;;;;;;;98145:89;98455:21;98479:34;98487:2;98491:7;98500:12;:10;:12::i;:::-;98479:7;:34::i;:::-;98455:58;;98545:4;98528:21;;:13;:21;;;98524:111;;98594:4;98600:7;98609:13;98573:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;98524:111;98134:508;98054:588;;;:::o;119428:65::-;2442:13;:11;:13::i;:::-;119475:10:::1;:8;:10::i;:::-;119428:65::o:0;98713:134::-;98800:39;98817:4;98823:2;98827:7;98800:39;;;;;;;;;;;;:16;:39::i;:::-;98713:134;;;:::o;114368:86::-;114415:4;114439:7;;;;;;;;;;;114432:14;;114368:86;:::o;96026:120::-;96089:7;96116:22;96130:7;96116:13;:22::i;:::-;96109:29;;96026:120;;;:::o;118950:42::-;;;;:::o;95751:213::-;95814:7;95855:1;95838:19;;:5;:19;;;95834:89;;95908:1;95881:30;;;;;;;;;;;:::i;:::-;;;;;;;;95834:89;95940:9;:16;95950:5;95940:16;;;;;;;;;;;;;;;;95933:23;;95751:213;;;:::o;3231:103::-;2442:13;:11;:13::i;:::-;3296:30:::1;3323:1;3296:18;:30::i;:::-;3231:103::o:0;119359:61::-;2442:13;:11;:13::i;:::-;119404:8:::1;:6;:8::i;:::-;119359:61::o:0;2556:87::-;2602:7;2629:6;;;;;;;;;;;2622:13;;2556:87;:::o;119015:34::-;;;:::o;96373:95::-;96420:13;96453:7;96446:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96373:95;:::o;97615:146::-;97701:52;97720:12;:10;:12::i;:::-;97734:8;97744;97701:18;:52::i;:::-;97615:146;;:::o;120222:312::-;2442:13;:11;:13::i;:::-;120273:15:::1;120291:21;120273:39;;120341:1;120331:7;:11;120323:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;120387:12;120405:7;:5;:7::i;:::-;:12;;120425:7;120405:32;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120386:51;;;120456:7;120448:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;120505:21;120518:7;120505:21;;;;;;:::i;:::-;;;;;;;;120262:272;;120222:312::o:0;98918:236::-;99032:31;99045:4;99051:2;99055:7;99032:12;:31::i;:::-;99074:72;99108:12;:10;:12::i;:::-;99122:4;99128:2;99132:7;99141:4;99074:33;:72::i;:::-;98918:236;;;;:::o;111652:609::-;111725:13;111751:22;111765:7;111751:13;:22::i;:::-;;111786:23;111812:10;:19;111823:7;111812:19;;;;;;;;;;;111786:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;111842:18;111863:10;:8;:10::i;:::-;111842:31;;111971:1;111955:4;111949:18;:23;111945:72;;111996:9;111989:16;;;;;;111945:72;112144:1;112124:9;112118:23;:27;112114:97;;;112183:4;112189:9;112169:30;;;;;;;;;:::i;:::-;;;;;;;;;;;;;112162:37;;;;;;112114:97;112230:23;112245:7;112230:14;:23::i;:::-;112223:30;;;;111652:609;;;;:::o;119501:454::-;117884:21;:19;:21::i;:::-;113973:19:::1;:17;:19::i;:::-;119625:1:::2;119611:16;;:2;:16;;::::0;119603:54:::2;;;;;;;;;;;;:::i;:::-;;;;;;;;;119696:1;119682:3;119676:17;:21;119668:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;119753:9;;119740;:22;119732:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;119813:15;119831;;119813:33;;119876:1;119857:15;;:20;;;;;;;:::i;:::-;;;;;;;;119888:22;119898:2;119902:7;119888:9;:22::i;:::-;119921:26;119934:7;119943:3;119921:12;:26::i;:::-;119592:363;117928:20:::0;:18;:20::i;:::-;119501:454;;:::o;97832:155::-;97920:4;97944:18;:25;97963:5;97944:25;;;;;;;;;;;;;;;:35;97970:8;97944:35;;;;;;;;;;;;;;;;;;;;;;;;;97937:42;;97832:155;;;;:::o;3489:220::-;2442:13;:11;:13::i;:::-;3594:1:::1;3574:22;;:8;:22;;::::0;3570:93:::1;;3648:1;3620:31;;;;;;;;;;;:::i;:::-;;;;;;;;3570:93;3673:28;3692:8;3673:18;:28::i;:::-;3489:220:::0;:::o;119963:251::-;2442:13;:11;:13::i;:::-;120050:1:::1;120039:8;:12;120031:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;120095:16;120114:9;;120095:28;;120146:8;120134:9;:20;;;;120170:36;120187:8;120197;120170:36;;;;;;;:::i;:::-;;;;;;;;120020:194;119963:251:::0;:::o;111372:209::-;111474:4;111187:10;111180:18;;111498:35;;;:11;:35;;;;:75;;;;111537:36;111561:11;111537:23;:36::i;:::-;111498:75;111491:82;;111372:209;;;:::o;110436:247::-;110499:7;110519:13;110535:17;110544:7;110535:8;:17::i;:::-;110519:33;;110584:1;110567:19;;:5;:19;;;110563:90;;110633:7;110610:31;;;;;;;;;;;:::i;:::-;;;;;;;;110563:90;110670:5;110663:12;;;110436:247;;;:::o;99917:129::-;99987:7;100014:15;:24;100030:7;100014:24;;;;;;;;;;;;;;;;;;;;;100007:31;;99917:129;;;:::o;661:98::-;714:7;741:10;734:17;;661:98;:::o;108668:122::-;108749:33;108758:2;108762:7;108771:4;108777;108749:8;:33::i;:::-;108668:122;;;:::o;102878:824::-;102964:7;102984:12;102999:17;103008:7;102999:8;:17::i;:::-;102984:32;;103095:1;103079:18;;:4;:18;;;103075:88;;103114:37;103131:4;103137;103143:7;103114:16;:37::i;:::-;103075:88;103226:1;103210:18;;:4;:18;;;103206:263;;103328:48;103345:1;103349:7;103366:1;103370:5;103328:8;:48::i;:::-;103441:1;103422:9;:15;103432:4;103422:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;103206:263;103499:1;103485:16;;:2;:16;;;103481:111;;103564:1;103547:9;:13;103557:2;103547:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;103481:111;103623:2;103604:7;:16;103612:7;103604:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;103662:7;103658:2;103643:27;;103652:4;103643:27;;;;;;;;;;;;103690:4;103683:11;;;102878:824;;;;;:::o;2721:166::-;2792:12;:10;:12::i;:::-;2781:23;;:7;:5;:7::i;:::-;:23;;;2777:103;;2855:12;:10;:12::i;:::-;2828:40;;;;;;;;;;;:::i;:::-;;;;;;;;2777:103;2721:166::o;115269:120::-;114232:16;:14;:16::i;:::-;115338:5:::1;115328:7;;:15;;;;;;;;;;;;;;;;;;115359:22;115368:12;:10;:12::i;:::-;115359:22;;;;;;:::i;:::-;;;;;;;;115269:120::o:0;3869:191::-;3943:16;3962:6;;;;;;;;;;;3943:25;;3988:8;3979:6;;:17;;;;;;;;;;;;;;;;;;4043:8;4012:40;;4033:8;4012:40;;;;;;;;;;;;3932:128;3869:191;:::o;115010:118::-;113973:19;:17;:19::i;:::-;115080:4:::1;115070:7;;:14;;;;;;;;;;;;;;;;;;115100:20;115107:12;:10;:12::i;:::-;115100:20;;;;;;:::i;:::-;;;;;;;;115010:118::o:0;109875:318::-;110003:1;109983:22;;:8;:22;;;109979:93;;110051:8;110029:31;;;;;;;;;;;:::i;:::-;;;;;;;;109979:93;110120:8;110082:18;:25;110101:5;110082:25;;;;;;;;;;;;;;;:35;110108:8;110082:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;110166:8;110144:41;;110159:5;110144:41;;;110176:8;110144:41;;;;;;:::i;:::-;;;;;;;;109875:318;;;:::o;19776:948::-;19980:1;19963:2;:14;;;:18;19959:758;;;20018:2;20002:36;;;20039:8;20049:4;20055:7;20064:4;20002:67;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;19998:708;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20382:1;20365:6;:13;:18;20361:330;;20507:2;20471:39;;;;;;;;;;;:::i;:::-;;;;;;;;20361:330;20641:6;20635:13;20626:6;20622:2;20618:15;20611:38;19998:708;20127:41;;;20117:51;;;:6;:51;;;;20113:185;;20275:2;20239:39;;;;;;;;;;;:::i;:::-;;;;;;;;20113:185;20070:243;19959:758;19776:948;;;;;:::o;97048:94::-;97099:13;97125:9;;;;;;;;;;;;;;97048:94;:::o;96539:260::-;96603:13;96629:22;96643:7;96629:13;:22::i;:::-;;96664:21;96688:10;:8;:10::i;:::-;96664:34;;96740:1;96722:7;96716:21;:25;:75;;;;;;;;;;;;;;;;;96758:7;96767:18;:7;:16;:18::i;:::-;96744:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;96716:75;96709:82;;;96539:260;;;:::o;117964:315::-;117262:1;118093:7;;:18;118089:88;;118135:30;;;;;;;;;;;;;;118089:88;117262:1;118254:7;:17;;;;117964:315::o;114527:132::-;114593:8;:6;:8::i;:::-;114589:63;;;114625:15;;;;;;;;;;;;;;114589:63;114527:132::o;104736:102::-;104804:26;104814:2;104818:7;104804:26;;;;;;;;;;;;:9;:26::i;:::-;104736:102;;:::o;112387:170::-;112501:9;112479:10;:19;112490:7;112479:19;;;;;;;;;;;:31;;;;;;:::i;:::-;;112526:23;112541:7;112526:23;;;;;;:::i;:::-;;;;;;;;112387:170;;:::o;118287:212::-;117219:1;118470:7;:21;;;;118287:212::o;95382:305::-;95484:4;95536:25;95521:40;;;:11;:40;;;;:105;;;;95593:33;95578:48;;;:11;:48;;;;95521:105;:158;;;;95643:36;95667:11;95643:23;:36::i;:::-;95521:158;95501:178;;95382:305;;;:::o;99679:117::-;99745:7;99772;:16;99780:7;99772:16;;;;;;;;;;;;;;;;;;;;;99765:23;;99679:117;;;:::o;108978:678::-;109140:9;:31;;;;109169:1;109153:18;;:4;:18;;;;109140:31;109136:471;;;109188:13;109204:22;109218:7;109204:13;:22::i;:::-;109188:38;;109373:1;109357:18;;:4;:18;;;;:35;;;;;109388:4;109379:13;;:5;:13;;;;109357:35;:69;;;;;109397:29;109414:5;109421:4;109397:16;:29::i;:::-;109396:30;109357:69;109353:144;;;109476:4;109454:27;;;;;;;;;;;:::i;:::-;;;;;;;;109353:144;109517:9;109513:83;;;109572:7;109568:2;109552:28;;109561:5;109552:28;;;;;;;;;;;;109513:83;109173:434;109136:471;109646:2;109619:15;:24;109635:7;109619:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;108978:678;;;;:::o;101085:376::-;101198:38;101212:5;101219:7;101228;101198:13;:38::i;:::-;101193:261;;101274:1;101257:19;;:5;:19;;;101253:190;;101327:7;101304:31;;;;;;;;;;;:::i;:::-;;;;;;;;101253:190;101410:7;101419;101383:44;;;;;;;;;;;;:::i;:::-;;;;;;;;101193:261;101085:376;;;:::o;114736:130::-;114800:8;:6;:8::i;:::-;114795:64;;114832:15;;;;;;;;;;;;;;114795:64;114736:130::o;90858:650::-;90914:13;90965:14;91002:1;90982:17;90993:5;90982:10;:17::i;:::-;:21;90965:38;;91018:20;91052:6;91041:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91018:41;;91074:11;91171:6;91167:2;91163:15;91155:6;91151:28;91144:35;;91208:254;91215:4;91208:254;;;91240:5;;;;;;;;91346:10;91341:2;91334:5;91330:14;91325:32;91320:3;91312:46;91404:2;91395:11;;;;;;:::i;:::-;;;;;91438:1;91429:5;:10;91208:254;91425:21;91208:254;91483:6;91476:13;;;;;90858:650;;;:::o;105065:210::-;105160:18;105166:2;105170:7;105160:5;:18::i;:::-;105189:78;105223:12;:10;:12::i;:::-;105245:1;105249:2;105253:7;105262:4;105189:33;:78::i;:::-;105065:210;;;:::o;21405:148::-;21481:4;21520:25;21505:40;;;:11;:40;;;;21498:47;;21405:148;;;:::o;100366:276::-;100469:4;100525:1;100506:21;;:7;:21;;;;:128;;;;;100554:7;100545:16;;:5;:16;;;:52;;;;100565:32;100582:5;100589:7;100565:16;:32::i;:::-;100545:52;:88;;;;100626:7;100601:32;;:21;100614:7;100601:12;:21::i;:::-;:32;;;100545:88;100506:128;100486:148;;100366:276;;;;;:::o;84703:948::-;84756:7;84776:14;84793:1;84776:18;;84843:8;84834:5;:17;84830:106;;84881:8;84872:17;;;;;;:::i;:::-;;;;;84918:2;84908:12;;;;84830:106;84963:8;84954:5;:17;84950:106;;85001:8;84992:17;;;;;;:::i;:::-;;;;;85038:2;85028:12;;;;84950:106;85083:8;85074:5;:17;85070:106;;85121:8;85112:17;;;;;;:::i;:::-;;;;;85158:2;85148:12;;;;85070:106;85203:7;85194:5;:16;85190:103;;85240:7;85231:16;;;;;;:::i;:::-;;;;;85276:1;85266:11;;;;85190:103;85320:7;85311:5;:16;85307:103;;85357:7;85348:16;;;;;;:::i;:::-;;;;;85393:1;85383:11;;;;85307:103;85437:7;85428:5;:16;85424:103;;85474:7;85465:16;;;;;;:::i;:::-;;;;;85510:1;85500:11;;;;85424:103;85554:7;85545:5;:16;85541:68;;85592:1;85582:11;;;;85541:68;85637:6;85630:13;;;84703:948;;;:::o;104038:335::-;104120:1;104106:16;;:2;:16;;;104102:89;;104176:1;104146:33;;;;;;;;;;;:::i;:::-;;;;;;;;104102:89;104201:21;104225:32;104233:2;104237:7;104254:1;104225:7;:32::i;:::-;104201:56;;104297:1;104272:27;;:13;:27;;;104268:98;;104351:1;104323:31;;;;;;;;;;;:::i;:::-;;;;;;;;104268:98;104091:282;104038:335;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:619::-;4967:6;4975;4983;5032:2;5020:9;5011:7;5007:23;5003:32;5000:119;;;5038:79;;:::i;:::-;5000:119;5158:1;5183:53;5228:7;5219:6;5208:9;5204:22;5183:53;:::i;:::-;5173:63;;5129:117;5285:2;5311:53;5356:7;5347:6;5336:9;5332:22;5311:53;:::i;:::-;5301:63;;5256:118;5413:2;5439:53;5484:7;5475:6;5464:9;5460:22;5439:53;:::i;:::-;5429:63;;5384:118;4890:619;;;;;:::o;5515:118::-;5602:24;5620:5;5602:24;:::i;:::-;5597:3;5590:37;5515:118;;:::o;5639:222::-;5732:4;5770:2;5759:9;5755:18;5747:26;;5783:71;5851:1;5840:9;5836:17;5827:6;5783:71;:::i;:::-;5639:222;;;;:::o;5867:329::-;5926:6;5975:2;5963:9;5954:7;5950:23;5946:32;5943:119;;;5981:79;;:::i;:::-;5943:119;6101:1;6126:53;6171:7;6162:6;6151:9;6147:22;6126:53;:::i;:::-;6116:63;;6072:117;5867:329;;;;:::o;6202:116::-;6272:21;6287:5;6272:21;:::i;:::-;6265:5;6262:32;6252:60;;6308:1;6305;6298:12;6252:60;6202:116;:::o;6324:133::-;6367:5;6405:6;6392:20;6383:29;;6421:30;6445:5;6421:30;:::i;:::-;6324:133;;;;:::o;6463:468::-;6528:6;6536;6585:2;6573:9;6564:7;6560:23;6556:32;6553:119;;;6591:79;;:::i;:::-;6553:119;6711:1;6736:53;6781:7;6772:6;6761:9;6757:22;6736:53;:::i;:::-;6726:63;;6682:117;6838:2;6864:50;6906:7;6897:6;6886:9;6882:22;6864:50;:::i;:::-;6854:60;;6809:115;6463:468;;;;;:::o;6937:117::-;7046:1;7043;7036:12;7060:117;7169:1;7166;7159:12;7183:180;7231:77;7228:1;7221:88;7328:4;7325:1;7318:15;7352:4;7349:1;7342:15;7369:281;7452:27;7474:4;7452:27;:::i;:::-;7444:6;7440:40;7582:6;7570:10;7567:22;7546:18;7534:10;7531:34;7528:62;7525:88;;;7593:18;;:::i;:::-;7525:88;7633:10;7629:2;7622:22;7412:238;7369:281;;:::o;7656:129::-;7690:6;7717:20;;:::i;:::-;7707:30;;7746:33;7774:4;7766:6;7746:33;:::i;:::-;7656:129;;;:::o;7791:307::-;7852:4;7942:18;7934:6;7931:30;7928:56;;;7964:18;;:::i;:::-;7928:56;8002:29;8024:6;8002:29;:::i;:::-;7994:37;;8086:4;8080;8076:15;8068:23;;7791:307;;;:::o;8104:146::-;8201:6;8196:3;8191;8178:30;8242:1;8233:6;8228:3;8224:16;8217:27;8104:146;;;:::o;8256:423::-;8333:5;8358:65;8374:48;8415:6;8374:48;:::i;:::-;8358:65;:::i;:::-;8349:74;;8446:6;8439:5;8432:21;8484:4;8477:5;8473:16;8522:3;8513:6;8508:3;8504:16;8501:25;8498:112;;;8529:79;;:::i;:::-;8498:112;8619:54;8666:6;8661:3;8656;8619:54;:::i;:::-;8339:340;8256:423;;;;;:::o;8698:338::-;8753:5;8802:3;8795:4;8787:6;8783:17;8779:27;8769:122;;8810:79;;:::i;:::-;8769:122;8927:6;8914:20;8952:78;9026:3;9018:6;9011:4;9003:6;8999:17;8952:78;:::i;:::-;8943:87;;8759:277;8698:338;;;;:::o;9042:943::-;9137:6;9145;9153;9161;9210:3;9198:9;9189:7;9185:23;9181:33;9178:120;;;9217:79;;:::i;:::-;9178:120;9337:1;9362:53;9407:7;9398:6;9387:9;9383:22;9362:53;:::i;:::-;9352:63;;9308:117;9464:2;9490:53;9535:7;9526:6;9515:9;9511:22;9490:53;:::i;:::-;9480:63;;9435:118;9592:2;9618:53;9663:7;9654:6;9643:9;9639:22;9618:53;:::i;:::-;9608:63;;9563:118;9748:2;9737:9;9733:18;9720:32;9779:18;9771:6;9768:30;9765:117;;;9801:79;;:::i;:::-;9765:117;9906:62;9960:7;9951:6;9940:9;9936:22;9906:62;:::i;:::-;9896:72;;9691:287;9042:943;;;;;;;:::o;9991:308::-;10053:4;10143:18;10135:6;10132:30;10129:56;;;10165:18;;:::i;:::-;10129:56;10203:29;10225:6;10203:29;:::i;:::-;10195:37;;10287:4;10281;10277:15;10269:23;;9991:308;;;:::o;10305:425::-;10383:5;10408:66;10424:49;10466:6;10424:49;:::i;:::-;10408:66;:::i;:::-;10399:75;;10497:6;10490:5;10483:21;10535:4;10528:5;10524:16;10573:3;10564:6;10559:3;10555:16;10552:25;10549:112;;;10580:79;;:::i;:::-;10549:112;10670:54;10717:6;10712:3;10707;10670:54;:::i;:::-;10389:341;10305:425;;;;;:::o;10750:340::-;10806:5;10855:3;10848:4;10840:6;10836:17;10832:27;10822:122;;10863:79;;:::i;:::-;10822:122;10980:6;10967:20;11005:79;11080:3;11072:6;11065:4;11057:6;11053:17;11005:79;:::i;:::-;10996:88;;10812:278;10750:340;;;;:::o;11096:654::-;11174:6;11182;11231:2;11219:9;11210:7;11206:23;11202:32;11199:119;;;11237:79;;:::i;:::-;11199:119;11357:1;11382:53;11427:7;11418:6;11407:9;11403:22;11382:53;:::i;:::-;11372:63;;11328:117;11512:2;11501:9;11497:18;11484:32;11543:18;11535:6;11532:30;11529:117;;;11565:79;;:::i;:::-;11529:117;11670:63;11725:7;11716:6;11705:9;11701:22;11670:63;:::i;:::-;11660:73;;11455:288;11096:654;;;;;:::o;11756:474::-;11824:6;11832;11881:2;11869:9;11860:7;11856:23;11852:32;11849:119;;;11887:79;;:::i;:::-;11849:119;12007:1;12032:53;12077:7;12068:6;12057:9;12053:22;12032:53;:::i;:::-;12022:63;;11978:117;12134:2;12160:53;12205:7;12196:6;12185:9;12181:22;12160:53;:::i;:::-;12150:63;;12105:118;11756:474;;;;;:::o;12236:180::-;12284:77;12281:1;12274:88;12381:4;12378:1;12371:15;12405:4;12402:1;12395:15;12422:320;12466:6;12503:1;12497:4;12493:12;12483:22;;12550:1;12544:4;12540:12;12571:18;12561:81;;12627:4;12619:6;12615:17;12605:27;;12561:81;12689:2;12681:6;12678:14;12658:18;12655:38;12652:84;;12708:18;;:::i;:::-;12652:84;12473:269;12422:320;;;:::o;12748:442::-;12897:4;12935:2;12924:9;12920:18;12912:26;;12948:71;13016:1;13005:9;13001:17;12992:6;12948:71;:::i;:::-;13029:72;13097:2;13086:9;13082:18;13073:6;13029:72;:::i;:::-;13111;13179:2;13168:9;13164:18;13155:6;13111:72;:::i;:::-;12748:442;;;;;;:::o;13196:168::-;13336:20;13332:1;13324:6;13320:14;13313:44;13196:168;:::o;13370:366::-;13512:3;13533:67;13597:2;13592:3;13533:67;:::i;:::-;13526:74;;13609:93;13698:3;13609:93;:::i;:::-;13727:2;13722:3;13718:12;13711:19;;13370:366;;;:::o;13742:419::-;13908:4;13946:2;13935:9;13931:18;13923:26;;13995:9;13989:4;13985:20;13981:1;13970:9;13966:17;13959:47;14023:131;14149:4;14023:131;:::i;:::-;14015:139;;13742:419;;;:::o;14167:147::-;14268:11;14305:3;14290:18;;14167:147;;;;:::o;14320:114::-;;:::o;14440:398::-;14599:3;14620:83;14701:1;14696:3;14620:83;:::i;:::-;14613:90;;14712:93;14801:3;14712:93;:::i;:::-;14830:1;14825:3;14821:11;14814:18;;14440:398;;;:::o;14844:379::-;15028:3;15050:147;15193:3;15050:147;:::i;:::-;15043:154;;15214:3;15207:10;;14844:379;;;:::o;15229:171::-;15369:23;15365:1;15357:6;15353:14;15346:47;15229:171;:::o;15406:366::-;15548:3;15569:67;15633:2;15628:3;15569:67;:::i;:::-;15562:74;;15645:93;15734:3;15645:93;:::i;:::-;15763:2;15758:3;15754:12;15747:19;;15406:366;;;:::o;15778:419::-;15944:4;15982:2;15971:9;15967:18;15959:26;;16031:9;16025:4;16021:20;16017:1;16006:9;16002:17;15995:47;16059:131;16185:4;16059:131;:::i;:::-;16051:139;;15778:419;;;:::o;16203:148::-;16305:11;16342:3;16327:18;;16203:148;;;;:::o;16357:390::-;16463:3;16491:39;16524:5;16491:39;:::i;:::-;16546:89;16628:6;16623:3;16546:89;:::i;:::-;16539:96;;16644:65;16702:6;16697:3;16690:4;16683:5;16679:16;16644:65;:::i;:::-;16734:6;16729:3;16725:16;16718:23;;16467:280;16357:390;;;;:::o;16753:435::-;16933:3;16955:95;17046:3;17037:6;16955:95;:::i;:::-;16948:102;;17067:95;17158:3;17149:6;17067:95;:::i;:::-;17060:102;;17179:3;17172:10;;16753:435;;;;;:::o;17194:175::-;17334:27;17330:1;17322:6;17318:14;17311:51;17194:175;:::o;17375:366::-;17517:3;17538:67;17602:2;17597:3;17538:67;:::i;:::-;17531:74;;17614:93;17703:3;17614:93;:::i;:::-;17732:2;17727:3;17723:12;17716:19;;17375:366;;;:::o;17747:419::-;17913:4;17951:2;17940:9;17936:18;17928:26;;18000:9;17994:4;17990:20;17986:1;17975:9;17971:17;17964:47;18028:131;18154:4;18028:131;:::i;:::-;18020:139;;17747:419;;;:::o;18172:169::-;18312:21;18308:1;18300:6;18296:14;18289:45;18172:169;:::o;18347:366::-;18489:3;18510:67;18574:2;18569:3;18510:67;:::i;:::-;18503:74;;18586:93;18675:3;18586:93;:::i;:::-;18704:2;18699:3;18695:12;18688:19;;18347:366;;;:::o;18719:419::-;18885:4;18923:2;18912:9;18908:18;18900:26;;18972:9;18966:4;18962:20;18958:1;18947:9;18943:17;18936:47;19000:131;19126:4;19000:131;:::i;:::-;18992:139;;18719:419;;;:::o;19144:175::-;19284:27;19280:1;19272:6;19268:14;19261:51;19144:175;:::o;19325:366::-;19467:3;19488:67;19552:2;19547:3;19488:67;:::i;:::-;19481:74;;19564:93;19653:3;19564:93;:::i;:::-;19682:2;19677:3;19673:12;19666:19;;19325:366;;;:::o;19697:419::-;19863:4;19901:2;19890:9;19886:18;19878:26;;19950:9;19944:4;19940:20;19936:1;19925:9;19921:17;19914:47;19978:131;20104:4;19978:131;:::i;:::-;19970:139;;19697:419;;;:::o;20122:180::-;20170:77;20167:1;20160:88;20267:4;20264:1;20257:15;20291:4;20288:1;20281:15;20308:191;20348:3;20367:20;20385:1;20367:20;:::i;:::-;20362:25;;20401:20;20419:1;20401:20;:::i;:::-;20396:25;;20444:1;20441;20437:9;20430:16;;20465:3;20462:1;20459:10;20456:36;;;20472:18;;:::i;:::-;20456:36;20308:191;;;;:::o;20505:178::-;20645:30;20641:1;20633:6;20629:14;20622:54;20505:178;:::o;20689:366::-;20831:3;20852:67;20916:2;20911:3;20852:67;:::i;:::-;20845:74;;20928:93;21017:3;20928:93;:::i;:::-;21046:2;21041:3;21037:12;21030:19;;20689:366;;;:::o;21061:419::-;21227:4;21265:2;21254:9;21250:18;21242:26;;21314:9;21308:4;21304:20;21300:1;21289:9;21285:17;21278:47;21342:131;21468:4;21342:131;:::i;:::-;21334:139;;21061:419;;;:::o;21486:332::-;21607:4;21645:2;21634:9;21630:18;21622:26;;21658:71;21726:1;21715:9;21711:17;21702:6;21658:71;:::i;:::-;21739:72;21807:2;21796:9;21792:18;21783:6;21739:72;:::i;:::-;21486:332;;;;;:::o;21824:98::-;21875:6;21909:5;21903:12;21893:22;;21824:98;;;:::o;21928:168::-;22011:11;22045:6;22040:3;22033:19;22085:4;22080:3;22076:14;22061:29;;21928:168;;;;:::o;22102:373::-;22188:3;22216:38;22248:5;22216:38;:::i;:::-;22270:70;22333:6;22328:3;22270:70;:::i;:::-;22263:77;;22349:65;22407:6;22402:3;22395:4;22388:5;22384:16;22349:65;:::i;:::-;22439:29;22461:6;22439:29;:::i;:::-;22434:3;22430:39;22423:46;;22192:283;22102:373;;;;:::o;22481:640::-;22676:4;22714:3;22703:9;22699:19;22691:27;;22728:71;22796:1;22785:9;22781:17;22772:6;22728:71;:::i;:::-;22809:72;22877:2;22866:9;22862:18;22853:6;22809:72;:::i;:::-;22891;22959:2;22948:9;22944:18;22935:6;22891:72;:::i;:::-;23010:9;23004:4;23000:20;22995:2;22984:9;22980:18;22973:48;23038:76;23109:4;23100:6;23038:76;:::i;:::-;23030:84;;22481:640;;;;;;;:::o;23127:141::-;23183:5;23214:6;23208:13;23199:22;;23230:32;23256:5;23230:32;:::i;:::-;23127:141;;;;:::o;23274:349::-;23343:6;23392:2;23380:9;23371:7;23367:23;23363:32;23360:119;;;23398:79;;:::i;:::-;23360:119;23518:1;23543:63;23598:7;23589:6;23578:9;23574:22;23543:63;:::i;:::-;23533:73;;23489:127;23274:349;;;;:::o;23629:141::-;23678:4;23701:3;23693:11;;23724:3;23721:1;23714:14;23758:4;23755:1;23745:18;23737:26;;23629:141;;;:::o;23776:93::-;23813:6;23860:2;23855;23848:5;23844:14;23840:23;23830:33;;23776:93;;;:::o;23875:107::-;23919:8;23969:5;23963:4;23959:16;23938:37;;23875:107;;;;:::o;23988:393::-;24057:6;24107:1;24095:10;24091:18;24130:97;24160:66;24149:9;24130:97;:::i;:::-;24248:39;24278:8;24267:9;24248:39;:::i;:::-;24236:51;;24320:4;24316:9;24309:5;24305:21;24296:30;;24369:4;24359:8;24355:19;24348:5;24345:30;24335:40;;24064:317;;23988:393;;;;;:::o;24387:60::-;24415:3;24436:5;24429:12;;24387:60;;;:::o;24453:142::-;24503:9;24536:53;24554:34;24563:24;24581:5;24563:24;:::i;:::-;24554:34;:::i;:::-;24536:53;:::i;:::-;24523:66;;24453:142;;;:::o;24601:75::-;24644:3;24665:5;24658:12;;24601:75;;;:::o;24682:269::-;24792:39;24823:7;24792:39;:::i;:::-;24853:91;24902:41;24926:16;24902:41;:::i;:::-;24894:6;24887:4;24881:11;24853:91;:::i;:::-;24847:4;24840:105;24758:193;24682:269;;;:::o;24957:73::-;25002:3;24957:73;:::o;25036:189::-;25113:32;;:::i;:::-;25154:65;25212:6;25204;25198:4;25154:65;:::i;:::-;25089:136;25036:189;;:::o;25231:186::-;25291:120;25308:3;25301:5;25298:14;25291:120;;;25362:39;25399:1;25392:5;25362:39;:::i;:::-;25335:1;25328:5;25324:13;25315:22;;25291:120;;;25231:186;;:::o;25423:543::-;25524:2;25519:3;25516:11;25513:446;;;25558:38;25590:5;25558:38;:::i;:::-;25642:29;25660:10;25642:29;:::i;:::-;25632:8;25628:44;25825:2;25813:10;25810:18;25807:49;;;25846:8;25831:23;;25807:49;25869:80;25925:22;25943:3;25925:22;:::i;:::-;25915:8;25911:37;25898:11;25869:80;:::i;:::-;25528:431;;25513:446;25423:543;;;:::o;25972:117::-;26026:8;26076:5;26070:4;26066:16;26045:37;;25972:117;;;;:::o;26095:169::-;26139:6;26172:51;26220:1;26216:6;26208:5;26205:1;26201:13;26172:51;:::i;:::-;26168:56;26253:4;26247;26243:15;26233:25;;26146:118;26095:169;;;;:::o;26269:295::-;26345:4;26491:29;26516:3;26510:4;26491:29;:::i;:::-;26483:37;;26553:3;26550:1;26546:11;26540:4;26537:21;26529:29;;26269:295;;;;:::o;26569:1395::-;26686:37;26719:3;26686:37;:::i;:::-;26788:18;26780:6;26777:30;26774:56;;;26810:18;;:::i;:::-;26774:56;26854:38;26886:4;26880:11;26854:38;:::i;:::-;26939:67;26999:6;26991;26985:4;26939:67;:::i;:::-;27033:1;27057:4;27044:17;;27089:2;27081:6;27078:14;27106:1;27101:618;;;;27763:1;27780:6;27777:77;;;27829:9;27824:3;27820:19;27814:26;27805:35;;27777:77;27880:67;27940:6;27933:5;27880:67;:::i;:::-;27874:4;27867:81;27736:222;27071:887;;27101:618;27153:4;27149:9;27141:6;27137:22;27187:37;27219:4;27187:37;:::i;:::-;27246:1;27260:208;27274:7;27271:1;27268:14;27260:208;;;27353:9;27348:3;27344:19;27338:26;27330:6;27323:42;27404:1;27396:6;27392:14;27382:24;;27451:2;27440:9;27436:18;27423:31;;27297:4;27294:1;27290:12;27285:17;;27260:208;;;27496:6;27487:7;27484:19;27481:179;;;27554:9;27549:3;27545:19;27539:26;27597:48;27639:4;27631:6;27627:17;27616:9;27597:48;:::i;:::-;27589:6;27582:64;27504:156;27481:179;27706:1;27702;27694:6;27690:14;27686:22;27680:4;27673:36;27108:611;;;27071:887;;26661:1303;;;26569:1395;;:::o;27970:332::-;28091:4;28129:2;28118:9;28114:18;28106:26;;28142:71;28210:1;28199:9;28195:17;28186:6;28142:71;:::i;:::-;28223:72;28291:2;28280:9;28276:18;28267:6;28223:72;:::i;:::-;27970:332;;;;;:::o;28308:180::-;28356:77;28353:1;28346:88;28453:4;28450:1;28443:15;28477:4;28474:1;28467:15

ipfs://71ab9b813e42ea84f87ecc980809a7a5d7ffe8431e1f18436b238985e69f1d8d