Contract

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 BOREDPEPEVIPCLUBNFTSTAKIN ... *
•    - 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-12
*/

// 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);
    }
}
// File: contracts/BOREDPEPEVIPCLUBNFTStaking.sol

//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 BOREDPEPEVIPCLUBNFTSTAKING 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(_rewardTokenDecimal)
                       .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(rewardTokenDecimal)
                                .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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

00000000000000000000000023c13be4aab42b1a1c6bdbd7b24934d59fa75cfd0000000000000000000000009d95486e1b0e0ea8a5361e853901f731b7f8e40300000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000003a980000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x23C13Be4Aab42B1A1C6bdbd7b24934D59fa75cfD
Arg [1] : _rewardToken (address): 0x9D95486E1B0E0Ea8A5361e853901F731B7f8e403
Arg [2] : _rewardTokenDecimal (uint256): 18
Arg [3] : _rewardsPerNFTPerDay (uint256): 15000
Arg [4] : _lockDuration (uint256): 0

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000023c13be4aab42b1a1c6bdbd7b24934d59fa75cfd
Arg [1] : 0000000000000000000000009d95486e1b0e0ea8a5361e853901f731b7f8e403
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [3] : 0000000000000000000000000000000000000000000000000000000000003a98
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000

48176:6197:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48353:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49009:967;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51007:1224;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48398:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54218:146;;;:::i;:::-;;45894:103;;;:::i;:::-;;47325:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49984:1015;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;53146:452;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45243:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52239:899;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47432:37;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;47392:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53606:462;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54076:138;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46152:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47359:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48353:38;;;;:::o;49009:967::-;42386:1;42984:7;;:19;42976:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;42386:1;43117:7;:18;;;;49134:9:::1;;49121:10;:22;49113:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;49183:17;49203:5;:17;49209:10;49203:17;;;;;;;;;;;49183:37;;49240:4;:13;;;;;;;;;;;;49239:14;49231:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;49312:24;49339:6;:18;49346:10;49339:18;;;;;;;;;;;:30;49358:10;49339:30;;;;;;;;;;;;;;;49312:57;;49387:9;49382:587;49406:8;:15;49402:1;:19;49382:587;;;49497:10;49451:56;;49459:12;;;;;;;;;;;49451:29;;;49481:8;49490:1;49481:11;;;;;;;;:::i;:::-;;;;;;;;49451:42;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:56;;;49443:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;49564:34;49586:8;49595:1;49586:11;;;;;;;;:::i;:::-;;;;;;;;49564:8;:17;;:21;;:34;;;;:::i;:::-;;49645:15;49613:8;:16;;:29;49630:8;49639:1;49630:11;;;;;;;;:::i;:::-;;;;;;;;49613:29;;;;;;;;;;;:47;;;;49728:4;:18;;;49710:15;:36;;;;:::i;:::-;49675:8;:19;;:32;49695:8;49704:1;49695:11;;;;;;;;:::i;:::-;;;;;;;;49675:32;;;;;;;;;;;:71;;;;49833:12;;;;;;;;;;;49825:34;;;49860:10;49880:4;49887:8;49896:1;49887:11;;;;;;;;:::i;:::-;;;;;;;;49825:74;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49956:1;49935:4;:18;;;:22;;;;:::i;:::-;49914:4;:18;;:43;;;;49423:3;;;;;:::i;:::-;;;;49382:587;;;;49100:876;;42342:1:::0;43296:7;:22;;;;49009:967;;:::o;51007:1224::-;42386:1;42984:7;;:19;42976:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;42386:1;43117:7;:18;;;;51121:17:::1;51141:5;:17;51147:10;51141:17;;;;;;;;;;;51121:37;;51169:24;51196:6;:18;51203:10;51196:18;;;;;;;;;;;:30;51215:10;51196:30;;;;;;;;;;;;;;;51169:57;;51237:16;51275:9:::0;51270:840:::1;51294:8;:15;51290:1;:19;51270:840;;;51339:39;51366:8;51375:1;51366:11;;;;;;;;:::i;:::-;;;;;;;;51339:8;:17;;:26;;:39;;;;:::i;:::-;51331:88;;;;;;;;;;;;:::i;:::-;;;;;;;;;51471:8;:19;;:32;51491:8;51500:1;51491:11;;;;;;;;:::i;:::-;;;;;;;;51471:32;;;;;;;;;;;;51452:15;:51;51448:339;;51535:236;51574:178;51739:12;;51574:130;51674:8;:16;;:29;51691:8;51700:1;51691:11;;;;;;;;:::i;:::-;;;;;;;;51674:29;;;;;;;;;;;;51656:15;:47;;;;:::i;:::-;51574;51617:3;51574:4;:8;;;:42;;:47;;;;:::i;:::-;:81;;:130;;;;:::i;:::-;:164;;:178;;;;:::i;:::-;51535:8;:12;;:236;;;;:::i;:::-;51524:247;;51448:339;51803:37;51828:8;51837:1;51828:11;;;;;;;;:::i;:::-;;;;;;;;51803:8;:17;;:24;;:37;;;;:::i;:::-;;51862:8;:16;;:29;51879:8;51888:1;51879:11;;;;;;;;:::i;:::-;;;;;;;;51862:29;;;;;;;;;;;51855:36;;;51913:8;:19;;:32;51933:8;51942:1;51933:11;;;;;;;;:::i;:::-;;;;;;;;51913:32;;;;;;;;;;;51906:39;;;51970:12;;;;;;;;;;;51962:38;;;52009:4;52016:10;52028:8;52037:1;52028:11;;;;;;;;:::i;:::-;;;;;;;;51962:78;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;52097:1;52076:4;:18;;;:22;;;;:::i;:::-;52055:4;:18;;:43;;;;51311:3;;;;;:::i;:::-;;;;51270:840;;;;52144:1;52133:8;:12;52130:94;;;52169:11;;;;;;;;;;;52162:28;;;52191:10;52203:8;52162:50;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52130:94;51100:1131;;;42342:1:::0;43296:7;:22;;;;51007:1224;;:::o;48398:28::-;;;;:::o;54218:146::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54277:11:::1;;;;;;;;;;;54270:28;;;54299:10;54318:11;;;;;;;;;;;54311:29;;;54349:4;54311:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54270:86;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;54218: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;47325:27::-;;;;;;;;;;;;;:::o;49984:1015::-;50078:7;50087;50107:17;50139:15;50169:17;50189:5;:17;50195:10;50189:17;;;;;;;;;;;50169:37;;50217:24;50244:6;:18;50251:10;50244:18;;;;;;;;;;;:28;50263:8;50244:28;;;;;;;;;;;;;;;50217:55;;50298:9;50293:659;50317:26;:8;:17;;:24;:26::i;:::-;50313:1;:30;50293:659;;;50365:15;50383:23;50404:1;50383:8;:17;;:20;;:23;;;;:::i;:::-;50365:41;;50444:8;:19;;:28;50464:7;50444:28;;;;;;;;;;;;50425:15;:47;50421:299;;50503:217;50539:162;50688:12;;50539:118;50631:8;:16;;:25;50648:7;50631:25;;;;;;;;;;;;50613:15;:43;;;;:::i;:::-;50539;50578:3;50539:4;:8;;;:38;;:43;;;;:::i;:::-;:73;;:118;;;;:::i;:::-;:148;;:162;;;;:::i;:::-;50503:9;:13;;:217;;;;:::i;:::-;50491:229;;50421:299;50745:195;50775:150;50912:12;;50775:110;50859:8;:16;;:25;50876:7;50859:25;;;;;;;;;;;;50841:15;:43;;;;:::i;:::-;50775:39;50810:3;50775:4;:8;;;:34;;:39;;;;:::i;:::-;:65;;:110;;;;:::i;:::-;:136;;:150;;;;:::i;:::-;50745:7;:11;;:195;;;;:::i;:::-;50735:205;;50350:602;50345:3;;;;;:::i;:::-;;;;50293:659;;;;50972:7;50981:9;50964:27;;;;;;;;49984:1015;;;;;:::o;53146:452::-;53239:16;53268:24;53295:6;:18;53302:10;53295:18;;;;;;;;;;;:28;53314:8;53295:28;;;;;;;;;;;;;;;53268:55;;53334:31;53382:26;:8;:17;;:24;:26::i;:::-;53368:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53334:75;;53435:9;53430:127;53454:26;:8;:17;;:24;:26::i;:::-;53450:1;:30;53430:127;;;53522:23;53543:1;53522:8;:17;;:20;;:23;;;;:::i;:::-;53502:14;53517:1;53502:17;;;;;;;;:::i;:::-;;;;;;;:43;;;;;53482:3;;;;;:::i;:::-;;;;53430:127;;;;53576:14;53569:21;;;;53146:452;;;;:::o;45243:87::-;45289:7;45316:6;;;;;;;;;;;45309:13;;45243:87;:::o;52239:899::-;42386:1;42984:7;;:19;42976:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;42386:1;43117:7;:18;;;;52326:16:::1;52357:17:::0;52377:5:::1;:17;52383:10;52377:17;;;;;;;;;;;52357:37;;52405:24;52432:6;:18;52439:10;52432:18;;;;;;;;;;;:30;52451:10;52432:30;;;;;;;;;;;;;;;52405:57;;52480:9;52475:532;52499:26;:8;:17;;:24;:26::i;:::-;52495:1;:30;52475:532;;;52547:15;52565:23;52586:1;52565:8;:17;;:20;;:23;;;;:::i;:::-;52547:41;;52626:8;:19;;:28;52646:7;52626:28;;;;;;;;;;;;52607:15;:47;52603:393;;52686:232;52725:174;52886:12;;52725:126;52825:8;:16;;:25;52842:7;52825:25;;;;;;;;;;;;52807:15;:43;;;;:::i;:::-;52725:47;52768:3;52725:4;:8;;;:42;;:47;;;;:::i;:::-;:81;;:126;;;;:::i;:::-;:160;;:174;;;;:::i;:::-;52686:8;:12;;:232;;;;:::i;:::-;52675:243;;52965:15;52937:8;:16;;:25;52954:7;52937:25;;;;;;;;;;;:43;;;;52603:393;52532:475;52527:3;;;;;:::i;:::-;;;;52475:532;;;;53036:1;53025:8;:12;53017:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;53087:11;;;;;;;;;;;53080:28;;;53109:10;53121:8;53080:50;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52315:823;;;42342:1:::0;43296:7;:22;;;;52239:899;:::o;47432:37::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;47392:33::-;;;;:::o;53606:462::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;53746:8:::1;53706:5;:17;53712:10;53706:17;;;;;;;;;;;:37;;:48;;;;53789:209;53989:8;53789:161;53946:3;53789:118;53894:12;;53789:66;53836:18;;53789:8;:46;;:66;;;;:::i;:::-;:104;;:118;;;;:::i;:::-;:156;;:161;;;;:::i;:::-;:199;;:209;;;;:::i;:::-;53765:5;:17;53771:10;53765:17;;;;;;;;;;;:21;;:233;;;;54042:6;;54017:5;:17;54023:10;54017:17;;;;;;;;;;;:21;;;:31;;54009:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;53606:462:::0;;:::o;54076:138::-;45474:12;:10;:12::i;:::-;45463:23;;:7;:5;:7::i;:::-;:23;;;45455:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54197:9:::1;54168:5;:17;54174:10;54168:17;;;;;;;;;;;:26;;;:38;;;;;;;;;;;;;;;;;;54076: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;47359: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://f022f4f158441651b6333e98879e0d232e8bb0ee5ff31f8c7fb66331f01bb3ad