Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0

// Hideo's quasar fighters 
// presented by Wildxyz


// LICENSE
// This is a modified version of the original code from the
// NounsToken.sol— an implementation of OpenZeppelin's ERC-721:
// https://github.com/nounsDAO/nouns-monorepo/blob/master/packages/nouns-contracts/contracts/NounsToken.sol 
// The original code is licensed under the GPL-3.0 license
// Thank you to the Nouns team for the inspiration and code!


pragma solidity ^0.8.17;

import {UpdatableOperatorFilterer} from './UpdatableOperatorFilterer.sol';
import {RevokableDefaultOperatorFilterer} from './RevokableDefaultOperatorFilterer.sol';
import { Ownable } from './Ownable.sol';
import { ERC721 } from './ERC721.sol';
import { IERC721 } from './IERC721.sol';
import { Strings } from './Strings.sol';
import { IQF } from './IQF.sol';

contract QuasarFighter is IQF, Ownable, RevokableDefaultOperatorFilterer, ERC721 {
    
    uint256 public max_supply = 256; //256;
    bool public revealed = false;

    // An address who has permissions to mint qf tokens
    address public minter;

    // The internal ID tracker
    uint256 public _currentTokenId;

    // URI
    string public baseURI = "https://static.wild.xyz/tokens/1112/metadata/";

    // Mapping of operators to whether they are approved or not
    mapping(address => bool) public authorized;

    // Mapping of addresses flagged for denying token interactions
    mapping(address => bool) public blockList;

    // Mapping of tokenId to hash
    mapping(uint256 => bytes32) public tokenHashes;

    /**
     * @notice Require that the sender is the minter.
     */
    modifier onlyMinter() {
        require(msg.sender == minter, "Sender is not the minter");
        _;
    }

    constructor(address _minter) ERC721("quasar fighter", "QF") {
        minter = _minter;
    }

    /**
     * @notice updates the deny list
     * @param flaggedOperator the address to be added to the deny list
     * @param status whether the address is to be added or removed from the deny list
     */
    function updateDenyList(address flaggedOperator, bool status) public onlyOwner {
        _updateDenyList(flaggedOperator, status);
    }

    function setReveal(bool _revealed) public onlyMinter {
        revealed = _revealed;

        emit Revealed(_revealed);
    }



    /*
     * @notice Override isApprovedForAll
     * @param owner The owner of the Nouns
     * @param operator The operator to check if approved
     */
    function isApprovedForAll(address _owner, address operator) public view override(IERC721, ERC721) returns (bool) {
        
        require(blockList[operator] == false, "Operator has been denied by contract owner."); 

        if (authorized[operator] == true) {
            return true;
        }

        return super.isApprovedForAll(_owner, operator);
    }

    /* OS */
    function setApprovalForAll(address operator, bool approved) public override(IERC721, ERC721) onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

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

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

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

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

    function owner() public view virtual override (Ownable, UpdatableOperatorFilterer) returns (address) {
        return Ownable.owner();
    }

    /**
     * @notice sets the authorized operators for interacting with the contract
     * @param operator the address to be added to the authorized operators
     * @param approved whether the address is approved or not within authorized operators
     */
    function setAuthorized(address operator, bool approved) public onlyOwner {
        authorized[operator] = approved;
    }
    
    /**
     * @notice Mint an qf token to the given address.
     * @dev Only callable by the minter.
     * @param _to The address to mint the qf token to.
     * @return The ID of the newly minted qf token.
     */
    function mint(address _to) public onlyMinter override returns (uint256) {
        require(_currentTokenId < max_supply, "Max supply reached");
        return _mintTo(_to, _currentTokenId++);
    }


    /**
     * @notice Burn a pass.
     * @dev Only callable by the minter.
     * @param tokenId The ID of the qf token to burn.
     */
    function burn(uint256 tokenId) public onlyMinter override {
        _burn(tokenId);
        emit TokenBurned(tokenId);
    }

    /** @notice Provides the tokenURI of a specific token
     * @param _tokenId: the token ID
     * @return the URI of the token
     */
    function tokenURI(uint256 _tokenId)
        public
        view
        override
        returns (string memory)
        {
            require(_exists(_tokenId), "Token does not exist.");
            if (revealed==false) {
                return string(
                    abi.encodePacked(
                        baseURI,
                        Strings.toString(_tokenId),
                        ".json"
                    )
                );
            } else {
                return string(
                    abi.encodePacked(
                        baseURI,
                        Strings.toString(_tokenId),
                        ".json"
                    )
                );
            }
        }

    /**
     * @notice Set the token minter.
     * @dev Only callable by the owner when not locked.
     * @param _minter The address of the new minter.
     */
    function setMinter(address _minter) external onlyOwner override {
        minter = _minter;
        //emit MinterUpdated(_minter);
    }

    

    /**
     * @notice Set the base URI.
     * @dev Only callable by the owner.
     * @param _newBaseURI The new base URI.
    */
    function setBaseURI(string memory _newBaseURI) public onlyOwner override {
        baseURI = _newBaseURI;
    }


    //////////////////////////
    // Internal Functions ////
    //////////////////////////

    /**
     * @notice updates the deny list
     * @param flaggedOperator The address to be approved.
     * @param status True if the operator is approved, false to revoke approval.
     */
    function _updateDenyList(address flaggedOperator, bool status) internal virtual {
        blockList[flaggedOperator] = status;
        //emit OperatorFlagged(flaggedOperator, status);
    }

    function assignTokenHash(uint256 _tokenId) internal virtual {
        uint256 time = block.timestamp;
        bytes32 hash = keccak256(
            abi.encodePacked(
                _tokenId,
                block.number,
                time,
                (time % 200) + 1
            )
        );
        tokenHashes[_tokenId] = hash;

        emit TokenHashCreated(_tokenId, hash);
    }

    /** @notice Mints a new token
     * @param to: the address of the new owner looking to mint
     * @param tokenId: the token ID
     * @return the ID of the newly minted token
     */
    function _mintTo(address to, uint256 tokenId) internal returns (uint256) {
        _mint(to, tokenId);
        assignTokenHash(tokenId);

        emit TokenCreated(tokenId, to);

        return tokenId;
    }

    function totalSupply() public view returns (uint256) {
        return _currentTokenId;
    }

    function getMaxSupply() public view returns (uint256) {
        return max_supply;
    }

}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.3.2 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// 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.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);

        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: GPL-3.0

/// @title Interface for Auction Houses

pragma solidity ^0.8.6;

import { QuasarFighter } from "./QuasarFighter.sol";

interface IAuctionHouse {

    struct Auction {
        // ID for the (ERC721 token ID)
        uint256 tokenId;
        // The current highest bid amount
        uint256 amount;
        // The time that the auction started
        uint256 startTime;
        // The time that the auction is scheduled to end
        uint256 endTime;
        // The address of the current highest bid
        address payable bidder;
        // Whether or not the auction has been settled
        bool settled;
        // amount of time auction was extended
        uint256 extendedTime;
    }


    event AuctionBid(address sender, uint256 value, bool extended);

    event AuctionExtended(uint256 indexed tokenId, uint256 endTime);

    event AuctionSettled(uint256 indexed tokenId, address winner, uint256 amount);

    event AuctionTimeBufferUpdated(uint256 timeBuffer);

    event AuctionReservePriceUpdated(uint256 reservePrice);

    event AuctionMinBidIncrementPercentageUpdated(uint256 minBidIncrementPercentage);

    event AuctionDurationUpdated(uint256 duration);

    event AllowlistMint(address indexed to);

    function setAuctionWinners(address[] memory _auctionWinners, uint256[] memory _price) external;

    // function settleCurrentAndCreateNewAuction() external;

