Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•    - function stake(uint256 _stakingId, ui ...
•    - function unstake(uint256 _stakingId, ...
•    - function getEarnedRewards(uint256 _st ...
•    - function claimEarnedReward(uint256 _s ...
•    - function getStakedTokens(uint256 _sta ...
•  contract PepemonNFTSTAKING is NFTS ... *
•    - function stake(uint256 _stakingId, ui ...
•    - function getEarnedRewards(uint256 _st ...
•    - function unstake(uint256 _stakingId, ...
•    - function claimEarnedReward(uint256 _s ...
•    - function getStakedTokens(uint256 _sta ...
•    - function setRewardsPerNFTPerDay(uint2 ...
•    - function setStakeConclude(uint256 _st ...
•    - function removeTokens()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-06-21
*/

// File: contracts/EnumerableSet.sol


// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

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

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

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

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

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

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

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

// File: contracts/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}
// File: contracts/Address.sol


// OpenZeppelin Contracts (last updated v4.5.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 functionCall(target, data, "Address: low-level call failed");
    }

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

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

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

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

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

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

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

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

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

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

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
// File: contracts/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}
// File: contracts/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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


// 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: contracts/Ownable.sol


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

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

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

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

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


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







abstract contract NFTStaking is ReentrancyGuard, Ownable {

    struct Plan {
        uint256 overallStaked;
        uint256 rewardsPerNFTPerDay;
        uint256 apr;
        uint256 stakeDuration;
        bool conclude;
    }
    
    struct Staking {
        EnumerableSet.UintSet tokenIds;
        mapping(uint256 => uint256) stakeAt;
        mapping(uint256 => uint256) endstakeAt;
    }

    mapping(uint256 => mapping(address => Staking)) internal stakes;

    address public stakingToken;
    address public rewardToken;
    uint256 public rewardTokenDecimal;
    mapping(uint256 => Plan) public plans;

    constructor(address _stakingToken, address _rewardToken, uint256 _rewardTokenDecimal) {
        stakingToken = _stakingToken;
        rewardToken = _rewardToken;
        rewardTokenDecimal = _rewardTokenDecimal;
    }

    function stake(uint256 _stakingId, uint256[] memory tokenIds) public virtual;
    function unstake(uint256 _stakingId, uint256[] memory tokenIds) public virtual;
    function getEarnedRewards(uint256 _stakingId, address account) public virtual view returns (uint256, uint256);
    function claimEarnedReward(uint256 _stakingId) public virtual;
    function getStakedTokens(uint256 _stakingId, address _account) public virtual view returns (uint256[] memory);
}

contract PepemonNFTSTAKING is NFTStaking {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.UintSet;

    uint256 public periodicTime = 365 days;
    uint256 public planLimit = 1;
    uint256 minAPR = 10;

    constructor(address _stakingToken, address _rewardToken, uint256 _rewardTokenDecimal, uint256 _rewardsPerNFTPerDay, uint256 _lockDuration) NFTStaking(_stakingToken, _rewardToken, _rewardTokenDecimal) {
        plans[0].rewardsPerNFTPerDay = _rewardsPerNFTPerDay;
        plans[0].apr = _rewardsPerNFTPerDay
                       .mul(periodicTime)
                       .mul(100)
                       .div(24 hours);
        plans[0].stakeDuration = _lockDuration * 1 days;
    }

    function stake(uint256 _stakingId, uint256[] memory tokenIds) public override nonReentrant {

        require(_stakingId < planLimit, "Staking is unavailable");

        Plan storage plan = plans[_stakingId];
        require(!plan.conclude, "Staking in this pool is concluded");
        
        Staking storage _staking = stakes[_stakingId][msg.sender];

        for (uint256 i = 0; i < tokenIds.length; i++) {
            require(IERC721(stakingToken).ownerOf(tokenIds[i]) == msg.sender, "You can only stake NFTs which you own");
            _staking.tokenIds.add(tokenIds[i]);
            _staking.stakeAt[tokenIds[i]] = block.timestamp;
            _staking.endstakeAt[tokenIds[i]] = block.timestamp + plan.stakeDuration;

            // Transfer the deposited token to this contract
            IERC721(stakingToken).transferFrom(msg.sender, address(this), tokenIds[i]);
            plan.overallStaked = plan.overallStaked + 1;
        }
    }

    function getEarnedRewards(uint256 _stakingId, address _account) public override view returns (uint256, uint256) {
        uint256 _canClaim = 0;
        uint256 _earned = 0;
        Plan storage plan = plans[_stakingId];
        Staking storage _staking = stakes[_stakingId][_account];
        
        for (uint256 i = 0; i < _staking.tokenIds.length(); i++) {
            uint256 tokenId = _staking.tokenIds.at(i);
            if (block.timestamp >= _staking.endstakeAt[tokenId])
                _canClaim = _canClaim.add(
                    plan.apr
                        .div(100)
                        .mul(block.timestamp - _staking.stakeAt[tokenId])
                        .div(periodicTime)
                );
            _earned = _earned.add(
                plan.apr
                    .div(100)
                    .mul(block.timestamp - _staking.stakeAt[tokenId])
                    .div(periodicTime)
            );
        }

        return (_earned, _canClaim);
    }

    function unstake(uint256 _stakingId, uint256[] memory tokenIds) public override nonReentrant {
        
        Plan storage plan = plans[_stakingId];
        Staking storage _staking = stakes[_stakingId][msg.sender];
        uint256 _rewards = 0;

        for (uint256 i = 0; i < tokenIds.length; i++) {
            require(_staking.tokenIds.contains(tokenIds[i]), "Query for a token you haven't staked");
            
            if (block.timestamp >= _staking.endstakeAt[tokenIds[i]]) {
                _rewards = _rewards.add(
                        plan.apr
                            .div(100)
                            .mul(block.timestamp - _staking.stakeAt[tokenIds[i]])
                            .div(periodicTime)
                );
            }

            _staking.tokenIds.remove(tokenIds[i]);
            delete _staking.stakeAt[tokenIds[i]];
            delete _staking.endstakeAt[tokenIds[i]];

            IERC721(stakingToken).safeTransferFrom(address(this), msg.sender, tokenIds[i]);
            plan.overallStaked = plan.overallStaked - 1;
        }
        
        if(_rewards > 0) {
            IERC20(rewardToken).transfer(msg.sender, _rewards);
        }
    }

    function claimEarnedReward(uint256 _stakingId) public override nonReentrant {
        uint256 _rewards = 0;
        Plan storage plan = plans[_stakingId];
        Staking storage _staking = stakes[_stakingId][msg.sender];

        for (uint256 i = 0; i < _staking.tokenIds.length(); i++) {
            uint256 tokenId = _staking.tokenIds.at(i);
            if (block.timestamp >= _staking.endstakeAt[tokenId]) {
                _rewards = _rewards.add(
                        plan.apr
                            .div(100)
                            .mul(block.timestamp - _staking.stakeAt[tokenId])
                            .div(periodicTime)
                );
                _staking.stakeAt[tokenId] = block.timestamp;
            }
        }
        require(_rewards > 0, "There is no amount to claim");
        IERC20(rewardToken).transfer(msg.sender, _rewards);
    }

    function getStakedTokens(uint256 _stakingId, address _account) public override view returns (uint256[] memory) {
        Staking storage _staking = stakes[_stakingId][_account];
        uint256[] memory stakedTokenIds = new uint256[](_staking.tokenIds.length());
        
        for (uint256 i = 0; i < _staking.tokenIds.length(); i++) {
            stakedTokenIds[i] = _staking.tokenIds.at(i);
        }

        return stakedTokenIds;
    }

    function setRewardsPerNFTPerDay(uint256 _stakingId, uint256 _rewards) external onlyOwner {
        plans[_stakingId].rewardsPerNFTPerDay = _rewards;
        plans[_stakingId].apr = _rewards
                                .mul(periodicTime)
                                .mul(100)
                                .div(24 hours);
        require(plans[_stakingId].apr >= minAPR, "Low APR");
    }

    function setStakeConclude(uint256 _stakingId, bool _conclude) external onlyOwner {
        plans[_stakingId].conclude = _conclude;
    }

    function removeTokens() public onlyOwner {
        IERC20(rewardToken).transfer(msg.sender, IERC20(rewardToken).balanceOf(address(this)));
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stakingToken","type":"address"},{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_rewardTokenDecimal","type":"uint256"},{"internalType":"uint256","name":"_rewardsPerNFTPerDay","type":"uint256"},{"internalType":"uint256","name":"_lockDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"}],"name":"claimEarnedReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"},{"internalType":"address","name":"_account","type":"address"}],"name":"getEarnedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"},{"internalType":"address","name":"_account","type":"address"}],"name":"getStakedTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodicTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"planLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"plans","outputs":[{"internalType":"uint256","name":"overallStaked","type":"uint256"},{"internalType":"uint256","name":"rewardsPerNFTPerDay","type":"uint256"},{"internalType":"uint256","name":"apr","type":"uint256"},{"internalType":"uint256","name":"stakeDuration","type":"uint256"},{"internalType":"bool","name":"conclude","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"removeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardTokenDecimal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"},{"internalType":"uint256","name":"_rewards","type":"uint256"}],"name":"setRewardsPerNFTPerDay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"},{"internalType":"bool","name":"_conclude","type":"bool"}],"name":"setStakeConclude","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakingId","type":"uint256"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005be311c3f67c94e2c9d2ce9218df32380a9b7595000000000000000000000000bf3079a21d7e3c4041f538a73957a4ce5517ed6d000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000006f05b59d3b200000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x5BE311c3f67c94e2c9D2cE9218DF32380a9b7595
Arg [1] : _rewardToken (address): 0xbF3079A21D7E3C4041F538A73957a4ce5517eD6d
Arg [2] : _rewardTokenDecimal (uint256): 18
Arg [3] : _rewardsPerNFTPerDay (uint256): 500000000000000000
Arg [4] : _lockDuration (uint256): 0

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000005be311c3f67c94e2c9d2ce9218df32380a9b7595
Arg [1] : 000000000000000000000000bf3079a21d7e3c4041f538a73957a4ce5517ed6d
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [3] : 00000000000000000000000000000000000000000000000006f05b59d3b20000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000

48127:6080:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48295:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48901:967;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50899:1224;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48340:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54056:146;;;:::i;:::-;;45894:103;;;:::i;:::-;;47276:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49876:1015;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;53038:452;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45243:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52131:899;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47383:37;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;47343:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53498:404;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53910:138;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46152:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47310:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48295:38;;;;:::o;48901:967::-;42386:1;42984:7;;:19;42976:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;42386:1;43117:7;:18;;;;49026:9:::1;;49013:10;:22;49005:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;49075:17;49095:5;:17;49101:10;49095:17;;;;;;;;;;;49075:37;;49132:4;:13;;;;;;;;;;;;49131:14;49123:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;49204:24;49231:6;:18;49238:10;49231:18;;;;;;;;;;;:30;49250:10;49231:30;;;;;;;;;;;;;;;49204:57;;49279:9;49274:587;49298:8;:15;49294:1;:19;49274:587;;;49389:10;49343:56;;49351:12;;;;;;;;;;;49343:29;;;49373:8;49382:1;49373:11;;;;;;;;:::i;:::-;;;;;;;;49343:42;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:56;;;49335:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;49456:34;49478:8;49487:1;49478:11;;;;;;;;:::i;:::-;;;;;;;;49456:8;:17;;:21;;:34;;;;:::i;:::-;;49537:15;49505:8;:16;;:29;49522:8;49531:1;49522:11;;;;;;;;:::i;:::-;;;;;;;;49505:29;;;;;;;;;;;:47;;;;49620:4;:18;;;49602:15;:36;;;;:::i;:::-;49567:8;:19;;:32;49587:8;49596:1;49587:11;;;;;;;;:::i;:::-;;;;;;;;49567:32;;;;;;;;;;;:71;;;;49725:12;;;;;;;;;;;49717:34;;;49752:10;49772:4;49779:8;49788:1;49779:11;;;;;;;;:::i;:::-;;;;;;;;49717:74;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49848:1;49827:4;:18;;;:22;;;;:::i;:::-;49806:4;:18;;:43;;;;49315:3;;;;;:::i;:::-;;;;49274:587;;;;48992:876;;42342:1:::0;43296:7;:22;;;;48901:967;;:::o;50899:1224::-;42386:1;42984:7;;:19;42976:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;42386:1;43117:7;:18;;;;51013:17:::1;51033:5;:17;51039:10;51033:17;;;;;;;;;;;51013:37;;51061:24;51088:6;:18;51095:10;51088:18;;;;;;;;;;;:30;51107:10;51088:30;;;;;;;;;;;;;;;51061:57;;51129:16;51167:9:::0;51162:840:::1;51186:8;:15;51182:1;:19;51162:840;;;51231:39;51258:8;51267:1;51258:11;;;;;;;;:::i;:::-;;;;;;;;51231:8;:17;;:26;;:39;;;;:::i;:::-;51223:88;;;;;;;;;;;;:::i;:::-;;;;;;;;;51363:8;:19;;:32;51383:8;51392:1;51383:11;;;;;;;;:::i;:::-;;;;;;;;51363:32;;;;;;;;;;;;51344:15;:51;51340:339;;51427:236;51466:178;51631:12;;51466:130;51566:8;:16;;:29;51583:8;51592:1;51583:11;;;;;;;;:::i;:::-;;;;;;;;51566:29;;;;;;;;;;;;51548:15;:47;;;;:::i;:::-;51466;51509:3;51466:4;:8;;;:42;;:47;;;;:::i;:::-;:81;;:130;;;;:::i;:::-;:164;;:178;;;;:::i;:::-;51427:8;:12;;:236;;;;:::i;:::-;51416:247;;51340:339;51695:37;51720:8;51729:1;51720:11;;;;;;;;:::i;:::-;;;;;;;;51695:8;:17;;:24;;:37;;;;:::i;:::-;;51754:8;:16;;:29;51771:8;51780:1;51771:11;;;;;;;;:::i;:::-;;;;;;;;51754:29;;;;;;;;;;;51747:36;;;51805:8;:19;;:32;51825:8;51834:1;51825:11;;;;;;;;:::i;:::-;;;;;;;;51805:32;;;;;;;;;;;51798:39;;;51862:12;;;;;;;;;;;51854:38;;;51901:4;51908:10;51920:8;51929:1;51920:11;;;;;;;;:::i;:::-;;;;;;;;51854:78;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;51989:1;51968:4;:18;;;:22;;;;:::i;:::-;51947:4;:18;;:43;;;;51203:3;;;;;:::i;:::-;;;;51162:840;;;;52036:1;52025:8;:12;52022:94;;;52061:11;;;;;;;;;;;52054:28;;;52083:10;52095:8;52054:50;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52022:94;50992:1131;;;42342:1:::0;43296:7;:22;;;;50899:1224;;:::o;48340:28::-;;;;:::o;54056:146::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54115:11:::1;;;;;;;;;;;54108:28;;;54137:10;54156:11;;;;;;;;;;;54149:29;;;54187:4;54149:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54108:86;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54056:146::o:0;45894:103::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;45959:30:::1;45986:1;45959:18;:30::i;:::-;45894:103::o:0;47276:27::-;;;;;;;;;;;;;:::o;49876:1015::-;49970:7;49979;49999:17;50031:15;50061:17;50081:5;:17;50087:10;50081:17;;;;;;;;;;;50061:37;;50109:24;50136:6;:18;50143:10;50136:18;;;;;;;;;;;:28;50155:8;50136:28;;;;;;;;;;;;;;;50109:55;;50190:9;50185:659;50209:26;:8;:17;;:24;:26::i;:::-;50205:1;:30;50185:659;;;50257:15;50275:23;50296:1;50275:8;:17;;:20;;:23;;;;:::i;:::-;50257:41;;50336:8;:19;;:28;50356:7;50336:28;;;;;;;;;;;;50317:15;:47;50313:299;;50395:217;50431:162;50580:12;;50431:118;50523:8;:16;;:25;50540:7;50523:25;;;;;;;;;;;;50505:15;:43;;;;:::i;:::-;50431;50470:3;50431:4;:8;;;:38;;:43;;;;:::i;:::-;:73;;:118;;;;:::i;:::-;:148;;:162;;;;:::i;:::-;50395:9;:13;;:217;;;;:::i;:::-;50383:229;;50313:299;50637:195;50667:150;50804:12;;50667:110;50751:8;:16;;:25;50768:7;50751:25;;;;;;;;;;;;50733:15;:43;;;;:::i;:::-;50667:39;50702:3;50667:4;:8;;;:34;;:39;;;;:::i;:::-;:65;;:110;;;;:::i;:::-;:136;;:150;;;;:::i;:::-;50637:7;:11;;:195;;;;:::i;:::-;50627:205;;50242:602;50237:3;;;;;:::i;:::-;;;;50185:659;;;;50864:7;50873:9;50856:27;;;;;;;;49876:1015;;;;;:::o;53038:452::-;53131:16;53160:24;53187:6;:18;53194:10;53187:18;;;;;;;;;;;:28;53206:8;53187:28;;;;;;;;;;;;;;;53160:55;;53226:31;53274:26;:8;:17;;:24;:26::i;:::-;53260:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53226:75;;53327:9;53322:127;53346:26;:8;:17;;:24;:26::i;:::-;53342:1;:30;53322:127;;;53414:23;53435:1;53414:8;:17;;:20;;:23;;;;:::i;:::-;53394:14;53409:1;53394:17;;;;;;;;:::i;:::-;;;;;;;:43;;;;;53374:3;;;;;:::i;:::-;;;;53322:127;;;;53468:14;53461:21;;;;53038:452;;;;:::o;45243:87::-;45289:7;45316:6;;;;;;;;;;;45309:13;;45243:87;:::o;52131:899::-;42386:1;42984:7;;:19;42976:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;42386:1;43117:7;:18;;;;52218:16:::1;52249:17:::0;52269:5:::1;:17;52275:10;52269:17;;;;;;;;;;;52249:37;;52297:24;52324:6;:18;52331:10;52324:18;;;;;;;;;;;:30;52343:10;52324:30;;;;;;;;;;;;;;;52297:57;;52372:9;52367:532;52391:26;:8;:17;;:24;:26::i;:::-;52387:1;:30;52367:532;;;52439:15;52457:23;52478:1;52457:8;:17;;:20;;:23;;;;:::i;:::-;52439:41;;52518:8;:19;;:28;52538:7;52518:28;;;;;;;;;;;;52499:15;:47;52495:393;;52578:232;52617:174;52778:12;;52617:126;52717:8;:16;;:25;52734:7;52717:25;;;;;;;;;;;;52699:15;:43;;;;:::i;:::-;52617:47;52660:3;52617:4;:8;;;:42;;:47;;;;:::i;:::-;:81;;:126;;;;:::i;:::-;:160;;:174;;;;:::i;:::-;52578:8;:12;;:232;;;;:::i;:::-;52567:243;;52857:15;52829:8;:16;;:25;52846:7;52829:25;;;;;;;;;;;:43;;;;52495:393;52424:475;52419:3;;;;;:::i;:::-;;;;52367:532;;;;52928:1;52917:8;:12;52909:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;52979:11;;;;;;;;;;;52972:28;;;53001:10;53013:8;52972:50;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52207:823;;;42342:1:::0;43296:7;:22;;;;52131:899;:::o;47383:37::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;47343:33::-;;;;:::o;53498:404::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;53638:8:::1;53598:5;:17;53604:10;53598:17;;;;;;;;;;;:37;;:48;;;;53681:151;53823:8;53681:103;53780:3;53681:60;53728:12;;53681:8;:46;;:60;;;;:::i;:::-;:98;;:103;;;;:::i;:::-;:141;;:151;;;;:::i;:::-;53657:5;:17;53663:10;53657:17;;;;;;;;;;;:21;;:175;;;;53876:6;;53851:5;:17;53857:10;53851:17;;;;;;;;;;;:21;;;:31;;53843:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;53498:404:::0;;:::o;53910:138::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54031:9:::1;54002:5;:17;54008:10;54002:17;;;;;;;;;;;:26;;;:38;;;;;;;;;;;;;;;;;;53910:138:::0;;:::o;46152:201::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;46261:1:::1;46241:22;;:8;:22;;::::0;46233:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;46317:28;46336:8;46317:18;:28::i;:::-;46152:201:::0;:::o;47310:26::-;;;;;;;;;;;;;:::o;21881:98::-;21939:7;21970:1;21966;:5;;;;:::i;:::-;21959:12;;21881:98;;;;:::o;22280:::-;22338:7;22369:1;22365;:5;;;;:::i;:::-;22358:12;;22280:98;;;;:::o;10362:131::-;10429:4;10453:32;10458:3;:10;;10478:5;10470:14;;10453:4;:32::i;:::-;10446:39;;10362:131;;;;:::o;10892:146::-;10969:4;10993:37;11003:3;:10;;11023:5;11015:14;;10993:9;:37::i;:::-;10986:44;;10892:146;;;;:::o;21143:98::-;21201:7;21232:1;21228;:5;;;;:::i;:::-;21221:12;;21143:98;;;;:::o;10669:137::-;10739:4;10763:35;10771:3;:10;;10791:5;10783:14;;10763:7;:35::i;:::-;10756:42;;10669:137;;;;:::o;43990:98::-;44043:7;44070:10;44063:17;;43990:98;:::o;46513:191::-;46587:16;46606:6;;;;;;;;;;;46587:25;;46632:8;46623:6;;:17;;;;;;;;;;;;;;;;;;46687:8;46656:40;;46677:8;46656:40;;;;;;;;;;;;46576:128;46513:191;:::o;11124:114::-;11184:7;11211:19;11219:3;:10;;11211:7;:19::i;:::-;11204:26;;11124:114;;;:::o;11592:137::-;11663:7;11698:22;11702:3;:10;;11714:5;11698:3;:22::i;:::-;11690:31;;11683:38;;11592:137;;;;:::o;1759:414::-;1822:4;1844:21;1854:3;1859:5;1844:9;:21::i;:::-;1839:327;;1882:3;:11;;1899:5;1882:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2065:3;:11;;:18;;;;2043:3;:12;;:19;2056:5;2043:19;;;;;;;;;;;:40;;;;2105:4;2098:11;;;;1839:327;2149:5;2142:12;;1759:414;;;;;:::o;3855:129::-;3928:4;3975:1;3952:3;:12;;:19;3965:5;3952:19;;;;;;;;;;;;:24;;3945:31;;3855:129;;;;:::o;2349:1420::-;2415:4;2533:18;2554:3;:12;;:19;2567:5;2554:19;;;;;;;;;;;;2533:40;;2604:1;2590:10;:15;2586:1176;;2965:21;3002:1;2989:10;:14;;;;:::i;:::-;2965:38;;3018:17;3059:1;3038:3;:11;;:18;;;;:22;;;;:::i;:::-;3018:42;;3094:13;3081:9;:26;3077:405;;3128:17;3148:3;:11;;3160:9;3148:22;;;;;;;;:::i;:::-;;;;;;;;;;3128:42;;3302:9;3273:3;:11;;3285:13;3273:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;3413:10;3387:3;:12;;:23;3400:9;3387:23;;;;;;;;;;;:36;;;;3109:373;3077:405;3563:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3658:3;:12;;:19;3671:5;3658:19;;;;;;;;;;;3651:26;;;3701:4;3694:11;;;;;;;2586:1176;3745:5;3738:12;;;2349:1420;;;;;:::o;4070:109::-;4126:7;4153:3;:11;;:18;;;;4146:25;;4070:109;;;:::o;4533:120::-;4600:7;4627:3;:11;;4639:5;4627:18;;;;;;;;:::i;:::-;;;;;;;;;;4620:25;;4533:120;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:75::-;475:6;508:2;502:9;492:19;;442:75;:::o;523:117::-;632:1;629;622:12;646:117;755:1;752;745:12;769:122;842:24;860:5;842:24;:::i;:::-;835:5;832:35;822:63;;881:1;878;871:12;822:63;769:122;:::o;897:139::-;943:5;981:6;968:20;959:29;;997:33;1024:5;997:33;:::i;:::-;897:139;;;;:::o;1042:117::-;1151:1;1148;1141:12;1165:102;1206:6;1257:2;1253:7;1248:2;1241:5;1237:14;1233:28;1223:38;;1165:102;;;:::o;1273:180::-;1321:77;1318:1;1311:88;1418:4;1415:1;1408:15;1442:4;1439:1;1432:15;1459:281;1542:27;1564:4;1542:27;:::i;:::-;1534:6;1530:40;1672:6;1660:10;1657:22;1636:18;1624:10;1621:34;1618:62;1615:88;;;1683:18;;:::i;:::-;1615:88;1723:10;1719:2;1712:22;1502:238;1459:281;;:::o;1746:129::-;1780:6;1807:20;;:::i;:::-;1797:30;;1836:33;1864:4;1856:6;1836:33;:::i;:::-;1746:129;;;:::o;1881:311::-;1958:4;2048:18;2040:6;2037:30;2034:56;;;2070:18;;:::i;:::-;2034:56;2120:4;2112:6;2108:17;2100:25;;2180:4;2174;2170:15;2162:23;;1881:311;;;:::o;2198:117::-;2307:1;2304;2297:12;2338:710;2434:5;2459:81;2475:64;2532:6;2475:64;:::i;:::-;2459:81;:::i;:::-;2450:90;;2560:5;2589:6;2582:5;2575:21;2623:4;2616:5;2612:16;2605:23;;2676:4;2668:6;2664:17;2656:6;2652:30;2705:3;2697:6;2694:15;2691:122;;;2724:79;;:::i;:::-;2691:122;2839:6;2822:220;2856:6;2851:3;2848:15;2822:220;;;2931:3;2960:37;2993:3;2981:10;2960:37;:::i;:::-;2955:3;2948:50;3027:4;3022:3;3018:14;3011:21;;2898:144;2882:4;2877:3;2873:14;2866:21;;2822:220;;;2826:21;2440:608;;2338:710;;;;;:::o;3071:370::-;3142:5;3191:3;3184:4;3176:6;3172:17;3168:27;3158:122;;3199:79;;:::i;:::-;3158:122;3316:6;3303:20;3341:94;3431:3;3423:6;3416:4;3408:6;3404:17;3341:94;:::i;:::-;3332:103;;3148:293;3071:370;;;;:::o;3447:684::-;3540:6;3548;3597:2;3585:9;3576:7;3572:23;3568:32;3565:119;;;3603:79;;:::i;:::-;3565:119;3723:1;3748:53;3793:7;3784:6;3773:9;3769:22;3748:53;:::i;:::-;3738:63;;3694:117;3878:2;3867:9;3863:18;3850:32;3909:18;3901:6;3898:30;3895:117;;;3931:79;;:::i;:::-;3895:117;4036:78;4106:7;4097:6;4086:9;4082:22;4036:78;:::i;:::-;4026:88;;3821:303;3447:684;;;;;:::o;4137:126::-;4174:7;4214:42;4207:5;4203:54;4192:65;;4137:126;;;:::o;4269:96::-;4306:7;4335:24;4353:5;4335:24;:::i;:::-;4324:35;;4269:96;;;:::o;4371:118::-;4458:24;4476:5;4458:24;:::i;:::-;4453:3;4446:37;4371:118;;:::o;4495:222::-;4588:4;4626:2;4615:9;4611:18;4603:26;;4639:71;4707:1;4696:9;4692:17;4683:6;4639:71;:::i;:::-;4495:222;;;;:::o;4723:122::-;4796:24;4814:5;4796:24;:::i;:::-;4789:5;4786:35;4776:63;;4835:1;4832;4825:12;4776:63;4723:122;:::o;4851:139::-;4897:5;4935:6;4922:20;4913:29;;4951:33;4978:5;4951:33;:::i;:::-;4851:139;;;;:::o;4996:474::-;5064:6;5072;5121:2;5109:9;5100:7;5096:23;5092:32;5089:119;;;5127:79;;:::i;:::-;5089:119;5247:1;5272:53;5317:7;5308:6;5297:9;5293:22;5272:53;:::i;:::-;5262:63;;5218:117;5374:2;5400:53;5445:7;5436:6;5425:9;5421:22;5400:53;:::i;:::-;5390:63;;5345:118;4996:474;;;;;:::o;5476:332::-;5597:4;5635:2;5624:9;5620:18;5612:26;;5648:71;5716:1;5705:9;5701:17;5692:6;5648:71;:::i;:::-;5729:72;5797:2;5786:9;5782:18;5773:6;5729:72;:::i;:::-;5476:332;;;;;:::o;5814:114::-;5881:6;5915:5;5909:12;5899:22;;5814:114;;;:::o;5934:184::-;6033:11;6067:6;6062:3;6055:19;6107:4;6102:3;6098:14;6083:29;;5934:184;;;;:::o;6124:132::-;6191:4;6214:3;6206:11;;6244:4;6239:3;6235:14;6227:22;;6124:132;;;:::o;6262:108::-;6339:24;6357:5;6339:24;:::i;:::-;6334:3;6327:37;6262:108;;:::o;6376:179::-;6445:10;6466:46;6508:3;6500:6;6466:46;:::i;:::-;6544:4;6539:3;6535:14;6521:28;;6376:179;;;;:::o;6561:113::-;6631:4;6663;6658:3;6654:14;6646:22;;6561:113;;;:::o;6710:732::-;6829:3;6858:54;6906:5;6858:54;:::i;:::-;6928:86;7007:6;7002:3;6928:86;:::i;:::-;6921:93;;7038:56;7088:5;7038:56;:::i;:::-;7117:7;7148:1;7133:284;7158:6;7155:1;7152:13;7133:284;;;7234:6;7228:13;7261:63;7320:3;7305:13;7261:63;:::i;:::-;7254:70;;7347:60;7400:6;7347:60;:::i;:::-;7337:70;;7193:224;7180:1;7177;7173:9;7168:14;;7133:284;;;7137:14;7433:3;7426:10;;6834:608;;;6710:732;;;;:::o;7448:373::-;7591:4;7629:2;7618:9;7614:18;7606:26;;7678:9;7672:4;7668:20;7664:1;7653:9;7649:17;7642:47;7706:108;7809:4;7800:6;7706:108;:::i;:::-;7698:116;;7448:373;;;;:::o;7827:329::-;7886:6;7935:2;7923:9;7914:7;7910:23;7906:32;7903:119;;;7941:79;;:::i;:::-;7903:119;8061:1;8086:53;8131:7;8122:6;8111:9;8107:22;8086:53;:::i;:::-;8076:63;;8032:117;7827:329;;;;:::o;8162:90::-;8196:7;8239:5;8232:13;8225:21;8214:32;;8162:90;;;:::o;8258:109::-;8339:21;8354:5;8339:21;:::i;:::-;8334:3;8327:34;8258:109;;:::o;8373:652::-;8572:4;8610:3;8599:9;8595:19;8587:27;;8624:71;8692:1;8681:9;8677:17;8668:6;8624:71;:::i;:::-;8705:72;8773:2;8762:9;8758:18;8749:6;8705:72;:::i;:::-;8787;8855:2;8844:9;8840:18;8831:6;8787:72;:::i;:::-;8869;8937:2;8926:9;8922:18;8913:6;8869:72;:::i;:::-;8951:67;9013:3;9002:9;8998:19;8989:6;8951:67;:::i;:::-;8373:652;;;;;;;;:::o;9031:474::-;9099:6;9107;9156:2;9144:9;9135:7;9131:23;9127:32;9124:119;;;9162:79;;:::i;:::-;9124:119;9282:1;9307:53;9352:7;9343:6;9332:9;9328:22;9307:53;:::i;:::-;9297:63;;9253:117;9409:2;9435:53;9480:7;9471:6;9460:9;9456:22;9435:53;:::i;:::-;9425:63;;9380:118;9031:474;;;;;:::o;9511:116::-;9581:21;9596:5;9581:21;:::i;:::-;9574:5;9571:32;9561:60;;9617:1;9614;9607:12;9561:60;9511:116;:::o;9633:133::-;9676:5;9714:6;9701:20;9692:29;;9730:30;9754:5;9730:30;:::i;:::-;9633:133;;;;:::o;9772:468::-;9837:6;9845;9894:2;9882:9;9873:7;9869:23;9865:32;9862:119;;;9900:79;;:::i;:::-;9862:119;10020:1;10045:53;10090:7;10081:6;10070:9;10066:22;10045:53;:::i;:::-;10035:63;;9991:117;10147:2;10173:50;10215:7;10206:6;10195:9;10191:22;10173:50;:::i;:::-;10163:60;;10118:115;9772:468;;;;;:::o;10246:329::-;10305:6;10354:2;10342:9;10333:7;10329:23;10325:32;10322:119;;;10360:79;;:::i;:::-;10322:119;10480:1;10505:53;10550:7;10541:6;10530:9;10526:22;10505:53;:::i;:::-;10495:63;;10451:117;10246:329;;;;:::o;10581:169::-;10665:11;10699:6;10694:3;10687:19;10739:4;10734:3;10730:14;10715:29;;10581:169;;;;:::o;10756:181::-;10896:33;10892:1;10884:6;10880:14;10873:57;10756:181;:::o;10943:366::-;11085:3;11106:67;11170:2;11165:3;11106:67;:::i;:::-;11099:74;;11182:93;11271:3;11182:93;:::i;:::-;11300:2;11295:3;11291:12;11284:19;;10943:366;;;:::o;11315:419::-;11481:4;11519:2;11508:9;11504:18;11496:26;;11568:9;11562:4;11558:20;11554:1;11543:9;11539:17;11532:47;11596:131;11722:4;11596:131;:::i;:::-;11588:139;;11315:419;;;:::o;11740:172::-;11880:24;11876:1;11868:6;11864:14;11857:48;11740:172;:::o;11918:366::-;12060:3;12081:67;12145:2;12140:3;12081:67;:::i;:::-;12074:74;;12157:93;12246:3;12157:93;:::i;:::-;12275:2;12270:3;12266:12;12259:19;;11918:366;;;:::o;12290:419::-;12456:4;12494:2;12483:9;12479:18;12471:26;;12543:9;12537:4;12533:20;12529:1;12518:9;12514:17;12507:47;12571:131;12697:4;12571:131;:::i;:::-;12563:139;;12290:419;;;:::o;12715:220::-;12855:34;12851:1;12843:6;12839:14;12832:58;12924:3;12919:2;12911:6;12907:15;12900:28;12715:220;:::o;12941:366::-;13083:3;13104:67;13168:2;13163:3;13104:67;:::i;:::-;13097:74;;13180:93;13269:3;13180:93;:::i;:::-;13298:2;13293:3;13289:12;13282:19;;12941:366;;;:::o;13313:419::-;13479:4;13517:2;13506:9;13502:18;13494:26;;13566:9;13560:4;13556:20;13552:1;13541:9;13537:17;13530:47;13594:131;13720:4;13594:131;:::i;:::-;13586:139;;13313:419;;;:::o;13738:180::-;13786:77;13783:1;13776:88;13883:4;13880:1;13873:15;13907:4;13904:1;13897:15;13924:143;13981:5;14012:6;14006:13;13997:22;;14028:33;14055:5;14028:33;:::i;:::-;13924:143;;;;:::o;14073:351::-;14143:6;14192:2;14180:9;14171:7;14167:23;14163:32;14160:119;;;14198:79;;:::i;:::-;14160:119;14318:1;14343:64;14399:7;14390:6;14379:9;14375:22;14343:64;:::i;:::-;14333:74;;14289:128;14073:351;;;;:::o;14430:224::-;14570:34;14566:1;14558:6;14554:14;14547:58;14639:7;14634:2;14626:6;14622:15;14615:32;14430:224;:::o;14660:366::-;14802:3;14823:67;14887:2;14882:3;14823:67;:::i;:::-;14816:74;;14899:93;14988:3;14899:93;:::i;:::-;15017:2;15012:3;15008:12;15001:19;;14660:366;;;:::o;15032:419::-;15198:4;15236:2;15225:9;15221:18;15213:26;;15285:9;15279:4;15275:20;15271:1;15260:9;15256:17;15249:47;15313:131;15439:4;15313:131;:::i;:::-;15305:139;;15032:419;;;:::o;15457:180::-;15505:77;15502:1;15495:88;15602:4;15599:1;15592:15;15626:4;15623:1;15616:15;15643:191;15683:3;15702:20;15720:1;15702:20;:::i;:::-;15697:25;;15736:20;15754:1;15736:20;:::i;:::-;15731:25;;15779:1;15776;15772:9;15765:16;;15800:3;15797:1;15794:10;15791:36;;;15807:18;;:::i;:::-;15791:36;15643:191;;;;:::o;15840:442::-;15989:4;16027:2;16016:9;16012:18;16004:26;;16040:71;16108:1;16097:9;16093:17;16084:6;16040:71;:::i;:::-;16121:72;16189:2;16178:9;16174:18;16165:6;16121:72;:::i;:::-;16203;16271:2;16260:9;16256:18;16247:6;16203:72;:::i;:::-;15840:442;;;;;;:::o;16288:233::-;16327:3;16350:24;16368:5;16350:24;:::i;:::-;16341:33;;16396:66;16389:5;16386:77;16383:103;;16466:18;;:::i;:::-;16383:103;16513:1;16506:5;16502:13;16495:20;;16288:233;;;:::o;16527:223::-;16667:34;16663:1;16655:6;16651:14;16644:58;16736:6;16731:2;16723:6;16719:15;16712:31;16527:223;:::o;16756:366::-;16898:3;16919:67;16983:2;16978:3;16919:67;:::i;:::-;16912:74;;16995:93;17084:3;16995:93;:::i;:::-;17113:2;17108:3;17104:12;17097:19;;16756:366;;;:::o;17128:419::-;17294:4;17332:2;17321:9;17317:18;17309:26;;17381:9;17375:4;17371:20;17367:1;17356:9;17352:17;17345:47;17409:131;17535:4;17409:131;:::i;:::-;17401:139;;17128:419;;;:::o;17553:194::-;17593:4;17613:20;17631:1;17613:20;:::i;:::-;17608:25;;17647:20;17665:1;17647:20;:::i;:::-;17642:25;;17691:1;17688;17684:9;17676:17;;17715:1;17709:4;17706:11;17703:37;;;17720:18;;:::i;:::-;17703:37;17553:194;;;;:::o;17753:332::-;17874:4;17912:2;17901:9;17897:18;17889:26;;17925:71;17993:1;17982:9;17978:17;17969:6;17925:71;:::i;:::-;18006:72;18074:2;18063:9;18059:18;18050:6;18006:72;:::i;:::-;17753:332;;;;;:::o;18091:137::-;18145:5;18176:6;18170:13;18161:22;;18192:30;18216:5;18192:30;:::i;:::-;18091:137;;;;:::o;18234:345::-;18301:6;18350:2;18338:9;18329:7;18325:23;18321:32;18318:119;;;18356:79;;:::i;:::-;18318:119;18476:1;18501:61;18554:7;18545:6;18534:9;18530:22;18501:61;:::i;:::-;18491:71;;18447:125;18234:345;;;;:::o;18585:182::-;18725:34;18721:1;18713:6;18709:14;18702:58;18585:182;:::o;18773:366::-;18915:3;18936:67;19000:2;18995:3;18936:67;:::i;:::-;18929:74;;19012:93;19101:3;19012:93;:::i;:::-;19130:2;19125:3;19121:12;19114:19;;18773:366;;;:::o;19145:419::-;19311:4;19349:2;19338:9;19334:18;19326:26;;19398:9;19392:4;19388:20;19384:1;19373:9;19369:17;19362:47;19426:131;19552:4;19426:131;:::i;:::-;19418:139;;19145:419;;;:::o;19570:143::-;19627:5;19658:6;19652:13;19643:22;;19674:33;19701:5;19674:33;:::i;:::-;19570:143;;;;:::o;19719:351::-;19789:6;19838:2;19826:9;19817:7;19813:23;19809:32;19806:119;;;19844:79;;:::i;:::-;19806:119;19964:1;19989:64;20045:7;20036:6;20025:9;20021:22;19989:64;:::i;:::-;19979:74;;19935:128;19719:351;;;;:::o;20076:177::-;20216:29;20212:1;20204:6;20200:14;20193:53;20076:177;:::o;20259:366::-;20401:3;20422:67;20486:2;20481:3;20422:67;:::i;:::-;20415:74;;20498:93;20587:3;20498:93;:::i;:::-;20616:2;20611:3;20607:12;20600:19;;20259:366;;;:::o;20631:419::-;20797:4;20835:2;20824:9;20820:18;20812:26;;20884:9;20878:4;20874:20;20870:1;20859:9;20855:17;20848:47;20912:131;21038:4;20912:131;:::i;:::-;20904:139;;20631:419;;;:::o;21056:157::-;21196:9;21192:1;21184:6;21180:14;21173:33;21056:157;:::o;21219:365::-;21361:3;21382:66;21446:1;21441:3;21382:66;:::i;:::-;21375:73;;21457:93;21546:3;21457:93;:::i;:::-;21575:2;21570:3;21566:12;21559:19;;21219:365;;;:::o;21590:419::-;21756:4;21794:2;21783:9;21779:18;21771:26;;21843:9;21837:4;21833:20;21829:1;21818:9;21814:17;21807:47;21871:131;21997:4;21871:131;:::i;:::-;21863:139;;21590:419;;;:::o;22015:225::-;22155:34;22151:1;22143:6;22139:14;22132:58;22224:8;22219:2;22211:6;22207:15;22200:33;22015:225;:::o;22246:366::-;22388:3;22409:67;22473:2;22468:3;22409:67;:::i;:::-;22402:74;;22485:93;22574:3;22485:93;:::i;:::-;22603:2;22598:3;22594:12;22587:19;;22246:366;;;:::o;22618:419::-;22784:4;22822:2;22811:9;22807:18;22799:26;;22871:9;22865:4;22861:20;22857:1;22846:9;22842:17;22835:47;22899:131;23025:4;22899:131;:::i;:::-;22891:139;;22618:419;;;:::o;23043:410::-;23083:7;23106:20;23124:1;23106:20;:::i;:::-;23101:25;;23140:20;23158:1;23140:20;:::i;:::-;23135:25;;23195:1;23192;23188:9;23217:30;23235:11;23217:30;:::i;:::-;23206:41;;23396:1;23387:7;23383:15;23380:1;23377:22;23357:1;23350:9;23330:83;23307:139;;23426:18;;:::i;:::-;23307:139;23091:362;23043:410;;;;:::o;23459:180::-;23507:77;23504:1;23497:88;23604:4;23601:1;23594:15;23628:4;23625:1;23618:15;23645:185;23685:1;23702:20;23720:1;23702:20;:::i;:::-;23697:25;;23736:20;23754:1;23736:20;:::i;:::-;23731:25;;23775:1;23765:35;;23780:18;;:::i;:::-;23765:35;23822:1;23819;23815:9;23810:14;;23645:185;;;;:::o;23836:180::-;23884:77;23881:1;23874:88;23981:4;23978:1;23971:15;24005:4;24002:1;23995:15

ipfs://4c9c45d731245baaf3f24a6ffd7b33f47e6701e48717323672fc6d8fe10be5fa