Token

Koingu (KOINGU)

ERC-20

Overview

Max Total Supply

25,477.1678575 KOINGU

Holders

128

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x5d8e18a07166551d1c960d2cd486af2ab3fc8e41

Filtered by Token Holder

0xd3034bDC0B7B7168aaE7f96F4DDa646051635bc7

Balance

1,360.963035 KOINGU

Value

$0.00

0xd3034bDC0B7B7168aaE7f96F4DDa646051635bc7

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

KonguStakingToken

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-22
*/

// Sources flattened with hardhat v2.12.6 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

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

pragma solidity ^0.8.0;

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

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


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://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 functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

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

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

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

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

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

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

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

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

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

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;







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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

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

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

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

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

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

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

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

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

        _owners[tokenId] = to;

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

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

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

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

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

        // Clear approvals
        delete _tokenApprovals[tokenId];

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

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

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

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

        emit Transfer(from, to, tokenId);

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/utils/ERC721Holder.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}


// File contracts/ERC20I.sol


pragma solidity ^0.8.0;

/*
    ERC20I (ERC20 0xInuarashi Edition)
    Minified and Gas Optimized
    Contributors: 0xInuarashi (Message to Martians, Anonymice), 0xBasset (Ether Orcs)
*/

contract ERC20I {
    // Token Params
    string public name;
    string public symbol;
    constructor(string memory name_, string memory symbol_) {
        name = name_;
        symbol = symbol_;
    }

    // Decimals
    uint8 public constant decimals = 18;

    // Supply
    uint256 public totalSupply;
    
    // Mappings of Balances
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    // Events
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    // Internal Functions
    function _mint(address to_, uint256 amount_) internal virtual {
        totalSupply += amount_;
        balanceOf[to_] += amount_;
        emit Transfer(address(0x0), to_, amount_);
    }
    function _burn(address from_, uint256 amount_) internal virtual {
        balanceOf[from_] -= amount_;
        totalSupply -= amount_;
        emit Transfer(from_, address(0x0), amount_);
    }
    function _approve(address owner_, address spender_, uint256 amount_) internal virtual {
        allowance[owner_][spender_] = amount_;
        emit Approval(owner_, spender_, amount_);
    }

    // Public Functions
    function approve(address spender_, uint256 amount_) public virtual returns (bool) {
        _approve(msg.sender, spender_, amount_);
        return true;
    }
    function transfer(address to_, uint256 amount_) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount_;
        balanceOf[to_] += amount_;
        emit Transfer(msg.sender, to_, amount_);
        return true;
    }
    function transferFrom(address from_, address to_, uint256 amount_) public virtual returns (bool) {
        if (allowance[from_][msg.sender] != type(uint256).max) {
            allowance[from_][msg.sender] -= amount_; }
        balanceOf[from_] -= amount_;
        balanceOf[to_] += amount_;
        emit Transfer(from_, to_, amount_);
        return true;
    }

    // 0xInuarashi Custom Functions
    function multiTransfer(address[] memory to_, uint256[] memory amounts_) public virtual {
        require(to_.length == amounts_.length, "ERC20I: To and Amounts length Mismatch!");
        for (uint256 i = 0; i < to_.length; i++) {
            transfer(to_[i], amounts_[i]);
        }
    }
    function multiTransferFrom(address[] memory from_, address[] memory to_, uint256[] memory amounts_) public virtual {
        require(from_.length == to_.length && from_.length == amounts_.length, "ERC20I: From, To, and Amounts length Mismatch!");
        for (uint256 i = 0; i < from_.length; i++) {
            transferFrom(from_[i], to_[i], amounts_[i]);
        }
    }

    function burn(uint256 amount_) external virtual {
        _burn(msg.sender, amount_);
    }
    function burnFrom(address from_, uint256 amount_) public virtual {
        uint256 _currentAllowance = allowance[from_][msg.sender];
        require(_currentAllowance >= amount_, "ERC20IBurnable: Burn amount requested exceeds allowance!");

        if (allowance[from_][msg.sender] != type(uint256).max) {
            allowance[from_][msg.sender] -= amount_; }

        _burn(from_, amount_);
    }
}


// File contracts/staking.sol


pragma solidity ^0.8.11;
error NotAuthorized();
error NotOwner();
error NotStaked();

contract KonguStakingPass is ERC721, Ownable {

    using Strings for uint256;

    string public baseURI;
    string public metadataExtension = ".json";
    uint256 public totalSupply;

    constructor(string memory _metadata) ERC721("Kongu Staking", "KONGUPASS") {
        setBaseURI(_metadata);

        for(uint256 i=1; i<=350; i++)
        {
            _mint(msg.sender, i);
        }
    }

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

    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require( _exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0 ? string( abi.encodePacked(currentBaseURI, tokenId.toString(), metadataExtension )): "";
    }
    
}


