Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

import "./Ownable.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
import "./SafeMath.sol";
import "./ERC721A.sol";


contract IVM is ERC721A, Ownable {
    using SafeMath for uint256;

    bytes32 private whitelistHash = 0x0e73c52114d4194e74408fcf466bc866014c0b91ed7336172b68832c1f201804;

    uint256 public MAX_TOKENS;
    uint256 public MAX_MINT = 2;
    uint256 public MAX_WHITELIST_MINT = 2;
    uint256 public PRICE = 0.079 ether;

    address public treasury;
    string private baseTokenURI;

    mapping(address => uint256) private publicMintMap;
    mapping(address => uint256) private whitelistMintMap; 

    bool public openPublicMint = false;
    bool public openWhiteListMint = false;

    constructor(
        address _treasury,
        uint256 _max_tokens,
        uint256 _maxBatchSize,
        uint256 _collectionSize
    ) ERC721A("invisible mate", "IVM", _maxBatchSize, _collectionSize) {
        treasury = _treasury;
        MAX_TOKENS = _max_tokens;
    }

    function publicMint(uint256 num) external payable {
        require(openPublicMint, "Public sales not active");
        uint256 supply = totalSupply();
        require(publicMintMap[_msgSender()].add(num) <= MAX_MINT, "Reached max per transaction");
        require(supply.add(num) <= MAX_TOKENS, "Fully minted");
        require(msg.value >= num * PRICE, "Invalid price");

        publicMintMap[_msgSender()] += num;
        _safeMint(_msgSender(), num);
    }

    function whitelistMint(bytes32[] calldata proof, uint256 num) external payable {
        require(openWhiteListMint, "whitelist mint not active");
        require(whitelistMintMap[_msgSender()].add(num) <= MAX_WHITELIST_MINT, "Reached max per transaction");
        bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
        require(MerkleProof.verify(proof, whitelistHash, leaf));
        uint256 supply = totalSupply();
        require(supply.add(num) <= MAX_TOKENS, "Fully minted");
        require(msg.value >= num * PRICE, "Invalid price");

        whitelistMintMap[_msgSender()] += num;
        _safeMint(_msgSender(), num);
    }


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

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

    function withdraw() public onlyOwner {
        payable(treasury).transfer(address(this).balance);
    }

    function setMint(bool _publicMint, bool _whitelistMint) external onlyOwner {
        openPublicMint = _publicMint;
        openWhiteListMint = _whitelistMint;
    }

    function setTreasury(address _treasury) external onlyOwner {
        treasury = _treasury;
    }

    function getHash() public view onlyOwner returns (bytes32) {
        return whitelistHash;
    }

    function setWL(bytes32 _whitelistHash, uint256 _max_whitelist_mint) external onlyOwner {
        whitelistHash = _whitelistHash;
        MAX_WHITELIST_MINT = _max_whitelist_mint;
    }

    function setPrice(uint256 _price) external onlyOwner {
        PRICE = _price;
    }

    function setParams(
        uint256 _max_token,
        uint256 _max_public_mint
    ) external onlyOwner {
        MAX_TOKENS = _max_token;
        MAX_MINT = _max_public_mint;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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
	 * ====
	 */
	function isContract(address account) internal view returns (bool) {
		// This method relies on extcodesize, which returns 0 for contracts in
		// construction, since the code is only stored at the end of the
		// constructor execution.

		uint256 size;
		assembly {
			size := extcodesize(account)
		}
		return size > 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);
			}
		}
	}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
	function _msgSender() internal view virtual returns (address) {
		return msg.sender;
	}

	function _msgData() internal view virtual returns (bytes calldata) {
		return msg.data;
	}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

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

	// Token name
	string private _name;

	// Token symbol
	string private _symbol;

	// Mapping from token ID to owner address
	mapping(uint256 => address) private _owners;

	// Mapping owner address to token count
	mapping(address => uint256) private _balances;

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

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

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

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

	/**
	 * @dev See {IERC721-balanceOf}.
	 */
	function balanceOf(address owner) public view virtual override returns (uint256) {
		require(owner != address(0), "ERC721: balance query for the zero address");
		return _balances[owner];
	}

	/**
	 * @dev See {IERC721-ownerOf}.
	 */
	function ownerOf(uint256 tokenId) public view virtual override returns (address) {
		address owner = _owners[tokenId];
		require(owner != address(0), "ERC721: owner query for nonexistent token");
		return owner;
	}

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

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

	/**
	 * @dev See {IERC721Metadata-tokenURI}.
	 */
	function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
		require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

		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 virtual override {
		address owner = ERC721.ownerOf(tokenId);
		require(to != owner, "ERC721: approval to current owner");

		require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all");

		_approve(to, tokenId);
	}

	/**
	 * @dev See {IERC721-getApproved}.
	 */
	function getApproved(uint256 tokenId) public view virtual override returns (address) {
		require(_exists(tokenId), "ERC721: approved query for nonexistent token");

		return _tokenApprovals[tokenId];
	}

	/**
	 * @dev See {IERC721-setApprovalForAll}.
	 */
	function setApprovalForAll(address operator, bool approved) public virtual override {
		require(operator != _msgSender(), "ERC721: approve to caller");

		_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 {
		//solhint-disable-next-line max-line-length
		require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

		_transfer(from, to, tokenId);
	}

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

	/**
	 * @dev See {IERC721-safeTransferFrom}.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) public virtual override {
		require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
		_safeTransfer(from, to, tokenId, _data);
	}

	/**
	 * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
	 * are aware of the ERC721 protocol to prevent tokens from being forever locked.
	 *
	 * `_data` is additional data, it has no specified format and it is sent in call to `to`.
	 *
	 * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
	 * implement alternative mechanisms to perform token transfer, such as signature-based.
	 *
	 * Requirements:
	 *
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must exist and be owned by `from`.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function _safeTransfer(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) internal virtual {
		_transfer(from, to, tokenId);
		require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
	}

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

	/**
	 * @dev Returns whether `spender` is allowed to manage `tokenId`.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 */
	function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
		require(_exists(tokenId), "ERC721: operator query for nonexistent token");
		address owner = ERC721.ownerOf(tokenId);
		return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
	}

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

	/**
	 * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
	 * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
	 */
	function _safeMint(
		address to,
		uint256 tokenId,
		bytes memory _data
	) internal virtual {
		_mint(to, tokenId);
		require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
	}

	/**
	 * @dev Mints `tokenId` and transfers it to `to`.
	 *
	 * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
	 *
	 * Requirements:
	 *
	 * - `tokenId` must not exist.
	 * - `to` cannot be the zero address.
	 *
	 * Emits a {Transfer} event.
	 */
	function _mint(address to, uint256 tokenId) internal virtual {
		require(to != address(0), "ERC721: mint to the zero address");
		require(!_exists(tokenId), "ERC721: token already minted");

		_beforeTokenTransfer(address(0), to, tokenId);

		_balances[to] += 1;
		_owners[tokenId] = to;

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

	/**
	 * @dev Destroys `tokenId`.
	 * The approval is cleared when the token is burned.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 *
	 * Emits a {Transfer} event.
	 */
	function _burn(uint256 tokenId) internal virtual {
		address owner = ERC721.ownerOf(tokenId);

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

		// Clear approvals
		_approve(address(0), tokenId);

		_balances[owner] -= 1;
		delete _owners[tokenId];

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

	/**
	 * @dev Transfers `tokenId` from `from` to `to`.
	 *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
	 *
	 * Requirements:
	 *
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must be owned by `from`.
	 *
	 * Emits a {Transfer} event.
	 */
	function _transfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual {
		require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
		require(to != address(0), "ERC721: transfer to the zero address");

		_beforeTokenTransfer(from, to, tokenId);

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

		_balances[from] -= 1;
		_balances[to] += 1;
		_owners[tokenId] = to;

		emit Transfer(from, to, tokenId);
	}

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

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

	/**
	 * @dev Hook that is called before any token transfer. This includes minting
	 * and burning.
	 *
	 * 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, ``from``'s `tokenId` will be burned.
	 * - `from` and `to` are never both zero.
	 *
	 * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
	 */
	function _beforeTokenTransfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./IERC721Enumerable.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
 *
 * Does not support burning tokens to address(0).
 */
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
    }

    struct AddressData {
        uint128 balance;
        uint128 numberMinted;
    }

    uint256 private currentIndex = 0;

    uint256 internal immutable collectionSize;
    uint256 internal immutable maxBatchSize;

    // 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) private _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;

    /**
     * @dev
   * `maxBatchSize` refers to how much a minter can mint at a time.
   * `collectionSize_` refers to how many tokens are in the collection.
   */
    constructor(
        string memory name_,
        string memory symbol_,
        uint256 maxBatchSize_,
        uint256 collectionSize_
    ) {
        require(
            collectionSize_ > 0,
            "ERC721A: collection must have a nonzero supply"
        );
        require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
        _name = name_;
        _symbol = symbol_;
        maxBatchSize = maxBatchSize_;
        collectionSize = collectionSize_;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
   */
    function totalSupply() public view override returns (uint256) {
        return currentIndex;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
   */
    function tokenByIndex(uint256 index) public view override returns (uint256) {
        require(index < totalSupply(), "ERC721A: global index out of bounds");
        return index;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
   * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
   * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
   */
    function tokenOfOwnerByIndex(address owner, uint256 index)
    public
    view
    override
    returns (uint256)
    {
        require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
        uint256 numMintedSoFar = totalSupply();
        uint256 tokenIdsIdx = 0;
        address currOwnershipAddr = address(0);
        for (uint256 i = 0; i < numMintedSoFar; i++) {
            TokenOwnership memory ownership = _ownerships[i];
            if (ownership.addr != address(0)) {
                currOwnershipAddr = ownership.addr;
            }
            if (currOwnershipAddr == owner) {
                if (tokenIdsIdx == index) {
                    return i;
                }
                tokenIdsIdx++;
            }
        }
        revert("ERC721A: unable to get token of owner by index");
    }

    /**
     * @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 ||
        interfaceId == type(IERC721Enumerable).interfaceId ||
        super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
   */
    function balanceOf(address owner) public view override returns (uint256) {
        require(owner != address(0), "ERC721A: balance query for the zero address");
        return uint256(_addressData[owner].balance);
    }

    function _numberMinted(address owner) internal view returns (uint256) {
        require(
            owner != address(0),
            "ERC721A: number minted query for the zero address"
        );
        return uint256(_addressData[owner].numberMinted);
    }

    function ownershipOf(uint256 tokenId)
    internal
    view
    returns (TokenOwnership memory)
    {
        require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

        uint256 lowestTokenToCheck;
        if (tokenId >= maxBatchSize) {
            lowestTokenToCheck = tokenId - maxBatchSize + 1;
        }

        for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
            TokenOwnership memory ownership = _ownerships[curr];
            if (ownership.addr != address(0)) {
                return ownership;
            }
        }

        revert("ERC721A: unable to determine the owner of token");
    }

    /**
     * @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)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        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);
        require(to != owner, "ERC721A: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721A: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
   */
    function getApproved(uint256 tokenId) public view override returns (address) {
        require(_exists(tokenId), "ERC721A: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
   */
    function setApprovalForAll(address operator, bool approved) public override {
        require(operator != _msgSender(), "ERC721A: approve to caller");

        _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 override {
        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
   */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public override {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, _data),
            "ERC721A: transfer to non ERC721Receiver implementer"
        );
    }

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

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

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
   *
   * Requirements:
   *
   * - there must be `quantity` tokens remaining unminted in the total collection.
   * - `to` cannot be the zero address.
   * - `quantity` cannot be larger than the max batch size.
   *
   * Emits a {Transfer} event.
   */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = currentIndex;
        require(to != address(0), "ERC721A: mint to the zero address");
        // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
        require(!_exists(startTokenId), "ERC721A: token already minted");
        require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");

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

        AddressData memory addressData = _addressData[to];
        _addressData[to] = AddressData(
            addressData.balance + uint128(quantity),
            addressData.numberMinted + uint128(quantity)
        );
        _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));

        uint256 updatedIndex = startTokenId;

        for (uint256 i = 0; i < quantity; i++) {
            emit Transfer(address(0), to, updatedIndex);
            require(
                _checkOnERC721Received(address(0), to, updatedIndex, _data),
                "ERC721A: transfer to non ERC721Receiver implementer"
            );
            updatedIndex++;
        }

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

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
        getApproved(tokenId) == _msgSender() ||
        isApprovedForAll(prevOwnership.addr, _msgSender()));

        require(
            isApprovedOrOwner,
            "ERC721A: transfer caller is not owner nor approved"
        );

        require(
            prevOwnership.addr == from,
            "ERC721A: transfer from incorrect owner"
        );
        require(to != address(0), "ERC721A: transfer to the zero address");

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        _addressData[from].balance -= 1;
        _addressData[to].balance += 1;
        _ownerships[tokenId] = TokenOwnership(to, 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;
        if (_ownerships[nextTokenId].addr == address(0)) {
            if (_exists(nextTokenId)) {
                _ownerships[nextTokenId] = TokenOwnership(
                    prevOwnership.addr,
                    prevOwnership.startTimestamp
                );
            }
        }

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

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

    uint256 public nextOwnerToExplicitlySet = 0;

    /**
     * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
   */
    function _setOwnersExplicit(uint256 quantity) internal {
        uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
        require(quantity > 0, "quantity must be nonzero");
        uint256 endIndex = oldNextOwnerToSet + quantity - 1;
        if (endIndex > collectionSize - 1) {
            endIndex = collectionSize - 1;
        }
        // We know if the last one in the group exists, all in the group exist, due to serial ordering.
        require(_exists(endIndex), "not enough minted yet for this cleanup");
        for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
            if (_ownerships[i].addr == address(0)) {
                TokenOwnership memory ownership = ownershipOf(i);
                _ownerships[i] = TokenOwnership(
                    ownership.addr,
                    ownership.startTimestamp
                );
            }
        }
        nextOwnerToExplicitlySet = endIndex + 1;
    }

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

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
   *
   * 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`.
   */
    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.
   *
   * 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` and `to` are never both zero.
   */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./IERC721Enumerable.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
	// Mapping from owner to list of owned token IDs
	mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

	// Mapping from token ID to index of the owner tokens list
	mapping(uint256 => uint256) private _ownedTokensIndex;

	// Array with all token ids, used for enumeration
	uint256[] private _allTokens;

	// Mapping from token id to position in the allTokens array
	mapping(uint256 => uint256) private _allTokensIndex;

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

	/**
	 * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
	 */
	function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
		require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
		return _ownedTokens[owner][index];
	}

	/**
	 * @dev See {IERC721Enumerable-totalSupply}.
	 */
	function totalSupply() public view virtual override returns (uint256) {
		return _allTokens.length;
	}

	/**
	 * @dev See {IERC721Enumerable-tokenByIndex}.
	 */
	function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
		require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
		return _allTokens[index];
	}

	/**
	 * @dev Hook that is called before any token transfer. This includes minting
	 * and burning.
	 *
	 * 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, ``from``'s `tokenId` will be burned.
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 *
	 * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
	 */
	function _beforeTokenTransfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual override {
		super._beforeTokenTransfer(from, to, tokenId);

		if (from == address(0)) {
			_addTokenToAllTokensEnumeration(tokenId);
		} else if (from != to) {
			_removeTokenFromOwnerEnumeration(from, tokenId);
		}
		if (to == address(0)) {
			_removeTokenFromAllTokensEnumeration(tokenId);
		} else if (to != from) {
			_addTokenToOwnerEnumeration(to, tokenId);
		}
	}

	/**
	 * @dev Private function to add a token to this extension's ownership-tracking data structures.
	 * @param to address representing the new owner of the given token ID
	 * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
	 */
	function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
		uint256 length = ERC721.balanceOf(to);
		_ownedTokens[to][length] = tokenId;
		_ownedTokensIndex[tokenId] = length;
	}

	/**
	 * @dev Private function to add a token to this extension's token tracking data structures.
	 * @param tokenId uint256 ID of the token to be added to the tokens list
	 */
	function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
		_allTokensIndex[tokenId] = _allTokens.length;
		_allTokens.push(tokenId);
	}

	/**
	 * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
	 * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
	 * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
	 * This has O(1) time complexity, but alters the order of the _ownedTokens array.
	 * @param from address representing the previous owner of the given token ID
	 * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
	 */
	function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
		// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
		// then delete the last slot (swap and pop).

		uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
		uint256 tokenIndex = _ownedTokensIndex[tokenId];

		// When the token to delete is the last token, the swap operation is unnecessary
		if (tokenIndex != lastTokenIndex) {
			uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

			_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
			_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
		}

		// This also deletes the contents at the last position of the array
		delete _ownedTokensIndex[tokenId];
		delete _ownedTokens[from][lastTokenIndex];
	}

	/**
	 * @dev Private function to remove a token from this extension's token tracking data structures.
	 * This has O(1) time complexity, but alters the order of the _allTokens array.
	 * @param tokenId uint256 ID of the token to be removed from the tokens list
	 */
	function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
		// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
		// then delete the last slot (swap and pop).

		uint256 lastTokenIndex = _allTokens.length - 1;
		uint256 tokenIndex = _allTokensIndex[tokenId];

		// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
		// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
		// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
		uint256 lastTokenId = _allTokens[lastTokenIndex];

		_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
		_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

		// This also deletes the contents at the last position of the array
		delete _allTokensIndex[tokenId];
		_allTokens.pop();
	}
}

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
	/**
	 * @dev Returns the total amount of tokens stored by the contract.
	 */
	function totalSupply() external view returns (uint256);

	/**
	 * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
	 * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
	 */
	function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

	/**
	 * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
	 * Use along with {totalSupply} to enumerate all tokens.
	 */
	function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

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

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

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @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() {
		_setOwner(_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 {
		_setOwner(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");
		_setOwner(newOwner);
	}

	function _setOwner(address newOwner) private {
		address oldOwner = _owner;
		_owner = newOwner;
		emit OwnershipTransferred(oldOwner, newOwner);
	}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. 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;
		}
	}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_treasury","type":"address"},{"internalType":"uint256","name":"_max_tokens","type":"uint256"},{"internalType":"uint256","name":"_maxBatchSize","type":"uint256"},{"internalType":"uint256","name":"_collectionSize","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"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":"MAX_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_WHITELIST_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextOwnerToExplicitlySet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openPublicMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openWhiteListMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","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":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_publicMint","type":"bool"},{"internalType":"bool","name":"_whitelistMint","type":"bool"}],"name":"setMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max_token","type":"uint256"},{"internalType":"uint256","name":"_max_public_mint","type":"uint256"}],"name":"setParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_whitelistHash","type":"bytes32"},{"internalType":"uint256","name":"_max_whitelist_mint","type":"uint256"}],"name":"setWL","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"uint256","name":"num","type":"uint256"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000aaab4ae449398b444c42c447472fa0afe7b5f97100000000000000000000000000000000000000000000000000000000000003e700000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000002710

-----Decoded View---------------
Arg [0] : _treasury (address): 0xaAaB4Ae449398b444C42c447472fa0afe7B5F971
Arg [1] : _max_tokens (uint256): 999
Arg [2] : _maxBatchSize (uint256): 5
Arg [3] : _collectionSize (uint256): 10000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000aaab4ae449398b444c42c447472fa0afe7b5f971
Arg [1] : 00000000000000000000000000000000000000000000000000000000000003e7
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 0000000000000000000000000000000000000000000000000000000000002710

185:3155:11:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4086:374:4;;;;;;;;;;-1:-1:-1;4086:374:4;;;;;:::i;:::-;;:::i;:::-;;;565:14:16;;558:22;540:41;;528:2;513:18;4086:374:4;;;;;;;;5894:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;7475:210::-;;;;;;;;;;-1:-1:-1;7475:210:4;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:16;;;1674:51;;1662:2;1647:18;7475:210:4;1528:203:16;7013:403:4;;;;;;;;;;-1:-1:-1;7013:403:4;;;;;:::i;:::-;;:::i;:::-;;2554:98;;;;;;;;;;-1:-1:-1;2607:7:4;2633:12;2554:98;;;2319:25:16;;;2307:2;2292:18;2554:98:4;2173:177:16;8343:156:4;;;;;;;;;;-1:-1:-1;8343:156:4;;;;;:::i;:::-;;:::i;1520:643:11:-;;;;;;:::i;:::-;;:::i;1052:462::-;;;;;;:::i;:::-;;:::i;3196:825:4:-;;;;;;;;;;-1:-1:-1;3196:825:4;;;;;:::i;:::-;;:::i;2392:103:11:-;;;;;;;;;;;;;:::i;8563:171:4:-;;;;;;;;;;-1:-1:-1;8563:171:4;;;;;:::i;:::-;;:::i;688:34:11:-;;;;;;;;;;-1:-1:-1;688:34:11;;;;;;;;2722:184:4;;;;;;;;;;-1:-1:-1;2722:184:4;;;;;:::i;:::-;;:::i;2287:99:11:-;;;;;;;;;;-1:-1:-1;2287:99:11;;;;;:::i;:::-;;:::i;510:23::-;;;;;;;;;;-1:-1:-1;510:23:11;;;;-1:-1:-1;;;;;510:23:11;;;5712:122:4;;;;;;;;;;-1:-1:-1;5712:122:4;;;;;:::i;:::-;;:::i;2875:184:11:-;;;;;;;;;;-1:-1:-1;2875:184:11;;;;;:::i;:::-;;:::i;4517:218:4:-;;;;;;;;;;-1:-1:-1;4517:218:4;;;;;:::i;:::-;;:::i;1499:83:13:-;;;;;;;;;;;;;:::i;469:34:11:-;;;;;;;;;;;;;;;;927:76:13;;;;;;;;;;-1:-1:-1;993:6:13;;-1:-1:-1;;;;;993:6:13;927:76;;3065:84:11;;;;;;;;;;-1:-1:-1;3065:84:11;;;;;:::i;:::-;;:::i;6054:102:4:-;;;;;;;;;;;;;:::i;7750:283::-;;;;;;;;;;-1:-1:-1;7750:283:4;;;;;:::i;:::-;;:::i;728:37:11:-;;;;;;;;;;-1:-1:-1;728:37:11;;;;;;;;;;;8798:344:4;;;;;;;;;;-1:-1:-1;8798:344:4;;;;;:::i;:::-;;:::i;3155:183:11:-;;;;;;;;;;-1:-1:-1;3155:183:11;;;;;:::i;:::-;;:::i;426:37::-;;;;;;;;;;;;;;;;6220:411:4;;;;;;;;;;-1:-1:-1;6220:411:4;;;;;:::i;:::-;;:::i;2773:96:11:-;;;;;;;;;;;;;:::i;2501:164::-;;;;;;;;;;-1:-1:-1;2501:164:11;;;;;:::i;:::-;;:::i;13476:43:4:-;;;;;;;;;;;;;;;;8097:186;;;;;;;;;;-1:-1:-1;8097:186:4;;;;;:::i;:::-;-1:-1:-1;;;;;8241:25:4;;;8214:4;8241:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;8097:186;393:27:11;;;;;;;;;;;;;;;;2671:96;;;;;;;;;;-1:-1:-1;2671:96:11;;;;;:::i;:::-;;:::i;1716:174:13:-;;;;;;;;;;-1:-1:-1;1716:174:13;;;;;:::i;:::-;;:::i;362:25:11:-;;;;;;;;;;;;;;;;4086:374:4;4208:4;-1:-1:-1;;;;;;4243:40:4;;-1:-1:-1;;;4243:40:4;;:100;;-1:-1:-1;;;;;;;4295:48:4;;-1:-1:-1;;;4295:48:4;4243:100;:162;;;-1:-1:-1;;;;;;;4355:50:4;;-1:-1:-1;;;4355:50:4;4243:162;:210;;;-1:-1:-1;;;;;;;;;;853:40:2;;;4417:36:4;4228:225;4086:374;-1:-1:-1;;4086:374:4:o;5894:98::-;5948:13;5980:5;5973:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5894:98;:::o;7475:210::-;7543:7;7570:16;7578:7;9435:4;9468:12;-1:-1:-1;9458:22:4;9378:109;7570:16;7562:74;;;;-1:-1:-1;;;7562:74:4;;7687:2:16;7562:74:4;;;7669:21:16;7726:2;7706:18;;;7699:30;7765:34;7745:18;;;7738:62;-1:-1:-1;;;7816:18:16;;;7809:43;7869:19;;7562:74:4;;;;;;;;;-1:-1:-1;7654:24:4;;;;:15;:24;;;;;;-1:-1:-1;;;;;7654:24:4;;7475:210::o;7013:403::-;7085:13;7101:24;7117:7;7101:15;:24::i;:::-;7085:40;;7149:5;-1:-1:-1;;;;;7143:11:4;:2;-1:-1:-1;;;;;7143:11:4;;;7135:58;;;;-1:-1:-1;;;7135:58:4;;8101:2:16;7135:58:4;;;8083:21:16;8140:2;8120:18;;;8113:30;8179:34;8159:18;;;8152:62;-1:-1:-1;;;8230:18:16;;;8223:32;8272:19;;7135:58:4;7899:398:16;7135:58:4;657:10:1;-1:-1:-1;;;;;7225:21:4;;;;:62;;-1:-1:-1;7250:37:4;7267:5;657:10:1;8097:186:4;:::i;7250:37::-;7204:166;;;;-1:-1:-1;;;7204:166:4;;8504:2:16;7204:166:4;;;8486:21:16;8543:2;8523:18;;;8516:30;8582:34;8562:18;;;8555:62;8653:27;8633:18;;;8626:55;8698:19;;7204:166:4;8302:421:16;7204:166:4;7381:28;7390:2;7394:7;7403:5;7381:8;:28::i;:::-;7075:341;7013:403;;:::o;8343:156::-;8464:28;8474:4;8480:2;8484:7;8464:9;:28::i;1520:643:11:-;1617:17;;;;;;;1609:55;;;;-1:-1:-1;;;1609:55:11;;8930:2:16;1609:55:11;;;8912:21:16;8969:2;8949:18;;;8942:30;9008:27;8988:18;;;8981:55;9053:18;;1609:55:11;8728:349:16;1609:55:11;1725:18;;1682:39;1717:3;1682:16;:30;657:10:1;1699:12:11;-1:-1:-1;;;;;1682:30:11;;;;;;;;;;;;-1:-1:-1;1682:30:11;;;:34;:39::i;:::-;:61;;1674:101;;;;-1:-1:-1;;;1674:101:11;;9284:2:16;1674:101:11;;;9266:21:16;9323:2;9303:18;;;9296:30;9362:29;9342:18;;;9335:57;9409:18;;1674:101:11;9082:351:16;1674:101:11;1810:30;;-1:-1:-1;;657:10:1;9587:2:16;9583:15;9579:53;1810:30:11;;;9567:66:16;1785:12:11;;9649::16;;1810:30:11;;;;;;;;;;;;1800:41;;;;;;1785:56;;1859:46;1878:5;;1859:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1885:13:11;;;-1:-1:-1;1900:4:11;;-1:-1:-1;1859:18:11;:46::i;:::-;1851:55;;;;;;1916:14;2633:12:4;1983:10:11;;1964:15;2633:12:4;1975:3:11;1964:10;:15::i;:::-;:29;;1956:54;;;;-1:-1:-1;;;1956:54:11;;9874:2:16;1956:54:11;;;9856:21:16;9913:2;9893:18;;;9886:30;-1:-1:-1;;;9932:18:16;;;9925:42;9984:18;;1956:54:11;9672:336:16;1956:54:11;2047:5;;2041:11;;:3;:11;:::i;:::-;2028:9;:24;;2020:50;;;;-1:-1:-1;;;2020:50:11;;10520:2:16;2020:50:11;;;10502:21:16;10559:2;10539:18;;;10532:30;-1:-1:-1;;;10578:18:16;;;10571:43;10631:18;;2020:50:11;10318:337:16;2020:50:11;657:10:1;2081:30:11;;;;:16;:30;;;;;:37;;2115:3;;2081:30;:37;;2115:3;;2081:37;:::i;:::-;;;;-1:-1:-1;2128:28:11;;-1:-1:-1;657:10:1;2152:3:11;2128:9;:28::i;:::-;1599:564;;1520:643;;;:::o;1052:462::-;1120:14;;;;1112:50;;;;-1:-1:-1;;;1112:50:11;;10995:2:16;1112:50:11;;;10977:21:16;11034:2;11014:18;;;11007:30;11073:25;11053:18;;;11046:53;11116:18;;1112:50:11;10793:347:16;1112:50:11;1172:14;2633:12:4;;1172:30:11;;1260:8;;1220:36;1252:3;1220:13;:27;1234:12;657:10:1;;584:87;1220:36:11;:48;;1212:88;;;;-1:-1:-1;;;1212:88:11;;9284:2:16;1212:88:11;;;9266:21:16;9323:2;9303:18;;;9296:30;9362:29;9342:18;;;9335:57;9409:18;;1212:88:11;9082:351:16;1212:88:11;1337:10;;1318:15;:6;1329:3;1318:10;:15::i;:::-;:29;;1310:54;;;;-1:-1:-1;;;1310:54:11;;9874:2:16;1310:54:11;;;9856:21:16;9913:2;9893:18;;;9886:30;-1:-1:-1;;;9932:18:16;;;9925:42;9984:18;;1310:54:11;9672:336:16;1310:54:11;1401:5;;1395:11;;:3;:11;:::i;:::-;1382:9;:24;;1374:50;;;;-1:-1:-1;;;1374:50:11;;10520:2:16;1374:50:11;;;10502:21:16;10559:2;10539:18;;;10532:30;-1:-1:-1;;;10578:18:16;;;10571:43;10631:18;;1374:50:11;10318:337:16;1374:50:11;657:10:1;1435:27:11;;;;:13;:27;;;;;:34;;1466:3;;1435:27;:34;;1466:3;;1435:34;:::i;:::-;;;;-1:-1:-1;1479:28:11;;-1:-1:-1;657:10:1;1503:3:11;1479:9;:28::i;:::-;1102:412;1052:462;:::o;3196:825:4:-;3301:7;3340:16;3350:5;3340:9;:16::i;:::-;3332:5;:24;3324:71;;;;-1:-1:-1;;;3324:71:4;;11347:2:16;3324:71:4;;;11329:21:16;11386:2;11366:18;;;11359:30;11425:34;11405:18;;;11398:62;-1:-1:-1;;;11476:18:16;;;11469:32;11518:19;;3324:71:4;11145:398:16;3324:71:4;3405:22;2633:12;;;3405:22;;3534:415;3558:14;3554:1;:18;3534:415;;;3593:31;3627:14;;;:11;:14;;;;;;;;;3593:48;;;;;;;;;-1:-1:-1;;;;;3593:48:4;;;;;-1:-1:-1;;;3593:48:4;;;;;;;;;;;;3659:28;3655:101;;3727:14;;;-1:-1:-1;3655:101:4;3794:5;-1:-1:-1;;;;;3773:26:4;:17;-1:-1:-1;;;;;3773:26:4;;3769:170;;;3838:5;3823:11;:20;3819:75;;;-1:-1:-1;3874:1:4;-1:-1:-1;3867:8:4;;-1:-1:-1;;;3867:8:4;3819:75;3911:13;;;;:::i;:::-;;;;3769:170;-1:-1:-1;3574:3:4;;;;:::i;:::-;;;;3534:415;;;-1:-1:-1;3958:56:4;;-1:-1:-1;;;3958:56:4;;11890:2:16;3958:56:4;;;11872:21:16;11929:2;11909:18;;;11902:30;11968:34;11948:18;;;11941:62;-1:-1:-1;;;12019:18:16;;;12012:44;12073:19;;3958:56:4;11688:410:16;2392:103:11;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;2447:8:11::1;::::0;2439:49:::1;::::0;-1:-1:-1;;;;;2447:8:11;;::::1;::::0;2466:21:::1;2439:49:::0;::::1;;;::::0;2447:8:::1;2439:49:::0;2447:8;2439:49;2466:21;2447:8;2439:49;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;2392:103::o:0;8563:171:4:-;8688:39;8705:4;8711:2;8715:7;8688:39;;;;;;;;;;;;:16;:39::i;2722:184::-;2789:7;2633:12;;2816:5;:21;2808:69;;;;-1:-1:-1;;;2808:69:4;;12666:2:16;2808:69:4;;;12648:21:16;12705:2;12685:18;;;12678:30;12744:34;12724:18;;;12717:62;-1:-1:-1;;;12795:18:16;;;12788:33;12838:19;;2808:69:4;12464:399:16;2808:69:4;-1:-1:-1;2894:5:4;2722:184::o;2287:99:11:-;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;2357:22:11;;::::1;::::0;:12:::1;::::0;:22:::1;::::0;::::1;::::0;::::1;:::i;5712:122:4:-:0;5776:7;5802:20;5814:7;5802:11;:20::i;:::-;:25;;5712:122;-1:-1:-1;;5712:122:4:o;2875:184:11:-;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;2972:13:11::1;:30:::0;;;;3012:18:::1;:40:::0;2875:184::o;4517:218:4:-;4581:7;-1:-1:-1;;;;;4608:19:4;;4600:75;;;;-1:-1:-1;;;4600:75:4;;13070:2:16;4600:75:4;;;13052:21:16;13109:2;13089:18;;;13082:30;13148:34;13128:18;;;13121:62;-1:-1:-1;;;13199:18:16;;;13192:41;13250:19;;4600:75:4;12868:407:16;4600:75:4;-1:-1:-1;;;;;;4700:19:4;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;4700:27:4;;4517:218::o;1499:83:13:-;993:6;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;1557:21:::1;1575:1;1557:9;:21::i;:::-;1499:83::o:0;3065:84:11:-;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;3128:5:11::1;:14:::0;3065:84::o;6054:102:4:-;6110:13;6142:7;6135:14;;;;;:::i;7750:283::-;-1:-1:-1;;;;;7844:24:4;;657:10:1;7844:24:4;;7836:63;;;;-1:-1:-1;;;7836:63:4;;13482:2:16;7836:63:4;;;13464:21:16;13521:2;13501:18;;;13494:30;13560:28;13540:18;;;13533:56;13606:18;;7836:63:4;13280:350:16;7836:63:4;657:10:1;7910:32:4;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;7910:42:4;;;;;;;;;;;;:53;;-1:-1:-1;;7910:53:4;;;;;;;;;;7978:48;;540:41:16;;;7910:42:4;;657:10:1;7978:48:4;;513:18:16;7978:48:4;;;;;;;7750:283;;:::o;8798:344::-;8951:28;8961:4;8967:2;8971:7;8951:9;:28::i;:::-;9010:48;9033:4;9039:2;9043:7;9052:5;9010:22;:48::i;:::-;8989:146;;;;-1:-1:-1;;;8989:146:4;;;;;;;:::i;:::-;8798:344;;;;:::o;3155:183:11:-;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;3271:10:11::1;:23:::0;;;;3304:8:::1;:27:::0;3155:183::o;6220:411:4:-;6313:13;6363:16;6371:7;9435:4;9468:12;-1:-1:-1;9458:22:4;9378:109;6363:16;6342:110;;;;-1:-1:-1;;;6342:110:4;;14257:2:16;6342:110:4;;;14239:21:16;14296:2;14276:18;;;14269:30;14335:34;14315:18;;;14308:62;-1:-1:-1;;;14386:18:16;;;14379:45;14441:19;;6342:110:4;14055:411:16;6342:110:4;6463:21;6487:10;:8;:10::i;:::-;6463:34;;6546:1;6528:7;6522:21;:25;:102;;;;;;;;;;;;;;;;;6582:7;6591:18;:7;:16;:18::i;:::-;6565:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6522:102;6507:117;6220:411;-1:-1:-1;;;6220:411:4:o;2773:96:11:-;993:6:13;;2823:7:11;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;-1:-1:-1;2849:13:11::1;::::0;2773:96;:::o;2501:164::-;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;2586:14:11::1;:28:::0;;-1:-1:-1;;2624:34:11;2586:28;::::1;;-1:-1:-1::0;;2624:34:11;;;;;2586:28:::1;2624:34:::0;::::1;;::::0;;;::::1;;::::0;;2501:164::o;2671:96::-;993:6:13;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;2740:8:11::1;:20:::0;;-1:-1:-1;;;;;;2740:20:11::1;-1:-1:-1::0;;;;;2740:20:11;;;::::1;::::0;;;::::1;::::0;;2671:96::o;1716:174:13:-;993:6;;-1:-1:-1;;;;;993:6:13;657:10:1;1112:23:13;1104:68;;;;-1:-1:-1;;;1104:68:13;;;;;;;:::i;:::-;-1:-1:-1;;;;;1798:22:13;::::1;1790:73;;;::::0;-1:-1:-1;;;1790:73:13;;15148:2:16;1790:73:13::1;::::0;::::1;15130:21:16::0;15187:2;15167:18;;;15160:30;15226:34;15206:18;;;15199:62;-1:-1:-1;;;15277:18:16;;;15270:36;15323:19;;1790:73:13::1;14946:402:16::0;1790:73:13::1;1867:19;1877:8;1867:9;:19::i;13281:189:4:-:0;13391:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;13391:29:4;-1:-1:-1;;;;;13391:29:4;;;;;;;;;13435:28;;13391:24;;13435:28;;;;;;;13281:189;;;:::o;11520:1656::-;11630:35;11668:20;11680:7;11668:11;:20::i;:::-;11741:18;;11630:58;;-1:-1:-1;11699:22:4;;-1:-1:-1;;;;;11725:34:4;657:10:1;-1:-1:-1;;;;;11725:34:4;;:82;;;-1:-1:-1;657:10:1;11771:20:4;11783:7;11771:11;:20::i;:::-;-1:-1:-1;;;;;11771:36:4;;11725:82;:144;;;-1:-1:-1;11836:18:4;;11819:50;;657:10:1;8097:186:4;:::i;11819:50::-;11699:171;;11902:17;11881:114;;;;-1:-1:-1;;;11881:114:4;;15555:2:16;11881:114:4;;;15537:21:16;15594:2;15574:18;;;15567:30;15633:34;15613:18;;;15606:62;-1:-1:-1;;;15684:18:16;;;15677:48;15742:19;;11881:114:4;15353:414:16;11881:114:4;12049:4;-1:-1:-1;;;;;12027:26:4;:13;:18;;;-1:-1:-1;;;;;12027:26:4;;12006:111;;;;-1:-1:-1;;;12006:111:4;;15974:2:16;12006:111:4;;;15956:21:16;16013:2;15993:18;;;15986:30;16052:34;16032:18;;;16025:62;-1:-1:-1;;;16103:18:16;;;16096:36;16149:19;;12006:111:4;15772:402:16;12006:111:4;-1:-1:-1;;;;;12135:16:4;;12127:66;;;;-1:-1:-1;;;12127:66:4;;16381:2:16;12127:66:4;;;16363:21:16;16420:2;16400:18;;;16393:30;16459:34;16439:18;;;16432:62;-1:-1:-1;;;16510:18:16;;;16503:35;16555:19;;12127:66:4;16179:401:16;12127:66:4;12309:49;12326:1;12330:7;12339:13;:18;;;12309:8;:49::i;:::-;-1:-1:-1;;;;;12369:18:4;;;;;;:12;:18;;;;;:31;;12399:1;;12369:18;:31;;12399:1;;-1:-1:-1;;;;;12369:31:4;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;12369:31:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;12410:16:4;;-1:-1:-1;12410:16:4;;;:12;:16;;;;;:29;;-1:-1:-1;;;12410:16:4;;:29;;-1:-1:-1;;12410:29:4;;:::i;:::-;;;-1:-1:-1;;;;;12410:29:4;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12472:43:4;;;;;;;;-1:-1:-1;;;;;12472:43:4;;;;;;12498:15;12472:43;;;;;;;;;-1:-1:-1;12449:20:4;;;:11;:20;;;;;;:66;;;;;;;;;-1:-1:-1;;;12449:66:4;-1:-1:-1;;;;;;12449:66:4;;;;;;;;;;;12773:11;12461:7;-1:-1:-1;12773:11:4;:::i;:::-;12839:1;12798:24;;;:11;:24;;;;;:29;12751:33;;-1:-1:-1;;;;;;12798:29:4;12794:281;;12861:20;12869:11;9435:4;9468:12;-1:-1:-1;9458:22:4;9378:109;12861:20;12857:208;;;12928:122;;;;;;;;12964:18;;-1:-1:-1;;;;;12928:122:4;;;;;;13004:28;;;;12928:122;;;;;;;;;;-1:-1:-1;12901:24:4;;;:11;:24;;;;;;;:149;;;;;;;;;-1:-1:-1;;;12901:149:4;-1:-1:-1;;;;;;12901:149:4;;;;;;;;;;;;12857:208;13109:7;13105:2;-1:-1:-1;;;;;13090:27:4;13099:4;-1:-1:-1;;;;;13090:27:4;;;;;;;;;;;13127:42;11620:1556;;;11520:1656;;;:::o;2330:87:14:-;2388:7;2408:5;2412:1;2408;:5;:::i;1154:184:12:-;1275:4;1327;1298:25;1311:5;1318:4;1298:12;:25::i;:::-;:33;;1154:184;-1:-1:-1;;;;1154:184:12:o;9493:102:4:-;9561:27;9571:2;9575:8;9561:27;;;;;;;;;;;;:9;:27::i;5007:650::-;-1:-1:-1;;;;;;;;;;;;;;;;;5125:16:4;5133:7;9435:4;9468:12;-1:-1:-1;9458:22:4;9378:109;5125:16;5117:71;;;;-1:-1:-1;;;5117:71:4;;17296:2:16;5117:71:4;;;17278:21:16;17335:2;17315:18;;;17308:30;17374:34;17354:18;;;17347:62;-1:-1:-1;;;17425:18:16;;;17418:40;17475:19;;5117:71:4;17094:406:16;5117:71:4;5199:26;5250:12;5239:7;:23;5235:101;;5299:22;5309:12;5299:7;:22;:::i;:::-;:26;;5324:1;5299:26;:::i;:::-;5278:47;;5235:101;5366:7;5346:237;5383:18;5375:4;:26;5346:237;;5425:31;5459:17;;;:11;:17;;;;;;;;;5425:51;;;;;;;;;-1:-1:-1;;;;;5425:51:4;;;;;-1:-1:-1;;;5425:51:4;;;;;;;;;;;;5494:28;5490:83;;5549:9;5007:650;-1:-1:-1;;;;5007:650:4:o;5490:83::-;-1:-1:-1;5403:6:4;;;;:::i;:::-;;;;5346:237;;;-1:-1:-1;5593:57:4;;-1:-1:-1;;;5593:57:4;;17978:2:16;5593:57:4;;;17960:21:16;18017:2;17997:18;;;17990:30;18056:34;18036:18;;;18029:62;-1:-1:-1;;;18107:18:16;;;18100:45;18162:19;;5593:57:4;17776:411:16;1893:148:13;1961:6;;;-1:-1:-1;;;;;1971:17:13;;;-1:-1:-1;;;;;;1971:17:13;;;;;;;1997:40;;1961:6;;;1971:17;1961:6;;1997:40;;1942:16;;1997:40;1938:103;1893:148;:::o;15093:807:4:-;15243:4;-1:-1:-1;;;;;15263:13:4;;941:20:0;975:8;15259:635:4;;15310:72;;-1:-1:-1;;;15310:72:4;;-1:-1:-1;;;;;15310:36:4;;;;;:72;;657:10:1;;15361:4:4;;15367:7;;15376:5;;15310:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15310:72:4;;;;;;;;-1:-1:-1;;15310:72:4;;;;;;;;;;;;:::i;:::-;;;15294:548;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15565:13:4;;15561:267;;15607:61;;-1:-1:-1;;;15607:61:4;;;;;;;:::i;15561:267::-;15780:6;15774:13;15765:6;15761:2;15757:15;15750:38;15294:548;-1:-1:-1;;;;;;15444:55:4;-1:-1:-1;;;15444:55:4;;-1:-1:-1;15437:62:4;;15259:635;-1:-1:-1;15879:4:4;15259:635;15093:807;;;;;;:::o;2170:111:11:-;2230:13;2262:12;2255:19;;;;;:::i;260:574:15:-;316:13;515:10;511:36;;-1:-1:-1;;532:10:15;;;;;;;;;;;;-1:-1:-1;;;532:10:15;;;;;260:574::o;511:36::-;565:5;550:12;592:51;599:9;;592:51;;615:8;;;;:::i;:::-;;-1:-1:-1;628:10:15;;-1:-1:-1;636:2:15;628:10;;:::i;:::-;;;592:51;;;646:19;678:6;668:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;668:17:15;;646:39;;689:117;696:10;;689:117;;713:11;723:1;713:11;;:::i;:::-;;-1:-1:-1;772:10:15;780:2;772:5;:10;:::i;:::-;759:24;;:2;:24;:::i;:::-;746:39;;729:6;736;729:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;729:56:15;;;;;;;;-1:-1:-1;790:11:15;799:2;790:11;;:::i;:::-;;;689:117;;1689:662:12;1772:7;1814:4;1772:7;1828:488;1852:5;:12;1848:1;:16;1828:488;;;1885:20;1908:5;1914:1;1908:8;;;;;;;;:::i;:::-;;;;;;;1885:31;;1950:12;1934;:28;1930:376;;2425:13;2473:15;;;2508:4;2501:15;;;2554:4;2538:21;;2060:57;;1930:376;;;2425:13;2473:15;;;2508:4;2501:15;;;2554:4;2538:21;;2234:57;;1930:376;-1:-1:-1;1866:3:12;;;;:::i;:::-;;;;1828:488;;;-1:-1:-1;2332:12:12;1689:662;-1:-1:-1;;;1689:662:12:o;9927:1367:4:-;10045:20;10068:12;-1:-1:-1;;;;;10098:16:4;;10090:62;;;;-1:-1:-1;;;10090:62:4;;19648:2:16;10090:62:4;;;19630:21:16;19687:2;19667:18;;;19660:30;19726:34;19706:18;;;19699:62;-1:-1:-1;;;19777:18:16;;;19770:31;19818:19;;10090:62:4;19446:397:16;10090:62:4;10295:21;10303:12;9435:4;9468:12;-1:-1:-1;9458:22:4;9378:109;10295:21;10294:22;10286:64;;;;-1:-1:-1;;;10286:64:4;;20050:2:16;10286:64:4;;;20032:21:16;20089:2;20069:18;;;20062:30;20128:31;20108:18;;;20101:59;20177:18;;10286:64:4;19848:353:16;10286:64:4;10380:12;10368:8;:24;;10360:71;;;;-1:-1:-1;;;10360:71:4;;20408:2:16;10360:71:4;;;20390:21:16;20447:2;20427:18;;;20420:30;20486:34;20466:18;;;20459:62;-1:-1:-1;;;20537:18:16;;;20530:32;20579:19;;10360:71:4;20206:398:16;10360:71:4;-1:-1:-1;;;;;10547:16:4;;10514:30;10547:16;;;:12;:16;;;;;;;;;10514:49;;;;;;;;;-1:-1:-1;;;;;10514:49:4;;;;;-1:-1:-1;;;10514:49:4;;;;;;;;;;;10592:132;;;;;;;;10617:19;;10514:49;;10592:132;;;10617:39;;10647:8;;10617:39;:::i;:::-;-1:-1:-1;;;;;10592:132:4;;;;;10705:8;10670:11;:24;;;:44;;;;:::i;:::-;-1:-1:-1;;;;;10592:132:4;;;;;;-1:-1:-1;;;;;10573:16:4;;;;;;;:12;:16;;;;;;;;:151;;;;;;;;-1:-1:-1;;;10573:151:4;;;;;;;;;;;;10762:43;;;;;;;;;;;10788:15;10762:43;;;;;;;;10734:25;;;:11;:25;;;;;;:71;;;;;;;;;-1:-1:-1;;;10734:71:4;-1:-1:-1;;;;;;10734:71:4;;;;;;;;;;;;;;;;;;10746:12;;10862:318;10886:8;10882:1;:12;10862:318;;;10920:38;;10945:12;;-1:-1:-1;;;;;10920:38:4;;;10937:1;;10920:38;;10937:1;;10920:38;10997:59;11028:1;11032:2;11036:12;11050:5;10997:22;:59::i;:::-;10972:169;;;;-1:-1:-1;;;10972:169:4;;;;;;;:::i;:::-;11155:14;;;;:::i;:::-;;;;10896:3;;;;;:::i;:::-;;;;10862:318;;;-1:-1:-1;11190:12:4;:27;;;11227:60;8798:344;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:131:16;-1:-1:-1;;;;;;88:32:16;;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:16;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:16;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:16: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:16;;1343:180;-1:-1:-1;1343:180:16:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:16;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:16:o;2355:328::-;2432:6;2440;2448;2501:2;2489:9;2480:7;2476:23;2472:32;2469:52;;;2517:1;2514;2507:12;2469:52;2540:29;2559:9;2540:29;:::i;:::-;2530:39;;2588:38;2622:2;2611:9;2607:18;2588:38;:::i;:::-;2578:48;;2673:2;2662:9;2658:18;2645:32;2635:42;;2355:328;;;;;:::o;2688:689::-;2783:6;2791;2799;2852:2;2840:9;2831:7;2827:23;2823:32;2820:52;;;2868:1;2865;2858:12;2820:52;2908:9;2895:23;2937:18;2978:2;2970:6;2967:14;2964:34;;;2994:1;2991;2984:12;2964:34;3032:6;3021:9;3017:22;3007:32;;3077:7;3070:4;3066:2;3062:13;3058:27;3048:55;;3099:1;3096;3089:12;3048:55;3139:2;3126:16;3165:2;3157:6;3154:14;3151:34;;;3181:1;3178;3171:12;3151:34;3236:7;3229:4;3219:6;3216:1;3212:14;3208:2;3204:23;3200:34;3197:47;3194:67;;;3257:1;3254;3247:12;3194:67;3288:4;3280:13;;;;3312:6;;-1:-1:-1;3350:20:16;;;;3337:34;;2688:689;-1:-1:-1;;;;2688:689:16:o;3382:127::-;3443:10;3438:3;3434:20;3431:1;3424:31;3474:4;3471:1;3464:15;3498:4;3495:1;3488:15;3514:632;3579:5;3609:18;3650:2;3642:6;3639:14;3636:40;;;3656:18;;:::i;:::-;3731:2;3725:9;3699:2;3785:15;;-1:-1:-1;;3781:24:16;;;3807:2;3777:33;3773:42;3761:55;;;3831:18;;;3851:22;;;3828:46;3825:72;;;3877:18;;:::i;:::-;3917:10;3913:2;3906:22;3946:6;3937:15;;3976:6;3968;3961:22;4016:3;4007:6;4002:3;3998:16;3995:25;3992:45;;;4033:1;4030;4023:12;3992:45;4083:6;4078:3;4071:4;4063:6;4059:17;4046:44;4138:1;4131:4;4122:6;4114;4110:19;4106:30;4099:41;;;;3514:632;;;;;:::o;4151:451::-;4220:6;4273:2;4261:9;4252:7;4248:23;4244:32;4241:52;;;4289:1;4286;4279:12;4241:52;4329:9;4316:23;4362:18;4354:6;4351:30;4348:50;;;4394:1;4391;4384:12;4348:50;4417:22;;4470:4;4462:13;;4458:27;-1:-1:-1;4448:55:16;;4499:1;4496;4489:12;4448:55;4522:74;4588:7;4583:2;4570:16;4565:2;4561;4557:11;4522:74;:::i;4607:248::-;4675:6;4683;4736:2;4724:9;4715:7;4711:23;4707:32;4704:52;;;4752:1;4749;4742:12;4704:52;-1:-1:-1;;4775:23:16;;;4845:2;4830:18;;;4817:32;;-1:-1:-1;4607:248:16:o;4860:186::-;4919:6;4972:2;4960:9;4951:7;4947:23;4943:32;4940:52;;;4988:1;4985;4978:12;4940:52;5011:29;5030:9;5011:29;:::i;5051:160::-;5116:20;;5172:13;;5165:21;5155:32;;5145:60;;5201:1;5198;5191:12;5216:254;5281:6;5289;5342:2;5330:9;5321:7;5317:23;5313:32;5310:52;;;5358:1;5355;5348:12;5310:52;5381:29;5400:9;5381:29;:::i;:::-;5371:39;;5429:35;5460:2;5449:9;5445:18;5429:35;:::i;:::-;5419:45;;5216:254;;;;;:::o;5475:667::-;5570:6;5578;5586;5594;5647:3;5635:9;5626:7;5622:23;5618:33;5615:53;;;5664:1;5661;5654:12;5615:53;5687:29;5706:9;5687:29;:::i;:::-;5677:39;;5735:38;5769:2;5758:9;5754:18;5735:38;:::i;:::-;5725:48;;5820:2;5809:9;5805:18;5792:32;5782:42;;5875:2;5864:9;5860:18;5847:32;5902:18;5894:6;5891:30;5888:50;;;5934:1;5931;5924:12;5888:50;5957:22;;6010:4;6002:13;;5998:27;-1:-1:-1;5988:55:16;;6039:1;6036;6029:12;5988:55;6062:74;6128:7;6123:2;6110:16;6105:2;6101;6097:11;6062:74;:::i;:::-;6052:84;;;5475:667;;;;;;;:::o;6582:248::-;6644:6;6652;6705:2;6693:9;6684:7;6680:23;6676:32;6673:52;;;6721:1;6718;6711:12;6673:52;6744:26;6760:9;6744:26;:::i;6835:260::-;6903:6;6911;6964:2;6952:9;6943:7;6939:23;6935:32;6932:52;;;6980:1;6977;6970:12;6932:52;7003:29;7022:9;7003:29;:::i;:::-;6993:39;;7051:38;7085:2;7074:9;7070:18;7051:38;:::i;7100:380::-;7179:1;7175:12;;;;7222;;;7243:61;;7297:4;7289:6;7285:17;7275:27;;7243:61;7350:2;7342:6;7339:14;7319:18;7316:38;7313:161;;;7396:10;7391:3;7387:20;7384:1;7377:31;7431:4;7428:1;7421:15;7459:4;7456:1;7449:15;7313:161;;7100:380;;;:::o;10013:127::-;10074:10;10069:3;10065:20;10062:1;10055:31;10105:4;10102:1;10095:15;10129:4;10126:1;10119:15;10145:168;10185:7;10251:1;10247;10243:6;10239:14;10236:1;10233:21;10228:1;10221:9;10214:17;10210:45;10207:71;;;10258:18;;:::i;:::-;-1:-1:-1;10298:9:16;;10145:168::o;10660:128::-;10700:3;10731:1;10727:6;10724:1;10721:13;10718:39;;;10737:18;;:::i;:::-;-1:-1:-1;10773:9:16;;10660:128::o;11548:135::-;11587:3;-1:-1:-1;;11608:17:16;;11605:43;;;11628:18;;:::i;:::-;-1:-1:-1;11675:1:16;11664:13;;11548:135::o;12103:356::-;12305:2;12287:21;;;12324:18;;;12317:30;12383:34;12378:2;12363:18;;12356:62;12450:2;12435:18;;12103:356::o;13635:415::-;13837:2;13819:21;;;13876:2;13856:18;;;13849:30;13915:34;13910:2;13895:18;;13888:62;-1:-1:-1;;;13981:2:16;13966:18;;13959:49;14040:3;14025:19;;13635:415::o;14471:470::-;14650:3;14688:6;14682:13;14704:53;14750:6;14745:3;14738:4;14730:6;14726:17;14704:53;:::i;:::-;14820:13;;14779:16;;;;14842:57;14820:13;14779:16;14876:4;14864:17;;14842:57;:::i;:::-;14915:20;;14471:470;-1:-1:-1;;;;14471:470:16:o;16585:246::-;16625:4;-1:-1:-1;;;;;16738:10:16;;;;16708;;16760:12;;;16757:38;;;16775:18;;:::i;:::-;16812:13;;16585:246;-1:-1:-1;;;16585:246:16:o;16836:253::-;16876:3;-1:-1:-1;;;;;16965:2:16;16962:1;16958:10;16995:2;16992:1;16988:10;17026:3;17022:2;17018:12;17013:3;17010:21;17007:47;;;17034:18;;:::i;17505:125::-;17545:4;17573:1;17570;17567:8;17564:34;;;17578:18;;:::i;:::-;-1:-1:-1;17615:9:16;;17505:125::o;17635:136::-;17674:3;17702:5;17692:39;;17711:18;;:::i;:::-;-1:-1:-1;;;17747:18:16;;17635:136::o;18192:489::-;-1:-1:-1;;;;;18461:15:16;;;18443:34;;18513:15;;18508:2;18493:18;;18486:43;18560:2;18545:18;;18538:34;;;18608:3;18603:2;18588:18;;18581:31;;;18386:4;;18629:46;;18655:19;;18647:6;18629:46;:::i;:::-;18621:54;18192:489;-1:-1:-1;;;;;;18192:489:16:o;18686:249::-;18755:6;18808:2;18796:9;18787:7;18783:23;18779:32;18776:52;;;18824:1;18821;18814:12;18776:52;18856:9;18850:16;18875:30;18899:5;18875:30;:::i;18940:127::-;19001:10;18996:3;18992:20;18989:1;18982:31;19032:4;19029:1;19022:15;19056:4;19053:1;19046:15;19072:120;19112:1;19138;19128:35;;19143:18;;:::i;:::-;-1:-1:-1;19177:9:16;;19072:120::o;19197:112::-;19229:1;19255;19245:35;;19260:18;;:::i;:::-;-1:-1:-1;19294:9:16;;19197:112::o;19314:127::-;19375:10;19370:3;19366:20;19363:1;19356:31;19406:4;19403:1;19396:15;19430:4;19427:1;19420:15

ipfs://f320eb73228c83f5002fe0cc949ff92932ed3da5bc9ce9a3214f132fead120f9