Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

import "ERC721Psi/ERC721Psi.sol";
import "openzeppelin-contracts/access/Ownable.sol";
import "./Errors.sol";

contract PVPNFT is ERC721Psi, Ownable {
    event NewSale(address sale);
    event TokensRevealed();

    address sale;

    string private baseURI;
    bool private uriAlreadySet;

    modifier onlySale() {
        if (_msgSender() != sale) { revert Blocked(); }
        _;
    }

    modifier onlyOwnerOrSale() {
        if(
            (_msgSender() != owner()) && (_msgSender() != sale)
        ) {
            revert Blocked();
        }
        _;
    }

    constructor(address owner_, address sale_, string memory name_, string memory symbol_, string memory initialURI_) ERC721Psi(name_, symbol_) {
        transferOwnership(owner_);
        baseURI = initialURI_;
        sale = sale_;
    }

    function setSale(address sale_) external onlyOwner {
        if (sale == sale_) { revert AlreadySet(); }
        sale = sale_;
        emit NewSale(sale);
    }

    function reveal(string calldata uri_) external onlyOwner {
        if (uriAlreadySet) { revert AlreadySet(); }
        uriAlreadySet = true;
        emit TokensRevealed();
        baseURI = uri_;
    }

    function mint(address receiver_, uint256 amount_) external onlySale {
        _safeMint(receiver_, amount_);
    }

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

// SPDX-License-Identifier: MIT
/**
  ______ _____   _____ ______ ___  __ _  _  _ 
 |  ____|  __ \ / ____|____  |__ \/_ | || || |
 | |__  | |__) | |        / /   ) || | \| |/ |
 |  __| |  _  /| |       / /   / / | |\_   _/ 
 | |____| | \ \| |____  / /   / /_ | |  | |   
 |______|_|  \_\\_____|/_/   |____||_|  |_|   

 - github: https://github.com/estarriolvetch/ERC721Psi
 - npm: https://www.npmjs.com/package/erc721psi
                                          
 */

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/StorageSlot.sol";
import "solidity-bits/contracts/BitMaps.sol";


contract ERC721Psi is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;
    using BitMaps for BitMaps.BitMap;

    BitMaps.BitMap private _batchHead;

    string private _name;
    string private _symbol;

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

    mapping(uint256 => address) private _tokenApprovals;
    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_;
        _currentIndex = _startTokenId();
    }

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal pure returns (uint256) {
        // It will become modifiable in the future versions
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view virtual returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view virtual returns (uint256) {
        return _currentIndex - _startTokenId();
    }


    /**
     * @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 (uint) 
    {
        require(owner != address(0), "ERC721Psi: balance query for the zero address");

        uint count;
        for( uint i = _startTokenId(); i < _nextTokenId(); ++i ){
            if(_exists(i)){
                if( owner == ownerOf(i)){
                    ++count;
                }
            }
        }
        return count;
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        (address owner, ) = _ownerAndBatchHeadOf(tokenId);
        return owner;
    }

    function _ownerAndBatchHeadOf(uint256 tokenId) internal view returns (address owner, uint256 tokenIdBatchHead){
        require(_exists(tokenId), "ERC721Psi: owner query for nonexistent token");
        tokenIdBatchHead = _getBatchHead(tokenId);
        owner = _owners[tokenIdBatchHead];
    }

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

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

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

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

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }


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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        override
        returns (bool)
    {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721Psi: transfer caller is not owner nor approved"
        );

        _transfer(from, to, tokenId);
    }

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

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

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

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return tokenId < _nextTokenId() && _startTokenId() <= tokenId;
    }

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

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 quantity) internal virtual {
        _safeMint(to, quantity, "");
    }

    
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal virtual {
        uint256 nextTokenId = _nextTokenId();
        _mint(to, quantity);
        require(
            _checkOnERC721Received(address(0), to, nextTokenId, quantity, _data),
            "ERC721Psi: transfer to non ERC721Receiver implementer"
        );
    }


    function _mint(
        address to,
        uint256 quantity
    ) internal virtual {
        uint256 nextTokenId = _nextTokenId();
        
        require(quantity > 0, "ERC721Psi: quantity must be greater 0");
        require(to != address(0), "ERC721Psi: mint to the zero address");
        
        _beforeTokenTransfers(address(0), to, nextTokenId, quantity);
        _currentIndex += quantity;
        _owners[nextTokenId] = to;
        _batchHead.set(nextTokenId);
        _afterTokenTransfers(address(0), to, nextTokenId, quantity);
        
        // Emit events
        for(uint256 tokenId=nextTokenId; tokenId < nextTokenId + quantity; tokenId++){
            emit Transfer(address(0), to, tokenId);
        } 
    }


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

        require(
            owner == from,
            "ERC721Psi: transfer of token that is not own"
        );
        require(to != address(0), "ERC721Psi: transfer to the zero address");

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        uint256 subsequentTokenId = tokenId + 1;

        if(!_batchHead.get(subsequentTokenId) &&  
            subsequentTokenId < _nextTokenId()
        ) {
            _owners[subsequentTokenId] = from;
            _batchHead.set(subsequentTokenId);
        }

        _owners[tokenId] = to;
        if(tokenId != tokenIdBatchHead) {
            _batchHead.set(tokenId);
        }

        emit Transfer(from, to, tokenId);

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

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

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

    function _getBatchHead(uint256 tokenId) internal view returns (uint256 tokenIdBatchHead) {
        tokenIdBatchHead = _batchHead.scanForward(tokenId); 
    }


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

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * This function is compatiable with ERC721AQueryable.
     */
    function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
        unchecked {
            uint256 tokenIdsIdx;
            uint256 tokenIdsLength = balanceOf(owner);
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);
            for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                if (_exists(i)) {
                    if (ownerOf(i) == owner) {
                        tokenIds[tokenIdsIdx++] = i;
                    }
                }
            }
            return tokenIds;   
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "../../utils/introspection/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 (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
// 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.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.4.1 (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 (last updated v4.7.0) (utils/StorageSlot.sol)

