Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {ERC721} from "ERC721.sol";
import {DefaultOperatorFilterer} from "DefaultOperatorFilterer.sol";
import {Ownable} from "Ownable.sol";
import "Counters.sol";
import "Strings.sol";
import "ERC2981.sol";
import "IERC20.sol";

/**
 * @title  ExampleERC721
 * @notice This example contract is configured to use the DefaultOperatorFilterer, which automatically registers the
 *         token and subscribes it to OpenSea's curated filters.
 *         Adding the onlyAllowedOperator modifier to the transferFrom and both safeTransferFrom methods ensures that
 *         the msg.sender (operator) is allowed by the OperatorFilterRegistry. Adding the onlyAllowedOperatorApproval
 *         modifier to the approval methods ensures that owners do not approve operators that are not allowed.
 */
contract ZodiacPuppy is ERC721, DefaultOperatorFilterer, Ownable, ERC2981 {
    using Strings for uint256;
    using Counters for Counters.Counter;

    IERC20 public token;

    string private baseURI;
    string public baseExtension = ".json";
    string public contractURI;

    bool public public_mint_status = true;

    uint256 public MAX_SUPPLY = 12000;
    uint256 public publicSaleCost;
    uint256 public max_per_wallet = 12000;
    uint256 public max_per_txn = 12000; 
    uint256 public totalSupply;    
    uint256 public decimals = 6;
    uint96 royaltyFeesInBips;

    address royaltyAddress;    
    address public token_Contract = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;
    address public premintwallet = 0xAb70FABa7c77C04Dd6aF16C2641aA0B1Ad09d3f6;

    mapping(uint256 => uint256) public count;
    mapping(uint256 => uint256) public sectionPrice;
    mapping(uint256 => uint256) public sectionCount;  

    constructor(
        string memory _name,
        string memory _symbol
        
    ) ERC721(_name, _symbol) {
        baseURI = "https://bafybeidmvkfihm56jwdpm6ski2ijarm4myzhwsxzhnu6mzllud436fmx2a.ipfs.nftstorage.link/";
        setRoyaltyInfo(owner(),500);
        token = IERC20(token_Contract);
    }

    function preMintNFTs(uint256 startingID, uint256 endingID) public onlyOwner {
        for (uint256 i = startingID; i <= endingID; i++) {
            _safeMint(premintwallet, i);
            totalSupply++;
        }        
    }

    function mint(uint256 _mintAmount, uint256 _priceSection) public payable {
    require(totalSupply + _mintAmount <= MAX_SUPPLY, "Maximum supply exceeds");
        
    uint256 startTokenId;
    uint256 endTokenId;
    
    // Define the start and end token IDs based on the selected price section
    if (_priceSection == 1) {
        startTokenId = 76;
        endTokenId = 200;
        sectionCount[1] = sectionCount[1] + _mintAmount;        
    } else if (_priceSection == 2) {
        startTokenId = 502;
        endTokenId = 1000;
        sectionCount[2] = sectionCount[2] + _mintAmount;  
    } else if (_priceSection == 3) {
        startTokenId = 1077;
        endTokenId = 1200;
        sectionCount[3] = sectionCount[3] + _mintAmount;  
    } else if (_priceSection == 4) {
        startTokenId = 1502;
        endTokenId = 2000;
        sectionCount[4] = sectionCount[4] + _mintAmount;  
    } else if (_priceSection == 5) {
        startTokenId = 2077;
        endTokenId = 2200;
        sectionCount[5] = sectionCount[5] + _mintAmount;  
    } else if (_priceSection == 6) {
        startTokenId = 2502;
        endTokenId = 3000;
        sectionCount[6] = sectionCount[6] + _mintAmount;  
    } else if (_priceSection == 7) {
        startTokenId = 3077;
        endTokenId = 3200;
        sectionCount[7] = sectionCount[7] + _mintAmount;  
    } else if (_priceSection == 8) {
        startTokenId = 3502;
        endTokenId = 4000;
        sectionCount[8] = sectionCount[8] + _mintAmount;  
    } else if (_priceSection == 9) {
        startTokenId = 4077;
        endTokenId = 4200;
        sectionCount[9] = sectionCount[9] + _mintAmount;  
    } else if (_priceSection == 10) {
        startTokenId = 4502;
        endTokenId = 5000;
        sectionCount[10] = sectionCount[10] + _mintAmount;  
    } else if (_priceSection == 11) {
        startTokenId = 5077;
        endTokenId = 5200;
        sectionCount[11] = sectionCount[11] + _mintAmount;  
    } else if (_priceSection == 12) {
        startTokenId = 5502;
        endTokenId = 6000;
        sectionCount[12] = sectionCount[12] + _mintAmount;  
    } else if (_priceSection == 13) {
        startTokenId = 6077;
        endTokenId = 6200;
        sectionCount[13] = sectionCount[13] + _mintAmount;  
    } else if (_priceSection == 14) {
        startTokenId = 6502;
        endTokenId = 7000;
        sectionCount[14] = sectionCount[14] + _mintAmount;  
    } else if (_priceSection == 15) {
        startTokenId = 7077;
        endTokenId = 7200;
        sectionCount[15] = sectionCount[15] + _mintAmount;  
    } else if (_priceSection == 16) {
        startTokenId = 7502;
        endTokenId = 8000;
        sectionCount[16] = sectionCount[16] + _mintAmount;  
    } else if (_priceSection == 17) {
        startTokenId = 8077;
        endTokenId = 8200;
        sectionCount[17] = sectionCount[17] + _mintAmount;  
    } else if (_priceSection == 18) {
        startTokenId = 8502;
        endTokenId = 9000;
        sectionCount[18] = sectionCount[18] + _mintAmount;  
    } else if (_priceSection == 19) {
        startTokenId = 9077;
        endTokenId = 9200;
        sectionCount[19] = sectionCount[19] + _mintAmount;  
    } else if (_priceSection == 20) {
        startTokenId = 9502;
        endTokenId = 10000;
        sectionCount[20] = sectionCount[20] + _mintAmount;  
    } else if (_priceSection == 21) {
        startTokenId = 10077;
        endTokenId = 10200;
        sectionCount[21] = sectionCount[21] + _mintAmount;  
    } else if (_priceSection == 22) {
        startTokenId = 10502;
        endTokenId = 11000;
        sectionCount[22] = sectionCount[22] + _mintAmount;  
    } else if (_priceSection == 23) {
        startTokenId = 11077;
        endTokenId = 11200;
        sectionCount[23] = sectionCount[23] + _mintAmount;  
    } else if (_priceSection == 24) {
        startTokenId = 11502;
        endTokenId = 12000;
        sectionCount[24] = sectionCount[24] + _mintAmount;  
    } else {
        revert("Invalid price section");
    }
    
    publicSaleCost = sectionPrice[_priceSection];

    if (msg.sender != owner()) {
        require(public_mint_status, "Public mint not available");
        require(_mintAmount + balanceOf(msg.sender) <= max_per_wallet, "Max per wallet exceeds");
        require(_mintAmount <= max_per_txn, "Per txn Limit Reached");
        require(token.balanceOf(msg.sender) >= (publicSaleCost * 10 ** decimals) * _mintAmount, "You do not have enough tokens to perform the transaction");
        token.transferFrom(msg.sender, owner(), (publicSaleCost * 10 ** decimals) * _mintAmount);
    }

    for (uint256 i = 0; i < _mintAmount; i++) {
        uint256 tokenId = startTokenId + count [_priceSection];
        
        if (tokenId >= startTokenId && tokenId <= endTokenId) {
            if (!_exists(tokenId)) {
                count[_priceSection]++;
                totalSupply++;
                _safeMint(msg.sender, tokenId);                
            } else {
                tokenId++;
                count [_priceSection]++;
                totalSupply++;
                _safeMint(msg.sender, tokenId);               
            }
        } else {
            revert("Token ID not within the selected price section");
        }
        
    }

}

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        _requireMinted(tokenId);

        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        return
            bytes(baseURI).length > 0
                ? string(
                    abi.encodePacked(baseURI, tokenId.toString(), baseExtension)
                )
                : "";
    }

    function setApprovalForAll(address operator, bool approved)
        public
        override
        onlyAllowedOperatorApproval(operator)
    {
        super.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId)
        public
        override
        onlyAllowedOperatorApproval(operator)
    {
        super.approve(operator, tokenId);
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    function setRoyaltyInfo(address _receiver, uint96 _royaltyFeesInBips)
        public
        onlyOwner
    {
        royaltyAddress = _receiver;
        royaltyFeesInBips = _royaltyFeesInBips;
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, data);
    }

    function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
        public
        view
        virtual
        override
        returns (address, uint256)
    {
        return (royaltyAddress, calculateRoyalty(_salePrice));
    }

    function calculateRoyalty(uint256 _salePrice)
        public
        view
        returns (uint256)
    {
        return (_salePrice / 10000) * royaltyFeesInBips;
    }

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

    function setBaseExtension(string memory _newBaseExtension)
        public
        onlyOwner
    {
        baseExtension = _newBaseExtension;
    }

    function setPublic_mint_status(bool _public_mint_status) public onlyOwner {
        public_mint_status = _public_mint_status;
    }

    function setPublicSaleCost(uint256 _publicSaleCost) public onlyOwner {
        publicSaleCost = _publicSaleCost;
    }

    function setMax_per_wallet(uint256 _max_per_wallet) public onlyOwner {
        max_per_wallet = _max_per_wallet;
    }

    function setMax_per_txn(uint256 _max_per_txn) public onlyOwner {
        max_per_txn = _max_per_txn;
    }

    function setDecimals(uint256 _decimals) public onlyOwner {
        decimals = _decimals;
    }

    function setRoyaltyAddress(address _royaltyAddress) public onlyOwner {
        royaltyAddress = _royaltyAddress;
    }

    function setPremintwallet(address _premintwallet) public onlyOwner {
        premintwallet = _premintwallet;
    }
    
    function setContractURI(string calldata _contractURI) public onlyOwner {
        contractURI = _contractURI;
    }

    function setTokenContract(address _tokenContract) public onlyOwner{
    token = IERC20(_tokenContract);
    token_Contract = _tokenContract;
    }

    function setSectionPrice(uint256 sectionNumber, uint256 _price) public onlyOwner {
        sectionPrice[sectionNumber] = _price;
    }

    function setBulkSetPrice(uint256[] memory _price) public onlyOwner {
        for(uint256 x = 1; x <= 24; x++){
        sectionPrice[x] = _price[x-1];
        
        }
    }

}