    //function settleAuction(uint256 tokenId) external;

    function setTimes(uint256 _startTime, uint256 _duration) external;

    

    function createBid() external payable;

    function pause() external;

    function unpause() external;

    function setTimeBuffer(uint256 timeBuffer) external;

    // function setMinBidIncrementPercentage(uint8 minBidIncrementPercentage) external;

    function setDuration(uint256 _duration) external;

}

// 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.8.0) (token/ERC721/IERC721.sol)

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`.
     *
     * 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;

    /**
     * @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

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
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

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 `IERC721Receiver.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: GPL-3.0

/// @title Interface for the Token

pragma solidity ^0.8.6;

import './IERC721.sol';

interface IQF is IERC721 {
    event OperatorFlagged(address flaggedOperator, bool status);

    event TokenCreated(uint256 indexed tokenId, address mintedTo);

    event TokenHashCreated(uint256 indexed tokenId, bytes32 hash);

    event TokenBurned(uint256 indexed tokenId);

    event MinterUpdated(address minter);

    event MinterLocked();

    event Revealed(bool revealed);

    function mint(address _to) external returns (uint256);

    //function allowlistMint(address _to) external returns (uint256);

    //function promoMint(address to, uint256 quantity) external returns (uint256);

    function setReveal(bool _revealed) external;

    function burn(uint256 tokenId) external;

    function setMinter(address minter) external;

    //function lockMinter() external;

