Token

/**
 *Submitted for verification at Etherscan.io on 2022-02-23
*/

// SPDX-License-Identifier: MIT

//Imports
pragma solidity ^0.8.0;
/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
} 
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _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

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

contract miniLandStakingv1 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;
    
  
    uint256 public expiration; 
    //rate governs how often you receive your token
    uint256 public rate; 
    
    // tax rate amounts
    uint256 public taxRateDiamond = 100;
    uint256 public taxRateGold = 48;
    uint256 public taxRateSilver = 23;
    uint256 public taxRateBronze = 4;
    
 
    uint256 public depositIndex;
    bool public em1schedule = false;
    bool public em2schedule = false;

 
    
    // mappings 
    mapping(address => EnumerableSet.UintSet) private _deposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;
    mapping(uint256 => address) public depositAdd;
    mapping(uint256 => uint256) public depositTok;
    mapping(address => uint256) public emissions1;
    mapping(address => uint256) public emissions2;
    uint256 public landsharelock;

    constructor(address _stakingDestinationAddress, uint256 _rate, uint256 _expiration, address _erc20Address, address _erc20Address2) {
        stakingDestinationAddress = _stakingDestinationAddress;
        rate = _rate;
        expiration = block.number + _expiration;
        erc20Address = _erc20Address;
        erc20Address2 = _erc20Address2;
        _pause();
        landsharelock = block.timestamp + 14 days;
    }

    function deedCheck (uint256 tokenId) internal view returns (uint256){
       return IDeedCheck(stakingDestinationAddress).deedCheck(tokenId);
    }

    function calcTaxRate(uint256 tokenId) internal view returns (uint256 tax){
       
       if(deedCheck(tokenId) == 4){
         return taxRateDiamond;
       }else if(deedCheck(tokenId) == 3){
         return taxRateGold;
       }else if(deedCheck(tokenId) == 2){
         return taxRateSilver;
       }else if(deedCheck(tokenId) == 1){
         return taxRateBronze;
       }else{
         return 0;
       }
    }
    // gets x %
   function calcTax(uint256 _amount, uint256 taxRate) internal pure returns (uint256){
        uint256 taxedAmount;
        taxedAmount = taxRate * _amount / 100;
        return taxedAmount;
    }
 
    function pause() public onlyOwner() {
        _pause();
    }
 
    function unpause() public onlyOwner() {
        _unpause();
    }
    
/* STAKING MECHANICS */
 
        // 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 seterc20Address(address _erc20Address) public onlyOwner() {
      erc20Address = _erc20Address;
    }

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

    function setTaxRateBronze(uint256 _newTax) public onlyOwner() {
      taxRateBronze = _newTax;
    }

    function setTaxRateSilver(uint256 _newTax) public onlyOwner() {
      taxRateSilver = _newTax;
    }

    function setTaxRateGold(uint256 _newTax) public onlyOwner() {
      taxRateGold = _newTax;
    }

    function setTaxRateDiamond(uint256 _newTax) public onlyOwner() {
      taxRateDiamond = _newTax;
    }

    function setEmissions1(bool _em1schedule) external onlyOwner(){
      em1schedule = _em1schedule;
    }

    function setEmissions2(bool _em2schedule) external onlyOwner(){
      em2schedule = _em2schedule;
    }
    
    //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]);
        rewards[i] = calcTax(rate * (_deposits[account].contains(tokenId) ? 1 : 0) * (Math.min(block.number, expiration) - _depositBlocks[account][tokenId]), calcTaxRate(tokenId));
      }
      return rewards;
    }

    //reward amount by address/tokenId - Tested
    function calculateReward(address account, uint256 tokenId) public view returns (uint256) {
      require(Math.min(block.number, expiration) > _depositBlocks[account][tokenId], "Invalid blocks");
      return rate * (_deposits[account].contains(tokenId) ? 1 : 0) * (Math.min(block.number, expiration) - _depositBlocks[account][tokenId]);
    }
 
    //reward claim function - Tested
    function claimRewards(uint256[] calldata tokenIds) public whenNotPaused {
      uint256 reward; 
      uint256 blockCur = Math.min(block.number, expiration);
      uint256 tax;
      
      require(tokenIds.length <= 1, "Can only Claim/Stake/Unstake 1 at a time");
      for (uint256 i; i < tokenIds.length; i++) {
        reward += calculateReward(msg.sender, tokenIds[i]);
        _depositBlocks[msg.sender][tokenIds[i]] = blockCur;
        tax = calcTaxRate(tokenIds[i]);
      }
      if(reward > 0) {
        IERC20(erc20Address).safeTransfer(msg.sender, calcTax(reward, tax));
    }   
   }
 
    //deposit function.  - Tested
    function deposit(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
       
        require(msg.sender != stakingDestinationAddress, "Invalid address");
        
        claimRewards(tokenIds);
 
        for (uint256 i; i < tokenIds.length; i++) {
           IERC721(stakingDestinationAddress).safeTransferFrom(msg.sender,address(this),tokenIds[i],"");
           _deposits[msg.sender].add(tokenIds[i]);
          if(em1schedule == false){
            depositAdd[depositIndex] = msg.sender;
            depositTok[depositIndex] = tokenIds[i];
            depositIndex++;
          }
        }     
      }

    //claim share emissions schedule 1
     function claimEmissions1() external whenNotPaused nonReentrant(){
      require(em1schedule == true, "Not emission schedule 1");
      uint256 reward; 
   
      reward = emissions1[msg.sender];
      
      if(reward > 0) {
      IERC20(erc20Address2).safeTransfer(msg.sender, reward);
    }
      emissions1[msg.sender] = 0;
    }

      //claim share emissions schedule 2
     function claimEmissions2() external whenNotPaused nonReentrant(){
      require(em2schedule == true, "Not emission schedule 2");
      uint256 reward; 
   
      reward = emissions2[msg.sender];
      
      if(reward > 0) {
      IERC20(erc20Address2).safeTransfer(msg.sender, reward);
    }
      emissions2[msg.sender] = 0;
    }

    //withdrawal function. Tested
    function withdraw(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        require(landsharelock <= block.timestamp, "Land Share Lock");
        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 withdrawAllTokens2() external onlyOwner() {
        uint256 tokenSupply = IERC20(erc20Address2).balanceOf(address(this));
        IERC20(erc20Address2).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;
    }

    function resetBalances(uint256 startindex, uint256 endIndex) external onlyOwner(){
      uint256 blockCur = Math.min(block.number, expiration);
      for (uint256 i = startindex; i <= endIndex; i++){
                              
        emissions1[depositAdd[i]] += calcTax(calculateReward(depositAdd[i],depositTok[i]), calcTaxRate(depositTok[i]));
        _depositBlocks[depositAdd[i]][depositTok[i]] = blockCur;
      } 
     
    }  
    function resetVar(uint256 _rate) external onlyOwner(){
      rate = _rate;
      em1schedule = true;
      taxRateBronze = 5;
      taxRateSilver = 24;
    }

     function resetBalances2(uint256 startindex, uint256 endIndex) external onlyOwner(){
      uint256 blockCur = Math.min(block.number, expiration);
      for (uint256 i = startindex; i <= endIndex; i++){
                              
        emissions2[depositAdd[i]] += calcTax(calculateReward(depositAdd[i],depositTok[i]), calcTaxRate(depositTok[i]));
        _depositBlocks[depositAdd[i]][depositTok[i]] = blockCur;
      } 
    
    }  

     function resetVar2(uint256 _rate,  address _erc20Address) external onlyOwner(){
      rate = _rate;
      em2schedule = true;
      taxRateBronze = 7;
      taxRateSilver = 25;
      taxRateGold = 50;
      erc20Address = _erc20Address;
    }
}