// 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;
        // solhint-disable-next-line no-inline-assembly
        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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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.3._
     */
    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.3._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

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.13;

import {OperatorFilterer} from "OperatorFilterer.sol";

/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "IERC165.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;

import "IERC2981.sol";
import "ERC165.sol";

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

    }

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

      /*  if (revealed == false) {
            return notRevealedUri;
        }*/

        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 overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

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

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

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

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

import "IERC165.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "IERC165.sol";

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {IOperatorFilterRegistry} from "IOperatorFilterRegistry.sol";

/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {IOperatorFilterRegistry} from "IOperatorFilterRegistry.sol";
import {Ownable} from "Ownable.sol";
import {EnumerableSet} from "EnumerableSet.sol";
import {OperatorFilterRegistryErrorsAndEvents} from "OperatorFilterRegistryErrorsAndEvents.sol";

/**
 * @title  OperatorFilterRegistry
 * @notice Borrows heavily from the QQL BlacklistOperatorFilter contract:
 *         https://github.com/qql-art/contracts/blob/main/contracts/BlacklistOperatorFilter.sol
 * @notice This contracts allows tokens or token owners to register specific addresses or codeHashes that may be
 * *       restricted according to the isOperatorAllowed function.
 */
contract OperatorFilterRegistry is IOperatorFilterRegistry, OperatorFilterRegistryErrorsAndEvents {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.Bytes32Set;

    /// @dev initialized accounts have a nonzero codehash (see https://eips.ethereum.org/EIPS/eip-1052)
    /// Note that this will also be a smart contract's codehash when making calls from its constructor.
    bytes32 constant EOA_CODEHASH = keccak256("");

    mapping(address => EnumerableSet.AddressSet) private _filteredOperators;
    mapping(address => EnumerableSet.Bytes32Set) private _filteredCodeHashes;
    mapping(address => address) private _registrations;
    mapping(address => EnumerableSet.AddressSet) private _subscribers;

    /**
     * @notice restricts method caller to the address or EIP-173 "owner()"
     */
    modifier onlyAddressOrOwner(address addr) {
        if (msg.sender != addr) {
            try Ownable(addr).owner() returns (address owner) {
                if (msg.sender != owner) {
                    revert OnlyAddressOrOwner();
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert NotOwnable();
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
        _;
    }

    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool) {
        address registration = _registrations[registrant];
        if (registration != address(0)) {
            EnumerableSet.AddressSet storage filteredOperatorsRef;
            EnumerableSet.Bytes32Set storage filteredCodeHashesRef;

            filteredOperatorsRef = _filteredOperators[registration];
            filteredCodeHashesRef = _filteredCodeHashes[registration];

            if (filteredOperatorsRef.contains(operator)) {
                revert AddressFiltered(operator);
            }
            if (operator.code.length > 0) {
                bytes32 codeHash = operator.codehash;
                if (filteredCodeHashesRef.contains(codeHash)) {
                    revert CodeHashFiltered(operator, codeHash);
                }
            }
        }
        return true;
    }

    //////////////////
    // AUTH METHODS //
    //////////////////

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external onlyAddressOrOwner(registrant) {
        if (_registrations[registrant] != address(0)) {
            revert AlreadyRegistered();
        }
        _registrations[registrant] = registrant;
        emit RegistrationUpdated(registrant, true);
    }

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address registrant) external onlyAddressOrOwner(registrant) {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            _subscribers[registration].remove(registrant);
            emit SubscriptionUpdated(registrant, registration, false);
        }
        _registrations[registrant] = address(0);
        emit RegistrationUpdated(registrant, false);
    }

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external onlyAddressOrOwner(registrant) {
        address registration = _registrations[registrant];
        if (registration != address(0)) {
            revert AlreadyRegistered();
        }
        if (registrant == subscription) {
            revert CannotSubscribeToSelf();
        }
        address subscriptionRegistration = _registrations[subscription];
        if (subscriptionRegistration == address(0)) {
            revert NotRegistered(subscription);
        }
        if (subscriptionRegistration != subscription) {
            revert CannotSubscribeToRegistrantWithSubscription(subscription);
        }

        _registrations[registrant] = subscription;
        _subscribers[subscription].add(registrant);
        emit RegistrationUpdated(registrant, true);
        emit SubscriptionUpdated(registrant, subscription, true);
    }

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy)
        external
        onlyAddressOrOwner(registrant)
    {
        if (registrantToCopy == registrant) {
            revert CannotCopyFromSelf();
        }
        address registration = _registrations[registrant];
        if (registration != address(0)) {
            revert AlreadyRegistered();
        }
        address registrantRegistration = _registrations[registrantToCopy];
        if (registrantRegistration == address(0)) {
            revert NotRegistered(registrantToCopy);
        }
        _registrations[registrant] = registrant;
        emit RegistrationUpdated(registrant, true);
        _copyEntries(registrant, registrantToCopy);
    }

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrant];

        if (!filtered) {
            bool removed = filteredOperatorsRef.remove(operator);
            if (!removed) {
                revert AddressNotFiltered(operator);
            }
        } else {
            bool added = filteredOperatorsRef.add(operator);
            if (!added) {
                revert AddressAlreadyFiltered(operator);
            }
        }
        emit OperatorUpdated(registrant, operator, filtered);
    }

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codeHash, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        if (codeHash == EOA_CODEHASH) {
            revert CannotFilterEOAs();
        }
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrant];

        if (!filtered) {
            bool removed = filteredCodeHashesRef.remove(codeHash);
            if (!removed) {
                revert CodeHashNotFiltered(codeHash);
            }
        } else {
            bool added = filteredCodeHashesRef.add(codeHash);
            if (!added) {
                revert CodeHashAlreadyFiltered(codeHash);
            }
        }
        emit CodeHashUpdated(registrant, codeHash, filtered);
    }

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrant];
        uint256 operatorsLength = operators.length;
        unchecked {
            if (!filtered) {
                for (uint256 i = 0; i < operatorsLength; ++i) {
                    address operator = operators[i];
                    bool removed = filteredOperatorsRef.remove(operator);
                    if (!removed) {
                        revert AddressNotFiltered(operator);
                    }
                }
            } else {
                for (uint256 i = 0; i < operatorsLength; ++i) {
                    address operator = operators[i];
                    bool added = filteredOperatorsRef.add(operator);
                    if (!added) {
                        revert AddressAlreadyFiltered(operator);
                    }
                }
            }
        }
        emit OperatorsUpdated(registrant, operators, filtered);
    }

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrant];
        uint256 codeHashesLength = codeHashes.length;
        unchecked {
            if (!filtered) {
                for (uint256 i = 0; i < codeHashesLength; ++i) {
                    bytes32 codeHash = codeHashes[i];
                    bool removed = filteredCodeHashesRef.remove(codeHash);
                    if (!removed) {
                        revert CodeHashNotFiltered(codeHash);
                    }
                }
            } else {
                for (uint256 i = 0; i < codeHashesLength; ++i) {
                    bytes32 codeHash = codeHashes[i];
                    if (codeHash == EOA_CODEHASH) {
                        revert CannotFilterEOAs();
                    }
                    bool added = filteredCodeHashesRef.add(codeHash);
                    if (!added) {
                        revert CodeHashAlreadyFiltered(codeHash);
                    }
                }
            }
        }
        emit CodeHashesUpdated(registrant, codeHashes, filtered);
    }

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address newSubscription) external onlyAddressOrOwner(registrant) {
        if (registrant == newSubscription) {
            revert CannotSubscribeToSelf();
        }
        if (newSubscription == address(0)) {
            revert CannotSubscribeToZeroAddress();
        }
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration == newSubscription) {
            revert AlreadySubscribed(newSubscription);
        }
        address newSubscriptionRegistration = _registrations[newSubscription];
        if (newSubscriptionRegistration == address(0)) {
            revert NotRegistered(newSubscription);
        }
        if (newSubscriptionRegistration != newSubscription) {
            revert CannotSubscribeToRegistrantWithSubscription(newSubscription);
        }

        if (registration != registrant) {
            _subscribers[registration].remove(registrant);
            emit SubscriptionUpdated(registrant, registration, false);
        }
        _registrations[registrant] = newSubscription;
        _subscribers[newSubscription].add(registrant);
        emit SubscriptionUpdated(registrant, newSubscription, true);
    }

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external onlyAddressOrOwner(registrant) {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration == registrant) {
            revert NotSubscribed();
        }
        _subscribers[registration].remove(registrant);
        _registrations[registrant] = registrant;
        emit SubscriptionUpdated(registrant, registration, false);
        if (copyExistingEntries) {
            _copyEntries(registrant, registration);
        }
    }

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external onlyAddressOrOwner(registrant) {
        if (registrant == registrantToCopy) {
            revert CannotCopyFromSelf();
        }
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        address registrantRegistration = _registrations[registrantToCopy];
        if (registrantRegistration == address(0)) {
            revert NotRegistered(registrantToCopy);
        }
        _copyEntries(registrant, registrantToCopy);
    }

    /// @dev helper to copy entries from registrantToCopy to registrant and emit events
    function _copyEntries(address registrant, address registrantToCopy) private {
        EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrantToCopy];
        EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrantToCopy];
        uint256 filteredOperatorsLength = filteredOperatorsRef.length();
        uint256 filteredCodeHashesLength = filteredCodeHashesRef.length();
        unchecked {
            for (uint256 i = 0; i < filteredOperatorsLength; ++i) {
                address operator = filteredOperatorsRef.at(i);
                bool added = _filteredOperators[registrant].add(operator);
                if (added) {
                    emit OperatorUpdated(registrant, operator, true);
                }
            }
            for (uint256 i = 0; i < filteredCodeHashesLength; ++i) {
                bytes32 codehash = filteredCodeHashesRef.at(i);
                bool added = _filteredCodeHashes[registrant].add(codehash);
                if (added) {
                    emit CodeHashUpdated(registrant, codehash, true);
                }
            }
        }
    }

    //////////////////
    // VIEW METHODS //
    //////////////////

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address registrant) external view returns (address subscription) {
        subscription = _registrations[registrant];
        if (subscription == address(0)) {
            revert NotRegistered(registrant);
        } else if (subscription == registrant) {
            subscription = address(0);
        }
    }

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external view returns (address[] memory) {
        return _subscribers[registrant].values();
    }

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external view returns (address) {
        return _subscribers[registrant].at(index);
    }

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external view returns (bool) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredOperators[registration].contains(operator);
        }
        return _filteredOperators[registrant].contains(operator);
    }

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external view returns (bool) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].contains(codeHash);
        }
        return _filteredCodeHashes[registrant].contains(codeHash);
    }

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external view returns (bool) {
        bytes32 codeHash = operatorWithCode.codehash;
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].contains(codeHash);
        }
        return _filteredCodeHashes[registrant].contains(codeHash);
    }

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address registrant) external view returns (bool) {
        return _registrations[registrant] != address(0);
    }

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address registrant) external view returns (address[] memory) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredOperators[registration].values();
        }
        return _filteredOperators[registrant].values();
    }

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address registrant) external view returns (bytes32[] memory) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].values();
        }
        return _filteredCodeHashes[registrant].values();
    }

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external view returns (address) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredOperators[registration].at(index);
        }
        return _filteredOperators[registrant].at(index);
    }

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external view returns (bytes32) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].at(index);
        }
        return _filteredCodeHashes[registrant].at(index);
    }

    /// @dev Convenience method to compute the code hash of an arbitrary contract
    function codeHashOf(address a) external view returns (bytes32) {
        return a.codehash;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract OperatorFilterRegistryErrorsAndEvents {
    error CannotFilterEOAs();
    error AddressAlreadyFiltered(address operator);
    error AddressNotFiltered(address operator);
    error CodeHashAlreadyFiltered(bytes32 codeHash);
    error CodeHashNotFiltered(bytes32 codeHash);
    error OnlyAddressOrOwner();
    error NotRegistered(address registrant);
    error AlreadyRegistered();
    error AlreadySubscribed(address subscription);
    error NotSubscribed();
    error CannotUpdateWhileSubscribed(address subscription);
    error CannotSubscribeToSelf();
    error CannotSubscribeToZeroAddress();
    error NotOwnable();
    error AddressFiltered(address filtered);
    error CodeHashFiltered(address account, bytes32 codeHash);
    error CannotSubscribeToRegistrantWithSubscription(address registrant);
    error CannotCopyFromSelf();

    event RegistrationUpdated(address indexed registrant, bool indexed registered);
    event OperatorUpdated(address indexed registrant, address indexed operator, bool indexed filtered);
    event OperatorsUpdated(address indexed registrant, address[] operators, bool indexed filtered);
    event CodeHashUpdated(address indexed registrant, bytes32 indexed codeHash, bool indexed filtered);
    event CodeHashesUpdated(address indexed registrant, bytes32[] codeHashes, bool indexed filtered);
    event SubscriptionUpdated(address indexed registrant, address indexed subscription, bool indexed subscribed);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "Context.sol";

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "Ownable.sol";

/**
 * @dev Contract module which provides 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} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

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

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

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() external {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {IOperatorFilterRegistry} from "IOperatorFilterRegistry.sol";
import {Ownable2Step} from "Ownable2Step.sol";

/**
 * @title  OwnedRegistrant
 * @notice Ownable contract that registers itself with the OperatorFilterRegistry and administers its own entries,
 *         to facilitate a subscription whose ownership can be transferred.
 */
contract OwnedRegistrant is Ownable2Step {
    address constant registry = 0x000000000000AAeB6D7670E522A718067333cd4E;

    constructor(address _owner) {
        IOperatorFilterRegistry(registry).register(address(this));
        transferOwnership(_owner);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {RevokableOperatorFilterer} from "RevokableOperatorFilterer.sol";

/**
 * @title  RevokableDefaultOperatorFilterer
 * @notice Inherits from RevokableOperatorFilterer and automatically subscribes to the default OpenSea subscription.
 *         Note that OpenSea will disable creator fee enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */
abstract contract RevokableDefaultOperatorFilterer is RevokableOperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() RevokableOperatorFilterer(0x000000000000AAeB6D7670E522A718067333cd4E, DEFAULT_SUBSCRIPTION, true) {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {UpdatableOperatorFilterer} from "UpdatableOperatorFilterer.sol";
import {IOperatorFilterRegistry} from "IOperatorFilterRegistry.sol";

/**
 * @title  RevokableOperatorFilterer
 * @notice This contract is meant to allow contracts to permanently skip OperatorFilterRegistry checks if desired. The
 *         Registry itself has an "unregister" function, but if the contract is ownable, the owner can re-register at
 *         any point. As implemented, this abstract contract allows the contract owner to permanently skip the
 *         OperatorFilterRegistry checks by calling revokeOperatorFilterRegistry. Once done, the registry
 *         address cannot be further updated.
 *         Note that OpenSea will still disable creator fee enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */
abstract contract RevokableOperatorFilterer is UpdatableOperatorFilterer {
    error RegistryHasBeenRevoked();
    error InitialRegistryAddressCannotBeZeroAddress();

    bool public isOperatorFilterRegistryRevoked;

    constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe)
        UpdatableOperatorFilterer(_registry, subscriptionOrRegistrantToCopy, subscribe)
    {
        // don't allow creating a contract with a permanently revoked registry
        if (_registry == address(0)) {
            revert InitialRegistryAddressCannotBeZeroAddress();
        }
    }

    function _checkFilterOperator(address operator) internal view virtual override {
        if (address(operatorFilterRegistry) != address(0)) {
            super._checkFilterOperator(operator);
        }
    }

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be permanently bypassed, and the address cannot be updated again. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public override {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        // if registry has been revoked, do not allow further updates
        if (isOperatorFilterRegistryRevoked) {
            revert RegistryHasBeenRevoked();
        }

        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
    }

    /**
     * @notice Revoke the OperatorFilterRegistry address, permanently bypassing checks. OnlyOwner.
     */
    function revokeOperatorFilterRegistry() public {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        // if registry has been revoked, do not allow further updates
        if (isOperatorFilterRegistryRevoked) {
            revert RegistryHasBeenRevoked();
        }

        // set to zero address to bypass checks
        operatorFilterRegistry = IOperatorFilterRegistry(address(0));
        isOperatorFilterRegistryRevoked = true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits;
        temp = value;
        while (temp != 0) {
            buffer[--index] = bytes1(uint8(48 + uint256(temp % 10)));
            temp /= 10;
        }
        return string(buffer);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {IOperatorFilterRegistry} from "IOperatorFilterRegistry.sol";

/**
 * @title  UpdatableOperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry. This contract allows the Owner to update the
 *         OperatorFilterRegistry address via updateOperatorFilterRegistryAddress, including to the zero address,
 *         which will bypass registry checks.
 *         Note that OpenSea will still disable creator fee enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract UpdatableOperatorFilterer {
    error OperatorNotAllowed(address operator);
    error OnlyOwner();

    IOperatorFilterRegistry public operatorFilterRegistry;

    constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) {
        IOperatorFilterRegistry registry = IOperatorFilterRegistry(_registry);
        operatorFilterRegistry = registry;
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(registry).code.length > 0) {
            if (subscribe) {
                registry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    registry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    registry.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be bypassed. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public virtual {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
    }

    /**
     * @dev assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract
     */
    function owner() public view virtual returns (address);

    function _checkFilterOperator(address operator) internal view virtual {
        IOperatorFilterRegistry registry = operatorFilterRegistry;
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(registry) != address(0) && address(registry).code.length > 0) {
            if (!registry.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"calculateRoyalty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"max_per_txn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"max_per_wallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"uint256","name":"_priceSection","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"startingID","type":"uint256"},{"internalType":"uint256","name":"endingID","type":"uint256"}],"name":"preMintNFTs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"premintwallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"public_mint_status","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sectionCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sectionPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_price","type":"uint256[]"}],"name":"setBulkSetPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_contractURI","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_decimals","type":"uint256"}],"name":"setDecimals","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max_per_txn","type":"uint256"}],"name":"setMax_per_txn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max_per_wallet","type":"uint256"}],"name":"setMax_per_wallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_premintwallet","type":"address"}],"name":"setPremintwallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicSaleCost","type":"uint256"}],"name":"setPublicSaleCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_public_mint_status","type":"bool"}],"name":"setPublic_mint_status","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_royaltyAddress","type":"address"}],"name":"setRoyaltyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint96","name":"_royaltyFeesInBips","type":"uint96"}],"name":"setRoyaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"sectionNumber","type":"uint256"},{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setSectionPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenContract","type":"address"}],"name":"setTokenContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token_Contract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000c5a6f64696163205075707079000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025a50000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Zodiac Puppy
