Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library TransferHelper
•    - function safeApprove(
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeTransferETH(address to, ...
•  contract DigiMinersLottery is Owna ... *
•    - function isContract(address _addr)
•    - function setManager(address manager_)
•    - function random()
•    - function getTicketDetails(uint256 rou ...
•    - function changeSignerwallet(address _ ...
•    - function getPrice(Ores ore)
•    - function currentRound()
•    - function startRound(uint256 startTime ...
•    - function startRoundbyManager(uint256 ...
•    - function setDIGI_NFT(IERC721 nft_)
•    - function buyTickets( bytes calldata s ...
•    - function emitPurchase(uint256 ticketI ...
•    - function checkSign(bytes calldata sig ...
•    - function getSignData(uint256 quantity ...
•    - function setKey()
•    - function distributionLimit(Ores ore)
•    - function SetdistributionLimit(Ores or ...
•    - function checkDistribution(uint256 ro ...
•    - function getTicketKey(uint256 ticketI ...
•    - function getWinningKey(uint256 roundI ...
•    - function getTicketWinning(uint256 rou ...
•    - function getTicketHolding(address wal ...
•    - function getWinningOre(uint256 winnin ...
•    - function getOreNew(uint256 num)
•    - function _getWinningOre(uint256 round ...
•    - function nextOre(uint256 roundId)
•    - function oreToNumber(Ores ore)
•    - function numberToOre(uint256 number)
•    - function claimAvailable(uint256 round ...
•    - function OreclaimAvailable(uint256 ro ...
•    - function ticketKeyFactory(uint256 tic ...
•    - function claimAllWinning(uint256 roun ...
•    - function bulkClaim(BulkClaim[] callda ...
•    - function _claim(uint256 roundId, uint ...
•    - function preClaim(uint256 roundId, ui ...
•    - function withdraw(uint256 amount)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-12-20
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

    /**
     * @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 Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: digiminer.sol



// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

    /**
     * @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 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

// File: @openzeppelin/contracts/interfaces/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol)

pragma solidity ^0.8.0;


// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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);
    }
}

// File: digiminer.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;



/**
 * @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.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
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) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

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

        /// @solidity memory-safe-assembly
        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 in 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;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}
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;
    }
}
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) {
        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) {
        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) {
        // 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) {
        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) {
        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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @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. 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) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }

}
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeApprove: approve failed'
        );
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeTransfer: transfer failed'
        );
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::transferFrom: transferFrom failed'
        );
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
    }
}

contract DigiMinersLottery is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using ECDSA for bytes32;

    address private signerWallet;

    struct LotteryRound {
        uint256 RoundId; //round id
        uint256 startTime; //startTime of lottery
        uint256 endTime; //endTime of lottery 
        uint256 ticketsSold; //tickets sold in this round
        uint256 priceClaimed;
    } 

    struct Ticket {
        address holder; //owner of the ticket (non transferrable)
        Ores winningOre;
    }

    /* Contract address of DIGI NFT */
    IERC721 public DIGI_NFT; 
   
    /* Current Round of Lottery */
    uint256 public LotteryRounds;

    /* Price for Each Ticket */
    uint256 public immutable ticketPrice = 0.01 ether;

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;

    // The `PURCHASE` event signature is given by:
    //"TicketPurchased(uint256,uint256,address)".
    bytes32 private constant _PURCHASE_EVENT_SIGNATURE =
    0x94c5953e15f54d38b82a662bdd5739fc91af3a23d3ef7e67269dfaeee71a813c;


    /* Winning Amount*/
    uint256 public constant Vortexia = 0.5 ether;
    uint256 public constant Diamond = 0.1 ether;
    uint256 public constant Gold = 0.02 ether;
    uint256 public constant Emerald = 0.01 ether;
    uint256 public constant Bronze = 0.002 ether;
    uint256 public constant Iron = 0.001 ether;
    
    address public manager;

    struct BulkClaim {
        uint256 roundId;
        uint256[] ticketIds;
    }

    struct TicketClaimed {
        uint256 ticketId;
        address holder;
        Ores winningOre;
        bool claimed;
    }
    enum Ores {
        Vortexia,
        Diamond,
        Gold,
        Emerald,
        Bronze,
        Iron
    }
    /* 
    Mapping of Lottery round to nft id which returns uint256 to check how many tickets an NFT has bought;
    */
    mapping(uint256=>mapping(uint256=>uint256)) public nftUsed;

    mapping(Ores=>uint256) public price;
    /* Ticket counter for each round of NFT */
    mapping(uint256=>LotteryRound) public RoundDetails;

    /* Mapping of Lottery round to its winning key */
    mapping(uint256=>uint256) public winningKey;

    mapping(uint256=>mapping(uint256=>Ticket)) public TicketKey;  

    mapping(uint256=>mapping(uint256=>bool)) public claimed;  

    mapping(Ores=>uint256) private Distributelimit;

    mapping(uint256=>Ores) private checkore;

    mapping(uint256=>mapping(Ores=>uint256)) private claimCounter;


    event WinningClaimed(uint256 indexed roundId, address indexed wallet);

    /* Ticket Fees is not correct */
    error BadFees();
    
    /* Not owner of the NFT */
    error NotOwner();

    /* Fake Signature */
    error FakeSignature();

    /* NFT used enough */
    error nftConsumed();

    /* Lottery has ended */
    error LotteryEnded();

    /* All tickets sold */
    error TicketsSold();

    /* Not holder of ticket */
    error NotHolder();

    /* Ticket Claimed */

    error AlreadyClaimed();

    /* Caller is contract */
    error ContractCall();

    /* Round not ended */
    error RoundNotEnded();

    constructor(){
        price[Ores.Vortexia]= Vortexia;
        price[Ores.Diamond]= Diamond;
        price[Ores.Gold]= Gold;
        price[Ores.Emerald]= Emerald;
        price[Ores.Bronze]= Bronze;
        price[Ores.Iron]= Iron;
        
        checkore[0]=Ores.Vortexia;
        checkore[1]=Ores.Diamond;
        checkore[2]=Ores.Gold;
        checkore[3]=Ores.Emerald;
        checkore[4]=Ores.Bronze;
        checkore[5]=Ores.Iron;

        Distributelimit[Ores.Vortexia] = 194;
        Distributelimit[Ores.Diamond] = 583;
        Distributelimit[Ores.Gold] = 3110;
        Distributelimit[Ores.Emerald] = 15554;
        Distributelimit[Ores.Bronze] = 19442;
        Distributelimit[Ores.Iron] = 38888;
        startRound(block.timestamp, block.timestamp + 7 days);
        signerWallet=0xd2149d74486e2C1b1c8d5a35984835F2b6184f5C;
        DIGI_NFT=IERC721(0xEcA22C0FD4ac62D81a5633eB547e6797C9579462);
    }

    function isContract(address _addr) private view returns (bool){
        uint32 size;
        assembly {
            size := extcodesize(_addr)
    }
        return (size > 0);
    }

    modifier callerIsWallet {
        if(isContract(_msgSender()) && msg.sender == tx.origin) revert ContractCall();
        _;
    }
    
    modifier onlyAuth {
        require(msg.sender == manager || msg.sender == owner(), "Not Auth");
        _;
    }

    function setManager(address manager_) public onlyOwner {
        manager = manager_;
    }

    function random() private view returns(uint){
        return uint(keccak256(abi.encodePacked(block.difficulty, block.timestamp, block.number))) % 10**10;
    }

    function getTicketDetails(uint256 roundId, uint256 ticketId) public view returns(Ticket memory){
        return TicketKey[roundId][ticketId];
    }

    function changeSignerwallet(address _signerWallet) public onlyOwner {
        signerWallet = _signerWallet;
    }

    function getPrice(Ores ore) public view returns(uint256){
        return price[ore];
    }

    function currentRound() public view returns(uint256){
        return LotteryRounds;
    }

    function startRound(uint256 startTime, uint256 endTime) public onlyOwner {
        require(block.timestamp > RoundDetails[currentRound()].endTime, "DIGI: Last Round has not ended");
        LotteryRounds++;
        RoundDetails[LotteryRounds] = LotteryRound(LotteryRounds, startTime, endTime, 0,0);
        setKey();
    }

    function startRoundbyManager(uint256 startTime, uint256 endTime) public onlyAuth {
        require(block.timestamp > RoundDetails[currentRound()].endTime, "DIGI: Last Round has not ended");
        LotteryRounds++;
        RoundDetails[LotteryRounds] = LotteryRound(LotteryRounds, startTime, endTime, 0,0);
        setKey();
    }

    function setDIGI_NFT(IERC721 nft_) public onlyOwner {
        DIGI_NFT = nft_;
    }

    function buyTickets( bytes calldata signature,   uint256 quantity,  uint256 tokenIdHolding,  uint256 multiplier) public payable callerIsWallet nonReentrant {
        //require(msg.value == ticketPrice.mul(quantity), "DIGI: Send proper ticket fees");
        if(msg.value != ticketPrice.mul(quantity)) revert BadFees();

        //require(DIGI_NFT.ownerOf(tokenIdHolding) == msg.sender, "You are not owner of NFT");        
        if(msg.sender != DIGI_NFT.ownerOf(tokenIdHolding)) revert NotOwner();

        uint256 roundId = currentRound();

        //require(checkSign(signature, quantity, tokenIdHolding, miningLevel, _msgSender(), roundId)==signerWallet, "DIGI: Fake signature");
        if(checkSign(signature, quantity, tokenIdHolding, multiplier, _msgSender(), roundId) != signerWallet) revert FakeSignature();

        nftUsed[roundId][tokenIdHolding] += quantity;

        //require(nftUsed[roundId][tokenIdHolding] <= 10, "DIGI: NFT used enough");
        if(nftUsed[roundId][tokenIdHolding] > 10) revert nftConsumed();

        LotteryRound storage round = RoundDetails[roundId];

        //require(round.endTime>block.timestamp, "DIGI: Lottery has been ended");
        if(round.endTime < block.timestamp) revert LotteryEnded();

        uint256 startTicketIndex = round.ticketsSold + 1;
        round.ticketsSold += quantity;

        uint256 winningKey_ = getWinningKey(roundId);

        //uint256 multiplier = getMultiplier(miningLevel);
        address buyer = _msgSender();

        for(uint256 i= 0;i<quantity;){
            uint256 ticketId = startTicketIndex + i;
            uint256 ticketKey = getTicketKey(ticketId);
            Ores winningOre = getWinningOre(winningKey_, roundId, ticketKey, multiplier);
            TicketKey[roundId][ticketId] = Ticket(buyer, winningOre);
            emitPurchase(ticketId, roundId, buyer);
            unchecked {
             ++claimCounter[roundId][winningOre];               
	         ++i;
	        }
        }
    }

    
   


    function emitPurchase(uint256 ticketId, uint256 roundId, address buyer) internal {
         assembly {   
        // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            buyer := and(buyer, _BITMASK_ADDRESS)
            // Emit the `Transfer` event.
            log4(
            0, // Start of data (0, since no data).
            0, // End of data (0, since no data).
            _PURCHASE_EVENT_SIGNATURE, // Signature.
            ticketId, // `startTicketId(0)`.
            roundId, // `to`.
            buyer // `tokenId`.
            )  
        }
    }


    function checkSign(bytes calldata signature, uint256 quantity, uint256 tokenIdHolding, uint256 multipler, address wallet, uint256 roundId) private pure returns(address){
        return keccak256(
            abi.encodePacked(
               "\x19Ethereum Signed Message:\n32",
                getSignData(quantity, tokenIdHolding, multipler, wallet, roundId)   
            )
        ).recover(signature);
    }

    function getSignData(uint256 quantity, uint256 tokenIdHolding, uint256 multiplier, address wallet, uint256 roundId) public pure returns(bytes32) {
        return (
        keccak256(abi.encodePacked(keccak256(abi.encodePacked(wallet)), keccak256(abi.encodePacked(quantity, tokenIdHolding, multiplier, roundId))))
        );
    }

    function setKey() private {
        uint256 roundId = currentRound();
        uint256 key = random(); /* will use chainlink in real contract */
        winningKey[roundId] = key;
    }    

    function distributionLimit(Ores ore) public view returns(uint256){
        return Distributelimit[ore];
    }

    function SetdistributionLimit(Ores ore, uint256 limit) public onlyOwner {
        Distributelimit[ore] = limit;
    }

    function checkDistribution(uint256 roundId, Ores ore) public view returns(uint256){
        return claimCounter[roundId][ore];
    }

    function getTicketKey(uint256 ticketId) private view returns(uint256){
        return uint(keccak256(abi.encodePacked(msg.sender, ticketId, block.timestamp, block.difficulty, block.number))) % 10**7;
    }

    function getWinningKey(uint256 roundId) public view returns(uint256){
        return winningKey[roundId];
    }

    function getTicketWinning(uint256 roundId, uint256 ticketId) public view returns(Ores ore){
        return TicketKey[roundId][ticketId].winningOre;
    }

    function getTicketHolding(address wallet, uint256 roundId) public view returns(TicketClaimed[] memory){
        uint256 len;
        for(uint256 i = 1; i< RoundDetails[roundId].ticketsSold;i++){
            address holder = TicketKey[roundId][i].holder;
            if(holder == wallet){
                len++;
            }
        }

        TicketClaimed[] memory tickets = new TicketClaimed[](len);
        uint256 index;
        for(uint256 i = 1; i< RoundDetails[roundId].ticketsSold;i++){
            address holder = TicketKey[roundId][i].holder;
            if(holder == wallet){
                tickets[index] = TicketClaimed(i, TicketKey[roundId][i].holder,TicketKey[roundId][i].winningOre, claimed[roundId][i] );
                index++;
            }
        }
        return tickets;
    }

    function getWinningOre(uint256 winningKey_, uint256 roundId, uint256 TicketKey_, uint256 multiplier) private view returns(Ores Ore){
       // Ores previousOre = Ores.Iron; //starting from lowest
        uint256 mlResult = 99999;
        for(uint256 i = 1; i<=multiplier;) {
        uint256 multiplierResult= ticketKeyFactory(TicketKey_, i).add(winningKey_) % 10**5 ;
            if(mlResult > multiplierResult){
                mlResult = multiplierResult;
            }
            unchecked {
                ++i;
            }
        }
        Ores previousOre = _getWinningOre(roundId, mlResult);
        return previousOre;
    }

    function getOreNew(uint256 num) public pure returns(Ores ore) {
        require(num <= 100000, "INVALID");
        if(45000 <= num && num <= 100000) {
            return Ores.Iron;
        }
        if(10000 <= num && num < 45000) {
            return Ores.Bronze;
        }
        if(4500 <= num && num < 10000) {
            return Ores.Emerald;
        }                    
        if(800 <= num && num < 4500) {
            return Ores.Gold;
        }
        if(200 <= num && num < 800) {
            return Ores.Diamond;
        } 
        if(0 <= num && num < 200) {
            return Ores.Vortexia;
        }
    }
    
    function _getWinningOre(uint256 roundId, uint256 number) private view returns(Ores){
        Ores ore = getOreNew(number);
        uint256 nextNum;
        if(OreclaimAvailable(roundId, ore) == true){
            return ore;
        } else {
            nextNum = nextOre(roundId);
        }
        return numberToOre(nextNum);
    }


    function nextOre(uint256 roundId) private view returns(uint256 num){
        for(uint256 i = 5; i>=0;){
            if(claimAvailable(roundId, i)){
                return i;
            }
            unchecked {
                ++i;
            }
        }
    }

    function oreToNumber(Ores ore) public pure returns(uint256 num){
            return uint256(ore);
    }

    function numberToOre(uint256 number) public view returns(Ores ore){
        return checkore[number];
    }

    function claimAvailable(uint256 roundId, uint256 ore) private view returns(bool){
        Ores ore_ = numberToOre(ore);
        if(Distributelimit[ore_]>claimCounter[roundId][ore_]){
            return true;
        }
        return false;
    }
    
    function OreclaimAvailable(uint256 roundId, Ores ore_) private view returns(bool){
        if(Distributelimit[ore_]>claimCounter[roundId][ore_]){
            return true;
        }
        return false;
    }
    
    function ticketKeyFactory(uint256 ticketKey, uint256 multiplier) public pure returns(uint256){
        return (ticketKey.add(multiplier));
    }

    function claimAllWinning(uint256 roundId, uint256[] calldata ticketIds) public nonReentrant callerIsWallet {
        _claim(roundId, ticketIds);            
    }

    function bulkClaim(BulkClaim[] calldata data) public nonReentrant callerIsWallet {
        for(uint256 i=0;i<data.length;++i){
            uint256 roundId = data[i].roundId;
                _claim(roundId, data[i].ticketIds);
        }
    }

    function _claim(uint256 roundId, uint256[] calldata ticketIds) private {
        if(roundId == currentRound()) revert RoundNotEnded();
        uint256 totalWinning;
        for(uint256 i=0;i<ticketIds.length;i++){
            uint256 winning = preClaim(roundId, ticketIds[i]);
            totalWinning += winning;
        }
        LotteryRound storage round = RoundDetails[roundId];
        round.priceClaimed += totalWinning;
        TransferHelper.safeTransferETH(_msgSender(), totalWinning);
        emit WinningClaimed(totalWinning, _msgSender());
    }

    function preClaim(uint256 roundId, uint256 ticketId) private returns(uint256) {
        Ticket storage ticket = TicketKey[roundId][ticketId];
        if(claimed[roundId][ticketId] == true) revert AlreadyClaimed();
        claimed[roundId][ticketId] = true;
        if(ticket.holder != _msgSender()) revert NotHolder();
        uint256 winning = getPrice(ticket.winningOre);
        return winning;
    }

    function withdraw(uint256 amount) external onlyOwner {
        TransferHelper.safeTransferETH(owner(), amount);
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyClaimed","type":"error"},{"inputs":[],"name":"BadFees","type":"error"},{"inputs":[],"name":"ContractCall","type":"error"},{"inputs":[],"name":"FakeSignature","type":"error"},{"inputs":[],"name":"LotteryEnded","type":"error"},{"inputs":[],"name":"NotHolder","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[],"name":"RoundNotEnded","type":"error"},{"inputs":[],"name":"TicketsSold","type":"error"},{"inputs":[],"name":"nftConsumed","type":"error"},{"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":"uint256","name":"roundId","type":"uint256"},{"indexed":true,"internalType":"address","name":"wallet","type":"address"}],"name":"WinningClaimed","type":"event"},{"inputs":[],"name":"Bronze","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DIGI_NFT","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Diamond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Emerald","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Gold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Iron","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LotteryRounds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"RoundDetails","outputs":[{"internalType":"uint256","name":"RoundId","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"uint256","name":"ticketsSold","type":"uint256"},{"internalType":"uint256","name":"priceClaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"SetdistributionLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"TicketKey","outputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"enum DigiMinersLottery.Ores","name":"winningOre","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Vortexia","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"uint256[]","name":"ticketIds","type":"uint256[]"}],"internalType":"struct DigiMinersLottery.BulkClaim[]","name":"data","type":"tuple[]"}],"name":"bulkClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"tokenIdHolding","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"}],"name":"buyTickets","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_signerWallet","type":"address"}],"name":"changeSignerwallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"name":"checkDistribution","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"uint256[]","name":"ticketIds","type":"uint256[]"}],"name":"claimAllWinning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"name":"distributionLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"name":"getOreNew","outputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"name":"getPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"tokenIdHolding","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"},{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"roundId","type":"uint256"}],"name":"getSignData","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"uint256","name":"ticketId","type":"uint256"}],"name":"getTicketDetails","outputs":[{"components":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"enum DigiMinersLottery.Ores","name":"winningOre","type":"uint8"}],"internalType":"struct DigiMinersLottery.Ticket","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"roundId","type":"uint256"}],"name":"getTicketHolding","outputs":[{"components":[{"internalType":"uint256","name":"ticketId","type":"uint256"},{"internalType":"address","name":"holder","type":"address"},{"internalType":"enum DigiMinersLottery.Ores","name":"winningOre","type":"uint8"},{"internalType":"bool","name":"claimed","type":"bool"}],"internalType":"struct DigiMinersLottery.TicketClaimed[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"uint256","name":"ticketId","type":"uint256"}],"name":"getTicketWinning","outputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundId","type":"uint256"}],"name":"getWinningKey","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"nftUsed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"number","type":"uint256"}],"name":"numberToOre","outputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"ore","type":"uint8"}],"name":"oreToNumber","outputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DigiMinersLottery.Ores","name":"","type":"uint8"}],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC721","name":"nft_","type":"address"}],"name":"setDIGI_NFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"manager_","type":"address"}],"name":"setManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"}],"name":"startRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"}],"name":"startRoundbyManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"ticketKey","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"}],"name":"ticketKeyFactory","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"ticketPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"winningKey","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

44691:15959:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59242:246;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46065:44;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45353:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45423:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60491:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50897:2026;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49926:92;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58916:146;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54535:111;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46947:43;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46833:50;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;46171:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55138:113;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50460:335;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45916:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58312:108;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20253:103;;;;;;;;;;;;;:::i;:::-;;56910:645;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50803:86;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50026:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49803:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19605:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46116:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53994:333;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46014:44;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45865;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47069:55;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54781:134;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45281:23;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58199:105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59070:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46999:59;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;46743:35;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50125:327;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55259:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45966:41;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49377:92;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55422:822;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54654:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46676:58;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49646:149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20511:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59242:246;35283:1;35881:7;;:19;35873:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;35283:1;36014:7;:18;;;;49147:24:::1;49158:12;:10;:12::i;:::-;49147:10;:24::i;:::-;:51;;;;;49189:9;49175:23;;:10;:23;;;49147:51;49144:77;;;49207:14;;;;;;;;;;;;;;49144:77;59338:9:::2;59334:147;59352:4;;:11;;59350:1;:13;59334:147;;;59383:15;59401:4;;59406:1;59401:7;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;:15;;;59383:33;;59435:34;59442:7;59451:4;;59456:1;59451:7;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;:17;;;;;;;;:::i;:::-;59435:6;:34::i;:::-;59368:113;59364:3;;;;:::i;:::-;;;59334:147;;;;35239:1:::0;36193:7;:22;;;;59242:246;;:::o;46065:44::-;46098:11;46065:44;:::o;45353:28::-;;;;:::o;45423:49::-;;;:::o;60491:119::-;19491:13;:11;:13::i;:::-;60555:47:::1;60586:7;:5;:7::i;:::-;60595:6;60555:30;:47::i;:::-;60491:119:::0;:::o;50897:2026::-;49147:24;49158:12;:10;:12::i;:::-;49147:10;:24::i;:::-;:51;;;;;49189:9;49175:23;;:10;:23;;;49147:51;49144:77;;;49207:14;;;;;;;;;;;;;;49144:77;35283:1:::1;35881:7;;:19:::0;35873:63:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;35283:1;36014:7;:18;;;;51173:25:::2;51189:8;51173:11;:15;;:25;;;;:::i;:::-;51160:9;:38;51157:59;;51207:9;;;;;;;;;;;;;;51157:59;51350:8;;;;;;;;;;;:16;;;51367:14;51350:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51336:46;;:10;:46;;;51333:68;;51391:10;;;;;;;;;;;;;;51333:68;51414:15;51432:14;:12;:14::i;:::-;51414:32;;51689:12;;;;;;;;;;;51604:97;;:81;51614:9;;51625:8;51635:14;51651:10;51663:12;:10;:12::i;:::-;51677:7;51604:9;:81::i;:::-;:97;;;51601:124;;51710:15;;;;;;;;;;;;;;51601:124;51774:8;51738:7;:16;51746:7;51738:16;;;;;;;;;;;:32;51755:14;51738:32;;;;;;;;;;;;:44;;;;;;;:::i;:::-;;;;;;;;51918:2;51883:7;:16;51891:7;51883:16;;;;;;;;;;;:32;51900:14;51883:32;;;;;;;;;;;;:37;51880:62;;;51929:13;;;;;;;;;;;;;;51880:62;51955:26;51984:12;:21;51997:7;51984:21;;;;;;;;;;;51955:50;;52120:15;52104:5;:13;;;:31;52101:57;;;52144:14;;;;;;;;;;;;;;52101:57;52171:24;52218:1;52198:5;:17;;;:21;;;;:::i;:::-;52171:48;;52251:8;52230:5;:17;;;:29;;;;;;;:::i;:::-;;;;;;;;52272:19;52294:22;52308:7;52294:13;:22::i;:::-;52272:44;;52389:13;52405:12;:10;:12::i;:::-;52389:28;;52434:9;52430:486;52449:8;52447:1;:10;52430:486;;;52474:16;52512:1;52493:16;:20;;;;:::i;:::-;52474:39;;52528:17;52548:22;52561:8;52548:12;:22::i;:::-;52528:42;;52585:15;52603:58;52617:11;52630:7;52639:9;52650:10;52603:13;:58::i;:::-;52585:76;;52707:25;;;;;;;;52714:5;52707:25;;;;;;52721:10;52707:25;;;;;;;;:::i;:::-;;;;::::0;52676:9:::2;:18;52686:7;52676:18;;;;;;;;;;;:28;52695:8;52676:28;;;;;;;;;;;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;52747:38;52760:8;52770:7;52779:5;52747:12;:38::i;:::-;52828:12;:21;52841:7;52828:21;;;;;;;;;;;:33;52850:10;52828:33;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;52826:35;;;;;;;;;;;52889:3;;;;;52459:457;;;52430:486;;;;51053:1870;;;;;35239:1:::1;36193:7:::0;:22:::1;;;;50897:2026:::0;;;;;:::o;49926:92::-;49974:7;50000:5;:10;50006:3;50000:10;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;49993:17;;49926:92;;;:::o;58916:146::-;59001:7;59028:25;59042:10;59028:9;:13;;:25;;;;:::i;:::-;59020:34;;58916:146;;;;:::o;54535:111::-;54592:7;54618:15;:20;54634:3;54618:20;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;54611:27;;54535:111;;;:::o;46947:43::-;;;;;;;;;;;;;;;;;:::o;46833:50::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;46171:22::-;;;;;;;;;;;;;:::o;55138:113::-;55198:7;55224:10;:19;55235:7;55224:19;;;;;;;;;;;;55217:26;;55138:113;;;:::o;50460:335::-;49304:7;;;;;;;;;;;49290:21;;:10;:21;;;:46;;;;49329:7;:5;:7::i;:::-;49315:21;;:10;:21;;;49290:46;49282:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;50578:12:::1;:28;50591:14;:12;:14::i;:::-;50578:28;;;;;;;;;;;:36;;;50560:15;:54;50552:97;;;;;;;;;;;;:::i;:::-;;;;;;;;;50660:13;;:15;;;;;;;;;:::i;:::-;;;;;;50716:52;;;;;;;;50729:13;;50716:52;;;;50744:9;50716:52;;;;50755:7;50716:52;;;;50764:1;50716:52;;;;50766:1;50716:52;;::::0;50686:12:::1;:27;50699:13;;50686:27;;;;;;;;;;;:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50779:8;:6;:8::i;:::-;50460:335:::0;;:::o;45916:43::-;45950:9;45916:43;:::o;58312:108::-;58369:8;58396;:16;58405:6;58396:16;;;;;;;;;;;;;;;;;;;;;58389:23;;58312:108;;;:::o;20253:103::-;19491:13;:11;:13::i;:::-;20318:30:::1;20345:1;20318:18;:30::i;:::-;20253:103::o:0;56910:645::-;56962:8;56998:6;56991:3;:13;;56983:33;;;;;;;;;;;;:::i;:::-;;;;;;;;;57039:3;57030:5;:12;;:29;;;;;57053:6;57046:3;:13;;57030:29;57027:77;;;57083:9;57076:16;;;;57027:77;57126:3;57117:5;:12;;:27;;;;;57139:5;57133:3;:11;57117:27;57114:77;;;57168:11;57161:18;;;;57114:77;57212:3;57204:4;:11;;:26;;;;;57225:5;57219:3;:11;57204:26;57201:77;;;57254:12;57247:19;;;;57201:77;57318:3;57311;:10;;:24;;;;;57331:4;57325:3;:10;57311:24;57308:72;;;57359:9;57352:16;;;;57308:72;57400:3;57393;:10;;:23;;;;;57413:3;57407;:9;57393:23;57390:74;;;57440:12;57433:19;;;;57390:74;57483:3;57478:1;:8;;:21;;;;;57496:3;57490;:9;57478:21;57475:73;;;57523:13;57516:20;;;;57475:73;56910:645;;;;:::o;50803:86::-;19491:13;:11;:13::i;:::-;50877:4:::1;50866:8;;:15;;;;;;;;;;;;;;;;;;50803:86:::0;:::o;50026:91::-;50070:7;50096:13;;50089:20;;50026:91;:::o;49803:115::-;19491:13;:11;:13::i;:::-;49897::::1;49882:12;;:28;;;;;;;;;;;;;;;;;;49803:115:::0;:::o;19605:87::-;19651:7;19678:6;;;;;;;;;;;19671:13;;19605:87;:::o;46116:42::-;46147:11;46116:42;:::o;53994:333::-;54130:7;54222:6;54205:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;54195:35;;;;;;54259:8;54269:14;54285:10;54297:7;54242:63;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54232:74;;;;;;54178:129;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54168:140;;;;;;54150:169;;53994:333;;;;;;;:::o;46014:44::-;46048:10;46014:44;:::o;45865:::-;45900:9;45865:44;:::o;47069:55::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;54781:134::-;54855:7;54881:12;:21;54894:7;54881:21;;;;;;;;;;;:26;54903:3;54881:26;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;54874:33;;54781:134;;;;:::o;45281:23::-;;;;;;;;;;;;;:::o;58199:105::-;58250:11;58292:3;58284:12;;;;;;;;:::i;:::-;;58277:19;;58199:105;;;:::o;59070:164::-;35283:1;35881:7;;:19;35873:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;35283:1;36014:7;:18;;;;49147:24:::1;49158:12;:10;:12::i;:::-;49147:10;:24::i;:::-;:51;;;;;49189:9;49175:23;;:10;:23;;;49147:51;49144:77;;;49207:14;;;;;;;;;;;;;;49144:77;59188:26:::2;59195:7;59204:9;;59188:6;:26::i;:::-;35239:1:::0;36193:7;:22;;;;59070:164;;;:::o;46999:59::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;46743:35::-;;;;;;;;;;;;;;;;;:::o;50125:327::-;19491:13;:11;:13::i;:::-;50235:12:::1;:28;50248:14;:12;:14::i;:::-;50235:28;;;;;;;;;;;:36;;;50217:15;:54;50209:97;;;;;;;;;;;;:::i;:::-;;;;;;;;;50317:13;;:15;;;;;;;;;:::i;:::-;;;;;;50373:52;;;;;;;;50386:13;;50373:52;;;;50401:9;50373:52;;;;50412:7;50373:52;;;;50421:1;50373:52;;;;50423:1;50373:52;;::::0;50343:12:::1;:27;50356:13;;50343:27;;;;;;;;;;;:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50436:8;:6;:8::i;:::-;50125:327:::0;;:::o;55259:155::-;55340:8;55367:9;:18;55377:7;55367:18;;;;;;;;;;;:28;55386:8;55367:28;;;;;;;;;;;:39;;;;;;;;;;;;55360:46;;55259:155;;;;:::o;45966:41::-;45997:10;45966:41;:::o;49377:92::-;19491:13;:11;:13::i;:::-;49453:8:::1;49443:7;;:18;;;;;;;;;;;;;;;;;;49377:92:::0;:::o;55422:822::-;55501:22;55535:11;55561:9;55573:1;55561:13;;55557:206;55579:12;:21;55592:7;55579:21;;;;;;;;;;;:33;;;55576:1;:36;55557:206;;;55632:14;55649:9;:18;55659:7;55649:18;;;;;;;;;;;:21;55668:1;55649:21;;;;;;;;;;;:28;;;;;;;;;;;;55632:45;;55705:6;55695:16;;:6;:16;;;55692:60;;55731:5;;;;;:::i;:::-;;;;55692:60;55617:146;55613:3;;;;;:::i;:::-;;;;55557:206;;;;55775:30;55828:3;55808:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;55775:57;;55843:13;55871:9;55883:1;55871:13;;55867:345;55889:12;:21;55902:7;55889:21;;;;;;;;;;;:33;;;55886:1;:36;55867:345;;;55942:14;55959:9;:18;55969:7;55959:18;;;;;;;;;;;:21;55978:1;55959:21;;;;;;;;;;;:28;;;;;;;;;;;;55942:45;;56015:6;56005:16;;:6;:16;;;56002:199;;56058:101;;;;;;;;56072:1;56058:101;;;;56075:9;:18;56085:7;56075:18;;;;;;;;;;;:21;56094:1;56075:21;;;;;;;;;;;:28;;;;;;;;;;;;56058:101;;;;;;56104:9;:18;56114:7;56104:18;;;;;;;;;;;:21;56123:1;56104:21;;;;;;;;;;;:32;;;;;;;;;;;;56058:101;;;;;;;;:::i;:::-;;;;;;56138:7;:16;56146:7;56138:16;;;;;;;;;;;:19;56155:1;56138:19;;;;;;;;;;;;;;;;;;;;;56058:101;;;;;56041:7;56049:5;56041:14;;;;;;;;:::i;:::-;;;;;;;:118;;;;56178:7;;;;;:::i;:::-;;;;56002:199;55927:285;55923:3;;;;;:::i;:::-;;;;55867:345;;;;56229:7;56222:14;;;;;55422:822;;;;:::o;54654:119::-;19491:13;:11;:13::i;:::-;54760:5:::1;54737:15;:20;54753:3;54737:20;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:28;;;;54654:119:::0;;:::o;46676:58::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49646:149::-;49727:13;;:::i;:::-;49759:9;:18;49769:7;49759:18;;;;;;;;;;;:28;49778:8;49759:28;;;;;;;;;;;49752:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;49646:149;;;;:::o;20511:201::-;19491:13;:11;:13::i;:::-;20620:1:::1;20600:22;;:8;:22;;::::0;20592:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;20676:28;20695:8;20676:18;:28::i;:::-;20511:201:::0;:::o;18156:98::-;18209:7;18236:10;18229:17;;18156:98;:::o;48914:187::-;48971:4;48987:11;49053:5;49041:18;49033:26;;49091:1;49084:4;:8;;;49076:17;;;48914:187;;;:::o;59496:569::-;59592:14;:12;:14::i;:::-;59581:7;:25;59578:52;;59615:15;;;;;;;;;;;;;;59578:52;59641:20;59676:9;59686:1;59676:11;;59672:153;59690:9;;:16;;59688:1;:18;59672:153;;;59726:15;59744:31;59753:7;59762:9;;59772:1;59762:12;;;;;;;:::i;:::-;;;;;;;;59744:8;:31::i;:::-;59726:49;;59806:7;59790:23;;;;;:::i;:::-;;;59711:114;59707:3;;;;;:::i;:::-;;;;59672:153;;;;59835:26;59864:12;:21;59877:7;59864:21;;;;;;;;;;;59835:50;;59918:12;59896:5;:18;;;:34;;;;;;;:::i;:::-;;;;;;;;59941:58;59972:12;:10;:12::i;:::-;59986;59941:30;:58::i;:::-;60044:12;:10;:12::i;:::-;60015:42;;60030:12;60015:42;;;;;;;;;;59567:498;;59496:569;;;:::o;19770:132::-;19845:12;:10;:12::i;:::-;19834:23;;:7;:5;:7::i;:::-;:23;;;19826:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;19770:132::o;44467:217::-;44540:12;44558:2;:7;;44573:5;44590:1;44580:12;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44558:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44539:54;;;44612:7;44604:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;44528:156;44467:217;;:::o;39233:220::-;39291:7;39320:1;39315;:6;39311:20;;39330:1;39323:8;;;;39311:20;39342:9;39358:1;39354;:5;;;;:::i;:::-;39342:17;;39387:1;39382;39378;:5;;;;:::i;:::-;:10;39370:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;39444:1;39437:8;;;39233:220;;;;;:::o;53568:418::-;53728:7;53754:224;53968:9;;53754:224;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53865:65;53877:8;53887:14;53903:9;53914:6;53922:7;53865:11;:65::i;:::-;53778:170;;;;;;;;:::i;:::-;;;;;;;;;;;;;53754:205;;;;;;:213;;:224;;;;:::i;:::-;53747:231;;53568:418;;;;;;;;;:::o;54923:207::-;54984:7;55117:5;55042:10;55054:8;55064:15;55081:16;55099:12;55025:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55015:98;;;;;;55010:104;;:112;;;;:::i;:::-;55003:119;;54923:207;;;:::o;56252:650::-;56374:8;56458:16;56477:5;56458:24;;56497:9;56509:1;56497:13;;56493:310;56515:10;56512:1;:13;56493:310;;56539:24;56616:5;56565:48;56601:11;56565:31;56582:10;56594:1;56565:16;:31::i;:::-;:35;;:48;;;;:::i;:::-;:56;;;;:::i;:::-;56539:82;;56651:16;56640:8;:27;56637:93;;;56698:16;56687:27;;56637:93;56773:3;;;;;56528:275;56493:310;;;;56813:16;56832:33;56847:7;56856:8;56832:14;:33::i;:::-;56813:52;;56883:11;56876:18;;;;56252:650;;;;;;:::o;52946:612::-;53176:16;53169:5;53165:28;53156:37;;53504:5;53473:7;53427:8;53373:25;53322:1;53269;53250:288;52946:612;;;:::o;38355:179::-;38413:7;38433:9;38449:1;38445;:5;;;;:::i;:::-;38433:17;;38474:1;38469;:6;;38461:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;38525:1;38518:8;;;38355:179;;;;:::o;54335:188::-;54372:15;54390:14;:12;:14::i;:::-;54372:32;;54415:11;54429:8;:6;:8::i;:::-;54415:22;;54512:3;54490:10;:19;54501:7;54490:19;;;;;;;;;;;:25;;;;54361:162;;54335:188::o;20872:191::-;20946:16;20965:6;;;;;;;;;;;20946:25;;20991:8;20982:6;;:17;;;;;;;;;;;;;;;;;;21046:8;21015:40;;21036:8;21015:40;;;;;;;;;;;;20935:128;20872:191;:::o;60073:410::-;60142:7;60162:21;60186:9;:18;60196:7;60186:18;;;;;;;;;;;:28;60205:8;60186:28;;;;;;;;;;;60162:52;;60258:4;60228:34;;:7;:16;60236:7;60228:16;;;;;;;;;;;:26;60245:8;60228:26;;;;;;;;;;;;;;;;;;;;;:34;;;60225:62;;60271:16;;;;;;;;;;;;;;60225:62;60327:4;60298:7;:16;60306:7;60298:16;;;;;;;;;;;:26;60315:8;60298:26;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;60362:12;:10;:12::i;:::-;60345:29;;:6;:13;;;;;;;;;;;;:29;;;60342:52;;60383:11;;;;;;;;;;;;;;60342:52;60405:15;60423:27;60432:6;:17;;;;;;;;;;;;60423:8;:27::i;:::-;60405:45;;60468:7;60461:14;;;;60073:410;;;;:::o;6388:231::-;6466:7;6487:17;6506:18;6528:27;6539:4;6545:9;6528:10;:27::i;:::-;6486:69;;;;6566:18;6578:5;6566:11;:18::i;:::-;6602:9;6595:16;;;;6388:231;;;;:::o;57567:343::-;57645:4;57661:8;57672:17;57682:6;57672:9;:17::i;:::-;57661:28;;57700:15;57764:4;57729:39;;:31;57747:7;57756:3;57729:17;:31::i;:::-;:39;;;57726:139;;57791:3;57784:10;;;;;;57726:139;57837:16;57845:7;57837;:16::i;:::-;57827:26;;57882:20;57894:7;57882:11;:20::i;:::-;57875:27;;;;57567:343;;;;;:::o;49477:161::-;49516:4;49624:6;49571:16;49589:15;49606:12;49554:65;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49544:76;;;;;;49539:82;;:91;;;;:::i;:::-;49532:98;;49477:161;:::o;4839:747::-;4920:7;4929:12;4978:2;4958:9;:16;:22;4954:625;;4997:9;5021;5045:7;5302:4;5291:9;5287:20;5281:27;5276:32;;5352:4;5341:9;5337:20;5331:27;5326:32;;5410:4;5399:9;5395:20;5389:27;5386:1;5381:36;5376:41;;5453:25;5464:4;5470:1;5473;5476;5453:10;:25::i;:::-;5446:32;;;;;;;;;4954:625;5527:1;5531:35;5511:56;;;;4839:747;;;;;;:::o;3110:643::-;3188:20;3179:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;3175:571;3225:7;3175:571;3286:29;3277:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;3273:473;;3332:34;;;;;;;;;;:::i;:::-;;;;;;;;3273:473;3397:35;3388:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;3384:362;;3449:41;;;;;;;;;;:::i;:::-;;;;;;;;3384:362;3521:30;3512:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;3508:238;;3568:44;;;;;;;;;;:::i;:::-;;;;;;;;3508:238;3643:30;3634:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;3630:116;;3690:44;;;;;;;;;;:::i;:::-;;;;;;;;3630:116;3110:643;;:::o;58691:213::-;58767:4;58808:12;:21;58821:7;58808:21;;;;;;;;;;;:27;58830:4;58808:27;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;58786:15;:21;58802:4;58786:21;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:49;58783:91;;;58858:4;58851:11;;;;58783:91;58891:5;58884:12;;58691:213;;;;;:::o;57920:271::-;57975:11;58002:9;58014:1;58002:13;;57998:186;58020:1;58017;:4;57998:186;;58041:26;58056:7;58065:1;58041:14;:26::i;:::-;58038:73;;;58094:1;58087:8;;;;;58038:73;58154:3;;;;;57998:186;;;;57920:271;;;;:::o;7840:1632::-;7971:7;7980:12;8905:66;8900:1;8892:10;;:79;8888:163;;;9004:1;9008:30;8988:51;;;;;;8888:163;9070:2;9065:1;:7;;;;:18;;;;;9081:2;9076:1;:7;;;;9065:18;9061:102;;;9116:1;9120:30;9100:51;;;;;;9061:102;9260:14;9277:24;9287:4;9293:1;9296;9299;9277:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9260:41;;9334:1;9316:20;;:6;:20;;;9312:103;;9369:1;9373:29;9353:50;;;;;;;9312:103;9435:6;9443:20;9427:37;;;;;7840:1632;;;;;;;;:::o;58428:251::-;58503:4;58519:9;58531:16;58543:3;58531:11;:16::i;:::-;58519:28;;58583:12;:21;58596:7;58583:21;;;;;;;;;;;:27;58605:4;58583:27;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;58561:15;:21;58577:4;58561:21;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:49;58558:91;;;58633:4;58626:11;;;;;58558:91;58666:5;58659:12;;;58428:251;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:117;566:1;563;556:12;580:117;689:1;686;679:12;747:597;849:8;859:6;909:3;902:4;894:6;890:17;886:27;876:122;;917:79;;:::i;:::-;876:122;1030:6;1017:20;1007:30;;1060:18;1052:6;1049:30;1046:117;;;1082:79;;:::i;:::-;1046:117;1196:4;1188:6;1184:17;1172:29;;1250:3;1242:4;1234:6;1230:17;1220:8;1216:32;1213:41;1210:128;;;1257:79;;:::i;:::-;1210:128;747:597;;;;;:::o;1350:617::-;1465:6;1473;1522:2;1510:9;1501:7;1497:23;1493:32;1490:119;;;1528:79;;:::i;:::-;1490:119;1676:1;1665:9;1661:17;1648:31;1706:18;1698:6;1695:30;1692:117;;;1728:79;;:::i;:::-;1692:117;1841:109;1942:7;1933:6;1922:9;1918:22;1841:109;:::i;:::-;1823:127;;;;1619:341;1350:617;;;;;:::o;1973:77::-;2010:7;2039:5;2028:16;;1973:77;;;:::o;2056:118::-;2143:24;2161:5;2143:24;:::i;:::-;2138:3;2131:37;2056:118;;:::o;2180:222::-;2273:4;2311:2;2300:9;2296:18;2288:26;;2324:71;2392:1;2381:9;2377:17;2368:6;2324:71;:::i;:::-;2180:222;;;;:::o;2408:122::-;2481:24;2499:5;2481:24;:::i;:::-;2474:5;2471:35;2461:63;;2520:1;2517;2510:12;2461:63;2408:122;:::o;2536:139::-;2582:5;2620:6;2607:20;2598:29;;2636:33;2663:5;2636:33;:::i;:::-;2536:139;;;;:::o;2681:329::-;2740:6;2789:2;2777:9;2768:7;2764:23;2760:32;2757:119;;;2795:79;;:::i;:::-;2757:119;2915:1;2940:53;2985:7;2976:6;2965:9;2961:22;2940:53;:::i;:::-;2930:63;;2886:117;2681:329;;;;:::o;3029:552::-;3086:8;3096:6;3146:3;3139:4;3131:6;3127:17;3123:27;3113:122;;3154:79;;:::i;:::-;3113:122;3267:6;3254:20;3244:30;;3297:18;3289:6;3286:30;3283:117;;;3319:79;;:::i;:::-;3283:117;3433:4;3425:6;3421:17;3409:29;;3487:3;3479:4;3471:6;3467:17;3457:8;3453:32;3450:41;3447:128;;;3494:79;;:::i;:::-;3447:128;3029:552;;;;;:::o;3587:963::-;3684:6;3692;3700;3708;3716;3765:3;3753:9;3744:7;3740:23;3736:33;3733:120;;;3772:79;;:::i;:::-;3733:120;3920:1;3909:9;3905:17;3892:31;3950:18;3942:6;3939:30;3936:117;;;3972:79;;:::i;:::-;3936:117;4085:64;4141:7;4132:6;4121:9;4117:22;4085:64;:::i;:::-;4067:82;;;;3863:296;4198:2;4224:53;4269:7;4260:6;4249:9;4245:22;4224:53;:::i;:::-;4214:63;;4169:118;4326:2;4352:53;4397:7;4388:6;4377:9;4373:22;4352:53;:::i;:::-;4342:63;;4297:118;4454:2;4480:53;4525:7;4516:6;4505:9;4501:22;4480:53;:::i;:::-;4470:63;;4425:118;3587:963;;;;;;;;:::o;4556:108::-;4638:1;4631:5;4628:12;4618:40;;4654:1;4651;4644:12;4618:40;4556:108;:::o;4670:157::-;4725:5;4763:6;4750:20;4741:29;;4779:42;4815:5;4779:42;:::i;:::-;4670:157;;;;:::o;4833:347::-;4901:6;4950:2;4938:9;4929:7;4925:23;4921:32;4918:119;;;4956:79;;:::i;:::-;4918:119;5076:1;5101:62;5155:7;5146:6;5135:9;5131:22;5101:62;:::i;:::-;5091:72;;5047:126;4833:347;;;;:::o;5186:474::-;5254:6;5262;5311:2;5299:9;5290:7;5286:23;5282:32;5279:119;;;5317:79;;:::i;:::-;5279:119;5437:1;5462:53;5507:7;5498:6;5487:9;5483:22;5462:53;:::i;:::-;5452:63;;5408:117;5564:2;5590:53;5635:7;5626:6;5615:9;5611:22;5590:53;:::i;:::-;5580:63;;5535:118;5186:474;;;;;:::o;5666:664::-;5871:4;5909:3;5898:9;5894:19;5886:27;;5923:71;5991:1;5980:9;5976:17;5967:6;5923:71;:::i;:::-;6004:72;6072:2;6061:9;6057:18;6048:6;6004:72;:::i;:::-;6086;6154:2;6143:9;6139:18;6130:6;6086:72;:::i;:::-;6168;6236:2;6225:9;6221:18;6212:6;6168:72;:::i;:::-;6250:73;6318:3;6307:9;6303:19;6294:6;6250:73;:::i;:::-;5666:664;;;;;;;;:::o;6336:126::-;6373:7;6413:42;6406:5;6402:54;6391:65;;6336:126;;;:::o;6468:96::-;6505:7;6534:24;6552:5;6534:24;:::i;:::-;6523:35;;6468:96;;;:::o;6570:118::-;6657:24;6675:5;6657:24;:::i;:::-;6652:3;6645:37;6570:118;;:::o;6694:222::-;6787:4;6825:2;6814:9;6810:18;6802:26;;6838:71;6906:1;6895:9;6891:17;6882:6;6838:71;:::i;:::-;6694:222;;;;:::o;6922:180::-;6970:77;6967:1;6960:88;7067:4;7064:1;7057:15;7091:4;7088:1;7081:15;7108:114;7190:1;7183:5;7180:12;7170:46;;7196:18;;:::i;:::-;7170:46;7108:114;:::o;7228:129::-;7274:7;7303:5;7292:16;;7309:42;7345:5;7309:42;:::i;:::-;7228:129;;;:::o;7363:::-;7420:9;7453:33;7480:5;7453:33;:::i;:::-;7440:46;;7363:129;;;:::o;7498:145::-;7592:44;7630:5;7592:44;:::i;:::-;7587:3;7580:57;7498:145;;:::o;7649:236::-;7749:4;7787:2;7776:9;7772:18;7764:26;;7800:78;7875:1;7864:9;7860:17;7851:6;7800:78;:::i;:::-;7649:236;;;;:::o;7891:111::-;7943:7;7972:24;7990:5;7972:24;:::i;:::-;7961:35;;7891:111;;;:::o;8008:152::-;8096:39;8129:5;8096:39;:::i;:::-;8089:5;8086:50;8076:78;;8150:1;8147;8140:12;8076:78;8008:152;:::o;8166:169::-;8227:5;8265:6;8252:20;8243:29;;8281:48;8323:5;8281:48;:::i;:::-;8166:169;;;;:::o;8341:359::-;8415:6;8464:2;8452:9;8443:7;8439:23;8435:32;8432:119;;;8470:79;;:::i;:::-;8432:119;8590:1;8615:68;8675:7;8666:6;8655:9;8651:22;8615:68;:::i;:::-;8605:78;;8561:132;8341:359;;;;:::o;8706:122::-;8779:24;8797:5;8779:24;:::i;:::-;8772:5;8769:35;8759:63;;8818:1;8815;8808:12;8759:63;8706:122;:::o;8834:139::-;8880:5;8918:6;8905:20;8896:29;;8934:33;8961:5;8934:33;:::i;:::-;8834:139;;;;:::o;8979:329::-;9038:6;9087:2;9075:9;9066:7;9062:23;9058:32;9055:119;;;9093:79;;:::i;:::-;9055:119;9213:1;9238:53;9283:7;9274:6;9263:9;9259:22;9238:53;:::i;:::-;9228:63;;9184:117;8979:329;;;;:::o;9314:911::-;9409:6;9417;9425;9433;9441;9490:3;9478:9;9469:7;9465:23;9461:33;9458:120;;;9497:79;;:::i;:::-;9458:120;9617:1;9642:53;9687:7;9678:6;9667:9;9663:22;9642:53;:::i;:::-;9632:63;;9588:117;9744:2;9770:53;9815:7;9806:6;9795:9;9791:22;9770:53;:::i;:::-;9760:63;;9715:118;9872:2;9898:53;9943:7;9934:6;9923:9;9919:22;9898:53;:::i;:::-;9888:63;;9843:118;10000:2;10026:53;10071:7;10062:6;10051:9;10047:22;10026:53;:::i;:::-;10016:63;;9971:118;10128:3;10155:53;10200:7;10191:6;10180:9;10176:22;10155:53;:::i;:::-;10145:63;;10099:119;9314:911;;;;;;;;:::o;10231:77::-;10268:7;10297:5;10286:16;;10231:77;;;:::o;10314:118::-;10401:24;10419:5;10401:24;:::i;:::-;10396:3;10389:37;10314:118;;:::o;10438:222::-;10531:4;10569:2;10558:9;10554:18;10546:26;;10582:71;10650:1;10639:9;10635:17;10626:6;10582:71;:::i;:::-;10438:222;;;;:::o;10666:90::-;10700:7;10743:5;10736:13;10729:21;10718:32;;10666:90;;;:::o;10762:109::-;10843:21;10858:5;10843:21;:::i;:::-;10838:3;10831:34;10762:109;;:::o;10877:210::-;10964:4;11002:2;10991:9;10987:18;10979:26;;11015:65;11077:1;11066:9;11062:17;11053:6;11015:65;:::i;:::-;10877:210;;;;:::o;11093:492::-;11170:6;11178;11227:2;11215:9;11206:7;11202:23;11198:32;11195:119;;;11233:79;;:::i;:::-;11195:119;11353:1;11378:53;11423:7;11414:6;11403:9;11399:22;11378:53;:::i;:::-;11368:63;;11324:117;11480:2;11506:62;11560:7;11551:6;11540:9;11536:22;11506:62;:::i;:::-;11496:72;;11451:127;11093:492;;;;;:::o;11591:60::-;11619:3;11640:5;11633:12;;11591:60;;;:::o;11657:142::-;11707:9;11740:53;11758:34;11767:24;11785:5;11767:24;:::i;:::-;11758:34;:::i;:::-;11740:53;:::i;:::-;11727:66;;11657:142;;;:::o;11805:126::-;11855:9;11888:37;11919:5;11888:37;:::i;:::-;11875:50;;11805:126;;;:::o;11937:141::-;12002:9;12035:37;12066:5;12035:37;:::i;:::-;12022:50;;11937:141;;;:::o;12084:161::-;12186:52;12232:5;12186:52;:::i;:::-;12181:3;12174:65;12084:161;;:::o;12251:252::-;12359:4;12397:2;12386:9;12382:18;12374:26;;12410:86;12493:1;12482:9;12478:17;12469:6;12410:86;:::i;:::-;12251:252;;;;:::o;12526:568::-;12599:8;12609:6;12659:3;12652:4;12644:6;12640:17;12636:27;12626:122;;12667:79;;:::i;:::-;12626:122;12780:6;12767:20;12757:30;;12810:18;12802:6;12799:30;12796:117;;;12832:79;;:::i;:::-;12796:117;12946:4;12938:6;12934:17;12922:29;;13000:3;12992:4;12984:6;12980:17;12970:8;12966:32;12963:41;12960:128;;;13007:79;;:::i;:::-;12960:128;12526:568;;;;;:::o;13100:704::-;13195:6;13203;13211;13260:2;13248:9;13239:7;13235:23;13231:32;13228:119;;;13266:79;;:::i;:::-;13228:119;13386:1;13411:53;13456:7;13447:6;13436:9;13432:22;13411:53;:::i;:::-;13401:63;;13357:117;13541:2;13530:9;13526:18;13513:32;13572:18;13564:6;13561:30;13558:117;;;13594:79;;:::i;:::-;13558:117;13707:80;13779:7;13770:6;13759:9;13755:22;13707:80;:::i;:::-;13689:98;;;;13484:313;13100:704;;;;;:::o;13810:346::-;13938:4;13976:2;13965:9;13961:18;13953:26;;13989:71;14057:1;14046:9;14042:17;14033:6;13989:71;:::i;:::-;14070:79;14145:2;14134:9;14130:18;14121:6;14070:79;:::i;:::-;13810:346;;;;;:::o;14162:474::-;14230:6;14238;14287:2;14275:9;14266:7;14262:23;14258:32;14255:119;;;14293:79;;:::i;:::-;14255:119;14413:1;14438:53;14483:7;14474:6;14463:9;14459:22;14438:53;:::i;:::-;14428:63;;14384:117;14540:2;14566:53;14611:7;14602:6;14591:9;14587:22;14566:53;:::i;:::-;14556:63;;14511:118;14162:474;;;;;:::o;14642:145::-;14740:6;14774:5;14768:12;14758:22;;14642:145;;;:::o;14793:215::-;14923:11;14957:6;14952:3;14945:19;14997:4;14992:3;14988:14;14973:29;;14793:215;;;;:::o;15014:163::-;15112:4;15135:3;15127:11;;15165:4;15160:3;15156:14;15148:22;;15014:163;;;:::o;15183:108::-;15260:24;15278:5;15260:24;:::i;:::-;15255:3;15248:37;15183:108;;:::o;15297:::-;15374:24;15392:5;15374:24;:::i;:::-;15369:3;15362:37;15297:108;;:::o;15411:135::-;15495:44;15533:5;15495:44;:::i;:::-;15490:3;15483:57;15411:135;;:::o;15552:99::-;15623:21;15638:5;15623:21;:::i;:::-;15618:3;15611:34;15552:99;;:::o;15745:873::-;15894:4;15889:3;15885:14;15985:4;15978:5;15974:16;15968:23;16004:63;16061:4;16056:3;16052:14;16038:12;16004:63;:::i;:::-;15909:168;16161:4;16154:5;16150:16;16144:23;16180:63;16237:4;16232:3;16228:14;16214:12;16180:63;:::i;:::-;16087:166;16341:4;16334:5;16330:16;16324:23;16360:70;16424:4;16419:3;16415:14;16401:12;16360:70;:::i;:::-;16263:177;16525:4;16518:5;16514:16;16508:23;16544:57;16595:4;16590:3;16586:14;16572:12;16544:57;:::i;:::-;16450:161;15863:755;15745:873;;:::o;16624:303::-;16755:10;16776:108;16880:3;16872:6;16776:108;:::i;:::-;16916:4;16911:3;16907:14;16893:28;;16624:303;;;;:::o;16933:144::-;17034:4;17066;17061:3;17057:14;17049:22;;16933:144;;;:::o;17175:980::-;17356:3;17385:85;17464:5;17385:85;:::i;:::-;17486:117;17596:6;17591:3;17486:117;:::i;:::-;17479:124;;17627:87;17708:5;17627:87;:::i;:::-;17737:7;17768:1;17753:377;17778:6;17775:1;17772:13;17753:377;;;17854:6;17848:13;17881:125;18002:3;17987:13;17881:125;:::i;:::-;17874:132;;18029:91;18113:6;18029:91;:::i;:::-;18019:101;;17813:317;17800:1;17797;17793:9;17788:14;;17753:377;;;17757:14;18146:3;18139:10;;17361:794;;;17175:980;;;;:::o;18161:497::-;18366:4;18404:2;18393:9;18389:18;18381:26;;18453:9;18447:4;18443:20;18439:1;18428:9;18424:17;18417:47;18481:170;18646:4;18637:6;18481:170;:::i;:::-;18473:178;;18161:497;;;;:::o;18664:492::-;18741:6;18749;18798:2;18786:9;18777:7;18773:23;18769:32;18766:119;;;18804:79;;:::i;:::-;18766:119;18924:1;18949:62;19003:7;18994:6;18983:9;18979:22;18949:62;:::i;:::-;18939:72;;18895:126;19060:2;19086:53;19131:7;19122:6;19111:9;19107:22;19086:53;:::i;:::-;19076:63;;19031:118;18664:492;;;;;:::o;19236:520::-;19381:4;19376:3;19372:14;19470:4;19463:5;19459:16;19453:23;19489:63;19546:4;19541:3;19537:14;19523:12;19489:63;:::i;:::-;19396:166;19650:4;19643:5;19639:16;19633:23;19669:70;19733:4;19728:3;19724:14;19710:12;19669:70;:::i;:::-;19572:177;19350:406;19236:520;;:::o;19762:318::-;19903:4;19941:2;19930:9;19926:18;19918:26;;19954:119;20070:1;20059:9;20055:17;20046:6;19954:119;:::i;:::-;19762:318;;;;:::o;20086:169::-;20170:11;20204:6;20199:3;20192:19;20244:4;20239:3;20235:14;20220:29;;20086:169;;;;:::o;20261:181::-;20401:33;20397:1;20389:6;20385:14;20378:57;20261:181;:::o;20448:366::-;20590:3;20611:67;20675:2;20670:3;20611:67;:::i;:::-;20604:74;;20687:93;20776:3;20687:93;:::i;:::-;20805:2;20800:3;20796:12;20789:19;;20448:366;;;:::o;20820:419::-;20986:4;21024:2;21013:9;21009:18;21001:26;;21073:9;21067:4;21063:20;21059:1;21048:9;21044:17;21037:47;21101:131;21227:4;21101:131;:::i;:::-;21093:139;;20820:419;;;:::o;21245:180::-;21293:77;21290:1;21283:88;21390:4;21387:1;21380:15;21414:4;21411:1;21404:15;21431:117;21540:1;21537;21530:12;21554:117;21663:1;21660;21653:12;21677:117;21786:1;21783;21776:12;21800:395;21895:4;21949:11;21936:25;22049:1;22043:4;22039:12;22028:8;22012:14;22008:29;22004:48;21984:18;21980:73;21970:168;;22057:79;;:::i;:::-;21970:168;22169:18;22159:8;22155:33;22147:41;;21900:295;21800:395;;;;:::o;22201:740::-;22294:4;22300:6;22356:11;22343:25;22456:1;22450:4;22446:12;22435:8;22419:14;22415:29;22411:48;22391:18;22387:73;22377:168;;22464:79;;:::i;:::-;22377:168;22576:18;22566:8;22562:33;22554:41;;22628:4;22615:18;22605:28;;22656:18;22648:6;22645:30;22642:117;;;22678:79;;:::i;:::-;22642:117;22786:2;22780:4;22776:13;22768:21;;22843:4;22835:6;22831:17;22815:14;22811:38;22805:4;22801:49;22798:136;;;22853:79;;:::i;:::-;22798:136;22307:634;22201:740;;;;;:::o;22947:180::-;22995:77;22992:1;22985:88;23092:4;23089:1;23082:15;23116:4;23113:1;23106:15;23133:233;23172:3;23195:24;23213:5;23195:24;:::i;:::-;23186:33;;23241:66;23234:5;23231:77;23228:103;;23311:18;;:::i;:::-;23228:103;23358:1;23351:5;23347:13;23340:20;;23133:233;;;:::o;23372:143::-;23429:5;23460:6;23454:13;23445:22;;23476:33;23503:5;23476:33;:::i;:::-;23372:143;;;;:::o;23521:351::-;23591:6;23640:2;23628:9;23619:7;23615:23;23611:32;23608:119;;;23646:79;;:::i;:::-;23608:119;23766:1;23791:64;23847:7;23838:6;23827:9;23823:22;23791:64;:::i;:::-;23781:74;;23737:128;23521:351;;;;:::o;23878:191::-;23918:3;23937:20;23955:1;23937:20;:::i;:::-;23932:25;;23971:20;23989:1;23971:20;:::i;:::-;23966:25;;24014:1;24011;24007:9;24000:16;;24035:3;24032:1;24029:10;24026:36;;;24042:18;;:::i;:::-;24026:36;23878:191;;;;:::o;24075:158::-;24215:10;24211:1;24203:6;24199:14;24192:34;24075:158;:::o;24239:365::-;24381:3;24402:66;24466:1;24461:3;24402:66;:::i;:::-;24395:73;;24477:93;24566:3;24477:93;:::i;:::-;24595:2;24590:3;24586:12;24579:19;;24239:365;;;:::o;24610:419::-;24776:4;24814:2;24803:9;24799:18;24791:26;;24863:9;24857:4;24853:20;24849:1;24838:9;24834:17;24827:47;24891:131;25017:4;24891:131;:::i;:::-;24883:139;;24610:419;;;:::o;25035:180::-;25175:32;25171:1;25163:6;25159:14;25152:56;25035:180;:::o;25221:366::-;25363:3;25384:67;25448:2;25443:3;25384:67;:::i;:::-;25377:74;;25460:93;25549:3;25460:93;:::i;:::-;25578:2;25573:3;25569:12;25562:19;;25221:366;;;:::o;25593:419::-;25759:4;25797:2;25786:9;25782:18;25774:26;;25846:9;25840:4;25836:20;25832:1;25821:9;25817:17;25810:47;25874:131;26000:4;25874:131;:::i;:::-;25866:139;;25593:419;;;:::o;26018:157::-;26158:9;26154:1;26146:6;26142:14;26135:33;26018:157;:::o;26181:365::-;26323:3;26344:66;26408:1;26403:3;26344:66;:::i;:::-;26337:73;;26419:93;26508:3;26419:93;:::i;:::-;26537:2;26532:3;26528:12;26521:19;;26181:365;;;:::o;26552:419::-;26718:4;26756:2;26745:9;26741:18;26733:26;;26805:9;26799:4;26795:20;26791:1;26780:9;26776:17;26769:47;26833:131;26959:4;26833:131;:::i;:::-;26825:139;;26552:419;;;:::o;26977:94::-;27010:8;27058:5;27054:2;27050:14;27029:35;;26977:94;;;:::o;27077:::-;27116:7;27145:20;27159:5;27145:20;:::i;:::-;27134:31;;27077:94;;;:::o;27177:100::-;27216:7;27245:26;27265:5;27245:26;:::i;:::-;27234:37;;27177:100;;;:::o;27283:157::-;27388:45;27408:24;27426:5;27408:24;:::i;:::-;27388:45;:::i;:::-;27383:3;27376:58;27283:157;;:::o;27446:256::-;27558:3;27573:75;27644:3;27635:6;27573:75;:::i;:::-;27673:2;27668:3;27664:12;27657:19;;27693:3;27686:10;;27446:256;;;;:::o;27708:79::-;27747:7;27776:5;27765:16;;27708:79;;;:::o;27793:157::-;27898:45;27918:24;27936:5;27918:24;:::i;:::-;27898:45;:::i;:::-;27893:3;27886:58;27793:157;;:::o;27956:679::-;28152:3;28167:75;28238:3;28229:6;28167:75;:::i;:::-;28267:2;28262:3;28258:12;28251:19;;28280:75;28351:3;28342:6;28280:75;:::i;:::-;28380:2;28375:3;28371:12;28364:19;;28393:75;28464:3;28455:6;28393:75;:::i;:::-;28493:2;28488:3;28484:12;28477:19;;28506:75;28577:3;28568:6;28506:75;:::i;:::-;28606:2;28601:3;28597:12;28590:19;;28626:3;28619:10;;27956:679;;;;;;;:::o;28641:79::-;28680:7;28709:5;28698:16;;28641:79;;;:::o;28726:157::-;28831:45;28851:24;28869:5;28851:24;:::i;:::-;28831:45;:::i;:::-;28826:3;28819:58;28726:157;;:::o;28889:397::-;29029:3;29044:75;29115:3;29106:6;29044:75;:::i;:::-;29144:2;29139:3;29135:12;29128:19;;29157:75;29228:3;29219:6;29157:75;:::i;:::-;29257:2;29252:3;29248:12;29241:19;;29277:3;29270:10;;28889:397;;;;;:::o;29292:180::-;29340:77;29337:1;29330:88;29437:4;29434:1;29427:15;29461:4;29458:1;29451:15;29478:225;29618:34;29614:1;29606:6;29602:14;29595:58;29687:8;29682:2;29674:6;29670:15;29663:33;29478:225;:::o;29709:366::-;29851:3;29872:67;29936:2;29931:3;29872:67;:::i;:::-;29865:74;;29948:93;30037:3;29948:93;:::i;:::-;30066:2;30061:3;30057:12;30050:19;;29709:366;;;:::o;30081:419::-;30247:4;30285:2;30274:9;30270:18;30262:26;;30334:9;30328:4;30324:20;30320:1;30309:9;30305:17;30298:47;30362:131;30488:4;30362:131;:::i;:::-;30354:139;;30081:419;;;:::o;30506:182::-;30646:34;30642:1;30634:6;30630:14;30623:58;30506:182;:::o;30694:366::-;30836:3;30857:67;30921:2;30916:3;30857:67;:::i;:::-;30850:74;;30933:93;31022:3;30933:93;:::i;:::-;31051:2;31046:3;31042:12;31035:19;;30694:366;;;:::o;31066:419::-;31232:4;31270:2;31259:9;31255:18;31247:26;;31319:9;31313:4;31309:20;31305:1;31294:9;31290:17;31283:47;31347:131;31473:4;31347:131;:::i;:::-;31339:139;;31066:419;;;:::o;31491:98::-;31542:6;31576:5;31570:12;31560:22;;31491:98;;;:::o;31595:147::-;31696:11;31733:3;31718:18;;31595:147;;;;:::o;31748:246::-;31829:1;31839:113;31853:6;31850:1;31847:13;31839:113;;;31938:1;31933:3;31929:11;31923:18;31919:1;31914:3;31910:11;31903:39;31875:2;31872:1;31868:10;31863:15;;31839:113;;;31986:1;31977:6;31972:3;31968:16;31961:27;31810:184;31748:246;;;:::o;32000:386::-;32104:3;32132:38;32164:5;32132:38;:::i;:::-;32186:88;32267:6;32262:3;32186:88;:::i;:::-;32179:95;;32283:65;32341:6;32336:3;32329:4;32322:5;32318:16;32283:65;:::i;:::-;32373:6;32368:3;32364:16;32357:23;;32108:278;32000:386;;;;:::o;32392:271::-;32522:3;32544:93;32633:3;32624:6;32544:93;:::i;:::-;32537:100;;32654:3;32647:10;;32392:271;;;;:::o;32669:239::-;32809:34;32805:1;32797:6;32793:14;32786:58;32878:22;32873:2;32865:6;32861:15;32854:47;32669:239;:::o;32914:366::-;33056:3;33077:67;33141:2;33136:3;33077:67;:::i;:::-;33070:74;;33153:93;33242:3;33153:93;:::i;:::-;33271:2;33266:3;33262:12;33255:19;;32914:366;;;:::o;33286:419::-;33452:4;33490:2;33479:9;33475:18;33467:26;;33539:9;33533:4;33529:20;33525:1;33514:9;33510:17;33503:47;33567:131;33693:4;33567:131;:::i;:::-;33559:139;;33286:419;;;:::o;33711:410::-;33751:7;33774:20;33792:1;33774:20;:::i;:::-;33769:25;;33808:20;33826:1;33808:20;:::i;:::-;33803:25;;33863:1;33860;33856:9;33885:30;33903:11;33885:30;:::i;:::-;33874:41;;34064:1;34055:7;34051:15;34048:1;34045:22;34025:1;34018:9;33998:83;33975:139;;34094:18;;:::i;:::-;33975:139;33759:362;33711:410;;;;:::o;34127:180::-;34175:77;34172:1;34165:88;34272:4;34269:1;34262:15;34296:4;34293:1;34286:15;34313:185;34353:1;34370:20;34388:1;34370:20;:::i;:::-;34365:25;;34404:20;34422:1;34404:20;:::i;:::-;34399:25;;34443:1;34433:35;;34448:18;;:::i;:::-;34433:35;34490:1;34487;34483:9;34478:14;;34313:185;;;;:::o;34504:220::-;34644:34;34640:1;34632:6;34628:14;34621:58;34713:3;34708:2;34700:6;34696:15;34689:28;34504:220;:::o;34730:366::-;34872:3;34893:67;34957:2;34952:3;34893:67;:::i;:::-;34886:74;;34969:93;35058:3;34969:93;:::i;:::-;35087:2;35082:3;35078:12;35071:19;;34730:366;;;:::o;35102:419::-;35268:4;35306:2;35295:9;35291:18;35283:26;;35355:9;35349:4;35345:20;35341:1;35330:9;35326:17;35319:47;35383:131;35509:4;35383:131;:::i;:::-;35375:139;;35102:419;;;:::o;35527:148::-;35629:11;35666:3;35651:18;;35527:148;;;;:::o;35681:214::-;35821:66;35817:1;35809:6;35805:14;35798:90;35681:214;:::o;35901:402::-;36061:3;36082:85;36164:2;36159:3;36082:85;:::i;:::-;36075:92;;36176:93;36265:3;36176:93;:::i;:::-;36294:2;36289:3;36285:12;36278:19;;35901:402;;;:::o;36309:522::-;36522:3;36544:148;36688:3;36544:148;:::i;:::-;36537:155;;36702:75;36773:3;36764:6;36702:75;:::i;:::-;36802:2;36797:3;36793:12;36786:19;;36822:3;36815:10;;36309:522;;;;:::o;36837:820::-;37061:3;37076:75;37147:3;37138:6;37076:75;:::i;:::-;37176:2;37171:3;37167:12;37160:19;;37189:75;37260:3;37251:6;37189:75;:::i;:::-;37289:2;37284:3;37280:12;37273:19;;37302:75;37373:3;37364:6;37302:75;:::i;:::-;37402:2;37397:3;37393:12;37386:19;;37415:75;37486:3;37477:6;37415:75;:::i;:::-;37515:2;37510:3;37506:12;37499:19;;37528:75;37599:3;37590:6;37528:75;:::i;:::-;37628:2;37623:3;37619:12;37612:19;;37648:3;37641:10;;36837:820;;;;;;;;:::o;37663:176::-;37695:1;37712:20;37730:1;37712:20;:::i;:::-;37707:25;;37746:20;37764:1;37746:20;:::i;:::-;37741:25;;37785:1;37775:35;;37790:18;;:::i;:::-;37775:35;37831:1;37828;37824:9;37819:14;;37663:176;;;;:::o;37845:177::-;37985:29;37981:1;37973:6;37969:14;37962:53;37845:177;:::o;38028:366::-;38170:3;38191:67;38255:2;38250:3;38191:67;:::i;:::-;38184:74;;38267:93;38356:3;38267:93;:::i;:::-;38385:2;38380:3;38376:12;38369:19;;38028:366;;;:::o;38400:419::-;38566:4;38604:2;38593:9;38589:18;38581:26;;38653:9;38647:4;38643:20;38639:1;38628:9;38624:17;38617:47;38681:131;38807:4;38681:131;:::i;:::-;38673:139;;38400:419;;;:::o;38825:538::-;38993:3;39008:75;39079:3;39070:6;39008:75;:::i;:::-;39108:2;39103:3;39099:12;39092:19;;39121:75;39192:3;39183:6;39121:75;:::i;:::-;39221:2;39216:3;39212:12;39205:19;;39234:75;39305:3;39296:6;39234:75;:::i;:::-;39334:2;39329:3;39325:12;39318:19;;39354:3;39347:10;;38825:538;;;;;;:::o;39369:174::-;39509:26;39505:1;39497:6;39493:14;39486:50;39369:174;:::o;39549:366::-;39691:3;39712:67;39776:2;39771:3;39712:67;:::i;:::-;39705:74;;39788:93;39877:3;39788:93;:::i;:::-;39906:2;39901:3;39897:12;39890:19;;39549:366;;;:::o;39921:419::-;40087:4;40125:2;40114:9;40110:18;40102:26;;40174:9;40168:4;40164:20;40160:1;40149:9;40145:17;40138:47;40202:131;40328:4;40202:131;:::i;:::-;40194:139;;39921:419;;;:::o;40346:181::-;40486:33;40482:1;40474:6;40470:14;40463:57;40346:181;:::o;40533:366::-;40675:3;40696:67;40760:2;40755:3;40696:67;:::i;:::-;40689:74;;40772:93;40861:3;40772:93;:::i;:::-;40890:2;40885:3;40881:12;40874:19;;40533:366;;;:::o;40905:419::-;41071:4;41109:2;41098:9;41094:18;41086:26;;41158:9;41152:4;41148:20;41144:1;41133:9;41129:17;41122:47;41186:131;41312:4;41186:131;:::i;:::-;41178:139;;40905:419;;;:::o;41330:221::-;41470:34;41466:1;41458:6;41454:14;41447:58;41539:4;41534:2;41526:6;41522:15;41515:29;41330:221;:::o;41557:366::-;41699:3;41720:67;41784:2;41779:3;41720:67;:::i;:::-;41713:74;;41796:93;41885:3;41796:93;:::i;:::-;41914:2;41909:3;41905:12;41898:19;;41557:366;;;:::o;41929:419::-;42095:4;42133:2;42122:9;42118:18;42110:26;;42182:9;42176:4;42172:20;42168:1;42157:9;42153:17;42146:47;42210:131;42336:4;42210:131;:::i;:::-;42202:139;;41929:419;;;:::o;42354:221::-;42494:34;42490:1;42482:6;42478:14;42471:58;42563:4;42558:2;42550:6;42546:15;42539:29;42354:221;:::o;42581:366::-;42723:3;42744:67;42808:2;42803:3;42744:67;:::i;:::-;42737:74;;42820:93;42909:3;42820:93;:::i;:::-;42938:2;42933:3;42929:12;42922:19;;42581:366;;;:::o;42953:419::-;43119:4;43157:2;43146:9;43142:18;43134:26;;43206:9;43200:4;43196:20;43192:1;43181:9;43177:17;43170:47;43234:131;43360:4;43234:131;:::i;:::-;43226:139;;42953:419;;;:::o;43378:86::-;43413:7;43453:4;43446:5;43442:16;43431:27;;43378:86;;;:::o;43470:112::-;43553:22;43569:5;43553:22;:::i;:::-;43548:3;43541:35;43470:112;;:::o;43588:545::-;43761:4;43799:3;43788:9;43784:19;43776:27;;43813:71;43881:1;43870:9;43866:17;43857:6;43813:71;:::i;:::-;43894:68;43958:2;43947:9;43943:18;43934:6;43894:68;:::i;:::-;43972:72;44040:2;44029:9;44025:18;44016:6;43972:72;:::i;:::-;44054;44122:2;44111:9;44107:18;44098:6;44054:72;:::i;:::-;43588:545;;;;;;;:::o

ipfs://0de364faac72fffcdf0bcaa2b63cbb0ec807be921fe30afddb1ce5a8c4650f9a