• 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"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"","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":[],"name":"claimEmissions1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimEmissions2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"depositAdd","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depositIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"depositTok","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"depositsOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"em1schedule","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"em2schedule","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"emissions1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"emissions2","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":[],"name":"landsharelock","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startindex","type":"uint256"},{"internalType":"uint256","name":"endIndex","type":"uint256"}],"name":"resetBalances","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startindex","type":"uint256"},{"internalType":"uint256","name":"endIndex","type":"uint256"}],"name":"resetBalances2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"resetVar","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"address","name":"_erc20Address","type":"address"}],"name":"resetVar2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_em1schedule","type":"bool"}],"name":"setEmissions1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_em2schedule","type":"bool"}],"name":"setEmissions2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setExpiration","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":"setTaxRateBronze","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTax","type":"uint256"}],"name":"setTaxRateDiamond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTax","type":"uint256"}],"name":"setTaxRateGold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTax","type":"uint256"}],"name":"setTaxRateSilver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20Address","type":"address"}],"name":"seterc20Address","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20Address2","type":"address"}],"name":"seterc20Address2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingDestinationAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxRateBronze","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxRateDiamond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxRateGold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxRateSilver","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":"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":[],"name":"withdrawAllTokens2","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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

000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc9900000000000000000000000000000000000000000000000000000193f60f060000000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71c71c71c7000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc99000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc99

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0xc1e87be1055509081ea73a0fd5d3d70f6573dc99
Arg [1] : _rate (uint256): 1735000000000
Arg [2] : _expiration (uint256): 1111111111111111111111111111111111111111111111111111111111111
Arg [3] : _erc20Address (address): 0xc1e87be1055509081ea73a0fd5d3d70f6573dc99
Arg [4] : _erc20Address2 (address): 0xc1e87be1055509081ea73a0fd5d3d70f6573dc99

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc99
Arg [1] : 00000000000000000000000000000000000000000000000000000193f60f0600
Arg [2] : 00000000000000b1029d46c4e42613c928344986ddc62f2a11c71c71c71c71c7
Arg [3] : 000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc99
Arg [4] : 000000000000000000000000c1e87be1055509081ea73a0fd5d3d70f6573dc99

