Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-06-08
*/

// SPDX-License-Identifier: MIT
// ERC721A Contracts v3.3.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721A is IERC721, IERC721Metadata {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

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

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

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);
}

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract()) if(!_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

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

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

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

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

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

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

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

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

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

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

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

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

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

        do {
            emit Transfer(address(0), to, updatedIndex++);
        } while (updatedIndex < end);

        _currentIndex = updatedIndex;
    }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

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

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = prevOwnership.addr;

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

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

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

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

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

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

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

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

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

abstract contract ContextMixin {
    function msgSender()
    internal
    view
    returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
            // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                mload(add(array, index)),
                0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    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 division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }
    }

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

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

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

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

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

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
    internal
    initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
    internal
    view
    returns (bytes32)
    {
        return
        keccak256(
            abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
        );
    }
}

contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
        nonce: nonces[userAddress],
        from: userAddress,
        functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
    internal
    pure
    returns (bytes32)
    {
        return
        keccak256(
            abi.encode(
                META_TRANSACTION_TYPEHASH,
                metaTx.nonce,
                metaTx.from,
                keccak256(metaTx.functionSignature)
            )
        );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
        signer ==
        ecrecover(
            toTypedMessageHash(hashMetaTransaction(metaTx)),
            sigV,
            sigR,
            sigS
        );
    }
}

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

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

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

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

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

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

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

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

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

    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 make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

contract OwnableDelegateProxy {}

/**
 * Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
 */
contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

contract ToxicBirdsOfficial is
    ERC721A,
    ContextMixin,
    NativeMetaTransaction,
    Ownable,
    ReentrancyGuard
{
    using Strings for uint256;

    address proxyRegistryAddress;
    address hapeTeensAddress;

    mapping(address => uint256) freeMintAvailable;

    string public constant collectionName = "TOXIC BIRDS OFFICIAL";
    string public constant collectionSymbol = "TBO";
    uint256 public constant maxQuantityPerMint = 10;
    uint256 public mintPrice = 0.03 ether;
    uint256 public maxTotalSupply = 3333;

    bool public mintActive = true;

    string public baseTokenURI = "ipfs://QmeDJWxzbbuRZLx9zynkxWhroHmrWpFszyerPvx3hevq4U/";
    string public _contractURI;
    string public baseExtension = ".json";

    constructor(
        address _proxyRegistryAddress,
        string memory contractURI_,
        address _hapeTeensAddress
    ) ERC721A(collectionName, collectionSymbol) {
        _contractURI = contractURI_;
        hapeTeensAddress = _hapeTeensAddress;
        proxyRegistryAddress = _proxyRegistryAddress;
        _initializeEIP712(collectionName);
    }

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

    function gift(address to, uint256 quantity) external onlyOwner nonReentrant {
        require(totalSupply() + quantity <= maxTotalSupply, "Total supply would be exceeded");
        _safeMint(to, quantity);
    }

    function freeMint(uint256 quantity) external callerIsUser {
        require(mintActive, "Mint is currently paused");
        require(quantity <= maxQuantityPerMint, "Mint quantity limit 10");
        require(quantity <= freeMintAvailable[_msgSender()], "You don't have so many Hape Teens");
        require(totalSupply() + quantity <= maxTotalSupply, "Total supply would be exceeded");

        freeMintAvailable[_msgSender()] -= quantity;
        _safeMint(_msgSender(), quantity);
    }

    function mint(uint256 quantity) external payable callerIsUser {
        require(mintActive, "Mint is currently paused");
        require(quantity <= maxQuantityPerMint, "Mint quantity limit 10");
        require(msg.value >= quantity * mintPrice, "Not enough payed");
        require(totalSupply() + quantity <= maxTotalSupply, "Total supply would be exceeded");

        _safeMint(_msgSender(), quantity);
        refundIfOver(mintPrice * quantity);
    }

    function refundIfOver(uint256 price) private {
        require(msg.value >= price, "Need to send more ETH.");
        if (msg.value > price) {
            payable(msg.sender).transfer(msg.value - price);
        }
    }

    function setMintActive(bool value) public onlyOwner {
        mintActive = value;
    }

    function setBaseURI(string calldata baseURI) public onlyOwner {
        baseTokenURI = baseURI;
    }

    function setContractURI(string calldata contractURI_) public onlyOwner {
        _contractURI = contractURI_;
    }

    function setBaseExtension(string calldata extension) public onlyOwner {
        baseExtension = extension;
    }

    function changeMintPrice(uint256 newPrice) public onlyOwner {
        mintPrice = newPrice;
    }

    function changeTotalSupply(uint256 newSupply) public onlyOwner {
        maxTotalSupply = newSupply;
    }

    function initializeFreeMint(uint256 start, uint256 end) public onlyOwner {
        uint256 hapeTeensTotalSupply = IERC721A(hapeTeensAddress).totalSupply();
        require(end <= hapeTeensTotalSupply);
        for (uint256 tokenId = start; tokenId < end; tokenId++) {
            address owner = IERC721A(hapeTeensAddress).ownerOf(tokenId);
            freeMintAvailable[owner] += 1;
        }
    }

    function getFreeMintAvailable(address owner) public view returns (uint256) {
        return freeMintAvailable[owner];
    }

    function getMintPrice() public view returns (uint256) {
        return mintPrice;
    }

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

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

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

    function contractURI() public view returns (string memory) {
        return _contractURI;
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
     */
    function isApprovedForAll(address owner, address operator)
    override
    public
    view
    returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(owner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
    internal
    override
    view
    returns (address sender)
    {
        return ContextMixin.msgSender();
    }

    function withdraw() public onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_proxyRegistryAddress","type":"address"},{"internalType":"string","name":"contractURI_","type":"string"},{"internalType":"address","name":"_hapeTeensAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"changeMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSupply","type":"uint256"}],"name":"changeTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"collectionName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"collectionSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"freeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getFreeMintAvailable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"gift","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"}],"name":"initializeFreeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxQuantityPerMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintActive","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"extension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"contractURI_","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c100000000000000000000000000000000000000000000000000000000000000600000000000000000000000007c89587bfbb13ef941b8d2667abfa84c00dea3580000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d5151707937776e474746616731416657456b6e42465944536b6d47394d4e5352667a564d53454368597658430000000000000000000000