Arg [1] : _symbol (string): ZP

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [3] : 5a6f646961632050757070790000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [5] : 5a50000000000000000000000000000000000000000000000000000000000000

869:11145:25:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10145:220;;;;;;;;;;-1:-1:-1;10145:220:25;;;;;:::i;:::-;;:::i;:::-;;;565:14:26;;558:22;540:41;;528:2;513:18;10145:220:25;;;;;;;;9195:204;;;;;;;;;;-1:-1:-1;9195:204:25;;;;;:::i;:::-;;:::i;:::-;;11149:120;;;;;;;;;;-1:-1:-1;11149:120:25;;;;;:::i;:::-;;:::i;2472:100:6:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;4071:171::-;;;;;;;;;;-1:-1:-1;4071:171:6;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2437:32:26;;;2419:51;;2407:2;2392:18;4071:171:6;2273:203:26;8580:189:25;;;;;;;;;;-1:-1:-1;8580:189:25;;;;;:::i;:::-;;:::i;10532:133::-;;;;;;;;;;-1:-1:-1;10532:133:25;;;;;:::i;:::-;;:::i;2149:233::-;;;;;;;;;;-1:-1:-1;2149:233:25;;;;;:::i;:::-;;:::i;1369:26::-;;;;;;;;;;;;;;;;;;;3508:25:26;;;3496:2;3481:18;1369:26:25;3362:177:26;2390:5444:25;;;;;;:::i;:::-;;:::i;8777:197::-;;;;;;;;;;-1:-1:-1;8777:197:25;;;;;:::i;:::-;;:::i;9654:237::-;;;;;;;;;;-1:-1:-1;9654:237:25;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;4069:32:26;;;4051:51;;4133:2;4118:18;;4111:34;;;;4024:18;9654:237:25;3877:274:26;1406:27:25;;;;;;;;;;;;;;;;1207:33;;;;;;;;;;;;;;;;1669:40;;;;;;;;;;-1:-1:-1;1669:40:25;;;;;:::i;:::-;;;;;;;;;;;;;;11277:116;;;;;;;;;;-1:-1:-1;11277:116:25;;;;;:::i;:::-;;:::i;735:142:17:-;;;;;;;;;;;;834:42;735:142;;8982:205:25;;;;;;;;;;-1:-1:-1;8982:205:25;;;;;:::i;:::-;;:::i;1247:29::-;;;;;;;;;;;;;;;;1770:47;;;;;;;;;;-1:-1:-1;1770:47:25;;;;;:::i;:::-;;;;;;;;;;;;;;2182:223:6;;;;;;;;;;-1:-1:-1;2182:223:6;;;;;:::i;:::-;;:::i;1913:207::-;;;;;;;;;;-1:-1:-1;1913:207:6;;;;;:::i;:::-;;:::i;1882:103:18:-;;;;;;;;;;;;;:::i;11830:179:25:-;;;;;;;;;;-1:-1:-1;11830:179:25;;;;;:::i;:::-;;:::i;1161:37::-;;;;;;;;;;-1:-1:-1;1161:37:25;;;;;;;;10801:120;;;;;;;;;;-1:-1:-1;10801:120:25;;;;;:::i;:::-;;:::i;11045:96::-;;;;;;;;;;-1:-1:-1;11045:96:25;;;;;:::i;:::-;;:::i;1234:87:18:-;;;;;;;;;;-1:-1:-1;1307:6:18;;-1:-1:-1;;;;;1307:6:18;1234:87;;10673:120:25;;;;;;;;;;-1:-1:-1;10673:120:25;;;;;:::i;:::-;;:::i;11405:116::-;;;;;;;;;;-1:-1:-1;11405:116:25;;;;;:::i;:::-;;:::i;2641:104:6:-;;;;;;;;;;;;;:::i;8364:208:25:-;;;;;;;;;;-1:-1:-1;8364:208:25;;;;;:::i;:::-;;:::i;9899:174::-;;;;;;;;;;-1:-1:-1;9899:174:25;;;;;:::i;:::-;;:::i;10929:108::-;;;;;;;;;;-1:-1:-1;10929:108:25;;;;;:::i;:::-;;:::i;1283:37::-;;;;;;;;;;;;;;;;1587:73;;;;;;;;;;-1:-1:-1;1587:73:25;;;;-1:-1:-1;;;;;1587:73:25;;;9407:239;;;;;;;;;;-1:-1:-1;9407:239:25;;;;;:::i;:::-;;:::i;11529:149::-;;;;;;;;;;-1:-1:-1;11529:149:25;;;;;:::i;:::-;;:::i;1506:74::-;;;;;;;;;;-1:-1:-1;1506:74:25;;;;-1:-1:-1;;;;;1506:74:25;;;1083:37;;;;;;;;;;;;;:::i;7842:514::-;;;;;;;;;;-1:-1:-1;7842:514:25;;;;;:::i;:::-;;:::i;1327:34::-;;;;;;;;;;;;;;;;1716:47;;;;;;;;;;-1:-1:-1;1716:47:25;;;;;:::i;:::-;;;;;;;;;;;;;;11686:136;;;;;;;;;;-1:-1:-1;11686:136:25;;;;;:::i;:::-;;:::i;10373:151::-;;;;;;;;;;-1:-1:-1;10373:151:25;;;;;:::i;:::-;;:::i;1127:25::-;;;;;;;;;;;;;:::i;4540:164:6:-;;;;;;;;;;-1:-1:-1;4540:164:6;;;;;:::i;:::-;;:::i;2140:201:18:-;;;;;;;;;;-1:-1:-1;2140:201:18;;;;;:::i;:::-;;:::i;1026:19:25:-;;;;;;;;;;-1:-1:-1;1026:19:25;;;;-1:-1:-1;;;;;1026:19:25;;;10145:220;10292:4;10321:36;10345:11;10321:23;:36::i;:::-;10314:43;10145:220;-1:-1:-1;;10145:220:25:o;9195:204::-;1120:13:18;:11;:13::i;:::-;-1:-1:-1;;;;;9353:38:25::1;-1:-1:-1::0;;;;;9316:26:25;;::::1;-1:-1:-1::0;;;9316:26:25::1;-1:-1:-1::0;;9353:38:25;::::1;9316:14;9353:38:::0;9195:204::o;11149:120::-;1120:13:18;:11;:13::i;:::-;11229:14:25::1;:32:::0;;-1:-1:-1;;;;;11229:32:25;;::::1;-1:-1:-1::0;;;11229:32:25::1;-1:-1:-1::0;;;;;11229:32:25;;::::1;::::0;;;::::1;::::0;;11149:120::o;2472:100:6:-;2526:13;2559:5;2552:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2472:100;:::o;4071:171::-;4147:7;4167:23;4182:7;4167:14;:23::i;:::-;-1:-1:-1;4210:24:6;;;;:15;:24;;;;;;-1:-1:-1;;;;;4210:24:6;;4071:171::o;8580:189:25:-;8703:8;2225:30:17;2246:8;2225:20;:30::i;:::-;8729:32:25::1;8743:8;8753:7;8729:13;:32::i;:::-;8580:189:::0;;;:::o;10532:133::-;1120:13:18;:11;:13::i;:::-;10617:18:25::1;:40:::0;;-1:-1:-1;;10617:40:25::1;::::0;::::1;;::::0;;;::::1;::::0;;10532:133::o;2149:233::-;1120:13:18;:11;:13::i;:::-;2253:10:25;2236:131:::1;2270:8;2265:1;:13;2236:131;;2310:13;::::0;2300:27:::1;::::0;-1:-1:-1;;;;;2310:13:25::1;2325:1:::0;2300:9:::1;:27::i;:::-;2342:11;:13:::0;;;:11:::1;:13;::::0;::::1;:::i;:::-;;;;;;2280:3;;;;;:::i;:::-;;;;2236:131;;2390:5444:::0;2507:10;;2492:11;2478;;:25;;;;:::i;:::-;:39;;2470:74;;;;-1:-1:-1;;;2470:74:25;;9690:2:26;2470:74:25;;;9672:21:26;9729:2;9709:18;;;9702:30;-1:-1:-1;;;9748:18:26;;;9741:52;9810:18;;2470:74:25;;;;;;;;;2561:20;2588:18;2702:13;2719:1;2702:18;2698:3850;;-1:-1:-1;;2819:1:25;2806:15;;:12;:15;;;;2748:2;;2774:3;;2806:29;;2824:11;;2806:29;:::i;:::-;2801:1;2788:15;;:12;:15;;;:47;2698:3850;;;2861:13;2878:1;2861:18;2857:3691;;-1:-1:-1;;2980:1:25;2967:15;;:12;:15;;;;2907:3;;2934:4;;2967:29;;2985:11;;2967:29;:::i;:::-;2962:1;2949:15;;:12;:15;;;:47;2857:3691;;;3016:13;3033:1;3016:18;3012:3536;;-1:-1:-1;;3136:1:25;3123:15;;:12;:15;;;;3062:4;;3090;;3123:29;;3141:11;;3123:29;:::i;:::-;3118:1;3105:15;;:12;:15;;;:47;3012:3536;;;3172:13;3189:1;3172:18;3168:3380;;-1:-1:-1;;3292:1:25;3279:15;;:12;:15;;;;3218:4;;3246;;3279:29;;3297:11;;3279:29;:::i;:::-;3274:1;3261:15;;:12;:15;;;:47;3168:3380;;;3328:13;3345:1;3328:18;3324:3224;;-1:-1:-1;;3448:1:25;3435:15;;:12;:15;;;;3374:4;;3402;;3435:29;;3453:11;;3435:29;:::i;:::-;3430:1;3417:15;;:12;:15;;;:47;3324:3224;;;3484:13;3501:1;3484:18;3480:3068;;-1:-1:-1;;3604:1:25;3591:15;;:12;:15;;;;3530:4;;3558;;3591:29;;3609:11;;3591:29;:::i;:::-;3586:1;3573:15;;:12;:15;;;:47;3480:3068;;;3640:13;3657:1;3640:18;3636:2912;;-1:-1:-1;;3760:1:25;3747:15;;:12;:15;;;;3686:4;;3714;;3747:29;;3765:11;;3747:29;:::i;:::-;3742:1;3729:15;;:12;:15;;;:47;3636:2912;;;3796:13;3813:1;3796:18;3792:2756;;-1:-1:-1;;3916:1:25;3903:15;;:12;:15;;;;3842:4;;3870;;3903:29;;3921:11;;3903:29;:::i;:::-;3898:1;3885:15;;:12;:15;;;:47;3792:2756;;;3952:13;3969:1;3952:18;3948:2600;;-1:-1:-1;;4072:1:25;4059:15;;:12;:15;;;;3998:4;;4026;;4059:29;;4077:11;;4059:29;:::i;:::-;4054:1;4041:15;;:12;:15;;;:47;3948:2600;;;4108:13;4125:2;4108:19;4104:2444;;-1:-1:-1;;4230:2:25;4217:16;;:12;:16;;;;4155:4;;4183;;4217:30;;4236:11;;4217:30;:::i;:::-;4211:2;4198:16;;:12;:16;;;:49;4104:2444;;;4267:13;4284:2;4267:19;4263:2285;;-1:-1:-1;;4389:2:25;4376:16;;:12;:16;;;;4314:4;;4342;;4376:30;;4395:11;;4376:30;:::i;:::-;4370:2;4357:16;;:12;:16;;;:49;4263:2285;;;4426:13;4443:2;4426:19;4422:2126;;-1:-1:-1;;4548:2:25;4535:16;;:12;:16;;;;4473:4;;4501;;4535:30;;4554:11;;4535:30;:::i;:::-;4529:2;4516:16;;:12;:16;;;:49;4422:2126;;;4585:13;4602:2;4585:19;4581:1967;;-1:-1:-1;;4707:2:25;4694:16;;:12;:16;;;;4632:4;;4660;;4694:30;;4713:11;;4694:30;:::i;:::-;4688:2;4675:16;;:12;:16;;;:49;4581:1967;;;4744:13;4761:2;4744:19;4740:1808;;-1:-1:-1;;4866:2:25;4853:16;;:12;:16;;;;4791:4;;4819;;4853:30;;4872:11;;4853:30;:::i;:::-;4847:2;4834:16;;:12;:16;;;:49;4740:1808;;;4903:13;4920:2;4903:19;4899:1649;;-1:-1:-1;;5025:2:25;5012:16;;:12;:16;;;;4950:4;;4978;;5012:30;;5031:11;;5012:30;:::i;:::-;5006:2;4993:16;;:12;:16;;;:49;4899:1649;;;5062:13;5079:2;5062:19;5058:1490;;-1:-1:-1;;5184:2:25;5171:16;;:12;:16;;;;5109:4;;5137;;5171:30;;5190:11;;5171:30;:::i;:::-;5165:2;5152:16;;:12;:16;;;:49;5058:1490;;;5221:13;5238:2;5221:19;5217:1331;;-1:-1:-1;;5343:2:25;5330:16;;:12;:16;;;;5268:4;;5296;;5330:30;;5349:11;;5330:30;:::i;:::-;5324:2;5311:16;;:12;:16;;;:49;5217:1331;;;5380:13;5397:2;5380:19;5376:1172;;-1:-1:-1;;5502:2:25;5489:16;;:12;:16;;;;5427:4;;5455;;5489:30;;5508:11;;5489:30;:::i;:::-;5483:2;5470:16;;:12;:16;;;:49;5376:1172;;;5539:13;5556:2;5539:19;5535:1013;;-1:-1:-1;;5661:2:25;5648:16;;:12;:16;;;;5586:4;;5614;;5648:30;;5667:11;;5648:30;:::i;:::-;5642:2;5629:16;;:12;:16;;;:49;5535:1013;;;5698:13;5715:2;5698:19;5694:854;;-1:-1:-1;;5821:2:25;5808:16;;:12;:16;;;;5745:4;;5773:5;;5808:30;;5827:11;;5808:30;:::i;:::-;5802:2;5789:16;;:12;:16;;;:49;5694:854;;;5858:13;5875:2;5858:19;5854:694;;-1:-1:-1;;5982:2:25;5969:16;;:12;:16;;;;5905:5;;5934;;5969:30;;5988:11;;5969:30;:::i;:::-;5963:2;5950:16;;:12;:16;;;:49;5854:694;;;6019:13;6036:2;6019:19;6015:533;;-1:-1:-1;;6143:2:25;6130:16;;:12;:16;;;;6066:5;;6095;;6130:30;;6149:11;;6130:30;:::i;:::-;6124:2;6111:16;;:12;:16;;;:49;6015:533;;;6180:13;6197:2;6180:19;6176:372;;-1:-1:-1;;6304:2:25;6291:16;;:12;:16;;;;6227:5;;6256;;6291:30;;6310:11;;6291:30;:::i;:::-;6285:2;6272:16;;:12;:16;;;:49;6176:372;;;6341:13;6358:2;6341:19;6337:211;;-1:-1:-1;;6465:2:25;6452:16;;:12;:16;;;;6388:5;;6417;;6452:30;;6471:11;;6452:30;:::i;:::-;6446:2;6433:16;;:12;:16;;;:49;6337:211;;;6509:31;;-1:-1:-1;;;6509:31:25;;10041:2:26;6509:31:25;;;10023:21:26;10080:2;10060:18;;;10053:30;-1:-1:-1;;;10099:18:26;;;10092:51;10160:18;;6509:31:25;9839:345:26;6337:211:25;6577:27;;;;:12;:27;;;;;;6560:14;:44;1307:6:18;;-1:-1:-1;;;;;1307:6:18;6617:10:25;:21;6613:529;;6659:18;;;;6651:56;;;;-1:-1:-1;;;6651:56:25;;10391:2:26;6651:56:25;;;10373:21:26;10430:2;10410:18;;;10403:30;10469:27;10449:18;;;10442:55;10514:18;;6651:56:25;10189:349:26;6651:56:25;6765:14;;6740:21;6750:10;6740:9;:21::i;:::-;6726:35;;:11;:35;:::i;:::-;:53;;6718:88;;;;-1:-1:-1;;;6718:88:25;;10745:2:26;6718:88:25;;;10727:21:26;10784:2;10764:18;;;10757:30;-1:-1:-1;;;10803:18:26;;;10796:52;10865:18;;6718:88:25;10543:346:26;6718:88:25;6840:11;;6825;:26;;6817:60;;;;-1:-1:-1;;;6817:60:25;;11096:2:26;6817:60:25;;;11078:21:26;11135:2;11115:18;;;11108:30;-1:-1:-1;;;11154:18:26;;;11147:51;11215:18;;6817:60:25;10894:345:26;6817:60:25;6963:11;6951:8;;6945:2;:14;;;;:::i;:::-;6928;;:31;;;;:::i;:::-;6927:47;;;;:::i;:::-;6896:5;;:27;;-1:-1:-1;;;6896:27:25;;6912:10;6896:27;;;2419:51:26;-1:-1:-1;;;;;6896:5:25;;;;:15;;2392:18:26;;6896:27:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:78;;6888:147;;;;-1:-1:-1;;;6888:147:25;;13182:2:26;6888:147:25;;;13164:21:26;13221:2;13201:18;;;13194:30;13260:34;13240:18;;;13233:62;13331:26;13311:18;;;13304:54;13375:19;;6888:147:25;12980:420:26;6888:147:25;7046:5;;-1:-1:-1;;;;;7046:5:25;:18;7065:10;7077:7;1307:6:18;;-1:-1:-1;;;;;1307:6:18;;1234:87;7077:7:25;7122:11;7110:8;;7104:2;:14;;;;:::i;:::-;7087;;:31;;;;:::i;:::-;7086:47;;;;:::i;:::-;7046:88;;-1:-1:-1;;;;;;7046:88:25;;;;;;;-1:-1:-1;;;;;13663:15:26;;;7046:88:25;;;13645:34:26;13715:15;;;;13695:18;;;13688:43;13747:18;;;13740:34;13580:18;;7046:88:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;6613:529;7155:9;7150:679;7174:11;7170:1;:15;7150:679;;;7203:15;7236:21;;;:5;:21;;;;;;7221:36;;:12;:36;:::i;:::-;7203:54;;7293:12;7282:7;:23;;:48;;;;;7320:10;7309:7;:21;;7282:48;7278:534;;;7558:4:6;7156:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7156:16:6;7347:365:25;;7389:20;;;;:5;:20;;;;;:22;;;;;;:::i;:::-;;;;-1:-1:-1;;7430:11:25;:13;;;:11;:13;;;:::i;:::-;;;;;;7462:30;7472:10;7484:7;7462:9;:30::i;:::-;7278:534;;7347:365;7549:9;;;;:::i;:::-;7577:21;;;;:5;:21;;;;;:23;;7549:9;;-1:-1:-1;7577:23:25;;-1:-1:-1;7577:23:25;;;:::i;7278:534::-;7744:56;;-1:-1:-1;;;7744:56:25;;14237:2:26;7744:56:25;;;14219:21:26;14276:2;14256:18;;;14249:30;14315:34;14295:18;;;14288:62;-1:-1:-1;;;14366:18:26;;;14359:44;14420:19;;7744:56:25;14035:410:26;7278:534:25;-1:-1:-1;7187:3:25;;;;:::i;:::-;;;;7150:679;;;;2463:5371;;2390:5444;;:::o;8777:197::-;8912:4;-1:-1:-1;;;;;2052:18:17;;2060:10;2052:18;2048:81;;2086:32;2107:10;2086:20;:32::i;:::-;8929:37:25::1;8948:4;8954:2;8958:7;8929:18;:37::i;:::-;8777:197:::0;;;;:::o;9654:237::-;9838:14;;9796:7;;;;-1:-1:-1;;;9838:14:25;;-1:-1:-1;;;;;9838:14:25;9854:28;9871:10;9854:16;:28::i;:::-;9830:53;;;;9654:237;;;;;:::o;11277:116::-;1120:13:18;:11;:13::i;:::-;11355::25::1;:30:::0;;-1:-1:-1;;;;;;11355:30:25::1;-1:-1:-1::0;;;;;11355:30:25;;;::::1;::::0;;;::::1;::::0;;11277:116::o;8982:205::-;9121:4;-1:-1:-1;;;;;2052:18:17;;2060:10;2052:18;2048:81;;2086:32;2107:10;2086:20;:32::i;:::-;9138:41:25::1;9161:4;9167:2;9171:7;9138:22;:41::i;2182:223:6:-:0;2254:7;7156:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7156:16:6;;2318:56;;;;-1:-1:-1;;;2318:56:6;;14652:2:26;2318:56:6;;;14634:21:26;14691:2;14671:18;;;14664:30;-1:-1:-1;;;14710:18:26;;;14703:54;14774:18;;2318:56:6;14450:348:26;1913:207:6;1985:7;-1:-1:-1;;;;;2013:19:6;;2005:73;;;;-1:-1:-1;;;2005:73:6;;15005:2:26;2005:73:6;;;14987:21:26;15044:2;15024:18;;;15017:30;15083:34;15063:18;;;15056:62;-1:-1:-1;;;15134:18:26;;;15127:39;15183:19;;2005:73:6;14803:405:26;2005:73:6;-1:-1:-1;;;;;;2096:16:6;;;;;:9;:16;;;;;;;1913:207::o;1882:103:18:-;1120:13;:11;:13::i;:::-;1947:30:::1;1974:1;1947:18;:30::i;:::-;1882:103::o:0;11830:179:25:-;1120:13:18;:11;:13::i;:::-;11924:1:25::1;11908:94;11932:2;11927:1;:7;11908:94;;11969:6:::0;11976:3:::1;11978:1;11976::::0;:3:::1;:::i;:::-;11969:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;11951:15:::1;::::0;;;:12:::1;:15:::0;;;;;;;:29;11964:1;11936:3:::1;11964:1:::0;11936:3:::1;:::i;:::-;;;;11908:94;;;;11830:179:::0;:::o;10801:120::-;1120:13:18;:11;:13::i;:::-;10881:14:25::1;:32:::0;10801:120::o;11045:96::-;1120:13:18;:11;:13::i;:::-;11113:8:25::1;:20:::0;11045:96::o;10673:120::-;1120:13:18;:11;:13::i;:::-;10753:14:25::1;:32:::0;10673:120::o;11405:116::-;1120:13:18;:11;:13::i;:::-;11487:11:25::1;:26;11501:12:::0;;11487:11;:26:::1;:::i;2641:104:6:-:0;2697:13;2730:7;2723:14;;;;;:::i;8364:208:25:-;8495:8;2225:30:17;2246:8;2225:20;:30::i;:::-;8521:43:25::1;8545:8;8555;8521:23;:43::i;9899:174::-:0;10048:17;;9993:7;;-1:-1:-1;;;;;10048:17:25;10026:18;10039:5;10026:10;:18;:::i;:::-;10025:40;;;;:::i;10929:108::-;1120:13:18;:11;:13::i;:::-;11003:11:25::1;:26:::0;10929:108::o;9407:239::-;9574:4;-1:-1:-1;;;;;2052:18:17;;2060:10;2052:18;2048:81;;2086:32;2107:10;2086:20;:32::i;:::-;9591:47:25::1;9614:4;9620:2;9624:7;9633:4;9591:22;:47::i;11529:149::-:0;1120:13:18;:11;:13::i;:::-;11602:5:25::1;:30:::0;;-1:-1:-1;;;;;11602:30:25;;::::1;-1:-1:-1::0;;;;;;11602:30:25;;::::1;::::0;::::1;::::0;;;11639:14:::1;:31:::0;;;;::::1;;::::0;;11529:149::o;1083:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7842:514::-;7960:13;7991:23;8006:7;7991:14;:23::i;:::-;7558:4:6;7156:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7156:16:6;8027:113:25;;;;-1:-1:-1;;;8027:113:25;;17995:2:26;8027:113:25;;;17977:21:26;18034:2;18014:18;;;18007:30;18073:34;18053:18;;;18046:62;-1:-1:-1;;;18124:18:26;;;18117:45;18179:19;;8027:113:25;17793:411:26;8027:113:25;8197:1;8179:7;8173:21;;;;;:::i;:::-;;;:25;:175;;;;;;;;;;;;;;;;;8264:7;8273:18;:7;:16;:18::i;:::-;8293:13;8247:60;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;8153:195;7842:514;-1:-1:-1;;7842:514:25:o;11686:136::-;1120:13:18;:11;:13::i;:::-;11778:27:25::1;::::0;;;:12:::1;:27;::::0;;;;;:36;11686:136::o;10373:151::-;1120:13:18;:11;:13::i;:::-;10483::25::1;:33;10499:17:::0;10483:13;:33:::1;:::i;1127:25::-:0;;;;;;;:::i;4540:164:6:-;-1:-1:-1;;;;;4661:25:6;;;4637:4;4661:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4540:164::o;2140:201:18:-;1120:13;:11;:13::i;:::-;-1:-1:-1;;;;;2229:22:18;::::1;2221:73;;;::::0;-1:-1:-1;;;2221:73:18;;20969:2:26;2221:73:18::1;::::0;::::1;20951:21:26::0;21008:2;20988:18;;;20981:30;21047:34;21027:18;;;21020:62;-1:-1:-1;;;21098:18:26;;;21091:36;21144:19;;2221:73:18::1;20767:402:26::0;2221:73:18::1;2305:28;2324:8;2305:18;:28::i;:::-;2140:201:::0;:::o;1400:215:5:-;1502:4;-1:-1:-1;;;;;;1526:41:5;;-1:-1:-1;;;1526:41:5;;:81;;;1571:36;1595:11;1571:23;:36::i;1399:132:18:-;1307:6;;-1:-1:-1;;;;;1307:6:18;669:10:1;1463:23:18;1455:68;;;;-1:-1:-1;;;1455:68:18;;21376:2:26;1455:68:18;;;21358:21:26;;;21395:18;;;21388:30;21454:34;21434:18;;;21427:62;21506:18;;1455:68:18;21174:356:26;13890:135:6;7558:4;7156:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7156:16:6;13964:53;;;;-1:-1:-1;;;13964:53:6;;14652:2:26;13964:53:6;;;14634:21:26;14691:2;14671:18;;;14664:30;-1:-1:-1;;;14710:18:26;;;14703:54;14774:18;;13964:53:6;14450:348:26;2279:412:17;834:42;2468:45;:49;2464:221;;2538:67;;-1:-1:-1;;;2538:67:17;;2589:4;2538:67;;;21747:34:26;-1:-1:-1;;;;;21817:15:26;;21797:18;;;21790:43;834:42:17;;2538;;21682:18:26;;2538:67:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2533:142;;2632:28;;-1:-1:-1;;;2632:28:17;;-1:-1:-1;;;;;2437:32:26;;2632:28:17;;;2419:51:26;2392:18;;2632:28:17;2273:203:26;3589:416:6;3670:13;3686:23;3701:7;3686:14;:23::i;:::-;3670:39;;3734:5;-1:-1:-1;;;;;3728:11:6;:2;-1:-1:-1;;;;;3728:11:6;;3720:57;;;;-1:-1:-1;;;3720:57:6;;22046:2:26;3720:57:6;;;22028:21:26;22085:2;22065:18;;;22058:30;22124:34;22104:18;;;22097:62;-1:-1:-1;;;22175:18:26;;;22168:31;22216:19;;3720:57:6;21844:397:26;3720:57:6;669:10:1;-1:-1:-1;;;;;3812:21:6;;;;:62;;-1:-1:-1;3837:37:6;3854:5;669:10:1;4540:164:6;:::i;3837:37::-;3790:173;;;;-1:-1:-1;;;3790:173:6;;22448:2:26;3790:173:6;;;22430:21:26;22487:2;22467:18;;;22460:30;22526:34;22506:18;;;22499:62;22597:31;22577:18;;;22570:59;22646:19;;3790:173:6;22246:425:26;3790:173:6;3976:21;3985:2;3989:7;3976:8;:21::i;8394:110::-;8470:26;8480:2;8484:7;8470:26;;;;;;;;;;;;:9;:26::i;4771:335::-;4966:41;669:10:1;4999:7:6;4966:18;:41::i;:::-;4958:99;;;;-1:-1:-1;;;4958:99:6;;;;;;;:::i;:::-;5070:28;5080:4;5086:2;5090:7;5070:9;:28::i;5177:185::-;5315:39;5332:4;5338:2;5342:7;5315:39;;;;;;;;;;;;:16;:39::i;2501:191:18:-;2594:6;;;-1:-1:-1;;;;;2611:17:18;;;-1:-1:-1;;;;;;2611:17:18;;;;;;;2644:40;;2594:6;;;2611:17;2594:6;;2644:40;;2575:16;;2644:40;2564:128;2501:191;:::o;4314:155:6:-;4409:52;669:10:1;4442:8:6;4452;4409:18;:52::i;5433:322::-;5607:41;669:10:1;5640:7:6;5607:18;:41::i;:::-;5599:99;;;;-1:-1:-1;;;5599:99:6;;;;;;;:::i;:::-;5709:38;5723:4;5729:2;5733:7;5742:4;5709:13;:38::i;202:730:23:-;258:13;475:5;484:1;475:10;471:51;;-1:-1:-1;;501:10:23;;;;;;;;;;;;-1:-1:-1;;;501:10:23;;;;;202:730::o;471:51::-;546:5;531:12;585:75;592:9;;585:75;;617:8;;;;:::i;:::-;;-1:-1:-1;639:10:23;;-1:-1:-1;647:2:23;639:10;;:::i;:::-;;;585:75;;;669:19;701:6;691:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;691:17:23;-1:-1:-1;757:5:23;;-1:-1:-1;669:39:23;-1:-1:-1;734:6:23;772:123;779:9;;772:123;;848:9;855:2;848:4;:9;:::i;:::-;835:23;;:2;:23;:::i;:::-;822:38;;804:6;811:7;;;:::i;:::-;;;;804:15;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;804:56:23;;;;;;;;-1:-1:-1;874:10:23;882:2;874:10;;:::i;:::-;;;772:123;;;-1:-1:-1;918:6:23;202:730;-1:-1:-1;;;;202:730:23:o;1544:305:6:-;1646:4;-1:-1:-1;;;;;;1683:40:6;;-1:-1:-1;;;1683:40:6;;:105;;-1:-1:-1;;;;;;;1740:48:6;;-1:-1:-1;;;1740:48:6;1683:105;:158;;;-1:-1:-1;;;;;;;;;;935:40:4;;;1805:36:6;827:155:4;13169:174:6;13244:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;13244:29:6;-1:-1:-1;;;;;13244:29:6;;;;;;;;:24;;13298:23;13244:24;13298:14;:23::i;:::-;-1:-1:-1;;;;;13289:46:6;;;;;;;;;;;13169:174;;:::o;8731:319::-;8860:18;8866:2;8870:7;8860:5;:18::i;:::-;8911:53;8942:1;8946:2;8950:7;8959:4;8911:22;:53::i;:::-;8889:153;;;;-1:-1:-1;;;8889:153:6;;;;;;;:::i;7788:264::-;7881:4;7898:13;7914:23;7929:7;7914:14;:23::i;:::-;7898:39;;7967:5;-1:-1:-1;;;;;7956:16:6;:7;-1:-1:-1;;;;;7956:16:6;;:52;;;;7976:32;7993:5;8000:7;7976:16;:32::i;:::-;7956:87;;;;8036:7;-1:-1:-1;;;;;8012:31:6;:20;8024:7;8012:11;:20::i;:::-;-1:-1:-1;;;;;8012:31:6;;7956:87;7948:96;7788:264;-1:-1:-1;;;;7788:264:6:o;11787:1263::-;11946:4;-1:-1:-1;;;;;11919:31:6;:23;11934:7;11919:14;:23::i;:::-;-1:-1:-1;;;;;11919:31:6;;11911:81;;;;-1:-1:-1;;;11911:81:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;12011:16:6;;12003:65;;;;-1:-1:-1;;;12003:65:6;;24375:2:26;12003:65:6;;;24357:21:26;24414:2;24394:18;;;24387:30;24453:34;24433:18;;;24426:62;-1:-1:-1;;;24504:18:26;;;24497:34;24548:19;;12003:65:6;24173:400:26;12003:65:6;12081:42;12102:4;12108:2;12112:7;12121:1;12081:20;:42::i;:::-;12253:4;-1:-1:-1;;;;;12226:31:6;:23;12241:7;12226:14;:23::i;:::-;-1:-1:-1;;;;;12226:31:6;;12218:81;;;;-1:-1:-1;;;12218:81:6;;;;;;;:::i;:::-;12371:24;;;;:15;:24;;;;;;;;12364:31;;-1:-1:-1;;;;;;12364:31:6;;;;;;-1:-1:-1;;;;;12847:15:6;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;12847:20:6;;;12882:13;;;;;;;;;:18;;12364:31;12882:18;;;12922:16;;;:7;:16;;;;;;:21;;;;;;;;;;12961:27;;12387:7;;12961:27;;;8580:189:25;;;:::o;13486:315:6:-;13641:8;-1:-1:-1;;;;;13632:17:6;:5;-1:-1:-1;;;;;13632:17:6;;13624:55;;;;-1:-1:-1;;;13624:55:6;;24780:2:26;13624:55:6;;;24762:21:26;24819:2;24799:18;;;24792:30;24858:27;24838:18;;;24831:55;24903:18;;13624:55:6;24578:349:26;13624:55:6;-1:-1:-1;;;;;13690:25:6;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;13690:46:6;;;;;;;;;;13752:41;;540::26;;;13752::6;;513:18:26;13752:41:6;;;;;;;13486:315;;;:::o;6636:313::-;6792:28;6802:4;6808:2;6812:7;6792:9;:28::i;:::-;6839:47;6862:4;6868:2;6872:7;6881:4;6839:22;:47::i;:::-;6831:110;;;;-1:-1:-1;;;6831:110:6;;;;;;;:::i;9386:942::-;-1:-1:-1;;;;;9466:16:6;;9458:61;;;;-1:-1:-1;;;9458:61:6;;25134:2:26;9458:61:6;;;25116:21:26;;;25153:18;;;25146:30;25212:34;25192:18;;;25185:62;25264:18;;9458:61:6;24932:356:26;9458:61:6;7558:4;7156:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7156:16:6;7582:31;9530:58;;;;-1:-1:-1;;;9530:58:6;;25495:2:26;9530:58:6;;;25477:21:26;25534:2;25514:18;;;25507:30;25573;25553:18;;;25546:58;25621:18;;9530:58:6;25293:352:26;9530:58:6;9601:48;9630:1;9634:2;9638:7;9647:1;9601:20;:48::i;:::-;7558:4;7156:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7156:16:6;7582:31;9739:58;;;;-1:-1:-1;;;9739:58:6;;25495:2:26;9739:58:6;;;25477:21:26;25534:2;25514:18;;;25507:30;25573;25553:18;;;25546:58;25621:18;;9739:58:6;25293:352:26;9739:58:6;-1:-1:-1;;;;;10146:13:6;;;;;;:9;:13;;;;;;;;:18;;10163:1;10146:18;;;10188:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;10188:21:6;;;;;10227:33;10196:7;;10146:13;;10227:33;;10146:13;;10227:33;11908:94:25::1;11830:179:::0;:::o;14589:853:6:-;14743:4;-1:-1:-1;;;;;14764:13:6;;1078:20:0;1116:8;14760:675:6;;14800:71;;-1:-1:-1;;;14800:71:6;;-1:-1:-1;;;;;14800:36:6;;;;;:71;;669:10:1;;14851:4:6;;14857:7;;14866:4;;14800:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14800:71:6;;;;;;;;-1:-1:-1;;14800:71:6;;;;;;;;;;;;:::i;:::-;;;14796:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15041:6;:13;15058:1;15041:18;15037:328;;15084:60;;-1:-1:-1;;;15084:60:6;;;;;;;:::i;15037:328::-;15315:6;15309:13;15300:6;15296:2;15292:15;15285:38;14796:584;-1:-1:-1;;;;;;14922:51:6;-1:-1:-1;;;14922:51:6;;-1:-1:-1;14915:58:6;;14760:675;-1:-1:-1;15419:4:6;14589:853;;;;;;:::o;16174:410::-;16364:1;16352:9;:13;16348:229;;;-1:-1:-1;;;;;16386:18:6;;;16382:87;;-1:-1:-1;;;;;16425:15:6;;;;;;:9;:15;;;;;:28;;16444:9;;16425:15;:28;;16444:9;;16425:28;:::i;:::-;;;;-1:-1:-1;;16382:87:6;-1:-1:-1;;;;;16487:16:6;;;16483:83;;-1:-1:-1;;;;;16524:13:6;;;;;;:9;:13;;;;;:26;;16541:9;;16524:13;:26;;16541:9;;16524:26;:::i;:::-;;;;-1:-1:-1;;16174:410:6;;;;:::o;14:131:26:-;-1:-1:-1;;;;;;88:32:26;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:26:o;592:173::-;660:20;;-1:-1:-1;;;;;709:31:26;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:366::-;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:26;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1141:186::-;1200:6;1253:2;1241:9;1232:7;1228:23;1224:32;1221:52;;;1269:1;1266;1259:12;1221:52;1292:29;1311:9;1292:29;:::i;1332:250::-;1417:1;1427:113;1441:6;1438:1;1435:13;1427:113;;;1517:11;;;1511:18;1498:11;;;1491:39;1463:2;1456:10;1427:113;;;-1:-1:-1;;1574:1:26;1556:16;;1549:27;1332:250::o;1587:271::-;1629:3;1667:5;1661:12;1694:6;1689:3;1682:19;1710:76;1779:6;1772:4;1767:3;1763:14;1756:4;1749:5;1745:16;1710:76;:::i;:::-;1840:2;1819:15;-1:-1:-1;;1815:29:26;1806:39;;;;1847:4;1802:50;;1587:271;-1:-1:-1;;1587:271:26:o;1863:220::-;2012:2;2001:9;1994:21;1975:4;2032:45;2073:2;2062:9;2058:18;2050:6;2032:45;:::i;2088:180::-;2147:6;2200:2;2188:9;2179:7;2175:23;2171:32;2168:52;;;2216:1;2213;2206:12;2168:52;-1:-1:-1;2239:23:26;;2088:180;-1:-1:-1;2088:180:26:o;2481:254::-;2549:6;2557;2610:2;2598:9;2589:7;2585:23;2581:32;2578:52;;;2626:1;2623;2616:12;2578:52;2649:29;2668:9;2649:29;:::i;:::-;2639:39;2725:2;2710:18;;;;2697:32;;-1:-1:-1;;;2481:254:26:o;2740:118::-;2826:5;2819:13;2812:21;2805:5;2802:32;2792:60;;2848:1;2845;2838:12;2863:241;2919:6;2972:2;2960:9;2951:7;2947:23;2943:32;2940:52;;;2988:1;2985;2978:12;2940:52;3027:9;3014:23;3046:28;3068:5;3046:28;:::i;3109:248::-;3177:6;3185;3238:2;3226:9;3217:7;3213:23;3209:32;3206:52;;;3254:1;3251;3244:12;3206:52;-1:-1:-1;;3277:23:26;;;3347:2;3332:18;;;3319:32;;-1:-1:-1;3109:248:26:o;3544:328::-;3621:6;3629;3637;3690:2;3678:9;3669:7;3665:23;3661:32;3658:52;;;3706:1;3703;3696:12;3658:52;3729:29;3748:9;3729:29;:::i;:::-;3719:39;;3777:38;3811:2;3800:9;3796:18;3777:38;:::i;:::-;3767:48;;3862:2;3851:9;3847:18;3834:32;3824:42;;3544:328;;;;;:::o;4396:127::-;4457:10;4452:3;4448:20;4445:1;4438:31;4488:4;4485:1;4478:15;4512:4;4509:1;4502:15;4528:275;4599:2;4593:9;4664:2;4645:13;;-1:-1:-1;;4641:27:26;4629:40;;4699:18;4684:34;;4720:22;;;4681:62;4678:88;;;4746:18;;:::i;:::-;4782:2;4775:22;4528:275;;-1:-1:-1;4528:275:26:o;4808:946::-;4892:6;4923:2;4966;4954:9;4945:7;4941:23;4937:32;4934:52;;;4982:1;4979;4972:12;4934:52;5022:9;5009:23;5051:18;5092:2;5084:6;5081:14;5078:34;;;5108:1;5105;5098:12;5078:34;5146:6;5135:9;5131:22;5121:32;;5191:7;5184:4;5180:2;5176:13;5172:27;5162:55;;5213:1;5210;5203:12;5162:55;5249:2;5236:16;5271:2;5267;5264:10;5261:36;;;5277:18;;:::i;:::-;5323:2;5320:1;5316:10;5306:20;;5346:28;5370:2;5366;5362:11;5346:28;:::i;:::-;5408:15;;;5478:11;;;5474:20;;;5439:12;;;;5506:19;;;5503:39;;;5538:1;5535;5528:12;5503:39;5562:11;;;;5582:142;5598:6;5593:3;5590:15;5582:142;;;5664:17;;5652:30;;5615:12;;;;5702;;;;5582:142;;;5743:5;4808:946;-1:-1:-1;;;;;;;;4808:946:26:o;5759:592::-;5830:6;5838;5891:2;5879:9;5870:7;5866:23;5862:32;5859:52;;;5907:1;5904;5897:12;5859:52;5947:9;5934:23;5976:18;6017:2;6009:6;6006:14;6003:34;;;6033:1;6030;6023:12;6003:34;6071:6;6060:9;6056:22;6046:32;;6116:7;6109:4;6105:2;6101:13;6097:27;6087:55;;6138:1;6135;6128:12;6087:55;6178:2;6165:16;6204:2;6196:6;6193:14;6190:34;;;6220:1;6217;6210:12;6190:34;6265:7;6260:2;6251:6;6247:2;6243:15;6239:24;6236:37;6233:57;;;6286:1;6283;6276:12;6233:57;6317:2;6309:11;;;;;6339:6;;-1:-1:-1;5759:592:26;;-1:-1:-1;;;;5759:592:26:o;6356:315::-;6421:6;6429;6482:2;6470:9;6461:7;6457:23;6453:32;6450:52;;;6498:1;6495;6488:12;6450:52;6521:29;6540:9;6521:29;:::i;:::-;6511:39;;6600:2;6589:9;6585:18;6572:32;6613:28;6635:5;6613:28;:::i;6676:406::-;6740:5;6774:18;6766:6;6763:30;6760:56;;;6796:18;;:::i;:::-;6834:57;6879:2;6858:15;;-1:-1:-1;;6854:29:26;6885:4;6850:40;6834:57;:::i;:::-;6825:66;;6914:6;6907:5;6900:21;6954:3;6945:6;6940:3;6936:16;6933:25;6930:45;;;6971:1;6968;6961:12;6930:45;7020:6;7015:3;7008:4;7001:5;6997:16;6984:43;7074:1;7067:4;7058:6;7051:5;7047:18;7043:29;7036:40;6676:406;;;;;:::o;7087:666::-;7182:6;7190;7198;7206;7259:3;7247:9;7238:7;7234:23;7230:33;7227:53;;;7276:1;7273;7266:12;7227:53;7299:29;7318:9;7299:29;:::i;:::-;7289:39;;7347:38;7381:2;7370:9;7366:18;7347:38;:::i;:::-;7337:48;;7432:2;7421:9;7417:18;7404:32;7394:42;;7487:2;7476:9;7472:18;7459:32;7514:18;7506:6;7503:30;7500:50;;;7546:1;7543;7536:12;7500:50;7569:22;;7622:4;7614:13;;7610:27;-1:-1:-1;7600:55:26;;7651:1;7648;7641:12;7600:55;7674:73;7739:7;7734:2;7721:16;7716:2;7712;7708:11;7674:73;:::i;:::-;7664:83;;;7087:666;;;;;;;:::o;7758:450::-;7827:6;7880:2;7868:9;7859:7;7855:23;7851:32;7848:52;;;7896:1;7893;7886:12;7848:52;7936:9;7923:23;7969:18;7961:6;7958:30;7955:50;;;8001:1;7998;7991:12;7955:50;8024:22;;8077:4;8069:13;;8065:27;-1:-1:-1;8055:55:26;;8106:1;8103;8096:12;8055:55;8129:73;8194:7;8189:2;8176:16;8171:2;8167;8163:11;8129:73;:::i;8213:260::-;8281:6;8289;8342:2;8330:9;8321:7;8317:23;8313:32;8310:52;;;8358:1;8355;8348:12;8310:52;8381:29;8400:9;8381:29;:::i;:::-;8371:39;;8429:38;8463:2;8452:9;8448:18;8429:38;:::i;:::-;8419:48;;8213:260;;;;;:::o;8701:380::-;8780:1;8776:12;;;;8823;;;8844:61;;8898:4;8890:6;8886:17;8876:27;;8844:61;8951:2;8943:6;8940:14;8920:18;8917:38;8914:161;;8997:10;8992:3;8988:20;8985:1;8978:31;9032:4;9029:1;9022:15;9060:4;9057:1;9050:15;8914:161;;8701:380;;;:::o;9086:127::-;9147:10;9142:3;9138:20;9135:1;9128:31;9178:4;9175:1;9168:15;9202:4;9199:1;9192:15;9218:135;9257:3;9278:17;;;9275:43;;9298:18;;:::i;:::-;-1:-1:-1;9345:1:26;9334:13;;9218:135::o;9358:125::-;9423:9;;;9444:10;;;9441:36;;;9457:18;;:::i;11244:422::-;11333:1;11376:5;11333:1;11390:270;11411:7;11401:8;11398:21;11390:270;;;11470:4;11466:1;11462:6;11458:17;11452:4;11449:27;11446:53;;;11479:18;;:::i;:::-;11529:7;11519:8;11515:22;11512:55;;;11549:16;;;;11512:55;11628:22;;;;11588:15;;;;11390:270;;;11394:3;11244:422;;;;;:::o;11671:806::-;11720:5;11750:8;11740:80;;-1:-1:-1;11791:1:26;11805:5;;11740:80;11839:4;11829:76;;-1:-1:-1;11876:1:26;11890:5;;11829:76;11921:4;11939:1;11934:59;;;;12007:1;12002:130;;;;11914:218;;11934:59;11964:1;11955:10;;11978:5;;;12002:130;12039:3;12029:8;12026:17;12023:43;;;12046:18;;:::i;:::-;-1:-1:-1;;12102:1:26;12088:16;;12117:5;;11914:218;;12216:2;12206:8;12203:16;12197:3;12191:4;12188:13;12184:36;12178:2;12168:8;12165:16;12160:2;12154:4;12151:12;12147:35;12144:77;12141:159;;;-1:-1:-1;12253:19:26;;;12285:5;;12141:159;12332:34;12357:8;12351:4;12332:34;:::i;:::-;12402:6;12398:1;12394:6;12390:19;12381:7;12378:32;12375:58;;;12413:18;;:::i;:::-;12451:20;;11671:806;-1:-1:-1;;;11671:806:26:o;12482:131::-;12542:5;12571:36;12598:8;12592:4;12571:36;:::i;12618:168::-;12691:9;;;12722;;12739:15;;;12733:22;;12719:37;12709:71;;12760:18;;:::i;12791:184::-;12861:6;12914:2;12902:9;12893:7;12889:23;12885:32;12882:52;;;12930:1;12927;12920:12;12882:52;-1:-1:-1;12953:16:26;;12791:184;-1:-1:-1;12791:184:26:o;13785:245::-;13852:6;13905:2;13893:9;13884:7;13880:23;13876:32;13873:52;;;13921:1;13918;13911:12;13873:52;13953:9;13947:16;13972:28;13994:5;13972:28;:::i;15213:128::-;15280:9;;;15301:11;;;15298:37;;;15315:18;;:::i;15346:127::-;15407:10;15402:3;15398:20;15395:1;15388:31;15438:4;15435:1;15428:15;15462:4;15459:1;15452:15;15604:545;15706:2;15701:3;15698:11;15695:448;;;15742:1;15767:5;15763:2;15756:17;15812:4;15808:2;15798:19;15882:2;15870:10;15866:19;15863:1;15859:27;15853:4;15849:38;15918:4;15906:10;15903:20;15900:47;;;-1:-1:-1;15941:4:26;15900:47;15996:2;15991:3;15987:12;15984:1;15980:20;15974:4;15970:31;15960:41;;16051:82;16069:2;16062:5;16059:13;16051:82;;;16114:17;;;16095:1;16084:13;16051:82;;;16055:3;;;15604:545;;;:::o;16325:1206::-;16449:18;16444:3;16441:27;16438:53;;;16471:18;;:::i;:::-;16500:94;16590:3;16550:38;16582:4;16576:11;16550:38;:::i;:::-;16544:4;16500:94;:::i;:::-;16620:1;16645:2;16640:3;16637:11;16662:1;16657:616;;;;17317:1;17334:3;17331:93;;;-1:-1:-1;17390:19:26;;;17377:33;17331:93;-1:-1:-1;;16282:1:26;16278:11;;;16274:24;16270:29;16260:40;16306:1;16302:11;;;16257:57;17437:78;;16630:895;;16657:616;15551:1;15544:14;;;15588:4;15575:18;;-1:-1:-1;;16693:17:26;;;16794:9;16816:229;16830:7;16827:1;16824:14;16816:229;;;16919:19;;;16906:33;16891:49;;17026:4;17011:20;;;;16979:1;16967:14;;;;16846:12;16816:229;;;16820:3;17073;17064:7;17061:16;17058:159;;;17197:1;17193:6;17187:3;17181;17178:1;17174:11;17170:21;17166:34;17162:39;17149:9;17144:3;17140:19;17127:33;17123:79;17115:6;17108:95;17058:159;;;17260:1;17254:3;17251:1;17247:11;17243:19;17237:4;17230:33;16630:895;;16325:1206;;;:::o;17536:127::-;17597:10;17592:3;17588:20;17585:1;17578:31;17628:4;17625:1;17618:15;17652:4;17649:1;17642:15;17668:120;17708:1;17734;17724:35;;17739:18;;:::i;:::-;-1:-1:-1;17773:9:26;;17668:120::o;18209:722::-;18259:3;18300:5;18294:12;18329:36;18355:9;18329:36;:::i;:::-;18384:1;18401:18;;;18428:133;;;;18575:1;18570:355;;;;18394:531;;18428:133;-1:-1:-1;;18461:24:26;;18449:37;;18534:14;;18527:22;18515:35;;18506:45;;;-1:-1:-1;18428:133:26;;18570:355;18601:5;18598:1;18591:16;18630:4;18675:2;18672:1;18662:16;18700:1;18714:165;18728:6;18725:1;18722:13;18714:165;;;18806:14;;18793:11;;;18786:35;18849:16;;;;18743:10;;18714:165;;;18718:3;;;18908:6;18903:3;18899:16;18892:23;;18394:531;;;;;18209:722;;;;:::o;18936:469::-;19157:3;19185:38;19219:3;19211:6;19185:38;:::i;:::-;19252:6;19246:13;19268:65;19326:6;19322:2;19315:4;19307:6;19303:17;19268:65;:::i;:::-;19349:50;19391:6;19387:2;19383:15;19375:6;19349:50;:::i;:::-;19342:57;18936:469;-1:-1:-1;;;;;;;18936:469:26:o;19410:1352::-;19536:3;19530:10;19563:18;19555:6;19552:30;19549:56;;;19585:18;;:::i;:::-;19614:97;19704:6;19664:38;19696:4;19690:11;19664:38;:::i;:::-;19658:4;19614:97;:::i;:::-;19766:4;;19830:2;19819:14;;19847:1;19842:663;;;;20549:1;20566:6;20563:89;;;-1:-1:-1;20618:19:26;;;20612:26;20563:89;-1:-1:-1;;16282:1:26;16278:11;;;16274:24;16270:29;16260:40;16306:1;16302:11;;;16257:57;20665:81;;19812:944;;19842:663;15551:1;15544:14;;;15588:4;15575:18;;-1:-1:-1;;19878:20:26;;;19996:236;20010:7;20007:1;20004:14;19996:236;;;20099:19;;;20093:26;20078:42;;20191:27;;;;20159:1;20147:14;;;;20026:19;;19996:236;;;20000:3;20260:6;20251:7;20248:19;20245:201;;;20321:19;;;20315:26;-1:-1:-1;;20404:1:26;20400:14;;;20416:3;20396:24;20392:37;20388:42;20373:58;20358:74;;20245:201;-1:-1:-1;;;;;20492:1:26;20476:14;;;20472:22;20459:36;;-1:-1:-1;19410:1352:26:o;22676:409::-;22878:2;22860:21;;;22917:2;22897:18;;;22890:30;22956:34;22951:2;22936:18;;22929:62;-1:-1:-1;;;23022:2:26;23007:18;;23000:43;23075:3;23060:19;;22676:409::o;23090:112::-;23122:1;23148;23138:35;;23153:18;;:::i;:::-;-1:-1:-1;23187:9:26;;23090:112::o;23207:136::-;23246:3;23274:5;23264:39;;23283:18;;:::i;:::-;-1:-1:-1;;;23319:18:26;;23207:136::o;23348:414::-;23550:2;23532:21;;;23589:2;23569:18;;;23562:30;23628:34;23623:2;23608:18;;23601:62;-1:-1:-1;;;23694:2:26;23679:18;;23672:48;23752:3;23737:19;;23348:414::o;23767:401::-;23969:2;23951:21;;;24008:2;23988:18;;;23981:30;24047:34;24042:2;24027:18;;24020:62;-1:-1:-1;;;24113:2:26;24098:18;;24091:35;24158:3;24143:19;;23767:401::o;25650:489::-;-1:-1:-1;;;;;25919:15:26;;;25901:34;;25971:15;;25966:2;25951:18;;25944:43;26018:2;26003:18;;25996:34;;;26066:3;26061:2;26046:18;;26039:31;;;25844:4;;26087:46;;26113:19;;26105:6;26087:46;:::i;:::-;26079:54;25650:489;-1:-1:-1;;;;;;25650:489:26:o;26144:249::-;26213:6;26266:2;26254:9;26245:7;26241:23;26237:32;26234:52;;;26282:1;26279;26272:12;26234:52;26314:9;26308:16;26333:30;26357:5;26333:30;:::i

ipfs://6981b6628fe209a7ddf5edf9f9a2a211fa70d6363fce0dbb5260e9be25ef7b4f