pragma solidity ^0.8.0;

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

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

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

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

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

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

pragma solidity ^0.8.0;

import "./math/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
// 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 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) (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, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 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
/**
   _____       ___     ___ __           ____  _ __      
  / ___/____  / (_)___/ (_) /___  __   / __ )(_) /______
  \__ \/ __ \/ / / __  / / __/ / / /  / __  / / __/ ___/
 ___/ / /_/ / / / /_/ / / /_/ /_/ /  / /_/ / / /_(__  ) 
/____/\____/_/_/\__,_/_/\__/\__, /  /_____/_/\__/____/  
                           /____/                        

- npm: https://www.npmjs.com/package/solidity-bits
- github: https://github.com/estarriolvetch/solidity-bits

 */
pragma solidity ^0.8.0;

import "./BitScan.sol";
import "./Popcount.sol";

/**
 * @dev This Library is a modified version of Openzeppelin's BitMaps library with extra features.
 *
 * 1. Functions of finding the index of the closest set bit from a given index are added.
 *    The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB.
 *    The modification of indexing makes finding the closest previous set bit more efficient in gas usage.
 * 2. Setting and unsetting the bitmap consecutively.
 * 3. Accounting number of set bits within a given range.   
 *
*/

/**
 * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
 * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
 */

library BitMaps {
    using BitScan for uint256;
    uint256 private constant MASK_INDEX_ZERO = (1 << 255);
    uint256 private constant MASK_FULL = type(uint256).max;

    struct BitMap {
        mapping(uint256 => uint256) _data;
    }

    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        return bitmap._data[bucket] & mask != 0;
    }

    /**
     * @dev Sets the bit at `index` to the boolean `value`.
     */
    function setTo(
        BitMap storage bitmap,
        uint256 index,
        bool value
    ) internal {
        if (value) {
            set(bitmap, index);
        } else {
            unset(bitmap, index);
        }
    }

    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        bitmap._data[bucket] |= mask;
    }

    /**
     * @dev Unsets the bit at `index`.
     */
    function unset(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        bitmap._data[bucket] &= ~mask;
    }


    /**
     * @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`.
     */    
    function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex;
            } else {
                bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex;
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    bitmap._data[bucket] = MASK_FULL;
                    amount -= 256;
                    bucket++;
                }

                bitmap._data[bucket] |= MASK_FULL << (256 - amount);
            }
        }
    }


    /**
     * @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`.
     */    
    function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex);
            } else {
                bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex);
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    bitmap._data[bucket] = 0;
                    amount -= 256;
                    bucket++;
                }

                bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount));
            }
        }
    }

    /**
     * @dev Returns number of set bits within a range.
     */
    function popcountA(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                count +=  Popcount.popcount256A(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
                );
            } else {
                count += Popcount.popcount256A(
                    bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
                );
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    count += Popcount.popcount256A(bitmap._data[bucket]);
                    amount -= 256;
                    bucket++;
                }
                count += Popcount.popcount256A(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount))
                );
            }
        }
    }

    /**
     * @dev Returns number of set bits within a range.
     */
    function popcountB(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                count +=  Popcount.popcount256B(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
                );
            } else {
                count += Popcount.popcount256B(
                    bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
                );
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    count += Popcount.popcount256B(bitmap._data[bucket]);
                    amount -= 256;
                    bucket++;
                }
                count += Popcount.popcount256B(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount))
                );
            }
        }
    }


    /**
     * @dev Find the closest index of the set bit before `index`.
     */
    function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) {
        uint256 bucket = index >> 8;

        // index within the bucket
        uint256 bucketIndex = (index & 0xff);

        // load a bitboard from the bitmap.
        uint256 bb = bitmap._data[bucket];

        // offset the bitboard to scan from `bucketIndex`.
        bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex)
        
        if(bb > 0) {
            unchecked {
                setBitIndex = (bucket << 8) | (bucketIndex -  bb.bitScanForward256());    
            }
        } else {
            while(true) {
                require(bucket > 0, "BitMaps: The set bit before the index doesn't exist.");
                unchecked {
                    bucket--;
                }
                // No offset. Always scan from the least significiant bit now.
                bb = bitmap._data[bucket];
                
                if(bb > 0) {
                    unchecked {
                        setBitIndex = (bucket << 8) | (255 -  bb.bitScanForward256());
                        break;
                    }
                } 
            }
        }
    }

    function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) {
        return bitmap._data[bucket];
    }
}

