Contract 0x1d8132574a15b284743029ef1a2bcc893dc102b4

/**
 *Submitted for verification at FtmScan.com on 2022-04-24
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//Imports
/**
 * @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() {
        _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);
    }
}
// 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 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;
        }
    }
}
/**
 * @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);

    /**
     * @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 `IERC721Receiver.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 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;
    }
}
/**
 * @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 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);
            }
        }
    }
}
/**
 * @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");
        }
    }
}
// End of Imports

 // token burn 
 interface IBurn {
     function burn(uint256 _amount) external;
 }

 interface IGenesisLevelChilla {
    function genesisLevelCheckChilla(uint256 tokenId) external returns(uint256 level);
}

interface IGenesisLevelGuinea {
    function genesisLevelCheckGuinea(uint256 tokenId) external returns(uint256 level);
}

interface IGenesisLevelLand {
    function genesisLevelCheckLand(uint256 tokenId) external returns(uint256 level);
}

interface IDeedCheck {
    function deedCheck(uint256 tokenId) external view returns(uint256);
}

contract miniStaking is Ownable, IERC721Receiver, ReentrancyGuard, Pausable {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.UintSet; 
    
    //addresses 
    address nullAddress = 0x0000000000000000000000000000000000000000;
    address public stakingDestinationAddress;
    address public erc20Address;
    address public erc20Address2;
    address public treasury;
    address public MiniMarket;

  
    uint256 public expiration; 
    //rate governs how often you receive your token
    uint256 public rate; 
    // deposit/withdraw tax
    uint256 public taxDeposit = 5 ether;
    uint256 public taxDeposit2 = 5 ether;
    
    // tax rate levels
    bool emissions = true;
    uint256 public rate1 = 1;
    uint256 public rate2 = 5;
    uint256 public rate3 = 9;
    uint256 public rate4 = 13;
    uint256 public rate5 = 4;
    uint256 public rate6 = 12;
    uint256 public rate7 = 22;
    uint256 public rate8 = 31;
    uint256 public rate9 = 8;
    uint256 public rate10 = 22;
    uint256 public rate11 = 38;
    uint256 public rate12 = 54;
    uint256 public rate13 = 15;
    uint256 public rate14 = 40;
    uint256 public rate15 = 70;
    uint256 public rate16 = 100;
 
    
    // mappings 
    mapping(address => EnumerableSet.UintSet) private _deposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;
    
    
   
    
 
    constructor(address _stakingDestinationAddress, uint256 _rate, uint256 _expiration, address _erc20Address, address _erc20Address2, address _minimarket) {
        stakingDestinationAddress = _stakingDestinationAddress;
        rate = _rate;
        expiration = block.number + _expiration;
        erc20Address = _erc20Address;
        erc20Address2 = _erc20Address2;
        MiniMarket = _minimarket;
        _pause();
    }


   function burn(uint256 _amount) internal {
        IBurn(erc20Address).burn(_amount);
  }

 function calcGenesisRateLand(uint256 _tokenId) internal returns (uint256 fusRate){
      if(IGenesisLevelLand(MiniMarket).genesisLevelCheckLand(_tokenId) == 1){
       if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 1) {
        return rate5;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 2){
        return rate6;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 3){
        return rate7;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 4){
        return rate8;
       }
      }else if(IGenesisLevelLand(MiniMarket).genesisLevelCheckLand(_tokenId) == 2){
       if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 1) {
        return rate9;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 2){
        return rate10;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 3){
        return rate11;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 4){
        return rate12;
       }
      }else if(IGenesisLevelLand(MiniMarket).genesisLevelCheckLand(_tokenId) == 3){
       if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 1) {
        return rate13;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 2){
        return rate14;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 3){
        return rate15;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 4){
        return rate16;
       }
      }else {
       if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 1) {
        return rate1;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 2){
        return rate2;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 3){
        return rate3;
       }else if(IDeedCheck(stakingDestinationAddress).deedCheck(_tokenId) == 4){
        return rate4;
      }
  }
 }

    // gets x %
   function calcTax(uint256 _amount, uint256 taxRate) private pure returns (uint256){
        uint256 taxedAmount;
        taxedAmount = taxRate * _amount / 100;
        return taxedAmount;
    }
    
/* STAKING MECHANICS */
 
    // Set a multiplier for how many tokens to earn each time a block passes. 
        // 277777777777777.66666666666666667 for aprox 25 a day at 100,000 blocks per day
    function setRate(uint256 _rate) public onlyOwner() {
      rate = _rate;
    }
 
    // Set this to a block to disable the ability to continue accruing tokens past that block number.
    function setExpiration(uint256 _expiration) public onlyOwner() {
      expiration = block.number + _expiration;
    }

    function setTreasury(address _address) public onlyOwner() {
      treasury = _address;
    }
    
    function setMiniMarket(address _address) public onlyOwner() {
      MiniMarket = _address;
    }

    function setTaxDeposit(uint256 _newTax) public onlyOwner() {
      taxDeposit = _newTax;
    }

    function setTaxDeposit2(uint256 _newTax) public onlyOwner() {
      taxDeposit2 = _newTax;
    }

    function seterc20Address(address _erc20Address) public onlyOwner() {
      erc20Address = _erc20Address;
    }

    function seterc20Address2(address _erc20Address) public onlyOwner() {
      erc20Address2 = _erc20Address;
    }

    function setemissions(bool _set) public onlyOwner(){
      emissions = _set;
    }

    //check deposit amount. - Tested
    function depositsOf(address account) public 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;
    }
 
    //reward amount by address/tokenIds[] - Tested
    function calculateRewards(address account, uint256[] memory tokenIds) public view returns (uint256[] memory rewards) {
      rewards = new uint256[](tokenIds.length);
 
      for (uint256 i; i < tokenIds.length; i++) {
        uint256 tokenId = tokenIds[i];
        rewards[i] = rate * (_deposits[account].contains(tokenId) ? 1 : 0) * (Math.min(block.number, expiration) - _depositBlocks[account][tokenId]);
      }
      return rewards;
    }
 
    //reward amount by address/tokenId - Tested
    function calculateReward(address account, uint256 tokenId) public view returns (uint256) {
      uint256 reward;
      require(Math.min(block.number, expiration) > _depositBlocks[account][tokenId], "Invalid blocks");
      reward = rate * (_deposits[account].contains(tokenId) ? 1 : 0) * (Math.min(block.number, expiration) - _depositBlocks[account][tokenId]);
      return reward;
    }

     function calculateRewardTaxed(address account, uint256 tokenId) internal returns (uint256) {
      uint256 reward;
      require(Math.min(block.number, expiration) > _depositBlocks[account][tokenId], "Invalid blocks");
      reward = rate * (_deposits[account].contains(tokenId) ? 1 : 0) * (Math.min(block.number, expiration) - _depositBlocks[account][tokenId]);
      return calcTax(reward, calcGenesisRateLand(tokenId));
    }
 
    //reward claim function - Tested
    function claimRewards(uint256[] calldata tokenIds) public whenNotPaused {
      uint256 reward; 
      uint256 blockCur = Math.min(block.number, expiration);
    
      
      //require(tokenIds.length <= 1, "Can only Claim/Stake/Unstake 1 at a time");
      for (uint256 i; i < tokenIds.length; i++) {
        reward += calculateRewardTaxed(msg.sender, tokenIds[i]);
        _depositBlocks[msg.sender][tokenIds[i]] = blockCur;
      }
      if(reward > 0) {
        burn(calcTax(reward, 5));
        reward = calcTax(reward, 90);
        IERC20(erc20Address).safeTransfer(msg.sender, reward);
    }
  }
 
    //deposit function.  - Tested
    function deposit(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        require(emissions == true, "Emissions Over");
        require(msg.sender != stakingDestinationAddress, "Invalid address");
        IERC20(erc20Address).safeTransferFrom(msg.sender, address(this), taxDeposit * tokenIds.length);
        IERC20(erc20Address2).safeTransferFrom(msg.sender, address(this), taxDeposit2 * tokenIds.length);
        claimRewards(tokenIds);
 
        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(stakingDestinationAddress).safeTransferFrom(msg.sender,address(this),tokenIds[i],"");
            _deposits[msg.sender].add(tokenIds[i]);
           
        }
    }

    //withdrawal function. Tested
    function withdraw(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        IERC20(erc20Address).safeTransferFrom(msg.sender, address(this), taxDeposit * tokenIds.length);
        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],"");
          
        }
    }
 
    //withdrawal function. 
    function withdrawAllTokens() external onlyOwner() {
        uint256 tokenSupply = IERC20(erc20Address).balanceOf(address(this));
        IERC20(erc20Address).safeTransfer(msg.sender, tokenSupply);
    }

     function withdrawTokens(address _erc20Address, uint256 _amount) external onlyOwner() {
      
        IERC20(_erc20Address).safeTransfer(msg.sender, _amount);
    }
 
    function onERC721Received(address,address,uint256,bytes calldata) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    //only owner

    function rateSwitch(uint256[] memory _newRate) public onlyOwner(){
         require(_newRate.length == 16, "Need 12");
         rate1 = _newRate[0];
         rate2 = _newRate[1];
         rate3 = _newRate[2];
         rate4 = _newRate[3];
         rate5 = _newRate[4];
         rate6 = _newRate[5];
         rate7 = _newRate[6];
         rate8 = _newRate[7];
         rate9 = _newRate[8];
         rate10 = _newRate[9];
         rate11 = _newRate[10];
         rate12 = _newRate[11];
         rate13 = _newRate[12];
         rate14 = _newRate[13];
         rate15 = _newRate[14];
         rate16 = _newRate[15];
    }

     function pause() public onlyOwner() {
        _pause();
    }
 
    function unpause() public onlyOwner() {
        _unpause();
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stakingDestinationAddress","type":"address"},{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"},{"internalType":"address","name":"_erc20Address","type":"address"},{"internalType":"address","name":"_erc20Address2","type":"address"},{"internalType":"address","name":"_minimarket","type":"address"}],"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":[],"name":"MiniMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"_depositBlocks","outputs":[{"internalType":"uint256","name":"","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":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"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":"erc20Address2","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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate10","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate11","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate12","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate13","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate14","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate15","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate16","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate3","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate4","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate5","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate6","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate7","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate8","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate9","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_newRate","type":"uint256[]"}],"name":"rateSwitch","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"_address","type":"address"}],"name":"setMiniMarket","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"setRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTax","type":"uint256"}],"name":"setTaxDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTax","type":"uint256"}],"name":"setTaxDeposit2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_set","type":"bool"}],"name":"setemissions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20Address","type":"address"}],"name":"seterc20Address","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20Address","type":"address"}],"name":"seterc20Address2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingDestinationAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxDeposit2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAllTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20Address","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405260028054610100600160a81b0319169055674563918244f40000600a819055600b55600c805460ff191660019081178255600d9081556005600e556009600f908155601091909155600460115560129190915560166013819055601f60145560086015558055602660175560366018556019556028601a556046601b556064601c553480156200009357600080fd5b5060405162002f2338038062002f23833981016040819052620000b6916200025c565b620000c13362000151565b600180556002805460ff19169055600380546001600160a01b0319166001600160a01b0388161790556009859055620000fb8443620002cb565b600855600480546001600160a01b038086166001600160a01b03199283161790925560058054858416908316179055600780549284169290911691909117905562000145620001a1565b505050505050620002f2565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b60025460ff1615620001ec5760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b604482015260640160405180910390fd5b6002805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258620002223390565b6040516001600160a01b03909116815260200160405180910390a1565b80516001600160a01b03811681146200025757600080fd5b919050565b60008060008060008060c087890312156200027657600080fd5b62000281876200023f565b955060208701519450604087015193506200029f606088016200023f565b9250620002af608088016200023f565b9150620002bf60a088016200023f565b90509295509295509295565b60008219821115620002ed57634e487b7160e01b600052601160045260246000fd5b500190565b612c2180620003026000396000f3fe608060405234801561001057600080fd5b50600436106102c15760003560e01c8063715018a61161017d578063d52d3c15116100d9578063f2fde38b11610092578063f2fde38b146105ac578063f5389b60146105bf578063f555b815146105c8578063f91a2bf1146105d1578063f97dd71a146105e4578063fc4f5777146105f7578063fdedabea1461060057600080fd5b8063d52d3c1514610544578063db16eca914610557578063e3a9db1a14610560578063ef5d9d0d14610573578063efa9f5ee14610586578063f0f442601461059957600080fd5b80638190fed8116101365780638190fed8146104d25780638456cb59146104db5780638da5cb5b146104e3578063983d95ce146104f4578063aff1f15f14610507578063b343ae1414610510578063cf8549691461053b57600080fd5b8063715018a614610493578063750487ef1461049b57806375454712146104a457806379630bd8146104b75780637c243285146104c05780637f137bbe146104c957600080fd5b806334fcf4371161022c578063515a20ba116101e5578063515a20ba1461041f578063598b8e71146104325780635c6d92bc146104455780635c975abb1461044e5780635dd8eb50146104645780635eac62391461046d57806361d027b31461048057600080fd5b806334fcf437146103d65780633f4ba83a146103e957806344cd43b7146103f157806345073312146104045780634665096d1461040d578063504999051461041657600080fd5b80631852e8d91161027e5780631852e8d9146103835780632722c67014610396578063276184ae1461039f5780632790000d146103b2578063280da6fa146103c55780632c4e722e146103cd57600080fd5b80630222a2c4146102c6578063053e536a146102f6578063068c526f1461030d57806306b091f91461032d578063150b7a021461034257806317ccf6a01461037a575b600080fd5b6003546102d9906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b6102ff601c5481565b6040519081526020016102ed565b61032061031b36600461284e565b610613565b6040516102ed91906129f8565b61034061033b36600461289c565b610754565b005b6103616103503660046127b3565b630a85bd0160e11b95945050505050565b6040516001600160e01b031990911681526020016102ed565b6102ff60115481565b6102ff61039136600461289c565b61079f565b6102ff60145481565b6004546102d9906001600160a01b031681565b6103406103c0366004612798565b6108a0565b6103406108ec565b6102ff60095481565b6103406103e43660046129aa565b6109b4565b6103406109e3565b6005546102d9906001600160a01b031681565b6102ff60155481565b6102ff60085481565b6102ff600b5481565b61034061042d3660046129aa565b610a17565b6103406104403660046128c6565b610a51565b6102ff60195481565b60025460ff1660405190151581526020016102ed565b6102ff60105481565b61034061047b3660046128c6565b610cbb565b6006546102d9906001600160a01b031681565b610340610dbe565b6102ff601b5481565b6103406104b2366004612970565b610df2565b6102ff60165481565b6102ff60125481565b6102ff600a5481565b6102ff601a5481565b610340610e2f565b6000546001600160a01b03166102d9565b6103406105023660046128c6565b610e61565b6102ff600f5481565b6102ff61051e36600461289c565b601e60209081526000928352604080842090915290825290205481565b6102ff600d5481565b610340610552366004612798565b61106f565b6102ff60185481565b61032061056e366004612798565b6110bb565b6007546102d9906001600160a01b031681565b6103406105943660046129aa565b611177565b6103406105a7366004612798565b6111a6565b6103406105ba366004612798565b6111f2565b6102ff60175481565b6102ff600e5481565b6103406105df36600461293b565b61128a565b6103406105f23660046129aa565b611502565b6102ff60135481565b61034061060e366004612798565b611531565b6060815167ffffffffffffffff81111561062f5761062f612bc7565b604051908082528060200260200182016040528015610658578160200160208202803683370190505b50905060005b825181101561074c57600083828151811061067b5761067b612bb1565b60200260200101519050601e6000866001600160a01b03166001600160a01b031681526020019081526020016000206000828152602001908152602001600020546106c84360085461157d565b6106d29190612b27565b6001600160a01b0386166000908152601d602052604090206106f49083611595565b6106ff576000610702565b60015b60ff166009546107129190612b08565b61071c9190612b08565b83838151811061072e5761072e612bb1565b6020908102919091010152508061074481612b6a565b91505061065e565b505b92915050565b6000546001600160a01b031633146107875760405162461bcd60e51b815260040161077e90612a99565b60405180910390fd5b61079b6001600160a01b03831633836115ad565b5050565b6001600160a01b0382166000908152601e602090815260408083208484529091528120546008548291906107d490439061157d565b116108125760405162461bcd60e51b815260206004820152600e60248201526d496e76616c696420626c6f636b7360901b604482015260640161077e565b6001600160a01b0384166000908152601e6020908152604080832086845290915290205460085461084490439061157d565b61084e9190612b27565b6001600160a01b0385166000908152601d602052604090206108709085611595565b61087b57600061087e565b60015b60ff1660095461088e9190612b08565b6108989190612b08565b949350505050565b6000546001600160a01b031633146108ca5760405162461bcd60e51b815260040161077e90612a99565b600480546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b031633146109165760405162461bcd60e51b815260040161077e90612a99565b600480546040516370a0823160e01b815230928101929092526000916001600160a01b03909116906370a082319060240160206040518083038186803b15801561095f57600080fd5b505afa158015610973573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061099791906129c3565b6004549091506109b1906001600160a01b031633836115ad565b50565b6000546001600160a01b031633146109de5760405162461bcd60e51b815260040161077e90612a99565b600955565b6000546001600160a01b03163314610a0d5760405162461bcd60e51b815260040161077e90612a99565b610a15611615565b565b6000546001600160a01b03163314610a415760405162461bcd60e51b815260040161077e90612a99565b610a4b8143612ace565b60085550565b60025460ff1615610a745760405162461bcd60e51b815260040161077e90612a6f565b60026001541415610ac75760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640161077e565b60026001908155600c5460ff16151514610b145760405162461bcd60e51b815260206004820152600e60248201526d22b6b4b9b9b4b7b7399027bb32b960911b604482015260640161077e565b6003546001600160a01b0316331415610b615760405162461bcd60e51b815260206004820152600f60248201526e496e76616c6964206164647265737360881b604482015260640161077e565b610b8b333084849050600a54610b779190612b08565b6004546001600160a01b03169291906116a8565b610bb5333084849050600b54610ba19190612b08565b6005546001600160a01b03169291906116a8565b610bbf8282610cbb565b60005b81811015610cb2576003546001600160a01b031663b88d4fde3330868686818110610bef57610bef612bb1565b6040516001600160e01b031960e088901b1681526001600160a01b03958616600482015294909316602485015250602090910201356044820152608060648201526000608482015260a401600060405180830381600087803b158015610c5457600080fd5b505af1158015610c68573d6000803e3d6000fd5b50505050610c9f838383818110610c8157610c81612bb1565b336000908152601d60209081526040909120939102013590506116e0565b5080610caa81612b6a565b915050610bc2565b50506001805550565b60025460ff1615610cde5760405162461bcd60e51b815260040161077e90612a6f565b600080610ced4360085461157d565b905060005b83811015610d7957610d1c33868684818110610d1057610d10612bb1565b905060200201356116ec565b610d269084612ace565b336000908152601e60205260408120919450839190878785818110610d4d57610d4d612bb1565b905060200201358152602001908152602001600020819055508080610d7190612b6a565b915050610cf2565b508115610db857610d93610d8e8360056117f4565b61180d565b610d9e82605a6117f4565b600454909250610db8906001600160a01b031633846115ad565b50505050565b6000546001600160a01b03163314610de85760405162461bcd60e51b815260040161077e90612a99565b610a15600061186c565b6000546001600160a01b03163314610e1c5760405162461bcd60e51b815260040161077e90612a99565b600c805460ff1916911515919091179055565b6000546001600160a01b03163314610e595760405162461bcd60e51b815260040161077e90612a99565b610a156118bc565b60025460ff1615610e845760405162461bcd60e51b815260040161077e90612a6f565b60026001541415610ed75760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640161077e565b6002600155600a54610ef29033903090610b77908590612b08565b610efc8282610cbb565b60005b81811015610cb257610f3a838383818110610f1c57610f1c612bb1565b336000908152601d6020908152604090912093910201359050611595565b610f865760405162461bcd60e51b815260206004820152601c60248201527f5374616b696e673a20746f6b656e206e6f74206465706f736974656400000000604482015260640161077e565b610fb9838383818110610f9b57610f9b612bb1565b336000908152601d6020908152604090912093910201359050611914565b506003546001600160a01b031663b88d4fde3033868686818110610fdf57610fdf612bb1565b6040516001600160e01b031960e088901b1681526001600160a01b03958616600482015294909316602485015250602090910201356044820152608060648201526000608482015260a401600060405180830381600087803b15801561104457600080fd5b505af1158015611058573d6000803e3d6000fd5b50505050808061106790612b6a565b915050610eff565b6000546001600160a01b031633146110995760405162461bcd60e51b815260040161077e90612a99565b600780546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b0381166000908152601d602052604081206060916110df82611920565b67ffffffffffffffff8111156110f7576110f7612bc7565b604051908082528060200260200182016040528015611120578160200160208202803683370190505b50905060005b61112f83611920565b81101561116f57611140838261192a565b82828151811061115257611152612bb1565b60209081029190910101528061116781612b6a565b915050611126565b509392505050565b6000546001600160a01b031633146111a15760405162461bcd60e51b815260040161077e90612a99565b600a55565b6000546001600160a01b031633146111d05760405162461bcd60e51b815260040161077e90612a99565b600680546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b0316331461121c5760405162461bcd60e51b815260040161077e90612a99565b6001600160a01b0381166112815760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161077e565b6109b18161186c565b6000546001600160a01b031633146112b45760405162461bcd60e51b815260040161077e90612a99565b80516010146112ef5760405162461bcd60e51b81526020600482015260076024820152662732b2b210189960c91b604482015260640161077e565b8060008151811061130257611302612bb1565b6020026020010151600d819055508060018151811061132357611323612bb1565b6020026020010151600e819055508060028151811061134457611344612bb1565b6020026020010151600f819055508060038151811061136557611365612bb1565b60200260200101516010819055508060048151811061138657611386612bb1565b6020026020010151601181905550806005815181106113a7576113a7612bb1565b6020026020010151601281905550806006815181106113c8576113c8612bb1565b6020026020010151601381905550806007815181106113e9576113e9612bb1565b60200260200101516014819055508060088151811061140a5761140a612bb1565b60200260200101516015819055508060098151811061142b5761142b612bb1565b602002602001015160168190555080600a8151811061144c5761144c612bb1565b602002602001015160178190555080600b8151811061146d5761146d612bb1565b602002602001015160188190555080600c8151811061148e5761148e612bb1565b602002602001015160198190555080600d815181106114af576114af612bb1565b6020026020010151601a8190555080600e815181106114d0576114d0612bb1565b6020026020010151601b8190555080600f815181106114f1576114f1612bb1565b6020026020010151601c8190555050565b6000546001600160a01b0316331461152c5760405162461bcd60e51b815260040161077e90612a99565b600b55565b6000546001600160a01b0316331461155b5760405162461bcd60e51b815260040161077e90612a99565b600580546001600160a01b0319166001600160a01b0392909216919091179055565b600081831061158c578161158e565b825b9392505050565b6000818152600183016020526040812054151561158e565b6040516001600160a01b03831660248201526044810182905261161090849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b031990931692909217909152611936565b505050565b60025460ff1661165e5760405162461bcd60e51b815260206004820152601460248201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b604482015260640161077e565b6002805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b6040516001600160a01b0380851660248301528316604482015260648101829052610db89085906323b872dd60e01b906084016115d9565b600061158e8383611a08565b6001600160a01b0382166000908152601e6020908152604080832084845290915281205460085482919061172190439061157d565b1161175f5760405162461bcd60e51b815260206004820152600e60248201526d496e76616c696420626c6f636b7360901b604482015260640161077e565b6001600160a01b0384166000908152601e6020908152604080832086845290915290205460085461179190439061157d565b61179b9190612b27565b6001600160a01b0385166000908152601d602052604090206117bd9085611595565b6117c85760006117cb565b60015b60ff166009546117db9190612b08565b6117e59190612b08565b9050610898816117f485611a57565b60008060646118038585612b08565b6108989190612ae6565b60048054604051630852cd8d60e31b81529182018390526001600160a01b0316906342966c6890602401600060405180830381600087803b15801561185157600080fd5b505af1158015611865573d6000803e3d6000fd5b5050505050565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b60025460ff16156118df5760405162461bcd60e51b815260040161077e90612a6f565b6002805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a25861168b3390565b600061158e83836124af565b600061074e825490565b600061158e83836125a2565b600061198b826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166125cc9092919063ffffffff16565b80519091501561161057808060200190518101906119a9919061298d565b6116105760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840161077e565b6000818152600183016020526040812054611a4f5750815460018181018455600084815260208082209093018490558454848252828601909352604090209190915561074e565b50600061074e565b60075460405163429f48bf60e11b8152600481018390526000916001600160a01b03169063853e917e90602401602060405180830381600087803b158015611a9e57600080fd5b505af1158015611ab2573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611ad691906129c3565b60011415611d13576003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611b2257600080fd5b505afa158015611b36573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b5a91906129c3565b60011415611b6a57505060115490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611bae57600080fd5b505afa158015611bc2573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611be691906129c3565b60021415611bf657505060125490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611c3a57600080fd5b505afa158015611c4e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c7291906129c3565b60031415611c8257505060135490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611cc657600080fd5b505afa158015611cda573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611cfe91906129c3565b60041415611d0e57505060145490565b919050565b60075460405163429f48bf60e11b8152600481018490526001600160a01b039091169063853e917e90602401602060405180830381600087803b158015611d5957600080fd5b505af1158015611d6d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611d9191906129c3565b60021415611fc9576003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611ddd57600080fd5b505afa158015611df1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e1591906129c3565b60011415611e2557505060155490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611e6957600080fd5b505afa158015611e7d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611ea191906129c3565b60021415611eb157505060165490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611ef557600080fd5b505afa158015611f09573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611f2d91906129c3565b60031415611f3d57505060175490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b158015611f8157600080fd5b505afa158015611f95573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611fb991906129c3565b60041415611d0e57505060185490565b60075460405163429f48bf60e11b8152600481018490526001600160a01b039091169063853e917e90602401602060405180830381600087803b15801561200f57600080fd5b505af1158015612023573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061204791906129c3565b6003141561227f576003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b15801561209357600080fd5b505afa1580156120a7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120cb91906129c3565b600114156120db57505060195490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b15801561211f57600080fd5b505afa158015612133573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061215791906129c3565b60021415612167575050601a5490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b1580156121ab57600080fd5b505afa1580156121bf573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121e391906129c3565b600314156121f3575050601b5490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b15801561223757600080fd5b505afa15801561224b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061226f91906129c3565b60041415611d0e575050601c5490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b1580156122c357600080fd5b505afa1580156122d7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122fb91906129c3565b6001141561230b575050600d5490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b15801561234f57600080fd5b505afa158015612363573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061238791906129c3565b60021415612397575050600e5490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b1580156123db57600080fd5b505afa1580156123ef573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061241391906129c3565b60031415612423575050600f5490565b6003546040516338621dc560e01b8152600481018490526001600160a01b03909116906338621dc59060240160206040518083038186803b15801561246757600080fd5b505afa15801561247b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061249f91906129c3565b60041415611d0e57505060105490565b600081815260018301602052604081205480156125985760006124d3600183612b27565b85549091506000906124e790600190612b27565b905081811461254c57600086600001828154811061250757612507612bb1565b906000526020600020015490508087600001848154811061252a5761252a612bb1565b6000918252602080832090910192909255918252600188019052604090208390555b855486908061255d5761255d612b9b565b60019003818190600052602060002001600090559055856001016000868152602001908152602001600020600090556001935050505061074e565b600091505061074e565b60008260000182815481106125b9576125b9612bb1565b9060005260206000200154905092915050565b60606108988484600085856001600160a01b0385163b61262e5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161077e565b600080866001600160a01b0316858760405161264a91906129dc565b60006040518083038185875af1925050503d8060008114612687576040519150601f19603f3d011682016040523d82523d6000602084013e61268c565b606091505b509150915061269c8282866126a7565b979650505050505050565b606083156126b657508161158e565b8251156126c65782518084602001fd5b8160405162461bcd60e51b815260040161077e9190612a3c565b80356001600160a01b0381168114611d0e57600080fd5b600082601f83011261270857600080fd5b8135602067ffffffffffffffff8083111561272557612725612bc7565b8260051b604051601f19603f8301168101818110848211171561274a5761274a612bc7565b6040528481528381019250868401828801850189101561276957600080fd5b600092505b8583101561278c57803584529284019260019290920191840161276e565b50979650505050505050565b6000602082840312156127aa57600080fd5b61158e826126e0565b6000806000806000608086880312156127cb57600080fd5b6127d4866126e0565b94506127e2602087016126e0565b935060408601359250606086013567ffffffffffffffff8082111561280657600080fd5b818801915088601f83011261281a57600080fd5b81358181111561282957600080fd5b89602082850101111561283b57600080fd5b9699959850939650602001949392505050565b6000806040838503121561286157600080fd5b61286a836126e0565b9150602083013567ffffffffffffffff81111561288657600080fd5b612892858286016126f7565b9150509250929050565b600080604083850312156128af57600080fd5b6128b8836126e0565b946020939093013593505050565b600080602083850312156128d957600080fd5b823567ffffffffffffffff808211156128f157600080fd5b818501915085601f83011261290557600080fd5b81358181111561291457600080fd5b8660208260051b850101111561292957600080fd5b60209290920196919550909350505050565b60006020828403121561294d57600080fd5b813567ffffffffffffffff81111561296457600080fd5b610898848285016126f7565b60006020828403121561298257600080fd5b813561158e81612bdd565b60006020828403121561299f57600080fd5b815161158e81612bdd565b6000602082840312156129bc57600080fd5b5035919050565b6000602082840312156129d557600080fd5b5051919050565b600082516129ee818460208701612b3e565b9190910192915050565b6020808252825182820181905260009190848201906040850190845b81811015612a3057835183529284019291840191600101612a14565b50909695505050505050565b6020815260008251806020840152612a5b816040850160208701612b3e565b601f01601f19169190910160400192915050565b60208082526010908201526f14185d5cd8589b194e881c185d5cd95960821b604082015260600190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60008219821115612ae157612ae1612b85565b500190565b600082612b0357634e487b7160e01b600052601260045260246000fd5b500490565b6000816000190483118215151615612b2257612b22612b85565b500290565b600082821015612b3957612b39612b85565b500390565b60005b83811015612b59578181015183820152602001612b41565b83811115610db85750506000910152565b6000600019821415612b7e57612b7e612b85565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052603160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b80151581146109b157600080fdfea264697066735822122082c2b58c6b6339435dc685a397e4b7db4486d18709120b8d3a1a83dd9a818b0d64736f6c63430008070033000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc990000000000000000000000000000000000000000000000000006c00a3912c00000000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71cb3246ff00000000000000000000000057976c467608983513c9355238dc6de1b1abbcca0000000000000000000000000dfc2329fa20c3be8def2ad64474512f8477ed6a000000000000000000000000ef5af209ae811fb759c0d863d7f6ec1af3a0a986

