Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

import {ConfigSettings} from "gwei-slim-nft-contracts/contracts/base/ERC721Base.sol";
import {ERC721Delegated} from "gwei-slim-nft-contracts/contracts/base/ERC721Delegated.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";

contract TheBeginningOfTheEnd is ERC721Delegated, ReentrancyGuard {
  using Counters for Counters.Counter;

  constructor(address baseFactory, string memory customBaseURI_)
    ERC721Delegated(
      baseFactory,
      "The Beginning Of The End",
      "TBoTE",
      ConfigSettings({
        royaltyBps: 650,
        uriBase: customBaseURI_,
        uriExtension: "",
        hasTransferHook: false
      })
    )
  {
    allowedMintCountMap[msg.sender] = 33;

    allowedMintCountMap[0xdf9e6a194F3d4DC2571158F4bA7CFA9696AA9274] = 3;

    allowedMintCountMap[0x6Fc5891d3daF91555f7b9C70eB9657A4dF59176f] = 3;

    allowedMintCountMap[0x7f5afC67d4C3AE0182354ea6e785FdEb20150f15] = 3;

    allowedMintCountMap[0x85cA7d812127677FFE9B5672DA40459348a8FF85] = 3;

    allowedMintCountMap[0x2EE54D8eB4F898c285b9fce4320D0bA6725E1704] = 3;

    allowedMintCountMap[0x8E74351b6C91e729395560438f6c85a16dD4cce4] = 3;

    allowedMintCountMap[0xECe055ea28bE3c1D9b08B8883b52700fFFaae20c] = 3;

    allowedMintCountMap[0xe6d6c64a981385f2e93196833a162655d6F8a8Fb] = 3;

    allowedMintCountMap[0xB58D73997C1CA0E1812c60A7eC69683eEFc098B8] = 3;

    allowedMintCountMap[0x4e07751EA822dBc8c71B1aC89e971Ed88a089b3f] = 3;

    allowedMintCountMap[0xCe6DB393C736A65e0B21d10A92B97418ABd0a2dE] = 3;

    allowedMintCountMap[0xD8f2c8dE147EdE45D00c1f1ba529Db5486F8b922] = 3;

    allowedMintCountMap[0xA7D775FB03F699bEAbbdc18FF97D1385feeB3EB9] = 3;

    allowedMintCountMap[0x819Aa1675c4baBa624A5E061F4F4cE05095A4AC2] = 3;

    allowedMintCountMap[0x7c192a1fF95c3254abc1B34B493E2fFCCdF3836F] = 3;

    allowedMintCountMap[0x85eEFFB8e62a2F196BDe282621368eb6839C6109] = 3;

    allowedMintCountMap[0x78161b0c34DA8bBf88DC73bC214d37616A927ae7] = 3;

    allowedMintCountMap[0xE0C9B6BeD7ecA8F9bCAaeC1763f73606967283c8] = 3;

    allowedMintCountMap[0xd17f430E0B973218576a37cc447F5910ED1BE9FE] = 3;

    allowedMintCountMap[0x9B5F74C8c979F3F34fc1aF43242FDf1683070D0D] = 3;

    allowedMintCountMap[0x85026596042Cf8CAB1b521bCca86C56cf2D2ecAe] = 2;

    allowedMintCountMap[0x580b1E94Dad298f5CD32E3C38B9faf4a25c08Ea4] = 2;

    allowedMintCountMap[0x91c2edF643304e983e35e572898B014AB0E7e64E] = 2;

    allowedMintCountMap[0x8A0ba5E4063C1FFA294FA6Bd9dE937f1B5BD4600] = 2;

    allowedMintCountMap[0x63C242920eD0e137cC7cBc6D2cDB5B1fccD050cE] = 2;

    allowedMintCountMap[0xfcfF7E05177619e187e337C5210685f06F725d13] = 2;

    allowedMintCountMap[0x324825B5B28b056d32757f0877411cb031810Ca9] = 2;

    allowedMintCountMap[0x28156730f1F2f588fcc3e9ED2f5793CAD354282c] = 2;

    allowedMintCountMap[0x3e051B18A633A48998CB1656817cA74DEbF37fab] = 2;

    allowedMintCountMap[0xf148d310ee342cd1A8ac15AFCF75BA7a7F6CB9Fb] = 2;

    allowedMintCountMap[0x53c68d3F629B53c27Cd658D41dC836F38603eD0c] = 2;

    allowedMintCountMap[0xD50a89b8f99EAFd815E1F552522632e673d1f73a] = 2;

    allowedMintCountMap[0x0e4230c3cbAFbACa98E1419721deC3D108767B72] = 2;

    allowedMintCountMap[0x91fe628414A41074Eb841da04B4D6992cF5f90e5] = 2;

    allowedMintCountMap[0x974Ab44B53a46875e4Cf0471FAEBF35b2F9d8561] = 2;

    allowedMintCountMap[0x199e024CD5eBB205c7A2EEBE4eBB33630D7b1d35] = 2;

    allowedMintCountMap[0xa0E84D22d5429C4E55d086F47D1BAb006E5ADEBB] = 2;

    allowedMintCountMap[0x4D2b5A91e41c933c190aaAbDa54B2Ed8765AEfAC] = 2;

    allowedMintCountMap[0xE436BeA44E9734220509E3d1fd501443eBFb2A7C] = 2;

    allowedMintCountMap[0x2C1C90B44Bf1f40A851B04146A358B053A74F067] = 2;

    allowedMintCountMap[0x20bE3D159eD81Ed9fa73432414Ea0460D1Ba94a5] = 2;

    allowedMintCountMap[0xA14626C73A39F4Ab461D3afAeCC3A4A8B2Aa6367] = 2;

    allowedMintCountMap[0xE1F0D43469492FcAc3eF69D8732bDBa1e65fcD63] = 2;

    allowedMintCountMap[0xAdBA3C3e04F77123e00cAB16FD1b9cD3cCCAB4aC] = 2;

    allowedMintCountMap[0x80f6391F15D77fD4051685121ea3BcC2cEc8959c] = 2;

    allowedMintCountMap[0x3d4c0f2f46b7c16117D1184Ed2B1878293614a86] = 2;

    allowedMintCountMap[0x060233eB6867f329C57586d9Be5BD918Ad06adF2] = 2;

    allowedMintCountMap[0xdf6B4D90860a0579d55737824Ce6f5aF7d378b7a] = 2;

    allowedMintCountMap[0x050f5Fb2314242c2560305574A35439aA006e0B6] = 2;

    allowedMintCountMap[0x3aAAE5C3c0f1F3b239cb6a5F02e105674De13bB2] = 2;

    allowedMintCountMap[0xFc2cEfF32e3a534b78C729fD23973CB9ce98FBAC] = 2;

    allowedMintCountMap[0xB67710d029B2A702d54E0F41BB5dC2ADd72C5DfF] = 2;

    allowedMintCountMap[0xa2DA32691EE54f3089d8328039Da3bFBa71f31A1] = 2;

    allowedMintCountMap[0xe4F93B524b742A6A76882C94D66F9d4f4B0583C5] = 2;

    allowedMintCountMap[0xf7f532af44b7DCd017f107EA7cc19F87f40c69e9] = 2;

    allowedMintCountMap[0x2DeD7A9a7C6aa52540E556c9660D505da0b10203] = 2;

    allowedMintCountMap[0x401B185d9a57a34e7888f6363AFf4B54E535A872] = 2;

    allowedMintCountMap[0xF338aE28794bc7a79c94Daaa8657aaC3CA65768b] = 2;

    allowedMintCountMap[0xC489042128d3ba383BcE79eaEef1dc69EfC40416] = 2;

    allowedMintCountMap[0xae68a4AB5228229391225283c899E88E4741c62A] = 2;

    allowedMintCountMap[0xEc44d23f2f2e1fB07d8B38207470Cf9d841e247D] = 2;

    allowedMintCountMap[0xf1d23725a29f80d6996b435D78b21596435B6c54] = 2;

    allowedMintCountMap[0xB6c64C6Ab138CF4439754566faA15E9c796f2B3b] = 2;

    allowedMintCountMap[0xc3E10c4b00D393F515B391b69504b76a219b2132] = 2;

    allowedMintCountMap[0xDfb5e6170eA423c4EF32bf49907B884e8Cb9dCed] = 2;

    allowedMintCountMap[0xA54cE875d138260315359b35a252303E75317efe] = 2;

    allowedMintCountMap[0x914d1eb2E0d63c29CF8df21830f1CabB9F53B377] = 2;

    allowedMintCountMap[0x7Fe178A16dC4b2EeCB34B860AB501a8AE017a729] = 2;

    allowedMintCountMap[0x8a622Bc901de1fa2384d42FFA79606e446eD788F] = 2;

    allowedMintCountMap[0x44B2945F9EC50ad1562c28CB7dF2077fC09F1427] = 2;

    allowedMintCountMap[0x68Db5E9B182Af5AffEfDBe102dEd829C018328f6] = 2;

    allowedMintCountMap[0xb5619Ba9D7f67254e4C53c8bE903d951B551C9a5] = 2;

    allowedMintCountMap[0x15B985DC531593b65d219C4f6947369345D713A0] = 2;

    allowedMintCountMap[0xD4BBe225b6A92cdadC69301Dd54C1Cf0E437B659] = 2;

    allowedMintCountMap[0x36c1238af9cd4D640e6c5D4184Fc88A2117265F3] = 2;

    allowedMintCountMap[0xe969C2dA5940eafe62e416983366A14F16B35FAe] = 2;

    allowedMintCountMap[0x0b8242F72ccf49E4C47C74d784fDd68e7bfdd62D] = 2;

    allowedMintCountMap[0x37328808192d370203F8dD85F7663C2E7FCd856f] = 2;

    allowedMintCountMap[0xe9F755Eba18CE85CAe770e0F4Ec0EC948c8d9779] = 2;

    allowedMintCountMap[0x8453B32B87e33ffE570Be91f1Ad1181F7037e0cf] = 2;

    allowedMintCountMap[0xAa73537FD1E34cd9E6bfD04270f9A0F160C39069] = 2;

    allowedMintCountMap[0xC7d21a6a1174fd3fa1E24b1BF2CfA1eE7b7FAa40] = 2;

    allowedMintCountMap[0xBe327B8AD8AEb1374962652b8B1B2465A0c234cA] = 2;
  }

  /** MINTING LIMITS **/

  mapping(address => uint256) private mintCountMap;

  mapping(address => uint256) private allowedMintCountMap;

  uint256 public constant MINT_LIMIT_PER_WALLET = 1;

  function max(uint256 a, uint256 b) private pure returns (uint256) {
    return a >= b ? a : b;
  }

  function allowedMintCount(address minter) public view returns (uint256) {
    if (saleIsActive) {
      return (
        max(allowedMintCountMap[minter], MINT_LIMIT_PER_WALLET) -
        mintCountMap[minter]
      );
    }

    return allowedMintCountMap[minter] - mintCountMap[minter];
  }

  function updateMintCount(address minter, uint256 count) private {
    mintCountMap[minter] += count;
  }

  /** MINTING **/

  uint256 public constant MAX_SUPPLY = 3333;

  uint256 public constant MAX_MULTIMINT = 3;

  Counters.Counter private supplyCounter;

  function mint(uint256 count) public nonReentrant {
    if (allowedMintCount(msg.sender) >= count) {
      updateMintCount(msg.sender, count);
    } else {
      revert(saleIsActive ? "Minting limit exceeded" : "Sale not active");
    }

    require(totalSupply() + count - 1 < MAX_SUPPLY, "Exceeds max supply");

    require(count <= MAX_MULTIMINT, "Mint at most 3 at a time");

    for (uint256 i = 0; i < count; i++) {
      _mint(msg.sender, totalSupply());

      supplyCounter.increment();
    }
  }

  function totalSupply() public view returns (uint256) {
    return supplyCounter.current();
  }

  /** ACTIVATION **/

  bool public saleIsActive = false;

  function setSaleIsActive(bool saleIsActive_) external onlyOwner {
    saleIsActive = saleIsActive_;
  }

  /** URI HANDLING **/

  function setBaseURI(string memory customBaseURI_) external onlyOwner {
    _setBaseURI(customBaseURI_, "");
  }

  function tokenURI(uint256 tokenId) public view returns (string memory) {
    return string(abi.encodePacked(_tokenURI(tokenId), ".json"));
  }

  /** PAYOUT **/

  function withdraw() public nonReentrant {
    uint256 balance = address(this).balance;

    Address.sendValue(payable(_owner()), balance);
  }
}