contract KonguStakingToken is ERC20I, ERC721Holder, Ownable {

    KonguStakingPass public konguPass;
    ERC721 public kongu;

    //5 Per Day
    uint256 public constant KonguRate = 0.0034725 ether;

    struct KonguStaked 
    { 
        bool isStaked;
        uint256 timestamp;
        address owner;
    }
    mapping (uint256 => KonguStaked) public stakingDetails;

    constructor(address konguContract) ERC20I("Koingu", "KOINGU") 
    {
        konguPass = new KonguStakingPass("https://kongu.mypinata.cloud/ipfs/QmSaozE7pz2PqF3s2wbMVC1qE8W2wGzKmNBV2DgBUC3YaM/");
        kongu = ERC721(konguContract);
    }

    modifier onlySender() 
    {
        require(msg.sender == tx.origin);
        _;
    }

    function stakeKongu(uint256[] memory tokenIDs) external onlySender
    {
        require(kongu.isApprovedForAll(msg.sender, address(this)), "You have not approved this contract for staking");

        uint256 currentTokenID;

        for(uint256 i=0; i<tokenIDs.length; i++)
        {
            if(tokenIDs[i] < currentTokenID) revert NotAuthorized();

            kongu.transferFrom(msg.sender, address(this), tokenIDs[i]);
            konguPass.transferFrom(address(this), msg.sender, tokenIDs[i]);
            stakingDetails[tokenIDs[i]].isStaked = true;
            stakingDetails[tokenIDs[i]].timestamp = block.timestamp;
            stakingDetails[tokenIDs[i]].owner = msg.sender;

            currentTokenID = tokenIDs[i];
        }
        
    }

    function unStakeKongu(uint256[] memory tokenIDs) external onlySender
    {
        require(kongu.isApprovedForAll(msg.sender, address(this)), "You have not approved this contract for unstaking");
        require(konguPass.isApprovedForAll(msg.sender, address(this)), "You have not approved this contract for unstaking");

        uint256 currentTokenID;
        uint256 tksEarned;

        for(uint256 i=0; i<tokenIDs.length; i++)
        {
            if(tokenIDs[i] < currentTokenID) revert NotAuthorized();

            if(stakingDetails[tokenIDs[i]].owner != msg.sender) revert NotOwner();
            if(!stakingDetails[tokenIDs[i]].isStaked) revert NotStaked();

            kongu.transferFrom(address(this), msg.sender, tokenIDs[i]);
            konguPass.transferFrom(msg.sender, address(this), tokenIDs[i]);

            tksEarned += tokensEarned(tokenIDs[i]);
            currentTokenID = tokenIDs[i];

            delete stakingDetails[tokenIDs[i]];
        }

        if(tksEarned > 0)
        {
            _mint(msg.sender, tksEarned);
        }

    }

    function claimTokens(uint256[] memory tokenIDs) external onlySender
    {
        uint256 currentTokenID;
        uint256 tksEarned;

        for(uint256 i=0; i<tokenIDs.length; i++)
        {
            if(currentTokenID >= tokenIDs[i]) revert NotAuthorized();
            if(stakingDetails[tokenIDs[i]].owner != msg.sender) revert NotOwner();
            if(!stakingDetails[tokenIDs[i]].isStaked) revert NotStaked();
            
            tksEarned += tokensEarned(tokenIDs[i]);
            stakingDetails[tokenIDs[i]].timestamp = block.timestamp;

            currentTokenID = tokenIDs[i];
        }

        _mint(msg.sender, tksEarned);
    }

    function tokensEarned(uint256 tokenId) public view returns(uint256)
    {
        return (minutesStaked(tokenId) * KonguRate);
    }

    function minutesStaked(uint256 tokenId) public view returns(uint256)
    {
        uint256 stakingCalculation = block.timestamp - stakingDetails[tokenId].timestamp;
        return stakingCalculation / 60;
    }

    function burn(address _from, uint256 _amount) external 
	{
	    require(msg.sender == _from, "You do not own these tokens");
		_burn(_from, _amount);
	}

    function burnFrom(address _from, uint256 _amount) public override
    {
        ERC20I.burnFrom(_from, _amount);
    }

    function walletOfUnstakedKonguOwner(address address_) public virtual view returns (uint256[] memory) {
        uint256 _balance = kongu.balanceOf(address_);
        uint256[] memory _tokens = new uint256[] (_balance);
        uint256 _index;
        for (uint256 i=1; i<=350; i++) {
            if (kongu.ownerOf(i) == address_) { _tokens[_index] = i; _index++; }
        }
        return _tokens;
    }

    function walletOfStakedKonguOwner(address address_) public virtual view returns (uint256[] memory) {
        uint256 _balance = konguPass.balanceOf(address_);
        uint256[] memory _tokens = new uint256[] (_balance);
        uint256 _index;
        for (uint256 i=1; i<=350; i++) {
            if (konguPass.ownerOf(i) == address_) { _tokens[_index] = i; _index++; }
        }
        return _tokens;
    }      
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"konguContract","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NotAuthorized","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[],"name":"NotStaked","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","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":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"KonguRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIDs","type":"uint256[]"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kongu","outputs":[{"internalType":"contract ERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"konguPass","outputs":[{"internalType":"contract KonguStakingPass","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"minutesStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"to_","type":"address[]"},{"internalType":"uint256[]","name":"amounts_","type":"uint256[]"}],"name":"multiTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"from_","type":"address[]"},{"internalType":"address[]","name":"to_","type":"address[]"},{"internalType":"uint256[]","name":"amounts_","type":"uint256[]"}],"name":"multiTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIDs","type":"uint256[]"}],"name":"stakeKongu","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakingDetails","outputs":[{"internalType":"bool","name":"isStaked","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokensEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from_","type":"address"},{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIDs","type":"uint256[]"}],"name":"unStakeKongu","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"address_","type":"address"}],"name":"walletOfStakedKonguOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"address_","type":"address"}],"name":"walletOfUnstakedKonguOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000005817b0987fef2307de7b786fbbb52b5a7a10ad95

-----Decoded View---------------
Arg [0] : konguContract (address): 0x5817b0987fEf2307dE7B786fBBb52b5a7A10ad95

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000005817b0987fef2307de7b786fbbb52b5a7a10ad95

