Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IERC721Receiver
•    - function onERC721Received(
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
•    - function _msgSender()
•    - function _msgData()
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function supportsInterface(bytes4 int ...
•  contract ERC721A is Context, ERC16 ...
•    - function _startTokenId()
•    - function totalSupply()
•    - function _totalMinted()
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function _numberMinted(address owner)
•    - function _numberBurned(address owner)
•    - function _getAux(address owner)
•    - function _setAux(address owner, uint6 ...
•    - function _ownershipOf(uint256 tokenId ...
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _exists(uint256 tokenId)
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(
•    - function _transfer(
•    - function _burn(uint256 tokenId)
•    - function _burn(uint256 tokenId, bool ...
•    - function _approve(
•    - function _checkContractOnERC721Receiv ...
•    - function _beforeTokenTransfers(
•    - function _afterTokenTransfers(
• library Counters
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
•    - function reset(Counter storage counte ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract ParaPreppers is ERC721A, ... *
•    - function setMintAddress(address[] mem ...
•    - function _baseURI()
•    - function setBaseURI(string memory _ba ...
•    - function massMint()
•    - function singleMint(address addr)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)


pragma solidity ^0.8.0;

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

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

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

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


/**
 * @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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


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

pragma solidity ^0.8.4;

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

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId, owner);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

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

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

        address from = prevOwnership.addr;

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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);
    }
}

contract ParaPreppers is ERC721A, Ownable {

    using SafeMath for uint256;
    using Counters for Counters.Counter;

    string public baseTokenURI = "https://nft.parapreppernft.com/ipfs/QmXrZcpzkqjV5haNqN4oUs3HhXtH95kqRG9cfAWbVz7Kqi/";
    address[] public array;

    constructor() ERC721A("OG Para Preppers", "OGPP") {
    }

    function setMintAddress(address[] memory addr) external onlyOwner {
        array = addr;
    }

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

    //  Set the base uri for token
    function setBaseURI(string memory _baseTokenURI) public onlyOwner {
        baseTokenURI = _baseTokenURI;
    }

    function massMint() public onlyOwner {
        for(uint256 i=0; i<array.length; i++) {
            _safeMint(array[i], 1);
        }
    }

    function singleMint(address addr) public onlyOwner {
        _safeMint(addr, 1);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"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":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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"array","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"_baseTokenURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"setMintAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"singleMint","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"}]

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

50966:972:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23283:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26396:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;27899:204;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;27462:371;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22532:303;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51695:142;;;:::i;:::-;;28764:170;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51215:22;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51312:97;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29005:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51574:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26204:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23652:206;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50149:103;;;:::i;:::-;;49498:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26565:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;28175:287;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51845:88;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29261:369;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26740:318;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51094:114;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;28533:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50407:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;23283:305;23385:4;23437:25;23422:40;;;:11;:40;;;;:105;;;;23494:33;23479:48;;;:11;:48;;;;23422:105;:158;;;;23544:36;23568:11;23544:23;:36::i;:::-;23422:158;23402:178;;23283:305;;;:::o;26396:100::-;26450:13;26483:5;26476:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26396:100;:::o;27899:204::-;27967:7;27992:16;28000:7;27992;:16::i;:::-;27987:64;;28017:34;;;;;;;;;;;;;;27987:64;28071:15;:24;28087:7;28071:24;;;;;;;;;;;;;;;;;;;;;28064:31;;27899:204;;;:::o;27462:371::-;27535:13;27551:24;27567:7;27551:15;:24::i;:::-;27535:40;;27596:5;27590:11;;:2;:11;;;27586:48;;;27610:24;;;;;;;;;;;;;;27586:48;27667:5;27651:21;;:12;:10;:12::i;:::-;:21;;;;:63;;;;;27677:37;27694:5;27701:12;:10;:12::i;:::-;27677:16;:37::i;:::-;27676:38;27651:63;27647:138;;;27738:35;;;;;;;;;;;;;;27647:138;27797:28;27806:2;27810:7;27819:5;27797:8;:28::i;:::-;27524:309;27462:371;;:::o;22532:303::-;22576:7;22801:15;:13;:15::i;:::-;22786:12;;22770:13;;:28;:46;22763:53;;22532:303;:::o;51695:142::-;49729:12;:10;:12::i;:::-;49718:23;;:7;:5;:7::i;:::-;:23;;;49710:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51747:9:::1;51743:87;51762:5;:12;;;;51760:1;:14;51743:87;;;51796:22;51806:5;51812:1;51806:8;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;51816:1;51796:9;:22::i;:::-;51776:3;;;;;:::i;:::-;;;;51743:87;;;;51695:142::o:0;28764:170::-;28898:28;28908:4;28914:2;28918:7;28898:9;:28::i;:::-;28764:170;;;:::o;51215:22::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51312:97::-;49729:12;:10;:12::i;:::-;49718:23;;:7;:5;:7::i;:::-;:23;;;49710:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51397:4:::1;51389:5;:12;;;;;;;;;;;;:::i;:::-;;51312:97:::0;:::o;29005:185::-;29143:39;29160:4;29166:2;29170:7;29143:39;;;;;;;;;;;;:16;:39::i;:::-;29005:185;;;:::o;51574:113::-;49729:12;:10;:12::i;:::-;49718:23;;:7;:5;:7::i;:::-;:23;;;49710:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51666:13:::1;51651:12;:28;;;;;;;;;;;;:::i;:::-;;51574:113:::0;:::o;26204:125::-;26268:7;26295:21;26308:7;26295:12;:21::i;:::-;:26;;;26288:33;;26204:125;;;:::o;23652:206::-;23716:7;23757:1;23740:19;;:5;:19;;;23736:60;;;23768:28;;;;;;;;;;;;;;23736:60;23822:12;:19;23835:5;23822:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;23814:36;;23807:43;;23652:206;;;:::o;50149:103::-;49729:12;:10;:12::i;:::-;49718:23;;:7;:5;:7::i;:::-;:23;;;49710:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;50214:30:::1;50241:1;50214:18;:30::i;:::-;50149:103::o:0;49498:87::-;49544:7;49571:6;;;;;;;;;;;49564:13;;49498:87;:::o;26565:104::-;26621:13;26654:7;26647:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26565:104;:::o;28175:287::-;28286:12;:10;:12::i;:::-;28274:24;;:8;:24;;;28270:54;;;28307:17;;;;;;;;;;;;;;28270:54;28382:8;28337:18;:32;28356:12;:10;:12::i;:::-;28337:32;;;;;;;;;;;;;;;:42;28370:8;28337:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;28435:8;28406:48;;28421:12;:10;:12::i;:::-;28406:48;;;28445:8;28406:48;;;;;;:::i;:::-;;;;;;;;28175:287;;:::o;51845:88::-;49729:12;:10;:12::i;:::-;49718:23;;:7;:5;:7::i;:::-;:23;;;49710:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51907:18:::1;51917:4;51923:1;51907:9;:18::i;:::-;51845:88:::0;:::o;29261:369::-;29428:28;29438:4;29444:2;29448:7;29428:9;:28::i;:::-;29471:15;:2;:13;;;:15::i;:::-;:76;;;;;29491:56;29522:4;29528:2;29532:7;29541:5;29491:30;:56::i;:::-;29490:57;29471:76;29467:156;;;29571:40;;;;;;;;;;;;;;29467:156;29261:369;;;;:::o;26740:318::-;26813:13;26844:16;26852:7;26844;:16::i;:::-;26839:59;;26869:29;;;;;;;;;;;;;;26839:59;26911:21;26935:10;:8;:10::i;:::-;26911:34;;26988:1;26969:7;26963:21;:26;;:87;;;;;;;;;;;;;;;;;27016:7;27025:18;:7;:16;:18::i;:::-;26999:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;26963:87;26956:94;;;26740:318;;;:::o;51094:114::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;28533:164::-;28630:4;28654:18;:25;28673:5;28654:25;;;;;;;;;;;;;;;:35;28680:8;28654:35;;;;;;;;;;;;;;;;;;;;;;;;;28647:42;;28533:164;;;;:::o;50407:201::-;49729:12;:10;:12::i;:::-;49718:23;;:7;:5;:7::i;:::-;:23;;;49710:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;50516:1:::1;50496:22;;:8;:22;;;;50488:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;50572:28;50591:8;50572:18;:28::i;:::-;50407:201:::0;:::o;18933:157::-;19018:4;19057:25;19042:40;;;:11;:40;;;;19035:47;;18933:157;;;:::o;29885:187::-;29942:4;29985:7;29966:15;:13;:15::i;:::-;:26;;:53;;;;;30006:13;;29996:7;:23;29966:53;:98;;;;;30037:11;:20;30049:7;30037:20;;;;;;;;;;;:27;;;;;;;;;;;;30036:28;29966:98;29959:105;;29885:187;;;:::o;16032:98::-;16085:7;16112:10;16105:17;;16032:98;:::o;38055:196::-;38197:2;38170:15;:24;38186:7;38170:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;38235:7;38231:2;38215:28;;38224:5;38215:28;;;;;;;;;;;;38055:196;;;:::o;22306:92::-;22362:7;22306:92;:::o;30080:104::-;30149:27;30159:2;30163:8;30149:27;;;;;;;;;;;;:9;:27::i;:::-;30080:104;;:::o;32998:2130::-;33113:35;33151:21;33164:7;33151:12;:21::i;:::-;33113:59;;33211:4;33189:26;;:13;:18;;;:26;;;33185:67;;33224:28;;;;;;;;;;;;;;33185:67;33265:22;33307:4;33291:20;;:12;:10;:12::i;:::-;:20;;;:73;;;;33328:36;33345:4;33351:12;:10;:12::i;:::-;33328:16;:36::i;:::-;33291:73;:126;;;;33405:12;:10;:12::i;:::-;33381:36;;:20;33393:7;33381:11;:20::i;:::-;:36;;;33291:126;33265:153;;33436:17;33431:66;;33462:35;;;;;;;;;;;;;;33431:66;33526:1;33512:16;;:2;:16;;;33508:52;;;33537:23;;;;;;;;;;;;;;33508:52;33573:43;33595:4;33601:2;33605:7;33614:1;33573:21;:43::i;:::-;33681:35;33698:1;33702:7;33711:4;33681:8;:35::i;:::-;34042:1;34012:12;:18;34025:4;34012:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34086:1;34058:12;:16;34071:2;34058:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34104:31;34138:11;:20;34150:7;34138:20;;;;;;;;;;;34104:54;;34189:2;34173:8;:13;;;:18;;;;;;;;;;;;;;;;;;34239:15;34206:8;:23;;;:49;;;;;;;;;;;;;;;;;;34507:19;34539:1;34529:7;:11;34507:33;;34555:31;34589:11;:24;34601:11;34589:24;;;;;;;;;;;34555:58;;34657:1;34632:27;;:8;:13;;;;;;;;;;;;:27;;;34628:384;;;34842:13;;34827:11;:28;34823:174;;34896:4;34880:8;:13;;;:20;;;;;;;;;;;;;;;;;;34949:13;:28;;;34923:8;:23;;;:54;;;;;;;;;;;;;;;;;;34823:174;34628:384;33987:1036;;;35059:7;35055:2;35040:27;;35049:4;35040:27;;;;;;;;;;;;35078:42;35099:4;35105:2;35109:7;35118:1;35078:20;:42::i;:::-;33102:2026;;32998:2130;;;:::o;25033:1109::-;25095:21;;:::i;:::-;25129:12;25144:7;25129:22;;25212:4;25193:15;:13;:15::i;:::-;:23;;:47;;;;;25227:13;;25220:4;:20;25193:47;25189:886;;;25261:31;25295:11;:17;25307:4;25295:17;;;;;;;;;;;25261:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25336:9;:16;;;25331:729;;25407:1;25381:28;;:9;:14;;;:28;;;25377:101;;25445:9;25438:16;;;;;;25377:101;25780:261;25787:4;25780:261;;;25820:6;;;;;;;;25865:11;:17;25877:4;25865:17;;;;;;;;;;;25853:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25939:1;25913:28;;:9;:14;;;:28;;;25909:109;;25981:9;25974:16;;;;;;25909:109;25780:261;;;25331:729;25242:833;25189:886;26103:31;;;;;;;;;;;;;;25033:1109;;;;:::o;50768:191::-;50842:16;50861:6;;;;;;;;;;;50842:25;;50887:8;50878:6;;:17;;;;;;;;;;;;;;;;;;50942:8;50911:40;;50932:8;50911:40;;;;;;;;;;;;50831:128;50768:191;:::o;8220:326::-;8280:4;8537:1;8515:7;:19;;;:23;8508:30;;8220:326;;;:::o;38743:667::-;38906:4;38943:2;38927:36;;;38964:12;:10;:12::i;:::-;38978:4;38984:7;38993:5;38927:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;38923:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39178:1;39161:6;:13;:18;39157:235;;;39207:40;;;;;;;;;;;;;;39157:235;39350:6;39344:13;39335:6;39331:2;39327:15;39320:38;38923:480;39056:45;;;39046:55;;;:6;:55;;;;39039:62;;;38743:667;;;;;;:::o;51417:113::-;51477:13;51510:12;51503:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51417:113;:::o;16474:723::-;16530:13;16760:1;16751:5;:10;16747:53;;;16778:10;;;;;;;;;;;;;;;;;;;;;16747:53;16810:12;16825:5;16810:20;;16841:14;16866:78;16881:1;16873:4;:9;16866:78;;16899:8;;;;;:::i;:::-;;;;16930:2;16922:10;;;;;:::i;:::-;;;16866:78;;;16954:19;16986:6;16976:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16954:39;;17004:154;17020:1;17011:5;:10;17004:154;;17048:1;17038:11;;;;;:::i;:::-;;;17115:2;17107:5;:10;;;;:::i;:::-;17094:2;:24;;;;:::i;:::-;17081:39;;17064:6;17071;17064:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;17144:2;17135:11;;;;;:::i;:::-;;;17004:154;;;17182:6;17168:21;;;;;16474:723;;;;:::o;30547:163::-;30670:32;30676:2;30680:8;30690:5;30697:4;30670:5;:32::i;:::-;30547:163;;;:::o;40058:159::-;;;;;:::o;40876:158::-;;;;;:::o;30969:1775::-;31108:20;31131:13;;31108:36;;31173:1;31159:16;;:2;:16;;;31155:48;;;31184:19;;;;;;;;;;;;;;31155:48;31230:1;31218:8;:13;31214:44;;;31240:18;;;;;;;;;;;;;;31214:44;31271:61;31301:1;31305:2;31309:12;31323:8;31271:21;:61::i;:::-;31644:8;31609:12;:16;31622:2;31609:16;;;;;;;;;;;;;;;:24;;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31708:8;31668:12;:16;31681:2;31668:16;;;;;;;;;;;;;;;:29;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31767:2;31734:11;:25;31746:12;31734:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;31834:15;31784:11;:25;31796:12;31784:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;31867:20;31890:12;31867:35;;31917:11;31946:8;31931:12;:23;31917:37;;31975:4;:23;;;;;31983:15;:2;:13;;;:15::i;:::-;31975:23;31971:641;;;32019:314;32075:12;32071:2;32050:38;;32067:1;32050:38;;;;;;;;;;;;32116:69;32155:1;32159:2;32163:14;;;;;;32179:5;32116:30;:69::i;:::-;32111:174;;32221:40;;;;;;;;;;;;;;32111:174;32328:3;32312:12;:19;;32019:314;;32414:12;32397:13;;:29;32393:43;;32428:8;;;32393:43;31971:641;;;32477:120;32533:14;;;;;;32529:2;32508:40;;32525:1;32508:40;;;;;;;;;;;;32592:3;32576:12;:19;;32477:120;;31971:641;32642:12;32626:13;:28;;;;31584:1082;;32676:60;32705:1;32709:2;32713:12;32727:8;32676:20;:60::i;:::-;31097:1647;30969:1775;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;24:722:1:-;120:5;145:81;161:64;218:6;161:64;:::i;:::-;145:81;:::i;:::-;136:90;;246:5;275:6;268:5;261:21;309:4;302:5;298:16;291:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:143;;;404:79;;:::i;:::-;350:143;517:1;502:238;527:6;524:1;521:13;502:238;;;595:3;624:37;657:3;645:10;624:37;:::i;:::-;619:3;612:50;691:4;686:3;682:14;675:21;;725:4;720:3;716:14;709:21;;562:178;549:1;546;542:9;537:14;;502:238;;;506:14;126:620;;24:722;;;;;:::o;752:410::-;829:5;854:65;870:48;911:6;870:48;:::i;:::-;854:65;:::i;:::-;845:74;;942:6;935:5;928:21;980:4;973:5;969:16;1018:3;1009:6;1004:3;1000:16;997:25;994:112;;;1025:79;;:::i;:::-;994:112;1115:41;1149:6;1144:3;1139;1115:41;:::i;:::-;835:327;752:410;;;;;:::o;1168:412::-;1246:5;1271:66;1287:49;1329:6;1287:49;:::i;:::-;1271:66;:::i;:::-;1262:75;;1360:6;1353:5;1346:21;1398:4;1391:5;1387:16;1436:3;1427:6;1422:3;1418:16;1415:25;1412:112;;;1443:79;;:::i;:::-;1412:112;1533:41;1567:6;1562:3;1557;1533:41;:::i;:::-;1252:328;1168:412;;;;;:::o;1586:139::-;1632:5;1670:6;1657:20;1648:29;;1686:33;1713:5;1686:33;:::i;:::-;1586:139;;;;:::o;1748:370::-;1819:5;1868:3;1861:4;1853:6;1849:17;1845:27;1835:122;;1876:79;;:::i;:::-;1835:122;1993:6;1980:20;2018:94;2108:3;2100:6;2093:4;2085:6;2081:17;2018:94;:::i;:::-;2009:103;;1825:293;1748:370;;;;:::o;2124:133::-;2167:5;2205:6;2192:20;2183:29;;2221:30;2245:5;2221:30;:::i;:::-;2124:133;;;;:::o;2263:137::-;2308:5;2346:6;2333:20;2324:29;;2362:32;2388:5;2362:32;:::i;:::-;2263:137;;;;:::o;2406:141::-;2462:5;2493:6;2487:13;2478:22;;2509:32;2535:5;2509:32;:::i;:::-;2406:141;;;;:::o;2566:338::-;2621:5;2670:3;2663:4;2655:6;2651:17;2647:27;2637:122;;2678:79;;:::i;:::-;2637:122;2795:6;2782:20;2820:78;2894:3;2886:6;2879:4;2871:6;2867:17;2820:78;:::i;:::-;2811:87;;2627:277;2566:338;;;;:::o;2924:340::-;2980:5;3029:3;3022:4;3014:6;3010:17;3006:27;2996:122;;3037:79;;:::i;:::-;2996:122;3154:6;3141:20;3179:79;3254:3;3246:6;3239:4;3231:6;3227:17;3179:79;:::i;:::-;3170:88;;2986:278;2924:340;;;;:::o;3270:139::-;3316:5;3354:6;3341:20;3332:29;;3370:33;3397:5;3370:33;:::i;:::-;3270:139;;;;:::o;3415:329::-;3474:6;3523:2;3511:9;3502:7;3498:23;3494:32;3491:119;;;3529:79;;:::i;:::-;3491:119;3649:1;3674:53;3719:7;3710:6;3699:9;3695:22;3674:53;:::i;:::-;3664:63;;3620:117;3415:329;;;;:::o;3750:474::-;3818:6;3826;3875:2;3863:9;3854:7;3850:23;3846:32;3843:119;;;3881:79;;:::i;:::-;3843:119;4001:1;4026:53;4071:7;4062:6;4051:9;4047:22;4026:53;:::i;:::-;4016:63;;3972:117;4128:2;4154:53;4199:7;4190:6;4179:9;4175:22;4154:53;:::i;:::-;4144:63;;4099:118;3750:474;;;;;:::o;4230:619::-;4307:6;4315;4323;4372:2;4360:9;4351:7;4347:23;4343:32;4340:119;;;4378:79;;:::i;:::-;4340:119;4498:1;4523:53;4568:7;4559:6;4548:9;4544:22;4523:53;:::i;:::-;4513:63;;4469:117;4625:2;4651:53;4696:7;4687:6;4676:9;4672:22;4651:53;:::i;:::-;4641:63;;4596:118;4753:2;4779:53;4824:7;4815:6;4804:9;4800:22;4779:53;:::i;:::-;4769:63;;4724:118;4230:619;;;;;:::o;4855:943::-;4950:6;4958;4966;4974;5023:3;5011:9;5002:7;4998:23;4994:33;4991:120;;;5030:79;;:::i;:::-;4991:120;5150:1;5175:53;5220:7;5211:6;5200:9;5196:22;5175:53;:::i;:::-;5165:63;;5121:117;5277:2;5303:53;5348:7;5339:6;5328:9;5324:22;5303:53;:::i;:::-;5293:63;;5248:118;5405:2;5431:53;5476:7;5467:6;5456:9;5452:22;5431:53;:::i;:::-;5421:63;;5376:118;5561:2;5550:9;5546:18;5533:32;5592:18;5584:6;5581:30;5578:117;;;5614:79;;:::i;:::-;5578:117;5719:62;5773:7;5764:6;5753:9;5749:22;5719:62;:::i;:::-;5709:72;;5504:287;4855:943;;;;;;;:::o;5804:468::-;5869:6;5877;5926:2;5914:9;5905:7;5901:23;5897:32;5894:119;;;5932:79;;:::i;:::-;5894:119;6052:1;6077:53;6122:7;6113:6;6102:9;6098:22;6077:53;:::i;:::-;6067:63;;6023:117;6179:2;6205:50;6247:7;6238:6;6227:9;6223:22;6205:50;:::i;:::-;6195:60;;6150:115;5804:468;;;;;:::o;6278:474::-;6346:6;6354;6403:2;6391:9;6382:7;6378:23;6374:32;6371:119;;;6409:79;;:::i;:::-;6371:119;6529:1;6554:53;6599:7;6590:6;6579:9;6575:22;6554:53;:::i;:::-;6544:63;;6500:117;6656:2;6682:53;6727:7;6718:6;6707:9;6703:22;6682:53;:::i;:::-;6672:63;;6627:118;6278:474;;;;;:::o;6758:539::-;6842:6;6891:2;6879:9;6870:7;6866:23;6862:32;6859:119;;;6897:79;;:::i;:::-;6859:119;7045:1;7034:9;7030:17;7017:31;7075:18;7067:6;7064:30;7061:117;;;7097:79;;:::i;:::-;7061:117;7202:78;7272:7;7263:6;7252:9;7248:22;7202:78;:::i;:::-;7192:88;;6988:302;6758:539;;;;:::o;7303:327::-;7361:6;7410:2;7398:9;7389:7;7385:23;7381:32;7378:119;;;7416:79;;:::i;:::-;7378:119;7536:1;7561:52;7605:7;7596:6;7585:9;7581:22;7561:52;:::i;:::-;7551:62;;7507:116;7303:327;;;;:::o;7636:349::-;7705:6;7754:2;7742:9;7733:7;7729:23;7725:32;7722:119;;;7760:79;;:::i;:::-;7722:119;7880:1;7905:63;7960:7;7951:6;7940:9;7936:22;7905:63;:::i;:::-;7895:73;;7851:127;7636:349;;;;:::o;7991:509::-;8060:6;8109:2;8097:9;8088:7;8084:23;8080:32;8077:119;;;8115:79;;:::i;:::-;8077:119;8263:1;8252:9;8248:17;8235:31;8293:18;8285:6;8282:30;8279:117;;;8315:79;;:::i;:::-;8279:117;8420:63;8475:7;8466:6;8455:9;8451:22;8420:63;:::i;:::-;8410:73;;8206:287;7991:509;;;;:::o;8506:329::-;8565:6;8614:2;8602:9;8593:7;8589:23;8585:32;8582:119;;;8620:79;;:::i;:::-;8582:119;8740:1;8765:53;8810:7;8801:6;8790:9;8786:22;8765:53;:::i;:::-;8755:63;;8711:117;8506:329;;;;:::o;8841:118::-;8928:24;8946:5;8928:24;:::i;:::-;8923:3;8916:37;8841:118;;:::o;8965:109::-;9046:21;9061:5;9046:21;:::i;:::-;9041:3;9034:34;8965:109;;:::o;9080:360::-;9166:3;9194:38;9226:5;9194:38;:::i;:::-;9248:70;9311:6;9306:3;9248:70;:::i;:::-;9241:77;;9327:52;9372:6;9367:3;9360:4;9353:5;9349:16;9327:52;:::i;:::-;9404:29;9426:6;9404:29;:::i;:::-;9399:3;9395:39;9388:46;;9170:270;9080:360;;;;:::o;9446:364::-;9534:3;9562:39;9595:5;9562:39;:::i;:::-;9617:71;9681:6;9676:3;9617:71;:::i;:::-;9610:78;;9697:52;9742:6;9737:3;9730:4;9723:5;9719:16;9697:52;:::i;:::-;9774:29;9796:6;9774:29;:::i;:::-;9769:3;9765:39;9758:46;;9538:272;9446:364;;;;:::o;9816:377::-;9922:3;9950:39;9983:5;9950:39;:::i;:::-;10005:89;10087:6;10082:3;10005:89;:::i;:::-;9998:96;;10103:52;10148:6;10143:3;10136:4;10129:5;10125:16;10103:52;:::i;:::-;10180:6;10175:3;10171:16;10164:23;;9926:267;9816:377;;;;:::o;10199:366::-;10341:3;10362:67;10426:2;10421:3;10362:67;:::i;:::-;10355:74;;10438:93;10527:3;10438:93;:::i;:::-;10556:2;10551:3;10547:12;10540:19;;10199:366;;;:::o;10571:::-;10713:3;10734:67;10798:2;10793:3;10734:67;:::i;:::-;10727:74;;10810:93;10899:3;10810:93;:::i;:::-;10928:2;10923:3;10919:12;10912:19;;10571:366;;;:::o;10943:118::-;11030:24;11048:5;11030:24;:::i;:::-;11025:3;11018:37;10943:118;;:::o;11067:435::-;11247:3;11269:95;11360:3;11351:6;11269:95;:::i;:::-;11262:102;;11381:95;11472:3;11463:6;11381:95;:::i;:::-;11374:102;;11493:3;11486:10;;11067:435;;;;;:::o;11508:222::-;11601:4;11639:2;11628:9;11624:18;11616:26;;11652:71;11720:1;11709:9;11705:17;11696:6;11652:71;:::i;:::-;11508:222;;;;:::o;11736:640::-;11931:4;11969:3;11958:9;11954:19;11946:27;;11983:71;12051:1;12040:9;12036:17;12027:6;11983:71;:::i;:::-;12064:72;12132:2;12121:9;12117:18;12108:6;12064:72;:::i;:::-;12146;12214:2;12203:9;12199:18;12190:6;12146:72;:::i;:::-;12265:9;12259:4;12255:20;12250:2;12239:9;12235:18;12228:48;12293:76;12364:4;12355:6;12293:76;:::i;:::-;12285:84;;11736:640;;;;;;;:::o;12382:210::-;12469:4;12507:2;12496:9;12492:18;12484:26;;12520:65;12582:1;12571:9;12567:17;12558:6;12520:65;:::i;:::-;12382:210;;;;:::o;12598:313::-;12711:4;12749:2;12738:9;12734:18;12726:26;;12798:9;12792:4;12788:20;12784:1;12773:9;12769:17;12762:47;12826:78;12899:4;12890:6;12826:78;:::i;:::-;12818:86;;12598:313;;;;:::o;12917:419::-;13083:4;13121:2;13110:9;13106:18;13098:26;;13170:9;13164:4;13160:20;13156:1;13145:9;13141:17;13134:47;13198:131;13324:4;13198:131;:::i;:::-;13190:139;;12917:419;;;:::o;13342:::-;13508:4;13546:2;13535:9;13531:18;13523:26;;13595:9;13589:4;13585:20;13581:1;13570:9;13566:17;13559:47;13623:131;13749:4;13623:131;:::i;:::-;13615:139;;13342:419;;;:::o;13767:222::-;13860:4;13898:2;13887:9;13883:18;13875:26;;13911:71;13979:1;13968:9;13964:17;13955:6;13911:71;:::i;:::-;13767:222;;;;:::o;13995:129::-;14029:6;14056:20;;:::i;:::-;14046:30;;14085:33;14113:4;14105:6;14085:33;:::i;:::-;13995:129;;;:::o;14130:75::-;14163:6;14196:2;14190:9;14180:19;;14130:75;:::o;14211:311::-;14288:4;14378:18;14370:6;14367:30;14364:56;;;14400:18;;:::i;:::-;14364:56;14450:4;14442:6;14438:17;14430:25;;14510:4;14504;14500:15;14492:23;;14211:311;;;:::o;14528:307::-;14589:4;14679:18;14671:6;14668:30;14665:56;;;14701:18;;:::i;:::-;14665:56;14739:29;14761:6;14739:29;:::i;:::-;14731:37;;14823:4;14817;14813:15;14805:23;;14528:307;;;:::o;14841:308::-;14903:4;14993:18;14985:6;14982:30;14979:56;;;15015:18;;:::i;:::-;14979:56;15053:29;15075:6;15053:29;:::i;:::-;15045:37;;15137:4;15131;15127:15;15119:23;;14841:308;;;:::o;15155:98::-;15206:6;15240:5;15234:12;15224:22;;15155:98;;;:::o;15259:99::-;15311:6;15345:5;15339:12;15329:22;;15259:99;;;:::o;15364:168::-;15447:11;15481:6;15476:3;15469:19;15521:4;15516:3;15512:14;15497:29;;15364:168;;;;:::o;15538:169::-;15622:11;15656:6;15651:3;15644:19;15696:4;15691:3;15687:14;15672:29;;15538:169;;;;:::o;15713:148::-;15815:11;15852:3;15837:18;;15713:148;;;;:::o;15867:305::-;15907:3;15926:20;15944:1;15926:20;:::i;:::-;15921:25;;15960:20;15978:1;15960:20;:::i;:::-;15955:25;;16114:1;16046:66;16042:74;16039:1;16036:81;16033:107;;;16120:18;;:::i;:::-;16033:107;16164:1;16161;16157:9;16150:16;;15867:305;;;;:::o;16178:185::-;16218:1;16235:20;16253:1;16235:20;:::i;:::-;16230:25;;16269:20;16287:1;16269:20;:::i;:::-;16264:25;;16308:1;16298:35;;16313:18;;:::i;:::-;16298:35;16355:1;16352;16348:9;16343:14;;16178:185;;;;:::o;16369:191::-;16409:4;16429:20;16447:1;16429:20;:::i;:::-;16424:25;;16463:20;16481:1;16463:20;:::i;:::-;16458:25;;16502:1;16499;16496:8;16493:34;;;16507:18;;:::i;:::-;16493:34;16552:1;16549;16545:9;16537:17;;16369:191;;;;:::o;16566:96::-;16603:7;16632:24;16650:5;16632:24;:::i;:::-;16621:35;;16566:96;;;:::o;16668:90::-;16702:7;16745:5;16738:13;16731:21;16720:32;;16668:90;;;:::o;16764:149::-;16800:7;16840:66;16833:5;16829:78;16818:89;;16764:149;;;:::o;16919:126::-;16956:7;16996:42;16989:5;16985:54;16974:65;;16919:126;;;:::o;17051:77::-;17088:7;17117:5;17106:16;;17051:77;;;:::o;17134:154::-;17218:6;17213:3;17208;17195:30;17280:1;17271:6;17266:3;17262:16;17255:27;17134:154;;;:::o;17294:307::-;17362:1;17372:113;17386:6;17383:1;17380:13;17372:113;;;17471:1;17466:3;17462:11;17456:18;17452:1;17447:3;17443:11;17436:39;17408:2;17405:1;17401:10;17396:15;;17372:113;;;17503:6;17500:1;17497:13;17494:101;;;17583:1;17574:6;17569:3;17565:16;17558:27;17494:101;17343:258;17294:307;;;:::o;17607:320::-;17651:6;17688:1;17682:4;17678:12;17668:22;;17735:1;17729:4;17725:12;17756:18;17746:81;;17812:4;17804:6;17800:17;17790:27;;17746:81;17874:2;17866:6;17863:14;17843:18;17840:38;17837:84;;;17893:18;;:::i;:::-;17837:84;17658:269;17607:320;;;:::o;17933:281::-;18016:27;18038:4;18016:27;:::i;:::-;18008:6;18004:40;18146:6;18134:10;18131:22;18110:18;18098:10;18095:34;18092:62;18089:88;;;18157:18;;:::i;:::-;18089:88;18197:10;18193:2;18186:22;17976:238;17933:281;;:::o;18220:233::-;18259:3;18282:24;18300:5;18282:24;:::i;:::-;18273:33;;18328:66;18321:5;18318:77;18315:103;;;18398:18;;:::i;:::-;18315:103;18445:1;18438:5;18434:13;18427:20;;18220:233;;;:::o;18459:176::-;18491:1;18508:20;18526:1;18508:20;:::i;:::-;18503:25;;18542:20;18560:1;18542:20;:::i;:::-;18537:25;;18581:1;18571:35;;18586:18;;:::i;:::-;18571:35;18627:1;18624;18620:9;18615:14;;18459:176;;;;:::o;18641:180::-;18689:77;18686:1;18679:88;18786:4;18783:1;18776:15;18810:4;18807:1;18800:15;18827:180;18875:77;18872:1;18865:88;18972:4;18969:1;18962:15;18996:4;18993:1;18986:15;19013:180;19061:77;19058:1;19051:88;19158:4;19155:1;19148:15;19182:4;19179:1;19172:15;19199:180;19247:77;19244:1;19237:88;19344:4;19341:1;19334:15;19368:4;19365:1;19358:15;19385:180;19433:77;19430:1;19423:88;19530:4;19527:1;19520:15;19554:4;19551:1;19544:15;19571:117;19680:1;19677;19670:12;19694:117;19803:1;19800;19793:12;19817:117;19926:1;19923;19916:12;19940:117;20049:1;20046;20039:12;20063:117;20172:1;20169;20162:12;20186:102;20227:6;20278:2;20274:7;20269:2;20262:5;20258:14;20254:28;20244:38;;20186:102;;;:::o;20294:225::-;20434:34;20430:1;20422:6;20418:14;20411:58;20503:8;20498:2;20490:6;20486:15;20479:33;20294:225;:::o;20525:182::-;20665:34;20661:1;20653:6;20649:14;20642:58;20525:182;:::o;20713:122::-;20786:24;20804:5;20786:24;:::i;:::-;20779:5;20776:35;20766:63;;20825:1;20822;20815:12;20766:63;20713:122;:::o;20841:116::-;20911:21;20926:5;20911:21;:::i;:::-;20904:5;20901:32;20891:60;;20947:1;20944;20937:12;20891:60;20841:116;:::o;20963:120::-;21035:23;21052:5;21035:23;:::i;:::-;21028:5;21025:34;21015:62;;21073:1;21070;21063:12;21015:62;20963:120;:::o;21089:122::-;21162:24;21180:5;21162:24;:::i;:::-;21155:5;21152:35;21142:63;;21201:1;21198;21191:12;21142:63;21089:122;:::o

ipfs://106e7f6e37b8a1b8c45743e6939f4b86db7a98a5af775e267d396e87a1635a91