000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc990000000000000000000000000000000000000000000000000006c00a3912c00000000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71cb3246ff00000000000000000000000057976c467608983513c9355238dc6de1b1abbcca0000000000000000000000000dfc2329fa20c3be8def2ad64474512f8477ed6a000000000000000000000000ef5af209ae811fb759c0d863d7f6ec1af3a0a986

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0xc1e87be1055509081ea73a0fd5d3d70f6573dc99
Arg [1] : _rate (uint256): 1900000000000000
Arg [2] : _expiration (uint256): 1111111111111111111111111111111111111111111111111111179650815
Arg [3] : _erc20Address (address): 0x57976c467608983513c9355238dc6de1b1abbcca
Arg [4] : _erc20Address2 (address): 0x0dfc2329fa20c3be8def2ad64474512f8477ed6a
Arg [5] : _minimarket (address): 0xef5af209ae811fb759c0d863d7f6ec1af3a0a986

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc99
Arg [1] : 0000000000000000000000000000000000000000000000000006c00a3912c000
Arg [2] : 00000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71cb3246ff
Arg [3] : 00000000000000000000000057976c467608983513c9355238dc6de1b1abbcca
Arg [4] : 0000000000000000000000000dfc2329fa20c3be8def2ad64474512f8477ed6a
Arg [5] : 000000000000000000000000ef5af209ae811fb759c0d863d7f6ec1af3a0a986

