Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED

pragma solidity >=0.7.0 <0.9.0;

// import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import "./OwnableUpgradeable.sol";
import "./MerkleProof.sol";
import "./ECDSA.sol";
import "./Initializable.sol";
import "./ERC721Upgradeable.sol";
import "./ERC165Upgradeable.sol";
import "./StringsUpgradeable.sol";
import "./IERC20.sol";
import "./Base64.sol";


// import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
/**
 * @dev Interface for the NFT Royalty Standard
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Called with the sale price to determine how much royalty is owed and to whom.
     * @param tokenId - the NFT asset queried for royalty information
     * @param salePrice - the sale price of the NFT asset specified by `tokenId`
     * @return receiver - address of who should be sent the royalty payment
     * @return royaltyAmount - the royalty payment amount for `salePrice`
     */
}

contract PowerBallV1 is Initializable, OwnableUpgradeable, ERC721Upgradeable, IERC2981Upgradeable
{
    string private baseURI = "ipfs://QmRe6FKkkgh5c78HEUth7oWMdMvRtC4Ax6L2BUqMw8pLVQ/";
    uint256 public mintFee = 0.005 ether;
    bool private mintRandomEnabled = true;
    
    uint256 public remaining = 10000;
    mapping(uint256 => uint256) public cache;
    mapping(uint256 => uint256) public cachePosition;
    mapping(address => uint256) public accountMintCount;

    uint256 public wlMintLimit = 2;
    uint256 public publicMintLimit = 10;
    uint256 public amountWithdrawn = 0;
    string public placeholderImage;

    bool public lockBaseUri = false;

    bytes32 public merkleRoot = 0x5e551ecbc4b0d0ab94638b0b80d7f29aaefff700dcb50b6a1271c4303ab5be0e;
    mapping(address => bool) public whitelistClaimed;
    bool public whitelistMintEnabled = false;

    constructor()  {}

    function initialize() public initializer  {
        __ERC721_init("Powerball V1", "PWBONE");
    }
    
    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }
    
    /* Mint 'n' random tokens if random minting is enabled */
    function mintRandom(uint256 count) payable public
    {
        require(count > 0 && count <= publicMintLimit, 'Cannot mint because exceeding mint per transaction limit');
        require(mintRandomEnabled == true, 'Random minting is not enabled for this contract');
        require(msg.value >= mintFee * count, 'Eth sent does not match the mint fee');
        
        _updateUserMintCount(msg.sender, count);

        for(uint256 i=0; i < count; i++){
            uint256 tokenID = _drawRandomIndex();
            _safeMint(msg.sender, tokenID);
        }
    }
    
    function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) payable public {
        require(_mintAmount > 0 && _mintAmount <= wlMintLimit, 'Cannot mint because exceeding mint per transaction limit');
        _updateUserMintCount(msg.sender);
        // Verify whitelist requirements
        require(whitelistMintEnabled, 'The whitelist sale is not enabled!');
        require(!whitelistClaimed[msg.sender], 'Address already claimed!');
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');

        whitelistClaimed[msg.sender] = true;
        for(uint256 i=0; i < _mintAmount; i++){
            /* Mint the token for the provided to address */
            uint256 tokenID = _drawRandomIndex();
            _safeMint(msg.sender, tokenID);
        }
    }
    
    /* Mint a token to a specific address */
    function airDropRandomToAccounts(address[] calldata to) onlyOwner() public
    {
        for (uint i=0; i<to.length; i++) {
            uint256 tokenID = _drawRandomIndex();
            _safeMint(to[i], tokenID);
        }
    }
    
    function _drawRandomIndex() internal returns (uint256 index) {
        //RNG
        uint256 i = uint(keccak256(abi.encodePacked(block.timestamp))) % remaining;

        // if there's a cache at cache[i] then use it
        // otherwise use i itself
        index = cache[i] == 0 ? i : cache[i];

        // grab a number from the tail
        cache[i] = cache[remaining - 1] == 0 ? remaining - 1 : cache[remaining - 1];
        
        // store the position of moved token in cache to be looked up (add 1 to avoid 0, remove when recovering)
        cachePosition[cache[i]] = i + 1;
        
        remaining = remaining - 1;
    }
    
    function _drawIndex(uint256 tokenID) internal {
        // recover the index, subtract 1 from cachePosition as an additional 1 was added to avoid 0 conflict
        uint256 i = cachePosition[tokenID] == 0 ? tokenID : cachePosition[tokenID] - 1;
        
        require(i <= remaining);
        
        // grab a number from the tail
        cache[i] = cache[remaining - 1] == 0 ? remaining - 1 : cache[remaining - 1];
        
        // store the position of moved token in cache to be looked up (add 1 to avoid 0, remove when recovering)
        cachePosition[cache[i]] = i + 1;
        
        remaining = remaining - 1;
    }
    
    function _updateUserMintCount(address account) internal {
        // increment a mapping for user on how many mints they have
        uint256 count = accountMintCount[account];

        accountMintCount[account] = count + 1;
    }
    
    function _updateUserMintCount(address account, uint256 quantity) internal {
        // increment a mapping for user on how many mints they have
        uint256 count = accountMintCount[account];

        accountMintCount[account] = count + quantity;
    }
    
    function isTokenAvailable(uint256 tokenID) external view returns (bool)
    {
        return !_exists(tokenID);
    }

    function toggleRandomPublicMinting() onlyOwner() public
    {
        mintRandomEnabled = !mintRandomEnabled;
    }

    function toggleWhitelistMinting() onlyOwner() public
    {
        whitelistMintEnabled = !whitelistMintEnabled;
    }
    function changeMintFee(uint256 mintFee_) onlyOwner() public
    {
        mintFee = mintFee_;
    }

    function changePublicMintLimit(uint256 mintLimit_) onlyOwner() public
    {
        publicMintLimit = mintLimit_;
    }

    function changeWlMintLimit(uint256 mintLimit_) onlyOwner() public
    {
        wlMintLimit = mintLimit_;
    }

    function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
        merkleRoot = _merkleRoot;
    }

    function changePlaceholderImage(string memory placeholderImage_) onlyOwner() public
    {
        require(bytes(placeholderImage).length != 0, "Metadata has already been revealed");
        require(bytes(placeholderImage_).length != 0, "Placeholder image cannot be empty");

        placeholderImage = placeholderImage_;
    }

    /* Transfer balance of this contract to an account */
    function transferBalance(address payable to, uint256 amount) onlyOwner() public{
        if(address(this).balance != 0){
            require(address(this).balance >= amount, "Not enought Balance to Transfer");
            payable(to).transfer(amount);
            amountWithdrawn += amount;
        }
    }
    
    /* Transfer any ERC20 balance of this contract to an account */
    function transferERC20Balance(address erc20ContractAddress, address payable to, uint256 amount) onlyOwner() public{
        IERC20(erc20ContractAddress).transfer(to, amount);
    }
    
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Upgradeable, IERC165Upgradeable) returns (bool) {
        return
            interfaceId == type(IERC721Upgradeable).interfaceId ||
            interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||
            interfaceId == type(IERC2981Upgradeable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

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

        string memory __baseURI = _baseURI();

        if(bytes(placeholderImage).length > 0){
            return placeholderImage;
        }
        else{
            return bytes(__baseURI).length > 0 ? string(abi.encodePacked(__baseURI, Strings.toString(tokenId),".json")) : "";
        }

    }

    function reveal() onlyOwner() public {
        placeholderImage = "";
    }

    function changeBaseUri(string memory baseURI_) onlyOwner() public {
        require(!lockBaseUri, "Base URI is locked, it cannot be edited");

        baseURI = baseURI_;
    }

    function permanentlyLockBaseUri() onlyOwner() public {
        lockBaseUri = true;
    }

    function getMintsUsed(address account) external view returns (uint256) {
        return accountMintCount[account];
    }
    
    function version() external pure returns (string memory)
    {
        return "1.0.6";
    }

    receive() external payable {}
}

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

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

/// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides a function for encoding some bytes in base64
library Base64 {
    string internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    function encode(bytes memory data) internal pure returns (string memory) {
        if (data.length == 0) return "";

        // load the table into memory
        string memory table = TABLE;

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((data.length + 2) / 3);

        // add some extra buffer at the end required for the writing
        string memory result = new string(encodedLen + 32);

        assembly {
            // set the actual output length
            mstore(result, encodedLen)

            // prepare the lookup table
            let tablePtr := add(table, 1)

            // input ptr
            let dataPtr := data
            let endPtr := add(dataPtr, mload(data))

            // result ptr, jump over length
            let resultPtr := add(result, 32)

            // run over the input, 3 bytes at a time
            for {

            } lt(dataPtr, endPtr) {

            } {
                dataPtr := add(dataPtr, 3)

                // read 3 bytes
                let input := mload(dataPtr)

                // write 4 characters
                mstore(
                    resultPtr,
                    shl(248, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
                mstore(
                    resultPtr,
                    shl(248, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
                mstore(
                    resultPtr,
                    shl(248, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
                mstore(
                    resultPtr,
                    shl(248, mload(add(tablePtr, and(input, 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
            }

            // padding with '='
            switch mod(mload(data), 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }
        }

        return result;
    }
}

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

pragma solidity ^0.8.0;
import "./Initializable.sol";

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

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

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

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

pragma solidity ^0.8.0;

import "./Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "./Initializable.sol";

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

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

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

pragma solidity ^0.8.0;

import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./IERC721MetadataUpgradeable.sol";
import "./AddressUpgradeable.sol";
import "./ContextUpgradeable.sol";
import "./StringsUpgradeable.sol";
import "./ERC165Upgradeable.sol";
import "./Initializable.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
    using AddressUpgradeable for address;
    using StringsUpgradeable for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __Context_init_unchained();
        __ERC165_init_unchained();
        __ERC721_init_unchained(name_, symbol_);
    }

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

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

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721Upgradeable.ownerOf(tokenId);

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

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

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

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

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
    uint256[44] private __gap;
}

// SPDX-License-Identifier: MIT
// 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 IERC165Upgradeable {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

pragma solidity ^0.8.0;

import "./IERC721Upgradeable.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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 IERC721ReceiverUpgradeable {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "./AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

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

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");

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

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} modifier, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = _efficientHash(computedHash, proofElement);
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = _efficientHash(proofElement, computedHash);
            }
        }
        return computedHash;
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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

pragma solidity ^0.8.0;

import "./ContextUpgradeable.sol";
import "./Initializable.sol";

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

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

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

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

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

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

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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

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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"accountMintCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"to","type":"address[]"}],"name":"airDropRandomToAccounts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"amountWithdrawn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"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":"","type":"uint256"}],"name":"cache","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"cachePosition","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"changeBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mintFee_","type":"uint256"}],"name":"changeMintFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"placeholderImage_","type":"string"}],"name":"changePlaceholderImage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mintLimit_","type":"uint256"}],"name":"changePublicMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mintLimit_","type":"uint256"}],"name":"changeWlMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getMintsUsed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPublicMintingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"isTokenAvailable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockBaseUri","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mintRandom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"permanentlyLockBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"placeholderImage","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"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":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleRandomPublicMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleWhitelistMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc20ContractAddress","type":"address"},{"internalType":"address payable","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferERC20Balance","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":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"whitelistMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wlMintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