// SPDX-License-Identifier: MIT
/**
   _____       ___     ___ __           ____  _ __      
  / ___/____  / (_)___/ (_) /___  __   / __ )(_) /______
  \__ \/ __ \/ / / __  / / __/ / / /  / __  / / __/ ___/
 ___/ / /_/ / / / /_/ / / /_/ /_/ /  / /_/ / / /_(__  ) 
/____/\____/_/_/\__,_/_/\__/\__, /  /_____/_/\__/____/  
                           /____/                        

- npm: https://www.npmjs.com/package/solidity-bits
- github: https://github.com/estarriolvetch/solidity-bits

 */

pragma solidity ^0.8.0;


library BitScan {
    uint256 constant private DEBRUIJN_256 = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff;
    bytes constant private LOOKUP_TABLE_256 = hex"0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8";

    /**
        @dev Isolate the least significant set bit.
     */ 
    function isolateLS1B256(uint256 bb) pure internal returns (uint256) {
        require(bb > 0);
        unchecked {
            return bb & (0 - bb);
        }
    } 

    /**
        @dev Isolate the most significant set bit.
     */ 
    function isolateMS1B256(uint256 bb) pure internal returns (uint256) {
        require(bb > 0);
        unchecked {
            bb |= bb >> 128;
            bb |= bb >> 64;
            bb |= bb >> 32;
            bb |= bb >> 16;
            bb |= bb >> 8;
            bb |= bb >> 4;
            bb |= bb >> 2;
            bb |= bb >> 1;
            
            return (bb >> 1) + 1;
        }
    } 

    /**
        @dev Find the index of the lest significant set bit. (trailing zero count)
     */ 
    function bitScanForward256(uint256 bb) pure internal returns (uint8) {
        unchecked {
            return uint8(LOOKUP_TABLE_256[(isolateLS1B256(bb) * DEBRUIJN_256) >> 248]);
        }   
    }

    /**
        @dev Find the index of the most significant set bit.
     */ 
    function bitScanReverse256(uint256 bb) pure internal returns (uint8) {
        unchecked {
            return 255 - uint8(LOOKUP_TABLE_256[((isolateMS1B256(bb) * DEBRUIJN_256) >> 248)]);
        }   
    }

    function log2(uint256 bb) pure internal returns (uint8) {
        unchecked {
            return uint8(LOOKUP_TABLE_256[(isolateMS1B256(bb) * DEBRUIJN_256) >> 248]);
        } 
    }
}