51076:10798:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51340:40;;;;;-1:-1:-1;;;;;51340:40:0;;;;;;-1:-1:-1;;;;;5086:32:1;;;5068:51;;5056:2;5041:18;51340:40:0;;;;;;;;52290:27;;;;;;;;;12639:25:1;;;12627:2;12612:18;52290:27:0;12493:177:1;57082:451:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;60709:167::-;;;;;;:::i;:::-;;:::i;:::-;;60885:173;;;;;;:::i;:::-;-1:-1:-1;;;60885:173:0;;;;;;;;;;;-1:-1:-1;;;;;;7340:33:1;;;7322:52;;7310:2;7295:18;60885:173:0;7178:202:1;51934:24:0;;;;;;57591:392;;;;;;:::i;:::-;;:::i;52029:25::-;;;;;;51387:27;;;;;-1:-1:-1;;;;;51387:27:0;;;56288:112;;;;;;:::i;:::-;;:::i;60495:205::-;;;:::i;51610:19::-;;;;;;55547:80;;;;;;:::i;:::-;;:::i;61802:67::-;;;:::i;51421:28::-;;;;;-1:-1:-1;;;;;51421:28:0;;;52061:24;;;;;;51524:25;;;;;;51708:36;;;;;;55739:119;;;;;;:::i;:::-;;:::i;59134:710::-;;;;;;:::i;:::-;;:::i;52191:26::-;;;;;;34392:86;34463:7;;;;34392:86;;7151:14:1;;7144:22;7126:41;;7114:2;7099:18;34392:86:0;6986:187:1;51902:25:0;;;;;;58472:618;;;;;;:::i;:::-;;:::i;51456:23::-;;;;;-1:-1:-1;;;;;51456:23:0;;;2392:103;;;:::i;52257:26::-;;;;;;56530:84;;;;;;:::i;:::-;;:::i;52092:26::-;;;;;;51965:25;;;;;;51666:35;;;;;;52224:26;;;;;;61730:63;;;:::i;1741:87::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;1741:87;;59887:570;;;;;;:::i;:::-;;:::i;51871:24::-;;;;;;52417:69;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;51809:24;;;;;;55972:98;;;;;;:::i;:::-;;:::i;52158:26::-;;;;;;56660:361;;;;;;:::i;:::-;;:::i;51486:25::-;;;;;-1:-1:-1;;;;;51486:25:0;;;56078:96;;;;;;:::i;:::-;;:::i;55866:94::-;;;;;;:::i;:::-;;:::i;2650:201::-;;;;;;:::i;:::-;;:::i;52125:26::-;;;;;;51840:24;;;;;;61086:635;;;;;;:::i;:::-;;:::i;56182:98::-;;;;;;:::i;:::-;;:::i;51997:25::-;;;;;;56408:114;;;;;;:::i;:::-;;:::i;57082:451::-;57173:24;57232:8;:15;57218:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57218:30:0;;57208:40;;57265:9;57260:243;57280:8;:15;57276:1;:19;57260:243;;;57313:15;57331:8;57340:1;57331:11;;;;;;;;:::i;:::-;;;;;;;57313:29;;57460:14;:23;57475:7;-1:-1:-1;;;;;57460:23:0;-1:-1:-1;;;;;57460:23:0;;;;;;;;;;;;:32;57484:7;57460:32;;;;;;;;;;;;57423:34;57432:12;57446:10;;57423:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;57374:18:0;;;;;;:9;:18;;;;;:36;;57402:7;57374:27;:36::i;:::-;:44;;57417:1;57374:44;;;57413:1;57374:44;57366:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;57353:7;57361:1;57353:10;;;;;;;;:::i;:::-;;;;;;;;;;:140;-1:-1:-1;57297:3:0;;;;:::i;:::-;;;;57260:243;;;;57082:451;;;;;:::o;60709:167::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;;;;;;;;;60813:55:::1;-1:-1:-1::0;;;;;60813:34:0;::::1;60848:10;60860:7:::0;60813:34:::1;:55::i;:::-;60709:167:::0;;:::o;57591:392::-;-1:-1:-1;;;;;57757:23:0;;57671:7;57757:23;;;:14;:23;;;;;;;;:32;;;;;;;;;57743:10;;57671:7;;57757:32;57720:34;;57729:12;;57720:8;:34::i;:::-;:69;57712:96;;;;-1:-1:-1;;;57712:96:0;;12352:2:1;57712:96:0;;;12334:21:1;12391:2;12371:18;;;12364:30;-1:-1:-1;;;12410:18:1;;;12403:44;12464:18;;57712:96:0;12150:338:1;57712:96:0;-1:-1:-1;;;;;57920:23:0;;;;;;:14;:23;;;;;;;;:32;;;;;;;;;57906:10;;57883:34;;57892:12;;57883:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;57834:18:0;;;;;;:9;:18;;;;;:36;;57862:7;57834:27;:36::i;:::-;:44;;57877:1;57834:44;;;57873:1;57834:44;57826:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;57817:136;57591:392;-1:-1:-1;;;;57591:392:0:o;56288:112::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56364:12:::1;:28:::0;;-1:-1:-1;;;;;;56364:28:0::1;-1:-1:-1::0;;;;;56364:28:0;;;::::1;::::0;;;::::1;::::0;;56288:112::o;60495:205::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;60585:12:::1;::::0;;60578:45:::1;::::0;-1:-1:-1;;;60578:45:0;;60617:4:::1;60578:45:::0;;::::1;5068:51:1::0;;;;60556:19:0::1;::::0;-1:-1:-1;;;;;60585:12:0;;::::1;::::0;60578:30:::1;::::0;5041:18:1;;60578:45:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60641:12;::::0;60556:67;;-1:-1:-1;60634:58:0::1;::::0;-1:-1:-1;;;;;60641:12:0::1;60668:10;60556:67:::0;60634:33:::1;:58::i;:::-;60545:155;60495:205::o:0;55547:80::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;55607:4:::1;:12:::0;55547:80::o;61802:67::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;61851:10:::1;:8;:10::i;:::-;61802:67::o:0;55739:119::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;55824:26:::1;55839:11:::0;55824:12:::1;:26;:::i;:::-;55811:10;:39:::0;-1:-1:-1;55739:119:0:o;59134:710::-;34463:7;;;;34717:9;34709:38;;;;-1:-1:-1;;;34709:38:0;;;;;;;:::i;:::-;31327:1:::1;31925:7;;:19;;31917:63;;;::::0;-1:-1:-1;;;31917:63:0;;11992:2:1;31917:63:0::1;::::0;::::1;11974:21:1::0;12031:2;12011:18;;;12004:30;12070:33;12050:18;;;12043:61;12121:18;;31917:63:0::1;11790:355:1::0;31917:63:0::1;31327:1;32058:7;:18:::0;;;59237:9:::2;::::0;::::2;;:17;;;59229:44;;;::::0;-1:-1:-1;;;59229:44:0;;10880:2:1;59229:44:0::2;::::0;::::2;10862:21:1::0;10919:2;10899:18;;;10892:30;-1:-1:-1;;;10938:18:1;;;10931:44;10992:18;;59229:44:0::2;10678:338:1::0;59229:44:0::2;59306:25;::::0;-1:-1:-1;;;;;59306:25:0::2;59292:10;:39;;59284:67;;;::::0;-1:-1:-1;;;59284:67:0;;8324:2:1;59284:67:0::2;::::0;::::2;8306:21:1::0;8363:2;8343:18;;;8336:30;-1:-1:-1;;;8382:18:1;;;8375:45;8437:18;;59284:67:0::2;8122:339:1::0;59284:67:0::2;59362:94;59400:10;59420:4;59440:8;;:15;;59427:10;;:28;;;;:::i;:::-;59369:12;::::0;-1:-1:-1;;;;;59369:12:0::2;::::0;59362:94;;:37:::2;:94::i;:::-;59467:96;59506:10;59526:4;59547:8;;:15;;59533:11;;:29;;;;:::i;:::-;59474:13;::::0;-1:-1:-1;;;;;59474:13:0::2;::::0;59467:96;;:38:::2;:96::i;:::-;59574:22;59587:8;;59574:12;:22::i;:::-;59615:9;59610:227;59626:19:::0;;::::2;59610:227;;;59675:25;::::0;-1:-1:-1;;;;;59675:25:0::2;59667:51;59719:10;59738:4;59744:8:::0;;59753:1;59744:11;;::::2;;;;;:::i;:::-;59667:92;::::0;-1:-1:-1;;;;;;59667:92:0::2;::::0;;;;;;-1:-1:-1;;;;;5833:15:1;;;59667:92:0::2;::::0;::::2;5815:34:1::0;5885:15;;;;5865:18;;;5858:43;-1:-1:-1;59744:11:0::2;::::0;;::::2;;;5917:18:1::0;;;5910:34;5980:3;5960:18;;;5953:31;-1:-1:-1;6000:19:1;;;5993:30;6040:19;;59667:92:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;59774:38;59800:8;;59809:1;59800:11;;;;;;;:::i;:::-;59784:10;59774:21;::::0;;;:9:::2;59800:11;59774:21:::0;;;;;;;;59800:11;::::2;;;::::0;-1:-1:-1;59774:25:0::2;:38::i;:::-;-1:-1:-1::0;59647:3:0;::::2;::::0;::::2;:::i;:::-;;;;59610:227;;;-1:-1:-1::0;;31283:1:0::1;32237:22:::0;;-1:-1:-1;59134:710:0:o;58472:618::-;34463:7;;;;34717:9;34709:38;;;;-1:-1:-1;;;34709:38:0;;;;;;;:::i;:::-;58553:14:::1;58577:16:::0;58596:34:::1;58605:12;58619:10;;58596:8;:34::i;:::-;58577:53;;58742:9;58737:179;58753:19:::0;;::::1;58737:179;;;58800:45;58821:10;58833:8;;58842:1;58833:11;;;;;;;:::i;:::-;;;;;;;58800:20;:45::i;:::-;58790:55;::::0;;::::1;:::i;:::-;58871:10;58856:26;::::0;;;:14:::1;:26;::::0;;;;58790:55;;-1:-1:-1;58898:8:0;;58856:26;58883:8;;58892:1;58883:11;;::::1;;;;;:::i;:::-;;;;;;;58856:39;;;;;;;;;;;:50;;;;58774:3;;;;;:::i;:::-;;;;58737:179;;;-1:-1:-1::0;58927:10:0;;58924:161:::1;;58950:24;58955:18;58963:6;58971:1;58955:7;:18::i;:::-;58950:4;:24::i;:::-;58994:19;59002:6;59010:2;58994:7;:19::i;:::-;59031:12;::::0;58985:28;;-1:-1:-1;59024:53:0::1;::::0;-1:-1:-1;;;;;59031:12:0::1;59058:10;58985:28:::0;59024:33:::1;:53::i;:::-;58544:546;;58472:618:::0;;:::o;2392:103::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;2457:30:::1;2484:1;2457:18;:30::i;56530:84::-:0;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56590:9:::1;:16:::0;;-1:-1:-1;;56590:16:0::1;::::0;::::1;;::::0;;;::::1;::::0;;56530:84::o;61730:63::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;61777:8:::1;:6;:8::i;59887:570::-:0;34463:7;;;;34717:9;34709:38;;;;-1:-1:-1;;;34709:38:0;;;;;;;:::i;:::-;31327:1:::1;31925:7;;:19;;31917:63;;;::::0;-1:-1:-1;;;31917:63:0;;11992:2:1;31917:63:0::1;::::0;::::1;11974:21:1::0;12031:2;12011:18;;;12004:30;12070:33;12050:18;;;12043:61;12121:18;;31917:63:0::1;11790:355:1::0;31917:63:0::1;31327:1;32058:7;:18:::0;60048:10:::2;::::0;59983:94:::2;::::0;60021:10:::2;::::0;60041:4:::2;::::0;60048:28:::2;::::0;60061:8;;60048:28:::2;:::i;59983:94::-;60088:22;60101:8;;60088:12;:22::i;:::-;60126:9;60121:329;60137:19:::0;;::::2;60121:329;;;60187:43;60218:8;;60227:1;60218:11;;;;;;;:::i;:::-;60197:10;60187:21;::::0;;;:9:::2;60218:11;60187:21:::0;;;;;;;;60218:11;::::2;;;::::0;-1:-1:-1;60187:30:0::2;:43::i;:::-;60178:84;;;::::0;-1:-1:-1;;;60178:84:0;;10523:2:1;60178:84:0::2;::::0;::::2;10505:21:1::0;10562:2;10542:18;;;10535:30;10601;10581:18;;;10574:58;10649:18;;60178:84:0::2;10321:352:1::0;60178:84:0::2;60277:41;60306:8;;60315:1;60306:11;;;;;;;:::i;:::-;60287:10;60277:21;::::0;;;:9:::2;60306:11;60277:21:::0;;;;;;;;60306:11;::::2;;;::::0;-1:-1:-1;60277:28:0::2;:41::i;:::-;-1:-1:-1::0;60341:25:0::2;::::0;-1:-1:-1;;;;;60341:25:0::2;60333:51;60393:4;60400:10;60411:8:::0;;60420:1;60411:11;;::::2;;;;;:::i;:::-;60333:93;::::0;-1:-1:-1;;;;;;60333:93:0::2;::::0;;;;;;-1:-1:-1;;;;;5833:15:1;;;60333:93:0::2;::::0;::::2;5815:34:1::0;5885:15;;;;5865:18;;;5858:43;-1:-1:-1;60411:11:0::2;::::0;;::::2;;;5917:18:1::0;;;5910:34;5980:3;5960:18;;;5953:31;-1:-1:-1;6000:19:1;;;5993:30;6040:19;;60333:93:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;60158:3;;;;;:::i;:::-;;;;60121:329;;55972:98:::0;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56041:10:::1;:21:::0;;-1:-1:-1;;;;;;56041:21:0::1;-1:-1:-1::0;;;;;56041:21:0;;;::::1;::::0;;;::::1;::::0;;55972:98::o;56660:361::-;-1:-1:-1;;;;;56788:18:0;;56745:40;56788:18;;;:9;:18;;;;;56718:16;;56858:19;56788:18;56858:17;:19::i;:::-;56843:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56843:35:0;;56815:63;;56895:9;56890:97;56910:19;:10;:17;:19::i;:::-;56906:1;:23;56890:97;;;56961:16;:10;56975:1;56961:13;:16::i;:::-;56947:8;56956:1;56947:11;;;;;;;;:::i;:::-;;;;;;;;;;:30;56931:3;;;;:::i;:::-;;;;56890:97;;;-1:-1:-1;57005:8:0;56660:361;-1:-1:-1;;;56660:361:0:o;56078:96::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56146:10:::1;:20:::0;56078:96::o;55866:94::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;55933:8:::1;:19:::0;;-1:-1:-1;;;;;;55933:19:0::1;-1:-1:-1::0;;;;;55933:19:0;;;::::1;::::0;;;::::1;::::0;;55866:94::o;2650:201::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2739:22:0;::::1;2731:73;;;::::0;-1:-1:-1;;;2731:73:0;;8668:2:1;2731:73:0::1;::::0;::::1;8650:21:1::0;8707:2;8687:18;;;8680:30;8746:34;8726:18;;;8719:62;-1:-1:-1;;;8797:18:1;;;8790:36;8843:19;;2731:73:0::1;8466:402:1::0;2731:73:0::1;2815:28;2834:8;2815:18;:28::i;61086:635::-:0;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;61171:8:::1;:15;61190:2;61171:21;61163:41;;;::::0;-1:-1:-1;;;61163:41:0;;10188:2:1;61163:41:0::1;::::0;::::1;10170:21:1::0;10227:1;10207:18;;;10200:29;-1:-1:-1;;;10245:18:1;;;10238:37;10292:18;;61163:41:0::1;9986:330:1::0;61163:41:0::1;61224:8;61233:1;61224:11;;;;;;;;:::i;:::-;;;;;;;61216:5;:19;;;;61255:8;61264:1;61255:11;;;;;;;;:::i;:::-;;;;;;;61247:5;:19;;;;61286:8;61295:1;61286:11;;;;;;;;:::i;:::-;;;;;;;61278:5;:19;;;;61317:8;61326:1;61317:11;;;;;;;;:::i;:::-;;;;;;;61309:5;:19;;;;61348:8;61357:1;61348:11;;;;;;;;:::i;:::-;;;;;;;61340:5;:19;;;;61379:8;61388:1;61379:11;;;;;;;;:::i;:::-;;;;;;;61371:5;:19;;;;61410:8;61419:1;61410:11;;;;;;;;:::i;:::-;;;;;;;61402:5;:19;;;;61441:8;61450:1;61441:11;;;;;;;;:::i;:::-;;;;;;;61433:5;:19;;;;61472:8;61481:1;61472:11;;;;;;;;:::i;:::-;;;;;;;61464:5;:19;;;;61504:8;61513:1;61504:11;;;;;;;;:::i;:::-;;;;;;;61495:6;:20;;;;61536:8;61545:2;61536:12;;;;;;;;:::i;:::-;;;;;;;61527:6;:21;;;;61569:8;61578:2;61569:12;;;;;;;;:::i;:::-;;;;;;;61560:6;:21;;;;61602:8;61611:2;61602:12;;;;;;;;:::i;:::-;;;;;;;61593:6;:21;;;;61635:8;61644:2;61635:12;;;;;;;;:::i;:::-;;;;;;;61626:6;:21;;;;61668:8;61677:2;61668:12;;;;;;;;:::i;:::-;;;;;;;61659:6;:21;;;;61701:8;61710:2;61701:12;;;;;;;;:::i;:::-;;;;;;;61692:6;:21;;;;61086:635:::0;:::o;56182:98::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56251:11:::1;:21:::0;56182:98::o;56408:114::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56485:13:::1;:29:::0;;-1:-1:-1;;;;;;56485:29:0::1;-1:-1:-1::0;;;;;56485:29:0;;;::::1;::::0;;;::::1;::::0;;56408:114::o;32619:106::-;32677:7;32708:1;32704;:5;:13;;32716:1;32704:13;;;32712:1;32704:13;32697:20;32619:106;-1:-1:-1;;;32619:106:0:o;28021:146::-;28098:4;21081:19;;;:12;;;:19;;;;;;:24;;28122:37;20984:129;47194:211;47338:58;;-1:-1:-1;;;;;6262:32:1;;47338:58:0;;;6244:51:1;6311:18;;;6304:34;;;47311:86:0;;47331:5;;-1:-1:-1;;;47361:23:0;6217:18:1;;47338:58:0;;;;-1:-1:-1;;47338:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;47338:58:0;-1:-1:-1;;;;;;47338:58:0;;;;;;;;;;47311:19;:86::i;:::-;47194:211;;;:::o;35451:120::-;34463:7;;;;34987:41;;;;-1:-1:-1;;;34987:41:0;;7975:2:1;34987:41:0;;;7957:21:1;8014:2;7994:18;;;7987:30;-1:-1:-1;;;8033:18:1;;;8026:50;8093:18;;34987:41:0;7773:344:1;34987:41:0;35510:7:::1;:15:::0;;-1:-1:-1;;35510:15:0::1;::::0;;35541:22:::1;689:10:::0;35550:12:::1;35541:22;::::0;-1:-1:-1;;;;;5086:32:1;;;5068:51;;5056:2;5041:18;35541:22:0::1;;;;;;;35451:120::o:0;47413:248::-;47584:68;;-1:-1:-1;;;;;5388:15:1;;;47584:68:0;;;5370:34:1;5440:15;;5420:18;;;5413:43;5472:18;;;5465:34;;;47557:96:0;;47577:5;;-1:-1:-1;;;47607:27:0;5305:18:1;;47584:68:0;5130:375:1;27491:131:0;27558:4;27582:32;27587:3;27607:5;27582:4;:32::i;57992:433::-;-1:-1:-1;;;;;58160:23:0;;58074:7;58160:23;;;:14;:23;;;;;;;;:32;;;;;;;;;58146:10;;58074:7;;58160:32;58123:34;;58132:12;;58123:8;:34::i;:::-;:69;58115:96;;;;-1:-1:-1;;;58115:96:0;;12352:2:1;58115:96:0;;;12334:21:1;12391:2;12371:18;;;12364:30;-1:-1:-1;;;12410:18:1;;;12403:44;12464:18;;58115:96:0;12150:338:1;58115:96:0;-1:-1:-1;;;;;58323:23:0;;;;;;:14;:23;;;;;;;;:32;;;;;;;;;58309:10;;58286:34;;58295:12;;58286:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;58237:18:0;;;;;;:9;:18;;;;;:36;;58265:7;58237:27;:36::i;:::-;:44;;58280:1;58237:44;;;58276:1;58237:44;58229:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;58220:136;;58372:45;58380:6;58388:28;58408:7;58388:19;:28::i;:::-;55213:7;;55296:3;55276:17;55286:7;55276;:17;:::i;:::-;:23;;;;:::i;52960:90::-;53017:12;;;53011:33;;-1:-1:-1;;;53011:33:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53017:12:0;;53011:24;;12612:18:1;;53011:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52960:90;:::o;3011:191::-;3085:16;3104:6;;-1:-1:-1;;;;;3121:17:0;;;-1:-1:-1;;;;;;3121:17:0;;;;;;3154:40;;3104:6;;;;;;;3154:40;;3085:16;3154:40;3074:128;3011:191;:::o;35192:118::-;34463:7;;;;34717:9;34709:38;;;;-1:-1:-1;;;34709:38:0;;;;;;;:::i;:::-;35252:7:::1;:14:::0;;-1:-1:-1;;35252:14:0::1;35262:4;35252:14;::::0;;35282:20:::1;35289:12;689:10:::0;;609:98;27798:137;27868:4;27892:35;27900:3;27920:5;27892:7;:35::i;28253:114::-;28313:7;28340:19;28348:3;21282:18;;21199:109;28721:137;28792:7;28827:22;28831:3;28843:5;28827:3;:22::i;49767:716::-;50191:23;50217:69;50245:4;50217:69;;;;;;;;;;;;;;;;;50225:5;-1:-1:-1;;;;;50217:27:0;;;:69;;;;;:::i;:::-;50301:17;;50191:95;;-1:-1:-1;50301:21:0;50297:179;;50398:10;50387:30;;;;;;;;;;;;:::i;:::-;50379:85;;;;-1:-1:-1;;;50379:85:0;;11581:2:1;50379:85:0;;;11563:21:1;11620:2;11600:18;;;11593:30;11659:34;11639:18;;;11632:62;-1:-1:-1;;;11710:18:1;;;11703:40;11760:19;;50379:85:0;11379:406:1;18888:414:0;18951:4;21081:19;;;:12;;;:19;;;;;;18968:327;;-1:-1:-1;19011:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;19194:18;;19172:19;;;:12;;;:19;;;;;;:40;;;;19227:11;;18968:327;-1:-1:-1;19278:5:0;19271:12;;53055:2061;53166:10;;53148:61;;-1:-1:-1;;;53148:61:0;;;;;12639:25:1;;;53120:15:0;;-1:-1:-1;;;;;53166:10:0;;53148:51;;12612:18:1;;53148:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53213:1;53148:66;53145:1967;;;53239:25;;53228:57;;-1:-1:-1;;;53228:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53239:25:0;;;;53228:47;;12612:18:1;;53228:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53289:1;53228:62;53225:416;;;-1:-1:-1;;53310:5:0;;;53055:2061::o;53225:416::-;53345:25;;53334:57;;-1:-1:-1;;;53334:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53345:25:0;;;;53334:47;;12612:18:1;;53334:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53395:1;53334:62;53331:310;;;-1:-1:-1;;53415:5:0;;;53055:2061::o;53331:310::-;53450:25;;53439:57;;-1:-1:-1;;;53439:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53450:25:0;;;;53439:47;;12612:18:1;;53439:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53500:1;53439:62;53436:205;;;-1:-1:-1;;53520:5:0;;;53055:2061::o;53436:205::-;53555:25;;53544:57;;-1:-1:-1;;;53544:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53555:25:0;;;;53544:47;;12612:18:1;;53544:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53605:1;53544:62;53541:100;;;-1:-1:-1;;53625:5:0;;;53055:2061::o;53541:100::-;53055:2061;;;:::o;53145:1967::-;53676:10;;53658:61;;-1:-1:-1;;;53658:61:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53676:10:0;;;;53658:51;;12612:18:1;;53658:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53723:1;53658:66;53655:1457;;;53749:25;;53738:57;;-1:-1:-1;;;53738:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53749:25:0;;;;53738:47;;12612:18:1;;53738:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53799:1;53738:62;53735:419;;;-1:-1:-1;;53820:5:0;;;53055:2061::o;53735:419::-;53855:25;;53844:57;;-1:-1:-1;;;53844:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53855:25:0;;;;53844:47;;12612:18:1;;53844:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53905:1;53844:62;53841:313;;;-1:-1:-1;;53925:6:0;;;53055:2061::o;53841:313::-;53961:25;;53950:57;;-1:-1:-1;;;53950:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;53961:25:0;;;;53950:47;;12612:18:1;;53950:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54011:1;53950:62;53947:207;;;-1:-1:-1;;54031:6:0;;;53055:2061::o;53947:207::-;54067:25;;54056:57;;-1:-1:-1;;;54056:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54067:25:0;;;;54056:47;;12612:18:1;;54056:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54117:1;54056:62;54053:101;;;-1:-1:-1;;54137:6:0;;;53055:2061::o;53655:1457::-;54189:10;;54171:61;;-1:-1:-1;;;54171:61:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54189:10:0;;;;54171:51;;12612:18:1;;54171:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54236:1;54171:66;54168:944;;;54262:25;;54251:57;;-1:-1:-1;;;54251:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54262:25:0;;;;54251:47;;12612:18:1;;54251:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54312:1;54251:62;54248:420;;;-1:-1:-1;;54333:6:0;;;53055:2061::o;54248:420::-;54369:25;;54358:57;;-1:-1:-1;;;54358:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54369:25:0;;;;54358:47;;12612:18:1;;54358:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54419:1;54358:62;54355:313;;;-1:-1:-1;;54439:6:0;;;53055:2061::o;54355:313::-;54475:25;;54464:57;;-1:-1:-1;;;54464:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54475:25:0;;;;54464:47;;12612:18:1;;54464:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54525:1;54464:62;54461:207;;;-1:-1:-1;;54545:6:0;;;53055:2061::o;54461:207::-;54581:25;;54570:57;;-1:-1:-1;;;54570:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54581:25:0;;;;54570:47;;12612:18:1;;54570:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54631:1;54570:62;54567:101;;;-1:-1:-1;;54651:6:0;;;53055:2061::o;54168:944::-;54706:25;;54695:57;;-1:-1:-1;;;54695:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54706:25:0;;;;54695:47;;12612:18:1;;54695:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54756:1;54695:62;54692:415;;;-1:-1:-1;;54777:5:0;;;53055:2061::o;54692:415::-;54812:25;;54801:57;;-1:-1:-1;;;54801:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54812:25:0;;;;54801:47;;12612:18:1;;54801:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54862:1;54801:62;54798:309;;;-1:-1:-1;;54882:5:0;;;53055:2061::o;54798:309::-;54917:25;;54906:57;;-1:-1:-1;;;54906:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;54917:25:0;;;;54906:47;;12612:18:1;;54906:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54967:1;54906:62;54903:204;;;-1:-1:-1;;54987:5:0;;;53055:2061::o;54903:204::-;55022:25;;55011:57;;-1:-1:-1;;;55011:57:0;;;;;12639:25:1;;;-1:-1:-1;;;;;55022:25:0;;;;55011:47;;12612:18:1;;55011:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55072:1;55011:62;55008:99;;;-1:-1:-1;;55092:5:0;;;53055:2061::o;19478:1420::-;19544:4;19683:19;;;:12;;;:19;;;;;;19719:15;;19715:1176;;20094:21;20118:14;20131:1;20118:10;:14;:::i;:::-;20167:18;;20094:38;;-1:-1:-1;20147:17:0;;20167:22;;20188:1;;20167:22;:::i;:::-;20147:42;;20223:13;20210:9;:26;20206:405;;20257:17;20277:3;:11;;20289:9;20277:22;;;;;;;;:::i;:::-;;;;;;;;;20257:42;;20431:9;20402:3;:11;;20414:13;20402:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;20516:23;;;:12;;;:23;;;;;:36;;;20206:405;20692:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;20787:3;:12;;:19;20800:5;20787:19;;;;;;;;;;;20780:26;;;20830:4;20823:11;;;;;;;19715:1176;20874:5;20867:12;;;;;21662:120;21729:7;21756:3;:11;;21768:5;21756:18;;;;;;;;:::i;:::-;;;;;;;;;21749:25;;21662:120;;;;:::o;42145:229::-;42282:12;42314:52;42336:6;42344:4;42350:1;42353:12;42282;-1:-1:-1;;;;;39695:19:0;;;43552:60;;;;-1:-1:-1;;;43552:60:0;;11223:2:1;43552:60:0;;;11205:21:1;11262:2;11242:18;;;11235:30;11301:31;11281:18;;;11274:59;11350:18;;43552:60:0;11021:353:1;43552:60:0;43626:12;43640:23;43667:6;-1:-1:-1;;;;;43667:11:0;43686:5;43693:4;43667:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43625:73;;;;43716:51;43733:7;43742:10;43754:12;43716:16;:51::i;:::-;43709:58;43265:510;-1:-1:-1;;;;;;;43265:510:0:o;45951:712::-;46101:12;46130:7;46126:530;;;-1:-1:-1;46161:10:0;46154:17;;46126:530;46275:17;;:21;46271:374;;46473:10;46467:17;46534:15;46521:10;46517:2;46513:19;46506:44;46271:374;46616:12;46609:20;;-1:-1:-1;;;46609:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;192:913;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;402:18;439:2;435;432:10;429:36;;;445:18;;:::i;:::-;491:2;488:1;484:10;523:2;517:9;586:2;582:7;577:2;573;569:11;565:25;557:6;553:38;641:6;629:10;626:22;621:2;609:10;606:18;603:46;600:72;;;652:18;;:::i;:::-;688:2;681:22;738:18;;;772:15;;;;-1:-1:-1;807:15:1;;;841;;;837:24;;834:33;-1:-1:-1;831:53:1;;;880:1;877;870:12;831:53;902:1;893:10;;912:163;926:2;923:1;920:9;912:163;;;983:17;;971:30;;1021:12;;;;944:1;937:9;;;;;1053:12;;912:163;;;-1:-1:-1;1093:6:1;192:913;-1:-1:-1;;;;;;;192:913:1:o;1110:186::-;1169:6;1222:2;1210:9;1201:7;1197:23;1193:32;1190:52;;;1238:1;1235;1228:12;1190:52;1261:29;1280:9;1261:29;:::i;1301:808::-;1398:6;1406;1414;1422;1430;1483:3;1471:9;1462:7;1458:23;1454:33;1451:53;;;1500:1;1497;1490:12;1451:53;1523:29;1542:9;1523:29;:::i;:::-;1513:39;;1571:38;1605:2;1594:9;1590:18;1571:38;:::i;:::-;1561:48;;1656:2;1645:9;1641:18;1628:32;1618:42;;1711:2;1700:9;1696:18;1683:32;1734:18;1775:2;1767:6;1764:14;1761:34;;;1791:1;1788;1781:12;1761:34;1829:6;1818:9;1814:22;1804:32;;1874:7;1867:4;1863:2;1859:13;1855:27;1845:55;;1896:1;1893;1886:12;1845:55;1936:2;1923:16;1962:2;1954:6;1951:14;1948:34;;;1978:1;1975;1968:12;1948:34;2023:7;2018:2;2009:6;2005:2;2001:15;1997:24;1994:37;1991:57;;;2044:1;2041;2034:12;1991:57;1301:808;;;;-1:-1:-1;1301:808:1;;-1:-1:-1;2075:2:1;2067:11;;2097:6;1301:808;-1:-1:-1;;;1301:808:1:o;2114:422::-;2207:6;2215;2268:2;2256:9;2247:7;2243:23;2239:32;2236:52;;;2284:1;2281;2274:12;2236:52;2307:29;2326:9;2307:29;:::i;:::-;2297:39;;2387:2;2376:9;2372:18;2359:32;2414:18;2406:6;2403:30;2400:50;;;2446:1;2443;2436:12;2400:50;2469:61;2522:7;2513:6;2502:9;2498:22;2469:61;:::i;:::-;2459:71;;;2114:422;;;;;:::o;2541:254::-;2609:6;2617;2670:2;2658:9;2649:7;2645:23;2641:32;2638:52;;;2686:1;2683;2676:12;2638:52;2709:29;2728:9;2709:29;:::i;:::-;2699:39;2785:2;2770:18;;;;2757:32;;-1:-1:-1;;;2541:254:1:o;2800:615::-;2886:6;2894;2947:2;2935:9;2926:7;2922:23;2918:32;2915:52;;;2963:1;2960;2953:12;2915:52;3003:9;2990:23;3032:18;3073:2;3065:6;3062:14;3059:34;;;3089:1;3086;3079:12;3059:34;3127:6;3116:9;3112:22;3102:32;;3172:7;3165:4;3161:2;3157:13;3153:27;3143:55;;3194:1;3191;3184:12;3143:55;3234:2;3221:16;3260:2;3252:6;3249:14;3246:34;;;3276:1;3273;3266:12;3246:34;3329:7;3324:2;3314:6;3311:1;3307:14;3303:2;3299:23;3295:32;3292:45;3289:65;;;3350:1;3347;3340:12;3289:65;3381:2;3373:11;;;;;3403:6;;-1:-1:-1;2800:615:1;;-1:-1:-1;;;;2800:615:1:o;3420:348::-;3504:6;3557:2;3545:9;3536:7;3532:23;3528:32;3525:52;;;3573:1;3570;3563:12;3525:52;3613:9;3600:23;3646:18;3638:6;3635:30;3632:50;;;3678:1;3675;3668:12;3632:50;3701:61;3754:7;3745:6;3734:9;3730:22;3701:61;:::i;3773:241::-;3829:6;3882:2;3870:9;3861:7;3857:23;3853:32;3850:52;;;3898:1;3895;3888:12;3850:52;3937:9;3924:23;3956:28;3978:5;3956:28;:::i;4019:245::-;4086:6;4139:2;4127:9;4118:7;4114:23;4110:32;4107:52;;;4155:1;4152;4145:12;4107:52;4187:9;4181:16;4206:28;4228:5;4206:28;:::i;4269:180::-;4328:6;4381:2;4369:9;4360:7;4356:23;4352:32;4349:52;;;4397:1;4394;4387:12;4349:52;-1:-1:-1;4420:23:1;;4269:180;-1:-1:-1;4269:180:1:o;4454:184::-;4524:6;4577:2;4565:9;4556:7;4552:23;4548:32;4545:52;;;4593:1;4590;4583:12;4545:52;-1:-1:-1;4616:16:1;;4454:184;-1:-1:-1;4454:184:1:o;4643:274::-;4772:3;4810:6;4804:13;4826:53;4872:6;4867:3;4860:4;4852:6;4848:17;4826:53;:::i;:::-;4895:16;;;;;4643:274;-1:-1:-1;;4643:274:1:o;6349:632::-;6520:2;6572:21;;;6642:13;;6545:18;;;6664:22;;;6491:4;;6520:2;6743:15;;;;6717:2;6702:18;;;6491:4;6786:169;6800:6;6797:1;6794:13;6786:169;;;6861:13;;6849:26;;6930:15;;;;6895:12;;;;6822:1;6815:9;6786:169;;;-1:-1:-1;6972:3:1;;6349:632;-1:-1:-1;;;;;;6349:632:1:o;7385:383::-;7534:2;7523:9;7516:21;7497:4;7566:6;7560:13;7609:6;7604:2;7593:9;7589:18;7582:34;7625:66;7684:6;7679:2;7668:9;7664:18;7659:2;7651:6;7647:15;7625:66;:::i;:::-;7752:2;7731:15;-1:-1:-1;;7727:29:1;7712:45;;;;7759:2;7708:54;;7385:383;-1:-1:-1;;7385:383:1:o;9280:340::-;9482:2;9464:21;;;9521:2;9501:18;;;9494:30;-1:-1:-1;;;9555:2:1;9540:18;;9533:46;9611:2;9596:18;;9280:340::o;9625:356::-;9827:2;9809:21;;;9846:18;;;9839:30;9905:34;9900:2;9885:18;;9878:62;9972:2;9957:18;;9625:356::o;12675:128::-;12715:3;12746:1;12742:6;12739:1;12736:13;12733:39;;;12752:18;;:::i;:::-;-1:-1:-1;12788:9:1;;12675:128::o;12808:217::-;12848:1;12874;12864:132;;12918:10;12913:3;12909:20;12906:1;12899:31;12953:4;12950:1;12943:15;12981:4;12978:1;12971:15;12864:132;-1:-1:-1;13010:9:1;;12808:217::o;13030:168::-;13070:7;13136:1;13132;13128:6;13124:14;13121:1;13118:21;13113:1;13106:9;13099:17;13095:45;13092:71;;;13143:18;;:::i;:::-;-1:-1:-1;13183:9:1;;13030:168::o;13203:125::-;13243:4;13271:1;13268;13265:8;13262:34;;;13276:18;;:::i;:::-;-1:-1:-1;13313:9:1;;13203:125::o;13333:258::-;13405:1;13415:113;13429:6;13426:1;13423:13;13415:113;;;13505:11;;;13499:18;13486:11;;;13479:39;13451:2;13444:10;13415:113;;;13546:6;13543:1;13540:13;13537:48;;;-1:-1:-1;;13581:1:1;13563:16;;13556:27;13333:258::o;13596:135::-;13635:3;-1:-1:-1;;13656:17:1;;13653:43;;;13676:18;;:::i;:::-;-1:-1:-1;13723:1:1;13712:13;;13596:135::o;13736:127::-;13797:10;13792:3;13788:20;13785:1;13778:31;13828:4;13825:1;13818:15;13852:4;13849:1;13842:15;13868:127;13929:10;13924:3;13920:20;13917:1;13910:31;13960:4;13957:1;13950:15;13984:4;13981:1;13974:15;14000:127;14061:10;14056:3;14052:20;14049:1;14042:31;14092:4;14089:1;14082:15;14116:4;14113:1;14106:15;14132:127;14193:10;14188:3;14184:20;14181:1;14174:31;14224:4;14221:1;14214:15;14248:4;14245:1;14238:15;14264:118;14350:5;14343:13;14336:21;14329:5;14326:32;14316:60;;14372:1;14369;14362:12

ipfs://82c2b58c6b6339435dc685a397e4b7db4486d18709120b8d3a1a83dd9a818b0d