Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
• 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(
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Receiver
•    - function onERC721Received(
• 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)
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function paused()
•    - function _pause()
•    - function _unpause()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
• library MerkleProof
•    - function verify(
•    - function processProof(bytes32[] memor ...
•    - function _efficientHash(bytes32 a, by ...
•  contract LostStaking is Ownable, I ... *
•    - function pause()
•    - function unpause()
•    - function updateMarkelTree(bytes32 _me ...
•    - function updateReward(uint256[] memor ...
•    - function updateRarity(uint256[] memor ...
•    - function setExpiration(uint256 _expir ...
•    - function balanceOfLostGirl(address ac ...
•    - function depositsOf(address account)
•    - function calculateRewards(address acc ...
•    - function calculateReward(address acco ...
•    - function claimRewards(uint256[] calld ...
•    - function deposit(markelData[] memory ...
•    - function withdraw(uint256[] calldata ...
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-07-21
*/

// SPDX-License-Identifier: MIT

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;
    }
}


/**
 * @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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


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 no longer needed starting with Solidity 0.8. 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 substraction 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;
        }
    }
}


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);
}


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


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

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

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


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


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


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


/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

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

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

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


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


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

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

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

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

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

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

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

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

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

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

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

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

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


/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

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

contract LostStaking is Ownable, IERC721Receiver, ReentrancyGuard, Pausable {
    using EnumerableSet for EnumerableSet.UintSet; 
    
    //addresses 
    address public stakingDestinationAddress;
    address public stakingLostGirlAddr;
    address public erc20Address;
    address public ownerAddr;

    bytes32 private merkleRoot1;
    bytes32 private merkleRoot2;
    bytes32 private merkleRoot3;
    bytes32 private merkleRoot4;

    //uint256's 
    uint256 public expiration;
  
    // mappings 
    mapping(address => EnumerableSet.UintSet) _deposits;
    mapping(address => mapping(uint256 => uint256)) _depositBlocks;
    mapping(address => mapping(uint256 => uint256)) _depositRarity;
    mapping(uint256 => uint256) _rewardArray;
    mapping(uint256 => uint256) _rewardRarity;

    struct markelData{
        bytes32[] merkleProof;
        uint256 _indexNum;
    }

    constructor(
      address _stakingDestinationAddress, // NFT Contract Address
      address _stakingLostGirlAddress, //NFT Contract lostgirl
      uint256 _expiration,  //in days
      address _erc20Address, // Token address
      uint256[] memory rewardArray,
      uint256[] memory rewardRarity
    ) {
        stakingLostGirlAddr = _stakingLostGirlAddress;
        stakingDestinationAddress = _stakingDestinationAddress;
        expiration = block.timestamp + (_expiration * 1 days);
        erc20Address = _erc20Address;
        ownerAddr = msg.sender;
        
        for (uint256 i; i < rewardArray.length; i++) {
            _rewardArray[i] = rewardArray[i];
        }

        for (uint256 i; i < rewardRarity.length; i++) {
            _rewardRarity[i] = rewardRarity[i];
        }
        
        _pause();
    }
    

    modifier isExpired() {
        require(0 < ((expiration - block.timestamp) / 60 ), "Close Staking");
        _;
    }

    function pause() external onlyOwner {
        _pause();
    }

    function unpause() external onlyOwner {
        _unpause();
    }

    function updateMarkelTree(bytes32 _merkleRoot1, bytes32 _merkleRoot2, bytes32 _merkleRoot3, bytes32 _merkleRoot4) external onlyOwner(){
        merkleRoot1 = _merkleRoot1;
        merkleRoot2 = _merkleRoot2;
        merkleRoot3 = _merkleRoot3;
        merkleRoot4 = _merkleRoot4;
    }

    /* STAKING MECHANICS */

    // Set a multiplier for how many to0x3E6DEab9Cb952b29FcDCC2f4F88bE8E1858B50Bckens to earn each time a block passes.
    function updateReward(uint256[] memory _updateReward) external onlyOwner() {
        for (uint256 i; i < _updateReward.length; i++) {
            _rewardArray[i] = _updateReward[i];
        }
    }

    // Set a multiplier for how many tokens to earn each time a block passes.
    function updateRarity(uint256[] memory _updateRarity) external onlyOwner() {
        for (uint256 i; i < _updateRarity.length; i++) {
            _rewardRarity[i] = _updateRarity[i];
        }
    }

    // Set this to a block to disable the ability to continue accruing tokens past that block number.
    function setExpiration(uint256 _expiration) external onlyOwner() {
        expiration = expiration + (_expiration * 1 days);
    }

    //check Lostboy Balance. 
    function balanceOfLostGirl(address account, uint256 tokens) external view returns (uint256 balance) {
        uint256 balanceOfd = IERC721(stakingLostGirlAddr).balanceOf(account);
        
        if(balanceOfd > 0 && balanceOfd <= 3){
            return (tokens*_rewardArray[0]);
        }else if(balanceOfd >= 4 && balanceOfd <= 6){
            return (tokens*_rewardArray[1]);
        }else if(balanceOfd >= 7 && balanceOfd <= 9){
            return (tokens*_rewardArray[2]);
        }else if(balanceOfd >= 10 && balanceOfd <= 15){
            return (tokens*_rewardArray[3]);
        }else if(balanceOfd > 15){
            return (tokens*_rewardArray[4]);
        }
        return (tokens*100);
    }

    //check deposit amount. 
    function depositsOf(address account) external view returns (uint256[] memory) {
      EnumerableSet.UintSet storage depositSet = _deposits[account];
      uint256[] memory tokenIds = new uint256[] (depositSet.length());

      for (uint256 i; i < depositSet.length(); i++) {
        tokenIds[i] = depositSet.at(i);
      }
      return tokenIds;
    }

    function calculateRewards(address account, uint256[] memory tokenIds) external view returns (uint256[] memory rewards) 
    {
      rewards = new uint256[](tokenIds.length);

      for (uint256 i; i < tokenIds.length; i++) {

            uint256 tokenId = tokenIds[i];
        
            if(_deposits[account].contains(tokenId)){
                uint256 diff = (block.timestamp - _depositBlocks[account][tokenId]) / 60 / 60 / 24;
                uint256 tokenCount = _rewardRarity[_depositRarity[account][tokenId]] * diff;
                rewards[i] = this.balanceOfLostGirl(account, tokenCount);
            }else{
                rewards[i] = 0;
            }
      }

      return rewards;
    }

    //reward amount by address/tokenIds[]
    function calculateReward(address account, uint256 tokenId) public view isExpired returns (uint256) {
        uint256 diff = (block.timestamp - _depositBlocks[account][tokenId]) / 60 / 60 / 24;
        uint256 totalToken = (_rewardRarity[_depositRarity[account][tokenId]] * ((_deposits[account].contains(tokenId) ? 1 : 0) * diff));
        return this.balanceOfLostGirl(account, totalToken);
    }

    //reward claim function 
    function claimRewards(uint256[] calldata tokenIds) public whenNotPaused {
        uint256 reward; 
        uint256 blockCur = block.timestamp;

        for (uint256 i; i < tokenIds.length; i++) {
            reward += calculateReward(msg.sender, tokenIds[i]);

            _depositBlocks[msg.sender][tokenIds[i]] = blockCur;
        }
        
        if (reward > 0) {
            IERC20(erc20Address).transferFrom(ownerAddr, msg.sender, (((reward * 10**18)/100)/100));
        } 
    } 

    function deposit(markelData[] memory _markelData) public {
        
        for (uint256 i; i < _markelData.length; i++) {

            string memory indexNum = Strings.toString(_markelData[i]._indexNum);

            bool matchSuccess = false;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
            uint256 _rarityValue = 0; 

            if(MerkleProof.verify(_markelData[i].merkleProof, merkleRoot1, keccak256(abi.encodePacked(indexNum)))){
                _rarityValue = 0;
            }else if(MerkleProof.verify(_markelData[i].merkleProof, merkleRoot2, keccak256(abi.encodePacked(indexNum)))){
                _rarityValue = 1;
            }else if(MerkleProof.verify(_markelData[i].merkleProof, merkleRoot3, keccak256(abi.encodePacked(indexNum)))){
                _rarityValue = 2;
            }else if(MerkleProof.verify(_markelData[i].merkleProof, merkleRoot4, keccak256(abi.encodePacked(indexNum)))){
                _rarityValue = 3;
            }else{
                require(matchSuccess, "Invalid merkel data");
            }

            uint256 blockCur1 = block.timestamp;
            _depositBlocks[msg.sender][_markelData[i]._indexNum] = blockCur1;
            _depositRarity[msg.sender][_markelData[i]._indexNum] = _rarityValue;
            
            IERC721(stakingDestinationAddress).safeTransferFrom(
                msg.sender,
                address(this),
                _markelData[i]._indexNum,
                ""
            );

            _deposits[msg.sender].add(_markelData[i]._indexNum);

        }
    }

    //withdrawal function.
    function withdraw(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        claimRewards(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            require( _deposits[msg.sender].contains(tokenIds[i]), "Staking: token not deposited");
        
            _deposits[msg.sender].remove(tokenIds[i]);

            IERC721(stakingDestinationAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                ""
            );
        }
    }
 
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stakingDestinationAddress","type":"address"},{"internalType":"address","name":"_stakingLostGirlAddress","type":"address"},{"internalType":"uint256","name":"_expiration","type":"uint256"},{"internalType":"address","name":"_erc20Address","type":"address"},{"internalType":"uint256[]","name":"rewardArray","type":"uint256[]"},{"internalType":"uint256[]","name":"rewardRarity","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"balanceOfLostGirl","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"calculateReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"calculateRewards","outputs":[{"internalType":"uint256[]","name":"rewards","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"},{"internalType":"uint256","name":"_indexNum","type":"uint256"}],"internalType":"struct LostStaking.markelData[]","name":"_markelData","type":"tuple[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"depositsOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setExpiration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingDestinationAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingLostGirlAddr","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":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot1","type":"bytes32"},{"internalType":"bytes32","name":"_merkleRoot2","type":"bytes32"},{"internalType":"bytes32","name":"_merkleRoot3","type":"bytes32"},{"internalType":"bytes32","name":"_merkleRoot4","type":"bytes32"}],"name":"updateMarkelTree","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_updateRarity","type":"uint256[]"}],"name":"updateRarity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_updateReward","type":"uint256[]"}],"name":"updateReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000c1a1e381389cb927f1d57511e144b644ef0c638500000000000000000000000043a16061986d2bcee1fc5e7ed132d5058eb25d6800000000000000000000000000000000000000000000000000000000000004ff000000000000000000000000d95897e53ba7fa442aac0d94414adeacddd5bd9800000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000730000000000000000000000000000000000000000000000000000000000000087000000000000000000000000000000000000000000000000000000000000009600000000000000000000000000000000000000000000000000000000000000af00000000000000000000000000000000000000000000000000000000000000c800000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000fa00000000000000000000000000000000000000000000000000000000000000abe00000000000000000000000000000000000000000000000000000000000005dc00000000000000000000000000000000000000000000000000000000000003e8

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0xc1a1E381389cb927f1d57511E144B644Ef0c6385
Arg [1] : _stakingLostGirlAddress (address): 0x43a16061986d2BCEe1FC5E7Ed132d5058EB25D68
Arg [2] : _expiration (uint256): 1279
Arg [3] : _erc20Address (address): 0xd95897e53Ba7Fa442aaC0D94414ADEacDDD5BD98
Arg [4] : rewardArray (uint256[]): 115,135,150,175,200
Arg [5] : rewardRarity (uint256[]): 4000,2750,1500,1000

-----Encoded View---------------
17 Constructor Arguments found :
Arg [0] : 000000000000000000000000c1a1e381389cb927f1d57511e144b644ef0c6385
Arg [1] : 00000000000000000000000043a16061986d2bcee1fc5e7ed132d5058eb25d68
Arg [2] : 00000000000000000000000000000000000000000000000000000000000004ff
Arg [3] : 000000000000000000000000d95897e53ba7fa442aac0d94414adeacddd5bd98
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000073
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000087
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000096
Arg [10] : 00000000000000000000000000000000000000000000000000000000000000af
Arg [11] : 00000000000000000000000000000000000000000000000000000000000000c8
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000fa0
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000abe
Arg [15] : 00000000000000000000000000000000000000000000000000000000000005dc
Arg [16] : 00000000000000000000000000000000000000000000000000000000000003e8

42688:10304:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42848:40;;;;;;;;-1:-1:-1;;;;;42848:40:0;;;;;;-1:-1:-1;;;;;7222:32:1;;;7204:51;;7192:2;7177:18;42848:40:0;;;;;;;;47081:718;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;52770:219::-;;;;;;:::i;:::-;-1:-1:-1;;;52770:219:0;;;;;;;;;;;-1:-1:-1;;;;;;9476:33:1;;;9458:52;;9446:2;9431:18;52770:219:0;9314:202:1;47850:400:0;;;;;;:::i;:::-;;:::i;:::-;;;12536:25:1;;;12524:2;12509:18;47850:400:0;12390:177:1;42936:27:0;;;;;-1:-1:-1;;;;;42936:27:0;;;45957:719;;;;;;:::i;:::-;;:::i;44660:67::-;;;:::i;:::-;;43159:25;;;;;;45185:201;;;;;;:::i;:::-;;:::i;45786:132::-;;;;;;:::i;:::-;;:::i;34269:86::-;34340:7;;;;34269:86;;9287:14:1;;9280:22;9262:41;;9250:2;9235:18;34269:86:0;9122:187:1;48288:500:0;;;;;;:::i;:::-;;:::i;2379:94::-;;;:::i;44589:63::-;;;:::i;42895:34::-;;;;;-1:-1:-1;;;;;42895:34:0;;;45473:202;;;;;;:::i;:::-;;:::i;1728:87::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;1728:87;;52208:553;;;;;;:::i;:::-;;:::i;42970:24::-;;;;;-1:-1:-1;;;;;42970:24:0;;;48797:3375;;;;;;:::i;:::-;;:::i;46714:359::-;;;;;;:::i;:::-;;:::i;44735:290::-;;;;;;:::i;:::-;;:::i;2628:192::-;;;;;;:::i;:::-;;:::i;47081:718::-;47174:24;47239:8;:15;47225:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47225:30:0;;47215:40;;47271:9;47266:501;47286:8;:15;47282:1;:19;47266:501;;;47325:15;47343:8;47352:1;47343:11;;;;;;;;:::i;:::-;;;;;;;47325:29;;47382:36;47410:7;47382:9;:18;47392:7;-1:-1:-1;;;;;47382:18:0;-1:-1:-1;;;;;47382:18:0;;;;;;;;;;;;:27;;:36;;;;:::i;:::-;47379:379;;;-1:-1:-1;;;;;47472:23:0;;47438:12;47472:23;;;:14;:23;;;;;;;;:32;;;;;;;;;47518:2;;47513;;;;47454:50;;:15;:50;:::i;:::-;47453:57;;;;:::i;:::-;:62;;;;:::i;:::-;:67;;;;:::i;:::-;-1:-1:-1;;;;;47574:23:0;;47539:18;47574:23;;;:14;:23;;;;;;;;:32;;;;;;;;;47560:47;;:13;:47;;;;;;47438:82;;-1:-1:-1;47539:18:0;47560:54;;47438:82;;47560:54;:::i;:::-;47646:43;;-1:-1:-1;;;47646:43:0;;-1:-1:-1;;;;;8398:32:1;;47646:43:0;;;8380:51:1;8447:18;;;8440:34;;;47539:75:0;;-1:-1:-1;47646:4:0;;:22;;8353:18:1;;47646:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47633:7;47641:1;47633:10;;;;;;;;:::i;:::-;;;;;;:56;;;;;47419:286;;47379:379;;;47741:1;47728:7;47736:1;47728:10;;;;;;;;:::i;:::-;;;;;;:14;;;;;47379:379;-1:-1:-1;47303:3:0;;;;:::i;:::-;;;;47266:501;;;;47081:718;;;;;:::o;47850:400::-;47940:7;44539:2;44520:15;44507:10;;:28;;;;:::i;:::-;44506:35;;;;:::i;:::-;44501:1;:42;44493:68;;;;-1:-1:-1;;;44493:68:0;;11185:2:1;44493:68:0;;;11167:21:1;11224:2;11204:18;;;11197:30;-1:-1:-1;;;11243:18:1;;;11236:43;11296:18;;44493:68:0;;;;;;;;;-1:-1:-1;;;;;47994:23:0;::::1;47960:12;47994:23:::0;;;:14:::1;:23;::::0;;;;;;;:32;;;;;;;;;48040:2:::1;::::0;48035::::1;::::0;;;47976:50:::1;::::0;:15:::1;:50;:::i;:::-;47975:57;;;;:::i;:::-;:62;;;;:::i;:::-;:67;;;;:::i;:::-;-1:-1:-1::0;;;;;48127:18:0;::::1;48053;48127::::0;;;:9:::1;:18;::::0;;;;47960:82;;-1:-1:-1;48053:18:0;47960:82;;48127:36:::1;::::0;48155:7;48127:27:::1;:36::i;:::-;:44;;48170:1;48127:44;;;48166:1;48127:44;48126:53;;;;;;:::i;:::-;-1:-1:-1::0;;;;;48089:23:0;::::1;48075:47;48089:23:::0;;;:14:::1;:23;::::0;;;;;;;:32;;;;;;;;;48075:47;;:13:::1;:47:::0;;;;;;:105:::1;::::0;;::::1;:::i;:::-;48199:43;::::0;-1:-1:-1;;;48199:43:0;;-1:-1:-1;;;;;8398:32:1;;48199:43:0::1;::::0;::::1;8380:51:1::0;8447:18;;;8440:34;;;48053:128:0;;-1:-1:-1;48199:4:0::1;::::0;:22:::1;::::0;8353:18:1;;48199:43:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48192:50:::0;47850:400;-1:-1:-1;;;;;47850:400:0:o;45957:719::-;46097:19;;46089:47;;-1:-1:-1;;;46089:47:0;;-1:-1:-1;;;;;7222:32:1;;;46089:47:0;;;7204:51:1;46040:15:0;;;;46097:19;;;46089:38;;7177:18:1;;46089:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46068:68;;46173:1;46160:10;:14;:33;;;;;46192:1;46178:10;:15;;46160:33;46157:482;;;46224:15;;;:12;:15;;;;46217:22;;:6;:22;:::i;:::-;46209:31;;;;;46157:482;46274:1;46260:10;:15;;:34;;;;;46293:1;46279:10;:15;;46260:34;46257:382;;;46338:1;46325:15;;:12;:15;;;;46318:22;;:6;:22;:::i;46257:382::-;46375:1;46361:10;:15;;:34;;;;;46394:1;46380:10;:15;;46361:34;46358:281;;;46439:1;46426:15;;:12;:15;;;;46419:22;;:6;:22;:::i;46358:281::-;46476:2;46462:10;:16;;:36;;;;;46496:2;46482:10;:16;;46462:36;46459:180;;;46542:1;46529:15;;:12;:15;;;;46522:22;;:6;:22;:::i;46459:180::-;46578:2;46565:10;:15;46562:77;;;46624:1;46611:15;;:12;:15;;;;46604:22;;:6;:22;:::i;46562:77::-;46657:10;:6;46664:3;46657:10;:::i;:::-;46649:19;45957:719;-1:-1:-1;;;;45957:719:0:o;44660:67::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;44709:10:::1;:8;:10::i;:::-;44660:67::o:0;45185:201::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;45276:9:::1;45271:108;45291:13;:20;45287:1;:24;45271:108;;;45351:13;45365:1;45351:16;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;45333:15:::1;::::0;;;:12:::1;:15:::0;;;;;;;:34;45346:1;45313:3:::1;45346:1:::0;45313:3:::1;:::i;:::-;;;;45271:108;;;;45185:201:::0;:::o;45786:132::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;45889:20:::1;:11:::0;45903:6:::1;45889:20;:::i;:::-;45875:10;;:35;;;;:::i;:::-;45862:10;:48:::0;-1:-1:-1;45786:132:0:o;48288:500::-;34340:7;;;;34594:9;34586:38;;;;-1:-1:-1;;;34586:38:0;;;;;;;:::i;:::-;48371:14:::1;48416:15;48371:14:::0;48444:186:::1;48460:19:::0;;::::1;48444:186;;;48511:40;48527:10;48539:8;;48548:1;48539:11;;;;;;;:::i;:::-;;;;;;;48511:15;:40::i;:::-;48501:50;::::0;;::::1;:::i;:::-;48583:10;48568:26;::::0;;;:14:::1;:26;::::0;;;;48501:50;;-1:-1:-1;48610:8:0;;48568:26;48595:8;;48604:1;48595:11;;::::1;;;;;:::i;:::-;;;;;;;48568:39;;;;;;;;;;;:50;;;;48481:3;;;;;:::i;:::-;;;;48444:186;;;-1:-1:-1::0;48654:10:0;;48650:130:::1;;48688:12;::::0;48715:9:::1;::::0;-1:-1:-1;;;;;48688:12:0;;::::1;::::0;48681:33:::1;::::0;48715:9:::1;48726:10;48763:3;::::0;48741:15:::1;:6:::0;48750::::1;48741:15;:::i;:::-;48740:21;;;;:::i;:::-;48739:27;;;;:::i;:::-;48681:87;::::0;-1:-1:-1;;;;;;48681:87:0::1;::::0;;;;;;-1:-1:-1;;;;;7524:15:1;;;48681:87:0::1;::::0;::::1;7506:34:1::0;7576:15;;;;7556:18;;;7549:43;7608:18;;;7601:34;7441:18;;48681:87:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48650:130;48360:428;;48288:500:::0;;:::o;2379:94::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;2444:21:::1;2462:1;2444:9;:21::i;44589:63::-:0;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;44636:8:::1;:6;:8::i;45473:202::-:0;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;45564:9:::1;45559:109;45579:13;:20;45575:1;:24;45559:109;;;45640:13;45654:1;45640:16;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;45621::::1;::::0;;;:13:::1;:16:::0;;;;;;;:35;45635:1;45601:3:::1;45635:1:::0;45601:3:::1;:::i;:::-;;;;45559:109;;52208:553:::0;34340:7;;;;34594:9;34586:38;;;;-1:-1:-1;;;34586:38:0;;;;;;;:::i;:::-;31198:1:::1;31794:7;;:19;;31786:63;;;::::0;-1:-1:-1;;;31786:63:0;;11884:2:1;31786:63:0::1;::::0;::::1;11866:21:1::0;11923:2;11903:18;;;11896:30;11962:33;11942:18;;;11935:61;12013:18;;31786:63:0::1;11682:355:1::0;31786:63:0::1;31198:1;31927:7;:18:::0;52304:22:::2;52317:8:::0;;52304:12:::2;:22::i;:::-;52344:9;52339:415;52355:19:::0;;::::2;52339:415;;;52405:43;52436:8;;52445:1;52436:11;;;;;;;:::i;:::-;52415:10;52405:21;::::0;;;:9:::2;52436:11;52405:21:::0;;;;;;;;52436:11;::::2;;;::::0;-1:-1:-1;52405:30:0::2;:43::i;:::-;52396:85;;;::::0;-1:-1:-1;;;52396:85:0;;11527:2:1;52396:85:0::2;::::0;::::2;11509:21:1::0;11566:2;11546:18;;;11539:30;11605;11585:18;;;11578:58;11653:18;;52396:85:0::2;11325:352:1::0;52396:85:0::2;52506:41;52535:8;;52544:1;52535:11;;;;;;;:::i;:::-;52516:10;52506:21;::::0;;;:9:::2;52535:11;52506:21:::0;;;;;;;;52535:11;::::2;;;::::0;-1:-1:-1;52506:28:0::2;:41::i;:::-;-1:-1:-1::0;52572:25:0::2;::::0;::::2;::::0;::::2;-1:-1:-1::0;;;;;52572:25:0::2;52564:51;52642:4;52666:10;52695:8:::0;;52704:1;52695:11;;::::2;;;;;:::i;:::-;52564:178;::::0;-1:-1:-1;;;;;;52564:178:0::2;::::0;;;;;;-1:-1:-1;;;;;7969:15:1;;;52564:178:0::2;::::0;::::2;7951:34:1::0;8021:15;;;;8001:18;;;7994:43;-1:-1:-1;52695:11:0::2;::::0;;::::2;;;8053:18:1::0;;;8046:34;8116:3;8096:18;;;8089:31;-1:-1:-1;8136:19:1;;;8129:30;8176:19;;52564:178:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;52376:3;;;;;:::i;:::-;;;;52339:415;;;-1:-1:-1::0;;31154:1:0::1;32106:22:::0;;-1:-1:-1;52208:553:0:o;48797:3375::-;48880:9;48875:3290;48895:11;:18;48891:1;:22;48875:3290;;;48937:22;48962:42;48979:11;48991:1;48979:14;;;;;;;;:::i;:::-;;;;;;;:24;;;48962:16;:42::i;:::-;48937:67;;49021:17;50899:20;50944:98;50963:11;50975:1;50963:14;;;;;;;;:::i;:::-;;;;;;;:26;;;50991:11;;51031:8;51014:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;51004:37;;;;;;50944:18;:98::i;:::-;50941:710;;;-1:-1:-1;51077:1:0;50941:710;;;51102:98;51121:11;51133:1;51121:14;;;;;;;;:::i;:::-;;;;;;;:26;;;51149:11;;51189:8;51172:26;;;;;;;;:::i;51102:98::-;51099:552;;;-1:-1:-1;51235:1:0;51099:552;;;51260:98;51279:11;51291:1;51279:14;;;;;;;;:::i;:::-;;;;;;;:26;;;51307:11;;51347:8;51330:26;;;;;;;;:::i;51260:98::-;51257:394;;;-1:-1:-1;51393:1:0;51257:394;;;51418:98;51437:11;51449:1;51437:14;;;;;;;;:::i;:::-;;;;;;;:26;;;51465:11;;51505:8;51488:26;;;;;;;;:::i;51418:98::-;51415:236;;;-1:-1:-1;51551:1:0;51415:236;;;51599:12;51591:44;;;;-1:-1:-1;;;51591:44:0;;12244:2:1;51591:44:0;;;12226:21:1;12283:2;12263:18;;;12256:30;-1:-1:-1;;;12302:18:1;;;12295:49;12361:18;;51591:44:0;12042:343:1;51591:44:0;51732:10;51667:17;51717:26;;;:14;:26;;;;;51744:14;;51687:15;;;;51717:26;51744:11;;51756:1;;51744:14;;;;;;:::i;:::-;;;;;;;:24;;;51717:52;;;;;;;;;;;:64;;;;51851:12;51796:14;:26;51811:10;-1:-1:-1;;;;;51796:26:0;-1:-1:-1;;;;;51796:26:0;;;;;;;;;;;;:52;51823:11;51835:1;51823:14;;;;;;;;:::i;:::-;;;;;;;:24;;;51796:52;;;;;;;;;;;:67;;;;51900:25;;;;;;;;;-1:-1:-1;;;;;51900:25:0;-1:-1:-1;;;;;51892:51:0;;51962:10;51999:4;52023:11;52035:1;52023:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:24;;51892:191;;-1:-1:-1;;;;;;51892:191:0;;;;;;;-1:-1:-1;;;;;7969:15:1;;;51892:191:0;;;7951:34:1;8021:15;;;;8001:18;;;7994:43;8053:18;;;8046:34;8116:3;8096:18;;;8089:31;-1:-1:-1;8136:19:1;;;8129:30;8176:19;;51892:191:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52100:51;52126:11;52138:1;52126:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:24;;;52110:10;52100:21;;;;:9;:21;;;;;;;;:25;:51::i;:::-;;48920:3245;;;;48915:3;;;;;:::i;:::-;;;;48875:3290;;46714:359;-1:-1:-1;;;;;46844:18:0;;46801:40;46844:18;;;:9;:18;;;;;46774:16;;46914:19;46844:18;46914:17;:19::i;:::-;46899:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46899:35:0;;46871:63;;46950:9;46945:97;46965:19;:10;:17;:19::i;:::-;46961:1;:23;46945:97;;;47016:16;:10;47030:1;47016:13;:16::i;:::-;47002:8;47011:1;47002:11;;;;;;;;:::i;:::-;;;;;;;;;;:30;46986:3;;;;:::i;:::-;;;;46945:97;;;-1:-1:-1;47057:8:0;46714:359;-1:-1:-1;;;46714:359:0:o;44735:290::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;44880:11:::1;:26:::0;;;;44917:11:::1;:26:::0;;;;44954:11:::1;:26:::0;44991:11:::1;:26:::0;44735:290::o;2628:192::-;1774:7;1801:6;-1:-1:-1;;;;;1801:6:0;682:10;1948:23;1940:68;;;;-1:-1:-1;;;1940:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2717:22:0;::::1;2709:73;;;::::0;-1:-1:-1;;;2709:73:0;;10072:2:1;2709:73:0::1;::::0;::::1;10054:21:1::0;10111:2;10091:18;;;10084:30;10150:34;10130:18;;;10123:62;-1:-1:-1;;;10201:18:1;;;10194:36;10247:19;;2709:73:0::1;9870:402:1::0;2709:73:0::1;2793:19;2803:8;2793:9;:19::i;:::-;2628:192:::0;:::o;27888:146::-;27965:4;20948:19;;;:12;;;:19;;;;;;:24;;27989:37;27982:44;27888:146;-1:-1:-1;;;27888:146:0:o;35328:120::-;34340:7;;;;34864:41;;;;-1:-1:-1;;;34864:41:0;;9723:2:1;34864:41:0;;;9705:21:1;9762:2;9742:18;;;9735:30;-1:-1:-1;;;9781:18:1;;;9774:50;9841:18;;34864:41:0;9521:344:1;34864:41:0;35387:7:::1;:15:::0;;-1:-1:-1;;35387:15:0::1;::::0;;35418:22:::1;682:10:::0;35427:12:::1;35418:22;::::0;-1:-1:-1;;;;;7222:32:1;;;7204:51;;7192:2;7177:18;35418:22:0::1;;;;;;;35328:120::o:0;2828:173::-;2884:16;2903:6;;-1:-1:-1;;;;;2920:17:0;;;-1:-1:-1;;;;;;2920:17:0;;;;;;2953:40;;2903:6;;;;;;;2953:40;;2884:16;2953:40;2873:128;2828:173;:::o;35069:118::-;34340:7;;;;34594:9;34586:38;;;;-1:-1:-1;;;34586:38:0;;;;;;;:::i;:::-;35129:7:::1;:14:::0;;-1:-1:-1;;35129:14:0::1;35139:4;35129:14;::::0;;35159:20:::1;35166:12;682:10:::0;;602:98;27665:137;27735:4;27759:35;27767:3;27787:5;27759:7;:35::i;38430:723::-;38486:13;38707:10;38703:53;;-1:-1:-1;;38734:10:0;;;;;;;;;;;;-1:-1:-1;;;38734:10:0;;;;;38430:723::o;38703:53::-;38781:5;38766:12;38822:78;38829:9;;38822:78;;38855:8;;;;:::i;:::-;;-1:-1:-1;38878:10:0;;-1:-1:-1;38886:2:0;38878:10;;:::i;:::-;;;38822:78;;;38910:19;38942:6;38932:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38932:17:0;;38910:39;;38960:154;38967:10;;38960:154;;38994:11;39004:1;38994:11;;:::i;:::-;;-1:-1:-1;39063:10:0;39071:2;39063:5;:10;:::i;:::-;39050:24;;:2;:24;:::i;:::-;39037:39;;39020:6;39027;39020:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;39020:56:0;;;;;;;;-1:-1:-1;39091:11:0;39100:2;39091:11;;:::i;:::-;;;38960:154;;41223:190;41348:4;41401;41372:25;41385:5;41392:4;41372:12;:25::i;:::-;:33;;41223:190;-1:-1:-1;;;;41223:190:0:o;27358:131::-;27425:4;27449:32;27454:3;27474:5;27449:4;:32::i;28120:114::-;28180:7;28207:19;28215:3;21149:18;;21066:109;28588:137;28659:7;28694:22;28698:3;28710:5;28694:3;:22::i;19345:1420::-;19411:4;19550:19;;;:12;;;:19;;;;;;19586:15;;19582:1176;;19961:21;19985:14;19998:1;19985:10;:14;:::i;:::-;20034:18;;19961:38;;-1:-1:-1;20014:17:0;;20034:22;;20055:1;;20034:22;:::i;:::-;20014:42;;20090:13;20077:9;:26;20073:405;;20124:17;20144:3;:11;;20156:9;20144:22;;;;;;;;:::i;:::-;;;;;;;;;20124:42;;20298:9;20269:3;:11;;20281:13;20269:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;20383:23;;;:12;;;:23;;;;;:36;;;20073:405;20559:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;20654:3;:12;;:19;20667:5;20654:19;;;;;;;;;;;20647:26;;;20697:4;20690:11;;;;;;;19582:1176;20741:5;20734:12;;;;;41774:675;41857:7;41900:4;41857:7;41915:497;41939:5;:12;41935:1;:16;41915:497;;;41973:20;41996:5;42002:1;41996:8;;;;;;;;:::i;:::-;;;;;;;41973:31;;42039:12;42023;:28;42019:382;;42525:13;42575:15;;;42611:4;42604:15;;;42658:4;42642:21;;42151:57;;42019:382;;;42525:13;42575:15;;;42611:4;42604:15;;;42658:4;42642:21;;42328:57;;42019:382;-1:-1:-1;41953:3:0;;;;:::i;:::-;;;;41915:497;;18755:414;18818:4;20948:19;;;:12;;;:19;;;;;;18835:327;;-1:-1:-1;18878:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;19061:18;;19039:19;;;:12;;;:19;;;;;;:40;;;;19094:11;;18835:327;-1:-1:-1;19145:5:0;19138:12;;21529:120;21596:7;21623:3;:11;;21635:5;21623:18;;;;;;;;:::i;:::-;;;;;;;;;21616:25;;21529:120;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:673::-;246:5;299:3;292:4;284:6;280:17;276:27;266:55;;317:1;314;307:12;266:55;353:6;340:20;379:4;403:60;419:43;459:2;419:43;:::i;:::-;403:60;:::i;:::-;485:3;509:2;504:3;497:15;537:2;532:3;528:12;521:19;;572:2;564:6;560:15;624:3;619:2;613;610:1;606:10;598:6;594:23;590:32;587:41;584:61;;;641:1;638;631:12;584:61;663:1;673:163;687:2;684:1;681:9;673:163;;;744:17;;732:30;;782:12;;;;814;;;;705:1;698:9;673:163;;;-1:-1:-1;854:5:1;;192:673;-1:-1:-1;;;;;;;192:673:1:o;870:186::-;929:6;982:2;970:9;961:7;957:23;953:32;950:52;;;998:1;995;988:12;950:52;1021:29;1040:9;1021:29;:::i;1061:808::-;1158:6;1166;1174;1182;1190;1243:3;1231:9;1222:7;1218:23;1214:33;1211:53;;;1260:1;1257;1250:12;1211:53;1283:29;1302:9;1283:29;:::i;:::-;1273:39;;1331:38;1365:2;1354:9;1350:18;1331:38;:::i;:::-;1321:48;;1416:2;1405:9;1401:18;1388:32;1378:42;;1471:2;1460:9;1456:18;1443:32;1494:18;1535:2;1527:6;1524:14;1521:34;;;1551:1;1548;1541:12;1521:34;1589:6;1578:9;1574:22;1564:32;;1634:7;1627:4;1623:2;1619:13;1615:27;1605:55;;1656:1;1653;1646:12;1605:55;1696:2;1683:16;1722:2;1714:6;1711:14;1708:34;;;1738:1;1735;1728:12;1708:34;1783:7;1778:2;1769:6;1765:2;1761:15;1757:24;1754:37;1751:57;;;1804:1;1801;1794:12;1751:57;1061:808;;;;-1:-1:-1;1061:808:1;;-1:-1:-1;1835:2:1;1827:11;;1857:6;1061:808;-1:-1:-1;;;1061:808:1:o;1874:422::-;1967:6;1975;2028:2;2016:9;2007:7;2003:23;1999:32;1996:52;;;2044:1;2041;2034:12;1996:52;2067:29;2086:9;2067:29;:::i;:::-;2057:39;;2147:2;2136:9;2132:18;2119:32;2174:18;2166:6;2163:30;2160:50;;;2206:1;2203;2196:12;2160:50;2229:61;2282:7;2273:6;2262:9;2258:22;2229:61;:::i;:::-;2219:71;;;1874:422;;;;;:::o;2301:254::-;2369:6;2377;2430:2;2418:9;2409:7;2405:23;2401:32;2398:52;;;2446:1;2443;2436:12;2398:52;2469:29;2488:9;2469:29;:::i;:::-;2459:39;2545:2;2530:18;;;;2517:32;;-1:-1:-1;;;2301:254:1:o;2560:2041::-;2672:6;2725:2;2713:9;2704:7;2700:23;2696:32;2693:52;;;2741:1;2738;2731:12;2693:52;2764:18;2822:2;2810:9;2797:23;2794:31;2791:51;;;2838:1;2835;2828:12;2791:51;2889:9;2876:23;2865:9;2861:39;2938:7;2931:4;2927:2;2923:13;2919:27;2909:55;;2960:1;2957;2950:12;2909:55;2984:74;3000:57;3053:2;3040:16;3000:57;:::i;2984:74::-;3080:3;3117:2;3104:16;3099:3;3092:29;3146:2;3141:3;3137:12;3130:19;;3177:2;3173;3169:11;3239:7;3234:2;3227;3214:16;3211:1;3207:24;3203:2;3199:33;3195:42;3192:55;3189:75;;;3260:1;3257;3250:12;3189:75;3282:1;3292:1279;3319:2;3306:16;3303:1;3300:23;3292:1279;;;3390:2;3384:3;3371:17;3368:25;3365:45;;;3406:1;3403;3396:12;3365:45;3441:17;;3433:26;;3511:4;3483:16;;;-1:-1:-1;;3479:30:1;3475:41;3472:61;;;3529:1;3526;3519:12;3472:61;3559:22;;:::i;:::-;3629:2;3625;3621:11;3608:25;3660:2;3652:6;3649:14;3646:34;;;3676:1;3673;3666:12;3646:34;3703:15;;3753:2;3745:11;;3741:25;-1:-1:-1;3731:53:1;;3780:1;3777;3770:12;3731:53;3828:2;3824;3820:11;3807:25;3858:60;3874:43;3914:2;3874:43;:::i;3858:60::-;3944:5;3976:2;3969:5;3962:17;4012:2;4005:5;4001:14;3992:23;;4049:4;4045:2;4041:13;4105:7;4098:4;4092:2;4089:1;4085:10;4081:2;4077:19;4073:30;4070:43;4067:63;;;4126:1;4123;4116:12;4067:63;4154:1;4143:12;;4168:201;4184:2;4179:3;4176:11;4168:201;;;4255:19;;4241:34;;4206:1;4197:11;;;;;4312:2;4301:14;;;;4341;4168:201;;;-1:-1:-1;4382:20:1;;-1:-1:-1;;;4459:4:1;4451:13;;;;4438:27;4433:2;4422:14;;;4415:51;;;;4479:18;;;4517:12;;;;4549;;;;;3338:1;3331:9;3292:1279;;4606:615;4692:6;4700;4753:2;4741:9;4732:7;4728:23;4724:32;4721:52;;;4769:1;4766;4759:12;4721:52;4809:9;4796:23;4838:18;4879:2;4871:6;4868:14;4865:34;;;4895:1;4892;4885:12;4865:34;4933:6;4922:9;4918:22;4908:32;;4978:7;4971:4;4967:2;4963:13;4959:27;4949:55;;5000:1;4997;4990:12;4949:55;5040:2;5027:16;5066:2;5058:6;5055:14;5052:34;;;5082:1;5079;5072:12;5052:34;5135:7;5130:2;5120:6;5117:1;5113:14;5109:2;5105:23;5101:32;5098:45;5095:65;;;5156:1;5153;5146:12;5095:65;5187:2;5179:11;;;;;5209:6;;-1:-1:-1;4606:615:1;;-1:-1:-1;;;;4606:615:1:o;5226:348::-;5310:6;5363:2;5351:9;5342:7;5338:23;5334:32;5331:52;;;5379:1;5376;5369:12;5331:52;5419:9;5406:23;5452:18;5444:6;5441:30;5438:50;;;5484:1;5481;5474:12;5438:50;5507:61;5560:7;5551:6;5540:9;5536:22;5507:61;:::i;5579:277::-;5646:6;5699:2;5687:9;5678:7;5674:23;5670:32;5667:52;;;5715:1;5712;5705:12;5667:52;5747:9;5741:16;5800:5;5793:13;5786:21;5779:5;5776:32;5766:60;;5822:1;5819;5812:12;5861:385;5947:6;5955;5963;5971;6024:3;6012:9;6003:7;5999:23;5995:33;5992:53;;;6041:1;6038;6031:12;5992:53;-1:-1:-1;;6064:23:1;;;6134:2;6119:18;;6106:32;;-1:-1:-1;6185:2:1;6170:18;;6157:32;;6236:2;6221:18;6208:32;;-1:-1:-1;5861:385:1;-1:-1:-1;5861:385:1:o;6251:180::-;6310:6;6363:2;6351:9;6342:7;6338:23;6334:32;6331:52;;;6379:1;6376;6369:12;6331:52;-1:-1:-1;6402:23:1;;6251:180;-1:-1:-1;6251:180:1:o;6436:184::-;6506:6;6559:2;6547:9;6538:7;6534:23;6530:32;6527:52;;;6575:1;6572;6565:12;6527:52;-1:-1:-1;6598:16:1;;6436:184;-1:-1:-1;6436:184:1:o;6625:428::-;6756:3;6794:6;6788:13;6819:1;6829:129;6843:6;6840:1;6837:13;6829:129;;;6941:4;6925:14;;;6921:25;;6915:32;6902:11;;;6895:53;6858:12;6829:129;;;6976:6;6973:1;6970:13;6967:48;;;7011:1;7002:6;6997:3;6993:16;6986:27;6967:48;-1:-1:-1;7031:16:1;;;;;6625:428;-1:-1:-1;;6625:428:1:o;8485:632::-;8656:2;8708:21;;;8778:13;;8681:18;;;8800:22;;;8627:4;;8656:2;8879:15;;;;8853:2;8838:18;;;8627:4;8922:169;8936:6;8933:1;8930:13;8922:169;;;8997:13;;8985:26;;9066:15;;;;9031:12;;;;8958:1;8951:9;8922:169;;;-1:-1:-1;9108:3:1;;8485:632;-1:-1:-1;;;;;;8485:632:1:o;10277:340::-;10479:2;10461:21;;;10518:2;10498:18;;;10491:30;-1:-1:-1;;;10552:2:1;10537:18;;10530:46;10608:2;10593:18;;10277:340::o;10622:356::-;10824:2;10806:21;;;10843:18;;;10836:30;10902:34;10897:2;10882:18;;10875:62;10969:2;10954:18;;10622:356::o;12572:257::-;12644:4;12638:11;;;12676:17;;12723:18;12708:34;;12744:22;;;12705:62;12702:88;;;12770:18;;:::i;:::-;12806:4;12799:24;12572:257;:::o;12834:275::-;12905:2;12899:9;12970:2;12951:13;;-1:-1:-1;;12947:27:1;12935:40;;13005:18;12990:34;;13026:22;;;12987:62;12984:88;;;13052:18;;:::i;:::-;13088:2;13081:22;12834:275;;-1:-1:-1;12834:275:1:o;13114:183::-;13174:4;13207:18;13199:6;13196:30;13193:56;;;13229:18;;:::i;:::-;-1:-1:-1;13274:1:1;13270:14;13286:4;13266:25;;13114:183::o;13302:128::-;13342:3;13373:1;13369:6;13366:1;13363:13;13360:39;;;13379:18;;:::i;:::-;-1:-1:-1;13415:9:1;;13302:128::o;13435:120::-;13475:1;13501;13491:35;;13506:18;;:::i;:::-;-1:-1:-1;13540:9:1;;13435:120::o;13560:168::-;13600:7;13666:1;13662;13658:6;13654:14;13651:1;13648:21;13643:1;13636:9;13629:17;13625:45;13622:71;;;13673:18;;:::i;:::-;-1:-1:-1;13713:9:1;;13560:168::o;13733:125::-;13773:4;13801:1;13798;13795:8;13792:34;;;13806:18;;:::i;:::-;-1:-1:-1;13843:9:1;;13733:125::o;13863:135::-;13902:3;-1:-1:-1;;13923:17:1;;13920:43;;;13943:18;;:::i;:::-;-1:-1:-1;13990:1:1;13979:13;;13863:135::o;14003:112::-;14035:1;14061;14051:35;;14066:18;;:::i;:::-;-1:-1:-1;14100:9:1;;14003:112::o;14120:127::-;14181:10;14176:3;14172:20;14169:1;14162:31;14212:4;14209:1;14202:15;14236:4;14233:1;14226:15;14252:127;14313:10;14308:3;14304:20;14301:1;14294:31;14344:4;14341:1;14334:15;14368:4;14365:1;14358:15;14384:127;14445:10;14440:3;14436:20;14433:1;14426:31;14476:4;14473:1;14466:15;14500:4;14497:1;14490:15;14516:127;14577:10;14572:3;14568:20;14565:1;14558:31;14608:4;14605:1;14598:15;14632:4;14629:1;14622:15;14648:127;14709:10;14704:3;14700:20;14697:1;14690:31;14740:4;14737:1;14730:15;14764:4;14761:1;14754:15

ipfs://625297dc4af873774469776c83457a5e130515dc8cc6b34cc92f26791817fa52