// SPDX-License-Identifier: MIT
/**
   _____       ___     ___ __           ____  _ __      
  / ___/____  / (_)___/ (_) /___  __   / __ )(_) /______
  \__ \/ __ \/ / / __  / / __/ / / /  / __  / / __/ ___/
 ___/ / /_/ / / / /_/ / / /_/ /_/ /  / /_/ / / /_(__  ) 
/____/\____/_/_/\__,_/_/\__/\__, /  /_____/_/\__/____/  
                           /____/                        

- npm: https://www.npmjs.com/package/solidity-bits
- github: https://github.com/estarriolvetch/solidity-bits

 */

pragma solidity ^0.8.0;

library Popcount {
    uint256 private constant m1 = 0x5555555555555555555555555555555555555555555555555555555555555555;
    uint256 private constant m2 = 0x3333333333333333333333333333333333333333333333333333333333333333;
    uint256 private constant m4 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
    uint256 private constant h01 = 0x0101010101010101010101010101010101010101010101010101010101010101;

    function popcount256A(uint256 x) internal pure returns (uint256 count) {
        unchecked{
            for (count=0; x!=0; count++)
                x &= x - 1;
        }
    }

    function popcount256B(uint256 x) internal pure returns (uint256) {
        if (x == type(uint256).max) {
            return 256;
        }
        unchecked {
            x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
            x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 
            x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits 
            x = (x * h01) >> 248;  //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 
        }
        return x;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

/** @dev Action restricted. Given account is not allowed to run it */
error Restricted();

/** @dev Trying to set Zero Address to an attribute that cannot be 0 */
error ZeroAddress();

/** @dev Attribute already set and does not allow resetting */
error AlreadySet();

/** @dev A cap has been exceeded - temporarily locked */
error CapExceeded();

/** @dev A deadline has been wrongly set */
error WrongDeadline();

/** @dev A kill switch is in play. Action restricted and temporarily frozen */
error KillSwitch();

/** @dev A value cannot be zero */
error ZeroValue();

/** @dev Value exceeded maximum allowed */
error TooBig();

/** @dev Appointed item does not exist */
error NotExists();

/** @dev Appointed item already exist */
error AlreadyExists();

/** @dev Timed action has timed out */
error Timeout();

/** @dev Insufficient funds to perform action */
error InsufficientFunds();

/** @dev Wrong currency used */
error WrongCurrency();

/** @dev Blocked action. For timing or other reasons */
error Blocked();

/** @dev Suspended access */
error Suspended();

/** @dev Nothing to claim */
error NothingToClaim();

/** @dev Missing vesting tokens */
error MissingVestingTokens();

{
  "remappings": [
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "ERC721Psi/=lib/ERC721Psi/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
    "solidity-bits/=lib/solidity-bits/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 20000
  },
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"sale_","type":"address"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"initialURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadySet","type":"error"},{"inputs":[],"name":"Blocked","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sale","type":"address"}],"name":"NewSale","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":[],"name":"TokensRevealed","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"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":[{"internalType":"address","name":"receiver_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri_","type":"string"}],"name":"reveal","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":"sale_","type":"address"}],"name":"setSale","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":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000076fc5bde70ba5d418f4eae9769c254dcc3b5973d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000012225076502047656e65736973205061737322000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000105056502d47454e455349532d5041535300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004068747470733a2f2f617277656176652e6e65742f643954303679485875335357483533714e5a6a3672514670375438544954344b57433856365249792d70412f

-----Decoded View---------------
Arg [0] : owner_ (address): 0x76fc5bDE70BA5d418f4Eae9769C254dcc3B5973d
Arg [1] : sale_ (address): 0x0000000000000000000000000000000000000000
Arg [2] : name_ (string): "PvP Genesis Pass"
Arg [3] : symbol_ (string): PVP-GENESIS-PASS
Arg [4] : initialURI_ (string): https://arweave.net/d9T06yHXu3SWH53qNZj6rQFp7T8TIT4KWC8V6RIy-pA/

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 00000000000000000000000076fc5bde70ba5d418f4eae9769c254dcc3b5973d
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [6] : 225076502047656e657369732050617373220000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000010
Arg [8] : 5056502d47454e455349532d5041535300000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [10] : 68747470733a2f2f617277656176652e6e65742f643954303679485875335357
Arg [11] : 483533714e5a6a3672514670375438544954344b57433856365249792d70412f

174:1307:16:-:0;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;:::i;:::-;;2753:25:0;2738:40;;:104;;;;;174:1307:16;2738:156:0;;;;174:1307:16;;;;;;;;;;2738:156:0;952:25:9;937:40;;;2738:156:0;;;:104;2809:33;2794:48;;;-1:-1:-1;2738:104:0;;174:1307:16;;;;;;;;-1:-1:-1;;174:1307:16;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;4150:5:0;174:1307:16;;;;;;:::i;:::-;;;;;;;;;4150:5:0;;;;174:1307:16;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;3644:29:0;;;:::i;:::-;174:1307:16;;;;;;;;;;5239:11:0;174:1307:16;;5494:7:0;719:10:6;5302:168:0;719:10:6;;5323:21:0;:62;;;;;174:1307:16;5302:168:0;;:::i;:::-;5494:7;:::i;:::-;174:1307:16;5323:62:0;6486:35;719:10:6;;6486:35:0;719:10:6;6486:25:0;719:10:6;6486:25:0;174:1307:16;;;;6486:18:0;174:1307:16;;;;;;;6486:25:0;174:1307:16;;;;;;;;;;;;6486:35:0;174:1307:16;;;;;6486:35:0;5323:62;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;6942:7:0;174:1307:16;;;:::i;:::-;719:10:6;6771:140:0;6792:41;719:10:6;;6792:41:0;:::i;:::-;6771:140;:::i;:::-;6942:7;:::i;174:1307:16:-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;1063:62:1;;:::i;:::-;945:4:16;174:1307;;;;;;;;;945:13;941:43;;174:1307;1020:13;174:1307;;;;;;945:4;174:1307;;;;;;1020:13;174:1307;941:43;174:1307;;;969:12;;;;174:1307;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;;;;410:4;174:1307;;719:10:6;394:20:16;390:47;;174:1307;;;;;:::i;:::-;-1:-1:-1;174:1307:16;;;;;;10832:12:0;;;174:1307:16;;;;10904:16:0;10896:64;10904:16;;;10896:64;:::i;:::-;11049:25;;;;;:::i;:::-;174:1307:16;;;11049:25:0;11084;:20;;;174:1307:16;;11084:7:0;174:1307:16;;;;;;;11084:20:0;174:1307:16;;;;;;;;;;;11084:25:0;11134:11;;174:1307:16;2388:1:12;174:1307:16;;;;;;1478:8:12;174:1307:16;;;;2434:12:12;;174:1307:16;;;2457:28:12;174:1307:16;;2292:200:12;11134:11:0;11261:27;11324:9;11300:22;;;;:::i;:::-;11290:32;;;;;11353:33;11324:9;11353:33;;;;;;;11324:9;:::i;:::-;11261:27;;11290:32;;10514:68;11290:32;;10493:168;11290:32;10514:68;:::i;:::-;10493:168;:::i;:::-;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;390:47;174:1307;;;425:9;;;;174:1307;;;;;7156:39:0;174:1307:16;;;:::i;:::-;;;;;;;;:::i;:::-;;;;7156:39:0;:::i;174:1307:16:-;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1063:62:1;;:::i;:::-;1117:13:16;174:1307;;;;;1113:43;;174:1307;1181:4;;174:1307;;;;;1117:13;174:1307;-1:-1:-1;1200:16:16;;;;;174:1307;;;1226:14;174:1307;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1226:14;174:1307;;;;;;;;-1:-1:-1;174:1307:16;;;;;;1226:14;174:1307;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1226:14;174:1307;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;3644:29:0;174:1307:16;;3644:29:0;:::i;:::-;174:1307:16;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;1063:62:1;;:::i;:::-;174:1307:16;;2525:6:1;174:1307:16;;;;2525:6:1;174:1307:16;;2573:40:1;;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;-1:-1:-1;15414:16:0;;;;:::i;:::-;174:1307:16;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;15520:27:0;15549:29;;;;;;174:1307:16;;;;;;;:::i;15580:3:0:-;15607:10;;174:1307:16;15607:10:0;;:::i;:::-;15603:157;;15580:3;174:1307:16;15520:27:0;;15603:157;3644:29;;;:::i;:::-;174:1307:16;;;;;;;15645:19:0;15603:157;15641:101;15701:13;;;;174:1307:16;;;;;;;;;15641:101:0;174:1307:16;;;;;;15603:157:0;;174:1307:16;;;:::i;:::-;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;1273:6:1;174:1307:16;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;;;4314:7:0;174:1307:16;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;4314:7:0;174:1307:16;;;;;;;;;-1:-1:-1;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;;;;;;;;;;;719:10:6;;6065:24:0;;174:1307:16;;719:10:6;6133:42:0;:53;719:10:6;;-1:-1:-1;174:1307:16;6133:18:0;174:1307:16;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;6133:42:0;174:1307:16;;;;;;;;;;;;;;6133:53:0;174:1307:16;;;;;;;719:10:6;;6201:48:0;;174:1307:16;;6201:48:0;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;174:1307:16;;;;;;;4500:16:0;;;:::i;:::-;174:1307:16;;;;;:::i;:::-;;;4625:25:0;:86;;4660:45;174:1307:16;4686:18:0;174:1307:16;4686:18:0;174:1307:16;4686:18:0;;:::i;:::-;174:1307:16;;4660:45:0;;;174:1307:16;4660:45:0;;174:1307:16;;:::i;:::-;;;:::i;:::-;4660:45:0;;;;;;;;:::i;4625:86::-;174:1307:16;;;;;:::i;:::-;4625:86:0;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;6486:35:0;174:1307:16;;:::i;:::-;;;;:::i;:::-;;;-1:-1:-1;174:1307:16;6486:18:0;174:1307:16;;;-1:-1:-1;174:1307:16;;;;;;;;;;;;;6486:35:0;174:1307:16;;;;;;;;;;;;;;;;-1:-1:-1;;174:1307:16;;;;;;;:::i;:::-;1063:62:1;;:::i;:::-;174:1307:16;;;;2169:22:1;;;174:1307:16;;2525:6:1;174:1307:16;;;;;;2525:6:1;174:1307:16;;2573:40:1;-1:-1:-1;2573:40:1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;:::o;2960:472:0:-;174:1307:16;;;;3106:19:0;;;174:1307:16;;;3211:24:0;;174:1307:16;2257:13:0;174:1307:16;3206:198:0;3237:18;;;;;;3413:12;;;;2960:472;:::o;3257:3::-;3279:10;;;:::i;:::-;3276:118;;3257:3;;;;:::i;:::-;3211:24;;3276:118;3644:29;;;;:::i;:::-;174:1307:16;;3312:19:0;;3276:118;3308:72;3354:7;;3257:3;3354:7;;:::i;:::-;3308:72;;;3276:118;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;3708:294:0;3836:16;;;:::i;:::-;174:1307:16;;;14804:10:0;7063:1:12;;174:1307:16;;;;;;7133:12:12;;174:1307:16;;;;;;;;;7316:18:12;174:1307:16;7316:18:12;174:1307:16;7386:6:12;;;7383:736;7386:6;;;7482:22;7467:37;7482:22;;:::i;:::-;174:1307:16;;;;7467:37:12;174:1307:16;;;;7450:55:12;7383:736;3970:25:0;;3911:41;174:1307:16;;11084:7:0;174:1307:16;;;;;;;3970:25:0;174:1307:16;;;;;3970:25:0;3708:294;:::o;7383:736:12:-;7554:555;;174:1307:16;7554:555:12;;7584:75;7592:10;;;7584:75;:::i;:::-;174:1307:16;7837:20:12;;14804:10:0;174:1307:16;14804:10:0;174:1307:16;;;14804:10:0;174:1307:16;;;7837:20:12;174:1307:16;7895:6:12;7892:202;;7554:555;174:1307:16;7554:555:12;;;7892:202;7992:29;7999:22;7975:47;7999:22;;:::i;:::-;174:1307:16;;;;;;;7975:47:12;174:1307:16;;7975:47:12;7383:736;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;1465:7;174:1307;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:::o;:::-;1465:7;-1:-1:-1;174:1307:16;;;-1:-1:-1;;174:1307:16;;;;;;;-1:-1:-1;174:1307:16;;-1:-1:-1;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;174:1307:16;;:::o;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;5570:298:0;5730:16;;;:::i;:::-;174:1307:16;;;-1:-1:-1;174:1307:16;5837:15:0;174:1307:16;;;;-1:-1:-1;174:1307:16;;;5570:298:0;:::o;174:1307:16:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;7268:357:0;;8676:150;7268:357;;8697:50;7268:357;7429:140;7450:41;719:10:6;;7450:41:0;:::i;7429:140::-;8658:7;;;;;:::i;:::-;8697:50;:::i;174:1307:16:-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9079:149:0;2257:13;174:1307:16;-1:-1:-1;9167:54:0;;;9079:149;:::o;9167:54::-;;9195:26;9079:149;:::o;9386:434::-;9552:16;;;:::i;:::-;174:1307:16;;;3644:29:0;;;:::i;:::-;174:1307:16;;;;;;;;;9701:16:0;;:63;;;;;9386:434;9701:111;;;;;;;9693:120;;9386:434;:::o;9701:111::-;174:1307:16;6486:25:0;;;;:35;:25;174:1307:16;;;;6486:18:0;174:1307:16;;;;;;;6486:35:0;174:1307:16;;9386:434:0;:::o;9701:63::-;9733:20;;;;;;;:::i;:::-;174:1307:16;9733:31:0;9701:63;;;;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12311:1:0;174:1307:16;;;;;;;:::o;:::-;;;:::i;:::-;;;;;;;;;;:::o;11729:1022:0:-;;11892:29;;;:::i;:::-;174:1307:16;;;;;;;;;;;;11953:13:0;174:1307:16;;12538:21:0;174:1307:16;;;12054:16:0;12046:68;12054:16;;;12046:68;:::i;:::-;12251:7;;;:::i;:::-;12301:11;;;:::i;:::-;12326:34;12327:33;;174:1307:16;1478:8:12;1695:231;174:1307:16;1811:1:12;174:1307:16;12068:1:0;174:1307:16;12068:1:0;174:1307:16;;1857:12:12;174:1307:16;;12068:1:0;174:1307:16;;1887:27:12;:32;;1695:231;;12327:33:0;12326:34;;174:1307:16;12326:34:0;:86;;;11729:1022;12323:205;;11729:1022;12538:16;;;;174:1307:16;;11084:7:0;174:1307:16;;;;;;;12538:21:0;12572:27;;12569:80;;11729:1022;12664:27;12068:1;12664:27;;11729:1022::o;12569:80::-;12630:7;;174:1307:16;2388:1:12;174:1307:16;12068:1:0;174:1307:16;12068:1:0;174:1307:16;;1478:8:12;174:1307:16;;12068:1:0;174:1307:16;2434:12:12;;174:1307:16;;;2457:28:12;174:1307:16;;2292:200:12;12630:7:0;12569:80;;12323:205;12437:33;12499:17;12437:26;;;174:1307:16;;11084:7:0;174:1307:16;;;;;;;12437:33:0;174:1307:16;2388:1:12;174:1307:16;12068:1:0;174:1307:16;12068:1:0;174:1307:16;;1478:8:12;174:1307:16;;12068:1:0;174:1307:16;2434:12:12;;174:1307:16;;;2457:28:12;174:1307:16;;2292:200:12;12499:17:0;12323:205;;;;12326:86;174:1307:16;2257:13:0;174:1307:16;12378:34:0;;12326:86;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;12862:164:0;174:1307:16;;;12936:15:0;174:1307:16;;;;;;;;;;;;;3644:29:0;;;:::i;:::-;174:1307:16;;12980:39:0;;;;12862:164::o;:::-;174:1307:16;-1:-1:-1;174:1307:16;12936:15:0;174:1307:16;;12936:29:0;174:1307:16;;-1:-1:-1;174:1307:16;;;;;;;;;;;;12936:29:0;3644;;;:::i;:::-;-1:-1:-1;174:1307:16;;;;;;12980:39:0;-1:-1:-1;;12980:39:0;12862:164::o;174:1307:16:-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;174:1307:16;;;;:::o;:::-;;;:::o;13667:1013:0:-;;;;1465:19:5;;:23;13870:15:0;;13901:8;;;13905:4;13901:8;;;13927:30;;13923:677;13905:4;;;13923:677;14613:8;;;;;;;:::o;13994:9::-;13969:23;;;;;;;;:::i;:::-;13959:33;;;;;174:1307:16;;;;;;14026:72:0;;;;;;;;719:10:6;;;;;;14026:72:0;;;;;;;:::i;:::-;;174:1307:16;;;;;;;;;;14026:72:0;;;;;;;13994:9;-1:-1:-1;;14022:564:0;;14225:361;;;;;:::i;:::-;174:1307:16;;;14279:18:0;;;14325:63;174:1307:16;;;14325:63:0;;;;;;;;174:1307:16;;;;;;;;;;;;;;;;;;;;;;;14275:293:0;14443:103;;;;;14022:564;14149:56;;;;;;;;;;13994:9;14149:56;;;;;;;14022:564;14145:60;;14022:564;13994:9;:::i;:::-;13927:30;;;;;;;;14149:56;174:1307:16;;14154:51:0;;-1:-1:-1;14149:56:0;;;;14026:72;;;;;;;-1:-1:-1;14026:72:0;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;13959:33;;;;;;;13866:808;14652:11;;;;14659:4;14652:11;:::o;13667:1013::-;;;;1465:19:5;;:23;13870:15:0;;13901:8;;;8739:1;13901:8;;13927:30;;;13923:677;8739:1;;;14613:8;;;;;;;:::o;13994:9::-;13969:23;;;;;;;:::i;:::-;13959:33;;;;;174:1307:16;;;;;;14026:72:0;;;;;;;;719:10:6;;;;;;;14026:72:0;;;;;;;:::i;:::-;;-1:-1:-1;;;;174:1307:16;;;;;;14026:72:0;;;;;;;13994:9;-1:-1:-1;;14022:564:0;;14225:361;;;;;:::i;14022:564::-;14149:56;;;;;;;;;;13994:9;14149:56;;;;;;;14145:60;;14022:564;13994:9;:::i;:::-;13927:30;;;;;;;;;14026:72;;;;;;;-1:-1:-1;14026:72:0;;;;;;:::i;:::-;;;;;;174:1307:16;;;;;;;;;;;;;:::o;:::-;;;:::i;:::-;;;;;;;;;;;;;;1359:130:1;174:1307:16;1273:6:1;174:1307:16;;719:10:6;1422:23:1;174:1307:16;;1359:130:1:o;174:1307:16:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;:::o;415:696:8:-;537:17;-1:-1:-1;9983:8:11;;9974:17;;;;9970:103;;415:696:8;10099:8:11;;10090:17;;;;10086:103;;415:696:8;10215:8:11;;10206:17;;;;10202:103;;415:696:8;10331:7:11;;10322:16;;;;10318:100;;415:696:8;10444:7:11;;10435:16;;;;10431:100;;415:696:8;10548:16:11;10557:7;10548:16;;;10544:100;;415:696:8;10670:7:11;10661:16;;;;10657:66;;415:696:8;557:1;174:1307:16;;699:76:8;595:18;174:1307:16;;;595:18:8;:::i;:::-;627:11;699:76;;;788:280;557:1;;;788:280;1081:13;;;;415:696;:::o;788:280::-;174:1307:16;;;;893:93:8;;;;;;;;174:1307:16;1003:11:8;;1036:10;1032:21;;788:280;;;;;1032:21;1048:5;;10657:66:11;174:1307:16;10707:1:11;174:1307:16;10657:66:11;;;10544:100;174:1307:16;;10557:7:11;10628:1;174:1307:16;;;;10544:100:11;;;10431;10515:1;174:1307:16;;;;;;10431:100:11;;;;10318;10402:1;174:1307:16;;;;;;10318:100:11;;;;10202:103;10288:2;174:1307:16;;;;;;10202:103:11;;;;10086;10172:2;174:1307:16;;;;;;10086:103:11;;;;9970;10056:2;;-1:-1:-1;174:1307:16;;;-1:-1:-1;9970:103:11;;;174:1307:16;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;583:64:13;;;;174:1307:16;;583:64:13;;;;;;;;:::o;:::-;;;:::i;:::-;;;;:::o;2032:197::-;174:1307:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1374:6:13;;174:1307:16;;2148:60:13;;174:1307:16;583:64:13;174:1307:16;2142:67:13;174:1307:16;-1:-1:-1;174:1307:16;1422:13:13;583:64;174:1307:16;;2148:60:13;;:::i;:::-;583:64;;;;;2148:60;174:1307:16;;;;;;;;;;;;:::o;:::-;-1:-1:-1;174:1307:16;1226:14;174:1307;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;-1:-1:-1;174:1307:16;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://77ad2cd13536305e4fb7e8a646d487bf0e676efc2e73d63010ff37dffae569e7