    function setBaseURI(string memory _newBaseURI) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

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

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

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.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
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// 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":"address","name":"_minter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InitialRegistryAddressCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"RegistryHasBeenRevoked","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":[],"name":"MinterLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"}],"name":"MinterUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"flaggedOperator","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"OperatorFlagged","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":false,"internalType":"bool","name":"revealed","type":"bool"}],"name":"Revealed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"TokenBurned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"mintedTo","type":"address"}],"name":"TokenCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"TokenHashCreated","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":"_currentTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"","type":"address"}],"name":"authorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"blockList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"isOperatorFilterRegistryRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"max_supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"revokeOperatorFilterRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setAuthorized","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_revealed","type":"bool"}],"name":"setReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenHashes","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"flaggedOperator","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"updateDenyList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"}],"name":"updateOperatorFilterRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000009daf56fb5d08b1dad7e6a46e0d5e814f41d1b7f9

-----Decoded View---------------
Arg [0] : _minter (address): 0x9DAF56fB5d08b1dad7e6A46e0d5E814F41d1b7F9

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000009daf56fb5d08b1dad7e6a46e0d5e814f41d1b7f9

845:7152:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1505:300:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2406:98;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1072:21:14;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3870:167:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3073:172:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7808:92;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3251:178;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2206:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3435:186;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4969:124;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7906:88;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;981:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6407:111;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2527:472:17;;;:::i;:::-;;2125:219:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4627:196:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1179:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1864:204:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4278:121:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1661:101:12;;;:::i;:::-;;1519:46:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;937:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3872:140;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2568:102:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2876:191:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1166:53:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1437:41:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3627:239;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1994:412:17;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1321:42:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5238:721;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1131:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2064:136;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2495:362;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1104:43:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1911:198:12;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6127:136:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1505:300:3;1607:4;1657:25;1642:40;;;:11;:40;;;;:104;;;;1713:33;1698:48;;;:11;:48;;;;1642:104;:156;;;;1762:36;1786:11;1762:23;:36::i;:::-;1642:156;1623:175;;1505:300;;;:::o;2406:98::-;2460:13;2492:5;2485:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2406:98;:::o;1072:21:14:-;;;;;;;;;;;;;:::o;3870:167:3:-;3946:7;3965:23;3980:7;3965:14;:23::i;:::-;4006:15;:24;4022:7;4006:24;;;;;;;;;;;;;;;;;;;;;3999:31;;3870:167;;;:::o;3073:172:14:-;3186:8;2644:30:19;2665:8;2644:20;:30::i;:::-;3206:32:14::1;3220:8;3230:7;3206:13;:32::i;:::-;3073:172:::0;;;:::o;7808:92::-;7852:7;7878:15;;7871:22;;7808:92;:::o;3251:178::-;3369:4;2479:10:19;2471:18;;:4;:18;;;2467:81;;2505:32;2526:10;2505:20;:32::i;:::-;2467:81;3385:37:14::1;3404:4;3410:2;3414:7;3385:18;:37::i;:::-;3251:178:::0;;;;:::o;2206:125::-;1696:6;;;;;;;;;;;1682:20;;:10;:20;;;1674:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;2280:9:::1;2269:8;;:20;;;;;;;;;;;;;;;;;;2305:19;2314:9;2305:19;;;;;;:::i;:::-;;;;;;;;2206:125:::0;:::o;3435:186::-;3557:4;2479:10:19;2471:18;;:4;:18;;;2467:81;;2505:32;2526:10;2505:20;:32::i;:::-;2467:81;3573:41:14::1;3596:4;3602:2;3606:7;3573:22;:41::i;:::-;3435:186:::0;;;;:::o;4969:124::-;1696:6;;;;;;;;;;;1682:20;;:10;:20;;;1674:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;5037:14:::1;5043:7;5037:5;:14::i;:::-;5078:7;5066:20;;;;;;;;;;4969:124:::0;:::o;7906:88::-;7951:7;7977:10;;7970:17;;7906:88;:::o;981:28::-;;;;;;;;;;;;;:::o;6407:111::-;1252:12:12;:10;:12::i;:::-;1241:23;;:7;:5;:7::i;:::-;:23;;;1233:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;6500:11:14::1;6490:7;:21;;;;;;:::i;:::-;;6407:111:::0;:::o;2527:472:17:-;2602:7;:5;:7::i;:::-;2588:21;;:10;:21;;;2584:70;;2632:11;;;;;;;;;;;;;;2584:70;2737:31;;;;;;;;;;;2733:93;;;2791:24;;;;;;;;;;;;;;2733:93;2941:1;2884:22;;:60;;;;;;;;;;;;;;;;;;2988:4;2954:31;;:38;;;;;;;;;;;;;;;;;;2527:472::o;2125:219:3:-;2197:7;2216:13;2232:17;2241:7;2232:8;:17::i;:::-;2216:33;;2284:1;2267:19;;:5;:19;;;2259:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;2332:5;2325:12;;;2125:219;;;:::o;4627:196:14:-;4690:7;1696:6;;;;;;;;;;;1682:20;;:10;:20;;;1674:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;4735:10:::1;;4717:15;;:28;4709:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;4785:31;4793:3;4798:15;;:17;;;;;;;;;:::i;:::-;;;;;4785:7;:31::i;:::-;4778:38;;4627:196:::0;;;:::o;1179:71::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1864:204:3:-;1936:7;1980:1;1963:19;;:5;:19;;;1955:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2045:9;:16;2055:5;2045:16;;;;;;;;;;;;;;;;2038:23;;1864:204;;;:::o;4278:121:14:-;1252:12:12;:10;:12::i;:::-;1241:23;;:7;:5;:7::i;:::-;:23;;;1233:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;4384:8:14::1;4361:10;:20;4372:8;4361:20;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;4278:121:::0;;:::o;1661:101:12:-;1252:12;:10;:12::i;:::-;1241:23;;:7;:5;:7::i;:::-;:23;;;1233:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1725:30:::1;1752:1;1725:18;:30::i;:::-;1661:101::o:0;1519:46:14:-;;;;;;;;;;;;;;;;;:::o;937:31::-;;;;:::o;3872:140::-;3964:7;3990:15;:13;:15::i;:::-;3983:22;;3872:140;:::o;2568:102:3:-;2624:13;2656:7;2649:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2568:102;:::o;2876:191:14:-;2997:8;2644:30:19;2665:8;2644:20;:30::i;:::-;3017:43:14::1;3041:8;3051;3017:23;:43::i;:::-;2876:191:::0;;;:::o;1166:53:19:-;;;;;;;;;;;;;:::o;1437:41:14:-;;;;;;;;;;;;;;;;;;;;;;:::o;3627:239::-;3792:4;2479:10:19;2471:18;;:4;:18;;;2467:81;;2505:32;2526:10;2505:20;:32::i;:::-;2467:81;3812:47:14::1;3835:4;3841:2;3845:7;3854:4;3812:22;:47::i;:::-;3627:239:::0;;;;;:::o;1994:412:17:-;2104:7;:5;:7::i;:::-;2090:21;;:10;:21;;;2086:70;;2134:11;;;;;;;;;;;;;;2086:70;2239:31;;;;;;;;;;;2235:93;;;2293:24;;;;;;;;;;;;;;2235:93;2387:11;2338:22;;:61;;;;;;;;;;;;;;;;;;1994:412;:::o;1321:42:14:-;;;;;;;;;;;;;;;;;;;;;;:::o;5238:721::-;5336:13;5381:17;5389:8;5381:7;:17::i;:::-;5373:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;5452:5;5442:15;;:8;;;;;;;;;;;:15;;;5438:511;;5554:7;5587:26;5604:8;5587:16;:26::i;:::-;5512:156;;;;;;;;;:::i;:::-;;;;;;;;;;;;;5477:209;;;;5438:511;5802:7;5835:26;5852:8;5835:16;:26::i;:::-;5760:156;;;;;;;;;:::i;:::-;;;;;;;;;;;;;5725:209;;5238:721;;;;:::o;1131:30::-;;;;:::o;2064:136::-;1252:12:12;:10;:12::i;:::-;1241:23;;:7;:5;:7::i;:::-;:23;;;1233:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2153:40:14::1;2169:15;2186:6;2153:15;:40::i;:::-;2064:136:::0;;:::o;2495:362::-;2602:4;2658:5;2635:28;;:9;:19;2645:8;2635:19;;;;;;;;;;;;;;;;;;;;;;;;;:28;;;2627:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;2751:4;2727:28;;:10;:20;2738:8;2727:20;;;;;;;;;;;;;;;;;;;;;;;;;:28;;;2723:70;;2778:4;2771:11;;;;2723:70;2810:40;2833:6;2841:8;2810:22;:40::i;:::-;2803:47;;2495:362;;;;;:::o;1104:43:17:-;;;;;;;;;;;;;:::o;1911:198:12:-;1252:12;:10;:12::i;:::-;1241:23;;:7;:5;:7::i;:::-;:23;;;1233:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2019:1:::1;1999:22;;:8;:22;;::::0;1991:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;2074:28;2093:8;2074:18;:28::i;:::-;1911:198:::0;:::o;6127:136:14:-;1252:12:12;:10;:12::i;:::-;1241:23;;:7;:5;:7::i;:::-;:23;;;1233:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;6210:7:14::1;6201:6;;:16;;;;;;;;;;;;;;;;;;6127:136:::0;:::o;829:155:2:-;914:4;952:25;937:40;;;:11;:40;;;;930:47;;829:155;;;:::o;13401:133:3:-;13482:16;13490:7;13482;:16::i;:::-;13474:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;13401:133;:::o;1538:207:17:-;1674:1;1631:45;;1639:22;;;;;;;;;;;1631:45;;;1627:112;;1692:36;1719:8;1692:26;:36::i;:::-;1627:112;1538:207;:::o;3403:406:3:-;3483:13;3499:23;3514:7;3499:14;:23::i;:::-;3483:39;;3546:5;3540:11;;:2;:11;;;3532:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;3637:5;3621:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;3646:37;3663:5;3670:12;:10;:12::i;:::-;3646:16;:37::i;:::-;3621:62;3600:170;;;;;;;;;;;;:::i;:::-;;;;;;;;;3781:21;3790:2;3794:7;3781:8;:21::i;:::-;3473:336;3403:406;;:::o;4547:326::-;4736:41;4755:12;:10;:12::i;:::-;4769:7;4736:18;:41::i;:::-;4728:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;4838:28;4848:4;4854:2;4858:7;4838:9;:28::i;:::-;4547:326;;;:::o;4939:179::-;5072:39;5089:4;5095:2;5099:7;5072:39;;;;;;;;;;;;:16;:39::i;:::-;4939:179;;;:::o;10272:762::-;10331:13;10347:23;10362:7;10347:14;:23::i;:::-;10331:39;;10381:51;10402:5;10417:1;10421:7;10430:1;10381:20;:51::i;:::-;10542:23;10557:7;10542:14;:23::i;:::-;10534:31;;10610:15;:24;10626:7;10610:24;;;;;;;;;;;;10603:31;;;;;;;;;;;10870:1;10850:9;:16;10860:5;10850:16;;;;;;;;;;;;;;;;:21;;;;;;;;;;;10898:7;:16;10906:7;10898:16;;;;;;;;;;;;10891:23;;;;;;;;;;;10958:7;10954:1;10930:36;;10939:5;10930:36;;;;;;;;;;;;10977:50;10997:5;11012:1;11016:7;11025:1;10977:19;:50::i;:::-;10321:713;10272:762;:::o;640:96:1:-;693:7;719:10;712:17;;640:96;:::o;6773:115:3:-;6839:7;6865;:16;6873:7;6865:16;;;;;;;;;;;;;;;;;;;;;6858:23;;6773:115;;;:::o;7594:208:14:-;7658:7;7677:18;7683:2;7687:7;7677:5;:18::i;:::-;7705:24;7721:7;7705:15;:24::i;:::-;7758:7;7745:25;7767:2;7745:25;;;;;;:::i;:::-;;;;;;;;7788:7;7781:14;;7594:208;;;;:::o;2263:187:12:-;2336:16;2355:6;;;;;;;;;;;2336:25;;2380:8;2371:6;;:17;;;;;;;;;;;;;;;;;;2434:8;2403:40;;2424:8;2403:40;;;;;;;;;;;;2326:124;2263:187;:::o;1029:85::-;1075:7;1101:6;;;;;;;;;;;1094:13;;1029:85;:::o;4104:153:3:-;4198:52;4217:12;:10;:12::i;:::-;4231:8;4241;4198:18;:52::i;:::-;4104:153;;:::o;5184:314::-;5352:41;5371:12;:10;:12::i;:::-;5385:7;5352:18;:41::i;:::-;5344:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;5453:38;5467:4;5473:2;5477:7;5486:4;5453:13;:38::i;:::-;5184:314;;;;:::o;7191:126::-;7256:4;7308:1;7279:31;;:17;7288:7;7279:8;:17::i;:::-;:31;;;;7272:38;;7191:126;;;:::o;410:696:18:-;466:13;515:14;552:1;532:17;543:5;532:10;:17::i;:::-;:21;515:38;;567:20;601:6;590:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;567:41;;622:11;748:6;744:2;740:15;732:6;728:28;721:35;;783:280;790:4;783:280;;;814:5;;;;;;;;953:8;948:2;941:5;937:14;932:30;927:3;919:44;1007:2;998:11;;;;;;:::i;:::-;;;;;1040:1;1031:5;:10;783:280;1027:21;783:280;1083:6;1076:13;;;;;410:696;;;:::o;6811:189:14:-;6930:6;6901:9;:26;6911:15;6901:26;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;6811:189;;:::o;4323:162:3:-;4420:4;4443:18;:25;4462:5;4443:25;;;;;;;;;;;;;;;:35;4469:8;4443:35;;;;;;;;;;;;;;;;;;;;;;;;;4436:42;;4323:162;;;;:::o;3323:482:19:-;3403:32;3438:22;;;;;;;;;;;3403:57;;3608:1;3579:31;;3587:8;3579:31;;;;:68;;;;;3646:1;3622:8;3614:29;;;:33;3579:68;3575:224;;;3668:8;:26;;;3703:4;3710:8;3668:51;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3663:126;;3765:8;3746:28;;;;;;;;;;;:::i;:::-;;;;;;;;3663:126;3575:224;3393:412;3323:482;:::o;12703:171:3:-;12804:2;12777:15;:24;12793:7;12777:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;12859:7;12855:2;12821:46;;12830:23;12845:7;12830:14;:23::i;:::-;12821:46;;;;;;;;;;;;12703:171;;:::o;7475:261::-;7568:4;7584:13;7600:23;7615:7;7600:14;:23::i;:::-;7584:39;;7652:5;7641:16;;:7;:16;;;:52;;;;7661:32;7678:5;7685:7;7661:16;:32::i;:::-;7641:52;:87;;;;7721:7;7697:31;;:20;7709:7;7697:11;:20::i;:::-;:31;;;7641:87;7633:96;;;7475:261;;;;:::o;11358:1233::-;11512:4;11485:31;;:23;11500:7;11485:14;:23::i;:::-;:31;;;11477:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;11590:1;11576:16;;:2;:16;;;11568:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;11644:42;11665:4;11671:2;11675:7;11684:1;11644:20;:42::i;:::-;11813:4;11786:31;;:23;11801:7;11786:14;:23::i;:::-;:31;;;11778:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;11928:15;:24;11944:7;11928:24;;;;;;;;;;;;11921:31;;;;;;;;;;;12415:1;12396:9;:15;12406:4;12396:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;12447:1;12430:9;:13;12440:2;12430:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;12487:2;12468:7;:16;12476:7;12468:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;12524:7;12520:2;12505:27;;12514:4;12505:27;;;;;;;;;;;;12543:41;12563:4;12569:2;12573:7;12582:1;12543:19;:41::i;:::-;11358:1233;;;:::o;15633:396::-;15817:1;15805:9;:13;15801:222;;;15854:1;15838:18;;:4;:18;;;15834:85;;15895:9;15876;:15;15886:4;15876:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;15834:85;15950:1;15936:16;;:2;:16;;;15932:81;;15989:9;15972;:13;15982:2;15972:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;15932:81;15801:222;15633:396;;;;:::o;16735:153::-;;;;;:::o;9026:920::-;9119:1;9105:16;;:2;:16;;;9097:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;9177:16;9185:7;9177;:16::i;:::-;9176:17;9168:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;9237:48;9266:1;9270:2;9274:7;9283:1;9237:20;:48::i;:::-;9381:16;9389:7;9381;:16::i;:::-;9380:17;9372:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;9789:1;9772:9;:13;9782:2;9772:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;9830:2;9811:7;:16;9819:7;9811:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;9873:7;9869:2;9848:33;;9865:1;9848:33;;;;;;;;;;;;9892:47;9920:1;9924:2;9928:7;9937:1;9892:19;:47::i;:::-;9026:920;;:::o;7006:393:14:-;7076:12;7091:15;7076:30;;7116:12;7188:8;7214:12;7244:4;7281:1;7274:3;7267:4;:10;;;;:::i;:::-;7266:16;;;;:::i;:::-;7154:142;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7131:175;;;;;;7116:190;;7340:4;7316:11;:21;7328:8;7316:21;;;;;;;;;;;:28;;;;7377:8;7360:32;7387:4;7360:32;;;;;;:::i;:::-;;;;;;;;7066:333;;7006:393;:::o;13010:307:3:-;13160:8;13151:17;;:5;:17;;;13143:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;13246:8;13208:18;:25;13227:5;13208:25;;;;;;;;;;;;;;;:35;13234:8;13208:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;13291:8;13269:41;;13284:5;13269:41;;;13301:8;13269:41;;;;;;:::i;:::-;;;;;;;;13010:307;;;:::o;6359:305::-;6509:28;6519:4;6525:2;6529:7;6509:9;:28::i;:::-;6555:47;6578:4;6584:2;6588:7;6597:4;6555:22;:47::i;:::-;6547:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;6359:305;;;;:::o;9889:890:11:-;9942:7;9961:14;9978:1;9961:18;;10026:6;10017:5;:15;10013:99;;10061:6;10052:15;;;;;;:::i;:::-;;;;;10095:2;10085:12;;;;10013:99;10138:6;10129:5;:15;10125:99;;10173:6;10164:15;;;;;;:::i;:::-;;;;;10207:2;10197:12;;;;10125:99;10250:6;10241:5;:15;10237:99;;10285:6;10276:15;;;;;;:::i;:::-;;;;;10319:2;10309:12;;;;10237:99;10362:5;10353;:14;10349:96;;10396:5;10387:14;;;;;;:::i;:::-;;;;;10429:1;10419:11;;;;10349:96;10471:5;10462;:14;10458:96;;10505:5;10496:14;;;;;;:::i;:::-;;;;;10538:1;10528:11;;;;10458:96;10580:5;10571;:14;10567:96;;10614:5;10605:14;;;;;;:::i;:::-;;;;;10647:1;10637:11;;;;10567:96;10689:5;10680;:14;10676:64;;10724:1;10714:11;;;;10676:64;10766:6;10759:13;;;9889:890;;;:::o;14086:831:3:-;14235:4;14255:15;:2;:13;;;:15::i;:::-;14251:660;;;14306:2;14290:36;;;14327:12;:10;:12::i;:::-;14341:4;14347:7;14356:4;14290:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;14286:573;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14545:1;14528:6;:13;:18;14524:321;;14570:60;;;;;;;;;;:::i;:::-;;;;;;;;14524:321;14797:6;14791:13;14782:6;14778:2;14774:15;14767:38;14286:573;14421:41;;;14411:51;;;:6;:51;;;;14404:58;;;;;14251:660;14896:4;14889:11;;14086:831;;;;;;;:::o;1175:320:0:-;1235:4;1487:1;1465:7;:19;;;:23;1458:30;;1175:320;;;:::o;7:75:20:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:126::-;2897:7;2937:42;2930:5;2926:54;2915:65;;2860:126;;;:::o;2992:96::-;3029:7;3058:24;3076:5;3058:24;:::i;:::-;3047:35;;2992:96;;;:::o;3094:118::-;3181:24;3199:5;3181:24;:::i;:::-;3176:3;3169:37;3094:118;;:::o;3218:222::-;3311:4;3349:2;3338:9;3334:18;3326:26;;3362:71;3430:1;3419:9;3415:17;3406:6;3362:71;:::i;:::-;3218:222;;;;:::o;3446:77::-;3483:7;3512:5;3501:16;;3446:77;;;:::o;3529:122::-;3602:24;3620:5;3602:24;:::i;:::-;3595:5;3592:35;3582:63;;3641:1;3638;3631:12;3582:63;3529:122;:::o;3657:139::-;3703:5;3741:6;3728:20;3719:29;;3757:33;3784:5;3757:33;:::i;:::-;3657:139;;;;:::o;3802:329::-;3861:6;3910:2;3898:9;3889:7;3885:23;3881:32;3878:119;;;3916:79;;:::i;:::-;3878:119;4036:1;4061:53;4106:7;4097:6;4086:9;4082:22;4061:53;:::i;:::-;4051:63;;4007:117;3802:329;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:116::-;5937:21;5952:5;5937:21;:::i;:::-;5930:5;5927:32;5917:60;;5973:1;5970;5963:12;5917:60;5867:116;:::o;5989:133::-;6032:5;6070:6;6057:20;6048:29;;6086:30;6110:5;6086:30;:::i;:::-;5989:133;;;;:::o;6128:323::-;6184:6;6233:2;6221:9;6212:7;6208:23;6204:32;6201:119;;;6239:79;;:::i;:::-;6201:119;6359:1;6384:50;6426:7;6417:6;6406:9;6402:22;6384:50;:::i;:::-;6374:60;;6330:114;6128:323;;;;:::o;6457:117::-;6566:1;6563;6556:12;6580:117;6689:1;6686;6679:12;6703:180;6751:77;6748:1;6741:88;6848:4;6845:1;6838:15;6872:4;6869:1;6862:15;6889:281;6972:27;6994:4;6972:27;:::i;:::-;6964:6;6960:40;7102:6;7090:10;7087:22;7066:18;7054:10;7051:34;7048:62;7045:88;;;7113:18;;:::i;:::-;7045:88;7153:10;7149:2;7142:22;6932:238;6889:281;;:::o;7176:129::-;7210:6;7237:20;;:::i;:::-;7227:30;;7266:33;7294:4;7286:6;7266:33;:::i;:::-;7176:129;;;:::o;7311:308::-;7373:4;7463:18;7455:6;7452:30;7449:56;;;7485:18;;:::i;:::-;7449:56;7523:29;7545:6;7523:29;:::i;:::-;7515:37;;7607:4;7601;7597:15;7589:23;;7311:308;;;:::o;7625:146::-;7722:6;7717:3;7712;7699:30;7763:1;7754:6;7749:3;7745:16;7738:27;7625:146;;;:::o;7777:425::-;7855:5;7880:66;7896:49;7938:6;7896:49;:::i;:::-;7880:66;:::i;:::-;7871:75;;7969:6;7962:5;7955:21;8007:4;8000:5;7996:16;8045:3;8036:6;8031:3;8027:16;8024:25;8021:112;;;8052:79;;:::i;:::-;8021:112;8142:54;8189:6;8184:3;8179;8142:54;:::i;:::-;7861:341;7777:425;;;;;:::o;8222:340::-;8278:5;8327:3;8320:4;8312:6;8308:17;8304:27;8294:122;;8335:79;;:::i;:::-;8294:122;8452:6;8439:20;8477:79;8552:3;8544:6;8537:4;8529:6;8525:17;8477:79;:::i;:::-;8468:88;;8284:278;8222:340;;;;:::o;8568:509::-;8637:6;8686:2;8674:9;8665:7;8661:23;8657:32;8654:119;;;8692:79;;:::i;:::-;8654:119;8840:1;8829:9;8825:17;8812:31;8870:18;8862:6;8859:30;8856:117;;;8892:79;;:::i;:::-;8856:117;8997:63;9052:7;9043:6;9032:9;9028:22;8997:63;:::i;:::-;8987:73;;8783:287;8568:509;;;;:::o;9083:329::-;9142:6;9191:2;9179:9;9170:7;9166:23;9162:32;9159:119;;;9197:79;;:::i;:::-;9159:119;9317:1;9342:53;9387:7;9378:6;9367:9;9363:22;9342:53;:::i;:::-;9332:63;;9288:117;9083:329;;;;:::o;9418:468::-;9483:6;9491;9540:2;9528:9;9519:7;9515:23;9511:32;9508:119;;;9546:79;;:::i;:::-;9508:119;9666:1;9691:53;9736:7;9727:6;9716:9;9712:22;9691:53;:::i;:::-;9681:63;;9637:117;9793:2;9819:50;9861:7;9852:6;9841:9;9837:22;9819:50;:::i;:::-;9809:60;;9764:115;9418:468;;;;;:::o;9892:77::-;9929:7;9958:5;9947:16;;9892:77;;;:::o;9975:118::-;10062:24;10080:5;10062:24;:::i;:::-;10057:3;10050:37;9975:118;;:::o;10099:222::-;10192:4;10230:2;10219:9;10215:18;10207:26;;10243:71;10311:1;10300:9;10296:17;10287:6;10243:71;:::i;:::-;10099:222;;;;:::o;10327:60::-;10355:3;10376:5;10369:12;;10327:60;;;:::o;10393:142::-;10443:9;10476:53;10494:34;10503:24;10521:5;10503:24;:::i;:::-;10494:34;:::i;:::-;10476:53;:::i;:::-;10463:66;;10393:142;;;:::o;10541:126::-;10591:9;10624:37;10655:5;10624:37;:::i;:::-;10611:50;;10541:126;;;:::o;10673:158::-;10755:9;10788:37;10819:5;10788:37;:::i;:::-;10775:50;;10673:158;;;:::o;10837:195::-;10956:69;11019:5;10956:69;:::i;:::-;10951:3;10944:82;10837:195;;:::o;11038:286::-;11163:4;11201:2;11190:9;11186:18;11178:26;;11214:103;11314:1;11303:9;11299:17;11290:6;11214:103;:::i;:::-;11038:286;;;;:::o;11330:307::-;11391:4;11481:18;11473:6;11470:30;11467:56;;;11503:18;;:::i;:::-;11467:56;11541:29;11563:6;11541:29;:::i;:::-;11533:37;;11625:4;11619;11615:15;11607:23;;11330:307;;;:::o;11643:423::-;11720:5;11745:65;11761:48;11802:6;11761:48;:::i;:::-;11745:65;:::i;:::-;11736:74;;11833:6;11826:5;11819:21;11871:4;11864:5;11860:16;11909:3;11900:6;11895:3;11891:16;11888:25;11885:112;;;11916:79;;:::i;:::-;11885:112;12006:54;12053:6;12048:3;12043;12006:54;:::i;:::-;11726:340;11643:423;;;;;:::o;12085:338::-;12140:5;12189:3;12182:4;12174:6;12170:17;12166:27;12156:122;;12197:79;;:::i;:::-;12156:122;12314:6;12301:20;12339:78;12413:3;12405:6;12398:4;12390:6;12386:17;12339:78;:::i;:::-;12330:87;;12146:277;12085:338;;;;:::o;12429:943::-;12524:6;12532;12540;12548;12597:3;12585:9;12576:7;12572:23;12568:33;12565:120;;;12604:79;;:::i;:::-;12565:120;12724:1;12749:53;12794:7;12785:6;12774:9;12770:22;12749:53;:::i;:::-;12739:63;;12695:117;12851:2;12877:53;12922:7;12913:6;12902:9;12898:22;12877:53;:::i;:::-;12867:63;;12822:118;12979:2;13005:53;13050:7;13041:6;13030:9;13026:22;13005:53;:::i;:::-;12995:63;;12950:118;13135:2;13124:9;13120:18;13107:32;13166:18;13158:6;13155:30;13152:117;;;13188:79;;:::i;:::-;13152:117;13293:62;13347:7;13338:6;13327:9;13323:22;13293:62;:::i;:::-;13283:72;;13078:287;12429:943;;;;;;;:::o;13378:474::-;13446:6;13454;13503:2;13491:9;13482:7;13478:23;13474:32;13471:119;;;13509:79;;:::i;:::-;13471:119;13629:1;13654:53;13699:7;13690:6;13679:9;13675:22;13654:53;:::i;:::-;13644:63;;13600:117;13756:2;13782:53;13827:7;13818:6;13807:9;13803:22;13782:53;:::i;:::-;13772:63;;13727:118;13378:474;;;;;:::o;13858:180::-;13906:77;13903:1;13896:88;14003:4;14000:1;13993:15;14027:4;14024:1;14017:15;14044:320;14088:6;14125:1;14119:4;14115:12;14105:22;;14172:1;14166:4;14162:12;14193:18;14183:81;;14249:4;14241:6;14237:17;14227:27;;14183:81;14311:2;14303:6;14300:14;14280:18;14277:38;14274:84;;14330:18;;:::i;:::-;14274:84;14095:269;14044:320;;;:::o;14370:174::-;14510:26;14506:1;14498:6;14494:14;14487:50;14370:174;:::o;14550:366::-;14692:3;14713:67;14777:2;14772:3;14713:67;:::i;:::-;14706:74;;14789:93;14878:3;14789:93;:::i;:::-;14907:2;14902:3;14898:12;14891:19;;14550:366;;;:::o;14922:419::-;15088:4;15126:2;15115:9;15111:18;15103:26;;15175:9;15169:4;15165:20;15161:1;15150:9;15146:17;15139:47;15203:131;15329:4;15203:131;:::i;:::-;15195:139;;14922:419;;;:::o;15347:182::-;15487:34;15483:1;15475:6;15471:14;15464:58;15347:182;:::o;15535:366::-;15677:3;15698:67;15762:2;15757:3;15698:67;:::i;:::-;15691:74;;15774:93;15863:3;15774:93;:::i;:::-;15892:2;15887:3;15883:12;15876:19;;15535:366;;;:::o;15907:419::-;16073:4;16111:2;16100:9;16096:18;16088:26;;16160:9;16154:4;16150:20;16146:1;16135:9;16131:17;16124:47;16188:131;16314:4;16188:131;:::i;:::-;16180:139;;15907:419;;;:::o;16332:141::-;16381:4;16404:3;16396:11;;16427:3;16424:1;16417:14;16461:4;16458:1;16448:18;16440:26;;16332:141;;;:::o;16479:93::-;16516:6;16563:2;16558;16551:5;16547:14;16543:23;16533:33;;16479:93;;;:::o;16578:107::-;16622:8;16672:5;16666:4;16662:16;16641:37;;16578:107;;;;:::o;16691:393::-;16760:6;16810:1;16798:10;16794:18;16833:97;16863:66;16852:9;16833:97;:::i;:::-;16951:39;16981:8;16970:9;16951:39;:::i;:::-;16939:51;;17023:4;17019:9;17012:5;17008:21;16999:30;;17072:4;17062:8;17058:19;17051:5;17048:30;17038:40;;16767:317;;16691:393;;;;;:::o;17090:142::-;17140:9;17173:53;17191:34;17200:24;17218:5;17200:24;:::i;:::-;17191:34;:::i;:::-;17173:53;:::i;:::-;17160:66;;17090:142;;;:::o;17238:75::-;17281:3;17302:5;17295:12;;17238:75;;;:::o;17319:269::-;17429:39;17460:7;17429:39;:::i;:::-;17490:91;17539:41;17563:16;17539:41;:::i;:::-;17531:6;17524:4;17518:11;17490:91;:::i;:::-;17484:4;17477:105;17395:193;17319:269;;;:::o;17594:73::-;17639:3;17594:73;:::o;17673:189::-;17750:32;;:::i;:::-;17791:65;17849:6;17841;17835:4;17791:65;:::i;:::-;17726:136;17673:189;;:::o;17868:186::-;17928:120;17945:3;17938:5;17935:14;17928:120;;;17999:39;18036:1;18029:5;17999:39;:::i;:::-;17972:1;17965:5;17961:13;17952:22;;17928:120;;;17868:186;;:::o;18060:543::-;18161:2;18156:3;18153:11;18150:446;;;18195:38;18227:5;18195:38;:::i;:::-;18279:29;18297:10;18279:29;:::i;:::-;18269:8;18265:44;18462:2;18450:10;18447:18;18444:49;;;18483:8;18468:23;;18444:49;18506:80;18562:22;18580:3;18562:22;:::i;:::-;18552:8;18548:37;18535:11;18506:80;:::i;:::-;18165:431;;18150:446;18060:543;;;:::o;18609:117::-;18663:8;18713:5;18707:4;18703:16;18682:37;;18609:117;;;;:::o;18732:169::-;18776:6;18809:51;18857:1;18853:6;18845:5;18842:1;18838:13;18809:51;:::i;:::-;18805:56;18890:4;18884;18880:15;18870:25;;18783:118;18732:169;;;;:::o;18906:295::-;18982:4;19128:29;19153:3;19147:4;19128:29;:::i;:::-;19120:37;;19190:3;19187:1;19183:11;19177:4;19174:21;19166:29;;18906:295;;;;:::o;19206:1395::-;19323:37;19356:3;19323:37;:::i;:::-;19425:18;19417:6;19414:30;19411:56;;;19447:18;;:::i;:::-;19411:56;19491:38;19523:4;19517:11;19491:38;:::i;:::-;19576:67;19636:6;19628;19622:4;19576:67;:::i;:::-;19670:1;19694:4;19681:17;;19726:2;19718:6;19715:14;19743:1;19738:618;;;;20400:1;20417:6;20414:77;;;20466:9;20461:3;20457:19;20451:26;20442:35;;20414:77;20517:67;20577:6;20570:5;20517:67;:::i;:::-;20511:4;20504:81;20373:222;19708:887;;19738:618;19790:4;19786:9;19778:6;19774:22;19824:37;19856:4;19824:37;:::i;:::-;19883:1;19897:208;19911:7;19908:1;19905:14;19897:208;;;19990:9;19985:3;19981:19;19975:26;19967:6;19960:42;20041:1;20033:6;20029:14;20019:24;;20088:2;20077:9;20073:18;20060:31;;19934:4;19931:1;19927:12;19922:17;;19897:208;;;20133:6;20124:7;20121:19;20118:179;;;20191:9;20186:3;20182:19;20176:26;20234:48;20276:4;20268:6;20264:17;20253:9;20234:48;:::i;:::-;20226:6;20219:64;20141:156;20118:179;20343:1;20339;20331:6;20327:14;20323:22;20317:4;20310:36;19745:611;;;19708:887;;19298:1303;;;19206:1395;;:::o;20607:174::-;20747:26;20743:1;20735:6;20731:14;20724:50;20607:174;:::o;20787:366::-;20929:3;20950:67;21014:2;21009:3;20950:67;:::i;:::-;20943:74;;21026:93;21115:3;21026:93;:::i;:::-;21144:2;21139:3;21135:12;21128:19;;20787:366;;;:::o;21159:419::-;21325:4;21363:2;21352:9;21348:18;21340:26;;21412:9;21406:4;21402:20;21398:1;21387:9;21383:17;21376:47;21440:131;21566:4;21440:131;:::i;:::-;21432:139;;21159:419;;;:::o;21584:168::-;21724:20;21720:1;21712:6;21708:14;21701:44;21584:168;:::o;21758:366::-;21900:3;21921:67;21985:2;21980:3;21921:67;:::i;:::-;21914:74;;21997:93;22086:3;21997:93;:::i;:::-;22115:2;22110:3;22106:12;22099:19;;21758:366;;;:::o;22130:419::-;22296:4;22334:2;22323:9;22319:18;22311:26;;22383:9;22377:4;22373:20;22369:1;22358:9;22354:17;22347:47;22411:131;22537:4;22411:131;:::i;:::-;22403:139;;22130:419;;;:::o;22555:180::-;22603:77;22600:1;22593:88;22700:4;22697:1;22690:15;22724:4;22721:1;22714:15;22741:233;22780:3;22803:24;22821:5;22803:24;:::i;:::-;22794:33;;22849:66;22842:5;22839:77;22836:103;;22919:18;;:::i;:::-;22836:103;22966:1;22959:5;22955:13;22948:20;;22741:233;;;:::o;22980:228::-;23120:34;23116:1;23108:6;23104:14;23097:58;23189:11;23184:2;23176:6;23172:15;23165:36;22980:228;:::o;23214:366::-;23356:3;23377:67;23441:2;23436:3;23377:67;:::i;:::-;23370:74;;23453:93;23542:3;23453:93;:::i;:::-;23571:2;23566:3;23562:12;23555:19;;23214:366;;;:::o;23586:419::-;23752:4;23790:2;23779:9;23775:18;23767:26;;23839:9;23833:4;23829:20;23825:1;23814:9;23810:17;23803:47;23867:131;23993:4;23867:131;:::i;:::-;23859:139;;23586:419;;;:::o;24011:171::-;24151:23;24147:1;24139:6;24135:14;24128:47;24011:171;:::o;24188:366::-;24330:3;24351:67;24415:2;24410:3;24351:67;:::i;:::-;24344:74;;24427:93;24516:3;24427:93;:::i;:::-;24545:2;24540:3;24536:12;24529:19;;24188:366;;;:::o;24560:419::-;24726:4;24764:2;24753:9;24749:18;24741:26;;24813:9;24807:4;24803:20;24799:1;24788:9;24784:17;24777:47;24841:131;24967:4;24841:131;:::i;:::-;24833:139;;24560:419;;;:::o;24985:148::-;25087:11;25124:3;25109:18;;24985:148;;;;:::o;25163:874::-;25266:3;25303:5;25297:12;25332:36;25358:9;25332:36;:::i;:::-;25384:89;25466:6;25461:3;25384:89;:::i;:::-;25377:96;;25504:1;25493:9;25489:17;25520:1;25515:166;;;;25695:1;25690:341;;;;25482:549;;25515:166;25599:4;25595:9;25584;25580:25;25575:3;25568:38;25661:6;25654:14;25647:22;25639:6;25635:35;25630:3;25626:45;25619:52;;25515:166;;25690:341;25757:38;25789:5;25757:38;:::i;:::-;25817:1;25831:154;25845:6;25842:1;25839:13;25831:154;;;25919:7;25913:14;25909:1;25904:3;25900:11;25893:35;25969:1;25960:7;25956:15;25945:26;;25867:4;25864:1;25860:12;25855:17;;25831:154;;;26014:6;26009:3;26005:16;25998:23;;25697:334;;25482:549;;25270:767;;25163:874;;;;:::o;26043:390::-;26149:3;26177:39;26210:5;26177:39;:::i;:::-;26232:89;26314:6;26309:3;26232:89;:::i;:::-;26225:96;;26330:65;26388:6;26383:3;26376:4;26369:5;26365:16;26330:65;:::i;:::-;26420:6;26415:3;26411:16;26404:23;;26153:280;26043:390;;;;:::o;26439:155::-;26579:7;26575:1;26567:6;26563:14;26556:31;26439:155;:::o;26600:400::-;26760:3;26781:84;26863:1;26858:3;26781:84;:::i;:::-;26774:91;;26874:93;26963:3;26874:93;:::i;:::-;26992:1;26987:3;26983:11;26976:18;;26600:400;;;:::o;27006:695::-;27284:3;27306:92;27394:3;27385:6;27306:92;:::i;:::-;27299:99;;27415:95;27506:3;27497:6;27415:95;:::i;:::-;27408:102;;27527:148;27671:3;27527:148;:::i;:::-;27520:155;;27692:3;27685:10;;27006:695;;;;;:::o;27707:230::-;27847:34;27843:1;27835:6;27831:14;27824:58;27916:13;27911:2;27903:6;27899:15;27892:38;27707:230;:::o;27943:366::-;28085:3;28106:67;28170:2;28165:3;28106:67;:::i;:::-;28099:74;;28182:93;28271:3;28182:93;:::i;:::-;28300:2;28295:3;28291:12;28284:19;;27943:366;;;:::o;28315:419::-;28481:4;28519:2;28508:9;28504:18;28496:26;;28568:9;28562:4;28558:20;28554:1;28543:9;28539:17;28532:47;28596:131;28722:4;28596:131;:::i;:::-;28588:139;;28315:419;;;:::o;28740:225::-;28880:34;28876:1;28868:6;28864:14;28857:58;28949:8;28944:2;28936:6;28932:15;28925:33;28740:225;:::o;28971:366::-;29113:3;29134:67;29198:2;29193:3;29134:67;:::i;:::-;29127:74;;29210:93;29299:3;29210:93;:::i;:::-;29328:2;29323:3;29319:12;29312:19;;28971:366;;;:::o;29343:419::-;29509:4;29547:2;29536:9;29532:18;29524:26;;29596:9;29590:4;29586:20;29582:1;29571:9;29567:17;29560:47;29624:131;29750:4;29624:131;:::i;:::-;29616:139;;29343:419;;;:::o;29768:220::-;29908:34;29904:1;29896:6;29892:14;29885:58;29977:3;29972:2;29964:6;29960:15;29953:28;29768:220;:::o;29994:366::-;30136:3;30157:67;30221:2;30216:3;30157:67;:::i;:::-;30150:74;;30233:93;30322:3;30233:93;:::i;:::-;30351:2;30346:3;30342:12;30335:19;;29994:366;;;:::o;30366:419::-;30532:4;30570:2;30559:9;30555:18;30547:26;;30619:9;30613:4;30609:20;30605:1;30594:9;30590:17;30583:47;30647:131;30773:4;30647:131;:::i;:::-;30639:139;;30366:419;;;:::o;30791:248::-;30931:34;30927:1;30919:6;30915:14;30908:58;31000:31;30995:2;30987:6;30983:15;30976:56;30791:248;:::o;31045:366::-;31187:3;31208:67;31272:2;31267:3;31208:67;:::i;:::-;31201:74;;31284:93;31373:3;31284:93;:::i;:::-;31402:2;31397:3;31393:12;31386:19;;31045:366;;;:::o;31417:419::-;31583:4;31621:2;31610:9;31606:18;31598:26;;31670:9;31664:4;31660:20;31656:1;31645:9;31641:17;31634:47;31698:131;31824:4;31698:131;:::i;:::-;31690:139;;31417:419;;;:::o;31842:232::-;31982:34;31978:1;31970:6;31966:14;31959:58;32051:15;32046:2;32038:6;32034:15;32027:40;31842:232;:::o;32080:366::-;32222:3;32243:67;32307:2;32302:3;32243:67;:::i;:::-;32236:74;;32319:93;32408:3;32319:93;:::i;:::-;32437:2;32432:3;32428:12;32421:19;;32080:366;;;:::o;32452:419::-;32618:4;32656:2;32645:9;32641:18;32633:26;;32705:9;32699:4;32695:20;32691:1;32680:9;32676:17;32669:47;32733:131;32859:4;32733:131;:::i;:::-;32725:139;;32452:419;;;:::o;32877:180::-;32925:77;32922:1;32915:88;33022:4;33019:1;33012:15;33046:4;33043:1;33036:15;33063:332;33184:4;33222:2;33211:9;33207:18;33199:26;;33235:71;33303:1;33292:9;33288:17;33279:6;33235:71;:::i;:::-;33316:72;33384:2;33373:9;33369:18;33360:6;33316:72;:::i;:::-;33063:332;;;;;:::o;33401:137::-;33455:5;33486:6;33480:13;33471:22;;33502:30;33526:5;33502:30;:::i;:::-;33401:137;;;;:::o;33544:345::-;33611:6;33660:2;33648:9;33639:7;33635:23;33631:32;33628:119;;;33666:79;;:::i;:::-;33628:119;33786:1;33811:61;33864:7;33855:6;33844:9;33840:22;33811:61;:::i;:::-;33801:71;;33757:125;33544:345;;;;:::o;33895:224::-;34035:34;34031:1;34023:6;34019:14;34012:58;34104:7;34099:2;34091:6;34087:15;34080:32;33895:224;:::o;34125:366::-;34267:3;34288:67;34352:2;34347:3;34288:67;:::i;:::-;34281:74;;34364:93;34453:3;34364:93;:::i;:::-;34482:2;34477:3;34473:12;34466:19;;34125:366;;;:::o;34497:419::-;34663:4;34701:2;34690:9;34686:18;34678:26;;34750:9;34744:4;34740:20;34736:1;34725:9;34721:17;34714:47;34778:131;34904:4;34778:131;:::i;:::-;34770:139;;34497:419;;;:::o;34922:223::-;35062:34;35058:1;35050:6;35046:14;35039:58;35131:6;35126:2;35118:6;35114:15;35107:31;34922:223;:::o;35151:366::-;35293:3;35314:67;35378:2;35373:3;35314:67;:::i;:::-;35307:74;;35390:93;35479:3;35390:93;:::i;:::-;35508:2;35503:3;35499:12;35492:19;;35151:366;;;:::o;35523:419::-;35689:4;35727:2;35716:9;35712:18;35704:26;;35776:9;35770:4;35766:20;35762:1;35751:9;35747:17;35740:47;35804:131;35930:4;35804:131;:::i;:::-;35796:139;;35523:419;;;:::o;35948:194::-;35988:4;36008:20;36026:1;36008:20;:::i;:::-;36003:25;;36042:20;36060:1;36042:20;:::i;:::-;36037:25;;36086:1;36083;36079:9;36071:17;;36110:1;36104:4;36101:11;36098:37;;;36115:18;;:::i;:::-;36098:37;35948:194;;;;:::o;36148:191::-;36188:3;36207:20;36225:1;36207:20;:::i;:::-;36202:25;;36241:20;36259:1;36241:20;:::i;:::-;36236:25;;36284:1;36281;36277:9;36270:16;;36305:3;36302:1;36299:10;36296:36;;;36312:18;;:::i;:::-;36296:36;36148:191;;;;:::o;36345:182::-;36485:34;36481:1;36473:6;36469:14;36462:58;36345:182;:::o;36533:366::-;36675:3;36696:67;36760:2;36755:3;36696:67;:::i;:::-;36689:74;;36772:93;36861:3;36772:93;:::i;:::-;36890:2;36885:3;36881:12;36874:19;;36533:366;;;:::o;36905:419::-;37071:4;37109:2;37098:9;37094:18;37086:26;;37158:9;37152:4;37148:20;37144:1;37133:9;37129:17;37122:47;37186:131;37312:4;37186:131;:::i;:::-;37178:139;;36905:419;;;:::o;37330:178::-;37470:30;37466:1;37458:6;37454:14;37447:54;37330:178;:::o;37514:366::-;37656:3;37677:67;37741:2;37736:3;37677:67;:::i;:::-;37670:74;;37753:93;37842:3;37753:93;:::i;:::-;37871:2;37866:3;37862:12;37855:19;;37514:366;;;:::o;37886:419::-;38052:4;38090:2;38079:9;38075:18;38067:26;;38139:9;38133:4;38129:20;38125:1;38114:9;38110:17;38103:47;38167:131;38293:4;38167:131;:::i;:::-;38159:139;;37886:419;;;:::o;38311:176::-;38343:1;38360:20;38378:1;38360:20;:::i;:::-;38355:25;;38394:20;38412:1;38394:20;:::i;:::-;38389:25;;38433:1;38423:35;;38438:18;;:::i;:::-;38423:35;38479:1;38476;38472:9;38467:14;;38311:176;;;;:::o;38493:79::-;38532:7;38561:5;38550:16;;38493:79;;;:::o;38578:157::-;38683:45;38703:24;38721:5;38703:24;:::i;:::-;38683:45;:::i;:::-;38678:3;38671:58;38578:157;;:::o;38741:679::-;38937:3;38952:75;39023:3;39014:6;38952:75;:::i;:::-;39052:2;39047:3;39043:12;39036:19;;39065:75;39136:3;39127:6;39065:75;:::i;:::-;39165:2;39160:3;39156:12;39149:19;;39178:75;39249:3;39240:6;39178:75;:::i;:::-;39278:2;39273:3;39269:12;39262:19;;39291:75;39362:3;39353:6;39291:75;:::i;:::-;39391:2;39386:3;39382:12;39375:19;;39411:3;39404:10;;38741:679;;;;;;;:::o;39426:175::-;39566:27;39562:1;39554:6;39550:14;39543:51;39426:175;:::o;39607:366::-;39749:3;39770:67;39834:2;39829:3;39770:67;:::i;:::-;39763:74;;39846:93;39935:3;39846:93;:::i;:::-;39964:2;39959:3;39955:12;39948:19;;39607:366;;;:::o;39979:419::-;40145:4;40183:2;40172:9;40168:18;40160:26;;40232:9;40226:4;40222:20;40218:1;40207:9;40203:17;40196:47;40260:131;40386:4;40260:131;:::i;:::-;40252:139;;39979:419;;;:::o;40404:237::-;40544:34;40540:1;40532:6;40528:14;40521:58;40613:20;40608:2;40600:6;40596:15;40589:45;40404:237;:::o;40647:366::-;40789:3;40810:67;40874:2;40869:3;40810:67;:::i;:::-;40803:74;;40886:93;40975:3;40886:93;:::i;:::-;41004:2;40999:3;40995:12;40988:19;;40647:366;;;:::o;41019:419::-;41185:4;41223:2;41212:9;41208:18;41200:26;;41272:9;41266:4;41262:20;41258:1;41247:9;41243:17;41236:47;41300:131;41426:4;41300:131;:::i;:::-;41292:139;;41019:419;;;:::o;41444:98::-;41495:6;41529:5;41523:12;41513:22;;41444:98;;;:::o;41548:168::-;41631:11;41665:6;41660:3;41653:19;41705:4;41700:3;41696:14;41681:29;;41548:168;;;;:::o;41722:373::-;41808:3;41836:38;41868:5;41836:38;:::i;:::-;41890:70;41953:6;41948:3;41890:70;:::i;:::-;41883:77;;41969:65;42027:6;42022:3;42015:4;42008:5;42004:16;41969:65;:::i;:::-;42059:29;42081:6;42059:29;:::i;:::-;42054:3;42050:39;42043:46;;41812:283;41722:373;;;;:::o;42101:640::-;42296:4;42334:3;42323:9;42319:19;42311:27;;42348:71;42416:1;42405:9;42401:17;42392:6;42348:71;:::i;:::-;42429:72;42497:2;42486:9;42482:18;42473:6;42429:72;:::i;:::-;42511;42579:2;42568:9;42564:18;42555:6;42511:72;:::i;:::-;42630:9;42624:4;42620:20;42615:2;42604:9;42600:18;42593:48;42658:76;42729:4;42720:6;42658:76;:::i;:::-;42650:84;;42101:640;;;;;;;:::o;42747:141::-;42803:5;42834:6;42828:13;42819:22;;42850:32;42876:5;42850:32;:::i;:::-;42747:141;;;;:::o;42894:349::-;42963:6;43012:2;43000:9;42991:7;42987:23;42983:32;42980:119;;;43018:79;;:::i;:::-;42980:119;43138:1;43163:63;43218:7;43209:6;43198:9;43194:22;43163:63;:::i;:::-;43153:73;;43109:127;42894:349;;;;:::o

ipfs://c22fcc26947f24aebcfaeeac4ea57ecd0d867eba60fc0670160913c9fb756012