Token

/**
 *Submitted for verification at Etherscan.io 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 = 4;
    uint256 public rate2 = 7;
    uint256 public rate3 = 15;
    uint256 public rate4 = 18;
    uint256 public rate5 = 33;
    uint256 public rate6 = 39;
    uint256 public rate7 = 45;
    uint256 public rate8 = 51;
    uint256 public rate9 = 73;
    uint256 public rate10 = 82;
    uint256 public rate11 = 91;
    uint256 public rate12 = 100;
 
    
    // mappings 
    mapping(address => EnumerableSet.UintSet) private _deposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;
    mapping(uint256 => bool) public uber;

   
    
 
    constructor(address _stakingDestinationAddress, uint256 _rate, uint256 _expiration, address _erc20Address, address _erc20Address2, address _minimarket, address _treasury) {
        stakingDestinationAddress = _stakingDestinationAddress;
        rate = _rate;
        expiration = block.number + _expiration;
        erc20Address = _erc20Address;
        erc20Address2 = _erc20Address2;
        MiniMarket = _minimarket;
        treasury = _treasury;
        _pause();

    }


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

  
 function calcGenesisRateGuinea(uint256 _tokenId) internal returns (uint256 fusRate){
      if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 1){
       return rate1;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 2){
       return rate2;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 3){
       return rate3;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 4){
       return rate4;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 5){
       return rate5;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 6){
       return rate6;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 7){
       return rate7;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 8){
       return rate8;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 9){
       return rate9;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 10){
       return rate10;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 11){
       return rate11;
      }else if(IGenesisLevelGuinea(MiniMarket).genesisLevelCheckGuinea(_tokenId) == 12){
       return rate12;
      }else {
       return 1;
      }
  }

  function calcGenesisRateChilla(uint256 _tokenId) internal returns (uint256 fusRate){
      if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 1){
       return rate1;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 2){
       return rate2;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 3){
       return rate3;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 4){
       return rate4;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 5){
       return rate5;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 6){
       return rate6;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 7){
       return rate7;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 8){
       return rate8;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 9){
       return rate9;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 10){
       return rate10;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 11){
       return rate11;
      }else if(IGenesisLevelChilla(MiniMarket).genesisLevelCheckChilla(_tokenId) == 12){
       return rate12;
      }else {
       return 1;
      }
  }

    // gets x %
   function calcTax(uint256 _amount, uint256 taxRate) internal 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 setUber(uint256[] calldata _users) public onlyOwner() {
    for (uint256 i = 0; i < _users.length; i++){
        uber[_users[i]] = true;
    }
  }

   function clearUber(uint256[] calldata _users) public onlyOwner() {
    for (uint256 i = 0; i < _users.length; i++){
        uber[_users[i]] = false;
    }
  }

    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, calcGenesisRateGuinea(tokenId));
    }
 
    //reward claim function - Tested
    function claimRewards(uint256[] calldata tokenIds) public whenNotPaused {
      uint256 reward; 
      uint256 blockCur = Math.min(block.number, expiration);
    
      bool uberDiscount = false;
      //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(uber[tokenIds[i]] == true){
          uberDiscount = true; 
        }
      }
      if(reward > 0) {
      //uber discount
      if(uberDiscount == true){
        for (uint256 i; i < tokenIds.length; i++){
        require(uber[tokenIds[i]] == true, "Not Uber");
        }
        IERC20(erc20Address).safeTransfer(msg.sender, reward);
        uberDiscount = false; 
      // regular bonding claim tax 
      }else {
        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 == 12, "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];
    }

    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"},{"internalType":"address","name":"_treasury","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":"_users","type":"uint256[]"}],"name":"clearUber","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":"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":"uint256[]","name":"_users","type":"uint256[]"}],"name":"setUber","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":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uber","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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"}]

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

000000000000000000000000ec2e4e100b26015dc7dee337b4dc5decfe28db580000000000000000000000000000000000000000000000000008626851ab800000000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71cb32433e00000000000000000000000057976c467608983513c9355238dc6de1b1abbcca0000000000000000000000000dfc2329fa20c3be8def2ad64474512f8477ed6a000000000000000000000000ef5af209ae811fb759c0d863d7f6ec1af3a0a98600000000000000000000000041f38ff9faf1f28c6db65f2c90ace2068725acd0

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0xec2e4e100b26015dc7dee337b4dc5decfe28db58
Arg [1] : _rate (uint256): 2360000000000000
Arg [2] : _expiration (uint256): 1111111111111111111111111111111111111111111111111111179649854
Arg [3] : _erc20Address (address): 0x57976c467608983513c9355238dc6de1b1abbcca
Arg [4] : _erc20Address2 (address): 0x0dfc2329fa20c3be8def2ad64474512f8477ed6a
Arg [5] : _minimarket (address): 0xef5af209ae811fb759c0d863d7f6ec1af3a0a986
Arg [6] : _treasury (address): 0x41f38ff9faf1f28c6db65f2c90ace2068725acd0

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000ec2e4e100b26015dc7dee337b4dc5decfe28db58
Arg [1] : 0000000000000000000000000000000000000000000000000008626851ab8000
Arg [2] : 00000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71cb32433e
Arg [3] : 00000000000000000000000057976c467608983513c9355238dc6de1b1abbcca
Arg [4] : 0000000000000000000000000dfc2329fa20c3be8def2ad64474512f8477ed6a
Arg [5] : 000000000000000000000000ef5af209ae811fb759c0d863d7f6ec1af3a0a986
Arg [6] : 00000000000000000000000041f38ff9faf1f28c6db65f2c90ace2068725acd0

51079:12297:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51343:40;;;;;-1:-1:-1;;;;;51343:40:0;;;;;;-1:-1:-1;;;;;5086:32:1;;;5068:51;;5056:2;5041:18;51343:40:0;;;;;;;;58268:451;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;62346:167::-;;;;;;:::i;:::-;;:::i;:::-;;62522:173;;;;;;:::i;:::-;-1:-1:-1;;;62522:173:0;;;;;;;;;;;-1:-1:-1;;;;;;7340:33:1;;;7322:52;;7310:2;7295:18;62522:173:0;7178:202:1;51954:25:0;;;;;;;;;12975::1;;;12963:2;12948:18;51954:25:0;12829:177:1;58777:392:0;;;;;;:::i;:::-;;:::i;52050:25::-;;;;;;51390:27;;;;;-1:-1:-1;;;;;51390:27:0;;;57474:112;;;;;;:::i;:::-;;:::i;62132:205::-;;;:::i;51613:19::-;;;;;;52383:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;7151:14:1;;7144:22;7126:41;;7114:2;7099:18;52383:36:0;6986:187:1;56397:80:0;;;;;;:::i;:::-;;:::i;63306:67::-;;;:::i;51424:28::-;;;;;-1:-1:-1;;;;;51424:28:0;;;52082:25;;;;;;51527;;;;;;51711:36;;;;;;56589:119;;;;;;:::i;:::-;;:::i;60771:710::-;;;;;;:::i;:::-;;:::i;34392:86::-;34463:7;;;;34392:86;;51922:25;;;;;;59660:1067;;;;;;:::i;:::-;;:::i;51459:23::-;;;;;-1:-1:-1;;;;;51459:23:0;;;2392:103;;;:::i;56716:159::-;;;;;;:::i;:::-;;:::i;57716:84::-;;;;;;:::i;:::-;;:::i;52114:26::-;;;;;;51986:25;;;;;;51669:35;;;;;;63234:63;;;:::i;1741:87::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;1741:87;;61524:570;;;;;;:::i;:::-;;:::i;51890:25::-;;;;;;52307:69;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;51828:24;;;;;;57158:98;;;;;;:::i;:::-;;:::i;52180:27::-;;;;;;57846:361;;;;;;:::i;:::-;;:::i;56882:162::-;;;;;;:::i;:::-;;:::i;51489:25::-;;;;;-1:-1:-1;;;;;51489:25:0;;;57264:96;;;;;;:::i;:::-;;:::i;57052:94::-;;;;;;:::i;:::-;;:::i;2650:201::-;;;;;;:::i;:::-;;:::i;52147:26::-;;;;;;51859:24;;;;;;62723:503;;;;;;:::i;:::-;;:::i;57368:98::-;;;;;;:::i;:::-;;:::i;52018:25::-;;;;;;57594:114;;;;;;:::i;:::-;;:::i;58268:451::-;58359:24;58418:8;:15;58404:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58404:30:0;;58394:40;;58451:9;58446:243;58466:8;:15;58462:1;:19;58446:243;;;58499:15;58517:8;58526:1;58517:11;;;;;;;;:::i;:::-;;;;;;;58499:29;;58646:14;:23;58661:7;-1:-1:-1;;;;;58646:23:0;-1:-1:-1;;;;;58646:23:0;;;;;;;;;;;;:32;58670:7;58646:32;;;;;;;;;;;;58609:34;58618:12;58632:10;;58609:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;58560:18:0;;;;;;:9;:18;;;;;:36;;58588:7;58560:27;:36::i;:::-;:44;;58603:1;58560:44;;;58599:1;58560:44;58552:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;58539:7;58547:1;58539:10;;;;;;;;:::i;:::-;;;;;;;;;;:140;-1:-1:-1;58483:3:0;;;;:::i;:::-;;;;58446:243;;;;58268:451;;;;;:::o;62346:167::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;;;;;;;;;62450:55:::1;-1:-1:-1::0;;;;;62450:34:0;::::1;62485:10;62497:7:::0;62450:34:::1;:55::i;:::-;62346:167:::0;;:::o;58777:392::-;-1:-1:-1;;;;;58943:23:0;;58857:7;58943:23;;;:14;:23;;;;;;;;:32;;;;;;;;;58929:10;;58857:7;;58943:32;58906:34;;58915:12;;58906:8;:34::i;:::-;:69;58898:96;;;;-1:-1:-1;;;58898:96:0;;12688:2:1;58898:96:0;;;12670:21:1;12727:2;12707:18;;;12700:30;-1:-1:-1;;;12746:18:1;;;12739:44;12800:18;;58898:96:0;12486:338:1;58898:96:0;-1:-1:-1;;;;;59106:23:0;;;;;;:14;:23;;;;;;;;:32;;;;;;;;;59092:10;;59069:34;;59078:12;;59069:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;59020:18:0;;;;;;:9;:18;;;;;:36;;59048:7;59020:27;:36::i;:::-;:44;;59063:1;59020:44;;;59059:1;59020:44;59012:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;59003:136;58777:392;-1:-1:-1;;;;58777:392:0:o;57474:112::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;57550:12:::1;:28:::0;;-1:-1:-1;;;;;;57550:28:0::1;-1:-1:-1::0;;;;;57550:28:0;;;::::1;::::0;;;::::1;::::0;;57474:112::o;62132:205::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;62222:12:::1;::::0;;62215:45:::1;::::0;-1:-1:-1;;;62215:45:0;;62254:4:::1;62215:45:::0;;::::1;5068:51:1::0;;;;62193:19:0::1;::::0;-1:-1:-1;;;;;62222:12:0;;::::1;::::0;62215:30:::1;::::0;5041:18:1;;62215:45:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62278:12;::::0;62193:67;;-1:-1:-1;62271:58:0::1;::::0;-1:-1:-1;;;;;62278:12:0::1;62305:10;62193:67:::0;62271:33:::1;:58::i;:::-;62182:155;62132:205::o:0;56397:80::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56457:4:::1;:12:::0;56397:80::o;63306:67::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;63355:10:::1;:8;:10::i;:::-;63306:67::o:0;56589:119::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56674:26:::1;56689:11:::0;56674:12:::1;:26;:::i;:::-;56661:10;:39:::0;-1:-1:-1;56589:119:0:o;60771: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;;12328:2:1;31917:63:0::1;::::0;::::1;12310:21:1::0;12367:2;12347:18;;;12340:30;12406:33;12386:18;;;12379:61;12457:18;;31917:63:0::1;12126:355:1::0;31917:63:0::1;31327:1;32058:7;:18:::0;;;60874:9:::2;::::0;::::2;;:17;;;60866:44;;;::::0;-1:-1:-1;;;60866:44:0;;10880:2:1;60866: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;;60866:44:0::2;10678:338:1::0;60866:44:0::2;60943:25;::::0;-1:-1:-1;;;;;60943:25:0::2;60929:10;:39;;60921:67;;;::::0;-1:-1:-1;;;60921:67:0;;8324:2:1;60921: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;;60921:67:0::2;8122:339:1::0;60921:67:0::2;60999:94;61037:10;61057:4;61077:8;;:15;;61064:10;;:28;;;;:::i;:::-;61006:12;::::0;-1:-1:-1;;;;;61006:12:0::2;::::0;60999:94;;:37:::2;:94::i;:::-;61104:96;61143:10;61163:4;61184:8;;:15;;61170:11;;:29;;;;:::i;:::-;61111:13;::::0;-1:-1:-1;;;;;61111:13:0::2;::::0;61104:96;;:38:::2;:96::i;:::-;61211:22;61224:8;;61211:12;:22::i;:::-;61252:9;61247:227;61263:19:::0;;::::2;61247:227;;;61312:25;::::0;-1:-1:-1;;;;;61312:25:0::2;61304:51;61356:10;61375:4;61381:8:::0;;61390:1;61381:11;;::::2;;;;;:::i;:::-;61304:92;::::0;-1:-1:-1;;;;;;61304:92:0::2;::::0;;;;;;-1:-1:-1;;;;;5833:15:1;;;61304:92:0::2;::::0;::::2;5815:34:1::0;5885:15;;;;5865:18;;;5858:43;-1:-1:-1;61381: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;;61304:92:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;61411:38;61437:8;;61446:1;61437:11;;;;;;;:::i;:::-;61421:10;61411:21;::::0;;;:9:::2;61437:11;61411:21:::0;;;;;;;;61437:11;::::2;;;::::0;-1:-1:-1;61411:25:0::2;:38::i;:::-;-1:-1:-1::0;61284:3:0;::::2;::::0;::::2;:::i;:::-;;;;61247:227;;;-1:-1:-1::0;;31283:1:0::1;32237:22:::0;;-1:-1:-1;60771:710:0:o;59660:1067::-;34463:7;;;;34717:9;34709:38;;;;-1:-1:-1;;;34709:38:0;;;;;;;:::i;:::-;59741:14:::1;59765:16:::0;59784:34:::1;59793:12;59807:10;;59784:8;:34::i;:::-;59765:53;;59833:17;59956:9:::0;59951:269:::1;59967:19:::0;;::::1;59951:269;;;60014:45;60035:10;60047:8;;60056:1;60047:11;;;;;;;:::i;:::-;;;;;;;60014:20;:45::i;:::-;60004:55;::::0;;::::1;:::i;:::-;60085:10;60070:26;::::0;;;:14:::1;:26;::::0;;;;60004:55;;-1:-1:-1;60112:8:0;;60070:26;60097:8;;60106:1;60097:11;;::::1;;;;;:::i;:::-;;;;;;;60070:39;;;;;;;;;;;:50;;;;60140:4;:17;60145:8;;60154:1;60145:11;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;::::1;;60140:17:::0;;-1:-1:-1;60140:17:0;::::1;::::0;;;;;;-1:-1:-1;60140:17:0;;::::1;;:25;;:17:::0;:25:::1;60137:74;;;60194:4;60179:19;;60137:74;59988:3:::0;::::1;::::0;::::1;:::i;:::-;;;;59951:269;;;-1:-1:-1::0;60231:10:0;;60228:494:::1;;60294:4;60278:20:::0;::::1;;;60275:440;;;60315:9;60310:110;60326:19:::0;;::::1;60310:110;;;60370:4;:17;60375:8;;60384:1;60375:11;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;::::1;;60370:17:::0;;-1:-1:-1;60370:17:0;::::1;::::0;;;;;;-1:-1:-1;60370:17:0;;::::1;;:25;;:17:::0;:25:::1;60362:46;;;::::0;-1:-1:-1;;;60362:46:0;;11992:2:1;60362:46:0::1;::::0;::::1;11974:21:1::0;12031:1;12011:18;;;12004:29;-1:-1:-1;;;12049:18:1;;;12042:38;12097:18;;60362:46:0::1;11790:331:1::0;60362:46:0::1;60347:3:::0;::::1;::::0;::::1;:::i;:::-;;;;60310:110;;;-1:-1:-1::0;60437:12:0::1;::::0;60430:53:::1;::::0;-1:-1:-1;;;;;60437:12:0::1;60464:10;60476:6:::0;60430:33:::1;:53::i;:::-;-1:-1:-1::0;60509:5:0::1;60275:440;;;60578:24;60583:18;60591:6;60599:1;60583:7;:18::i;:::-;60578:4;:24::i;:::-;60622:19;60630:6;60638:2;60622:7;:19::i;:::-;60659:12;::::0;60613:28;;-1:-1:-1;60652:53:0::1;::::0;-1:-1:-1;;;;;60659:12:0::1;60686:10;60613:28:::0;60652:33:::1;:53::i;:::-;59732:995;;;59660:1067:::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;56716:159::-:0;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56791:9:::1;56786:84;56806:17:::0;;::::1;56786:84;;;56858:4;56840;:15;56845:6;;56852:1;56845:9;;;;;;;:::i;:::-;;;;;;;56840:15;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;56825:3;;;;;:::i;:::-;;;;56786:84;;;;56716:159:::0;;:::o;57716:84::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;57776:9:::1;:16:::0;;-1:-1:-1;;57776:16:0::1;::::0;::::1;;::::0;;;::::1;::::0;;57716:84::o;63234:63::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;63281:8:::1;:6;:8::i;61524: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;;12328:2:1;31917:63:0::1;::::0;::::1;12310:21:1::0;12367:2;12347:18;;;12340:30;12406:33;12386:18;;;12379:61;12457:18;;31917:63:0::1;12126:355:1::0;31917:63:0::1;31327:1;32058:7;:18:::0;61685:10:::2;::::0;61620:94:::2;::::0;61658:10:::2;::::0;61678:4:::2;::::0;61685:28:::2;::::0;61698:8;;61685:28:::2;:::i;61620:94::-;61725:22;61738:8;;61725:12;:22::i;:::-;61763:9;61758:329;61774:19:::0;;::::2;61758:329;;;61824:43;61855:8;;61864:1;61855:11;;;;;;;:::i;:::-;61834:10;61824:21;::::0;;;:9:::2;61855:11;61824:21:::0;;;;;;;;61855:11;::::2;;;::::0;-1:-1:-1;61824:30:0::2;:43::i;:::-;61815:84;;;::::0;-1:-1:-1;;;61815:84:0;;10523:2:1;61815:84:0::2;::::0;::::2;10505:21:1::0;10562:2;10542:18;;;10535:30;10601;10581:18;;;10574:58;10649:18;;61815:84:0::2;10321:352:1::0;61815:84:0::2;61914:41;61943:8;;61952:1;61943:11;;;;;;;:::i;:::-;61924:10;61914:21;::::0;;;:9:::2;61943:11;61914:21:::0;;;;;;;;61943:11;::::2;;;::::0;-1:-1:-1;61914:28:0::2;:41::i;:::-;-1:-1:-1::0;61978:25:0::2;::::0;-1:-1:-1;;;;;61978:25:0::2;61970:51;62030:4;62037:10;62048:8:::0;;62057:1;62048:11;;::::2;;;;;:::i;:::-;61970:93;::::0;-1:-1:-1;;;;;;61970:93:0::2;::::0;;;;;;-1:-1:-1;;;;;5833:15:1;;;61970:93:0::2;::::0;::::2;5815:34:1::0;5885:15;;;;5865:18;;;5858:43;-1:-1:-1;62048: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;;61970:93:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;61795:3;;;;;:::i;:::-;;;;61758:329;;57158: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;:::-;57227:10:::1;:21:::0;;-1:-1:-1;;;;;;57227:21:0::1;-1:-1:-1::0;;;;;57227:21:0;;;::::1;::::0;;;::::1;::::0;;57158:98::o;57846:361::-;-1:-1:-1;;;;;57974:18:0;;57931:40;57974:18;;;:9;:18;;;;;57904:16;;58044:19;57974:18;58044:17;:19::i;:::-;58029:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58029:35:0;;58001:63;;58081:9;58076:97;58096:19;:10;:17;:19::i;:::-;58092:1;:23;58076:97;;;58147:16;:10;58161:1;58147:13;:16::i;:::-;58133:8;58142:1;58133:11;;;;;;;;:::i;:::-;;;;;;;;;;:30;58117:3;;;;:::i;:::-;;;;58076:97;;;-1:-1:-1;58191:8:0;57846:361;-1:-1:-1;;;57846:361:0:o;56882:162::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;56959:9:::1;56954:85;56974:17:::0;;::::1;56954:85;;;57026:5;57008:4;:15;57013:6;;57020:1;57013:9;;;;;;;:::i;:::-;;;;;;;57008:15;;;;;;;;;;;;:23;;;;;;;;;;;;;;;;;;56993:3;;;;;:::i;:::-;;;;56954:85;;57264:96:::0;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;57332:10:::1;:20:::0;57264:96::o;57052:94::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;57119:8:::1;:19:::0;;-1:-1:-1;;;;;;57119:19:0::1;-1:-1:-1::0;;;;;57119:19:0;;;::::1;::::0;;;::::1;::::0;;57052: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;62723:503::-:0;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;62808:8:::1;:15;62827:2;62808:21;62800:41;;;::::0;-1:-1:-1;;;62800:41:0;;10188:2:1;62800: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;;62800:41:0::1;9986:330:1::0;62800:41:0::1;62861:8;62870:1;62861:11;;;;;;;;:::i;:::-;;;;;;;62853:5;:19;;;;62892:8;62901:1;62892:11;;;;;;;;:::i;:::-;;;;;;;62884:5;:19;;;;62923:8;62932:1;62923:11;;;;;;;;:::i;:::-;;;;;;;62915:5;:19;;;;62954:8;62963:1;62954:11;;;;;;;;:::i;:::-;;;;;;;62946:5;:19;;;;62985:8;62994:1;62985:11;;;;;;;;:::i;:::-;;;;;;;62977:5;:19;;;;63016:8;63025:1;63016:11;;;;;;;;:::i;:::-;;;;;;;63008:5;:19;;;;63047:8;63056:1;63047:11;;;;;;;;:::i;:::-;;;;;;;63039:5;:19;;;;63078:8;63087:1;63078:11;;;;;;;;:::i;:::-;;;;;;;63070:5;:19;;;;63109:8;63118:1;63109:11;;;;;;;;:::i;:::-;;;;;;;63101:5;:19;;;;63141:8;63150:1;63141:11;;;;;;;;:::i;:::-;;;;;;;63132:6;:20;;;;63173:8;63182:2;63173:12;;;;;;;;:::i;:::-;;;;;;;63164:6;:21;;;;63206:8;63215:2;63206:12;;;;;;;;:::i;:::-;;;;;;;63197:6;:21;;;;62723:503:::0;:::o;57368:98::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;57437:11:::1;:21:::0;57368:98::o;57594:114::-;1787:7;1814:6;-1:-1:-1;;;;;1814:6:0;689:10;1961:23;1953:68;;;;-1:-1:-1;;;1953:68:0;;;;;;;:::i;:::-;57671:13:::1;:29:::0;;-1:-1:-1;;;;;;57671:29:0::1;-1:-1:-1::0;;;;;57671:29:0;;;::::1;::::0;;;::::1;::::0;;57594: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;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;47557:96:0;47413:248;;;;:::o;27491:131::-;27558:4;27582:32;27587:3;27607:5;27582:4;:32::i;59178:435::-;-1:-1:-1;;;;;59346:23:0;;59260:7;59346:23;;;:14;:23;;;;;;;;:32;;;;;;;;;59332:10;;59260:7;;59346:32;59309:34;;59318:12;;59309:8;:34::i;:::-;:69;59301:96;;;;-1:-1:-1;;;59301:96:0;;12688:2:1;59301:96:0;;;12670:21:1;12727:2;12707:18;;;12700:30;-1:-1:-1;;;12746:18:1;;;12739:44;12800:18;;59301:96:0;12486:338:1;59301:96:0;-1:-1:-1;;;;;59509:23:0;;;;;;:14;:23;;;;;;;;:32;;;;;;;;;59495:10;;59472:34;;59481:12;;59472:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;59423:18:0;;;;;;:9;:18;;;;;:36;;59451:7;59423:27;:36::i;:::-;:44;;59466:1;59423:44;;;59462:1;59423:44;59415:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;59406:136;;59558:47;59566:6;59574:30;59596:7;59574:21;:30::i;:::-;56064:7;;56147:3;56127:17;56137:7;56127;:17;:::i;:::-;:23;;;;:::i;52935:90::-;52992:12;;;52986:33;;-1:-1:-1;;;52986:33:0;;;;;12975:25:1;;;-1:-1:-1;;;;;52992:12:0;;52986:24;;12948:18:1;;52986:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;53034:1463;53149:10;;53129:65;;-1:-1:-1;;;53129:65:0;;;;;12975:25:1;;;53101:15:0;;-1:-1:-1;;;;;53149:10:0;;53129:55;;12948:18:1;;53129:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53198:1;53129:70;53126:1366;;;-1:-1:-1;;53217:5:0;;;53034:1463::o;53126:1366::-;53260:10;;53240:65;;-1:-1:-1;;;53240:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53260:10:0;;;;53240:55;;12948:18:1;;53240:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53309:1;53240:70;53237:1255;;;-1:-1:-1;;53328:5:0;;;53034:1463::o;53237:1255::-;53371:10;;53351:65;;-1:-1:-1;;;53351:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53371:10:0;;;;53351:55;;12948:18:1;;53351:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53420:1;53351:70;53348:1144;;;-1:-1:-1;;53439:5:0;;;53034:1463::o;53348:1144::-;53482:10;;53462:65;;-1:-1:-1;;;53462:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53482:10:0;;;;53462:55;;12948:18:1;;53462:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53531:1;53462:70;53459:1033;;;-1:-1:-1;;53550:5:0;;;53034:1463::o;53459:1033::-;53593:10;;53573:65;;-1:-1:-1;;;53573:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53593:10:0;;;;53573:55;;12948:18:1;;53573:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53642:1;53573:70;53570:922;;;-1:-1:-1;;53661:5:0;;;53034:1463::o;53570:922::-;53704:10;;53684:65;;-1:-1:-1;;;53684:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53704:10:0;;;;53684:55;;12948:18:1;;53684:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53753:1;53684:70;53681:811;;;-1:-1:-1;;53772:5:0;;;53034:1463::o;53681:811::-;53815:10;;53795:65;;-1:-1:-1;;;53795:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53815:10:0;;;;53795:55;;12948:18:1;;53795:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53864:1;53795:70;53792:700;;;-1:-1:-1;;53883:5:0;;;53034:1463::o;53792:700::-;53926:10;;53906:65;;-1:-1:-1;;;53906:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;53926:10:0;;;;53906:55;;12948:18:1;;53906:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53975:1;53906:70;53903:589;;;-1:-1:-1;;53994:5:0;;;53034:1463::o;53903:589::-;54037:10;;54017:65;;-1:-1:-1;;;54017:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;54037:10:0;;;;54017:55;;12948:18:1;;54017:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54086:1;54017:70;54014:478;;;-1:-1:-1;;54105:5:0;;;53034:1463::o;54014:478::-;54148:10;;54128:65;;-1:-1:-1;;;54128:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;54148:10:0;;;;54128:55;;12948:18:1;;54128:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54197:2;54128:71;54125:367;;;-1:-1:-1;;54217:6:0;;;53034:1463::o;54125:367::-;54261:10;;54241:65;;-1:-1:-1;;;54241:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;54261:10:0;;;;54241:55;;12948:18:1;;54241:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54310:2;54241:71;54238:254;;;-1:-1:-1;;54330:6:0;;;53034:1463::o;54238:254::-;54374:10;;54354:65;;-1:-1:-1;;;54354:65:0;;;;;12975:25:1;;;-1:-1:-1;;;;;54374:10:0;;;;54354:55;;12948:18:1;;54354:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54423:2;54354:71;54351:141;;;-1:-1:-1;;54443:6:0;;;53034:1463::o;54351:141::-;-1:-1:-1;54481:1:0;;53034:1463;-1:-1:-1;53034:1463:0:o;54351:141::-;53034:1463;;;:::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;13011:128::-;13051:3;13082:1;13078:6;13075:1;13072:13;13069:39;;;13088:18;;:::i;:::-;-1:-1:-1;13124:9:1;;13011:128::o;13144:217::-;13184:1;13210;13200:132;;13254:10;13249:3;13245:20;13242:1;13235:31;13289:4;13286:1;13279:15;13317:4;13314:1;13307:15;13200:132;-1:-1:-1;13346:9:1;;13144:217::o;13366:168::-;13406:7;13472:1;13468;13464:6;13460:14;13457:1;13454:21;13449:1;13442:9;13435:17;13431:45;13428:71;;;13479:18;;:::i;:::-;-1:-1:-1;13519:9:1;;13366:168::o;13539:125::-;13579:4;13607:1;13604;13601:8;13598:34;;;13612:18;;:::i;:::-;-1:-1:-1;13649:9:1;;13539:125::o;13669:258::-;13741:1;13751:113;13765:6;13762:1;13759:13;13751:113;;;13841:11;;;13835:18;13822:11;;;13815:39;13787:2;13780:10;13751:113;;;13882:6;13879:1;13876:13;13873:48;;;-1:-1:-1;;13917:1:1;13899:16;;13892:27;13669:258::o;13932:135::-;13971:3;-1:-1:-1;;13992:17:1;;13989:43;;;14012:18;;:::i;:::-;-1:-1:-1;14059:1:1;14048:13;;13932:135::o;14072:127::-;14133:10;14128:3;14124:20;14121:1;14114:31;14164:4;14161:1;14154:15;14188:4;14185:1;14178:15;14204:127;14265:10;14260:3;14256:20;14253:1;14246:31;14296:4;14293:1;14286:15;14320:4;14317:1;14310:15;14336:127;14397:10;14392:3;14388:20;14385:1;14378:31;14428:4;14425:1;14418:15;14452:4;14449:1;14442:15;14468:127;14529:10;14524:3;14520:20;14517:1;14510:31;14560:4;14557:1;14550:15;14584:4;14581:1;14574:15;14600:118;14686:5;14679:13;14672:21;14665:5;14662:32;14652:60;;14708:1;14705;14698:12

ipfs://21d2a661747cf0bcd7924491f9c89005d261aa4d0b57b3dc92ecd18760f6f3e1