Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IERC721Receiver
•    - function onERC721Received(
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
•    - function _msgSender()
•    - function _msgData()
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function supportsInterface(bytes4 int ...
•  contract ERC721 is Context, ERC165 ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _safeTransfer(
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(
•    - function _approve(address to, uint256 ...
•    - function _setApprovalForAll(
•    - function _checkOnERC721Received(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
•    - function supportsInterface(bytes4 int ...
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function _beforeTokenTransfer(
•    - function _addTokenToOwnerEnumeration( ...
•    - function _addTokenToAllTokensEnumerat ...
•    - function _removeTokenFromOwnerEnumera ...
•    - function _removeTokenFromAllTokensEnu ...
•  contract Membership is Context
•    - function transferOwner(address newOwn ...
•    - function setMembership(address key, u ...
•    - function isOwner()
•    - function isAdmin()
•    - function isMinter()
•    - function getMembership(address accoun ...
•  contract LOKPay is Membership *
•    - function take(uint256 code)
•    - function pay(uint256 code)
•    - function setReceiver(address payable ...
•    - function setTokenReceiver(address r)
•    - function withdraw()
•    - function payBy(address token, uint256 ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-01-24
*/

pragma solidity ^0.8.0;

// SPDX-License-Identifier: MIT

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);
    
    event Mint(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);
}

// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/IERC20Metadata.sol)
/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
/**
 * @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);
    }
}

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    string baseURI;

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

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

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

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

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

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

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

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

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

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not 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 = ERC721.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);

        _afterTokenTransfer(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 = ERC721.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);

        _afterTokenTransfer(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(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        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);

        _afterTokenTransfer(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(ERC721.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 IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Enumerable.sol)
/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)
/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @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` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * 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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


contract Membership is Context {
    address private owner;
    event MembershipChanged(address indexed owner, uint256 level);
    event OwnerTransferred(address indexed preOwner, address indexed newOwner);

    mapping(address => uint256) internal membership;

    constructor() {
        owner = _msgSender();
        setMembership(_msgSender(), 1);
    }

    function transferOwner(address newOwner) public onlyOwner {
        address preOwner = owner;
        setMembership(newOwner, 1);
        setMembership(preOwner, 0);
        owner = newOwner;
        emit OwnerTransferred(preOwner, newOwner);
    }

    function setMembership(address key, uint256 level) public onlyOwner {
        membership[key] = level;
        emit MembershipChanged(key, level);
    }

    modifier onlyOwner() {
        require(isOwner(), "Membership : caller is not the owner");
        _;
    }

    function isOwner() public view returns (bool) {
        return _msgSender() == owner;
    }


    modifier onlyAdmin() {
        require(isAdmin(), "Membership : caller is not a admin");
        _;
    }

    function isAdmin() public view returns (bool) {
        return membership[_msgSender()] == 1;
    }

    modifier onlyMinter() {
        require(isMinter(), "Memberhsip : caller is not a Minter");
        _;
    }

    function isMinter() public view returns (bool) {
        return isOwner() || membership[_msgSender()] == 11;
    }
    
    function getMembership(address account) public view returns (uint256){
        return membership[account];
    }
}


contract LOKPay is Membership {
    event Pay(address token, uint256 code, uint256 value);
    event Take(uint256 code, uint256 value);

    address payable private receiver;
    address private tokenReceiver;

    receive() external payable {}

    fallback() external payable {}

    constructor() {
        setReceiver(payable(_msgSender()));
        setTokenReceiver(_msgSender());
    }

    function take(uint256 code) public payable {
        emit Take(code, msg.value);
    }

    function pay(uint256 code) public payable {
        emit Pay(address(0), code, msg.value);
    }

    function setReceiver(address payable r) public onlyOwner {
        receiver = r;
    }

    function setTokenReceiver(address r) public onlyOwner {
        tokenReceiver = r;
    }

    function withdraw() public {
        require(receiver != address(0));
        require(_msgSender() == receiver || isOwner(), "Incorrect address");
        receiver.transfer(address(this).balance);
    }
    
    function payBy(address token, uint256 code, uint256 value) public {
        emit Pay(token, code, value);
        IERC20(token).transferFrom(_msgSender(), tokenReceiver, value);
    }
}

• 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":false,"internalType":"uint256","name":"level","type":"uint256"}],"name":"MembershipChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"preOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"code","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Pay","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"code","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Take","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getMembership","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"code","type":"uint256"}],"name":"pay","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"code","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"payBy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"level","type":"uint256"}],"name":"setMembership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"r","type":"address"}],"name":"setReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"r","type":"address"}],"name":"setTokenReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"code","type":"uint256"}],"name":"take","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

46451:1216:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47478:186;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46328:114;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47260:206;;;;;;;;;;;;;:::i;:::-;;45210:254;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46864:88;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46200:116;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47066:88;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45472:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45753:93;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45972:101;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46960:98;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47162:90;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47478:186;47560:23;47564:5;47571:4;47577:5;47560:23;;;;;;;;:::i;:::-;;;;;;;;47601:5;47594:26;;;47621:12;:10;:12::i;:::-;47635:13;;;;;;;;;;;47650:5;47594:62;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47478:186;;;:::o;46328:114::-;46389:7;46415:10;:19;46426:7;46415:19;;;;;;;;;;;;;;;;46408:26;;46328:114;;;:::o;47260:206::-;47326:1;47306:22;;:8;;;;;;;;;;;:22;;;;47298:31;;;;;;47364:8;;;;;;;;;;;47348:24;;:12;:10;:12::i;:::-;:24;;;:37;;;;47376:9;:7;:9::i;:::-;47348:37;47340:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;47418:8;;;;;;;;;;;:17;;:40;47436:21;47418:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47260:206::o;45210:254::-;45675:9;:7;:9::i;:::-;45667:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;45279:16:::1;45298:5:::0;::::1;;;;;;;;;;45279:24;;45314:26;45328:8;45338:1;45314:13;:26::i;:::-;45351;45365:8;45375:1;45351:13;:26::i;:::-;45396:8;45388:5;::::0;:16:::1;;;;;;;;;;;;;;;;;;45447:8;45420:36;;45437:8;45420:36;;;;;;;;;;;;45268:196;45210:254:::0;:::o;46864:88::-;46923:21;46928:4;46934:9;46923:21;;;;;;;:::i;:::-;;;;;;;;46864:88;:::o;46200:116::-;46241:4;46265:9;:7;:9::i;:::-;:43;;;;46306:2;46278:10;:24;46289:12;:10;:12::i;:::-;46278:24;;;;;;;;;;;;;;;;:30;46265:43;46258:50;;46200:116;:::o;47066:88::-;45675:9;:7;:9::i;:::-;45667:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;47145:1:::1;47134:8;;:12;;;;;;;;;;;;;;;;;;47066:88:::0;:::o;45472:155::-;45675:9;:7;:9::i;:::-;45667:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;45569:5:::1;45551:10;:15;45562:3;45551:15;;;;;;;;;;;;;;;:23;;;;45608:3;45590:29;;;45613:5;45590:29;;;;;;:::i;:::-;;;;;;;;45472:155:::0;;:::o;45753:93::-;45793:4;45833:5;;;;;;;;;;;45817:21;;:12;:10;:12::i;:::-;:21;;;45810:28;;45753:93;:::o;45972:101::-;46012:4;46064:1;46036:10;:24;46047:12;:10;:12::i;:::-;46036:24;;;;;;;;;;;;;;;;:29;46029:36;;45972:101;:::o;46960:98::-;47018:32;47030:1;47034:4;47040:9;47018:32;;;;;;;;:::i;:::-;;;;;;;;46960:98;:::o;47162:90::-;45675:9;:7;:9::i;:::-;45667:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;47243:1:::1;47227:13;;:17;;;;;;;;;;;;;;;;;;47162:90:::0;:::o;19629:98::-;19682:7;19709:10;19702:17;;19629:98;:::o;88:117:1:-;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:619::-;1274:6;1282;1290;1339:2;1327:9;1318:7;1314:23;1310:32;1307:119;;;1345:79;;:::i;:::-;1307:119;1465:1;1490:53;1535:7;1526:6;1515:9;1511:22;1490:53;:::i;:::-;1480:63;;1436:117;1592:2;1618:53;1663:7;1654:6;1643:9;1639:22;1618:53;:::i;:::-;1608:63;;1563:118;1720:2;1746:53;1791:7;1782:6;1771:9;1767:22;1746:53;:::i;:::-;1736:63;;1691:118;1197:619;;;;;:::o;1822:329::-;1881:6;1930:2;1918:9;1909:7;1905:23;1901:32;1898:119;;;1936:79;;:::i;:::-;1898:119;2056:1;2081:53;2126:7;2117:6;2106:9;2102:22;2081:53;:::i;:::-;2071:63;;2027:117;1822:329;;;;:::o;2157:118::-;2244:24;2262:5;2244:24;:::i;:::-;2239:3;2232:37;2157:118;;:::o;2281:222::-;2374:4;2412:2;2401:9;2397:18;2389:26;;2425:71;2493:1;2482:9;2478:17;2469:6;2425:71;:::i;:::-;2281:222;;;;:::o;2509:329::-;2568:6;2617:2;2605:9;2596:7;2592:23;2588:32;2585:119;;;2623:79;;:::i;:::-;2585:119;2743:1;2768:53;2813:7;2804:6;2793:9;2789:22;2768:53;:::i;:::-;2758:63;;2714:117;2509:329;;;;:::o;2844:90::-;2878:7;2921:5;2914:13;2907:21;2896:32;;2844:90;;;:::o;2940:109::-;3021:21;3036:5;3021:21;:::i;:::-;3016:3;3009:34;2940:109;;:::o;3055:210::-;3142:4;3180:2;3169:9;3165:18;3157:26;;3193:65;3255:1;3244:9;3240:17;3231:6;3193:65;:::i;:::-;3055:210;;;;:::o;3271:104::-;3316:7;3345:24;3363:5;3345:24;:::i;:::-;3334:35;;3271:104;;;:::o;3381:138::-;3462:32;3488:5;3462:32;:::i;:::-;3455:5;3452:43;3442:71;;3509:1;3506;3499:12;3442:71;3381:138;:::o;3525:155::-;3579:5;3617:6;3604:20;3595:29;;3633:41;3668:5;3633:41;:::i;:::-;3525:155;;;;:::o;3686:345::-;3753:6;3802:2;3790:9;3781:7;3777:23;3773:32;3770:119;;;3808:79;;:::i;:::-;3770:119;3928:1;3953:61;4006:7;3997:6;3986:9;3982:22;3953:61;:::i;:::-;3943:71;;3899:125;3686:345;;;;:::o;4037:474::-;4105:6;4113;4162:2;4150:9;4141:7;4137:23;4133:32;4130:119;;;4168:79;;:::i;:::-;4130:119;4288:1;4313:53;4358:7;4349:6;4338:9;4334:22;4313:53;:::i;:::-;4303:63;;4259:117;4415:2;4441:53;4486:7;4477:6;4466:9;4462:22;4441:53;:::i;:::-;4431:63;;4386:118;4037:474;;;;;:::o;4517:118::-;4604:24;4622:5;4604:24;:::i;:::-;4599:3;4592:37;4517:118;;:::o;4641:442::-;4790:4;4828:2;4817:9;4813:18;4805:26;;4841:71;4909:1;4898:9;4894:17;4885:6;4841:71;:::i;:::-;4922:72;4990:2;4979:9;4975:18;4966:6;4922:72;:::i;:::-;5004;5072:2;5061:9;5057:18;5048:6;5004:72;:::i;:::-;4641:442;;;;;;:::o;5089:::-;5238:4;5276:2;5265:9;5261:18;5253:26;;5289:71;5357:1;5346:9;5342:17;5333:6;5289:71;:::i;:::-;5370:72;5438:2;5427:9;5423:18;5414:6;5370:72;:::i;:::-;5452;5520:2;5509:9;5505:18;5496:6;5452:72;:::i;:::-;5089:442;;;;;;:::o;5537:116::-;5607:21;5622:5;5607:21;:::i;:::-;5600:5;5597:32;5587:60;;5643:1;5640;5633:12;5587:60;5537:116;:::o;5659:137::-;5713:5;5744:6;5738:13;5729:22;;5760:30;5784:5;5760:30;:::i;:::-;5659:137;;;;:::o;5802:345::-;5869:6;5918:2;5906:9;5897:7;5893:23;5889:32;5886:119;;;5924:79;;:::i;:::-;5886:119;6044:1;6069:61;6122:7;6113:6;6102:9;6098:22;6069:61;:::i;:::-;6059:71;;6015:125;5802:345;;;;:::o;6153:169::-;6237:11;6271:6;6266:3;6259:19;6311:4;6306:3;6302:14;6287:29;;6153:169;;;;:::o;6328:167::-;6468:19;6464:1;6456:6;6452:14;6445:43;6328:167;:::o;6501:366::-;6643:3;6664:67;6728:2;6723:3;6664:67;:::i;:::-;6657:74;;6740:93;6829:3;6740:93;:::i;:::-;6858:2;6853:3;6849:12;6842:19;;6501:366;;;:::o;6873:419::-;7039:4;7077:2;7066:9;7062:18;7054:26;;7126:9;7120:4;7116:20;7112:1;7101:9;7097:17;7090:47;7154:131;7280:4;7154:131;:::i;:::-;7146:139;;6873:419;;;:::o;7298:223::-;7438:34;7434:1;7426:6;7422:14;7415:58;7507:6;7502:2;7494:6;7490:15;7483:31;7298:223;:::o;7527:366::-;7669:3;7690:67;7754:2;7749:3;7690:67;:::i;:::-;7683:74;;7766:93;7855:3;7766:93;:::i;:::-;7884:2;7879:3;7875:12;7868:19;;7527:366;;;:::o;7899:419::-;8065:4;8103:2;8092:9;8088:18;8080:26;;8152:9;8146:4;8142:20;8138:1;8127:9;8123:17;8116:47;8180:131;8306:4;8180:131;:::i;:::-;8172:139;;7899:419;;;:::o;8324:332::-;8445:4;8483:2;8472:9;8468:18;8460:26;;8496:71;8564:1;8553:9;8549:17;8540:6;8496:71;:::i;:::-;8577:72;8645:2;8634:9;8630:18;8621:6;8577:72;:::i;:::-;8324:332;;;;;:::o

ipfs://c6b79ae4033db0ecca3da3823e1fdbfd74bc1b4af0ea66018975ae6645510d8f