{"Address.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Collection of functions related to the address type\r\n */\r\nlibrary Address {\r\n    /**\r\n     * @dev Returns true if `account` is a contract.\r\n     *\r\n     * [IMPORTANT]\r\n     * ====\r\n     * It is unsafe to assume that an address for which this function returns\r\n     * false is an externally-owned account (EOA) and not a contract.\r\n     *\r\n     * Among others, `isContract` will return false for the following\r\n     * types of addresses:\r\n     *\r\n     *  - an externally-owned account\r\n     *  - a contract in construction\r\n     *  - an address where a contract will be created\r\n     *  - an address where a contract lived, but was destroyed\r\n     * ====\r\n     */\r\n    function isContract(address account) internal view returns (bool) {\r\n        // This method relies on extcodesize, which returns 0 for contracts in\r\n        // construction, since the code is only stored at the end of the\r\n        // constructor execution.\r\n\r\n        uint256 size;\r\n        assembly {\r\n            size := extcodesize(account)\r\n        }\r\n        return size \u003e 0;\r\n    }\r\n\r\n    /**\r\n     * @dev Replacement for Solidity\u0027s `transfer`: sends `amount` wei to\r\n     * `recipient`, forwarding all available gas and reverting on errors.\r\n     *\r\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\r\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\r\n     * imposed by `transfer`, making them unable to receive funds via\r\n     * `transfer`. {sendValue} removes this limitation.\r\n     *\r\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\r\n     *\r\n     * IMPORTANT: because control is transferred to `recipient`, care must be\r\n     * taken to not create reentrancy vulnerabilities. Consider using\r\n     * {ReentrancyGuard} or the\r\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\r\n     */\r\n    function sendValue(address payable recipient, uint256 amount) internal {\r\n        require(address(this).balance \u003e= amount, \"Address: insufficient balance\");\r\n\r\n        (bool success, ) = recipient.call{value: amount}(\"\");\r\n        require(success, \"Address: unable to send value, recipient may have reverted\");\r\n    }\r\n\r\n    /**\r\n     * @dev Performs a Solidity function call using a low level `call`. A\r\n     * plain `call` is an unsafe replacement for a function call: use this\r\n     * function instead.\r\n     *\r\n     * If `target` reverts with a revert reason, it is bubbled up by this\r\n     * function (like regular Solidity function calls).\r\n     *\r\n     * Returns the raw returned data. To convert to the expected return value,\r\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `target` must be a contract.\r\n     * - calling `target` with `data` must not revert.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionCall(target, data, \"Address: low-level call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\r\n     * `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, 0, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but also transferring `value` wei to `target`.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the calling contract must have an ETH balance of at least `value`.\r\n     * - the called Solidity function must be `payable`.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value\r\n    ) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\r\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(address(this).balance \u003e= value, \"Address: insufficient balance for call\");\r\n        require(isContract(target), \"Address: call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\r\n        return _verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal view returns (bytes memory) {\r\n        require(isContract(target), \"Address: static call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.staticcall(data);\r\n        return _verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(isContract(target), \"Address: delegate call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.delegatecall(data);\r\n        return _verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    function _verifyCallResult(\r\n        bool success,\r\n        bytes memory returndata,\r\n        string memory errorMessage\r\n    ) private pure returns (bytes memory) {\r\n        if (success) {\r\n            return returndata;\r\n        } else {\r\n            // Look for revert reason and bubble it up if present\r\n            if (returndata.length \u003e 0) {\r\n                // The easiest way to bubble the revert reason is using memory via assembly\r\n\r\n                assembly {\r\n                    let returndata_size := mload(returndata)\r\n                    revert(add(32, returndata), returndata_size)\r\n                }\r\n            } else {\r\n                revert(errorMessage);\r\n            }\r\n        }\r\n    }\r\n}"},"ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IERC165.sol\";\r\n\r\n/**\r\n * @dev Implementation of the {IERC165} interface.\r\n *\r\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\r\n * for the additional interface id that will be supported. For example:\r\n *\r\n * ```solidity\r\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\r\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\r\n * }\r\n * ```\r\n *\r\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\r\n */\r\nabstract contract ERC165 is IERC165 {\r\n    /**\r\n     * @dev See {IERC165-supportsInterface}.\r\n     */\r\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\r\n        return interfaceId == type(IERC165).interfaceId;\r\n    }\r\n}"},"Gaoqiqiang.sol":{"content":"// SPDX-License-Identifier: MIT\r\n/*\r\n\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\r\n\\\\                                                                                                                                                             \\\\\r\n\\\\                                                                     \\\\\\\\                                                                                     \\\\\r\n\\\\                                                                      \\\\\\\\                                                                                    \\\\\r\n\\\\                                                       ||||||||||||||||||||||||||||||||||                                                                    \\\\\r\n\\\\                                                                                                                                                             \\\\\r\n\\\\                                                                |||||||||||||||||                                                                            \\\\\r\n\\\\                                                                ||             ||                                                                            \\\\\r\n\\\\                                                                ||             ||                                                                            \\\\\r\n\\\\                                                                ||             ||                                                                            \\\\\r\n\\\\                                                                |||||||||||||||||                                                                            \\\\\r\n\\\\                                                                                                                                                             \\\\ \r\n\\\\                                                   |||||||||||||||||||||||||||||||||||||||||||                                                               \\\\\r\n\\\\                                                   ||                                       ||                                                               \\\\\r\n\\\\                                                   ||                                       ||                                                               \\\\\r\n\\\\                                                   ||           |||||||||||||||||           ||                                                               \\\\\r\n\\\\                                                   ||           ||             ||           ||                                                               \\\\\r\n\\\\                                                   ||           ||             ||           ||                                                               \\\\\r\n\\\\                                                   ||           ||             ||           ||                                                               \\\\\r\n\\\\                                                   ||           |||||||||||||||||           ||                                                               \\\\\r\n\\\\                                                   ||                                       ||                                                               \\\\\r\n\\\\                                                   ||                                    \\\\ ||                                                               \\\\\r\n\\\\                                                   ||                                     \\\\||                                                               \\\\\r\n\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\r\n\r\n*/\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./Ownable.sol\";\r\nimport \"./IERC721.sol\";\r\nimport \"./Math.sol\";\r\nimport \"./QS721.sol\";\r\nimport \"./ERC165.sol\";\r\nimport \"./IERC165.sol\";\r\nimport \"./Address.sol\";\r\nimport \"./IERC721M.sol\";\r\nimport \"./IERC721R.sol\";\r\ncontract Gaoqiqiang is Ownable, ERC721A {\r\n\r\n  \r\n  uint256  allowListStartTime;\r\n  uint256  publicStartTime;\r\n  uint256  price = 7000000000000000;\r\n  \r\n  \r\n  mapping(address =\u003e bool) public allowlist;\r\n  mapping(address =\u003e uint256) public publicMintNum;\r\n\r\n  constructor(\r\n    uint256 collectionSize_\r\n  ) ERC721A(\"G\",collectionSize_){\r\n\r\n  }\r\n  modifier callerIsUser() {\r\n    require(tx.origin == msg.sender, \"The caller is another contract\");\r\n    _;\r\n  }\r\n\r\n  \r\n  function setAllowlist(address[] memory addresses)\r\n    external\r\n    onlyOwner\r\n  {\r\n    for (uint256 i = 0; i \u003c addresses.length; i++) {\r\n      allowlist[addresses[i]] = true;\r\n    }\r\n  }\r\n  function allowlistMint() external payable callerIsUser {\r\n    \r\n    require(allowlist[msg.sender] == true, \"not eligible for allowlist mint\");\r\n    require(totalSupply() + 1 \u003c= collectionSize, \"reached max supply\");\r\n    require(allowListStartTime \u003c= block.timestamp \u0026\u0026 allowListStartTime!=0,\"sale has not started yet\");\r\n    allowlist[msg.sender] = false;\r\n    _safeMint(msg.sender, 1);\r\n   \r\n  }\r\n\r\n\r\n  function publicSaleMint(uint8 quantity)\r\n    external\r\n    payable\r\n    callerIsUser\r\n  { \r\n    require(publicStartTime \u003c block.timestamp \u0026\u0026 publicStartTime != 0,\"not start \"); \r\n    require(totalSupply() + quantity \u003c= collectionSize, \"reached max supply\");\r\n    require(\r\n      publicMintNum[msg.sender] + quantity \u003c= 2,\r\n      \"can not mint this many\"\r\n    );\r\n    publicMintNum[msg.sender] = publicMintNum[msg.sender] + quantity;\r\n    uint256 totalprice;\r\n    totalprice = quantity * price;\r\n    _safeMint(msg.sender, quantity);\r\n    refundIfOver(totalprice);\r\n  }\r\n  function refundIfOver(uint256 cost) private {\r\n    require(msg.value \u003e= cost, \"Need to send more ETH.\");\r\n    if (msg.value \u003e cost) {\r\n      payable(msg.sender).transfer(msg.value - cost);\r\n   }\r\n  }\r\n  function setAllowListStartTime(\r\n    uint32 startTime_\r\n  ) external onlyOwner {\r\n    allowListStartTime =  startTime_;\r\n  }\r\n  function setPublicStartTime(\r\n    uint32 startTime_\r\n  ) external onlyOwner {\r\n    publicStartTime =  startTime_;\r\n  }\r\n\r\n \r\n\r\n\r\n\r\n  // // metadata URI\r\n  string private _baseTokenURI;\r\n\r\n \r\n  function _baseURI() internal view virtual override returns (string memory) {\r\n    return _baseTokenURI;\r\n  }\r\n\r\n  function setBaseURI(string calldata baseURI) external onlyOwner {\r\n    _baseTokenURI = baseURI;\r\n  }\r\n\r\n  function withdrawMoney() external onlyOwner {\r\n    (bool success, ) = msg.sender.call{value: address(this).balance}(\"\");\r\n    require(success, \"Transfer failed.\");\r\n  }\r\n\r\n\r\n  function getOwnershipData(uint256 tokenId)\r\n    external\r\n    view\r\n    returns (TokenOwnership memory)\r\n  {\r\n    return ownershipOf(tokenId);\r\n  }\r\n}"},"IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Interface of the ERC165 standard, as defined in the\r\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\r\n *\r\n * Implementers can declare support of contract interfaces, which can then be\r\n * queried by others ({ERC165Checker}).\r\n *\r\n * For an implementation, see {ERC165}.\r\n */\r\ninterface IERC165 {\r\n    /**\r\n     * @dev Returns true if this contract implements the interface defined by\r\n     * `interfaceId`. See the corresponding\r\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\r\n     * to learn more about how these ids are created.\r\n     *\r\n     * This function call must use less than 30 000 gas.\r\n     */\r\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\r\n}"},"IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IERC165.sol\";\r\n\r\n/**\r\n * @dev Required interface of an ERC721 compliant contract.\r\n */\r\ninterface IERC721 is IERC165 {\r\n    /**\r\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\r\n     */\r\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\r\n\r\n    /**\r\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\r\n     */\r\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\r\n\r\n    /**\r\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\r\n     */\r\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\r\n\r\n    /**\r\n     * @dev Returns the number of tokens in ``owner``\u0027s account.\r\n     */\r\n    function balanceOf(address owner) external view returns (uint256 balance);\r\n\r\n    /**\r\n     * @dev Returns the owner of the `tokenId` token.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `tokenId` must exist.\r\n     */\r\n    function ownerOf(uint256 tokenId) external view returns (address owner);\r\n\r\n    /**\r\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\r\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `from` cannot be the zero address.\r\n     * - `to` cannot be the zero address.\r\n     * - `tokenId` token must exist and be owned by `from`.\r\n     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\r\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function safeTransferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 tokenId\r\n    ) external;\r\n\r\n    /**\r\n     * @dev Transfers `tokenId` token from `from` to `to`.\r\n     *\r\n     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `from` cannot be the zero address.\r\n     * - `to` cannot be the zero address.\r\n     * - `tokenId` token must be owned by `from`.\r\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 tokenId\r\n    ) external;\r\n\r\n    /**\r\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\r\n     * The approval is cleared when the token is transferred.\r\n     *\r\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The caller must own the token or be an approved operator.\r\n     * - `tokenId` must exist.\r\n     *\r\n     * Emits an {Approval} event.\r\n     */\r\n    function approve(address to, uint256 tokenId) external;\r\n\r\n    /**\r\n     * @dev Returns the account approved for `tokenId` token.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `tokenId` must exist.\r\n     */\r\n    function getApproved(uint256 tokenId) external view returns (address operator);\r\n\r\n    /**\r\n     * @dev Approve or remove `operator` as an operator for the caller.\r\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The `operator` cannot be the caller.\r\n     *\r\n     * Emits an {ApprovalForAll} event.\r\n     */\r\n    function setApprovalForAll(address operator, bool _approved) external;\r\n\r\n    /**\r\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\r\n     *\r\n     * See {setApprovalForAll}\r\n     */\r\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\r\n\r\n    /**\r\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `from` cannot be the zero address.\r\n     * - `to` cannot be the zero address.\r\n     * - `tokenId` token must exist and be owned by `from`.\r\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\r\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function safeTransferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 tokenId,\r\n        bytes calldata data\r\n    ) external;\r\n}"},"IERC721M.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IERC721.sol\";\r\n\r\n/**\r\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\r\n * @dev See https://eips.ethereum.org/EIPS/eip-721\r\n */\r\ninterface IERC721Metadata is IERC721 {\r\n    /**\r\n     * @dev Returns the token collection name.\r\n     */\r\n    function name() external view returns (string memory);\r\n\r\n    /**\r\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\r\n     */\r\n    function tokenURI(uint256 tokenId) external view returns (string memory);\r\n}"},"IERC721R.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @title ERC721 token receiver interface\r\n * @dev Interface for any contract that wants to support safeTransfers\r\n * from ERC721 asset contracts.\r\n */\r\ninterface IERC721Receiver {\r\n    /**\r\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\r\n     * by `operator` from `from`, this function is called.\r\n     *\r\n     * It must return its Solidity selector to confirm the token transfer.\r\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\r\n     *\r\n     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\r\n     */\r\n    function onERC721Received(\r\n        address operator,\r\n        address from,\r\n        uint256 tokenId,\r\n        bytes calldata data\r\n    ) external returns (bytes4);\r\n}"},"Math.sol":{"content":"// SPDX-License-Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Standard math utilities missing in the Solidity language.\r\n */\r\nlibrary Math {\r\n    enum Rounding {\r\n        Down, // Toward negative infinity\r\n        Up, // Toward infinity\r\n        Zero // Toward zero\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the largest of two numbers.\r\n     */\r\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return a \u003e b ? a : b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the smallest of two numbers.\r\n     */\r\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return a \u003c b ? a : b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the average of two numbers. The result is rounded towards\r\n     * zero.\r\n     */\r\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        // (a + b) / 2 can overflow.\r\n        return (a \u0026 b) + (a ^ b) / 2;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the ceiling of the division of two numbers.\r\n     *\r\n     * This differs from standard division with `/` in that it rounds up instead\r\n     * of rounding down.\r\n     */\r\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        // (a + b - 1) / b can overflow on addition, so we distribute.\r\n        return a == 0 ? 0 : (a - 1) / b + 1;\r\n    }\r\n\r\n    /**\r\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\r\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\r\n     * with further edits by Uniswap Labs also under MIT license.\r\n     */\r\n    function mulDiv(\r\n        uint256 x,\r\n        uint256 y,\r\n        uint256 denominator\r\n    ) internal pure returns (uint256 result) {\r\n        unchecked {\r\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\r\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\r\n            // variables such that product = prod1 * 2^256 + prod0.\r\n            uint256 prod0; // Least significant 256 bits of the product\r\n            uint256 prod1; // Most significant 256 bits of the product\r\n            assembly {\r\n                let mm := mulmod(x, y, not(0))\r\n                prod0 := mul(x, y)\r\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\r\n            }\r\n\r\n            // Handle non-overflow cases, 256 by 256 division.\r\n            if (prod1 == 0) {\r\n                return prod0 / denominator;\r\n            }\r\n\r\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\r\n            require(denominator \u003e prod1);\r\n\r\n            ///////////////////////////////////////////////\r\n            // 512 by 256 division.\r\n            ///////////////////////////////////////////////\r\n\r\n            // Make division exact by subtracting the remainder from [prod1 prod0].\r\n            uint256 remainder;\r\n            assembly {\r\n                // Compute remainder using mulmod.\r\n                remainder := mulmod(x, y, denominator)\r\n\r\n                // Subtract 256 bit number from 512 bit number.\r\n                prod1 := sub(prod1, gt(remainder, prod0))\r\n                prod0 := sub(prod0, remainder)\r\n            }\r\n\r\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always \u003e= 1.\r\n            // See https://cs.stackexchange.com/q/138556/92363.\r\n\r\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\r\n            uint256 twos = denominator \u0026 (~denominator + 1);\r\n            assembly {\r\n                // Divide denominator by twos.\r\n                denominator := div(denominator, twos)\r\n\r\n                // Divide [prod1 prod0] by twos.\r\n                prod0 := div(prod0, twos)\r\n\r\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\r\n                twos := add(div(sub(0, twos), twos), 1)\r\n            }\r\n\r\n            // Shift in bits from prod1 into prod0.\r\n            prod0 |= prod1 * twos;\r\n\r\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\r\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\r\n            // four bits. That is, denominator * inv = 1 mod 2^4.\r\n            uint256 inverse = (3 * denominator) ^ 2;\r\n\r\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel\u0027s lifting lemma, this also works\r\n            // in modular arithmetic, doubling the correct bits in each step.\r\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\r\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\r\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\r\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\r\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\r\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\r\n\r\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\r\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\r\n            // less than 2^256, this is the final result. We don\u0027t need to compute the high bits of the result and prod1\r\n            // is no longer required.\r\n            result = prod0 * inverse;\r\n            return result;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\r\n     */\r\n    function mulDiv(\r\n        uint256 x,\r\n        uint256 y,\r\n        uint256 denominator,\r\n        Rounding rounding\r\n    ) internal pure returns (uint256) {\r\n        uint256 result = mulDiv(x, y, denominator);\r\n        if (rounding == Rounding.Up \u0026\u0026 mulmod(x, y, denominator) \u003e 0) {\r\n            result += 1;\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\r\n     *\r\n     * Inspired by Henry S. Warren, Jr.\u0027s \"Hacker\u0027s Delight\" (Chapter 11).\r\n     */\r\n    function sqrt(uint256 a) internal pure returns (uint256) {\r\n        if (a == 0) {\r\n            return 0;\r\n        }\r\n\r\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\r\n        //\r\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\r\n        // `msb(a) \u003c= a \u003c 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\r\n        //\r\n        // This can be rewritten `2**log2(a) \u003c= a \u003c 2**(log2(a) + 1)`\r\n        // → `sqrt(2**k) \u003c= sqrt(a) \u003c sqrt(2**(k+1))`\r\n        // → `2**(k/2) \u003c= sqrt(a) \u003c 2**((k+1)/2) \u003c= 2**(k/2 + 1)`\r\n        //\r\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\r\n        uint256 result = 1 \u003c\u003c (log2(a) \u003e\u003e 1);\r\n\r\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\r\n        // since it is the square root of a uint256. Newton\u0027s method converges quadratically (precision doubles at\r\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\r\n        // into the expected uint128 result.\r\n        unchecked {\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            result = (result + a / result) \u003e\u003e 1;\r\n            return min(result, a / result);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @notice Calculates sqrt(a), following the selected rounding direction.\r\n     */\r\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\r\n        unchecked {\r\n            uint256 result = sqrt(a);\r\n            return result + (rounding == Rounding.Up \u0026\u0026 result * result \u003c a ? 1 : 0);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Return the log in base 2, rounded down, of a positive value.\r\n     * Returns 0 if given 0.\r\n     */\r\n    function log2(uint256 value) internal pure returns (uint256) {\r\n        uint256 result = 0;\r\n        unchecked {\r\n            if (value \u003e\u003e 128 \u003e 0) {\r\n                value \u003e\u003e= 128;\r\n                result += 128;\r\n            }\r\n            if (value \u003e\u003e 64 \u003e 0) {\r\n                value \u003e\u003e= 64;\r\n                result += 64;\r\n            }\r\n            if (value \u003e\u003e 32 \u003e 0) {\r\n                value \u003e\u003e= 32;\r\n                result += 32;\r\n            }\r\n            if (value \u003e\u003e 16 \u003e 0) {\r\n                value \u003e\u003e= 16;\r\n                result += 16;\r\n            }\r\n            if (value \u003e\u003e 8 \u003e 0) {\r\n                value \u003e\u003e= 8;\r\n                result += 8;\r\n            }\r\n            if (value \u003e\u003e 4 \u003e 0) {\r\n                value \u003e\u003e= 4;\r\n                result += 4;\r\n            }\r\n            if (value \u003e\u003e 2 \u003e 0) {\r\n                value \u003e\u003e= 2;\r\n                result += 2;\r\n            }\r\n            if (value \u003e\u003e 1 \u003e 0) {\r\n                result += 1;\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\r\n     * Returns 0 if given 0.\r\n     */\r\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\r\n        unchecked {\r\n            uint256 result = log2(value);\r\n            return result + (rounding == Rounding.Up \u0026\u0026 1 \u003c\u003c result \u003c value ? 1 : 0);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Return the log in base 10, rounded down, of a positive value.\r\n     * Returns 0 if given 0.\r\n     */\r\n    function log10(uint256 value) internal pure returns (uint256) {\r\n        uint256 result = 0;\r\n        unchecked {\r\n            if (value \u003e= 10**64) {\r\n                value /= 10**64;\r\n                result += 64;\r\n            }\r\n            if (value \u003e= 10**32) {\r\n                value /= 10**32;\r\n                result += 32;\r\n            }\r\n            if (value \u003e= 10**16) {\r\n                value /= 10**16;\r\n                result += 16;\r\n            }\r\n            if (value \u003e= 10**8) {\r\n                value /= 10**8;\r\n                result += 8;\r\n            }\r\n            if (value \u003e= 10**4) {\r\n                value /= 10**4;\r\n                result += 4;\r\n            }\r\n            if (value \u003e= 10**2) {\r\n                value /= 10**2;\r\n                result += 2;\r\n            }\r\n            if (value \u003e= 10**1) {\r\n                result += 1;\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\r\n     * Returns 0 if given 0.\r\n     */\r\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\r\n        unchecked {\r\n            uint256 result = log10(value);\r\n            return result + (rounding == Rounding.Up \u0026\u0026 10**result \u003c value ? 1 : 0);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Return the log in base 256, rounded down, of a positive value.\r\n     * Returns 0 if given 0.\r\n     *\r\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\r\n     */\r\n    function log256(uint256 value) internal pure returns (uint256) {\r\n        uint256 result = 0;\r\n        unchecked {\r\n            if (value \u003e\u003e 128 \u003e 0) {\r\n                value \u003e\u003e= 128;\r\n                result += 16;\r\n            }\r\n            if (value \u003e\u003e 64 \u003e 0) {\r\n                value \u003e\u003e= 64;\r\n                result += 8;\r\n            }\r\n            if (value \u003e\u003e 32 \u003e 0) {\r\n                value \u003e\u003e= 32;\r\n                result += 4;\r\n            }\r\n            if (value \u003e\u003e 16 \u003e 0) {\r\n                value \u003e\u003e= 16;\r\n                result += 2;\r\n            }\r\n            if (value \u003e\u003e 8 \u003e 0) {\r\n                result += 1;\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\r\n     * Returns 0 if given 0.\r\n     */\r\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\r\n        unchecked {\r\n            uint256 result = log256(value);\r\n            return result + (rounding == Rounding.Up \u0026\u0026 1 \u003c\u003c (result * 8) \u003c value ? 1 : 0);\r\n        }\r\n    }\r\n}"},"Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\n/**\r\n * @dev Contract module which provides a basic access control mechanism, where\r\n * there is an account (an owner) that can be granted exclusive access to\r\n * specific functions.\r\n *\r\n * By default, the owner account will be the one that deploys the contract. This\r\n * can later be changed with {transferOwnership}.\r\n *\r\n * This module is used through inheritance. It will make available the modifier\r\n * `onlyOwner`, which can be applied to your functions to restrict their use to\r\n * the owner.\r\n */\r\nabstract contract Ownable  {\r\n    address private _owner;\r\n\r\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r\n\r\n    /**\r\n     * @dev Initializes the contract setting the deployer as the initial owner.\r\n     */\r\n    constructor() {\r\n        _setOwner(msg.sender);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the address of the current owner.\r\n     */\r\n    function owner() public view virtual returns (address) {\r\n        return _owner;\r\n    }\r\n\r\n    /**\r\n     * @dev Throws if called by any account other than the owner.\r\n     */\r\n    modifier onlyOwner() {\r\n        require(owner() == msg.sender, \"Ownable: caller is not the owner\");\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev Leaves the contract without owner. It will not be possible to call\r\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\r\n     *\r\n     * NOTE: Renouncing ownership will leave the contract without an owner,\r\n     * thereby removing any functionality that is only available to the owner.\r\n     */\r\n    function renounceOwnership() public virtual onlyOwner {\r\n        _setOwner(address(0));\r\n    }\r\n\r\n    /**\r\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\r\n     * Can only be called by the current owner.\r\n     */\r\n    function transferOwnership(address newOwner) public virtual onlyOwner {\r\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\r\n        _setOwner(newOwner);\r\n    }\r\n\r\n    function _setOwner(address newOwner) private {\r\n        address oldOwner = _owner;\r\n        _owner = newOwner;\r\n        emit OwnershipTransferred(oldOwner, newOwner);\r\n    }\r\n}"},"QS721.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IERC721.sol\";\r\nimport \"./IERC721R.sol\";\r\nimport \"./IERC721M.sol\";\r\nimport \"./Address.sol\";\r\nimport \"./ERC165.sol\";\r\nimport \"./Ownable.sol\";\r\n/**\r\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\r\n * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.\r\n *\r\n * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).\r\n *\r\n * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.\r\n *\r\n * Does not support burning tokens to address(0).\r\n */\r\ncontract ERC721A is\r\n  ERC165,\r\n  IERC721,\r\n  IERC721Metadata,\r\n  Ownable\r\n{\r\n  using Address for address;\r\n\r\n  struct TokenOwnership {\r\n    address addr;\r\n    uint64 startTimestamp;\r\n  }\r\n\r\n  struct AddressData {\r\n    uint128 balance;\r\n  }\r\n\r\n  uint256 private currentIndex = 1;\r\n\r\n  uint256 internal immutable collectionSize;\r\n\r\n\r\n  // Token name\r\n  string private _name;\r\n\r\n  // Token symbol\r\n  //\r\n  string private baseExtension = \".json\";\r\n  // Mapping from token ID to ownership details\r\n  // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.\r\n  mapping(uint256 =\u003e TokenOwnership) private _ownerships;\r\n\r\n  // Mapping owner address to address data\r\n  mapping(address =\u003e AddressData) private _addressData;\r\n\r\n  // Mapping from token ID to approved address\r\n  mapping(uint256 =\u003e address) private _tokenApprovals;\r\n\r\n  // Mapping from owner to operator approvals\r\n  mapping(address =\u003e mapping(address =\u003e bool)) private _operatorApprovals;\r\n\r\n  /**\r\n   * @dev\r\n   * `maxBatchSize` refers to how much a minter can mint at a time.\r\n   * `collectionSize_` refers to how many tokens are in the collection.\r\n   */\r\n  constructor(\r\n    string memory name_,\r\n    uint256 collectionSize_\r\n    // bool isBind_\r\n  ) {\r\n    require(\r\n      collectionSize_ \u003e 0,\r\n      \"ERC721A: collection must have a nonzero supply\"\r\n    );\r\n    _name = name_;\r\n    collectionSize = collectionSize_;\r\n    \r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721Enumerable-totalSupply}.\r\n   */\r\n  function totalSupply() public view returns (uint256) {\r\n    return currentIndex-1;\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721Enumerable-tokenByIndex}.\r\n   */\r\n  // function tokenByIndex(uint256 index) public view override returns (uint256) {\r\n  //   require(index \u003c totalSupply(), \"ERC721A: global index out of bounds\");\r\n  //   return index;\r\n  // }\r\n\r\n  /**\r\n   * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.\r\n   * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.\r\n   * It may also degrade with extremely large collection sizes (e.g \u003e\u003e 10000), test for your use case.\r\n   */\r\n  function tokenOfOwnerByIndex(address owner, uint256 index)\r\n    public\r\n    view\r\n    returns (uint256)\r\n  {\r\n    require(index \u003c= balanceOf(owner), \"ERC721A: owner index out of bounds\");\r\n    uint256 numMintedSoFar = totalSupply();\r\n    uint256 tokenIdsIdx = 1;\r\n    address currOwnershipAddr = address(0);\r\n    for (uint256 i = 1; i \u003c= numMintedSoFar; i++) {\r\n      TokenOwnership memory ownership = _ownerships[i];\r\n      if (ownership.addr != address(0)) {\r\n        currOwnershipAddr = ownership.addr;\r\n      }\r\n      if (currOwnershipAddr == owner) {\r\n        if (tokenIdsIdx == index) {\r\n          return i;\r\n        }\r\n        tokenIdsIdx++;\r\n      }\r\n    }\r\n    revert(\"ERC721A: unable to get token of owner by index\");\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC165-supportsInterface}.\r\n   */\r\n  function supportsInterface(bytes4 interfaceId)\r\n    public\r\n    view\r\n    virtual\r\n    override(ERC165, IERC165)\r\n    returns (bool)\r\n  {\r\n    return\r\n      interfaceId == type(IERC721).interfaceId ||\r\n      interfaceId == type(IERC721Metadata).interfaceId ||\r\n      super.supportsInterface(interfaceId);\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-balanceOf}.\r\n   */\r\n  function balanceOf(address owner) public view override returns (uint256) {\r\n    require(owner != address(0), \"ERC721A: balance query for the zero address\");\r\n    return uint256(_addressData[owner].balance);\r\n  }\r\n\r\n\r\n\r\n  function ownershipOf(uint256 tokenId) public\r\n    view\r\n    returns (TokenOwnership memory)\r\n  {\r\n    require(_exists(tokenId)\u0026\u0026tokenId!=0, \"ERC721A: owner query for nonexistent token\");\r\n     return _ownerships[tokenId];\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-ownerOf}.\r\n   */\r\n  function ownerOf(uint256 tokenId) public view override returns (address) {\r\n    return ownershipOf(tokenId).addr;\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721Metadata-name}.\r\n   */\r\n  function name() public view virtual override returns (string memory) {\r\n    return _name;\r\n  }\r\n  /**\r\n   * @dev See {IERC721Metadata-tokenURI}.\r\n   */\r\n  function tokenURI(uint256 tokenId)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (string memory)\r\n  {\r\n    \r\n    require(\r\n      _exists(tokenId),\r\n      \"ERC721Metadata: URI query for nonexistent token\"\r\n    );\r\n    require(\r\n      tokenId!=0,\r\n      \"ERC721Metadata: URI query for nonexistent token\"\r\n    );\r\n    string memory baseURI = _baseURI();\r\n    return\r\n      bytes(baseURI).length \u003e 0\r\n        ? string(abi.encodePacked(baseURI, toString(tokenId),baseExtension))\r\n        : \"\";\r\n  }\r\n\r\n  /**\r\n   * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\r\n   * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\r\n   * by default, can be overriden in child contracts.\r\n   */\r\n  function _baseURI() internal view virtual returns (string memory) {\r\n    return \"\";\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-approve}.\r\n   */\r\n  function approve(address to, uint256 tokenId) public override {\r\n    address owner = ERC721A.ownerOf(tokenId);\r\n    require(to != owner, \"ERC721A: approval to current owner\");\r\n\r\n    require(\r\n      msg.sender == owner || isApprovedForAll(owner, msg.sender),\r\n      \"ERC721A: approve caller is not owner nor approved for all\"\r\n    );\r\n\r\n    _approve(to, tokenId, owner);\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-getApproved}.\r\n   */\r\n  function getApproved(uint256 tokenId) public view override returns (address) {\r\n    require(_exists(tokenId), \"ERC721A: approved query for nonexistent token\");\r\n\r\n    return _tokenApprovals[tokenId];\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-setApprovalForAll}.\r\n   */\r\n  function setApprovalForAll(address operator, bool approved) public override {\r\n    require(operator != msg.sender, \"ERC721A: approve to caller\");\r\n\r\n    _operatorApprovals[msg.sender][operator] = approved;\r\n    emit ApprovalForAll(msg.sender, operator, approved);\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-isApprovedForAll}.\r\n   */\r\n  function isApprovedForAll(address owner, address operator)\r\n    public\r\n    view\r\n    virtual\r\n    override\r\n    returns (bool)\r\n  {\r\n    return _operatorApprovals[owner][operator];\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-transferFrom}.\r\n   */\r\n  function transferFrom(\r\n    address from,\r\n    address to,\r\n    uint256 tokenId\r\n  ) public override {\r\n    _transfer(from, to, tokenId);\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-safeTransferFrom}.\r\n   */\r\n  function safeTransferFrom(\r\n    address from,\r\n    address to,\r\n    uint256 tokenId\r\n  ) public override {\r\n    safeTransferFrom(from, to, tokenId, \"\");\r\n  }\r\n\r\n  /**\r\n   * @dev See {IERC721-safeTransferFrom}.\r\n   */\r\n  function safeTransferFrom(\r\n    address from,\r\n    address to,\r\n    uint256 tokenId,\r\n    bytes memory _data\r\n  ) public override {\r\n    _transfer(from, to, tokenId);\r\n    require(\r\n      _checkOnERC721Received(from, to, tokenId, _data),\r\n      \"ERC721A: transfer to non ERC721Receiver implementer\"\r\n    );\r\n  }\r\n\r\n  /**\r\n   * @dev Returns whether `tokenId` exists.\r\n   *\r\n   * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\r\n   *\r\n   * Tokens start existing when they are minted (`_mint`),\r\n   */\r\n  function _exists(uint256 tokenId) internal view returns (bool) {\r\n    return tokenId \u003c currentIndex;\r\n  }\r\n\r\n  function _safeMint(address to, uint256 quantity) internal {\r\n    _safeMint(to, quantity, \"\");\r\n  }\r\n\r\n  /**\r\n   * @dev Mints `quantity` tokens and transfers them to `to`.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - there must be `quantity` tokens remaining unminted in the total collection.\r\n   * - `to` cannot be the zero address.\r\n   * - `quantity` cannot be larger than the max batch size.\r\n   *\r\n   * Emits a {Transfer} event.\r\n   */\r\n  function _safeMint(\r\n    address to,\r\n    uint256 quantity,\r\n    bytes memory _data\r\n  ) internal {\r\n    uint256 startTokenId = currentIndex;\r\n    require(to != address(0), \"ERC721A: mint to the zero address\");\r\n    // We know if the first token in the batch doesn\u0027t exist, the other ones don\u0027t as well, because of serial ordering.\r\n    require(!_exists(startTokenId), \"ERC721A: token already minted\");\r\n\r\n    _beforeTokenTransfers(address(0), to, startTokenId, quantity);\r\n\r\n    AddressData memory addressData = _addressData[to];\r\n    _addressData[to] = AddressData(\r\n      addressData.balance + uint128(quantity)\r\n    );\r\n     for (uint256 i = 0; i \u003c quantity; i++) {\r\n       emit Transfer(address(0), to, startTokenId);\r\n       require(\r\n        _checkOnERC721Received(address(0), to, startTokenId, _data),\r\n        \"ERC721A: transfer to non ERC721Receiver implementer\"\r\n      );\r\n      _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));\r\n      startTokenId++;\r\n      }\r\n      currentIndex = startTokenId;\r\n      _afterTokenTransfers(address(0), to, startTokenId, quantity);\r\n\r\n  }\r\n\r\n  /**\r\n   * @dev Transfers `tokenId` from `from` to `to`.\r\n   *\r\n   * Requirements:\r\n   *\r\n   * - `to` cannot be the zero address.\r\n   * - `tokenId` token must be owned by `from`.\r\n   *\r\n   * Emits a {Transfer} event.\r\n   */\r\n  function _transfer(\r\n    address from,\r\n    address to,\r\n    uint256 tokenId\r\n  ) private {\r\n    TokenOwnership memory prevOwnership = ownershipOf(tokenId);\r\n\r\n    bool isApprovedOrOwner = (msg.sender == prevOwnership.addr ||\r\n      getApproved(tokenId) == msg.sender ||\r\n      isApprovedForAll(prevOwnership.addr, msg.sender));\r\n\r\n    require(\r\n      isApprovedOrOwner,\r\n      \"ERC721A: transfer caller is not owner nor approved\"\r\n    );\r\n\r\n    require(\r\n      prevOwnership.addr == from,\r\n      \"ERC721A: transfer from incorrect owner\"\r\n    );\r\n    require(to != address(0), \"ERC721A: transfer to the zero address\");\r\n\r\n    _beforeTokenTransfers(from, to, tokenId, 1);\r\n\r\n    // Clear approvals from the previous owner\r\n    _approve(address(0), tokenId, prevOwnership.addr);\r\n\r\n    _addressData[from].balance -= 1;\r\n    _addressData[to].balance += 1;\r\n    _ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));\r\n\r\n    // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.\r\n    // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.\r\n    uint256 nextTokenId = tokenId + 1;\r\n    if (_ownerships[nextTokenId].addr == address(0)) {\r\n      if (_exists(nextTokenId)) {\r\n        _ownerships[nextTokenId] = TokenOwnership(\r\n          prevOwnership.addr,\r\n          prevOwnership.startTimestamp\r\n        );\r\n      }\r\n    }\r\n\r\n    emit Transfer(from, to, tokenId);\r\n    _afterTokenTransfers(from, to, tokenId, 1);\r\n  }\r\n\r\n  /**\r\n   * @dev Approve `to` to operate on `tokenId`\r\n   *\r\n   * Emits a {Approval} event.\r\n   */\r\n  function _approve(\r\n    address to,\r\n    uint256 tokenId,\r\n    address owner\r\n  ) private {\r\n    _tokenApprovals[tokenId] = to;\r\n    emit Approval(owner, to, tokenId);\r\n  }\r\n\r\n\r\n\r\n  /**\r\n   * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\r\n   * The call is not executed if the target address is not a contract.\r\n   *\r\n   * @param from address representing the previous owner of the given token ID\r\n   * @param to target address that will receive the tokens\r\n   * @param tokenId uint256 ID of the token to be transferred\r\n   * @param _data bytes optional data to send along with the call\r\n   * @return bool whether the call correctly returned the expected magic value\r\n   */\r\n  function _checkOnERC721Received(\r\n    address from,\r\n    address to,\r\n    uint256 tokenId,\r\n    bytes memory _data\r\n  ) private returns (bool) {\r\n    if (to.isContract()) {\r\n      try\r\n        IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data)\r\n      returns (bytes4 retval) {\r\n        return retval == IERC721Receiver(to).onERC721Received.selector;\r\n      } catch (bytes memory reason) {\r\n        if (reason.length == 0) {\r\n          revert(\"ERC721A: transfer to non ERC721Receiver implementer\");\r\n        } else {\r\n          assembly {\r\n            revert(add(32, reason), mload(reason))\r\n          }\r\n        }\r\n      }\r\n    } else {\r\n      return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.\r\n   *\r\n   * startTokenId - the first token id to be transferred\r\n   * quantity - the amount to be transferred\r\n   *\r\n   * Calling conditions:\r\n   *\r\n   * - When `from` and `to` are both non-zero, ``from``\u0027s `tokenId` will be\r\n   * transferred to `to`.\r\n   * - When `from` is zero, `tokenId` will be minted for `to`.\r\n   */\r\n  function _beforeTokenTransfers(\r\n    address from,\r\n    address to,\r\n    uint256 startTokenId,\r\n    uint256 quantity\r\n  ) internal virtual {}\r\n\r\n  /**\r\n   * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes\r\n   * minting.\r\n   *\r\n   * startTokenId - the first token id to be transferred\r\n   * quantity - the amount to be transferred\r\n   *\r\n   * Calling conditions:\r\n   *\r\n   * - when `from` and `to` are both non-zero.\r\n   * - `from` and `to` are never both zero.\r\n   */\r\n  function _afterTokenTransfers(\r\n    address from,\r\n    address to,\r\n    uint256 startTokenId,\r\n    uint256 quantity\r\n  ) internal virtual {}\r\n  function toString(uint256 value) internal pure returns (string memory) {\r\n        // Inspired by OraclizeAPI\u0027s implementation - MIT licence\r\n        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\r\n\r\n        if (value == 0) {\r\n            return \"0\";\r\n        }\r\n        uint256 temp = value;\r\n        uint256 digits;\r\n        while (temp != 0) {\r\n            digits++;\r\n            temp /= 10;\r\n        }\r\n        bytes memory buffer = new bytes(digits);\r\n        while (value != 0) {\r\n            digits -= 1;\r\n            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\r\n            value /= 10;\r\n        }\r\n        return string(buffer);\r\n    }\r\n}"}}