// Contract created with Studio 721 v1.5.0
// https://721.so

// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.9;

import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {StringsUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import {CountersUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import {IBaseERC721Interface} from "./IBaseERC721Interface.sol";

struct ConfigSettings {
    uint16 royaltyBps;
    string uriBase;
    string uriExtension;
    bool hasTransferHook;
}

/**
    This smart contract adds features and allows for a ownership only by another smart contract as fallback behavior
    while also implementing all normal ERC721 functions as expected
*/
contract ERC721Base is
    ERC721Upgradeable,
    IBaseERC721Interface,
    IERC2981Upgradeable,
    OwnableUpgradeable
{
    using CountersUpgradeable for CountersUpgradeable.Counter;
    // Minted counter for totalSupply()
    CountersUpgradeable.Counter private mintedCounter;

    modifier onlyInternal() {
        require(msg.sender == address(this), "Only internal");
        _;
    }

    /// on-chain record of when this contract was deployed
    uint256 public immutable deployedBlock;

    ConfigSettings public advancedConfig;

    /// Constructor called once when the base contract is deployed
    constructor() {
        // Can be used to verify contract implementation is correct at address
        deployedBlock = block.number;
    }

    /// Initializer that's called when a new child nft is setup
    /// @param newOwner Owner for the new derived nft
    /// @param _name name of NFT contract
    /// @param _symbol symbol of NFT contract
    /// @param settings configuration settings for uri, royalty, and hooks features
    function initialize(
        address newOwner,
        string memory _name,
        string memory _symbol,
        ConfigSettings memory settings
    ) public initializer {
        __ERC721_init(_name, _symbol);
        __Ownable_init();

        advancedConfig = settings;

        transferOwnership(newOwner);
    }

    /// Getter to expose appoval status to root contract
    function isApprovedForAll(address _owner, address operator)
        public
        view
        override
        returns (bool)
    {
        return
            ERC721Upgradeable.isApprovedForAll(_owner, operator) ||
            operator == address(this);
    }

    /// internal getter for approval by all
    /// When isApprovedForAll is overridden, this can be used to call original impl
    function __isApprovedForAll(address _owner, address operator)
        public
        view
        override
        returns (bool)
    {
        return isApprovedForAll(_owner, operator);
    }

    /// Hook that when enabled manually calls _beforeTokenTransfer on
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override {
        if (advancedConfig.hasTransferHook) {
            (bool success, ) = address(this).delegatecall(
                abi.encodeWithSignature(
                    "_beforeTokenTransfer(address,address,uint256)",
                    from,
                    to,
                    tokenId
                )
            );
            // Raise error again from result if error exists
            assembly {
                switch success
                // delegatecall returns 0 on error.
                case 0 {
                    returndatacopy(0, 0, returndatasize())
                    revert(0, returndatasize())
                }
            }
        }
    }

    /// Internal-only function to update the base uri
    function __setBaseURI(string memory uriBase, string memory uriExtension)
        public
        override
        onlyInternal
    {
        advancedConfig.uriBase = uriBase;
        advancedConfig.uriExtension = uriExtension;
    }

    /// @dev returns the number of minted tokens
    /// uses some extra gas but makes etherscan and users happy so :shrug:
    /// partial erc721enumerable implemntation
    function totalSupply() public view returns (uint256) {
        return mintedCounter.current();
    }

    /**
      Internal-only
      @param to address to send the newly minted NFT to
      @dev This mints one edition to the given address by an allowed minter on the edition instance.
     */
    function __mint(address to, uint256 tokenId)
        external
        override
        onlyInternal
    {
        _mint(to, tokenId);
        mintedCounter.increment();
    }

    /**
        @param tokenId Token ID to burn
        User burn function for token id 
     */
    function burn(uint256 tokenId) public {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "Not allowed");
        _burn(tokenId);
        mintedCounter.decrement();
    }

    /// Internal only
    function __burn(uint256 tokenId) public onlyInternal {
        _burn(tokenId);
        mintedCounter.decrement();
    }

    /**
        Simple override for owner interface.
     */
    function owner()
        public
        view
        override(OwnableUpgradeable)
        returns (address)
    {
        return super.owner();
    }

    /// internal alias for overrides
    function __owner()
        public
        view
        override(IBaseERC721Interface)
        returns (address)
    {
        return owner();
    }

    /// Get royalty information for token
    /// ignored token id to get royalty info. able to override and set per-token royalties
    /// @param _salePrice sales price for token to determine royalty split
    function royaltyInfo(uint256, uint256 _salePrice)
        external
        view
        override
        returns (address receiver, uint256 royaltyAmount)
    {
        // If ownership is revoked, don't set royalties.
        if (owner() == address(0x0)) {
            return (owner(), 0);
        }
        return (owner(), (_salePrice * advancedConfig.royaltyBps) / 10_000);
    }

    /// Default simple token-uri implementation. works for ipfs folders too
    /// @param tokenId token id ot get uri for
    /// @return default uri getter functionality
    function tokenURI(uint256 tokenId)
        public
        view
        override
        returns (string memory)
    {
        require(_exists(tokenId), "No token");

        return
            string(
                abi.encodePacked(
                    advancedConfig.uriBase,
                    StringsUpgradeable.toString(tokenId),
                    advancedConfig.uriExtension
                )
            );
    }

    /// internal base override
    function __tokenURI(uint256 tokenId)
        public
        view
        onlyInternal
        returns (string memory)
    {
        return tokenURI(tokenId);
    }

    /// Exposing token exists check for base contract
    function __exists(uint256 tokenId) external view override returns (bool) {
        return _exists(tokenId);
    }

    /// Getter for approved or owner
    function __isApprovedOrOwner(address spender, uint256 tokenId)
        external
        view
        override
        onlyInternal
        returns (bool)
    {
        return _isApprovedOrOwner(spender, tokenId);
    }

    /// IERC165 getter
    /// @param interfaceId interfaceId bytes4 to check support for
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721Upgradeable, IERC165Upgradeable)
        returns (bool)
    {
        return
            type(IERC2981Upgradeable).interfaceId == interfaceId ||
            type(IBaseERC721Interface).interfaceId == interfaceId ||
            ERC721Upgradeable.supportsInterface(interfaceId);
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.9;

import {StorageSlotUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol";

import {IBaseERC721Interface, ConfigSettings} from "./ERC721Base.sol";

contract ERC721Delegated {
    uint256[100000] gap;
    bytes32 internal constant _IMPLEMENTATION_SLOT =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    // Reference to base NFT implementation
    function implementation() public view returns (address) {
        return
            StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    function _initImplementation(address _nftImplementation) private {
        StorageSlotUpgradeable
            .getAddressSlot(_IMPLEMENTATION_SLOT)
            .value = _nftImplementation;
    }

    /// Constructor that sets up the
    constructor(
        address _nftImplementation,
        string memory name,
        string memory symbol,
        ConfigSettings memory settings
    ) {
        /// Removed for gas saving reasons, the check below implictly accomplishes this
        // require(
        //     _nftImplementation.supportsInterface(
        //         type(IBaseERC721Interface).interfaceId
        //     )
        // );
        _initImplementation(_nftImplementation);
        (bool success, ) = _nftImplementation.delegatecall(
            abi.encodeWithSignature(
                "initialize(address,string,string,(uint16,string,string,bool))",
                msg.sender,
                name,
                symbol,
                settings
            )
        );
        require(success);
    }

    /// OnlyOwner implemntation that proxies to base ownable contract for info
    modifier onlyOwner() {
        require(msg.sender == base().__owner(), "Not owner");
        _;
    }

    /// Getter to return the base implementation contract to call methods from
    /// Don't expose base contract to parent due to need to call private internal base functions
    function base() private view returns (IBaseERC721Interface) {
        return IBaseERC721Interface(address(this));
    }

    // helpers to mimic Openzeppelin internal functions

    /// Getter for the contract owner
    /// @return address owner address
    function _owner() internal view returns (address) {
        return base().__owner();
    }

    /// Internal burn function, only accessible from within contract
    /// @param id nft id to burn
    function _burn(uint256 id) internal {
        base().__burn(id);
    }

    /// Internal mint function, only accessible from within contract
    /// @param to address to mint NFT to
    /// @param id nft id to mint
    function _mint(address to, uint256 id) internal {
        base().__mint(to, id);
    }

    /// Internal exists function to determine if fn exists
    /// @param id nft id to check if exists
    function _exists(uint256 id) internal view returns (bool) {
        return base().__exists(id);
    }

    /// Internal getter for tokenURI
    /// @param tokenId id of token to get tokenURI for
    function _tokenURI(uint256 tokenId) internal view returns (string memory) {
        return base().__tokenURI(tokenId);
    }

    /// is approved for all getter underlying getter
    /// @param owner to check
    /// @param operator to check
    function _isApprovedForAll(address owner, address operator)
        internal
        view
        returns (bool)
    {
        return base().__isApprovedForAll(owner, operator);
    }

    /// Internal getter for approved or owner for a given operator
    /// @param operator address of operator to check
    /// @param id id of nft to check for
    function _isApprovedOrOwner(address operator, uint256 id)
        internal
        view
        returns (bool)
    {
        return base().__isApprovedOrOwner(operator, id);
    }

    /// Sets the base URI of the contract. Allowed only by parent contract
    /// @param newUri new uri base (http://URI) followed by number string of nft followed by extension string
    /// @param newExtension optional uri extension
    function _setBaseURI(string memory newUri, string memory newExtension)
        internal
    {
        base().__setBaseURI(newUri, newExtension);
    }

    /**
     * @dev Delegates the current call to nftImplementation.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        address impl = implementation();

        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external virtual {
        _fallback();
    }

    /**
     * @dev No base NFT functions receive any value
     */
    receive() external payable {
        revert();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./extensions/IERC721MetadataUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/StringsUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.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 ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
    using AddressUpgradeable for address;
    using StringsUpgradeable 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.
     */
    function __ERC721_init(string memory name_, string memory symbol_) internal initializer {
        __Context_init_unchained();
        __ERC165_init_unchained();
        __ERC721_init_unchained(name_, symbol_);
    }

    function __ERC721_init_unchained(string memory name_, string memory symbol_) internal initializer {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
        return
            interfaceId == type(IERC721Upgradeable).interfaceId ||
            interfaceId == type(IERC721MetadataUpgradeable).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 = ERC721Upgradeable.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 = ERC721Upgradeable.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 = ERC721Upgradeable.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(ERC721Upgradeable.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(ERC721Upgradeable.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 IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721ReceiverUpgradeable.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 {}
    uint256[44] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";

/**
 * @dev Interface for the NFT Royalty Standard
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Called with the sale price to determine how much royalty is owed and to whom.
     * @param tokenId - the NFT asset queried for royalty information
     * @param salePrice - the sale price of the NFT asset specified by `tokenId`
     * @return receiver - address of who should be sent the royalty payment
     * @return royaltyAmount - the royalty payment amount for `salePrice`
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        _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);
    }
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    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);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.9;

/// Additional features and functions assigned to the
/// Base721 contract for hooks and overrides
interface IBaseERC721Interface {
    /*
     Exposing common NFT internal functionality for base contract overrides
     To save gas and make API cleaner this is only for new functionality not exposed in
     the core ERC721 contract
    */

    /// Mint an NFT. Allowed to mint by owner, approval or by the parent contract
    /// @param tokenId id to burn
    function __burn(uint256 tokenId) external;

    /// Mint an NFT. Allowed only by the parent contract
    /// @param to address to mint to
    /// @param tokenId token id to mint
    function __mint(address to, uint256 tokenId) external;

    /// Set the base URI of the contract. Allowed only by parent contract
    /// @param base base uri
    /// @param extension extension
    function __setBaseURI(string memory base, string memory extension) external;

    /* Exposes common internal read features for public use */

    /// Token exists
    /// @param tokenId token id to see if it exists
    function __exists(uint256 tokenId) external view returns (bool);

    /// Simple approval for operation check on token for address
    /// @param spender address spending/changing token
    /// @param tokenId tokenID to change / operate on
    function __isApprovedOrOwner(address spender, uint256 tokenId)
        external
        view
        returns (bool);

    function __isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);

    function __tokenURI(uint256 tokenId) external view returns (string memory);

    function __owner() external view returns (address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlotUpgradeable {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721Upgradeable is IERC165Upgradeable {
    /**
     * @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;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721ReceiverUpgradeable {
    /**
     * @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

pragma solidity ^0.8.0;

import "../IERC721Upgradeable.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
    /**
     * @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;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @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 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;
import "../proxy/utils/Initializable.sol";

/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal initializer {
        __ERC165_init_unchained();
    }

    function __ERC165_init_unchained() internal initializer {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/introspection/IERC165Upgradeable.sol";

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

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"baseFactory","type":"address"},{"internalType":"string","name":"customBaseURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"MAX_MULTIMINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINT_LIMIT_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"allowedMintCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"customBaseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"saleIsActive_","type":"bool"}],"name":"setSaleIsActive","outputs":[],"stateMutability":"nonpayable","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":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000043955024b1985e2b933a59021500ae5f55b0409100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000043697066733a2f2f6261667962656965696f79666b686535746b34756268753633646a37646864716d65793765726c617632727072646678686435697778336b7471752f0000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : baseFactory (address): 0x43955024b1985E2b933A59021500aE5f55b04091
Arg [1] : customBaseURI_ (string): ipfs://bafybeieioyfkhe5tk4ubhu63dj7dhdqmey7erlav2rprdfxhd5iwx3ktqu/

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 00000000000000000000000043955024b1985e2b933a59021500ae5f55b04091
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [3] : 697066733a2f2f6261667962656965696f79666b686535746b34756268753633
Arg [4] : 646a37646864716d65793765726c617632727072646678686435697778336b74
Arg [5] : 71752f0000000000000000000000000000000000000000000000000000000000

405:8680:18:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5734:8:20;;;405:8680:18;;;;;;;;;;;5605:11:20;:9;:11::i;:::-;405:8680:18;8531:103;;;;;;;;;;-1:-1:-1;8531:103:18;;;;;:::i;:::-;;:::i;8374:94::-;;;;;;;;;;;;;:::i;:::-;;;438:25:22;;;426:2;411:18;8374:94:18;;;;;;;;7731:41;;;;;;;;;;;;7768:4;7731:41;;8941:142;;;;;;;;;;;;;:::i;8662:111::-;;;;;;;;;;-1:-1:-1;8662:111:18;;;;;:::i;:::-;;:::i;472:157:20:-;;;;;;;;;;-1:-1:-1;355:66:20;557:65;472:157;;-1:-1:-1;;;;;557:65:20;;;1902:51:22;;1890:2;1875:18;472:157:20;1756:203:22;7866:504:18;;;;;;;;;;-1:-1:-1;7866:504:18;;;;;:::i;:::-;;:::i;7777:41::-;;;;;;;;;;;;7817:1;7777:41;;7310:290;;;;;;;;;;-1:-1:-1;7310:290:18;;;;;:::i;:::-;;:::i;8777:142::-;;;;;;;;;;-1:-1:-1;8777:142:18;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;7154:49::-;;;;;;;;;;;;7202:1;7154:49;;8494:32;;;;;;;;;;-1:-1:-1;8494:32:18;;;;;;;;;;;3453:14:22;;3446:22;3428:41;;3416:2;3401:18;8494:32:18;3288:187:22;4465:905:20;4513:12;4528:16;355:66;557:65;-1:-1:-1;;;;;557:65:20;;472:157;4528:16;4513:31;;4823:14;4820:1;4817;4804:34;5027:1;5024;5008:14;5005:1;4999:4;4992:5;4979:50;5103:16;5100:1;5097;5082:38;5141:6;5208:66;;;;5323:16;5320:1;5313:27;5208:66;5243:16;5240:1;5233:27;5134:220;;;4564:800;4465:905::o;8531:103:18:-;2132:4:20;-1:-1:-1;;;;;1796:14:20;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1782:30:20;:10;-1:-1:-1;;;;;1782:30:20;;1774:52;;;;-1:-1:-1;;;1774:52:20;;3938:2:22;1774:52:20;;;3920:21:22;3977:1;3957:18;;;3950:29;-1:-1:-1;;;3995:18:22;;;3988:39;4044:18;;1774:52:20;;;;;;;;;8601:12:18::1;:28:::0;;-1:-1:-1;;8601:28:18::1;::::0;::::1;;::::0;;;::::1;::::0;;8531:103::o;8374:94::-;8418:7;8440:23;:13;864:14:17;;773:112;8440:23:18;8433:30;;8374:94;:::o;8941:142::-;1680:1:15;2259:7;;:19;;2251:63;;;;-1:-1:-1;;;2251:63:15;;4275:2:22;2251:63:15;;;4257:21:22;4314:2;4294:18;;;4287:30;4353:33;4333:18;;;4326:61;4404:18;;2251:63:15;4073:355:22;2251:63:15;1680:1;2389:7;:18;9005:21:18::1;9033:45;9059:8;:6;:8::i;:::-;9070:7;9033:17;:45::i;:::-;-1:-1:-1::0;1637:1:15;2562:7;:22;8941:142:18:o;8662:111::-;2132:4:20;-1:-1:-1;;;;;1796:14:20;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1782:30:20;:10;-1:-1:-1;;;;;1782:30:20;;1774:52;;;;-1:-1:-1;;;1774:52:20;;3938:2:22;1774:52:20;;;3920:21:22;3977:1;3957:18;;;3950:29;-1:-1:-1;;;3995:18:22;;;3988:39;4044:18;;1774:52:20;3736:332:22;1774:52:20;8737:31:18::1;8749:14;8737:31;;;;;;;;;;;::::0;:11:::1;:31::i;:::-;8662:111:::0;:::o;7866:504::-;1680:1:15;2259:7;;:19;;2251:63;;;;-1:-1:-1;;;2251:63:15;;4275:2:22;2251:63:15;;;4257:21:22;4314:2;4294:18;;;4287:30;4353:33;4333:18;;;4326:61;4404:18;;2251:63:15;4073:355:22;2251:63:15;1680:1;2389:7;:18;7957:5:18;7925:28:::1;7942:10;7925:16;:28::i;:::-;:37;7921:180;;7972:34;7988:10;8000:5;7972:15;:34::i;:::-;7921:180;;;8034:12;::::0;::::1;;:59;;;;;;;;;;;;;;;-1:-1:-1::0;;;8034:59:18::1;;::::0;::::1;;;;;;;;;;;;;;;;-1:-1:-1::0;;;8034:59:18::1;;::::0;::::1;8027:67;;-1:-1:-1::0;;;8027:67:18::1;;;;;;;;:::i;7921:180::-;7768:4;8139:1;8131:5;8115:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:25;;;;:::i;:::-;:38;8107:69;;;::::0;-1:-1:-1;;;8107:69:18;;5030:2:22;8107:69:18::1;::::0;::::1;5012:21:22::0;5069:2;5049:18;;;5042:30;-1:-1:-1;;;5088:18:22;;;5081:48;5146:18;;8107:69:18::1;4828:342:22::0;8107:69:18::1;7817:1;8191:5;:22;;8183:59;;;::::0;-1:-1:-1;;;8183:59:18;;5377:2:22;8183:59:18::1;::::0;::::1;5359:21:22::0;5416:2;5396:18;;;5389:30;5455:26;5435:18;;;5428:54;5499:18;;8183:59:18::1;5175:348:22::0;8183:59:18::1;8254:9;8249:117;8273:5;8269:1;:9;8249:117;;;8293:32;8299:10;8311:13;:11;:13::i;:::-;8293:5;:32::i;:::-;8334:25;:13;978:19:17::0;;996:1;978:19;;;891:123;8334:25:18::1;8280:3:::0;::::1;::::0;::::1;:::i;:::-;;;;8249:117;;;-1:-1:-1::0;;1637:1:15;2562:7;:22;7866:504:18:o;7310:290::-;7392:12;;7373:7;;7392:12;;7388:144;;;-1:-1:-1;;;;;7497:20:18;;;;;;:12;:20;;;;;;;;;7435:19;:27;;;;;;;7431:55;;7202:1;7431:3;:55::i;:::-;:86;;;;:::i;:::-;7414:111;7310:290;-1:-1:-1;;7310:290:18:o;7388:144::-;-1:-1:-1;;;;;7575:20:18;;;;;;:12;:20;;;;;;;;;7545:19;:27;;;;;;;:50;;7575:20;7545:50;:::i;8777:142::-;8833:13;8885:18;8895:7;8885:9;:18::i;:::-;8868:45;;;;;;;;:::i;:::-;;;;;;;;;;;;;8854:60;;8777:142;;;:::o;1553:147:11:-;1680:4;1553:147::o;2284:90:20:-;2325:7;2132:4;-1:-1:-1;;;;;2351:14:20;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2012:312:16:-;2126:6;2101:21;:31;;2093:73;;;;-1:-1:-1;;;2093:73:16;;6318:2:22;2093:73:16;;;6300:21:22;6357:2;6337:18;;;6330:30;6396:31;6376:18;;;6369:59;6445:18;;2093:73:16;6116:353:22;2093:73:16;2178:12;2196:9;-1:-1:-1;;;;;2196:14:16;2218:6;2196:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2177:52;;;2247:7;2239:78;;;;-1:-1:-1;;;2239:78:16;;6886:2:22;2239:78:16;;;6868:21:22;6925:2;6905:18;;;6898:30;6964:34;6944:18;;;6937:62;7035:28;7015:18;;;7008:56;7081:19;;2239:78:16;6684:422:22;4112:150:20;4214:41;;-1:-1:-1;;;4214:41:20;;2132:4;;4214:19;;:41;;4234:6;;4242:12;;4214:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4112:150;;:::o;7604:104:18:-;-1:-1:-1;;;;;7674:20:18;;;;;;:12;:20;;;;;:29;;7698:5;;7674:20;:29;;7698:5;;7674:29;:::i;:::-;;;;-1:-1:-1;;;;7604:104:18:o;2701:86:20:-;2759:21;;-1:-1:-1;;;2759:21:20;;-1:-1:-1;;;;;7691:32:22;;2759:21:20;;;7673:51:22;7740:18;;;7733:34;;;2132:4:20;;2759:13;;7646:18:22;;2759:21:20;7499:274:22;7208:98:18;7265:7;7292:1;7287;:6;;:14;;7300:1;7287:14;;;7296:1;7287:14;7280:21;7208:98;-1:-1:-1;;;7208:98:18:o;3095:124:20:-;3186:26;;-1:-1:-1;;;3186:26:20;;;;;438:25:22;;;3154:13:20;;2132:4;;3186:17;;411:18:22;;3186:26:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3186:26:20;;;;;;;;;;;;:::i;14:273:22:-;70:6;123:2;111:9;102:7;98:23;94:32;91:52;;;139:1;136;129:12;91:52;178:9;165:23;231:5;224:13;217:21;210:5;207:32;197:60;;253:1;250;243:12;474:127;535:10;530:3;526:20;523:1;516:31;566:4;563:1;556:15;590:4;587:1;580:15;606:275;677:2;671:9;742:2;723:13;;-1:-1:-1;;719:27:22;707:40;;777:18;762:34;;798:22;;;759:62;756:88;;;824:18;;:::i;:::-;860:2;853:22;606:275;;-1:-1:-1;606:275:22:o;886:187::-;935:4;968:18;960:6;957:30;954:56;;;990:18;;:::i;:::-;-1:-1:-1;1056:2:22;1035:15;-1:-1:-1;;1031:29:22;1062:4;1027:40;;886:187::o;1078:673::-;1147:6;1200:2;1188:9;1179:7;1175:23;1171:32;1168:52;;;1216:1;1213;1206:12;1168:52;1256:9;1243:23;1289:18;1281:6;1278:30;1275:50;;;1321:1;1318;1311:12;1275:50;1344:22;;1397:4;1389:13;;1385:27;-1:-1:-1;1375:55:22;;1426:1;1423;1416:12;1375:55;1462:2;1449:16;1487:49;1503:32;1532:2;1503:32;:::i;:::-;1487:49;:::i;:::-;1559:2;1552:5;1545:17;1599:7;1594:2;1589;1585;1581:11;1577:20;1574:33;1571:53;;;1620:1;1617;1610:12;1571:53;1675:2;1670;1666;1662:11;1657:2;1650:5;1646:14;1633:45;1719:1;1698:14;;;1714:2;1694:23;1687:34;;;;1702:5;1078:673;-1:-1:-1;;;;1078:673:22:o;1964:180::-;2023:6;2076:2;2064:9;2055:7;2051:23;2047:32;2044:52;;;2092:1;2089;2082:12;2044:52;-1:-1:-1;2115:23:22;;1964:180;-1:-1:-1;1964:180:22:o;2149:131::-;-1:-1:-1;;;;;2224:31:22;;2214:42;;2204:70;;2270:1;2267;2260:12;2285:247;2344:6;2397:2;2385:9;2376:7;2372:23;2368:32;2365:52;;;2413:1;2410;2403:12;2365:52;2452:9;2439:23;2471:31;2496:5;2471:31;:::i;2537:258::-;2609:1;2619:113;2633:6;2630:1;2627:13;2619:113;;;2709:11;;;2703:18;2690:11;;;2683:39;2655:2;2648:10;2619:113;;;2750:6;2747:1;2744:13;2741:48;;;2785:1;2776:6;2771:3;2767:16;2760:27;2741:48;;2537:258;;;:::o;2800:::-;2842:3;2880:5;2874:12;2907:6;2902:3;2895:19;2923:63;2979:6;2972:4;2967:3;2963:14;2956:4;2949:5;2945:16;2923:63;:::i;:::-;3040:2;3019:15;-1:-1:-1;;3015:29:22;3006:39;;;;3047:4;3002:50;;2800:258;-1:-1:-1;;2800:258:22:o;3063:220::-;3212:2;3201:9;3194:21;3175:4;3232:45;3273:2;3262:9;3258:18;3250:6;3232:45;:::i;3480:251::-;3550:6;3603:2;3591:9;3582:7;3578:23;3574:32;3571:52;;;3619:1;3616;3609:12;3571:52;3651:9;3645:16;3670:31;3695:5;3670:31;:::i;4433:127::-;4494:10;4489:3;4485:20;4482:1;4475:31;4525:4;4522:1;4515:15;4549:4;4546:1;4539:15;4565:128;4605:3;4636:1;4632:6;4629:1;4626:13;4623:39;;;4642:18;;:::i;:::-;-1:-1:-1;4678:9:22;;4565:128::o;4698:125::-;4738:4;4766:1;4763;4760:8;4757:34;;;4771:18;;:::i;:::-;-1:-1:-1;4808:9:22;;4698:125::o;5528:135::-;5567:3;-1:-1:-1;;5588:17:22;;5585:43;;;5608:18;;:::i;:::-;-1:-1:-1;5655:1:22;5644:13;;5528:135::o;5668:443::-;5900:3;5938:6;5932:13;5954:53;6000:6;5995:3;5988:4;5980:6;5976:17;5954:53;:::i;:::-;-1:-1:-1;;;6029:16:22;;6054:22;;;-1:-1:-1;6103:1:22;6092:13;;5668:443;-1:-1:-1;5668:443:22:o;7111:383::-;7308:2;7297:9;7290:21;7271:4;7334:45;7375:2;7364:9;7360:18;7352:6;7334:45;:::i;:::-;7427:9;7419:6;7415:22;7410:2;7399:9;7395:18;7388:50;7455:33;7481:6;7473;7455:33;:::i;:::-;7447:41;7111:383;-1:-1:-1;;;;;7111:383:22:o;7778:636::-;7858:6;7911:2;7899:9;7890:7;7886:23;7882:32;7879:52;;;7927:1;7924;7917:12;7879:52;7960:9;7954:16;7993:18;7985:6;7982:30;7979:50;;;8025:1;8022;8015:12;7979:50;8048:22;;8101:4;8093:13;;8089:27;-1:-1:-1;8079:55:22;;8130:1;8127;8120:12;8079:55;8159:2;8153:9;8184:49;8200:32;8229:2;8200:32;:::i;8184:49::-;8256:2;8249:5;8242:17;8296:7;8291:2;8286;8282;8278:11;8274:20;8271:33;8268:53;;;8317:1;8314;8307:12;8268:53;8330:54;8381:2;8376;8369:5;8365:14;8360:2;8356;8352:11;8330:54;:::i

ipfs://ee25847d19e4ed75652316c82461db1f456df37ff1158fd78ea1fcffd91e33f4