50615:10329:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50885:40;;;;;-1:-1:-1;;;;;50885:40:0;;;;;;-1:-1:-1;;;;;5105:32:1;;;5087:51;;5075:2;5060:18;50885:40:0;;;;;;;;55059:636;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;59257:167::-;;;;;;:::i;:::-;;:::i;:::-;;59433:173;;;;;;:::i;:::-;-1:-1:-1;;;59433:173:0;;;;;;;;;;;-1:-1:-1;;;;;;6979:33:1;;;6961:52;;6949:2;6934:18;59433:173:0;6817:202:1;55752:345:0;;;;;;:::i;:::-;;:::i;:::-;;;13057:25:1;;;13045:2;13030:18;55752:345:0;12911:177:1;54154:98:0;;;;;;:::i;:::-;;:::i;60237:444::-;;;;;;:::i;:::-;;:::i;51604:45::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;51604:45:0;;;50932:27;;;;;-1:-1:-1;;;;;50932:27:0;;;53689:112;;;;;;:::i;:::-;;:::i;58825:205::-;;;:::i;51097:19::-;;;;;;53368:80;;;;;;:::i;:::-;;:::i;51656:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;53170:67;;;:::i;50966:28::-;;;;;-1:-1:-1;;;;;50966:28:0;;;51011:25;;;;;;54485:105;;;;;;:::i;:::-;;:::i;53560:119::-;;;;;;:::i;:::-;;:::i;51708:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;54372:105;;;;;;:::i;:::-;;:::i;56798:638::-;;;;;;:::i;:::-;;:::i;51357:31::-;;;;;;;;;;;;6790:14:1;;6783:22;6765:41;;6753:2;6738:18;51357:31:0;6625:187:1;34394:86:0;34465:7;;;;34394:86;;56144:610;;;;;;:::i;:::-;;:::i;57878:342::-;;;:::i;51812:28::-;;;;;;2394:103;;;:::i;51323:27::-;;;;;;60066:162;;;;;;:::i;:::-;;:::i;54260:104::-;;;;;;:::i;:::-;;:::i;53098:63::-;;;:::i;1743:87::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;1743:87;;59038:208;;;:::i;51235:33::-;;;;;;58263:524;;;;;;:::i;:::-;;:::i;51155:35::-;;;;;;53934:102;;;;;;:::i;:::-;;:::i;54044:::-;;;;;;:::i;:::-;;:::i;60692:249::-;;;;;;:::i;:::-;;:::i;51528:69::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;51395:31;;;;;;;;;;;;51760:45;;;;;;:::i;:::-;;;;;;;;;;;;;;51275:32;;;;;;57485:342;;;:::i;54640:358::-;;;;;;:::i;:::-;;:::i;59614:444::-;;;;;;:::i;:::-;;:::i;51197:31::-;;;;;;2652:201;;;;;;:::i;:::-;;:::i;53810:116::-;;;;;;:::i;:::-;;:::i;55059:636::-;55150:24;55209:8;:15;55195:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55195:30:0;;55185:40;;55242:9;55237:428;55257:8;:15;55253:1;:19;55237:428;;;55290:15;55308:8;55317:1;55308:11;;;;;;;;:::i;:::-;;;;;;;55290:29;;55497:158;55599:14;:23;55614:7;-1:-1:-1;;;;;55599:23:0;-1:-1:-1;;;;;55599:23:0;;;;;;;;;;;;:32;55623:7;55599:32;;;;;;;;;;;;55562:34;55571:12;55585:10;;55562:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;55513:18:0;;;;;;:9;:18;;;;;:36;;55541:7;55513:27;:36::i;:::-;:44;;55556:1;55513:44;;;55552:1;55513:44;55505:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;55634:20;55646:7;55634:11;:20::i;:::-;55497:7;:158::i;:::-;55484:7;55492:1;55484:10;;;;;;;;:::i;:::-;;;;;;;;;;:171;-1:-1:-1;55274:3:0;;;;:::i;:::-;;;;55237:428;;;;55059:636;;;;;:::o;59257:167::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;;;;;;;;;59361:55:::1;-1:-1:-1::0;;;;;59361:34:0;::::1;59396:10;59408:7:::0;59361:34:::1;:55::i;:::-;59257:167:::0;;:::o;55752:345::-;-1:-1:-1;;;;;55895:23:0;;55832:7;55895:23;;;:14;:23;;;;;;;;:32;;;;;;;;;55881:10;;55858:34;;55867:12;;55858:8;:34::i;:::-;:69;55850:96;;;;-1:-1:-1;;;55850:96:0;;12770:2:1;55850:96:0;;;12752:21:1;12809:2;12789:18;;;12782:30;-1:-1:-1;;;12828:18:1;;;12821:44;12882:18;;55850:96:0;12568:338:1;55850:96:0;-1:-1:-1;;;;;56056:23:0;;;;;;:14;:23;;;;;;;;:32;;;;;;;;;56042:10;;56019:34;;56028:12;;56019:8;:34::i;:::-;:69;;;;:::i;:::-;-1:-1:-1;;;;;55970:18:0;;;;;;:9;:18;;;;;:36;;55998:7;55970:27;:36::i;:::-;:44;;56013:1;55970:44;;;56009:1;55970:44;55962:53;;:4;;:53;;;;:::i;:::-;:127;;;;:::i;:::-;55955:134;55752:345;-1:-1:-1;;;55752:345:0:o;54154:98::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;54223:11:::1;:21:::0;54154:98::o;60237:444::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;60328:16:::1;60347:34;60356:12;60370:10;;60347:8;:34::i;:::-;60328:53:::0;-1:-1:-1;60407:10:0;60390:277:::1;60424:8;60419:1;:13;60390:277;;60534:13;::::0;;;:10:::1;:13;::::0;;;;;;;;60548:10:::1;:13:::0;;;;;;;60510:81:::1;::::0;60518:44:::1;::::0;-1:-1:-1;;;;;60534:13:0;;::::1;::::0;60518:15:::1;:44::i;:::-;60576:13;::::0;;;:10:::1;:13;::::0;;;;;60564:26:::1;::::0;:11:::1;:26::i;60510:81::-;60481:25;60492:13:::0;;;:10:::1;:13;::::0;;;;;;;;-1:-1:-1;;;;;60492:13:0::1;60481:25:::0;;:10:::1;:25:::0;;;;;:110;;:25;;;:110:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;60602:29:0::1;60617:13:::0;;;:10:::1;:13;::::0;;;;;;;;-1:-1:-1;;;;;60617:13:0::1;60602:29:::0;;:14:::1;:29:::0;;;;;60632:13;;;:10:::1;:13:::0;;;;;;60602:44;;;;;;;:55;;;60628:1;60434:3:::1;60628:1:::0;60434:3:::1;:::i;:::-;;;;60390:277;;;;60319:362;60237:444:::0;;:::o;53689:112::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;53765:12:::1;:28:::0;;-1:-1:-1;;;;;;53765:28:0::1;-1:-1:-1::0;;;;;53765:28:0;;;::::1;::::0;;;::::1;::::0;;53689:112::o;58825:205::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;58915:12:::1;::::0;;58908:45:::1;::::0;-1:-1:-1;;;58908:45:0;;58947:4:::1;58908:45:::0;;::::1;5087:51:1::0;;;;58886:19:0::1;::::0;-1:-1:-1;;;;;58915:12:0;;::::1;::::0;58908:30:::1;::::0;5060:18:1;;58908:45:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58971:12;::::0;58886:67;;-1:-1:-1;58964:58:0::1;::::0;-1:-1:-1;;;;;58971:12:0::1;58998:10;58886:67:::0;58964:33:::1;:58::i;:::-;58875:155;58825:205::o:0;53368:80::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;53428:4:::1;:12:::0;53368:80::o;53170:67::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;53219:10:::1;:8;:10::i;:::-;53170:67::o:0;54485:105::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;54556:11:::1;:26:::0;;;::::1;;;;-1:-1:-1::0;;54556:26:0;;::::1;::::0;;;::::1;::::0;;54485:105::o;53560:119::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;53645:26:::1;53660:11:::0;53645:12:::1;:26;:::i;:::-;53632:10;:39:::0;-1:-1:-1;53560:119:0:o;54372:105::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;54443:11:::1;:26:::0;;-1:-1:-1;;54443:26:0::1;::::0;::::1;;::::0;;;::::1;::::0;;54372:105::o;56798:638::-;34465:7;;;;34719:9;34711:38;;;;-1:-1:-1;;;34711:38:0;;;;;;;:::i;:::-;31329:1:::1;31927:7;;:19;;31919:63;;;;-1:-1:-1::0;;;31919:63:0::1;;;;;;;:::i;:::-;31329:1;32060:7;:18:::0;56924:25:::2;::::0;-1:-1:-1;;;;;56924:25:0::2;56910:10;:39;;56902:67;;;::::0;-1:-1:-1;;;56902:67:0;;8724:2:1;56902:67:0::2;::::0;::::2;8706:21:1::0;8763:2;8743:18;;;8736:30;-1:-1:-1;;;8782:18:1;;;8775:45;8837:18;;56902:67:0::2;8522:339:1::0;56902:67:0::2;56990:22;57003:8;;56990:12;:22::i;:::-;57031:9;57026:396;57042:19:::0;;::::2;57026:396;;;57090:25;::::0;-1:-1:-1;;;;;57090:25:0::2;57082:51;57134:10;57153:4;57159:8:::0;;57168:1;57159:11;;::::2;;;;;:::i;:::-;57082:92;::::0;-1:-1:-1;;;;;;57082:92:0::2;::::0;;;;;;-1:-1:-1;;;;;5472:15:1;;;57082:92:0::2;::::0;::::2;5454:34:1::0;5524:15;;;;5504:18;;;5497:43;-1:-1:-1;57159:11:0::2;::::0;;::::2;;;5556:18:1::0;;;5549:34;5619:3;5599:18;;;5592:31;-1:-1:-1;5639:19:1;;;5632:30;5679:19;;57082:92:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;57188:38;57214:8;;57223:1;57214:11;;;;;;;:::i;:::-;57198:10;57188:21;::::0;;;:9:::2;57214:11;57188:21:::0;;;;;;;;57214:11;::::2;;;::::0;-1:-1:-1;57188:25:0::2;:38::i;:::-;-1:-1:-1::0;57242:11:0::2;::::0;::::2;;57239:172;;57289:12;::::0;57278:24:::2;::::0;;;:10:::2;:24;::::0;;;;:37;;-1:-1:-1;;;;;;57278:37:0::2;57305:10;57278:37;::::0;;57357:8;;57366:1;57357:11;;::::2;;;;;:::i;:::-;57341:12;::::0;;57330:24:::2;::::0;;;:10:::2;57357:11;57330:24:::0;;;;;;57357:11;::::2;::::0;;;::::2;;57330:38:::0;;;57383:14;;;57341:12;;-1:-1:-1;57383:14:0::2;::::0;::::2;:::i;:::-;;;;;;57239:172;57063:3:::0;::::2;::::0;::::2;:::i;:::-;;;;57026:396;;;-1:-1:-1::0;;31285:1:0::1;32239:22:::0;;-1:-1:-1;56798:638:0:o;56144:610::-;34465:7;;;;34719:9;34711:38;;;;-1:-1:-1;;;34711:38:0;;;;;;;:::i;:::-;56225:14:::1;56249:16:::0;56268:34:::1;56277:12;56291:10;;56268:8;:34::i;:::-;56249:53:::0;-1:-1:-1;56311:11:0::1;56366:1;56347:20:::0;::::1;;56339:73;;;::::0;-1:-1:-1;;;56339:73:0;;7966:2:1;56339:73:0::1;::::0;::::1;7948:21:1::0;8005:2;7985:18;;;7978:30;8044:34;8024:18;;;8017:62;-1:-1:-1;;;8095:18:1;;;8088:38;8143:19;;56339:73:0::1;7764:404:1::0;56339:73:0::1;56426:9;56421:215;56437:19:::0;;::::1;56421:215;;;56484:40;56500:10;56512:8;;56521:1;56512:11;;;;;;;:::i;:::-;;;;;;;56484:15;:40::i;:::-;56474:50;::::0;;::::1;:::i;:::-;56550:10;56535:26;::::0;;;:14:::1;:26;::::0;;;;56474:50;;-1:-1:-1;56577:8:0;;56535:26;56562:8;;56571:1;56562:11;;::::1;;;;;:::i;:::-;;;;;;;56535:39;;;;;;;;;;;:50;;;;56602:24;56614:8;;56623:1;56614:11;;;;;;;:::i;:::-;;;;;;;56602;:24::i;:::-;56596:30:::0;-1:-1:-1;56458:3:0;::::1;::::0;::::1;:::i;:::-;;;;56421:215;;;-1:-1:-1::0;56647:10:0;;56644:101:::1;;56670:67;56704:10;56716:20;56724:6;56732:3;56716:7;:20::i;:::-;56677:12;::::0;-1:-1:-1;;;;;56677:12:0::1;::::0;56670:67;:33:::1;:67::i;:::-;56216:538;;;56144:610:::0;;:::o;57878:342::-;34465:7;;;;34719:9;34711:38;;;;-1:-1:-1;;;34711:38:0;;;;;;;:::i;:::-;31329:1:::1;31927:7;;:19;;31919:63;;;;-1:-1:-1::0;;;31919:63:0::1;;;;;;;:::i;:::-;31329:1;32060:7;:18:::0;;;57959:11:::2;::::0;::::2;::::0;::::2;;;:19;;;57951:55;;;::::0;-1:-1:-1;;;57951:55:0;;7614:2:1;57951:55:0::2;::::0;::::2;7596:21:1::0;7653:2;7633:18;;;7626:30;7692:25;7672:18;;;7665:53;7735:18;;57951:55:0::2;7412:347:1::0;57951:55:0::2;58064:10;58015:14;58053:22:::0;;;:10:::2;:22;::::0;;;;;58095:10;;58092:86:::2;;58123:13;::::0;58116:54:::2;::::0;-1:-1:-1;;;;;58123:13:0::2;58151:10;58163:6:::0;58116:34:::2;:54::i;:::-;-1:-1:-1::0;58197:10:0::2;58211:1;58186:22:::0;;;:10:::2;:22;::::0;;;;:26;31285:1:::1;32239:22:::0;;57878:342::o;2394:103::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;2459:30:::1;2486:1;2459:18;:30::i;60066:162::-:0;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;60128:4:::1;:12:::0;60149:11:::1;:18:::0;;-1:-1:-1;;60149:18:0::1;60163:4;60149:18;::::0;;60192:1:::1;60176:13;:17:::0;60218:2:::1;60202:13;:18:::0;60066:162::o;54260:104::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;54332:14:::1;:24:::0;54260:104::o;53098:63::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;53145:8:::1;:6;:8::i;59038:208::-:0;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;59129:13:::1;::::0;59122:46:::1;::::0;-1:-1:-1;;;59122:46:0;;59162:4:::1;59122:46;::::0;::::1;5087:51:1::0;59100:19:0::1;::::0;-1:-1:-1;;;;;59129:13:0::1;::::0;59122:31:::1;::::0;5060:18:1;;59122:46:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59186:13;::::0;59100:68;;-1:-1:-1;59179:59:0::1;::::0;-1:-1:-1;;;;;59186:13:0::1;59214:10;59100:68:::0;59179:34:::1;:59::i;58263:524::-:0;34465:7;;;;34719:9;34711:38;;;;-1:-1:-1;;;34711:38:0;;;;;;;:::i;:::-;31329:1:::1;31927:7;;:19;;31919:63;;;;-1:-1:-1::0;;;31919:63:0::1;;;;;;;:::i;:::-;31329:1;32060:7;:18:::0;58367:13:::2;::::0;58384:15:::2;-1:-1:-1::0;58367:32:0::2;58359:60;;;::::0;-1:-1:-1;;;58359:60:0;;10227:2:1;58359:60:0::2;::::0;::::2;10209:21:1::0;10266:2;10246:18;;;10239:30;-1:-1:-1;;;10285:18:1;;;10278:45;10340:18;;58359:60:0::2;10025:339:1::0;58359:60:0::2;58430:22;58443:8;;58430:12;:22::i;:::-;58468:9;58463:317;58479:19:::0;;::::2;58463:317;;;58529:43;58560:8;;58569:1;58560:11;;;;;;;:::i;:::-;58539:10;58529:21;::::0;;;:9:::2;58560:11;58529:21:::0;;;;;;;;58560:11;::::2;;;::::0;-1:-1:-1;58529:30:0::2;:43::i;:::-;58520:84;;;::::0;-1:-1:-1;;;58520:84:0;;10932:2:1;58520:84:0::2;::::0;::::2;10914:21:1::0;10971:2;10951:18;;;10944:30;11010;10990:18;;;10983:58;11058:18;;58520:84:0::2;10730:352:1::0;58520:84:0::2;58619:41;58648:8;;58657:1;58648:11;;;;;;;:::i;:::-;58629:10;58619:21;::::0;;;:9:::2;58648:11;58619:21:::0;;;;;;;;58648:11;::::2;;;::::0;-1:-1:-1;58619:28:0::2;:41::i;:::-;-1:-1:-1::0;58683:25:0::2;::::0;-1:-1:-1;;;;;58683:25:0::2;58675:51;58735:4;58742:10;58753:8:::0;;58762:1;58753:11;;::::2;;;;;:::i;:::-;58675:93;::::0;-1:-1:-1;;;;;;58675:93:0::2;::::0;;;;;;-1:-1:-1;;;;;5472:15:1;;;58675:93:0::2;::::0;::::2;5454:34:1::0;5524:15;;;;5504:18;;;5497:43;-1:-1:-1;58753:11:0::2;::::0;;::::2;;;5556:18:1::0;;;5549:34;5619:3;5599:18;;;5592:31;-1:-1:-1;5639:19:1;;;5632:30;5679:19;;58675:93:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;58500:3;;;;;:::i;:::-;;;;58463:317;;53934:102:::0;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;54005:13:::1;:23:::0;53934:102::o;54044:::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;54115:13:::1;:23:::0;54044:102::o;60692:249::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;60779:4:::1;:12:::0;;;60800:11:::1;:18:::0;;-1:-1:-1;;60800:18:0::1;;;::::0;;60827:13:::1;:17:::0;;;;60869:2:::1;60853:13;:18:::0;60894:2:::1;60880:11;:16:::0;-1:-1:-1;60905:28:0;;-1:-1:-1;;;;;60905:28:0;;::::1;-1:-1:-1::0;;;;;;60905:28:0;;::::1;::::0;;;::::1;::::0;;60692:249::o;57485:342::-;34465:7;;;;34719:9;34711:38;;;;-1:-1:-1;;;34711:38:0;;;;;;;:::i;:::-;31329:1:::1;31927:7;;:19;;31919:63;;;;-1:-1:-1::0;;;31919:63:0::1;;;;;;;:::i;:::-;31329:1;32060:7;:18:::0;;;57566:11:::2;::::0;::::2;;:19;;;57558:55;;;::::0;-1:-1:-1;;;57558:55:0;;11289:2:1;57558:55:0::2;::::0;::::2;11271:21:1::0;11328:2;11308:18;;;11301:30;11367:25;11347:18;;;11340:53;11410:18;;57558:55:0::2;11087:347:1::0;57558:55:0::2;57671:10;57622:14;57660:22:::0;;;:10:::2;:22;::::0;;;;;57702:10;;57699:86:::2;;57730:13;::::0;57723:54:::2;::::0;-1:-1:-1;;;;;57730:13:0::2;57758:10;57770:6:::0;57723:34:::2;:54::i;:::-;-1:-1:-1::0;57804:10:0::2;57818:1;57793:22:::0;;;:10:::2;:22;::::0;;;;:26;31285:1:::1;32239:22:::0;;57485:342::o;54640:358::-;-1:-1:-1;;;;;54768:18:0;;54725:40;54768:18;;;:9;:18;;;;;54698:16;;54838:19;54768:18;54838:17;:19::i;:::-;54823:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54823:35:0;;54795:63;;54875:9;54870:97;54890:19;:10;:17;:19::i;:::-;54886:1;:23;54870:97;;;54941:16;:10;54955:1;54941:13;:16::i;:::-;54927:8;54936:1;54927:11;;;;;;;;:::i;:::-;;;;;;;;;;:30;54911:3;;;;:::i;:::-;;;;54870:97;;;-1:-1:-1;54982:8:0;54640:358;-1:-1:-1;;;54640:358:0:o;59614:444::-;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;59704:16:::1;59723:34;59732:12;59746:10;;59723:8;:34::i;:::-;59704:53:::0;-1:-1:-1;59783:10:0;59766:277:::1;59800:8;59795:1;:13;59766:277;;59910:13;::::0;;;:10:::1;:13;::::0;;;;;;;;59924:10:::1;:13:::0;;;;;;;59886:81:::1;::::0;59894:44:::1;::::0;-1:-1:-1;;;;;59910:13:0;;::::1;::::0;59894:15:::1;:44::i;59886:81::-;59857:25;59868:13:::0;;;:10:::1;:13;::::0;;;;;;;;-1:-1:-1;;;;;59868:13:0::1;59857:25:::0;;:10:::1;:25:::0;;;;;:110;;:25;;;:110:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;59978:29:0::1;59993:13:::0;;;:10:::1;:13;::::0;;;;;;;;-1:-1:-1;;;;;59993:13:0::1;59978:29:::0;;:14:::1;:29:::0;;;;;60008:13;;;:10:::1;:13:::0;;;;;;59978:44;;;;;;;:55;;;60004:1;59810:3:::1;60004:1:::0;59810:3:::1;:::i;:::-;;;;59766:277;;2652:201:::0;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2741:22:0;::::1;2733:73;;;::::0;-1:-1:-1;;;2733:73:0;;9068:2:1;2733:73:0::1;::::0;::::1;9050:21:1::0;9107:2;9087:18;;;9080:30;9146:34;9126:18;;;9119:62;-1:-1:-1;;;9197:18:1;;;9190:36;9243:19;;2733:73:0::1;8866:402:1::0;2733:73:0::1;2817:28;2836:8;2817:18;:28::i;53810:116::-:0;1789:7;1816:6;-1:-1:-1;;;;;1816:6:0;691:10;1963:23;1955:68;;;;-1:-1:-1;;;1955:68:0;;;;;;;:::i;:::-;53888:13:::1;:30:::0;;-1:-1:-1;;;;;;53888:30:0::1;-1:-1:-1::0;;;;;53888:30:0;;;::::1;::::0;;;::::1;::::0;;53810:116::o;32621:106::-;32679:7;32710:1;32706;:5;:13;;32718:1;32706:13;;;-1:-1:-1;32714:1:0;;32621:106;-1:-1:-1;32621:106:0:o;28023:146::-;28100:4;21083:19;;;:12;;;:19;;;;;;:24;;28124:37;20986:129;52442:428;52503:11;52537:18;52547:7;52537:9;:18::i;:::-;52559:1;52537:23;52534:329;;;-1:-1:-1;;52580:14:0;;;52442:428::o;52534:329::-;52613:18;52623:7;52613:9;:18::i;:::-;52635:1;52613:23;52610:253;;;-1:-1:-1;;52656:11:0;;;52442:428::o;52610:253::-;52686:18;52696:7;52686:9;:18::i;:::-;52708:1;52686:23;52683:180;;;-1:-1:-1;;52729:13:0;;;52442:428::o;52683:180::-;52761:18;52771:7;52761:9;:18::i;:::-;52783:1;52761:23;52758:105;;;-1:-1:-1;;52804:13:0;;;52442:428::o;52758:105::-;-1:-1:-1;52851:1:0;;52442:428;-1:-1:-1;52442:428:0:o;52758:105::-;52442:428;;;:::o;52892:197::-;52966:7;;53049:3;53029:17;53039:7;53029;:17;:::i;:::-;:23;;;;:::i;:::-;53015:37;52892:197;-1:-1:-1;;;;52892:197:0:o;47196:211::-;47340:58;;;-1:-1:-1;;;;;5901:32:1;;47340:58:0;;;5883:51:1;5950:18;;;;5943:34;;;47340:58:0;;;;;;;;;;5856:18:1;;;;47340:58:0;;;;;;;;-1:-1:-1;;;;;47340:58:0;-1:-1:-1;;;47340:58:0;;;47313:86;;47333:5;;47313:19;:86::i;:::-;47196:211;;;:::o;35453:120::-;34465:7;;;;34989:41;;;;-1:-1:-1;;;34989:41:0;;8375:2:1;34989:41:0;;;8357:21:1;8414:2;8394:18;;;8387:30;-1:-1:-1;;;8433:18:1;;;8426:50;8493:18;;34989:41:0;8173:344:1;34989:41:0;35512:7:::1;:15:::0;;-1:-1:-1;;35512:15:0::1;::::0;;35543:22:::1;691:10:::0;35552:12:::1;35543:22;::::0;-1:-1:-1;;;;;5105:32:1;;;5087:51;;5075:2;5060:18;35543:22:0::1;;;;;;;35453:120::o:0;27493:131::-;27560:4;27584:32;27589:3;27609:5;27584:4;:32::i;3013:191::-;3087:16;3106:6;;-1:-1:-1;;;;;3123:17:0;;;-1:-1:-1;;;;;;3123:17:0;;;;;;3156:40;;3106:6;;;;;;;3156:40;;3087:16;3156:40;3076:128;3013:191;:::o;35194:118::-;34465:7;;;;34719:9;34711:38;;;;-1:-1:-1;;;34711:38:0;;;;;;;:::i;:::-;35254:7:::1;:14:::0;;-1:-1:-1;;35254:14:0::1;35264:4;35254:14;::::0;;35284:20:::1;35291:12;691:10:::0;;611:98;27800:137;27870:4;27894:35;27902:3;27922:5;27894:7;:35::i;28255:114::-;28315:7;28342:19;28350:3;21284:18;;21201:109;28723:137;28794:7;28829:22;28833:3;28845:5;28829:3;:22::i;52285:149::-;52381:25;;52370:56;;-1:-1:-1;;;52370:56:0;;;;;13057:25:1;;;52345:7:0;;-1:-1:-1;;;;;52381:25:0;;52370:47;;13030:18:1;;52370:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;49769:716::-;50193:23;50219:69;50247:4;50219:69;;;;;;;;;;;;;;;;;50227:5;-1:-1:-1;;;;;50219:27:0;;;:69;;;;;:::i;:::-;50303:17;;50193:95;;-1:-1:-1;50303:21:0;50299:179;;50400:10;50389:30;;;;;;;;;;;;:::i;:::-;50381:85;;;;-1:-1:-1;;;50381:85:0;;11999:2:1;50381:85:0;;;11981:21:1;12038:2;12018:18;;;12011:30;12077:34;12057:18;;;12050:62;-1:-1:-1;;;12128:18:1;;;12121:40;12178:19;;50381:85:0;11797:406:1;18890:414:0;18953:4;21083:19;;;:12;;;:19;;;;;;18970:327;;-1:-1:-1;19013:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;19196:18;;19174:19;;;:12;;;:19;;;;;;:40;;;;19229:11;;18970:327;-1:-1:-1;19280:5:0;19273:12;;19480:1420;19546:4;19685:19;;;:12;;;:19;;;;;;19721:15;;19717:1176;;20096:21;20120:14;20133:1;20120:10;:14;:::i;:::-;20169:18;;20096:38;;-1:-1:-1;20149:17:0;;20169:22;;20190:1;;20169:22;:::i;:::-;20149:42;;20225:13;20212:9;:26;20208:405;;20259:17;20279:3;:11;;20291:9;20279:22;;;;;;;;:::i;:::-;;;;;;;;;20259:42;;20433:9;20404:3;:11;;20416:13;20404:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;20518:23;;;:12;;;:23;;;;;:36;;;20208:405;20694:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;20789:3;:12;;:19;20802:5;20789:19;;;;;;;;;;;20782:26;;;20832:4;20825:11;;;;;;;19717:1176;20876:5;20869:12;;;;;21664:120;21731:7;21758:3;:11;;21770:5;21758:18;;;;;;;;:::i;:::-;;;;;;;;;21751:25;;21664:120;;;;:::o;42147:229::-;42284:12;42316:52;42338:6;42346:4;42352:1;42355:12;42284;-1:-1:-1;;;;;39697:19:0;;;43554:60;;;;-1:-1:-1;;;43554:60:0;;11641:2:1;43554:60:0;;;11623:21:1;11680:2;11660:18;;;11653:30;11719:31;11699:18;;;11692:59;11768:18;;43554:60:0;11439:353:1;43554:60:0;43628:12;43642:23;43669:6;-1:-1:-1;;;;;43669:11:0;43688:5;43695:4;43669:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43627:73;;;;43718:51;43735:7;43744:10;43756:12;43718:16;:51::i;:::-;43711:58;43267:510;-1:-1:-1;;;;;;;43267:510:0:o;45953:712::-;46103:12;46132:7;46128:530;;;-1:-1:-1;46163:10:0;46156:17;;46128:530;46277:17;;:21;46273:374;;46475:10;46469:17;46536:15;46523:10;46519:2;46515:19;46508:44;46273:374;46618:12;46611:20;;-1:-1:-1;;;46611:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;192:186;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;383:808::-;480:6;488;496;504;512;565:3;553:9;544:7;540:23;536:33;533:53;;;582:1;579;572:12;533:53;605:29;624:9;605:29;:::i;:::-;595:39;;653:38;687:2;676:9;672:18;653:38;:::i;:::-;643:48;;738:2;727:9;723:18;710:32;700:42;;793:2;782:9;778:18;765:32;816:18;857:2;849:6;846:14;843:34;;;873:1;870;863:12;843:34;911:6;900:9;896:22;886:32;;956:7;949:4;945:2;941:13;937:27;927:55;;978:1;975;968:12;927:55;1018:2;1005:16;1044:2;1036:6;1033:14;1030:34;;;1060:1;1057;1050:12;1030:34;1105:7;1100:2;1091:6;1087:2;1083:15;1079:24;1076:37;1073:57;;;1126:1;1123;1116:12;1073:57;383:808;;;;-1:-1:-1;383:808:1;;-1:-1:-1;1157:2:1;1149:11;;1179:6;383:808;-1:-1:-1;;;383:808:1:o;1196:1200::-;1289:6;1297;1350:2;1338:9;1329:7;1325:23;1321:32;1318:52;;;1366:1;1363;1356:12;1318:52;1389:29;1408:9;1389:29;:::i;:::-;1379:39;;1437:2;1490;1479:9;1475:18;1462:32;1513:18;1554:2;1546:6;1543:14;1540:34;;;1570:1;1567;1560:12;1540:34;1608:6;1597:9;1593:22;1583:32;;1653:7;1646:4;1642:2;1638:13;1634:27;1624:55;;1675:1;1672;1665:12;1624:55;1711:2;1698:16;1733:2;1729;1726:10;1723:36;;;1739:18;;:::i;:::-;1785:2;1782:1;1778:10;1817:2;1811:9;1880:2;1876:7;1871:2;1867;1863:11;1859:25;1851:6;1847:38;1935:6;1923:10;1920:22;1915:2;1903:10;1900:18;1897:46;1894:72;;;1946:18;;:::i;:::-;1982:2;1975:22;2032:18;;;2066:15;;;;-1:-1:-1;2101:11:1;;;2131;;;2127:20;;2124:33;-1:-1:-1;2121:53:1;;;2170:1;2167;2160:12;2121:53;2192:1;2183:10;;2202:163;2216:2;2213:1;2210:9;2202:163;;;2273:17;;2261:30;;2234:1;2227:9;;;;;2311:12;;;;2343;;2202:163;;;2206:3;2384:6;2374:16;;;;;;;;1196:1200;;;;;:::o;2401:254::-;2469:6;2477;2530:2;2518:9;2509:7;2505:23;2501:32;2498:52;;;2546:1;2543;2536:12;2498:52;2569:29;2588:9;2569:29;:::i;:::-;2559:39;2645:2;2630:18;;;;2617:32;;-1:-1:-1;;;2401:254:1:o;2660:615::-;2746:6;2754;2807:2;2795:9;2786:7;2782:23;2778:32;2775:52;;;2823:1;2820;2813:12;2775:52;2863:9;2850:23;2892:18;2933:2;2925:6;2922:14;2919:34;;;2949:1;2946;2939:12;2919:34;2987:6;2976:9;2972:22;2962:32;;3032:7;3025:4;3021:2;3017:13;3013:27;3003:55;;3054:1;3051;3044:12;3003:55;3094:2;3081:16;3120:2;3112:6;3109:14;3106:34;;;3136:1;3133;3126:12;3106:34;3189:7;3184:2;3174:6;3171:1;3167:14;3163:2;3159:23;3155:32;3152:45;3149:65;;;3210:1;3207;3200:12;3149:65;3241:2;3233:11;;;;;3263:6;;-1:-1:-1;2660:615:1;;-1:-1:-1;;;;2660:615:1:o;3280:241::-;3336:6;3389:2;3377:9;3368:7;3364:23;3360:32;3357:52;;;3405:1;3402;3395:12;3357:52;3444:9;3431:23;3463:28;3485:5;3463:28;:::i;3526:245::-;3593:6;3646:2;3634:9;3625:7;3621:23;3617:32;3614:52;;;3662:1;3659;3652:12;3614:52;3694:9;3688:16;3713:28;3735:5;3713:28;:::i;3776:180::-;3835:6;3888:2;3876:9;3867:7;3863:23;3859:32;3856:52;;;3904:1;3901;3894:12;3856:52;-1:-1:-1;3927:23:1;;3776:180;-1:-1:-1;3776:180:1:o;3961:184::-;4031:6;4084:2;4072:9;4063:7;4059:23;4055:32;4052:52;;;4100:1;4097;4090:12;4052:52;-1:-1:-1;4123:16:1;;3961:184;-1:-1:-1;3961:184:1:o;4150:254::-;4218:6;4226;4279:2;4267:9;4258:7;4254:23;4250:32;4247:52;;;4295:1;4292;4285:12;4247:52;4331:9;4318:23;4308:33;;4360:38;4394:2;4383:9;4379:18;4360:38;:::i;:::-;4350:48;;4150:254;;;;;:::o;4409:248::-;4477:6;4485;4538:2;4526:9;4517:7;4513:23;4509:32;4506:52;;;4554:1;4551;4544:12;4506:52;-1:-1:-1;;4577:23:1;;;4647:2;4632:18;;;4619:32;;-1:-1:-1;4409:248:1:o;4662:274::-;4791:3;4829:6;4823:13;4845:53;4891:6;4886:3;4879:4;4871:6;4867:17;4845:53;:::i;:::-;4914:16;;;;;4662:274;-1:-1:-1;;4662:274:1:o;5988:632::-;6159:2;6211:21;;;6281:13;;6184:18;;;6303:22;;;6130:4;;6159:2;6382:15;;;;6356:2;6341:18;;;6130:4;6425:169;6439:6;6436:1;6433:13;6425:169;;;6500:13;;6488:26;;6569:15;;;;6534:12;;;;6461:1;6454:9;6425:169;;;-1:-1:-1;6611:3:1;;5988:632;-1:-1:-1;;;;;;5988:632:1:o;7024:383::-;7173:2;7162:9;7155:21;7136:4;7205:6;7199:13;7248:6;7243:2;7232:9;7228:18;7221:34;7264:66;7323:6;7318:2;7307:9;7303:18;7298:2;7290:6;7286:15;7264:66;:::i;:::-;7391:2;7370:15;-1:-1:-1;;7366:29:1;7351:45;;;;7398:2;7347:54;;7024:383;-1:-1:-1;;7024:383:1:o;9680:340::-;9882:2;9864:21;;;9921:2;9901:18;;;9894:30;-1:-1:-1;;;9955:2:1;9940:18;;9933:46;10011:2;9996:18;;9680:340::o;10369:356::-;10571:2;10553:21;;;10590:18;;;10583:30;10649:34;10644:2;10629:18;;10622:62;10716:2;10701:18;;10369:356::o;12208:355::-;12410:2;12392:21;;;12449:2;12429:18;;;12422:30;12488:33;12483:2;12468:18;;12461:61;12554:2;12539:18;;12208:355::o;13093:128::-;13133:3;13164:1;13160:6;13157:1;13154:13;13151:39;;;13170:18;;:::i;:::-;-1:-1:-1;13206:9:1;;13093:128::o;13226:217::-;13266:1;13292;13282:132;;13336:10;13331:3;13327:20;13324:1;13317:31;13371:4;13368:1;13361:15;13399:4;13396:1;13389:15;13282:132;-1:-1:-1;13428:9:1;;13226:217::o;13448:168::-;13488:7;13554:1;13550;13546:6;13542:14;13539:1;13536:21;13531:1;13524:9;13517:17;13513:45;13510:71;;;13561:18;;:::i;:::-;-1:-1:-1;13601:9:1;;13448:168::o;13621:125::-;13661:4;13689:1;13686;13683:8;13680:34;;;13694:18;;:::i;:::-;-1:-1:-1;13731:9:1;;13621:125::o;13751:258::-;13823:1;13833:113;13847:6;13844:1;13841:13;13833:113;;;13923:11;;;13917:18;13904:11;;;13897:39;13869:2;13862:10;13833:113;;;13964:6;13961:1;13958:13;13955:48;;;-1:-1:-1;;13999:1:1;13981:16;;13974:27;13751:258::o;14014:135::-;14053:3;-1:-1:-1;;14074:17:1;;14071:43;;;14094:18;;:::i;:::-;-1:-1:-1;14141:1:1;14130:13;;14014:135::o;14154:127::-;14215:10;14210:3;14206:20;14203:1;14196:31;14246:4;14243:1;14236:15;14270:4;14267:1;14260:15;14286:127;14347:10;14342:3;14338:20;14335:1;14328:31;14378:4;14375:1;14368:15;14402:4;14399:1;14392:15;14418:127;14479:10;14474:3;14470:20;14467:1;14460:31;14510:4;14507:1;14500:15;14534:4;14531:1;14524:15;14550:127;14611:10;14606:3;14602:20;14599:1;14592:31;14642:4;14639:1;14632:15;14666:4;14663:1;14656:15;14682:118;14768:5;14761:13;14754:21;14747:5;14744:32;14734:60;;14790:1;14787;14780:12

ipfs://38458d8b5c25e40ca0314b044f4b3566a78c9375eb05d11c74bef11be303c139