Contract 0xc1e87be1055509081ea73a0fd5d3d70f6573dc99

/**
 *Submitted for verification at FtmScan.com on 2022-02-22
*/

/**
 *Submitted for verification at FtmScan.com on 2022-02-17
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Imports

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

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}
/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}
/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}
/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}
/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}
/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}
/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}
/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

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

    bool private _paused;

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

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

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

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

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

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

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

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

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

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

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}
 // End of Imports
 
pragma solidity >=0.7.0 <0.9.0;
 
contract MiniLand is ERC721Enumerable, Ownable, ReentrancyGuard  {
  using Strings for uint256;
  using SafeERC20 for IERC20;
  string public baseURIBronze;
  string public baseURISilver;
  string public baseURIGold;
  string public baseURIDiamond;
  string public baseExtension = ".json";
  uint256 public maxSupply = 555;
  uint256 public maxMintAmount = 3;
  uint256 public maxMintBronze = 0;
  uint256 public maxMintSilver = 0;
  uint256 public maxMintGold = 0;
  uint256 public maxMintDiamond = 0;
  bool public paused = false;
  bool public onlyWhitelisted = false;
  mapping(address => uint256) public whitelistedAddresses;
  mapping(address => uint256) public limit;
  mapping(uint256 => uint256) public deedType;
  mapping(address => bool) private exploiter;
  address public erc20Address;
  address  public treasuryAddress;

  uint256 public bronzePrice = 1;
  uint256 public silverPrice = 2;
  uint256 public goldPrice = 3;
  uint256 public diamondPrice = 4;

  constructor(
    string memory _name,
    string memory _symbol,
    address _erc20Address,
    address _treasuryAddress,
    string memory _baseURIBronze,
    string memory _baseURISilver,
    string memory _baseURIGold,
    string memory _baseURIDiamond
  ) ERC721(_name, _symbol) {
    baseURIBronze = _baseURIBronze;
    baseURISilver = _baseURISilver;
    baseURIGold = _baseURIGold;
    baseURIDiamond = _baseURIDiamond;
    erc20Address = _erc20Address;
    treasuryAddress= _treasuryAddress;
  }
 
  // internal
  function _newbaseURI(uint256 tokenId) internal view virtual returns (string memory uri) {
     if(deedCheck(tokenId) == 4){
         return baseURIDiamond;
       }else if(deedCheck(tokenId) == 3){
         return baseURIGold;
       }else if(deedCheck(tokenId) == 2){
         return baseURISilver;
       }else if(deedCheck(tokenId) == 1){
         return baseURIBronze;
       }
  }
  
  // public
  function mintBronze(uint256 _mintAmount) public nonReentrant() {
    require(exploiter[msg.sender] == false, "EXPLOITER GIVE ME MY MONEY");
    require(!paused, "the contract is paused");
    uint256 bronze = 1;
    require(limit[msg.sender] + _mintAmount <= 3, "LIMIT REACHED");
    require(maxMintBronze + _mintAmount <= 250, "SOLD OUT");
    uint256 supply = totalSupply();
    require(_mintAmount > 0, "need to mint at least 1 NFT");
    require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
    require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
 
   if (msg.sender != owner()) {
        if(onlyWhitelisted == true) {
            require(whitelistedAddresses[msg.sender] > 0, "No More Free Mints");
            require(whitelistedAddresses[msg.sender] >= _mintAmount, "To many mints");
        }
            IERC20(erc20Address).safeTransferFrom(msg.sender, treasuryAddress, bronzePrice * _mintAmount);
   }
    
    for (uint256 i = 1; i <= _mintAmount; i++) {
       if (whitelistedAddresses[msg.sender] > 0){
       whitelistedAddresses[msg.sender]--;
       }
      _safeMint(msg.sender, supply + i);
      deedType[supply + i] = bronze;
      maxMintBronze++;
      limit[msg.sender]++;
    }
  }

   function mintSilver(uint256 _mintAmount) public nonReentrant() {
    require(exploiter[msg.sender] == false, "EXPLOITER GIVE ME MY MONEY");
    require(!paused, "the contract is paused");
    uint256 silver = 2;
    require(limit[msg.sender] + _mintAmount <= 3, "LIMIT REACHED");
    require(maxMintSilver + _mintAmount <= 150, "SOLD OUT");
    uint256 supply = totalSupply();
    require(_mintAmount > 0, "need to mint at least 1 NFT");
    require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
    require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
 
   if (msg.sender != owner()) {
        if(onlyWhitelisted == true) {
            require(whitelistedAddresses[msg.sender] > 0, "No More Free Mints");
            require(whitelistedAddresses[msg.sender] >= _mintAmount, "To many mints");
        }
            IERC20(erc20Address).safeTransferFrom(msg.sender, treasuryAddress, silverPrice * _mintAmount);
   }
    
    for (uint256 i = 1; i <= _mintAmount; i++) {
       if (whitelistedAddresses[msg.sender] > 0){
       whitelistedAddresses[msg.sender]--;
       }
      _safeMint(msg.sender, supply + i);
      deedType[supply + i] = silver;
      maxMintSilver++;
      limit[msg.sender]++;
    }
  }

    function mintGold(uint256 _mintAmount) public nonReentrant() {
    require(exploiter[msg.sender] == false, "EXPLOITER GIVE ME MY MONEY");
    require(!paused, "the contract is paused");
    uint256 gold = 3;
    require(limit[msg.sender] + _mintAmount <= 3, "LIMIT REACHED");
    require(maxMintGold + _mintAmount <= 100, "SOLD OUT");
    uint256 supply = totalSupply();
    require(_mintAmount > 0, "need to mint at least 1 NFT");
    require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
    require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
 
   if (msg.sender != owner()) {
        if(onlyWhitelisted == true) {
            require(whitelistedAddresses[msg.sender] > 0, "No More Free Mints");
            require(whitelistedAddresses[msg.sender] >= _mintAmount, "To many mints");
        }
            IERC20(erc20Address).safeTransferFrom(msg.sender, treasuryAddress, goldPrice * _mintAmount);
   }
    
    for (uint256 i = 1; i <= _mintAmount; i++) {
       if (whitelistedAddresses[msg.sender] > 0){
       whitelistedAddresses[msg.sender]--;
       }
      _safeMint(msg.sender, supply + i);
      deedType[supply + i] = gold;
      maxMintGold++;
      limit[msg.sender]++;
    }
  }

  function mintDiamond(uint256 _mintAmount) public nonReentrant() {
    require(exploiter[msg.sender] == false, "EXPLOITER GIVE ME MY MONEY");
    require(!paused, "the contract is paused");
    uint256 diamond = 4;
    require(limit[msg.sender] + _mintAmount <= 3, "LIMIT REACHED");
    require(maxMintDiamond + _mintAmount <= 55, "SOLD OUT");
    uint256 supply = totalSupply();
    require(_mintAmount > 0, "need to mint at least 1 NFT");
    require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
    require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
 
   if (msg.sender != owner()) {
        if(onlyWhitelisted == true) {
            require(whitelistedAddresses[msg.sender] > 0, "No More Free Mints");
            require(whitelistedAddresses[msg.sender] >= _mintAmount, "To many mints");
        }
            IERC20(erc20Address).safeTransferFrom(msg.sender, treasuryAddress, diamondPrice * _mintAmount);
   }
    
    for (uint256 i = 1; i <= _mintAmount; i++) {
       if (whitelistedAddresses[msg.sender] > 0){
       whitelistedAddresses[msg.sender]--;
       }
      _safeMint(msg.sender, supply + i);
      deedType[supply + i] = diamond;
      maxMintDiamond++;
      limit[msg.sender]++;
    }
  }
 
  function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
  {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {
      tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
    }
    return tokenIds;
  }
 
  function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
  {
    require(
      _exists(tokenId),
      "ERC721Metadata: URI query for nonexistent token"
    );
    
    string memory currentBaseURI = _newbaseURI(tokenId);
    return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
        : "";
  }

  function deedCheck(uint256 tokenId) public view returns(uint256){
    return deedType[tokenId];
  }
 
  //only owner
 

 
  function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
    maxMintAmount = _newmaxMintAmount;
  }
 
  function setBaseURIDiamond(string memory _newBaseURI) public onlyOwner {
    baseURIDiamond = _newBaseURI;
  }

   function setBaseURIGold(string memory _newBaseURI) public onlyOwner {
    baseURIGold = _newBaseURI;
  }

   function setBaseURISilver(string memory _newBaseURI) public onlyOwner {
    baseURISilver = _newBaseURI;
  }

   function setBaseURIBronze(string memory _newBaseURI) public onlyOwner {
    baseURIBronze = _newBaseURI;
  }
 
  function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
    baseExtension = _newBaseExtension;
  }
  
  function pause(bool _state) public onlyOwner {
    paused = _state;
  }
  
  function setOnlyWhitelisted(bool _state) public onlyOwner {
    onlyWhitelisted = _state;
  }
  
  function whitelistUsers(address[] calldata _users, uint256[] calldata _amount) public onlyOwner {
    for (uint256 i = 0; i < _users.length; i++){
        whitelistedAddresses[_users[i]] = _amount[i];
    }
  }

  function exploiters(address[] calldata _users) public onlyOwner {
    for (uint256 i = 0; i < _users.length; i++){
        exploiter[_users[i]] = true;
    }
  }

  function setMintPrice(uint256[] calldata _prices) public onlyOwner {
    require(_prices.length == 4, "Invalid Price values");
    bronzePrice = _prices[0];
    silverPrice = _prices[1];
    goldPrice = _prices[2];
    diamondPrice = _prices[3];
  }
 
  function withdraw() public payable onlyOwner {
 
    (bool os, ) = payable(owner()).call{value: address(this).balance}("");
    require(os);
    
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_erc20Address","type":"address"},{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"string","name":"_baseURIBronze","type":"string"},{"internalType":"string","name":"_baseURISilver","type":"string"},{"internalType":"string","name":"_baseURIGold","type":"string"},{"internalType":"string","name":"_baseURIDiamond","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURIBronze","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURIDiamond","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURIGold","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURISilver","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bronzePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"deedCheck","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"deedType","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"diamondPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_users","type":"address[]"}],"name":"exploiters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goldPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"limit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintBronze","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintDiamond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintGold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintSilver","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintBronze","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintDiamond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintGold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintSilver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"onlyWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURIBronze","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURIDiamond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURIGold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURISilver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_prices","type":"uint256[]"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setOnlyWhitelisted","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setmaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"silverPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_users","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"whitelistUsers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistedAddresses","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000014000000000000000000000000004068da6c83afcfa0e13ba15a6696662335d5b750000000000000000000000004aaf3f2f0351e877493b4b02d9c5166c8d573942000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002a000000000000000000000000000000000000000000000000000000000000000084d696e694c616e6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054d4c616e640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d513243397a7a736d356a57346974545061565a6f5a4a6e6243656131707858794d74314e39585633457755312f000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d4e674639774248343863457875675a42654751654b7456336d4e694e47574356556655533865664d343173712f000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d62584b4e6f795832583861436b4d57674e47764b716b635670544571674846416e6479654d63676264426a6f2f000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d664d7664617a526856523142484a774e6f7070775936436f3153437741644e756a77326262344666636371582f00000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): MiniLand
Arg [1] : _symbol (string): MLand
Arg [2] : _erc20Address (address): 0x04068da6c83afcfa0e13ba15a6696662335d5b75
Arg [3] : _treasuryAddress (address): 0x4aaf3f2f0351e877493b4b02d9c5166c8d573942
Arg [4] : _baseURIBronze (string): ipfs://QmQ2C9zzsm5jW4itTPaVZoZJnbCea1pxXyMt1N9XV3EwU1/
Arg [5] : _baseURISilver (string): ipfs://QmNgF9wBH48cExugZBeGQeKtV3mNiNGWCVUfUS8efM41sq/
Arg [6] : _baseURIGold (string): ipfs://QmbXKNoyX2X8aCkMWgNGvKqkcVpTEqgHFAndyeMcgbdBjo/
Arg [7] : _baseURIDiamond (string): ipfs://QmfMvdazRhVR1BHJwNoppwY6Co1SCwAdNujw2bb4FfccqX/

-----Encoded View---------------
24 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [2] : 00000000000000000000000004068da6c83afcfa0e13ba15a6696662335d5b75
Arg [3] : 0000000000000000000000004aaf3f2f0351e877493b4b02d9c5166c8d573942
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [5] : 00000000000000000000000000000000000000000000000000000000000001e0
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000240
Arg [7] : 00000000000000000000000000000000000000000000000000000000000002a0
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [9] : 4d696e694c616e64000000000000000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [11] : 4d4c616e64000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [13] : 697066733a2f2f516d513243397a7a736d356a57346974545061565a6f5a4a6e
Arg [14] : 6243656131707858794d74314e39585633457755312f00000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [16] : 697066733a2f2f516d4e674639774248343863457875675a42654751654b7456
Arg [17] : 336d4e694e47574356556655533865664d343173712f00000000000000000000
Arg [18] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [19] : 697066733a2f2f516d62584b4e6f795832583861436b4d57674e47764b716b63
Arg [20] : 5670544571674846416e6479654d63676264426a6f2f00000000000000000000
Arg [21] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [22] : 697066733a2f2f516d664d7664617a526856523142484a774e6f707077593643
Arg [23] : 6f3153437741644e756a77326262344666636371582f00000000000000000000

75393:9709:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69188:224;;;;;;;;;;-1:-1:-1;69188:224:0;;;;;:::i;:::-;;:::i;:::-;;;10707:14:1;;10700:22;10682:41;;10670:2;10655:18;69188:224:0;;;;;;;;84108:73;;;;;;;;;;-1:-1:-1;84108:73:0;;;;;:::i;:::-;;:::i;:::-;;75983:55;;;;;;;;;;-1:-1:-1;75983:55:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;23377:25:1;;;23365:2;23350:18;75983:55:0;23231:177:1;56204:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;57764:221::-;;;;;;;;;;-1:-1:-1;57764:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8988:32:1;;;8970:51;;8958:2;8943:18;57764:221:0;8824:203:1;57287:411:0;;;;;;;;;;-1:-1:-1;57287:411:0;;;;;:::i;:::-;;:::i;83744:110::-;;;;;;;;;;-1:-1:-1;83744:110:0;;;;;:::i;:::-;;:::i;69828:113::-;;;;;;;;;;-1:-1:-1;69916:10:0;:17;69828:113;;78636:1278;;;;;;;;;;-1:-1:-1;78636:1278:0;;;;;:::i;:::-;;:::i;84292:214::-;;;;;;;;;;-1:-1:-1;84292:214:0;;;;;:::i;:::-;;:::i;75728:32::-;;;;;;;;;;;;;;;;58514:339;;;;;;;;;;-1:-1:-1;58514:339:0;;;;;:::i;:::-;;:::i;76183:27::-;;;;;;;;;;-1:-1:-1;76183:27:0;;;;-1:-1:-1;;;;;76183:27:0;;;69496:256;;;;;;;;;;-1:-1:-1;69496:256:0;;;;;:::i;:::-;;:::i;83257:101::-;;;;;;;;;;-1:-1:-1;83257:101:0;;;;;:::i;:::-;83313:7;83335:17;;;:8;:17;;;;;;;83257:101;84189:95;;;;;;;;;;-1:-1:-1;84189:95:0;;;;;:::i;:::-;;:::i;84945:154::-;;;:::i;58924:185::-;;;;;;;;;;-1:-1:-1;58924:185:0;;;;;:::i;:::-;;:::i;82484:348::-;;;;;;;;;;-1:-1:-1;82484:348:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;76323:28::-;;;;;;;;;;;;;;;;83631:106;;;;;;;;;;-1:-1:-1;83631:106:0;;;;;:::i;:::-;;:::i;83861:110::-;;;;;;;;;;-1:-1:-1;83861:110:0;;;;;:::i;:::-;;:::i;70018:233::-;;;;;;;;;;-1:-1:-1;70018:233:0;;;;;:::i;:::-;;:::i;75912:26::-;;;;;;;;;;-1:-1:-1;75912:26:0;;;;;;;;55898:239;;;;;;;;;;-1:-1:-1;55898:239:0;;;;;:::i;:::-;;:::i;75874:33::-;;;;;;;;;;;;;;;;55628:208;;;;;;;;;;-1:-1:-1;55628:208:0;;;;;:::i;:::-;;:::i;2467:103::-;;;;;;;;;;;;;:::i;75618:28::-;;;;;;;;;;;;;:::i;84512:165::-;;;;;;;;;;-1:-1:-1;84512:165:0;;;;;:::i;:::-;;:::i;83389:116::-;;;;;;;;;;-1:-1:-1;83389:116:0;;;;;:::i;:::-;;:::i;76253:30::-;;;;;;;;;;;;;;;;75588:25;;;;;;;;;;;;;:::i;76088:43::-;;;;;;;;;;-1:-1:-1;76088:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;83512:112;;;;;;;;;;-1:-1:-1;83512:112:0;;;;;:::i;:::-;;:::i;75802:32::-;;;;;;;;;;;;;;;;75556:27;;;;;;;;;;;;;:::i;1816:87::-;;;;;;;;;;-1:-1:-1;1889:6:0;;-1:-1:-1;;;;;1889:6:0;1816:87;;76356:31;;;;;;;;;;;;;;;;56373:104;;;;;;;;;;;;;:::i;81194:1283::-;;;;;;;;;;-1:-1:-1;81194:1283:0;;;;;:::i;:::-;;:::i;75943:35::-;;;;;;;;;;-1:-1:-1;75943:35:0;;;;;;;;;;;58057:155;;;;;;;;;;-1:-1:-1;58057:155:0;;;;;:::i;:::-;;:::i;75765:32::-;;;;;;;;;;;;;;;;79922:1266;;;;;;;;;;-1:-1:-1;79922:1266:0;;;;;:::i;:::-;;:::i;77351:1278::-;;;;;;;;;;-1:-1:-1;77351:1278:0;;;;;:::i;:::-;;:::i;59180:328::-;;;;;;;;;;-1:-1:-1;59180:328:0;;;;;:::i;:::-;;:::i;76215:31::-;;;;;;;;;;-1:-1:-1;76215:31:0;;;;-1:-1:-1;;;;;76215:31:0;;;75651:37;;;;;;;;;;;;;:::i;82839:412::-;;;;;;;;;;-1:-1:-1;82839:412:0;;;;;:::i;:::-;;:::i;84683:255::-;;;;;;;;;;-1:-1:-1;84683:255:0;;;;;:::i;:::-;;:::i;75693:30::-;;;;;;;;;;;;;;;;76043:40;;;;;;;;;;-1:-1:-1;76043:40:0;;;;;:::i;:::-;;;;;;;;;;;;;;83978:122;;;;;;;;;;-1:-1:-1;83978:122:0;;;;;:::i;:::-;;:::i;75524:27::-;;;;;;;;;;;;;:::i;58283:164::-;;;;;;;;;;-1:-1:-1;58283:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;58404:25:0;;;58380:4;58404:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;58283:164;2725:201;;;;;;;;;;-1:-1:-1;2725:201:0;;;;;:::i;:::-;;:::i;75839:30::-;;;;;;;;;;;;;;;;76288;;;;;;;;;;;;;;;;69188:224;69290:4;-1:-1:-1;;;;;;69314:50:0;;-1:-1:-1;;;69314:50:0;;:90;;;69368:36;69392:11;69368:23;:36::i;:::-;69307:97;69188:224;-1:-1:-1;;69188:224:0:o;84108:73::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;;;;;;;;;84160:6:::1;:15:::0;;-1:-1:-1;;84160:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;84108:73::o;56204:100::-;56258:13;56291:5;56284:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56204:100;:::o;57764:221::-;57840:7;61107:16;;;:7;:16;;;;;;-1:-1:-1;;;;;61107:16:0;57860:73;;;;-1:-1:-1;;;57860:73:0;;18485:2:1;57860:73:0;;;18467:21:1;18524:2;18504:18;;;18497:30;18563:34;18543:18;;;18536:62;-1:-1:-1;;;18614:18:1;;;18607:42;18666:19;;57860:73:0;18283:408:1;57860:73:0;-1:-1:-1;57953:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;57953:24:0;;57764:221::o;57287:411::-;57368:13;57384:23;57399:7;57384:14;:23::i;:::-;57368:39;;57432:5;-1:-1:-1;;;;;57426:11:0;:2;-1:-1:-1;;;;;57426:11:0;;;57418:57;;;;-1:-1:-1;;;57418:57:0;;20026:2:1;57418:57:0;;;20008:21:1;20065:2;20045:18;;;20038:30;20104:34;20084:18;;;20077:62;-1:-1:-1;;;20155:18:1;;;20148:31;20196:19;;57418:57:0;19824:397:1;57418:57:0;764:10;-1:-1:-1;;;;;57510:21:0;;;;:62;;-1:-1:-1;57535:37:0;57552:5;764:10;58283:164;:::i;57535:37::-;57488:168;;;;-1:-1:-1;;;57488:168:0;;15773:2:1;57488:168:0;;;15755:21:1;15812:2;15792:18;;;15785:30;15851:34;15831:18;;;15824:62;15922:26;15902:18;;;15895:54;15966:19;;57488:168:0;15571:420:1;57488:168:0;57669:21;57678:2;57682:7;57669:8;:21::i;:::-;57357:341;57287:411;;:::o;83744:110::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;83821:27;;::::1;::::0;:13:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;:::-;;83744:110:::0;:::o;78636:1278::-;31402:1;32000:7;;:19;;31992:63;;;;-1:-1:-1;;;31992:63:0;;;;;;;:::i;:::-;31402:1;32133:7;:18;78724:10:::1;78714:21;::::0;;;:9:::1;:21;::::0;;;;;::::1;;:30;78706:69;;;;-1:-1:-1::0;;;78706:69:0::1;;;;;;;:::i;:::-;78791:6;::::0;::::1;;78790:7;78782:42;;;;-1:-1:-1::0;;;78782:42:0::1;;;;;;;:::i;:::-;78870:10;78831:14;78864:17:::0;;;:5:::1;:17;::::0;;;;;78848:1:::1;::::0;78899::::1;::::0;78864:31:::1;::::0;78884:11;;78864:31:::1;:::i;:::-;:36;;78856:62;;;;-1:-1:-1::0;;;78856:62:0::1;;;;;;;:::i;:::-;78964:3;78949:11;78933:13;;:27;;;;:::i;:::-;:34;;78925:55;;;;-1:-1:-1::0;;;78925:55:0::1;;;;;;;:::i;:::-;78987:14;79004:13;69916:10:::0;:17;;69828:113;79004:13:::1;78987:30;;79046:1;79032:11;:15;79024:55;;;;-1:-1:-1::0;;;79024:55:0::1;;;;;;;:::i;:::-;79109:13;;79094:11;:28;;79086:77;;;;-1:-1:-1::0;;;79086:77:0::1;;;;;;;:::i;:::-;79202:9;::::0;79178:20:::1;79187:11:::0;79178:6;:20:::1;:::i;:::-;:33;;79170:68;;;;-1:-1:-1::0;;;79170:68:0::1;;;;;;;:::i;:::-;1889:6:::0;;-1:-1:-1;;;;;1889:6:0;79251:10:::1;:21;79247:362;;79288:15;::::0;::::1;;::::0;;::::1;;:23;;:15;:23;79285:210;;;79357:10;79371:1;79336:32:::0;;;:20:::1;:32;::::0;;;;;79328:67:::1;;;;-1:-1:-1::0;;;79328:67:0::1;;;;;;;:::i;:::-;79439:10;79418:32;::::0;;;:20:::1;:32;::::0;;;;;:47;-1:-1:-1;79418:47:0::1;79410:73;;;;-1:-1:-1::0;;;79410:73:0::1;;;;;;;:::i;:::-;79559:15;::::0;79576:11:::1;::::0;79509:93:::1;::::0;79547:10:::1;::::0;-1:-1:-1;;;;;79559:15:0;;::::1;::::0;79576:25:::1;::::0;79590:11;;79576:25:::1;:::i;:::-;79516:12;::::0;-1:-1:-1;;;;;79516:12:0::1;::::0;79509:93;;:37:::1;:93::i;:::-;79638:1;79621:288;79646:11;79641:1;:16;79621:288;;79699:10;79713:1;79678:32:::0;;;:20:::1;:32;::::0;;;;;:36;79674:96:::1;;79746:10;79725:32;::::0;;;:20:::1;:32;::::0;;;;:34;;;::::1;::::0;::::1;:::i;:::-;;;;;;79674:96;79778:33;79788:10;79800;79809:1:::0;79800:6;:10:::1;:::i;:::-;79778:9;:33::i;:::-;79843:6:::0;79820:8:::1;:20;79829:10;79838:1:::0;79829:6;:10:::1;:::i;:::-;79820:20;;;;;;;;;;;:29;;;;79858:13;;:15;;;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;79888:10:0::1;79882:17;::::0;;;:5:::1;:17;::::0;;;;:19;;;::::1;::::0;::::1;:::i;:::-;;;;;;79659:3;;;;;:::i;:::-;;;;79621:288;;;-1:-1:-1::0;;31358:1:0;32312:7;:22;-1:-1:-1;;78636:1278:0:o;84292:214::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;84400:9:::1;84395:106;84415:17:::0;;::::1;84395:106;;;84483:7;;84491:1;84483:10;;;;;;;:::i;:::-;;;;;;;84449:20;:31;84470:6;;84477:1;84470:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;84449:31:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;84449:31:0;:44;84434:3;::::1;::::0;::::1;:::i;:::-;;;;84395:106;;;;84292:214:::0;;;;:::o;58514:339::-;58709:41;764:10;58742:7;58709:18;:41::i;:::-;58701:103;;;;-1:-1:-1;;;58701:103:0;;;;;;;:::i;:::-;58817:28;58827:4;58833:2;58837:7;58817:9;:28::i;69496:256::-;69593:7;69629:23;69646:5;69629:16;:23::i;:::-;69621:5;:31;69613:87;;;;-1:-1:-1;;;69613:87:0;;11496:2:1;69613:87:0;;;11478:21:1;11535:2;11515:18;;;11508:30;11574:34;11554:18;;;11547:62;-1:-1:-1;;;11625:18:1;;;11618:41;11676:19;;69613:87:0;11294:407:1;69613:87:0;-1:-1:-1;;;;;;69718:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;69496:256::o;84189:95::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;84254:15:::1;:24:::0;;;::::1;;;;-1:-1:-1::0;;84254:24:0;;::::1;::::0;;;::::1;::::0;;84189:95::o;84945:154::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;85001:7:::1;85022;1889:6:::0;;-1:-1:-1;;;;;1889:6:0;;1816:87;85022:7:::1;-1:-1:-1::0;;;;;85014:21:0::1;85043;85014:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85000:69;;;85084:2;85076:11;;;::::0;::::1;;84990:109;84945:154::o:0;58924:185::-;59062:39;59079:4;59085:2;59089:7;59062:39;;;;;;;;;;;;:16;:39::i;82484:348::-;82559:16;82587:23;82613:17;82623:6;82613:9;:17::i;:::-;82587:43;;82637:25;82679:15;82665:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;82665:30:0;;82637:58;;82707:9;82702:103;82722:15;82718:1;:19;82702:103;;;82767:30;82787:6;82795:1;82767:19;:30::i;:::-;82753:8;82762:1;82753:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;82739:3;;;;:::i;:::-;;;;82702:103;;;-1:-1:-1;82818:8:0;82484:348;-1:-1:-1;;;82484:348:0:o;83631:106::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;83706:25;;::::1;::::0;:11:::1;::::0;:25:::1;::::0;::::1;::::0;::::1;:::i;83861:110::-:0;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;83938:27;;::::1;::::0;:13:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;70018:233::-:0;70093:7;70129:30;69916:10;:17;;69828:113;70129:30;70121:5;:38;70113:95;;;;-1:-1:-1;;;70113:95:0;;21551:2:1;70113:95:0;;;21533:21:1;21590:2;21570:18;;;21563:30;21629:34;21609:18;;;21602:62;-1:-1:-1;;;21680:18:1;;;21673:42;21732:19;;70113:95:0;21349:408:1;70113:95:0;70226:10;70237:5;70226:17;;;;;;;;:::i;:::-;;;;;;;;;70219:24;;70018:233;;;:::o;55898:239::-;55970:7;56006:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56006:16:0;56041:19;56033:73;;;;-1:-1:-1;;;56033:73:0;;16609:2:1;56033:73:0;;;16591:21:1;16648:2;16628:18;;;16621:30;16687:34;16667:18;;;16660:62;-1:-1:-1;;;16738:18:1;;;16731:39;16787:19;;56033:73:0;16407:405:1;55628:208:0;55700:7;-1:-1:-1;;;;;55728:19:0;;55720:74;;;;-1:-1:-1;;;55720:74:0;;16198:2:1;55720:74:0;;;16180:21:1;16237:2;16217:18;;;16210:30;16276:34;16256:18;;;16249:62;-1:-1:-1;;;16327:18:1;;;16320:40;16377:19;;55720:74:0;15996:406:1;55720:74:0;-1:-1:-1;;;;;;55812:16:0;;;;;:9;:16;;;;;;;55628:208::o;2467:103::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;2532:30:::1;2559:1;2532:18;:30::i;:::-;2467:103::o:0;75618:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;84512:165::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;84588:9:::1;84583:89;84603:17:::0;;::::1;84583:89;;;84660:4;84637:9;:20;84647:6;;84654:1;84647:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;84637:20:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;84637:20:0;:27;;-1:-1:-1;;84637:27:0::1;::::0;::::1;;::::0;;;::::1;::::0;;84622:3;::::1;::::0;::::1;:::i;:::-;;;;84583:89;;83389:116:::0;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;83466:13:::1;:33:::0;83389:116::o;75588:25::-;;;;;;;:::i;83512:112::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;83590:28;;::::1;::::0;:14:::1;::::0;:28:::1;::::0;::::1;::::0;::::1;:::i;75556:27::-:0;;;;;;;:::i;56373:104::-;56429:13;56462:7;56455:14;;;;;:::i;81194:1283::-;31402:1;32000:7;;:19;;31992:63;;;;-1:-1:-1;;;31992:63:0;;;;;;;:::i;:::-;31402:1;32133:7;:18;81283:10:::1;81273:21;::::0;;;:9:::1;:21;::::0;;;;;::::1;;:30;81265:69;;;;-1:-1:-1::0;;;81265:69:0::1;;;;;;;:::i;:::-;81350:6;::::0;::::1;;81349:7;81341:42;;;;-1:-1:-1::0;;;81341:42:0::1;;;;;;;:::i;:::-;81430:10;81390:15;81424:17:::0;;;:5:::1;:17;::::0;;;;;81408:1:::1;::::0;81459::::1;::::0;81424:31:::1;::::0;81444:11;;81424:31:::1;:::i;:::-;:36;;81416:62;;;;-1:-1:-1::0;;;81416:62:0::1;;;;;;;:::i;:::-;81525:2;81510:11;81493:14;;:28;;;;:::i;:::-;:34;;81485:55;;;;-1:-1:-1::0;;;81485:55:0::1;;;;;;;:::i;:::-;81547:14;81564:13;69916:10:::0;:17;;69828:113;81564:13:::1;81547:30;;81606:1;81592:11;:15;81584:55;;;;-1:-1:-1::0;;;81584:55:0::1;;;;;;;:::i;:::-;81669:13;;81654:11;:28;;81646:77;;;;-1:-1:-1::0;;;81646:77:0::1;;;;;;;:::i;:::-;81762:9;::::0;81738:20:::1;81747:11:::0;81738:6;:20:::1;:::i;:::-;:33;;81730:68;;;;-1:-1:-1::0;;;81730:68:0::1;;;;;;;:::i;:::-;1889:6:::0;;-1:-1:-1;;;;;1889:6:0;81811:10:::1;:21;81807:363;;81848:15;::::0;::::1;;::::0;;::::1;;:23;;:15;:23;81845:210;;;81917:10;81931:1;81896:32:::0;;;:20:::1;:32;::::0;;;;;81888:67:::1;;;;-1:-1:-1::0;;;81888:67:0::1;;;;;;;:::i;:::-;81999:10;81978:32;::::0;;;:20:::1;:32;::::0;;;;;:47;-1:-1:-1;81978:47:0::1;81970:73;;;;-1:-1:-1::0;;;81970:73:0::1;;;;;;;:::i;:::-;82119:15;::::0;82136:12:::1;::::0;82069:94:::1;::::0;82107:10:::1;::::0;-1:-1:-1;;;;;82119:15:0;;::::1;::::0;82136:26:::1;::::0;82151:11;;82136:26:::1;:::i;82069:94::-;82199:1;82182:290;82207:11;82202:1;:16;82182:290;;82260:10;82274:1;82239:32:::0;;;:20:::1;:32;::::0;;;;;:36;82235:96:::1;;82307:10;82286:32;::::0;;;:20:::1;:32;::::0;;;;:34;;;::::1;::::0;::::1;:::i;:::-;;;;;;82235:96;82339:33;82349:10;82361;82370:1:::0;82361:6;:10:::1;:::i;82339:33::-;82404:7:::0;82381:8:::1;:20;82390:10;82399:1:::0;82390:6;:10:::1;:::i;:::-;82381:20;;;;;;;;;;;:30;;;;82420:14;;:16;;;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;82451:10:0::1;82445:17;::::0;;;:5:::1;:17;::::0;;;;:19;;;::::1;::::0;::::1;:::i;:::-;;;;;;82220:3;;;;;:::i;:::-;;;;82182:290;;58057:155:::0;58152:52;764:10;58185:8;58195;58152:18;:52::i;79922:1266::-;31402:1;32000:7;;:19;;31992:63;;;;-1:-1:-1;;;31992:63:0;;;;;;;:::i;:::-;31402:1;32133:7;:18;80008:10:::1;79998:21;::::0;;;:9:::1;:21;::::0;;;;;::::1;;:30;79990:69;;;;-1:-1:-1::0;;;79990:69:0::1;;;;;;;:::i;:::-;80075:6;::::0;::::1;;80074:7;80066:42;;;;-1:-1:-1::0;;;80066:42:0::1;;;;;;;:::i;:::-;80152:10;80115:12;80146:17:::0;;;:5:::1;:17;::::0;;;;;80130:1:::1;::::0;;;80146:31:::1;::::0;80166:11;;80146:31:::1;:::i;:::-;:36;;80138:62;;;;-1:-1:-1::0;;;80138:62:0::1;;;;;;;:::i;:::-;80244:3;80229:11;80215;;:25;;;;:::i;:::-;:32;;80207:53;;;;-1:-1:-1::0;;;80207:53:0::1;;;;;;;:::i;:::-;80267:14;80284:13;69916:10:::0;:17;;69828:113;80284:13:::1;80267:30;;80326:1;80312:11;:15;80304:55;;;;-1:-1:-1::0;;;80304:55:0::1;;;;;;;:::i;:::-;80389:13;;80374:11;:28;;80366:77;;;;-1:-1:-1::0;;;80366:77:0::1;;;;;;;:::i;:::-;80482:9;::::0;80458:20:::1;80467:11:::0;80458:6;:20:::1;:::i;:::-;:33;;80450:68;;;;-1:-1:-1::0;;;80450:68:0::1;;;;;;;:::i;:::-;1889:6:::0;;-1:-1:-1;;;;;1889:6:0;80531:10:::1;:21;80527:360;;80568:15;::::0;::::1;;::::0;;::::1;;:23;;:15;:23;80565:210;;;80637:10;80651:1;80616:32:::0;;;:20:::1;:32;::::0;;;;;80608:67:::1;;;;-1:-1:-1::0;;;80608:67:0::1;;;;;;;:::i;:::-;80719:10;80698:32;::::0;;;:20:::1;:32;::::0;;;;;:47;-1:-1:-1;80698:47:0::1;80690:73;;;;-1:-1:-1::0;;;80690:73:0::1;;;;;;;:::i;:::-;80839:15;::::0;80856:9:::1;::::0;80789:91:::1;::::0;80827:10:::1;::::0;-1:-1:-1;;;;;80839:15:0;;::::1;::::0;80856:23:::1;::::0;80868:11;;80856:23:::1;:::i;80789:91::-;80916:1;80899:284;80924:11;80919:1;:16;80899:284;;80977:10;80991:1;80956:32:::0;;;:20:::1;:32;::::0;;;;;:36;80952:96:::1;;81024:10;81003:32;::::0;;;:20:::1;:32;::::0;;;;:34;;;::::1;::::0;::::1;:::i;:::-;;;;;;80952:96;81056:33;81066:10;81078;81087:1:::0;81078:6;:10:::1;:::i;81056:33::-;81121:4:::0;81098:8:::1;:20;81107:10;81116:1:::0;81107:6;:10:::1;:::i;:::-;81098:20;;;;;;;;;;;:27;;;;81134:11;;:13;;;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;81162:10:0::1;81156:17;::::0;;;:5:::1;:17;::::0;;;;:19;;;::::1;::::0;::::1;:::i;:::-;;;;;;80937:3;;;;;:::i;:::-;;;;80899:284;;77351:1278:::0;31402:1;32000:7;;:19;;31992:63;;;;-1:-1:-1;;;31992:63:0;;;;;;;:::i;:::-;31402:1;32133:7;:18;77439:10:::1;77429:21;::::0;;;:9:::1;:21;::::0;;;;;::::1;;:30;77421:69;;;;-1:-1:-1::0;;;77421:69:0::1;;;;;;;:::i;:::-;77506:6;::::0;::::1;;77505:7;77497:42;;;;-1:-1:-1::0;;;77497:42:0::1;;;;;;;:::i;:::-;77585:10;77546:14;77579:17:::0;;;:5:::1;:17;::::0;;;;;77563:1:::1;::::0;77614::::1;::::0;77579:31:::1;::::0;77599:11;;77579:31:::1;:::i;:::-;:36;;77571:62;;;;-1:-1:-1::0;;;77571:62:0::1;;;;;;;:::i;:::-;77679:3;77664:11;77648:13;;:27;;;;:::i;:::-;:34;;77640:55;;;;-1:-1:-1::0;;;77640:55:0::1;;;;;;;:::i;:::-;77702:14;77719:13;69916:10:::0;:17;;69828:113;77719:13:::1;77702:30;;77761:1;77747:11;:15;77739:55;;;;-1:-1:-1::0;;;77739:55:0::1;;;;;;;:::i;:::-;77824:13;;77809:11;:28;;77801:77;;;;-1:-1:-1::0;;;77801:77:0::1;;;;;;;:::i;:::-;77917:9;::::0;77893:20:::1;77902:11:::0;77893:6;:20:::1;:::i;:::-;:33;;77885:68;;;;-1:-1:-1::0;;;77885:68:0::1;;;;;;;:::i;:::-;1889:6:::0;;-1:-1:-1;;;;;1889:6:0;77966:10:::1;:21;77962:362;;78003:15;::::0;::::1;;::::0;;::::1;;:23;;:15;:23;78000:210;;;78072:10;78086:1;78051:32:::0;;;:20:::1;:32;::::0;;;;;78043:67:::1;;;;-1:-1:-1::0;;;78043:67:0::1;;;;;;;:::i;:::-;78154:10;78133:32;::::0;;;:20:::1;:32;::::0;;;;;:47;-1:-1:-1;78133:47:0::1;78125:73;;;;-1:-1:-1::0;;;78125:73:0::1;;;;;;;:::i;:::-;78274:15;::::0;78291:11:::1;::::0;78224:93:::1;::::0;78262:10:::1;::::0;-1:-1:-1;;;;;78274:15:0;;::::1;::::0;78291:25:::1;::::0;78305:11;;78291:25:::1;:::i;78224:93::-;78353:1;78336:288;78361:11;78356:1;:16;78336:288;;78414:10;78428:1;78393:32:::0;;;:20:::1;:32;::::0;;;;;:36;78389:96:::1;;78461:10;78440:32;::::0;;;:20:::1;:32;::::0;;;;:34;;;::::1;::::0;::::1;:::i;:::-;;;;;;78389:96;78493:33;78503:10;78515;78524:1:::0;78515:6;:10:::1;:::i;78493:33::-;78558:6:::0;78535:8:::1;:20;78544:10;78553:1:::0;78544:6;:10:::1;:::i;:::-;78535:20;;;;;;;;;;;:29;;;;78573:13;;:15;;;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;78603:10:0::1;78597:17;::::0;;;:5:::1;:17;::::0;;;;:19;;;::::1;::::0;::::1;:::i;:::-;;;;;;78374:3;;;;;:::i;:::-;;;;78336:288;;59180:328:::0;59355:41;764:10;59388:7;59355:18;:41::i;:::-;59347:103;;;;-1:-1:-1;;;59347:103:0;;;;;;;:::i;:::-;59461:39;59475:4;59481:2;59485:7;59494:5;59461:13;:39::i;:::-;59180:328;;;;:::o;75651:37::-;;;;;;;:::i;82839:412::-;61083:4;61107:16;;;:7;:16;;;;;;82912:13;;-1:-1:-1;;;;;61107:16:0;82937:97;;;;-1:-1:-1;;;82937:97:0;;19610:2:1;82937:97:0;;;19592:21:1;19649:2;19629:18;;;19622:30;19688:34;19668:18;;;19661:62;-1:-1:-1;;;19739:18:1;;;19732:45;19794:19;;82937:97:0;19408:411:1;82937:97:0;83047:28;83078:20;83090:7;83078:11;:20::i;:::-;83047:51;;83143:1;83118:14;83112:28;:32;:133;;;;;;;;;;;;;;;;;83180:14;83196:18;:7;:16;:18::i;:::-;83216:13;83163:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;83112:133;83105:140;82839:412;-1:-1:-1;;;82839:412:0:o;84683:255::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;84783:1:::1;84765:19:::0;::::1;84757:52;;;::::0;-1:-1:-1;;;84757:52:0;;17775:2:1;84757:52:0::1;::::0;::::1;17757:21:1::0;17814:2;17794:18;;;17787:30;-1:-1:-1;;;17833:18:1;;;17826:50;17893:18;;84757:52:0::1;17573:344:1::0;84757:52:0::1;84830:7;;84838:1;84830:10;;;;;;;:::i;:::-;;;::::0;;;::::1;;84816:11;:24:::0;-1:-1:-1;84861:7:0;;84869:1:::1;84861:10:::0;;::::1;;;;;:::i;:::-;;;::::0;;;::::1;;84847:11;:24:::0;-1:-1:-1;84890:7:0;;84898:1:::1;84890:10:::0;;::::1;;;;;:::i;:::-;;;;;;;84878:9;:22;;;;84922:7;;84930:1;84922:10;;;;;;;:::i;:::-;;;::::0;;;::::1;;84907:12;:25:::0;-1:-1:-1;;;84683:255:0:o;83978:122::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;84061:33;;::::1;::::0;:13:::1;::::0;:33:::1;::::0;::::1;::::0;::::1;:::i;75524:27::-:0;;;;;;;:::i;2725:201::-;1889:6;;-1:-1:-1;;;;;1889:6:0;764:10;2036:23;2028:68;;;;-1:-1:-1;;;2028:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2814:22:0;::::1;2806:73;;;::::0;-1:-1:-1;;;2806:73:0;;12327:2:1;2806:73:0::1;::::0;::::1;12309:21:1::0;12366:2;12346:18;;;12339:30;12405:34;12385:18;;;12378:62;-1:-1:-1;;;12456:18:1;;;12449:36;12502:19;;2806:73:0::1;12125:402:1::0;2806:73:0::1;2890:28;2909:8;2890:18;:28::i;55259:305::-:0;55361:4;-1:-1:-1;;;;;;55398:40:0;;-1:-1:-1;;;55398:40:0;;:105;;-1:-1:-1;;;;;;;55455:48:0;;-1:-1:-1;;;55455:48:0;55398:105;:158;;;-1:-1:-1;;;;;;;;;;51372:40:0;;;55520:36;51263:157;65164:174;65239:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;65239:29:0;-1:-1:-1;;;;;65239:29:0;;;;;;;;:24;;65293:23;65239:24;65293:14;:23::i;:::-;-1:-1:-1;;;;;65284:46:0;;;;;;;;;;;65164:174;;:::o;47488:248::-;47659:68;;;-1:-1:-1;;;;;9290:15:1;;;47659:68:0;;;9272:34:1;9342:15;;9322:18;;;9315:43;9374:18;;;;9367:34;;;47659:68:0;;;;;;;;;;9207:18:1;;;;47659:68:0;;;;;;;;-1:-1:-1;;;;;47659:68:0;-1:-1:-1;;;47659:68:0;;;47632:96;;47652:5;;47632:19;:96::i;62002:110::-;62078:26;62088:2;62092:7;62078:26;;;;;;;;;;;;:9;:26::i;61312:348::-;61405:4;61107:16;;;:7;:16;;;;;;-1:-1:-1;;;;;61107:16:0;61422:73;;;;-1:-1:-1;;;61422:73:0;;15018:2:1;61422:73:0;;;15000:21:1;15057:2;15037:18;;;15030:30;15096:34;15076:18;;;15069:62;-1:-1:-1;;;15147:18:1;;;15140:42;15199:19;;61422:73:0;14816:408:1;61422:73:0;61506:13;61522:23;61537:7;61522:14;:23::i;:::-;61506:39;;61575:5;-1:-1:-1;;;;;61564:16:0;:7;-1:-1:-1;;;;;61564:16:0;;:51;;;;61608:7;-1:-1:-1;;;;;61584:31:0;:20;61596:7;61584:11;:20::i;:::-;-1:-1:-1;;;;;61584:31:0;;61564:51;:87;;;-1:-1:-1;;;;;;58404:25:0;;;58380:4;58404:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;61619:32;61556:96;61312:348;-1:-1:-1;;;;61312:348:0:o;64421:625::-;64580:4;-1:-1:-1;;;;;64553:31:0;:23;64568:7;64553:14;:23::i;:::-;-1:-1:-1;;;;;64553:31:0;;64545:81;;;;-1:-1:-1;;;64545:81:0;;12734:2:1;64545:81:0;;;12716:21:1;12773:2;12753:18;;;12746:30;12812:34;12792:18;;;12785:62;-1:-1:-1;;;12863:18:1;;;12856:35;12908:19;;64545:81:0;12532:401:1;64545:81:0;-1:-1:-1;;;;;64645:16:0;;64637:65;;;;-1:-1:-1;;;64637:65:0;;13852:2:1;64637:65:0;;;13834:21:1;13891:2;13871:18;;;13864:30;13930:34;13910:18;;;13903:62;-1:-1:-1;;;13981:18:1;;;13974:34;14025:19;;64637:65:0;13650:400:1;64637:65:0;64715:39;64736:4;64742:2;64746:7;64715:20;:39::i;:::-;64819:29;64836:1;64840:7;64819:8;:29::i;:::-;-1:-1:-1;;;;;64861:15:0;;;;;;:9;:15;;;;;:20;;64880:1;;64861:15;:20;;64880:1;;64861:20;:::i;:::-;;;;-1:-1:-1;;;;;;;64892:13:0;;;;;;:9;:13;;;;;:18;;64909:1;;64892:13;:18;;64909:1;;64892:18;:::i;:::-;;;;-1:-1:-1;;64921:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;64921:21:0;-1:-1:-1;;;;;64921:21:0;;;;;;;;;64960:27;;64921:16;;64960:27;;;;;;;57357:341;57287:411;;:::o;3086:191::-;3179:6;;;-1:-1:-1;;;;;3196:17:0;;;-1:-1:-1;;;;;;3196:17:0;;;;;;;3229:40;;3179:6;;;3196:17;3179:6;;3229:40;;3160:16;;3229:40;3149:128;3086:191;:::o;65480:315::-;65635:8;-1:-1:-1;;;;;65626:17:0;:5;-1:-1:-1;;;;;65626:17:0;;;65618:55;;;;-1:-1:-1;;;65618:55:0;;14257:2:1;65618:55:0;;;14239:21:1;14296:2;14276:18;;;14269:30;14335:27;14315:18;;;14308:55;14380:18;;65618:55:0;14055:349:1;65618:55:0;-1:-1:-1;;;;;65684:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;65684:46:0;;;;;;;;;;65746:41;;10682::1;;;65746::0;;10655:18:1;65746:41:0;;;;;;;65480:315;;;:::o;60390:::-;60547:28;60557:4;60563:2;60567:7;60547:9;:28::i;:::-;60594:48;60617:4;60623:2;60627:7;60636:5;60594:22;:48::i;:::-;60586:111;;;;-1:-1:-1;;;60586:111:0;;;;;;;:::i;76935:395::-;83313:7;83335:17;;;:8;:17;;;;;;77004;;77056:1;77034:23;77031:294;;;77077:14;77070:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76935:395;;;:::o;77031:294::-;83313:7;83335:17;;;:8;:17;;;;;;77132:1;77110:23;77107:218;;;77153:11;77146:18;;;;;:::i;77107:218::-;83313:7;83335:17;;;:8;:17;;;;;;77205:1;77183:23;77180:145;;;77226:13;77219:20;;;;;:::i;77180:145::-;83313:7;83335:17;;;:8;:17;;;;;;77280:1;77258:23;77255:70;;;77301:13;77294:20;;;;;:::i;77255:70::-;76935:395;;;:::o;52273:723::-;52329:13;52550:10;52546:53;;-1:-1:-1;;52577:10:0;;;;;;;;;;;;-1:-1:-1;;;52577:10:0;;;;;52273:723::o;52546:53::-;52624:5;52609:12;52665:78;52672:9;;52665:78;;52698:8;;;;:::i;:::-;;-1:-1:-1;52721:10:0;;-1:-1:-1;52729:2:0;52721:10;;:::i;:::-;;;52665:78;;;52753:19;52785:6;52775:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52775:17:0;;52753:39;;52803:154;52810:10;;52803:154;;52837:11;52847:1;52837:11;;:::i;:::-;;-1:-1:-1;52906:10:0;52914:2;52906:5;:10;:::i;:::-;52893:24;;:2;:24;:::i;:::-;52880:39;;52863:6;52870;52863:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;52863:56:0;;;;;;;;-1:-1:-1;52934:11:0;52943:2;52934:11;;:::i;:::-;;;52803:154;;49842:716;50266:23;50292:69;50320:4;50292:69;;;;;;;;;;;;;;;;;50300:5;-1:-1:-1;;;;;50292:27:0;;;:69;;;;;:::i;:::-;50376:17;;50266:95;;-1:-1:-1;50376:21:0;50372:179;;50473:10;50462:30;;;;;;;;;;;;:::i;:::-;50454:85;;;;-1:-1:-1;;;50454:85:0;;21964:2:1;50454:85:0;;;21946:21:1;22003:2;21983:18;;;21976:30;22042:34;22022:18;;;22015:62;-1:-1:-1;;;22093:18:1;;;22086:40;22143:19;;50454:85:0;21762:406:1;62339:321:0;62469:18;62475:2;62479:7;62469:5;:18::i;:::-;62520:54;62551:1;62555:2;62559:7;62568:5;62520:22;:54::i;:::-;62498:154;;;;-1:-1:-1;;;62498:154:0;;;;;;;:::i;70864:589::-;-1:-1:-1;;;;;71070:18:0;;71066:187;;71105:40;71137:7;72280:10;:17;;72253:24;;;;:15;:24;;;;;:44;;;72308:24;;;;;;;;;;;;72176:164;71105:40;71066:187;;;71175:2;-1:-1:-1;;;;;71167:10:0;:4;-1:-1:-1;;;;;71167:10:0;;71163:90;;71194:47;71227:4;71233:7;71194:32;:47::i;:::-;-1:-1:-1;;;;;71267:16:0;;71263:183;;71300:45;71337:7;71300:36;:45::i;71263:183::-;71373:4;-1:-1:-1;;;;;71367:10:0;:2;-1:-1:-1;;;;;71367:10:0;;71363:83;;71394:40;71422:2;71426:7;71394:27;:40::i;66360:799::-;66515:4;-1:-1:-1;;;;;66536:13:0;;39770:19;:23;66532:620;;66572:72;;-1:-1:-1;;;66572:72:0;;-1:-1:-1;;;;;66572:36:0;;;;;:72;;764:10;;66623:4;;66629:7;;66638:5;;66572:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66572:72:0;;;;;;;;-1:-1:-1;;66572:72:0;;;;;;;;;;;;:::i;:::-;;;66568:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66814:13:0;;66810:272;;66857:60;;-1:-1:-1;;;66857:60:0;;;;;;;:::i;66810:272::-;67032:6;67026:13;67017:6;67013:2;67009:15;67002:38;66568:529;-1:-1:-1;;;;;;66695:51:0;-1:-1:-1;;;66695:51:0;;-1:-1:-1;66688:58:0;;66532:620;-1:-1:-1;67136:4:0;66360:799;;;;;;:::o;42220:229::-;42357:12;42389:52;42411:6;42419:4;42425:1;42428:12;42389:21;:52::i;62996:439::-;-1:-1:-1;;;;;63076:16:0;;63068:61;;;;-1:-1:-1;;;63068:61:0;;18124:2:1;63068:61:0;;;18106:21:1;;;18143:18;;;18136:30;18202:34;18182:18;;;18175:62;18254:18;;63068:61:0;17922:356:1;63068:61:0;61083:4;61107:16;;;:7;:16;;;;;;-1:-1:-1;;;;;61107:16:0;:30;63140:58;;;;-1:-1:-1;;;63140:58:0;;13140:2:1;63140:58:0;;;13122:21:1;13179:2;13159:18;;;13152:30;13218;13198:18;;;13191:58;13266:18;;63140:58:0;12938:352:1;63140:58:0;63211:45;63240:1;63244:2;63248:7;63211:20;:45::i;:::-;-1:-1:-1;;;;;63269:13:0;;;;;;:9;:13;;;;;:18;;63286:1;;63269:13;:18;;63286:1;;63269:18;:::i;:::-;;;;-1:-1:-1;;63298:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;63298:21:0;-1:-1:-1;;;;;63298:21:0;;;;;;;;63337:33;;63298:16;;;63337:33;;63298:16;;63337:33;83821:27:::1;83744:110:::0;:::o;72967:988::-;73233:22;73283:1;73258:22;73275:4;73258:16;:22::i;:::-;:26;;;;:::i;:::-;73295:18;73316:26;;;:17;:26;;;;;;73233:51;;-1:-1:-1;73449:28:0;;;73445:328;;-1:-1:-1;;;;;73516:18:0;;73494:19;73516:18;;;:12;:18;;;;;;;;:34;;;;;;;;;73567:30;;;;;;:44;;;73684:30;;:17;:30;;;;;:43;;;73445:328;-1:-1:-1;73869:26:0;;;;:17;:26;;;;;;;;73862:33;;;-1:-1:-1;;;;;73913:18:0;;;;;:12;:18;;;;;:34;;;;;;;73906:41;72967:988::o;74250:1079::-;74528:10;:17;74503:22;;74528:21;;74548:1;;74528:21;:::i;:::-;74560:18;74581:24;;;:15;:24;;;;;;74954:10;:26;;74503:46;;-1:-1:-1;74581:24:0;;74503:46;;74954:26;;;;;;:::i;:::-;;;;;;;;;74932:48;;75018:11;74993:10;75004;74993:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;75098:28;;;:15;:28;;;;;;;:41;;;75270:24;;;;;75263:31;75305:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;74321:1008;;;74250:1079;:::o;71754:221::-;71839:14;71856:20;71873:2;71856:16;:20::i;:::-;-1:-1:-1;;;;;71887:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;71932:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;71754:221:0:o;43340:510::-;43510:12;43568:5;43543:21;:30;;43535:81;;;;-1:-1:-1;;;43535:81:0;;14611:2:1;43535:81:0;;;14593:21:1;14650:2;14630:18;;;14623:30;14689:34;14669:18;;;14662:62;-1:-1:-1;;;14740:18:1;;;14733:36;14786:19;;43535:81:0;14409:402:1;43535:81:0;-1:-1:-1;;;;;39770:19:0;;;43627:60;;;;-1:-1:-1;;;43627:60:0;;20846:2:1;43627:60:0;;;20828:21:1;20885:2;20865:18;;;20858:30;20924:31;20904:18;;;20897:59;20973:18;;43627:60:0;20644:353:1;43627:60:0;43701:12;43715:23;43742:6;-1:-1:-1;;;;;43742:11:0;43761:5;43768:4;43742:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43700:73;;;;43791:51;43808:7;43817:10;43829:12;43791:16;:51::i;:::-;43784:58;43340:510;-1:-1:-1;;;;;;;43340:510:0:o;46026:712::-;46176:12;46205:7;46201:530;;;-1:-1:-1;46236:10:0;46229:17;;46201:530;46350:17;;:21;46346:374;;46548:10;46542:17;46609:15;46596:10;46592:2;46588:19;46581:44;46346:374;46691:12;46684:20;;-1:-1:-1;;;46684:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;828:367;891:8;901:6;955:3;948:4;940:6;936:17;932:27;922:55;;973:1;970;963:12;922:55;-1:-1:-1;996:20:1;;1039:18;1028:30;;1025:50;;;1071:1;1068;1061:12;1025:50;1108:4;1100:6;1096:17;1084:29;;1168:3;1161:4;1151:6;1148:1;1144:14;1136:6;1132:27;1128:38;1125:47;1122:67;;;1185:1;1182;1175:12;1122:67;828:367;;;;;:::o;1200:186::-;1259:6;1312:2;1300:9;1291:7;1287:23;1283:32;1280:52;;;1328:1;1325;1318:12;1280:52;1351:29;1370:9;1351:29;:::i;1391:260::-;1459:6;1467;1520:2;1508:9;1499:7;1495:23;1491:32;1488:52;;;1536:1;1533;1526:12;1488:52;1559:29;1578:9;1559:29;:::i;:::-;1549:39;;1607:38;1641:2;1630:9;1626:18;1607:38;:::i;:::-;1597:48;;1391:260;;;;;:::o;1656:328::-;1733:6;1741;1749;1802:2;1790:9;1781:7;1777:23;1773:32;1770:52;;;1818:1;1815;1808:12;1770:52;1841:29;1860:9;1841:29;:::i;:::-;1831:39;;1889:38;1923:2;1912:9;1908:18;1889:38;:::i;:::-;1879:48;;1974:2;1963:9;1959:18;1946:32;1936:42;;1656:328;;;;;:::o;1989:666::-;2084:6;2092;2100;2108;2161:3;2149:9;2140:7;2136:23;2132:33;2129:53;;;2178:1;2175;2168:12;2129:53;2201:29;2220:9;2201:29;:::i;:::-;2191:39;;2249:38;2283:2;2272:9;2268:18;2249:38;:::i;:::-;2239:48;;2334:2;2323:9;2319:18;2306:32;2296:42;;2389:2;2378:9;2374:18;2361:32;2416:18;2408:6;2405:30;2402:50;;;2448:1;2445;2438:12;2402:50;2471:22;;2524:4;2516:13;;2512:27;-1:-1:-1;2502:55:1;;2553:1;2550;2543:12;2502:55;2576:73;2641:7;2636:2;2623:16;2618:2;2614;2610:11;2576:73;:::i;:::-;2566:83;;;1989:666;;;;;;;:::o;2660:315::-;2725:6;2733;2786:2;2774:9;2765:7;2761:23;2757:32;2754:52;;;2802:1;2799;2792:12;2754:52;2825:29;2844:9;2825:29;:::i;:::-;2815:39;;2904:2;2893:9;2889:18;2876:32;2917:28;2939:5;2917:28;:::i;:::-;2964:5;2954:15;;;2660:315;;;;;:::o;2980:254::-;3048:6;3056;3109:2;3097:9;3088:7;3084:23;3080:32;3077:52;;;3125:1;3122;3115:12;3077:52;3148:29;3167:9;3148:29;:::i;:::-;3138:39;3224:2;3209:18;;;;3196:32;;-1:-1:-1;;;2980:254:1:o;3239:437::-;3325:6;3333;3386:2;3374:9;3365:7;3361:23;3357:32;3354:52;;;3402:1;3399;3392:12;3354:52;3442:9;3429:23;3475:18;3467:6;3464:30;3461:50;;;3507:1;3504;3497:12;3461:50;3546:70;3608:7;3599:6;3588:9;3584:22;3546:70;:::i;:::-;3635:8;;3520:96;;-1:-1:-1;3239:437:1;-1:-1:-1;;;;3239:437:1:o;3681:773::-;3803:6;3811;3819;3827;3880:2;3868:9;3859:7;3855:23;3851:32;3848:52;;;3896:1;3893;3886:12;3848:52;3936:9;3923:23;3965:18;4006:2;3998:6;3995:14;3992:34;;;4022:1;4019;4012:12;3992:34;4061:70;4123:7;4114:6;4103:9;4099:22;4061:70;:::i;:::-;4150:8;;-1:-1:-1;4035:96:1;-1:-1:-1;4238:2:1;4223:18;;4210:32;;-1:-1:-1;4254:16:1;;;4251:36;;;4283:1;4280;4273:12;4251:36;;4322:72;4386:7;4375:8;4364:9;4360:24;4322:72;:::i;:::-;3681:773;;;;-1:-1:-1;4413:8:1;-1:-1:-1;;;;3681:773:1:o;4901:241::-;4957:6;5010:2;4998:9;4989:7;4985:23;4981:32;4978:52;;;5026:1;5023;5016:12;4978:52;5065:9;5052:23;5084:28;5106:5;5084:28;:::i;5147:245::-;5214:6;5267:2;5255:9;5246:7;5242:23;5238:32;5235:52;;;5283:1;5280;5273:12;5235:52;5315:9;5309:16;5334:28;5356:5;5334:28;:::i;5397:245::-;5455:6;5508:2;5496:9;5487:7;5483:23;5479:32;5476:52;;;5524:1;5521;5514:12;5476:52;5563:9;5550:23;5582:30;5606:5;5582:30;:::i;5647:249::-;5716:6;5769:2;5757:9;5748:7;5744:23;5740:32;5737:52;;;5785:1;5782;5775:12;5737:52;5817:9;5811:16;5836:30;5860:5;5836:30;:::i;5901:450::-;5970:6;6023:2;6011:9;6002:7;5998:23;5994:32;5991:52;;;6039:1;6036;6029:12;5991:52;6079:9;6066:23;6112:18;6104:6;6101:30;6098:50;;;6144:1;6141;6134:12;6098:50;6167:22;;6220:4;6212:13;;6208:27;-1:-1:-1;6198:55:1;;6249:1;6246;6239:12;6198:55;6272:73;6337:7;6332:2;6319:16;6314:2;6310;6306:11;6272:73;:::i;6356:180::-;6415:6;6468:2;6456:9;6447:7;6443:23;6439:32;6436:52;;;6484:1;6481;6474:12;6436:52;-1:-1:-1;6507:23:1;;6356:180;-1:-1:-1;6356:180:1:o;6541:257::-;6582:3;6620:5;6614:12;6647:6;6642:3;6635:19;6663:63;6719:6;6712:4;6707:3;6703:14;6696:4;6689:5;6685:16;6663:63;:::i;:::-;6780:2;6759:15;-1:-1:-1;;6755:29:1;6746:39;;;;6787:4;6742:50;;6541:257;-1:-1:-1;;6541:257:1:o;6803:274::-;6932:3;6970:6;6964:13;6986:53;7032:6;7027:3;7020:4;7012:6;7008:17;6986:53;:::i;:::-;7055:16;;;;;6803:274;-1:-1:-1;;6803:274:1:o;7082:1527::-;7306:3;7344:6;7338:13;7370:4;7383:51;7427:6;7422:3;7417:2;7409:6;7405:15;7383:51;:::i;:::-;7497:13;;7456:16;;;;7519:55;7497:13;7456:16;7541:15;;;7519:55;:::i;:::-;7663:13;;7596:20;;;7636:1;;7723;7745:18;;;;7798;;;;7825:93;;7903:4;7893:8;7889:19;7877:31;;7825:93;7966:2;7956:8;7953:16;7933:18;7930:40;7927:167;;;-1:-1:-1;;;7993:33:1;;8049:4;8046:1;8039:15;8079:4;8000:3;8067:17;7927:167;8110:18;8137:110;;;;8261:1;8256:328;;;;8103:481;;8137:110;-1:-1:-1;;8172:24:1;;8158:39;;8217:20;;;;-1:-1:-1;8137:110:1;;8256:328;23486:1;23479:14;;;23523:4;23510:18;;8351:1;8365:169;8379:8;8376:1;8373:15;8365:169;;;8461:14;;8446:13;;;8439:37;8504:16;;;;8396:10;;8365:169;;;8369:3;;8565:8;8558:5;8554:20;8547:27;;8103:481;-1:-1:-1;8600:3:1;;7082:1527;-1:-1:-1;;;;;;;;;;;7082:1527:1:o;9412:488::-;-1:-1:-1;;;;;9681:15:1;;;9663:34;;9733:15;;9728:2;9713:18;;9706:43;9780:2;9765:18;;9758:34;;;9828:3;9823:2;9808:18;;9801:31;;;9606:4;;9849:45;;9874:19;;9866:6;9849:45;:::i;:::-;9841:53;9412:488;-1:-1:-1;;;;;;9412:488:1:o;9905:632::-;10076:2;10128:21;;;10198:13;;10101:18;;;10220:22;;;10047:4;;10076:2;10299:15;;;;10273:2;10258:18;;;10047:4;10342:169;10356:6;10353:1;10350:13;10342:169;;;10417:13;;10405:26;;10486:15;;;;10451:12;;;;10378:1;10371:9;10342:169;;;-1:-1:-1;10528:3:1;;9905:632;-1:-1:-1;;;;;;9905:632:1:o;10734:219::-;10883:2;10872:9;10865:21;10846:4;10903:44;10943:2;10932:9;10928:18;10920:6;10903:44;:::i;10958:331::-;11160:2;11142:21;;;11199:1;11179:18;;;11172:29;-1:-1:-1;;;11232:2:1;11217:18;;11210:38;11280:2;11265:18;;10958:331::o;11706:414::-;11908:2;11890:21;;;11947:2;11927:18;;;11920:30;11986:34;11981:2;11966:18;;11959:62;-1:-1:-1;;;12052:2:1;12037:18;;12030:48;12110:3;12095:19;;11706:414::o;13295:350::-;13497:2;13479:21;;;13536:2;13516:18;;;13509:30;13575:28;13570:2;13555:18;;13548:56;13636:2;13621:18;;13295:350::o;15229:337::-;15431:2;15413:21;;;15470:2;15450:18;;;15443:30;-1:-1:-1;;;15504:2:1;15489:18;;15482:43;15557:2;15542:18;;15229:337::o;16817:346::-;17019:2;17001:21;;;17058:2;17038:18;;;17031:30;-1:-1:-1;;;17092:2:1;17077:18;;17070:52;17154:2;17139:18;;16817:346::o;17168:400::-;17370:2;17352:21;;;17409:2;17389:18;;;17382:30;17448:34;17443:2;17428:18;;17421:62;-1:-1:-1;;;17514:2:1;17499:18;;17492:34;17558:3;17543:19;;17168:400::o;18696:356::-;18898:2;18880:21;;;18917:18;;;18910:30;18976:34;18971:2;18956:18;;18949:62;19043:2;19028:18;;18696:356::o;19057:346::-;19259:2;19241:21;;;19298:2;19278:18;;;19271:30;-1:-1:-1;;;19332:2:1;19317:18;;19310:52;19394:2;19379:18;;19057:346::o;20226:413::-;20428:2;20410:21;;;20467:2;20447:18;;;20440:30;20506:34;20501:2;20486:18;;20479:62;-1:-1:-1;;;20572:2:1;20557:18;;20550:47;20629:3;20614:19;;20226:413::o;21002:342::-;21204:2;21186:21;;;21243:2;21223:18;;;21216:30;-1:-1:-1;;;21277:2:1;21262:18;;21255:48;21335:2;21320:18;;21002:342::o;22173:337::-;22375:2;22357:21;;;22414:2;22394:18;;;22387:30;-1:-1:-1;;;22448:2:1;22433:18;;22426:43;22501:2;22486:18;;22173:337::o;22515:355::-;22717:2;22699:21;;;22756:2;22736:18;;;22729:30;22795:33;22790:2;22775:18;;22768:61;22861:2;22846:18;;22515:355::o;22875:351::-;23077:2;23059:21;;;23116:2;23096:18;;;23089:30;23155:29;23150:2;23135:18;;23128:57;23217:2;23202:18;;22875:351::o;23539:128::-;23579:3;23610:1;23606:6;23603:1;23600:13;23597:39;;;23616:18;;:::i;:::-;-1:-1:-1;23652:9:1;;23539:128::o;23672:120::-;23712:1;23738;23728:35;;23743:18;;:::i;:::-;-1:-1:-1;23777:9:1;;23672:120::o;23797:168::-;23837:7;23903:1;23899;23895:6;23891:14;23888:1;23885:21;23880:1;23873:9;23866:17;23862:45;23859:71;;;23910:18;;:::i;:::-;-1:-1:-1;23950:9:1;;23797:168::o;23970:125::-;24010:4;24038:1;24035;24032:8;24029:34;;;24043:18;;:::i;:::-;-1:-1:-1;24080:9:1;;23970:125::o;24100:258::-;24172:1;24182:113;24196:6;24193:1;24190:13;24182:113;;;24272:11;;;24266:18;24253:11;;;24246:39;24218:2;24211:10;24182:113;;;24313:6;24310:1;24307:13;24304:48;;;-1:-1:-1;;24348:1:1;24330:16;;24323:27;24100:258::o;24363:136::-;24402:3;24430:5;24420:39;;24439:18;;:::i;:::-;-1:-1:-1;;;24475:18:1;;24363:136::o;24504:380::-;24583:1;24579:12;;;;24626;;;24647:61;;24701:4;24693:6;24689:17;24679:27;;24647:61;24754:2;24746:6;24743:14;24723:18;24720:38;24717:161;;;24800:10;24795:3;24791:20;24788:1;24781:31;24835:4;24832:1;24825:15;24863:4;24860:1;24853:15;24717:161;;24504:380;;;:::o;24889:135::-;24928:3;-1:-1:-1;;24949:17:1;;24946:43;;;24969:18;;:::i;:::-;-1:-1:-1;25016:1:1;25005:13;;24889:135::o;25029:112::-;25061:1;25087;25077:35;;25092:18;;:::i;:::-;-1:-1:-1;25126:9:1;;25029:112::o;25146:127::-;25207:10;25202:3;25198:20;25195:1;25188:31;25238:4;25235:1;25228:15;25262:4;25259:1;25252:15;25278:127;25339:10;25334:3;25330:20;25327:1;25320:31;25370:4;25367:1;25360:15;25394:4;25391:1;25384:15;25410:127;25471:10;25466:3;25462:20;25459:1;25452:31;25502:4;25499:1;25492:15;25526:4;25523:1;25516:15;25542:127;25603:10;25598:3;25594:20;25591:1;25584:31;25634:4;25631:1;25624:15;25658:4;25655:1;25648:15;25674:127;25735:10;25730:3;25726:20;25723:1;25716:31;25766:4;25763:1;25756:15;25790:4;25787:1;25780:15;25806:118;25892:5;25885:13;25878:21;25871:5;25868:32;25858:60;;25914:1;25911;25904:12;25929:131;-1:-1:-1;;;;;;26003:32:1;;25993:43;;25983:71;;26050:1;26047;26040:12

ipfs://4c923af5b09673d27675394dda446510910300573a11b13bc1b28d355102a0bc