-----Decoded View---------------
Arg [0] : _proxyRegistryAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1
Arg [1] : contractURI_ (string): ipfs://QmQQpy7wnGGFag1AfWEknBFYDSkmG9MNSRfzVMSEChYvXC
Arg [2] : _hapeTeensAddress (address): 0x7C89587BfBb13EF941b8D2667ABfa84c00DeA358

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [2] : 0000000000000000000000007c89587bfbb13ef941b8d2667abfa84c00dea358
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [4] : 697066733a2f2f516d5151707937776e474746616731416657456b6e42465944
Arg [5] : 536b6d47394d4e5352667a564d53454368597658430000000000000000000000

60292:5688:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24523:293;;;;;;;;;;-1:-1:-1;24523:293:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;24523:293:0;;;;;;;;27542:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;29091:204::-;;;;;;;;;;-1:-1:-1;29091:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;29091:204:0;1528:203:1;28608:417:0;;;;;;;;;;-1:-1:-1;28608:417:0;;;;;:::i;:::-;;:::i;:::-;;52937:1139;;;;;;:::i;:::-;;:::i;50234:43::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;50234:43:0;;;;;23787:300;;;;;;;;;;-1:-1:-1;24042:12:0;;23840:7;24026:13;:28;23787:300;;;4179:25:1;;;4167:2;4152:18;23787:300:0;4033:177:1;51235:101:0;;;;;;;;;;-1:-1:-1;51313:15:0;;51235:101;;29956:170;;;;;;;;;;-1:-1:-1;29956:170:0;;;;;:::i;:::-;;:::i;60849:29::-;;;;;;;;;;-1:-1:-1;60849:29:0;;;;;;;;60804:36;;;;;;;;;;;;;;;;54458:107;;;;;;;;;;-1:-1:-1;54458:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;54545:12:0;54511:13;54545:12;;;:6;:12;;;;;;;54458:107;60652:47;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;60652:47:0;;;;;51344:161;;;;;;;;;;-1:-1:-1;51458:9:0;51344:161;;65793:184;;;;;;;;;;;;;:::i;63446:99::-;;;;;;;;;;-1:-1:-1;63446:99:0;;;;;:::i;:::-;;:::i;30197:185::-;;;;;;;;;;-1:-1:-1;30197:185:0;;;;;:::i;:::-;;:::i;63553:108::-;;;;;;;;;;-1:-1:-1;63553:108:0;;;;;:::i;:::-;;:::i;63088:103::-;;;;;;;;;;-1:-1:-1;63088:103:0;;;;;:::i;:::-;;:::i;63669:406::-;;;;;;;;;;-1:-1:-1;63669:406:0;;;;;:::i;:::-;;:::i;27350:125::-;;;;;;;;;;-1:-1:-1;27350:125:0;;;;;:::i;:::-;;:::i;60760:37::-;;;;;;;;;;;;;;;;60706:47;;;;;;;;;;;;60751:2;60706:47;;24880:206;;;;;;;;;;-1:-1:-1;24880:206:0;;;;;:::i;:::-;;:::i;56608:103::-;;;;;;;;;;;;;:::i;61783:496::-;;;;;;;;;;-1:-1:-1;61783:496:0;;;;;:::i;:::-;;:::i;55957:87::-;;;;;;;;;;-1:-1:-1;56030:6:0;;-1:-1:-1;;;;;56030:6:0;55957:87;;63199:117;;;;;;;;;;-1:-1:-1;63199:117:0;;;;;:::i;:::-;;:::i;27711:104::-;;;;;;;;;;;;;:::i;62287:464::-;;;;;;:::i;:::-;;:::i;29367:287::-;;;;;;;;;;-1:-1:-1;29367:287:0;;;;;:::i;:::-;;:::i;64216:89::-;;;;;;;;;;-1:-1:-1;64288:9:0;;64216:89;;64083:125;;;;;;;;;;-1:-1:-1;64083:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;64176:24:0;64149:7;64176:24;;;:17;:24;;;;;;;64083:125;30453:370;;;;;;;;;;-1:-1:-1;30453:370:0;;;;;:::i;:::-;;:::i;60979:26::-;;;;;;;;;;;;;:::i;61012:37::-;;;;;;;;;;;;;:::i;64497:333::-;;;;;;;;;;-1:-1:-1;64497:333:0;;;;;:::i;:::-;;:::i;61561:214::-;;;;;;;;;;-1:-1:-1;61561:214:0;;;;;:::i;:::-;;:::i;60887:85::-;;;;;;;;;;;;;:::i;63324:114::-;;;;;;;;;;-1:-1:-1;63324:114:0;;;;;:::i;:::-;;:::i;60583:62::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;60583:62:0;;;;;64838:97;;;;;;;;;;;;;:::i;65067:429::-;;;;;;;;;;-1:-1:-1;65067:429:0;;;;;:::i;:::-;;:::i;62991:89::-;;;;;;;;;;-1:-1:-1;62991:89:0;;;;;:::i;:::-;;:::i;56866:201::-;;;;;;;;;;-1:-1:-1;56866:201:0;;;;;:::i;:::-;;:::i;24523:293::-;24625:4;-1:-1:-1;;;;;;24658:40:0;;-1:-1:-1;;;24658:40:0;;:101;;-1:-1:-1;;;;;;;24711:48:0;;-1:-1:-1;;;24711:48:0;24658:101;:150;;;-1:-1:-1;;;;;;;;;;21781:40:0;;;24772:36;24642:166;24523:293;-1:-1:-1;;24523:293:0:o;27542:100::-;27596:13;27629:5;27622:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27542:100;:::o;29091:204::-;29159:7;29184:16;29192:7;29184;:16::i;:::-;29179:64;;29209:34;;-1:-1:-1;;;29209:34:0;;;;;;;;;;;29179:64;-1:-1:-1;29263:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;29263:24:0;;29091:204::o;28608:417::-;28681:13;28697:24;28713:7;28697:15;:24::i;:::-;28681:40;;28742:5;-1:-1:-1;;;;;28736:11:0;:2;-1:-1:-1;;;;;28736:11:0;;28732:48;;28756:24;;-1:-1:-1;;;28756:24:0;;;;;;;;;;;28732:48;28813:5;-1:-1:-1;;;;;28797:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;28797:21:0;;28793:139;;28824:37;28841:5;28848:12;:10;:12::i;28824:37::-;28820:112;;28885:35;;-1:-1:-1;;;28885:35:0;;;;;;;;;;;28820:112;28944:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;28944:29:0;-1:-1:-1;;;;;28944:29:0;;;;;;;;;28989:28;;28944:24;;28989:28;;;;;;;28670:355;28608:417;;:::o;52937:1139::-;53195:140;;;53138:12;53195:140;;;;;-1:-1:-1;;;;;53229:19:0;;53163:29;53229:19;;;:6;:19;;;;;;;;;53195:140;;;;;;;;;;;53370:45;53236:11;53195:140;53398:4;53404;53410;53370:6;:45::i;:::-;53348:128;;;;-1:-1:-1;;;53348:128:0;;8280:2:1;53348:128:0;;;8262:21:1;8319:2;8299:18;;;8292:30;8358:34;8338:18;;;8331:62;-1:-1:-1;;;8409:18:1;;;8402:31;8450:19;;53348:128:0;;;;;;;;;-1:-1:-1;;;;;53565:19:0;;;;;;:6;:19;;;;;;:26;;53589:1;53565:23;:26::i;:::-;-1:-1:-1;;;;;53543:19:0;;;;;;:6;:19;;;;;;;:48;;;;53609:126;;;;;53550:11;;53681:10;;53707:17;;53609:126;:::i;:::-;;;;;;;;53846:12;53860:23;53895:4;-1:-1:-1;;;;;53887:18:0;53937:17;53956:11;53920:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;53920:48:0;;;;;;;;;;53887:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53845:134;;;;53998:7;53990:48;;;;-1:-1:-1;;;53990:48:0;;9818:2:1;53990:48:0;;;9800:21:1;9857:2;9837:18;;;9830:30;9896;9876:18;;;9869:58;9944:18;;53990:48:0;9616:352:1;53990:48:0;54058:10;52937:1139;-1:-1:-1;;;;;;;;52937:1139:0:o;29956:170::-;30090:28;30100:4;30106:2;30110:7;30090:9;:28::i;:::-;29956:170;;;:::o;65793:184::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;59076:1:::1;59672:7;;:19:::0;59664:63:::1;;;::::0;-1:-1:-1;;;59664:63:0;;10536:2:1;59664:63:0::1;::::0;::::1;10518:21:1::0;10575:2;10555:18;;;10548:30;10614:33;10594:18;;;10587:61;10665:18;;59664:63:0::1;10334:355:1::0;59664:63:0::1;59076:1;59805:7;:18:::0;65873:49:::2;::::0;65855:12:::2;::::0;65873:10:::2;::::0;65896:21:::2;::::0;65855:12;65873:49;65855:12;65873:49;65896:21;65873:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65854:68;;;65941:7;65933:36;;;::::0;-1:-1:-1;;;65933:36:0;;11106:2:1;65933:36:0::2;::::0;::::2;11088:21:1::0;11145:2;11125:18;;;11118:30;-1:-1:-1;;;11164:18:1;;;11157:46;11220:18;;65933:36:0::2;10904:340:1::0;65933:36:0::2;-1:-1:-1::0;59032:1:0::1;59984:7;:22:::0;65793:184::o;63446:99::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63517:9:::1;:20:::0;63446:99::o;30197:185::-;30335:39;30352:4;30358:2;30362:7;30335:39;;;;;;;;;;;;:16;:39::i;63553:108::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63627:14:::1;:26:::0;63553:108::o;63088:103::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63161:22:::1;:12;63176:7:::0;;63161:22:::1;:::i;63669:406::-:0;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63793:16:::1;::::0;63784:40:::1;::::0;;-1:-1:-1;;;63784:40:0;;;;63753:28:::1;::::0;-1:-1:-1;;;;;63793:16:0::1;::::0;63784:38:::1;::::0;:40:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;63793:16;63784:40:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63753:71;;63850:20;63843:3;:27;;63835:36;;;::::0;::::1;;63905:5:::0;63882:186:::1;63922:3;63912:7;:13;63882:186;;;63978:16;::::0;63969:43:::1;::::0;-1:-1:-1;;;63969:43:0;;::::1;::::0;::::1;4179:25:1::0;;;63953:13:0::1;::::0;-1:-1:-1;;;;;63978:16:0::1;::::0;63969:34:::1;::::0;4152:18:1;;63969:43:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;64027:24:0;::::1;;::::0;;;:17:::1;:24;::::0;;;;:29;;63953:59;;-1:-1:-1;64055:1:0::1;::::0;64027:24;;;:29:::1;::::0;64055:1;;64027:29:::1;:::i;:::-;::::0;;;-1:-1:-1;63927:9:0;;-1:-1:-1;63927:9:0::1;::::0;-1:-1:-1;63927:9:0;::::1;:::i;:::-;;;;63882:186;;;;63742:333;63669:406:::0;;:::o;27350:125::-;27414:7;27441:21;27454:7;27441:12;:21::i;:::-;:26;;27350:125;-1:-1:-1;;27350:125:0:o;24880:206::-;24944:7;-1:-1:-1;;;;;24968:19:0;;24964:60;;24996:28;;-1:-1:-1;;;24996:28:0;;;;;;;;;;;24964:60;-1:-1:-1;;;;;;25050:19:0;;;;;:12;:19;;;;;:27;;;;24880:206::o;56608:103::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;56673:30:::1;56700:1;56673:18;:30::i;:::-;56608:103::o:0;61783:496::-;61475:9;61488:10;61475:23;61467:66;;;;-1:-1:-1;;;61467:66:0;;12301:2:1;61467:66:0;;;12283:21:1;12340:2;12320:18;;;12313:30;12379:32;12359:18;;;12352:60;12429:18;;61467:66:0;12099:354:1;61467:66:0;61860:10:::1;::::0;::::1;;61852:47;;;::::0;-1:-1:-1;;;61852:47:0;;12660:2:1;61852:47:0::1;::::0;::::1;12642:21:1::0;12699:2;12679:18;;;12672:30;-1:-1:-1;;;12718:18:1;;;12711:54;12782:18;;61852:47:0::1;12458:348:1::0;61852:47:0::1;60751:2;61918:8;:30;;61910:65;;;::::0;-1:-1:-1;;;61910:65:0;;13013:2:1;61910:65:0::1;::::0;::::1;12995:21:1::0;13052:2;13032:18;;;13025:30;-1:-1:-1;;;13071:18:1;;;13064:52;13133:18;;61910:65:0::1;12811:346:1::0;61910:65:0::1;62006:17;:31;62024:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;62006:31:0::1;-1:-1:-1::0;;;;;62006:31:0::1;;;;;;;;;;;;;61994:8;:43;;61986:89;;;::::0;-1:-1:-1;;;61986:89:0;;13364:2:1;61986:89:0::1;::::0;::::1;13346:21:1::0;13403:2;13383:18;;;13376:30;13442:34;13422:18;;;13415:62;-1:-1:-1;;;13493:18:1;;;13486:31;13534:19;;61986:89:0::1;13162:397:1::0;61986:89:0::1;62122:14;;62110:8;62094:13;24042:12:::0;;23840:7;24026:13;:28;;23787:300;62094:13:::1;:24;;;;:::i;:::-;:42;;62086:85;;;;-1:-1:-1::0;;;62086:85:0::1;;;;;;;:::i;:::-;62219:8;62184:17;:31;62202:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;62184:31:0::1;-1:-1:-1::0;;;;;62184:31:0::1;;;;;;;;;;;;;:43;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;62238:33:0::1;::::0;-1:-1:-1;62248:12:0::1;:10;:12::i;:::-;62262:8;62238:9;:33::i;:::-;61783:496:::0;:::o;63199:117::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63281:27:::1;:12;63296::::0;;63281:27:::1;:::i;27711:104::-:0;27767:13;27800:7;27793:14;;;;;:::i;62287:464::-;61475:9;61488:10;61475:23;61467:66;;;;-1:-1:-1;;;61467:66:0;;12301:2:1;61467:66:0;;;12283:21:1;12340:2;12320:18;;;12313:30;12379:32;12359:18;;;12352:60;12429:18;;61467:66:0;12099:354:1;61467:66:0;62368:10:::1;::::0;::::1;;62360:47;;;::::0;-1:-1:-1;;;62360:47:0;;12660:2:1;62360:47:0::1;::::0;::::1;12642:21:1::0;12699:2;12679:18;;;12672:30;-1:-1:-1;;;12718:18:1;;;12711:54;12782:18;;62360:47:0::1;12458:348:1::0;62360:47:0::1;60751:2;62426:8;:30;;62418:65;;;::::0;-1:-1:-1;;;62418:65:0;;13013:2:1;62418:65:0::1;::::0;::::1;12995:21:1::0;13052:2;13032:18;;;13025:30;-1:-1:-1;;;13071:18:1;;;13064:52;13133:18;;62418:65:0::1;12811:346:1::0;62418:65:0::1;62526:9;::::0;62515:20:::1;::::0;:8;:20:::1;:::i;:::-;62502:9;:33;;62494:62;;;::::0;-1:-1:-1;;;62494:62:0;;14428:2:1;62494:62:0::1;::::0;::::1;14410:21:1::0;14467:2;14447:18;;;14440:30;-1:-1:-1;;;14486:18:1;;;14479:46;14542:18;;62494:62:0::1;14226:340:1::0;62494:62:0::1;62603:14;;62591:8;62575:13;24042:12:::0;;23840:7;24026:13;:28;;23787:300;62575:13:::1;:24;;;;:::i;:::-;:42;;62567:85;;;;-1:-1:-1::0;;;62567:85:0::1;;;;;;;:::i;:::-;62665:33;62675:12;:10;:12::i;62665:33::-;62709:34;62734:8;62722:9;;:20;;;;:::i;:::-;62709:12;:34::i;29367:287::-:0;29478:12;:10;:12::i;:::-;-1:-1:-1;;;;;29466:24:0;:8;-1:-1:-1;;;;;29466:24:0;;29462:54;;29499:17;;-1:-1:-1;;;29499:17:0;;;;;;;;;;;29462:54;29574:8;29529:18;:32;29548:12;:10;:12::i;:::-;-1:-1:-1;;;;;29529:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;29529:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;29529:53:0;;;;;;;;;;;29613:12;:10;:12::i;:::-;-1:-1:-1;;;;;29598:48:0;;29637:8;29598:48;;;;565:14:1;558:22;540:41;;528:2;513:18;;400:187;29598:48:0;;;;;;;;29367:287;;:::o;30453:370::-;30620:28;30630:4;30636:2;30640:7;30620:9;:28::i;:::-;-1:-1:-1;;;;;30663:13:0;;11260:19;:23;30659:157;;30684:56;30715:4;30721:2;30725:7;30734:5;30684:30;:56::i;:::-;30680:136;;30764:40;;-1:-1:-1;;;30764:40:0;;;;;;;;;;;60979:26;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;61012:37::-;;;;;;;:::i;64497:333::-;64570:13;64601:16;64609:7;64601;:16::i;:::-;64596:59;;64626:29;;-1:-1:-1;;;64626:29:0;;;;;;;;;;;64596:59;64668:21;64692:10;:8;:10::i;:::-;64668:34;;64726:7;64720:21;64745:1;64720:26;:102;;;;;;;;;;;;;;;;;64773:7;64782:18;:7;:16;:18::i;:::-;64802:13;64756:60;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;64720:102;64713:109;64497:333;-1:-1:-1;;;64497:333:0:o;61561:214::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;59076:1:::1;59672:7;;:19:::0;59664:63:::1;;;::::0;-1:-1:-1;;;59664:63:0;;10536:2:1;59664:63:0::1;::::0;::::1;10518:21:1::0;10575:2;10555:18;;;10548:30;10614:33;10594:18;;;10587:61;10665:18;;59664:63:0::1;10334:355:1::0;59664:63:0::1;59076:1;59805:7;:18:::0;61684:14:::2;::::0;61672:8;61656:13:::2;24042:12:::0;;23840:7;24026:13;:28;;23787:300;61656:13:::2;:24;;;;:::i;:::-;:42;;61648:85;;;;-1:-1:-1::0;;;61648:85:0::2;;;;;;;:::i;:::-;61744:23;61754:2;61758:8;61744:9;:23::i;:::-;-1:-1:-1::0;;59032:1:0::1;59984:7;:22:::0;61561:214::o;60887:85::-;;;;;;;:::i;63324:114::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63405:25:::1;:13;63421:9:::0;;63405:25:::1;:::i;64838:97::-:0;64882:13;64915:12;64908:19;;;;;:::i;65067:429::-;65305:20;;65349:28;;-1:-1:-1;;;65349:28:0;;-1:-1:-1;;;;;1692:32:1;;;65349:28:0;;;1674:51:1;65176:4:0;;65305:20;;;65341:49;;;;65305:20;;65349:21;;1647:18:1;;65349:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;65341:49:0;;65337:93;;65414:4;65407:11;;;;;65337:93;-1:-1:-1;;;;;29846:25:0;;;29822:4;29846:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;65449:39;65442:46;65067:429;-1:-1:-1;;;;65067:429:0:o;62991:89::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;63054:10:::1;:18:::0;;-1:-1:-1;;63054:18:0::1;::::0;::::1;;::::0;;;::::1;::::0;;62991:89::o;56866:201::-;56188:12;:10;:12::i;:::-;-1:-1:-1;;;;;56177:23:0;:7;56030:6;;-1:-1:-1;;;;;56030:6:0;;55957:87;56177:7;-1:-1:-1;;;;;56177:23:0;;56169:68;;;;-1:-1:-1;;;56169:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56955:22:0;::::1;56947:73;;;::::0;-1:-1:-1;;;56947:73:0;;16716:2:1;56947:73:0::1;::::0;::::1;16698:21:1::0;16755:2;16735:18;;;16728:30;16794:34;16774:18;;;16767:62;-1:-1:-1;;;16845:18:1;;;16838:36;16891:19;;56947:73:0::1;16514:402:1::0;56947:73:0::1;57031:28;57050:8;57031:18;:28::i;42672:626::-:0;42731:22;42797:4;42775:10;:27;42771:496;;42819:18;42840:8;;42819:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;42879:8:0;43082:17;43076:24;-1:-1:-1;;;;;43054:126:0;;-1:-1:-1;42771:496:0;;-1:-1:-1;42771:496:0;;-1:-1:-1;43244:10:0;42771:496;42672:626;:::o;31078:174::-;31135:4;31199:13;;31189:7;:23;31159:85;;;;-1:-1:-1;;31217:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;31217:27:0;;;;31216:28;;31078:174::o;65640:145::-;65714:14;65753:24;:22;:24::i;:::-;65746:31;;65640:145;:::o;54573:458::-;54751:4;-1:-1:-1;;;;;54776:20:0;;54768:70;;;;-1:-1:-1;;;54768:70:0;;17123:2:1;54768:70:0;;;17105:21:1;17162:2;17142:18;;;17135:30;17201:34;17181:18;;;17174:62;-1:-1:-1;;;17252:18:1;;;17245:35;17297:19;;54768:70:0;16921:401:1;54768:70:0;54884:139;54908:47;54927:27;54947:6;54927:19;:27::i;:::-;54908:18;:47::i;:::-;54884:139;;;;;;;;;;;;17554:25:1;;;;17627:4;17615:17;;17595:18;;;17588:45;17649:18;;;17642:34;;;17692:18;;;17685:34;;;17526:19;;54884:139:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54865:158:0;:6;-1:-1:-1;;;;;54865:158:0;;54849:174;;54573:458;;;;;;;:::o;45754:98::-;45812:7;45839:5;45843:1;45839;:5;:::i;35108:2043::-;35223:35;35261:21;35274:7;35261:12;:21::i;:::-;35223:59;;35321:4;-1:-1:-1;;;;;35299:26:0;:13;:18;;;-1:-1:-1;;;;;35299:26:0;;35295:67;;35334:28;;-1:-1:-1;;;35334:28:0;;;;;;;;;;;35295:67;35375:22;35417:4;-1:-1:-1;;;;;35401:20:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;35401:20:0;;:69;;;;35434:36;35451:4;35457:12;:10;:12::i;35434:36::-;35401:118;;;;35507:12;:10;:12::i;:::-;-1:-1:-1;;;;;35483:36:0;:20;35495:7;35483:11;:20::i;:::-;-1:-1:-1;;;;;35483:36:0;;35401:118;35375:145;;35538:17;35533:66;;35564:35;;-1:-1:-1;;;35564:35:0;;;;;;;;;;;35533:66;-1:-1:-1;;;;;35614:16:0;;35610:52;;35639:23;;-1:-1:-1;;;35639:23:0;;;;;;;;;;;35610:52;35791:24;;;;:15;:24;;;;;;;;35784:31;;-1:-1:-1;;;;;;35784:31:0;;;-1:-1:-1;;;;;36103:18:0;;;;;:12;:18;;;;;:31;;-1:-1:-1;;36103:31:0;;;;;;;-1:-1:-1;;36103:31:0;;;;;;;36145:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;36145:29:0;;;;;;;;;;;36221:20;;;:11;:20;;;;;;36252:18;;-1:-1:-1;;;;;;36281:49:0;;;;-1:-1:-1;;;36314:15:0;36281:49;;;;;;;;;;36592:11;;36648:24;;;;;;;36687:13;;36221:20;;36592:11;;36648:24;;36687:13;36683:356;;36885:13;;36870:11;:28;36866:162;;36919:20;;36984:28;;;;36958:54;;-1:-1:-1;;;36958:54:0;-1:-1:-1;;;;;;36958:54:0;;;-1:-1:-1;;;;;36919:20:0;;36958:54;;;;36866:162;36082:964;;;37082:7;37078:2;-1:-1:-1;;;;;37063:27:0;37072:4;-1:-1:-1;;;;;37063:27:0;;;;;;;;;;;35212:1939;;35108:2043;;;:::o;26261:1027::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;26372:7:0;26449:13;;26442:4;:20;26438:787;;;26479:31;26513:17;;;:11;:17;;;;;;;;;26479:51;;;;;;;;;-1:-1:-1;;;;;26479:51:0;;;;-1:-1:-1;;;26479:51:0;;;;;;;;;;;-1:-1:-1;;;26479:51:0;;;;;;;;;;;;;;26545:669;;26591:14;;-1:-1:-1;;;;;26591:28:0;;26587:93;;26651:9;26261:1027;-1:-1:-1;;;26261:1027:0:o;26587:93::-;-1:-1:-1;;;26998:6:0;27039:17;;;;:11;:17;;;;;;;;;27027:29;;;;;;;;;-1:-1:-1;;;;;27027:29:0;;;;;-1:-1:-1;;;27027:29:0;;;;;;;;;;;-1:-1:-1;;;27027:29:0;;;;;;;;;;;;;27083:28;27079:101;;27147:9;26261:1027;-1:-1:-1;;;26261:1027:0:o;27079:101::-;26962:237;;;26464:761;26438:787;27249:31;;-1:-1:-1;;;27249:31:0;;;;;;;;;;;57227:191;57320:6;;;-1:-1:-1;;;;;57337:17:0;;;-1:-1:-1;;;;;;57337:17:0;;;;;;;57370:40;;57320:6;;;57337:17;57320:6;;57370:40;;57301:16;;57370:40;57290:128;57227:191;:::o;31336:104::-;31405:27;31415:2;31419:8;31405:27;;;;;;;;;;;;:9;:27::i;:::-;31336:104;;:::o;62759:224::-;62836:5;62823:9;:18;;62815:53;;;;-1:-1:-1;;;62815:53:0;;17932:2:1;62815:53:0;;;17914:21:1;17971:2;17951:18;;;17944:30;-1:-1:-1;;;17990:18:1;;;17983:52;18052:18;;62815:53:0;17730:346:1;62815:53:0;62895:5;62883:9;:17;62879:97;;;62925:10;62917:47;62946:17;62958:5;62946:9;:17;:::i;:::-;62917:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40336:667;40499:4;40536:2;-1:-1:-1;;;;;40520:36:0;;40557:12;:10;:12::i;:::-;40571:4;40577:7;40586:5;40520:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40520:72:0;;;;;;;;-1:-1:-1;;40520:72:0;;;;;;;;;;;;:::i;:::-;;;40516:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40754:6;:13;40771:1;40754:18;40750:235;;40800:40;;-1:-1:-1;;;40800:40:0;;;;;;;;;;;40750:235;40943:6;40937:13;40928:6;40924:2;40920:15;40913:38;40516:480;-1:-1:-1;;;;;;40639:55:0;-1:-1:-1;;;40639:55:0;;-1:-1:-1;40336:667:0;;;;;;:::o;64313:113::-;64373:13;64406:12;64399:19;;;;;:::i;19215:723::-;19271:13;19492:5;19501:1;19492:10;19488:53;;-1:-1:-1;;19519:10:0;;;;;;;;;;;;-1:-1:-1;;;19519:10:0;;;;;19215:723::o;19488:53::-;19566:5;19551:12;19607:78;19614:9;;19607:78;;19640:8;;;;:::i;:::-;;-1:-1:-1;19663:10:0;;-1:-1:-1;19671:2:0;19663:10;;:::i;:::-;;;19607:78;;;19695:19;19727:6;19717:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19717:17:0;;19695:39;;19745:154;19752:10;;19745:154;;19779:11;19789:1;19779:11;;:::i;:::-;;-1:-1:-1;19848:10:0;19856:2;19848:5;:10;:::i;:::-;19835:24;;:2;:24;:::i;:::-;19822:39;;19805:6;19812;19805:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;19805:56:0;;;;;;;;-1:-1:-1;19876:11:0;19885:2;19876:11;;:::i;:::-;;;19745:154;;54084:366;54182:7;52273:100;;;;;;;;;;;;;;;;;52253:127;;;;;;;54320:12;;54351:11;;;;54391:24;;;;;54381:35;;;;;;54247:184;;;;;19566:25:1;;;19622:2;19607:18;;19600:34;;;;-1:-1:-1;;;;;19670:32:1;19665:2;19650:18;;19643:60;19734:2;19719:18;;19712:34;19553:3;19538:19;;19335:417;54247:184:0;;;;;;;;;;;;;54223:219;;;;;;54207:235;;54084:366;;;:::o;51874:234::-;51961:7;52055:20;51313:15;;;51235:101;52055:20;52026:63;;-1:-1:-1;;;52026:63:0;;;20015:27:1;20058:11;;;20051:27;;;;20094:12;;;20087:28;;;20131:12;;52026:63:0;19757:392:1;31813:1657:0;31936:20;31959:13;-1:-1:-1;;;;;31987:16:0;;31983:48;;32012:19;;-1:-1:-1;;;32012:19:0;;;;;;;;;;;31983:48;32046:8;32058:1;32046:13;32042:44;;32068:18;;-1:-1:-1;;;32068:18:0;;;;;;;;;;;32042:44;-1:-1:-1;;;;;32429:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;32484:49:0;;32429:44;;;;;;;;32484:49;;;;-1:-1:-1;;32429:44:0;;;;;;32484:49;;;;;;;;;;;;;;;;32546:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;32592:66:0;;;-1:-1:-1;;;32642:15:0;32592:66;;;;;;;;;;;;;32546:25;;32731:23;;;;11260:19;:23;32767:579;;32803:293;32830:38;;32855:12;;-1:-1:-1;;;;;32830:38:0;;;32847:1;;32830:38;;32847:1;;32830:38;32892:69;32931:1;32935:2;32939:14;;;;;;32955:5;32892:30;:69::i;:::-;32887:166;;32993:40;;-1:-1:-1;;;32993:40:0;;;;;;;;;;;32887:166;33091:3;33076:12;:18;32803:293;;33169:12;33152:13;;:29;33148:43;;33183:8;;;33148:43;32767:579;;;33224:111;33251:40;;33276:14;;;;;-1:-1:-1;;;;;33251:40:0;;;33268:1;;33251:40;;33268:1;;33251:40;33330:3;33315:12;:18;33224:111;;32767:579;-1:-1:-1;33356:13:0;:28;;;33402:60;;33435:2;33439:12;33453:8;33402:60;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:131::-;-1:-1:-1;;;;;1811:31:1;;1801:42;;1791:70;;1857:1;1854;1847:12;1872:315;1940:6;1948;2001:2;1989:9;1980:7;1976:23;1972:32;1969:52;;;2017:1;2014;2007:12;1969:52;2056:9;2043:23;2075:31;2100:5;2075:31;:::i;:::-;2125:5;2177:2;2162:18;;;;2149:32;;-1:-1:-1;;;1872:315:1:o;2192:127::-;2253:10;2248:3;2244:20;2241:1;2234:31;2284:4;2281:1;2274:15;2308:4;2305:1;2298:15;2324:718;2366:5;2419:3;2412:4;2404:6;2400:17;2396:27;2386:55;;2437:1;2434;2427:12;2386:55;2473:6;2460:20;2499:18;2536:2;2532;2529:10;2526:36;;;2542:18;;:::i;:::-;2617:2;2611:9;2585:2;2671:13;;-1:-1:-1;;2667:22:1;;;2691:2;2663:31;2659:40;2647:53;;;2715:18;;;2735:22;;;2712:46;2709:72;;;2761:18;;:::i;:::-;2801:10;2797:2;2790:22;2836:2;2828:6;2821:18;2882:3;2875:4;2870:2;2862:6;2858:15;2854:26;2851:35;2848:55;;;2899:1;2896;2889:12;2848:55;2963:2;2956:4;2948:6;2944:17;2937:4;2929:6;2925:17;2912:54;3010:1;3003:4;2998:2;2990:6;2986:15;2982:26;2975:37;3030:6;3021:15;;;;;;2324:718;;;;:::o;3047:758::-;3149:6;3157;3165;3173;3181;3234:3;3222:9;3213:7;3209:23;3205:33;3202:53;;;3251:1;3248;3241:12;3202:53;3290:9;3277:23;3309:31;3334:5;3309:31;:::i;:::-;3359:5;-1:-1:-1;3415:2:1;3400:18;;3387:32;3442:18;3431:30;;3428:50;;;3474:1;3471;3464:12;3428:50;3497:49;3538:7;3529:6;3518:9;3514:22;3497:49;:::i;:::-;3487:59;;;3593:2;3582:9;3578:18;3565:32;3555:42;;3644:2;3633:9;3629:18;3616:32;3606:42;;3700:3;3689:9;3685:19;3672:33;3749:4;3740:7;3736:18;3727:7;3724:31;3714:59;;3769:1;3766;3759:12;3714:59;3792:7;3782:17;;;3047:758;;;;;;;;:::o;4397:456::-;4474:6;4482;4490;4543:2;4531:9;4522:7;4518:23;4514:32;4511:52;;;4559:1;4556;4549:12;4511:52;4598:9;4585:23;4617:31;4642:5;4617:31;:::i;:::-;4667:5;-1:-1:-1;4724:2:1;4709:18;;4696:32;4737:33;4696:32;4737:33;:::i;:::-;4397:456;;4789:7;;-1:-1:-1;;;4843:2:1;4828:18;;;;4815:32;;4397:456::o;4858:247::-;4917:6;4970:2;4958:9;4949:7;4945:23;4941:32;4938:52;;;4986:1;4983;4976:12;4938:52;5025:9;5012:23;5044:31;5069:5;5044:31;:::i;5110:592::-;5181:6;5189;5242:2;5230:9;5221:7;5217:23;5213:32;5210:52;;;5258:1;5255;5248:12;5210:52;5298:9;5285:23;5327:18;5368:2;5360:6;5357:14;5354:34;;;5384:1;5381;5374:12;5354:34;5422:6;5411:9;5407:22;5397:32;;5467:7;5460:4;5456:2;5452:13;5448:27;5438:55;;5489:1;5486;5479:12;5438:55;5529:2;5516:16;5555:2;5547:6;5544:14;5541:34;;;5571:1;5568;5561:12;5541:34;5616:7;5611:2;5602:6;5598:2;5594:15;5590:24;5587:37;5584:57;;;5637:1;5634;5627:12;5584:57;5668:2;5660:11;;;;;5690:6;;-1:-1:-1;5110:592:1;;-1:-1:-1;;;;5110:592:1:o;5707:248::-;5775:6;5783;5836:2;5824:9;5815:7;5811:23;5807:32;5804:52;;;5852:1;5849;5842:12;5804:52;-1:-1:-1;;5875:23:1;;;5945:2;5930:18;;;5917:32;;-1:-1:-1;5707:248:1:o;5960:160::-;6025:20;;6081:13;;6074:21;6064:32;;6054:60;;6110:1;6107;6100:12;6054:60;5960:160;;;:::o;6125:315::-;6190:6;6198;6251:2;6239:9;6230:7;6226:23;6222:32;6219:52;;;6267:1;6264;6257:12;6219:52;6306:9;6293:23;6325:31;6350:5;6325:31;:::i;:::-;6375:5;-1:-1:-1;6399:35:1;6430:2;6415:18;;6399:35;:::i;:::-;6389:45;;6125:315;;;;;:::o;6445:665::-;6540:6;6548;6556;6564;6617:3;6605:9;6596:7;6592:23;6588:33;6585:53;;;6634:1;6631;6624:12;6585:53;6673:9;6660:23;6692:31;6717:5;6692:31;:::i;:::-;6742:5;-1:-1:-1;6799:2:1;6784:18;;6771:32;6812:33;6771:32;6812:33;:::i;:::-;6864:7;-1:-1:-1;6918:2:1;6903:18;;6890:32;;-1:-1:-1;6973:2:1;6958:18;;6945:32;7000:18;6989:30;;6986:50;;;7032:1;7029;7022:12;6986:50;7055:49;7096:7;7087:6;7076:9;7072:22;7055:49;:::i;:::-;7045:59;;;6445:665;;;;;;;:::o;7115:388::-;7183:6;7191;7244:2;7232:9;7223:7;7219:23;7215:32;7212:52;;;7260:1;7257;7250:12;7212:52;7299:9;7286:23;7318:31;7343:5;7318:31;:::i;:::-;7368:5;-1:-1:-1;7425:2:1;7410:18;;7397:32;7438:33;7397:32;7438:33;:::i;:::-;7490:7;7480:17;;;7115:388;;;;;:::o;7508:180::-;7564:6;7617:2;7605:9;7596:7;7592:23;7588:32;7585:52;;;7633:1;7630;7623:12;7585:52;7656:26;7672:9;7656:26;:::i;7693:380::-;7772:1;7768:12;;;;7815;;;7836:61;;7890:4;7882:6;7878:17;7868:27;;7836:61;7943:2;7935:6;7932:14;7912:18;7909:38;7906:161;;7989:10;7984:3;7980:20;7977:1;7970:31;8024:4;8021:1;8014:15;8052:4;8049:1;8042:15;7906:161;;7693:380;;;:::o;8480:432::-;-1:-1:-1;;;;;8737:15:1;;;8719:34;;8789:15;;8784:2;8769:18;;8762:43;8841:2;8836;8821:18;;8814:30;;;8662:4;;8861:45;;8887:18;;8879:6;8861:45;:::i;:::-;8853:53;8480:432;-1:-1:-1;;;;;8480:432:1:o;8917:415::-;9074:3;9112:6;9106:13;9128:53;9174:6;9169:3;9162:4;9154:6;9150:17;9128:53;:::i;:::-;9250:2;9246:15;;;;-1:-1:-1;;9242:53:1;9203:16;;;;9228:68;;;9323:2;9312:14;;8917:415;-1:-1:-1;;8917:415:1:o;9337:274::-;9466:3;9504:6;9498:13;9520:53;9566:6;9561:3;9554:4;9546:6;9542:17;9520:53;:::i;:::-;9589:16;;;;;9337:274;-1:-1:-1;;9337:274:1:o;9973:356::-;10175:2;10157:21;;;10194:18;;;10187:30;10253:34;10248:2;10233:18;;10226:62;10320:2;10305:18;;9973:356::o;11249:184::-;11319:6;11372:2;11360:9;11351:7;11347:23;11343:32;11340:52;;;11388:1;11385;11378:12;11340:52;-1:-1:-1;11411:16:1;;11249:184;-1:-1:-1;11249:184:1:o;11438:251::-;11508:6;11561:2;11549:9;11540:7;11536:23;11532:32;11529:52;;;11577:1;11574;11567:12;11529:52;11609:9;11603:16;11628:31;11653:5;11628:31;:::i;11694:127::-;11755:10;11750:3;11746:20;11743:1;11736:31;11786:4;11783:1;11776:15;11810:4;11807:1;11800:15;11826:128;11866:3;11897:1;11893:6;11890:1;11887:13;11884:39;;;11903:18;;:::i;:::-;-1:-1:-1;11939:9:1;;11826:128::o;11959:135::-;11998:3;12019:17;;;12016:43;;12039:18;;:::i;:::-;-1:-1:-1;12086:1:1;12075:13;;11959:135::o;13564:354::-;13766:2;13748:21;;;13805:2;13785:18;;;13778:30;13844:32;13839:2;13824:18;;13817:60;13909:2;13894:18;;13564:354::o;13923:125::-;13963:4;13991:1;13988;13985:8;13982:34;;;13996:18;;:::i;:::-;-1:-1:-1;14033:9:1;;13923:125::o;14053:168::-;14093:7;14159:1;14155;14151:6;14147:14;14144:1;14141:21;14136:1;14129:9;14122:17;14118:45;14115:71;;;14166:18;;:::i;:::-;-1:-1:-1;14206:9:1;;14053:168::o;14697:1527::-;14921:3;14959:6;14953:13;14985:4;14998:51;15042:6;15037:3;15032:2;15024:6;15020:15;14998:51;:::i;:::-;15112:13;;15071:16;;;;15134:55;15112:13;15071:16;15156:15;;;15134:55;:::i;:::-;15278:13;;15211:20;;;15251:1;;15338;15360:18;;;;15413;;;;15440:93;;15518:4;15508:8;15504:19;15492:31;;15440:93;15581:2;15571:8;15568:16;15548:18;15545:40;15542:167;;-1:-1:-1;;;15608:33:1;;15664:4;15661:1;15654:15;15694:4;15615:3;15682:17;15542:167;15725:18;15752:110;;;;15876:1;15871:328;;;;15718:481;;15752:110;-1:-1:-1;;15787:24:1;;15773:39;;15832:20;;;;-1:-1:-1;15752:110:1;;15871:328;14644:1;14637:14;;;14681:4;14668:18;;15966:1;15980:169;15994:8;15991:1;15988:15;15980:169;;;16076:14;;16061:13;;;16054:37;16119:16;;;;16011:10;;15980:169;;;15984:3;;16180:8;16173:5;16169:20;16162:27;;15718:481;-1:-1:-1;16215:3:1;;14697:1527;-1:-1:-1;;;;;;;;;;;14697:1527:1:o;18081:489::-;-1:-1:-1;;;;;18350:15:1;;;18332:34;;18402:15;;18397:2;18382:18;;18375:43;18449:2;18434:18;;18427:34;;;18497:3;18492:2;18477:18;;18470:31;;;18275:4;;18518:46;;18544:19;;18536:6;18518:46;:::i;:::-;18510:54;18081:489;-1:-1:-1;;;;;;18081:489:1:o;18575:249::-;18644:6;18697:2;18685:9;18676:7;18672:23;18668:32;18665:52;;;18713:1;18710;18703:12;18665:52;18745:9;18739:16;18764:30;18788:5;18764:30;:::i;18829:127::-;18890:10;18885:3;18881:20;18878:1;18871:31;18921:4;18918:1;18911:15;18945:4;18942:1;18935:15;18961:120;19001:1;19027;19017:35;;19032:18;;:::i;:::-;-1:-1:-1;19066:9:1;;18961:120::o;19086:112::-;19118:1;19144;19134:35;;19149:18;;:::i;:::-;-1:-1:-1;19183:9:1;;19086:112::o;19203:127::-;19264:10;19259:3;19255:20;19252:1;19245:31;19295:4;19292:1;19285:15;19319:4;19316:1;19309:15

ipfs://251b2c14fe683f0b142ea632d58908ab481eed1c0764035ce37af5c210e644ab