1033:8472:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7764:418;;;;;;;;;;-1:-1:-1;7764:418:14;;;;;:::i;:::-;;:::i;:::-;;;565:14:17;;558:22;540:41;;528:2;513:18;7764:418:14;;;;;;;;3009:100:5;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;4579:221::-;;;;;;;;;;-1:-1:-1;4579:221:5;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:17;;;1674:51;;1662:2;1647:18;4579:221:5;1528:203:17;4091:422:5;;;;;;;;;;-1:-1:-1;4091:422:5;;;;;:::i;:::-;;:::i;:::-;;2245:576:14;;;;;;:::i;:::-;;:::i;1600:34::-;;;;;;;;;;;;;;;;;;;2338:25:17;;;2326:2;2311:18;1600:34:14;2192:177:17;1227:36:14;;;;;;;;;;;;;;;;1359:40;;;;;;;;;;-1:-1:-1;1359:40:14;;;;;:::i;:::-;;;;;;;;;;;;;;5329:339:5;;;;;;;;;;-1:-1:-1;5329:339:5;;;;;:::i;:::-;;:::i;7506:182:14:-;;;;;;;;;;-1:-1:-1;7506:182:14;;;;;:::i;:::-;;:::i;6111:121::-;;;;;;;;;;;;;:::i;1720:94::-;;;;;;;;;;;;;;;;1680:31;;;;;;;;;;-1:-1:-1;1680:31:14;;;;;;;;5739:185:5;;;;;;;;;;-1:-1:-1;5739:185:5;;;;;:::i;:::-;;:::i;8190:105:14:-;;;;;;;;;;-1:-1:-1;8270:17:14;;;;8190:105;;1641:30;;;;;;;;;;;;;:::i;8950:180::-;;;;;;;;;;-1:-1:-1;8950:180:14;;;;;:::i;:::-;;:::i;3775:234::-;;;;;;;;;;-1:-1:-1;3775:234:14;;;;;:::i;:::-;;:::i;9370:95::-;;;;;;;;;;-1:-1:-1;9443:14:14;;;;;;;;;;;;-1:-1:-1;;;9443:14:14;;;;9370:95;;1320:32;;;;;;;;;;;;;;;;7113:312;;;;;;;;;;-1:-1:-1;7113:312:14;;;;;:::i;:::-;;:::i;9236:122::-;;;;;;;;;;-1:-1:-1;9236:122:14;;;;;:::i;:::-;-1:-1:-1;;;;;9325:25:14;9298:7;9325:25;;;:16;:25;;;;;;;9236:122;2703:239:5;;;;;;;;;;-1:-1:-1;2703:239:5;;;;;:::i;:::-;;:::i;1876:40:14:-;;;;;;;;;;-1:-1:-1;1876:40:14;;;;;;;;5857:120;;;;;;;;;;-1:-1:-1;5857:120:14;;;;;:::i;:::-;5923:4;7922:16:5;;;:7;:16;;;;;;-1:-1:-1;;;;;7922:16:5;:30;;5857:120:14;2433:208:5;;;;;;;;;;-1:-1:-1;2433:208:5;;;;;:::i;:::-;;:::i;2028:103:13:-;;;;;;;;;;;;;:::i;6600:106:14:-;;;;;;;;;;-1:-1:-1;6600:106:14;;;;;:::i;:::-;;:::i;1950:100::-;;;;;;;;;;;;;:::i;1377:87:13:-;;;;;;;;;;-1:-1:-1;1450:6:13;;-1:-1:-1;;;;;1450:6:13;1377:87;;3178:104:5;;;;;;;;;;;;;:::i;4872:155::-;;;;;;;;;;-1:-1:-1;4872:155:5;;;;;:::i;:::-;;:::i;8865:77:14:-;;;;;;;;;;;;;:::i;5985:118::-;;;;;;;;;;;;;:::i;5995:328:5:-;;;;;;;;;;-1:-1:-1;5995:328:5;;;;;:::i;:::-;;:::i;1558:35:14:-;;;;;;;;;;;;;;;;6478:114;;;;;;;;;;-1:-1:-1;6478:114:14;;;;;:::i;:::-;;:::i;6348:122::-;;;;;;;;;;-1:-1:-1;6348:122:14;;;;;:::i;:::-;;:::i;1461:51::-;;;;;;;;;;-1:-1:-1;1461:51:14;;;;;:::i;:::-;;;;;;;;;;;;;;1406:48;;;;;;;;;;-1:-1:-1;1406:48:14;;;;;:::i;:::-;;;;;;;;;;;;;;8370:487;;;;;;;;;;-1:-1:-1;8370:487:14;;;;;:::i;:::-;;:::i;2833:884::-;;;;;;:::i;:::-;;:::i;1521:30::-;;;;;;;;;;;;;;;;1821:48;;;;;;;;;;-1:-1:-1;1821:48:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;6714:332;;;;;;;;;;-1:-1:-1;6714:332:14;;;;;:::i;:::-;;:::i;6238:102::-;;;;;;;;;;-1:-1:-1;6238:102:14;;;;;:::i;:::-;;:::i;5098:164:5:-;;;;;;;;;;-1:-1:-1;5098:164:5;;;;;:::i;:::-;-1:-1:-1;;;;;5219:25:5;;;5195:4;5219:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;5098:164;9138:90:14;;;;;;;;;;;;;:::i;2286:201:13:-;;;;;;;;;;-1:-1:-1;2286:201:13;;;;;:::i;:::-;;:::i;7764:418:14:-;7888:4;-1:-1:-1;;;;;;7925:51:14;;-1:-1:-1;;;7925:51:14;;:127;;-1:-1:-1;;;;;;;7993:59:14;;-1:-1:-1;;;7993:59:14;7925:127;:196;;;-1:-1:-1;;;;;;;8069:52:14;;;7925:196;:249;;;;8138:36;8162:11;8138:23;:36::i;:::-;7905:269;7764:418;-1:-1:-1;;7764:418:14:o;3009:100:5:-;3063:13;3096:5;3089:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3009:100;:::o;4579:221::-;4655:7;7922:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7922:16:5;4675:73;;;;-1:-1:-1;;;4675:73:5;;9090:2:17;4675:73:5;;;9072:21:17;9129:2;9109:18;;;9102:30;9168:34;9148:18;;;9141:62;-1:-1:-1;;;9219:18:17;;;9212:42;9271:19;;4675:73:5;;;;;;;;;-1:-1:-1;4768:24:5;;;;:15;:24;;;;;;-1:-1:-1;;;;;4768:24:5;;4579:221::o;4091:422::-;4172:13;4188:34;4214:7;4188:25;:34::i;:::-;4172:50;;4247:5;-1:-1:-1;;;;;4241:11:5;:2;-1:-1:-1;;;;;4241:11:5;;4233:57;;;;-1:-1:-1;;;4233:57:5;;9503:2:17;4233:57:5;;;9485:21:17;9542:2;9522:18;;;9515:30;9581:34;9561:18;;;9554:62;-1:-1:-1;;;9632:18:17;;;9625:31;9673:19;;4233:57:5;9301:397:17;4233:57:5;976:10:2;-1:-1:-1;;;;;4325:21:5;;;;:62;;-1:-1:-1;4350:37:5;4367:5;976:10:2;5098:164:5;:::i;4350:37::-;4303:168;;;;-1:-1:-1;;;4303:168:5;;9905:2:17;4303:168:5;;;9887:21:17;9944:2;9924:18;;;9917:30;9983:34;9963:18;;;9956:62;10054:26;10034:18;;;10027:54;10098:19;;4303:168:5;9703:420:17;4303:168:5;4484:21;4493:2;4497:7;4484:8;:21::i;:::-;4161:352;4091:422;;:::o;2245:576:14:-;2327:1;2319:5;:9;:37;;;;;2341:15;;2332:5;:24;;2319:37;2311:106;;;;-1:-1:-1;;;2311:106:14;;;;;;;:::i;:::-;2436:17;;;;:25;;:17;:25;2428:85;;;;-1:-1:-1;;;2428:85:14;;10755:2:17;2428:85:14;;;10737:21:17;10794:2;10774:18;;;10767:30;10833:34;10813:18;;;10806:62;-1:-1:-1;;;10884:18:17;;;10877:45;10939:19;;2428:85:14;10553:411:17;2428:85:14;2555:5;2545:7;;:15;;;;:::i;:::-;2532:9;:28;;2524:77;;;;-1:-1:-1;;;2524:77:14;;11476:2:17;2524:77:14;;;11458:21:17;11515:2;11495:18;;;11488:30;11554:34;11534:18;;;11527:62;-1:-1:-1;;;11605:18:17;;;11598:34;11649:19;;2524:77:14;11274:400:17;2524:77:14;2622:39;2643:10;2655:5;2622:20;:39::i;:::-;2678:9;2674:140;2695:5;2691:1;:9;2674:140;;;2721:15;2739:18;:16;:18::i;:::-;2721:36;;2772:30;2782:10;2794:7;2772:9;:30::i;:::-;-1:-1:-1;2702:3:14;;;;:::i;:::-;;;;2674:140;;;;2245:576;:::o;5329:339:5:-;5524:41;976:10:2;5557:7:5;5524:18;:41::i;:::-;5516:103;;;;-1:-1:-1;;;5516:103:5;;;;;;;:::i;:::-;5632:28;5642:4;5648:2;5652:7;5632:9;:28::i;7506:182:14:-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;7631:49:14::1;::::0;-1:-1:-1;;;7631:49:14;;-1:-1:-1;;;;;12798:32:17;;;7631:49:14::1;::::0;::::1;12780:51:17::0;12847:18;;;12840:34;;;7631:37:14;::::1;::::0;::::1;::::0;12753:18:17;;7631:49:14::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;7506:182:::0;;;:::o;6111:121::-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6204:20:14::1;::::0;;-1:-1:-1;;6180:44:14;::::1;6204:20;::::0;;::::1;6203:21;6180:44;::::0;;6111:121::o;5739:185:5:-;5877:39;5894:4;5900:2;5904:7;5877:39;;;;;;;;;;;;:16;:39::i;1641:30:14:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8950:180::-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;9036:11:14::1;::::0;::::1;;9035:12;9027:64;;;::::0;-1:-1:-1;;;9027:64:14;;13337:2:17;9027:64:14::1;::::0;::::1;13319:21:17::0;13376:2;13356:18;;;13349:30;13415:34;13395:18;;;13388:62;-1:-1:-1;;;13466:18:17;;;13459:37;13513:19;;9027:64:14::1;13135:403:17::0;9027:64:14::1;9104:7;:18;9114:8:::0;9104:7;:18:::1;:::i;3775:234::-:0;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;3871:6:14::1;3866:136;3881:11:::0;;::::1;3866:136;;;3914:15;3932:18;:16;:18::i;:::-;3914:36;;3965:25;3975:2;;3978:1;3975:5;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;3982:7;3965:9;:25::i;:::-;-1:-1:-1::0;3894:3:14;::::1;::::0;::::1;:::i;:::-;;;;3866:136;;7113:312:::0;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;7206:21:14::1;:26:::0;7203:215:::1;;7281:6;7256:21;:31;;7248:75;;;::::0;-1:-1:-1;;;7248:75:14;;16081:2:17;7248:75:14::1;::::0;::::1;16063:21:17::0;16120:2;16100:18;;;16093:30;16159:33;16139:18;;;16132:61;16210:18;;7248:75:14::1;15879:355:17::0;7248:75:14::1;7338:28;::::0;-1:-1:-1;;;;;7338:20:14;::::1;::::0;:28;::::1;;;::::0;7359:6;;7338:28:::1;::::0;;;7359:6;7338:20;:28;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;7400:6;7381:15;;:25;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;7113:312:14;;:::o;2703:239:5:-;2775:7;2811:16;;;:7;:16;;;;;;-1:-1:-1;;;;;2811:16:5;;2838:73;;;;-1:-1:-1;;;2838:73:5;;16574:2:17;2838:73:5;;;16556:21:17;16613:2;16593:18;;;16586:30;16652:34;16632:18;;;16625:62;-1:-1:-1;;;16703:18:17;;;16696:39;16752:19;;2838:73:5;16372:405:17;2433:208:5;2505:7;-1:-1:-1;;;;;2533:19:5;;2525:74;;;;-1:-1:-1;;;2525:74:5;;16984:2:17;2525:74:5;;;16966:21:17;17023:2;17003:18;;;16996:30;17062:34;17042:18;;;17035:62;-1:-1:-1;;;17113:18:17;;;17106:40;17163:19;;2525:74:5;16782:406:17;2525:74:5;-1:-1:-1;;;;;;2617:16:5;;;;;:9;:16;;;;;;;2433:208::o;2028:103:13:-;1450:6;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;2093:30:::1;2120:1;2093:18;:30::i;:::-;2028:103::o:0;6600:106:14:-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6674:10:14::1;:24:::0;6600:106::o;1950:100::-;2389:13:11;;;;;;;:48;;2425:12;;;;2424:13;2389:48;;;3192:4;1131:20:0;1179:8;2405:16:11;2381:107;;;;-1:-1:-1;;;2381:107:11;;17395:2:17;2381:107:11;;;17377:21:17;17434:2;17414:18;;;17407:30;17473:34;17453:18;;;17446:62;-1:-1:-1;;;17524:18:17;;;17517:44;17578:19;;2381:107:11;17193:410:17;2381:107:11;2501:19;2524:13;;;;;;2523:14;2548:101;;;;2583:13;:20;;-1:-1:-1;;2618:19:11;;;;;2548:101;2003:39:14::1;;;;;;;;;;;;;;-1:-1:-1::0;;;2003:39:14::1;;::::0;::::1;;;;;;;;;;;;;-1:-1:-1::0;;;2003:39:14::1;;::::0;:13:::1;:39::i;:::-;2679:14:11::0;2675:68;;;2726:5;2710:21;;-1:-1:-1;;2710:21:11;;;2675:68;2096:654;1950:100:14:o;3178:104:5:-;3234:13;3267:7;3260:14;;;;;:::i;4872:155::-;4967:52;976:10:2;5000:8:5;5010;4967:18;:52::i;8865:77:14:-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;8913:21:14::1;::::0;;::::1;::::0;::::1;::::0;;;-1:-1:-1;8913:21:14;;:16:::1;::::0;:21:::1;::::0;:16;:21:::1;:::i;5985:118::-:0;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6078:17:14::1;::::0;;-1:-1:-1;;6057:38:14;::::1;6078:17;::::0;;::::1;6077:18;6057:38;::::0;;5985:118::o;5995:328:5:-;6170:41;976:10:2;6203:7:5;6170:18;:41::i;:::-;6162:103;;;;-1:-1:-1;;;6162:103:5;;;;;;;:::i;:::-;6276:39;6290:4;6296:2;6300:7;6309:5;6276:13;:39::i;6478:114:14:-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6560:11:14::1;:24:::0;6478:114::o;6348:122::-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6434:15:14::1;:28:::0;6348:122::o;8370:487::-;7898:4:5;7922:16;;;:7;:16;;;;;;8443:13:14;;-1:-1:-1;;;;;7922:16:5;8469:76:14;;;;-1:-1:-1;;;8469:76:14;;17810:2:17;8469:76:14;;;17792:21:17;17849:2;17829:18;;;17822:30;17888:34;17868:18;;;17861:62;-1:-1:-1;;;17939:18:17;;;17932:45;17994:19;;8469:76:14;17608:411:17;8469:76:14;8558:23;8584:10;:8;:10::i;:::-;8558:36;;8643:1;8616:16;8610:30;;;;;:::i;:::-;;;:34;8607:241;;;8667:16;8660:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8370:487;;;:::o;8607:241::-;8757:1;8737:9;8731:23;:27;:105;;;;;;;;;;;;;;;;;8785:9;8796:25;8813:7;8796:16;:25::i;:::-;8768:62;;;;;;;;;:::i;:::-;;;;;;;;;;;;;8731:105;8724:112;8370:487;-1:-1:-1;;;8370:487:14:o;8607:241::-;8458:399;8370:487;;;:::o;2833:884::-;2958:1;2944:11;:15;:45;;;;;2978:11;;2963;:26;;2944:45;2936:114;;;;-1:-1:-1;;;2936:114:14;;;;;;;:::i;:::-;3061:32;3082:10;3061:20;:32::i;:::-;3154:20;;;;3146:67;;;;-1:-1:-1;;;3146:67:14;;18868:2:17;3146:67:14;;;18850:21:17;18907:2;18887:18;;;18880:30;18946:34;18926:18;;;18919:62;-1:-1:-1;;;18997:18:17;;;18990:32;19039:19;;3146:67:14;18666:398:17;3146:67:14;3250:10;3233:28;;;;:16;:28;;;;;;;;3232:29;3224:66;;;;-1:-1:-1;;;3224:66:14;;19271:2:17;3224:66:14;;;19253:21:17;19310:2;19290:18;;;19283:30;19349:26;19329:18;;;19322:54;19393:18;;3224:66:14;19069:348:17;3224:66:14;3326:28;;-1:-1:-1;;3343:10:14;19571:2:17;19567:15;19563:53;3326:28:14;;;19551:66:17;3301:12:14;;19633::17;;3326:28:14;;;;;;;;;;;;3316:39;;;;;;3301:54;;3374:50;3393:12;;3374:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3407:10:14;;;-1:-1:-1;3419:4:14;;-1:-1:-1;3374:18:14;:50::i;:::-;3366:77;;;;-1:-1:-1;;;3366:77:14;;19858:2:17;3366:77:14;;;19840:21:17;19897:2;19877:18;;;19870:30;-1:-1:-1;;;19916:18:17;;;19909:44;19970:18;;3366:77:14;19656:338:17;3366:77:14;3473:10;3456:28;;;;:16;:28;;;;;:35;;-1:-1:-1;;3456:35:14;3487:4;3456:35;;;3502:208;3523:11;3519:1;:15;3502:208;;;3617:15;3635:18;:16;:18::i;:::-;3617:36;;3668:30;3678:10;3690:7;3668:9;:30::i;:::-;-1:-1:-1;3536:3:14;;;;:::i;:::-;;;;3502:208;;;;2925:792;2833:884;;;:::o;6714:332::-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6828:16:14::1;6822:30;;;;;:::i;:::-;;;6856:1;6822:35:::0;6814:82:::1;;;::::0;-1:-1:-1;;;6814:82:14;;20201:2:17;6814:82:14::1;::::0;::::1;20183:21:17::0;20240:2;20220:18;;;20213:30;20279:34;20259:18;;;20252:62;-1:-1:-1;;;20330:18:17;;;20323:32;20372:19;;6814:82:14::1;19999:398:17::0;6814:82:14::1;6921:17;6915:31;6950:1;6915:36:::0;6907:82:::1;;;::::0;-1:-1:-1;;;6907:82:14;;20604:2:17;6907:82:14::1;::::0;::::1;20586:21:17::0;20643:2;20623:18;;;20616:30;20682:34;20662:18;;;20655:62;-1:-1:-1;;;20733:18:17;;;20726:31;20774:19;;6907:82:14::1;20402:397:17::0;6907:82:14::1;7002:16;:36;7021:17:::0;7002:16;:36:::1;:::i;6238:102::-:0;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;6314:7:14::1;:18:::0;6238:102::o;9138:90::-;1450:6:13;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;9202:11:14::1;:18:::0;;-1:-1:-1;;9202:18:14::1;9216:4;9202:18;::::0;;9138:90::o;2286:201:13:-;1450:6;;-1:-1:-1;;;;;1450:6:13;976:10:2;1597:23:13;1589:68;;;;-1:-1:-1;;;1589:68:13;;;;;;;:::i;:::-;-1:-1:-1;;;;;2375:22:13;::::1;2367:73;;;::::0;-1:-1:-1;;;2367:73:13;;21006:2:17;2367:73:13::1;::::0;::::1;20988:21:17::0;21045:2;21025:18;;;21018:30;21084:34;21064:18;;;21057:62;-1:-1:-1;;;21135:18:17;;;21128:36;21181:19;;2367:73:13::1;20804:402:17::0;2367:73:13::1;2451:28;2470:8;2451:18;:28::i;2020:349:5:-:0;2144:4;-1:-1:-1;;;;;;2181:51:5;;-1:-1:-1;;;2181:51:5;;:127;;-1:-1:-1;;;;;;;2249:59:5;;-1:-1:-1;;;2249:59:5;2181:127;:180;;;-1:-1:-1;;;;;;;;;;1220:51:4;;;2325:36:5;1111:168:4;11848:185:5;11923:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;11923:29:5;-1:-1:-1;;;;;11923:29:5;;;;;;;;:24;;11977:34;11923:24;11977:25;:34::i;:::-;-1:-1:-1;;;;;11968:57:5;;;;;;;;;;;11848:185;;:::o;5585:260:14:-;-1:-1:-1;;;;;5755:25:14;;5739:13;5755:25;;;:16;:25;;;;;;5821:16;5829:8;5755:25;5821:16;:::i;:::-;-1:-1:-1;;;;;5793:25:14;;;;;;;:16;:25;;;;;:44;;;;-1:-1:-1;;5585:260:14:o;4021:648::-;4067:13;4108:9;4173;;4152:15;4135:33;;;;;;21340:19:17;;21384:2;21375:12;;21211:182;4135:33:14;;;;;;;;;;;;;4125:44;;;;;;4120:50;;:62;;;;:::i;:::-;4293:8;;;;:5;:8;;;;;;4108:74;;-1:-1:-1;4293:13:14;:28;;4313:8;;;;:5;:8;;;;;;4293:28;;;4309:1;4293:28;4285:36;;4385:5;:20;4403:1;4391:9;;:13;;;;:::i;:::-;4385:20;;;;;;;;;;;;4409:1;4385:25;:64;;4429:5;:20;4447:1;4435:9;;:13;;;;:::i;:::-;4429:20;;;;;;;;;;;;4385:64;;;4425:1;4413:9;;:13;;;;:::i;:::-;4374:8;;;;:5;:8;;;;;:75;4610:5;4380:1;4614;4610:5;:::i;:::-;4584:23;4598:8;;;:5;:8;;;;;;;;;4584:23;;:13;:23;;;;;:31;4648:9;;:13;;4660:1;;4648:13;:::i;:::-;4636:9;:25;-1:-1:-1;4021:648:14;:::o;8828:110:5:-;8904:26;8914:2;8918:7;8904:26;;;;;;;;;;;;:9;:26::i;8127:359::-;8220:4;7922:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7922:16:5;8237:73;;;;-1:-1:-1;;;8237:73:5;;21979:2:17;8237:73:5;;;21961:21:17;22018:2;21998:18;;;21991:30;22057:34;22037:18;;;22030:62;-1:-1:-1;;;22108:18:17;;;22101:42;22160:19;;8237:73:5;21777:408:17;8237:73:5;8321:13;8337:34;8363:7;8337:25;:34::i;:::-;8321:50;;8401:5;-1:-1:-1;;;;;8390:16:5;:7;-1:-1:-1;;;;;8390:16:5;;:51;;;;8434:7;-1:-1:-1;;;;;8410:31:5;:20;8422:7;8410:11;:20::i;:::-;-1:-1:-1;;;;;8410:31:5;;8390:51;:87;;;-1:-1:-1;;;;;;5219:25:5;;;5195:4;5219:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;8445:32;8382:96;8127:359;-1:-1:-1;;;;8127:359:5:o;11141:589::-;11311:4;-1:-1:-1;;;;;11273:42:5;:34;11299:7;11273:25;:34::i;:::-;-1:-1:-1;;;;;11273:42:5;;11265:96;;;;-1:-1:-1;;;11265:96:5;;22392:2:17;11265:96:5;;;22374:21:17;22431:2;22411:18;;;22404:30;22470:34;22450:18;;;22443:62;-1:-1:-1;;;22521:18:17;;;22514:39;22570:19;;11265:96:5;22190:405:17;11265:96:5;-1:-1:-1;;;;;11380:16:5;;11372:65;;;;-1:-1:-1;;;11372:65:5;;22802:2:17;11372:65:5;;;22784:21:17;22841:2;22821:18;;;22814:30;22880:34;22860:18;;;22853:62;-1:-1:-1;;;22931:18:17;;;22924:34;22975:19;;11372:65:5;22600:400:17;11372:65:5;11554:29;11571:1;11575:7;11554:8;:29::i;:::-;-1:-1:-1;;;;;11596:15:5;;;;;;:9;:15;;;;;:20;;11615:1;;11596:15;:20;;11615:1;;11596:20;:::i;:::-;;;;-1:-1:-1;;;;;;;11627:13:5;;;;;;:9;:13;;;;;:18;;11644:1;;11627:13;:18;;11644:1;;11627:18;:::i;:::-;;;;-1:-1:-1;;11656:16:5;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;11656:21:5;-1:-1:-1;;;;;11656:21:5;;;;;;;;;11695:27;;11656:16;;11695:27;;;;;;;11141:589;;;:::o;2647:191:13:-;2740:6;;;-1:-1:-1;;;;;2757:17:13;;;-1:-1:-1;;;;;;2757:17:13;;;;;;;2790:40;;2740:6;;;2757:17;2740:6;;2790:40;;2721:16;;2790:40;2710:128;2647:191;:::o;1553:224:5:-;2992:13:11;;;;;;;2984:69;;;;-1:-1:-1;;;2984:69:11;;;;;;;:::i;:::-;1657:26:5::1;:24;:26::i;:::-;1694:25;:23;:25::i;:::-;1730:39;1754:5;1761:7;1730:23;:39::i;12175:315::-:0;12330:8;-1:-1:-1;;;;;12321:17:5;:5;-1:-1:-1;;;;;12321:17:5;;12313:55;;;;-1:-1:-1;;;12313:55:5;;23619:2:17;12313:55:5;;;23601:21:17;23658:2;23638:18;;;23631:30;23697:27;23677:18;;;23670:55;23742:18;;12313:55:5;23417:349:17;12313:55:5;-1:-1:-1;;;;;12379:25:5;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;12379:46:5;;;;;;;;;;12441:41;;540::17;;;12441::5;;513:18:17;12441:41:5;;;;;;;12175:315;;;:::o;7205:::-;7362:28;7372:4;7378:2;7382:7;7362:9;:28::i;:::-;7409:48;7432:4;7438:2;7442:7;7451:5;7409:22;:48::i;:::-;7401:111;;;;-1:-1:-1;;;7401:111:5;;;;;;;:::i;2062:108:14:-;2122:13;2155:7;2148:14;;;;;:::i;342:723:15:-;398:13;619:5;628:1;619:10;615:53;;-1:-1:-1;;646:10:15;;;;;;;;;;;;-1:-1:-1;;;646:10:15;;;;;342:723::o;615:53::-;693:5;678:12;734:78;741:9;;734:78;;767:8;;;;:::i;:::-;;-1:-1:-1;790:10:15;;-1:-1:-1;798:2:15;790:10;;:::i;:::-;;;734:78;;;822:19;854:6;844:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;844:17:15;;822:39;;872:154;879:10;;872:154;;906:11;916:1;906:11;;:::i;:::-;;-1:-1:-1;975:10:15;983:2;975:5;:10;:::i;:::-;962:24;;:2;:24;:::i;:::-;949:39;;932:6;939;932:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;932:56:15;;;;;;;;-1:-1:-1;1003:11:15;1012:2;1003:11;;:::i;:::-;;;872:154;;5338:235:14;-1:-1:-1;;;;;5490:25:14;;5474:13;5490:25;;;:16;:25;;;;;;5556:9;5490:25;5564:1;5556:9;:::i;:::-;-1:-1:-1;;;;;5528:25:14;;;;;;;:16;:25;;;;;:37;;;;-1:-1:-1;5338:235:14:o;883:190:12:-;1008:4;1061;1032:25;1045:5;1052:4;1032:12;:25::i;:::-;:33;;883:190;-1:-1:-1;;;;883:190:12:o;9165:321:5:-;9295:18;9301:2;9305:7;9295:5;:18::i;:::-;9346:54;9377:1;9381:2;9385:7;9394:5;9346:22;:54::i;:::-;9324:154;;;;-1:-1:-1;;;9324:154:5;;;;;;;:::i;820:70:2:-;2992:13:11;;;;;;;2984:69;;;;-1:-1:-1;;;2984:69:11;;;;;;;:::i;1785:163:5:-;2992:13:11;;;;;;;2984:69;;;;-1:-1:-1;;;2984:69:11;;;;;;;:::i;:::-;1899:5:5::1;:13;1907:5:::0;1899;:13:::1;:::i;:::-;-1:-1:-1::0;1923:7:5::1;:17;1933:7:::0;1923;:17:::1;:::i;13055:821::-:0;13210:4;-1:-1:-1;;;;;13231:13:5;;1131:20:0;1179:8;13227:642:5;;13267:83;;-1:-1:-1;;;13267:83:5;;-1:-1:-1;;;;;13267:47:5;;;;;:83;;976:10:2;;13329:4:5;;13335:7;;13344:5;;13267:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13267:83:5;;;;;;;;-1:-1:-1;;13267:83:5;;;;;;;;;;;;:::i;:::-;;;13263:551;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13531:6;:13;13548:1;13531:18;13527:272;;13574:60;;-1:-1:-1;;;13574:60:5;;;;;;;:::i;13527:272::-;13749:6;13743:13;13734:6;13730:2;13726:15;13719:38;13263:551;-1:-1:-1;;;;;;13401:62:5;-1:-1:-1;;;13401:62:5;;-1:-1:-1;13394:69:5;;13227:642;-1:-1:-1;13853:4:5;13055:821;;;;;;:::o;1435:675:12:-;1518:7;1561:4;1518:7;1576:497;1600:5;:12;1596:1;:16;1576:497;;;1634:20;1657:5;1663:1;1657:8;;;;;;;;:::i;:::-;;;;;;;1634:31;;1700:12;1684;:28;1680:382;;2186:13;2236:15;;;2272:4;2265:15;;;2319:4;2303:21;;1812:57;;1680:382;;;2186:13;2236:15;;;2272:4;2265:15;;;2319:4;2303:21;;1989:57;;1680:382;-1:-1:-1;1614:3:12;;;;:::i;:::-;;;;1576:497;;;-1:-1:-1;2090:12:12;1435:675;-1:-1:-1;;;1435:675:12:o;9822:382:5:-;-1:-1:-1;;;;;9902:16:5;;9894:61;;;;-1:-1:-1;;;9894:61:5;;25265:2:17;9894:61:5;;;25247:21:17;;;25284:18;;;25277:30;25343:34;25323:18;;;25316:62;25395:18;;9894:61:5;25063:356:17;9894:61:5;7898:4;7922:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7922:16:5;:30;9966:58;;;;-1:-1:-1;;;9966:58:5;;25626:2:17;9966:58:5;;;25608:21:17;25665:2;25645:18;;;25638:30;25704;25684:18;;;25677:58;25752:18;;9966:58:5;25424:352:17;9966:58:5;-1:-1:-1;;;;;10095:13:5;;;;;;:9;:13;;;;;:18;;10112:1;;10095:13;:18;;10112:1;;10095:18;:::i;:::-;;;;-1:-1:-1;;10124:16:5;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;10124:21:5;-1:-1:-1;;;;;10124:21:5;;;;;;;;10163:33;;10124:16;;;10163:33;;10124:16;;10163:33;9822:382;;:::o;14:131:17:-;-1:-1:-1;;;;;;88:32:17;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:17;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:17;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:17:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:17;;1343:180;-1:-1:-1;1343:180:17:o;1736:131::-;-1:-1:-1;;;;;1811:31:17;;1801:42;;1791:70;;1857:1;1854;1847:12;1872:315;1940:6;1948;2001:2;1989:9;1980:7;1976:23;1972:32;1969:52;;;2017:1;2014;2007:12;1969:52;2056:9;2043:23;2075:31;2100:5;2075:31;:::i;:::-;2125:5;2177:2;2162:18;;;;2149:32;;-1:-1:-1;;;1872:315:17:o;2374:456::-;2451:6;2459;2467;2520:2;2508:9;2499:7;2495:23;2491:32;2488:52;;;2536:1;2533;2526:12;2488:52;2575:9;2562:23;2594:31;2619:5;2594:31;:::i;:::-;2644:5;-1:-1:-1;2701:2:17;2686:18;;2673:32;2714:33;2673:32;2714:33;:::i;:::-;2374:456;;2766:7;;-1:-1:-1;;;2820:2:17;2805:18;;;;2792:32;;2374:456::o;3486:127::-;3547:10;3542:3;3538:20;3535:1;3528:31;3578:4;3575:1;3568:15;3602:4;3599:1;3592:15;3618:632;3683:5;3713:18;3754:2;3746:6;3743:14;3740:40;;;3760:18;;:::i;:::-;3835:2;3829:9;3803:2;3889:15;;-1:-1:-1;;3885:24:17;;;3911:2;3881:33;3877:42;3865:55;;;3935:18;;;3955:22;;;3932:46;3929:72;;;3981:18;;:::i;:::-;4021:10;4017:2;4010:22;4050:6;4041:15;;4080:6;4072;4065:22;4120:3;4111:6;4106:3;4102:16;4099:25;4096:45;;;4137:1;4134;4127:12;4096:45;4187:6;4182:3;4175:4;4167:6;4163:17;4150:44;4242:1;4235:4;4226:6;4218;4214:19;4210:30;4203:41;;;;3618:632;;;;;:::o;4255:451::-;4324:6;4377:2;4365:9;4356:7;4352:23;4348:32;4345:52;;;4393:1;4390;4383:12;4345:52;4433:9;4420:23;4466:18;4458:6;4455:30;4452:50;;;4498:1;4495;4488:12;4452:50;4521:22;;4574:4;4566:13;;4562:27;-1:-1:-1;4552:55:17;;4603:1;4600;4593:12;4552:55;4626:74;4692:7;4687:2;4674:16;4669:2;4665;4661:11;4626:74;:::i;4711:367::-;4774:8;4784:6;4838:3;4831:4;4823:6;4819:17;4815:27;4805:55;;4856:1;4853;4846:12;4805:55;-1:-1:-1;4879:20:17;;4922:18;4911:30;;4908:50;;;4954:1;4951;4944:12;4908:50;4991:4;4983:6;4979:17;4967:29;;5051:3;5044:4;5034:6;5031:1;5027:14;5019:6;5015:27;5011:38;5008:47;5005:67;;;5068:1;5065;5058:12;5005:67;4711:367;;;;;:::o;5083:437::-;5169:6;5177;5230:2;5218:9;5209:7;5205:23;5201:32;5198:52;;;5246:1;5243;5236:12;5198:52;5286:9;5273:23;5319:18;5311:6;5308:30;5305:50;;;5351:1;5348;5341:12;5305:50;5390:70;5452:7;5443:6;5432:9;5428:22;5390:70;:::i;:::-;5479:8;;5364:96;;-1:-1:-1;5083:437:17;-1:-1:-1;;;;5083:437:17:o;5853:247::-;5912:6;5965:2;5953:9;5944:7;5940:23;5936:32;5933:52;;;5981:1;5978;5971:12;5933:52;6020:9;6007:23;6039:31;6064:5;6039:31;:::i;6290:118::-;6376:5;6369:13;6362:21;6355:5;6352:32;6342:60;;6398:1;6395;6388:12;6413:382;6478:6;6486;6539:2;6527:9;6518:7;6514:23;6510:32;6507:52;;;6555:1;6552;6545:12;6507:52;6594:9;6581:23;6613:31;6638:5;6613:31;:::i;:::-;6663:5;-1:-1:-1;6720:2:17;6705:18;;6692:32;6733:30;6692:32;6733:30;:::i;:::-;6782:7;6772:17;;;6413:382;;;;;:::o;6800:795::-;6895:6;6903;6911;6919;6972:3;6960:9;6951:7;6947:23;6943:33;6940:53;;;6989:1;6986;6979:12;6940:53;7028:9;7015:23;7047:31;7072:5;7047:31;:::i;:::-;7097:5;-1:-1:-1;7154:2:17;7139:18;;7126:32;7167:33;7126:32;7167:33;:::i;:::-;7219:7;-1:-1:-1;7273:2:17;7258:18;;7245:32;;-1:-1:-1;7328:2:17;7313:18;;7300:32;7355:18;7344:30;;7341:50;;;7387:1;7384;7377:12;7341:50;7410:22;;7463:4;7455:13;;7451:27;-1:-1:-1;7441:55:17;;7492:1;7489;7482:12;7441:55;7515:74;7581:7;7576:2;7563:16;7558:2;7554;7550:11;7515:74;:::i;:::-;7505:84;;;6800:795;;;;;;;:::o;7600:505::-;7695:6;7703;7711;7764:2;7752:9;7743:7;7739:23;7735:32;7732:52;;;7780:1;7777;7770:12;7732:52;7816:9;7803:23;7793:33;;7877:2;7866:9;7862:18;7849:32;7904:18;7896:6;7893:30;7890:50;;;7936:1;7933;7926:12;7890:50;7975:70;8037:7;8028:6;8017:9;8013:22;7975:70;:::i;:::-;7600:505;;8064:8;;-1:-1:-1;7949:96:17;;-1:-1:-1;;;;7600:505:17:o;8110:388::-;8178:6;8186;8239:2;8227:9;8218:7;8214:23;8210:32;8207:52;;;8255:1;8252;8245:12;8207:52;8294:9;8281:23;8313:31;8338:5;8313:31;:::i;:::-;8363:5;-1:-1:-1;8420:2:17;8405:18;;8392:32;8433:33;8392:32;8433:33;:::i;8503:380::-;8582:1;8578:12;;;;8625;;;8646:61;;8700:4;8692:6;8688:17;8678:27;;8646:61;8753:2;8745:6;8742:14;8722:18;8719:38;8716:161;;8799:10;8794:3;8790:20;8787:1;8780:31;8834:4;8831:1;8824:15;8862:4;8859:1;8852:15;10128:420;10330:2;10312:21;;;10369:2;10349:18;;;10342:30;10408:34;10403:2;10388:18;;10381:62;10479:26;10474:2;10459:18;;10452:54;10538:3;10523:19;;10128:420::o;10969:127::-;11030:10;11025:3;11021:20;11018:1;11011:31;11061:4;11058:1;11051:15;11085:4;11082:1;11075:15;11101:168;11141:7;11207:1;11203;11199:6;11195:14;11192:1;11189:21;11184:1;11177:9;11170:17;11166:45;11163:71;;;11214:18;;:::i;:::-;-1:-1:-1;11254:9:17;;11101:168::o;11679:135::-;11718:3;11739:17;;;11736:43;;11759:18;;:::i;:::-;-1:-1:-1;11806:1:17;11795:13;;11679:135::o;11819:413::-;12021:2;12003:21;;;12060:2;12040:18;;;12033:30;12099:34;12094:2;12079:18;;12072:62;-1:-1:-1;;;12165:2:17;12150:18;;12143:47;12222:3;12207:19;;11819:413::o;12237:356::-;12439:2;12421:21;;;12458:18;;;12451:30;12517:34;12512:2;12497:18;;12490:62;12584:2;12569:18;;12237:356::o;12885:245::-;12952:6;13005:2;12993:9;12984:7;12980:23;12976:32;12973:52;;;13021:1;13018;13011:12;12973:52;13053:9;13047:16;13072:28;13094:5;13072:28;:::i;13669:545::-;13771:2;13766:3;13763:11;13760:448;;;13807:1;13832:5;13828:2;13821:17;13877:4;13873:2;13863:19;13947:2;13935:10;13931:19;13928:1;13924:27;13918:4;13914:38;13983:4;13971:10;13968:20;13965:47;;;-1:-1:-1;14006:4:17;13965:47;14061:2;14056:3;14052:12;14049:1;14045:20;14039:4;14035:31;14025:41;;14116:82;14134:2;14127:5;14124:13;14116:82;;;14179:17;;;14160:1;14149:13;14116:82;;;14120:3;;;13669:545;;;:::o;14390:1352::-;14516:3;14510:10;14543:18;14535:6;14532:30;14529:56;;;14565:18;;:::i;:::-;14594:97;14684:6;14644:38;14676:4;14670:11;14644:38;:::i;:::-;14638:4;14594:97;:::i;:::-;14746:4;;14810:2;14799:14;;14827:1;14822:663;;;;15529:1;15546:6;15543:89;;;-1:-1:-1;15598:19:17;;;15592:26;15543:89;-1:-1:-1;;14347:1:17;14343:11;;;14339:24;14335:29;14325:40;14371:1;14367:11;;;14322:57;15645:81;;14792:944;;14822:663;13616:1;13609:14;;;13653:4;13640:18;;-1:-1:-1;;14858:20:17;;;14976:236;14990:7;14987:1;14984:14;14976:236;;;15079:19;;;15073:26;15058:42;;15171:27;;;;15139:1;15127:14;;;;15006:19;;14976:236;;;14980:3;15240:6;15231:7;15228:19;15225:201;;;15301:19;;;15295:26;-1:-1:-1;;15384:1:17;15380:14;;;15396:3;15376:24;15372:37;15368:42;15353:58;15338:74;;15225:201;-1:-1:-1;;;;;15472:1:17;15456:14;;;15452:22;15439:36;;-1:-1:-1;14390:1352:17:o;15747:127::-;15808:10;15803:3;15799:20;15796:1;15789:31;15839:4;15836:1;15829:15;15863:4;15860:1;15853:15;16239:128;16279:3;16310:1;16306:6;16303:1;16300:13;16297:39;;;16316:18;;:::i;:::-;-1:-1:-1;16352:9:17;;16239:128::o;18024:637::-;18304:3;18342:6;18336:13;18358:53;18404:6;18399:3;18392:4;18384:6;18380:17;18358:53;:::i;:::-;18474:13;;18433:16;;;;18496:57;18474:13;18433:16;18530:4;18518:17;;18496:57;:::i;:::-;-1:-1:-1;;;18575:20:17;;18604:22;;;18653:1;18642:13;;18024:637;-1:-1:-1;;;;18024:637:17:o;21398:127::-;21459:10;21454:3;21450:20;21447:1;21440:31;21490:4;21487:1;21480:15;21514:4;21511:1;21504:15;21530:112;21562:1;21588;21578:35;;21593:18;;:::i;:::-;-1:-1:-1;21627:9:17;;21530:112::o;21647:125::-;21687:4;21715:1;21712;21709:8;21706:34;;;21720:18;;:::i;:::-;-1:-1:-1;21757:9:17;;21647:125::o;23005:407::-;23207:2;23189:21;;;23246:2;23226:18;;;23219:30;23285:34;23280:2;23265:18;;23258:62;-1:-1:-1;;;23351:2:17;23336:18;;23329:41;23402:3;23387:19;;23005:407::o;23771:414::-;23973:2;23955:21;;;24012:2;23992:18;;;23985:30;24051:34;24046:2;24031:18;;24024:62;-1:-1:-1;;;24117:2:17;24102:18;;24095:48;24175:3;24160:19;;23771:414::o;24190:120::-;24230:1;24256;24246:35;;24261:18;;:::i;:::-;-1:-1:-1;24295:9:17;;24190:120::o;24315:489::-;-1:-1:-1;;;;;24584:15:17;;;24566:34;;24636:15;;24631:2;24616:18;;24609:43;24683:2;24668:18;;24661:34;;;24731:3;24726:2;24711:18;;24704:31;;;24509:4;;24752:46;;24778:19;;24770:6;24752:46;:::i;:::-;24744:54;24315:489;-1:-1:-1;;;;;;24315:489:17:o;24809:249::-;24878:6;24931:2;24919:9;24910:7;24906:23;24902:32;24899:52;;;24947:1;24944;24937:12;24899:52;24979:9;24973:16;24998:30;25022:5;24998:30;:::i

ipfs://296bb1fcd58fff1a98e9a0be68b75a4bc6ac4308752b96b45302ce322f6d55a1