Deployed Bytecode Sourcemap

60179:4810:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60288:19;;;;;-1:-1:-1;;;;;60288:19:0;;;;;;-1:-1:-1;;;;;193:32:1;;;175:51;;163:2;148:18;60288:19:0;;;;;;;;55670:18;;;:::i;:::-;;;;;;;:::i;56944:162::-;;;;;;:::i;:::-;;:::i;:::-;;;1411:14:1;;1404:22;1386:41;;1374:2;1359:18;56944:162:0;1246:187:1;64563:417:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;55180:207::-;;;;;;:::i;:::-;-1:-1:-1;;;55180:207:0;;;;;;;;;;-1:-1:-1;;;;;;4014:33:1;;;3996:52;;3984:2;3969:18;55180:207:0;3852:202:1;55920:26:0;;;;;;;;;4205:25:1;;;4193:2;4178:18;55920:26:0;4059:177:1;57768:294:0;;;;;;:::i;:::-;;:::i;:::-;;57355:368;;;;;;:::i;:::-;;:::i;62809:669::-;;;;;;:::i;:::-;;:::i;55861:35::-;;55894:2;55861:35;;;;;7424:4:1;7412:17;;;7394:36;;7382:2;7367:18;55861:35:0;7252:184:1;58453:93:0;;;;;;:::i;:::-;;:::i;61706:1095::-;;;;;;:::i;:::-;;:::i;63486:135::-;;;;;;:::i;:::-;;:::i;63629:214::-;;;;;;:::i;:::-;;:::i;55988:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;2884:103;;;:::i;64015:121::-;;;;;;:::i;:::-;;:::i;58068:377::-;;;;;;:::i;:::-;;:::i;2236:87::-;2309:6;;-1:-1:-1;;;;;2309:6:0;2236:87;;55695:20;;;:::i;63851:156::-;;;;;;:::i;:::-;;:::i;60333:51::-;;60369:15;60333:51;;57112:237;;;;;;:::i;:::-;;:::i;60509:54::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;60509:54:0;;;;;;;8881:14:1;;8874:22;8856:41;;8928:2;8913:18;;8906:34;;;;-1:-1:-1;;;;;8976:32:1;8956:18;;;8949:60;8844:2;8829:18;60509:54:0;8660:355:1;60923:775:0;;;;;;:::i;:::-;;:::i;60248:33::-;;;;;-1:-1:-1;;;;;60248:33:0;;;64144:411;;;;;;:::i;:::-;;:::i;56039:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;3142:201;;;;;;:::i;:::-;;:::i;55670:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;56944:162::-;57020:4;57037:39;57046:10;57058:8;57068:7;57037:8;:39::i;:::-;-1:-1:-1;57094:4:0;56944:162;;;;;:::o;64563:417::-;64692:9;;:29;;-1:-1:-1;;;64692:29:0;;-1:-1:-1;;;;;193:32:1;;;64692:29:0;;;175:51:1;64644:16:0;;64673;;64692:9;;;:19;;148:18:1;;64692:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64673:48;;64732:24;64774:8;64759:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64759:24:0;-1:-1:-1;64732:51:0;-1:-1:-1;64794:14:0;64834:1;64819:129;64840:3;64837:1;:6;64819:129;;64869:9;;:20;;-1:-1:-1;;;64869:20:0;;;;;4205:25:1;;;-1:-1:-1;;;;;64869:32:0;;;;:9;;:17;;4178:18:1;;64869:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64869:32:0;;64865:72;;64923:1;64905:7;64913:6;64905:15;;;;;;;;:::i;:::-;;;;;;;;;;:19;64926:8;;;;:::i;:::-;;;;64865:72;64845:3;;;;:::i;:::-;;;;64819:129;;;-1:-1:-1;64965:7:0;;64563:417;-1:-1:-1;;;;64563:417:0:o;57768:294::-;57888:8;:15;57874:3;:10;:29;57866:81;;;;-1:-1:-1;;;57866:81:0;;11082:2:1;57866:81:0;;;11064:21:1;11121:2;11101:18;;;11094:30;11160:34;11140:18;;;11133:62;-1:-1:-1;;;11211:18:1;;;11204:37;11258:19;;57866:81:0;;;;;;;;;57963:9;57958:97;57982:3;:10;57978:1;:14;57958:97;;;58014:29;58023:3;58027:1;58023:6;;;;;;;;:::i;:::-;;;;;;;58031:8;58040:1;58031:11;;;;;;;;:::i;:::-;;;;;;;58014:8;:29::i;:::-;-1:-1:-1;57994:3:0;;;;:::i;:::-;;;;57958:97;;;;57768:294;;:::o;57355:368::-;-1:-1:-1;;;;;57467:16:0;;57446:4;57467:16;;;:9;:16;;;;;;;;57484:10;57467:28;;;;;;;;-1:-1:-1;;57467:49:0;57463:112;;-1:-1:-1;;;;;57533:16:0;;;;;;:9;:16;;;;;;;;57550:10;57533:28;;;;;;;:39;;57565:7;;57533:16;:39;;57565:7;;57533:39;:::i;:::-;;;;-1:-1:-1;;57463:112:0;-1:-1:-1;;;;;57585:16:0;;;;;;:9;:16;;;;;:27;;57605:7;;57585:16;:27;;57605:7;;57585:27;:::i;:::-;;;;-1:-1:-1;;;;;;;57623:14:0;;;;;;:9;:14;;;;;:25;;57641:7;;57623:14;:25;;57641:7;;57623:25;:::i;:::-;;;;;;;;57680:3;-1:-1:-1;;;;;57664:29:0;57673:5;-1:-1:-1;;;;;57664:29:0;-1:-1:-1;;;;;;;;;;;57685:7:0;57664:29;;;;4205:25:1;;4193:2;4178:18;;4059:177;57664:29:0;;;;;;;;-1:-1:-1;57711:4:0;57355:368;;;;;:::o;62809:669::-;60871:10;60885:9;60871:23;60863:32;;;;;;62893:22:::1;62926:17:::0;62960:9:::1;62956:474;62975:8;:15;62973:1;:17;62956:474;;;63042:8;63051:1;63042:11;;;;;;;;:::i;:::-;;;;;;;63024:14;:29;63021:56;;63062:15;;-1:-1:-1::0;;;63062:15:0::1;;;;;;;;;;;63021:56;63132:10;-1:-1:-1::0;;;;;63095:47:0::1;:14;:27;63110:8;63119:1;63110:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;63095:27;;;::::1;::::0;;;;;;-1:-1:-1;63095:27:0;:33:::1;;::::0;-1:-1:-1;;;;;63095:33:0::1;:47;63092:69;;63151:10;;-1:-1:-1::0;;;63151:10:0::1;;;;;;;;;;;63092:69;63180:14;:27;63195:8;63204:1;63195:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;63180:27;;;::::1;::::0;;;;;;-1:-1:-1;63180:27:0;:36;::::1;;63176:60;;63225:11;;-1:-1:-1::0;;;63225:11:0::1;;;;;;;;;;;63176:60;63278:25;63291:8;63300:1;63291:11;;;;;;;;:::i;:::-;;;;;;;63278:12;:25::i;:::-;63265:38;::::0;;::::1;:::i;:::-;;;63358:15;63318:14;:27;63333:8;63342:1;63333:11;;;;;;;;:::i;:::-;;;;;;;63318:27;;;;;;;;;;;:37;;:55;;;;63407:8;63416:1;63407:11;;;;;;;;:::i;:::-;;;;;;;63390:28;;62992:3;;;;;:::i;:::-;;;;62956:474;;;;63442:28;63448:10;63460:9;63442:5;:28::i;58453:93::-:0;58512:26;58518:10;58530:7;58512:5;:26::i;:::-;58453:93;:::o;61706:1095::-;60871:10;60885:9;60871:23;60863:32;;;;;;61799:5:::1;::::0;:49:::1;::::0;-1:-1:-1;;;61799:49:0;;61822:10:::1;61799:49;::::0;::::1;11763:34:1::0;61842:4:0::1;11813:18:1::0;;;11806:43;-1:-1:-1;;;;;61799:5:0;;::::1;::::0;:22:::1;::::0;11698:18:1;;61799:49:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61791:111;;;;-1:-1:-1::0;;;61791:111:0::1;;;;;;;:::i;:::-;61921:9;::::0;:53:::1;::::0;-1:-1:-1;;;61921:53:0;;61948:10:::1;61921:53;::::0;::::1;11763:34:1::0;61968:4:0::1;11813:18:1::0;;;11806:43;-1:-1:-1;;;;;61921:9:0;;::::1;::::0;:26:::1;::::0;11698:18:1;;61921:53:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61913:115;;;;-1:-1:-1::0;;;61913:115:0::1;;;;;;;:::i;:::-;62041:22;62074:17:::0;62108:9:::1;62104:594;62123:8;:15;62121:1;:17;62104:594;;;62186:14;62172:8;62181:1;62172:11;;;;;;;;:::i;:::-;;;;;;;:28;62169:55;;;62209:15;;-1:-1:-1::0;;;62209:15:0::1;;;;;;;;;;;62169:55;62281:10;-1:-1:-1::0;;;;;62244:47:0::1;:14;:27;62259:8;62268:1;62259:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;62244:27;;;::::1;::::0;;;;;;-1:-1:-1;62244:27:0;:33:::1;;::::0;-1:-1:-1;;;;;62244:33:0::1;:47;62241:69;;62300:10;;-1:-1:-1::0;;;62300:10:0::1;;;;;;;;;;;62241:69;62329:14;:27;62344:8;62353:1;62344:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;62329:27;;;::::1;::::0;;;;;;-1:-1:-1;62329:27:0;:36;::::1;;62325:60;;62374:11;;-1:-1:-1::0;;;62374:11:0::1;;;;;;;;;;;62325:60;62402:5;::::0;62448:11;;-1:-1:-1;;;;;62402:5:0;;::::1;::::0;:18:::1;::::0;62429:4:::1;::::0;62436:10:::1;::::0;62448:8;;62457:1;;62448:11;::::1;;;;;:::i;:::-;;;;;;;62402:58;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;62475:9:0::1;::::0;62525:11;;-1:-1:-1;;;;;62475:9:0;;::::1;::::0;-1:-1:-1;62475:22:0::1;::::0;-1:-1:-1;62498:10:0::1;::::0;62518:4:::1;::::0;62525:8;;62534:1;;62525:11;::::1;;;;;:::i;:::-;;;;;;;62475:62;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;62567:25;62580:8;62589:1;62580:11;;;;;;;;:::i;62567:25::-;62554:38;::::0;;::::1;:::i;:::-;;;62624:8;62633:1;62624:11;;;;;;;;:::i;:::-;;;;;;;62607:28;;62659:14;:27;62674:8;62683:1;62674:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;62659:27;;;::::1;::::0;;;;;;-1:-1:-1;62659:27:0;;;62652:34;;-1:-1:-1;;62652:34:0::1;::::0;;;;::::1;::::0;;;;::::1;;::::0;;-1:-1:-1;;;;;;62652:34:0::1;::::0;;62140:3;::::1;::::0;::::1;:::i;:::-;;;;62104:594;;;-1:-1:-1::0;62713:13:0;;62710:82:::1;;62752:28;62758:10;62770:9;62752:5;:28::i;63486:135::-:0;63545:7;60369:15;63578:22;63592:7;63578:13;:22::i;:::-;:34;;;;:::i;63629:214::-;63689:7;63761:23;;;:14;:23;;;;;:33;;;63689:7;;63743:51;;:15;:51;:::i;:::-;63714:80;-1:-1:-1;63812:23:0;63833:2;63714:80;63812:23;:::i;:::-;63805:30;63629:214;-1:-1:-1;;;63629:214:0:o;2884:103::-;2122:13;:11;:13::i;:::-;2949:30:::1;2976:1;2949:18;:30::i;:::-;2884:103::o:0;64015:121::-;64097:31;64113:5;64120:7;64097:15;:31::i;:::-;64015:121;;:::o;58068:377::-;58218:3;:10;58202:5;:12;:26;:61;;;;;58248:8;:15;58232:5;:12;:31;58202:61;58194:120;;;;-1:-1:-1;;;58194:120:0;;13537:2:1;58194:120:0;;;13519:21:1;13576:2;13556:18;;;13549:30;13615:34;13595:18;;;13588:62;-1:-1:-1;;;13666:18:1;;;13659:44;13720:19;;58194:120:0;13335:410:1;58194:120:0;58330:9;58325:113;58349:5;:12;58345:1;:16;58325:113;;;58383:43;58396:5;58402:1;58396:8;;;;;;;;:::i;:::-;;;;;;;58406:3;58410:1;58406:6;;;;;;;;:::i;:::-;;;;;;;58414:8;58423:1;58414:11;;;;;;;;:::i;:::-;;;;;;;58383:12;:43::i;:::-;-1:-1:-1;58363:3:0;;;;:::i;:::-;;;;58325:113;;;;58068:377;;;:::o;55695:20::-;;;;;;;:::i;63851:156::-;63925:10;-1:-1:-1;;;;;63925:19:0;;;63917:59;;;;-1:-1:-1;;;63917:59:0;;13952:2:1;63917:59:0;;;13934:21:1;13991:2;13971:18;;;13964:30;14030:29;14010:18;;;14003:57;14077:18;;63917:59:0;13750:351:1;63917:59:0;63981:21;63987:5;63994:7;63981:5;:21::i;57112:237::-;57211:10;57184:4;57201:21;;;:9;:21;;;;;:32;;57226:7;;57201:21;57184:4;;57201:32;;57226:7;;57201:32;:::i;:::-;;;;-1:-1:-1;;;;;;;57244:14:0;;;;;;:9;:14;;;;;:25;;57262:7;;57244:14;:25;;57262:7;;57244:25;:::i;:::-;;;;-1:-1:-1;;57285:34:0;;4205:25:1;;;-1:-1:-1;;;;;57285:34:0;;;57294:10;;-1:-1:-1;;;;;;;;;;;57285:34:0;4193:2:1;4178:18;57285:34:0;;;;;;;-1:-1:-1;57337:4:0;57112:237;;;;:::o;60923:775::-;60871:10;60885:9;60871:23;60863:32;;;;;;61014:5:::1;::::0;:49:::1;::::0;-1:-1:-1;;;61014:49:0;;61037:10:::1;61014:49;::::0;::::1;11763:34:1::0;61057:4:0::1;11813:18:1::0;;;11806:43;-1:-1:-1;;;;;61014:5:0;;::::1;::::0;:22:::1;::::0;11698:18:1;;61014:49:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61006:109;;;::::0;-1:-1:-1;;;61006:109:0;;14308:2:1;61006:109:0::1;::::0;::::1;14290:21:1::0;14347:2;14327:18;;;14320:30;14386:34;14366:18;;;14359:62;-1:-1:-1;;;14437:18:1;;;14430:45;14492:19;;61006:109:0::1;14106:411:1::0;61006:109:0::1;61128:22;::::0;61163:518:::1;61182:8;:15;61180:1;:17;61163:518;;;61245:14;61231:8;61240:1;61231:11;;;;;;;;:::i;:::-;;;;;;;:28;61228:55;;;61268:15;;-1:-1:-1::0;;;61268:15:0::1;;;;;;;;;;;61228:55;61300:5;::::0;61346:11;;-1:-1:-1;;;;;61300:5:0;;::::1;::::0;:18:::1;::::0;61319:10:::1;::::0;61339:4:::1;::::0;61346:8;;61355:1;;61346:11;::::1;;;;;:::i;:::-;;;;;;;61300:58;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;61373:9:0::1;::::0;61423:11;;-1:-1:-1;;;;;61373:9:0;;::::1;::::0;-1:-1:-1;61373:22:0::1;::::0;-1:-1:-1;61404:4:0::1;::::0;61411:10:::1;::::0;61423:8;;61432:1;;61423:11;::::1;;;;;:::i;:::-;;;;;;;61373:62;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61489:4;61450:14;:27;61465:8;61474:1;61465:11;;;;;;;;:::i;:::-;;;;;;;61450:27;;;;;;;;;;;:36;;;:43;;;;;;;;;;;;;;;;;;61548:15;61508:14;:27;61523:8;61532:1;61523:11;;;;;;;;:::i;:::-;;;;;;;61508:27;;;;;;;;;;;:37;;:55;;;;61614:10;61578:14;:27;61593:8;61602:1;61593:11;;;;;;;;:::i;:::-;;;;;;;61578:27;;;;;;;;;;;:33;;;:46;;;;;-1:-1:-1::0;;;;;61578:46:0::1;;;;;-1:-1:-1::0;;;;;61578:46:0::1;;;;;;61658:8;61667:1;61658:11;;;;;;;;:::i;:::-;;;;;;;61641:28;;61199:3;;;;;:::i;:::-;;;;61163:518;;64144:411:::0;64275:5;;:25;;-1:-1:-1;;;64275:25:0;;-1:-1:-1;;;;;193:32:1;;;64275:25:0;;;175:51:1;64227:16:0;;64256;;64275:5;;;:15;;148:18:1;;64275:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64256:44;;64311:24;64353:8;64338:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64338:24:0;-1:-1:-1;64311:51:0;-1:-1:-1;64373:14:0;64413:1;64398:125;64419:3;64416:1;:6;64398:125;;64448:5;;:16;;-1:-1:-1;;;64448:16:0;;;;;4205:25:1;;;-1:-1:-1;;;;;64448:28:0;;;;:5;;:13;;4178:18:1;;64448:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64448:28:0;;64444:68;;64498:1;64480:7;64488:6;64480:15;;;;;;;;:::i;:::-;;;;;;;;;;:19;64501:8;;;;:::i;:::-;;;;64444:68;64424:3;;;;:::i;:::-;;;;64398:125;;3142:201;2122:13;:11;:13::i;:::-;-1:-1:-1;;;;;3231:22:0;::::1;3223:73;;;::::0;-1:-1:-1;;;3223:73:0;;14724:2:1;3223:73:0::1;::::0;::::1;14706:21:1::0;14763:2;14743:18;;;14736:30;14802:34;14782:18;;;14775:62;-1:-1:-1;;;14853:18:1;;;14846:36;14899:19;;3223:73:0::1;14522:402:1::0;3223:73:0::1;3307:28;3326:8;3307:18;:28::i;56718:193::-:0;-1:-1:-1;;;;;56815:17:0;;;;;;;:9;:17;;;;;;;;:27;;;;;;;;;;;;;:37;;;56868:35;;4205:25:1;;;56868:35:0;;4178:18:1;56868:35:0;;;;;;;56718:193;;;:::o;56318:191::-;56406:7;56391:11;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;56424:14:0;;;;;;:9;:14;;;;;:25;;56442:7;;56424:14;:25;;56442:7;;56424:25;:::i;:::-;;;;-1:-1:-1;;56465:36:0;;4205:25:1;;;-1:-1:-1;;;;;56465:36:0;;;56482:3;;-1:-1:-1;;;;;;;;;;;56465:36:0;4193:2:1;4178:18;56465:36:0;;;;;;;;56318:191;;:::o;56515:197::-;-1:-1:-1;;;;;56590:16:0;;;;;;:9;:16;;;;;:27;;56610:7;;56590:16;:27;;56610:7;;56590:27;:::i;:::-;;;;;;;;56643:7;56628:11;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;56666:38:0;;4205:25:1;;;56690:3:0;;-1:-1:-1;;;;;56666:38:0;;;-1:-1:-1;;;;;;;;;;;56666:38:0;4193:2:1;4178:18;56666:38:0;4059:177:1;2401:132:0;2309:6;;-1:-1:-1;;;;;2309:6:0;861:10;2465:23;2457:68;;;;-1:-1:-1;;;2457:68:0;;15131:2:1;2457:68:0;;;15113:21:1;;;15150:18;;;15143:30;15209:34;15189:18;;;15182:62;15261:18;;2457:68:0;14929:356:1;3503:191:0;3596:6;;;-1:-1:-1;;;;;3613:17:0;;;-1:-1:-1;;;;;;3613:17:0;;;;;;;3646:40;;3596:6;;;3613:17;3596:6;;3646:40;;3577:16;;3646:40;3566:128;3503:191;:::o;58552:406::-;-1:-1:-1;;;;;58656:16:0;;58628:25;58656:16;;;:9;:16;;;;;;;;58673:10;58656:28;;;;;;;;58703;;;;58695:97;;;;-1:-1:-1;;;58695:97:0;;15492:2:1;58695:97:0;;;15474:21:1;15531:2;15511:18;;;15504:30;15570:34;15550:18;;;15543:62;15641:26;15621:18;;;15614:54;15685:19;;58695:97:0;15290:420:1;58695:97:0;-1:-1:-1;;;;;58809:16:0;;;;;;:9;:16;;;;;;;;58826:10;58809:28;;;;;;;;-1:-1:-1;;58809:49:0;58805:112;;-1:-1:-1;;;;;58875:16:0;;;;;;:9;:16;;;;;;;;58892:10;58875:28;;;;;;;:39;;58907:7;;58875:16;:39;;58907:7;;58875:39;:::i;:::-;;;;-1:-1:-1;;58805:112:0;58929:21;58935:5;58942:7;58929:5;:21::i;237:548:1:-;349:4;378:2;407;396:9;389:21;439:6;433:13;482:6;477:2;466:9;462:18;455:34;507:1;517:140;531:6;528:1;525:13;517:140;;;626:14;;;622:23;;616:30;592:17;;;611:2;588:26;581:66;546:10;;517:140;;;521:3;706:1;701:2;692:6;681:9;677:22;673:31;666:42;776:2;769;765:7;760:2;752:6;748:15;744:29;733:9;729:45;725:54;717:62;;;;237:548;;;;:::o;790:131::-;-1:-1:-1;;;;;865:31:1;;855:42;;845:70;;911:1;908;901:12;926:315;994:6;1002;1055:2;1043:9;1034:7;1030:23;1026:32;1023:52;;;1071:1;1068;1061:12;1023:52;1110:9;1097:23;1129:31;1154:5;1129:31;:::i;:::-;1179:5;1231:2;1216:18;;;;1203:32;;-1:-1:-1;;;926:315:1:o;1438:247::-;1497:6;1550:2;1538:9;1529:7;1525:23;1521:32;1518:52;;;1566:1;1563;1556:12;1518:52;1605:9;1592:23;1624:31;1649:5;1624:31;:::i;1690:632::-;1861:2;1913:21;;;1983:13;;1886:18;;;2005:22;;;1832:4;;1861:2;2084:15;;;;2058:2;2043:18;;;1832:4;2127:169;2141:6;2138:1;2135:13;2127:169;;;2202:13;;2190:26;;2271:15;;;;2236:12;;;;2163:1;2156:9;2127:169;;;-1:-1:-1;2313:3:1;;1690:632;-1:-1:-1;;;;;;1690:632:1:o;2327:127::-;2388:10;2383:3;2379:20;2376:1;2369:31;2419:4;2416:1;2409:15;2443:4;2440:1;2433:15;2459:275;2530:2;2524:9;2595:2;2576:13;;-1:-1:-1;;2572:27:1;2560:40;;2630:18;2615:34;;2651:22;;;2612:62;2609:88;;;2677:18;;:::i;:::-;2713:2;2706:22;2459:275;;-1:-1:-1;2459:275:1:o;2739:1108::-;2834:6;2842;2850;2858;2911:3;2899:9;2890:7;2886:23;2882:33;2879:53;;;2928:1;2925;2918:12;2879:53;2967:9;2954:23;2986:31;3011:5;2986:31;:::i;:::-;3036:5;-1:-1:-1;3060:2:1;3099:18;;;3086:32;3127:33;3086:32;3127:33;:::i;:::-;3179:7;-1:-1:-1;3233:2:1;3218:18;;3205:32;;-1:-1:-1;3288:2:1;3273:18;;3260:32;3311:18;3341:14;;;3338:34;;;3368:1;3365;3358:12;3338:34;3406:6;3395:9;3391:22;3381:32;;3451:7;3444:4;3440:2;3436:13;3432:27;3422:55;;3473:1;3470;3463:12;3422:55;3509:2;3496:16;3531:2;3527;3524:10;3521:36;;;3537:18;;:::i;:::-;3579:53;3622:2;3603:13;;-1:-1:-1;;3599:27:1;3595:36;;3579:53;:::i;:::-;3566:66;;3655:2;3648:5;3641:17;3695:7;3690:2;3685;3681;3677:11;3673:20;3670:33;3667:53;;;3716:1;3713;3706:12;3667:53;3771:2;3766;3762;3758:11;3753:2;3746:5;3742:14;3729:45;3815:1;3810:2;3805;3798:5;3794:14;3790:23;3783:34;;3836:5;3826:15;;;;;2739:1108;;;;;;;:::o;4241:183::-;4301:4;4334:18;4326:6;4323:30;4320:56;;;4356:18;;:::i;:::-;-1:-1:-1;4401:1:1;4397:14;4413:4;4393:25;;4241:183::o;4429:737::-;4483:5;4536:3;4529:4;4521:6;4517:17;4513:27;4503:55;;4554:1;4551;4544:12;4503:55;4590:6;4577:20;4616:4;4640:60;4656:43;4696:2;4656:43;:::i;:::-;4640:60;:::i;:::-;4734:15;;;4820:1;4816:10;;;;4804:23;;4800:32;;;4765:12;;;;4844:15;;;4841:35;;;4872:1;4869;4862:12;4841:35;4908:2;4900:6;4896:15;4920:217;4936:6;4931:3;4928:15;4920:217;;;5016:3;5003:17;5033:31;5058:5;5033:31;:::i;:::-;5077:18;;5115:12;;;;4953;;4920:217;;;-1:-1:-1;5155:5:1;4429:737;-1:-1:-1;;;;;;4429:737:1:o;5171:662::-;5225:5;5278:3;5271:4;5263:6;5259:17;5255:27;5245:55;;5296:1;5293;5286:12;5245:55;5332:6;5319:20;5358:4;5382:60;5398:43;5438:2;5398:43;:::i;5382:60::-;5476:15;;;5562:1;5558:10;;;;5546:23;;5542:32;;;5507:12;;;;5586:15;;;5583:35;;;5614:1;5611;5604:12;5583:35;5650:2;5642:6;5638:15;5662:142;5678:6;5673:3;5670:15;5662:142;;;5744:17;;5732:30;;5782:12;;;;5695;;5662:142;;5838:595;5956:6;5964;6017:2;6005:9;5996:7;5992:23;5988:32;5985:52;;;6033:1;6030;6023:12;5985:52;6073:9;6060:23;6102:18;6143:2;6135:6;6132:14;6129:34;;;6159:1;6156;6149:12;6129:34;6182:61;6235:7;6226:6;6215:9;6211:22;6182:61;:::i;:::-;6172:71;;6296:2;6285:9;6281:18;6268:32;6252:48;;6325:2;6315:8;6312:16;6309:36;;;6341:1;6338;6331:12;6309:36;;6364:63;6419:7;6408:8;6397:9;6393:24;6364:63;:::i;:::-;6354:73;;;5838:595;;;;;:::o;6438:456::-;6515:6;6523;6531;6584:2;6572:9;6563:7;6559:23;6555:32;6552:52;;;6600:1;6597;6590:12;6552:52;6639:9;6626:23;6658:31;6683:5;6658:31;:::i;:::-;6708:5;-1:-1:-1;6765:2:1;6750:18;;6737:32;6778:33;6737:32;6778:33;:::i;:::-;6438:456;;6830:7;;-1:-1:-1;;;6884:2:1;6869:18;;;;6856:32;;6438:456::o;6899:348::-;6983:6;7036:2;7024:9;7015:7;7011:23;7007:32;7004:52;;;7052:1;7049;7042:12;7004:52;7092:9;7079:23;7125:18;7117:6;7114:30;7111:50;;;7157:1;7154;7147:12;7111:50;7180:61;7233:7;7224:6;7213:9;7209:22;7180:61;:::i;:::-;7170:71;6899:348;-1:-1:-1;;;;6899:348:1:o;7441:180::-;7500:6;7553:2;7541:9;7532:7;7528:23;7524:32;7521:52;;;7569:1;7566;7559:12;7521:52;-1:-1:-1;7592:23:1;;7441:180;-1:-1:-1;7441:180:1:o;7626:821::-;7778:6;7786;7794;7847:2;7835:9;7826:7;7822:23;7818:32;7815:52;;;7863:1;7860;7853:12;7815:52;7903:9;7890:23;7932:18;7973:2;7965:6;7962:14;7959:34;;;7989:1;7986;7979:12;7959:34;8012:61;8065:7;8056:6;8045:9;8041:22;8012:61;:::i;:::-;8002:71;;8126:2;8115:9;8111:18;8098:32;8082:48;;8155:2;8145:8;8142:16;8139:36;;;8171:1;8168;8161:12;8139:36;8194:63;8249:7;8238:8;8227:9;8223:24;8194:63;:::i;:::-;8184:73;;8310:2;8299:9;8295:18;8282:32;8266:48;;8339:2;8329:8;8326:16;8323:36;;;8355:1;8352;8345:12;8323:36;;8378:63;8433:7;8422:8;8411:9;8407:24;8378:63;:::i;:::-;8368:73;;;7626:821;;;;;:::o;9253:388::-;9321:6;9329;9382:2;9370:9;9361:7;9357:23;9353:32;9350:52;;;9398:1;9395;9388:12;9350:52;9437:9;9424:23;9456:31;9481:5;9456:31;:::i;:::-;9506:5;-1:-1:-1;9563:2:1;9548:18;;9535:32;9576:33;9535:32;9576:33;:::i;:::-;9628:7;9618:17;;;9253:388;;;;;:::o;9646:380::-;9725:1;9721:12;;;;9768;;;9789:61;;9843:4;9835:6;9831:17;9821:27;;9789:61;9896:2;9888:6;9885:14;9865:18;9862:38;9859:161;;9942:10;9937:3;9933:20;9930:1;9923:31;9977:4;9974:1;9967:15;10005:4;10002:1;9995:15;9859:161;;9646:380;;;:::o;10031:184::-;10101:6;10154:2;10142:9;10133:7;10129:23;10125:32;10122:52;;;10170:1;10167;10160:12;10122:52;-1:-1:-1;10193:16:1;;10031:184;-1:-1:-1;10031:184:1:o;10220:251::-;10290:6;10343:2;10331:9;10322:7;10318:23;10314:32;10311:52;;;10359:1;10356;10349:12;10311:52;10391:9;10385:16;10410:31;10435:5;10410:31;:::i;10476:127::-;10537:10;10532:3;10528:20;10525:1;10518:31;10568:4;10565:1;10558:15;10592:4;10589:1;10582:15;10608:127;10669:10;10664:3;10660:20;10657:1;10650:31;10700:4;10697:1;10690:15;10724:4;10721:1;10714:15;10740:135;10779:3;10800:17;;;10797:43;;10820:18;;:::i;:::-;-1:-1:-1;10867:1:1;10856:13;;10740:135::o;11288:128::-;11355:9;;;11376:11;;;11373:37;;;11390:18;;:::i;11421:125::-;11486:9;;;11507:10;;;11504:36;;;11520:18;;:::i;11860:277::-;11927:6;11980:2;11968:9;11959:7;11955:23;11951:32;11948:52;;;11996:1;11993;11986:12;11948:52;12028:9;12022:16;12081:5;12074:13;12067:21;12060:5;12057:32;12047:60;;12103:1;12100;12093:12;12142:413;12344:2;12326:21;;;12383:2;12363:18;;;12356:30;12422:34;12417:2;12402:18;;12395:62;-1:-1:-1;;;12488:2:1;12473:18;;12466:47;12545:3;12530:19;;12142:413::o;12560:375::-;-1:-1:-1;;;;;12818:15:1;;;12800:34;;12870:15;;;;12865:2;12850:18;;12843:43;12917:2;12902:18;;12895:34;;;;12750:2;12735:18;;12560:375::o;12940:168::-;13013:9;;;13044;;13061:15;;;13055:22;;13041:37;13031:71;;13082:18;;:::i;13113:217::-;13153:1;13179;13169:132;;13223:10;13218:3;13214:20;13211:1;13204:31;13258:4;13255:1;13248:15;13286:4;13283:1;13276:15;13169:132;-1:-1:-1;13315:9:1;;13113:217::o

Swarm Source

ipfs://4cb6198f0f39400bbc67ee8292b3bd5366991e4af7bda872d84bc2dc83f83dc0

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services