Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• 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 ...
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• 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 ...
•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
• library MerkleProof
•    - function verify(
•    - function verifyCalldata(
•    - function processProof(bytes32[] memor ...
•    - function processProofCalldata(bytes32 ...
•    - function multiProofVerify(
•    - function multiProofVerifyCalldata(
•    - function processMultiProof(
•    - function processMultiProofCalldata(
•    - function _hashPair(bytes32 a, bytes32 ...
•    - function _efficientHash(bytes32 a, by ...
• 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(
•    - function div(
•    - function mod(
• interface IRelationship
•    - function binding(bytes memory c)
•    - function isInvited(address player)
•    - function getInviteeList(address playe ...
•    - function getParent(address player)
•    - function getInviteCode(address player ...
•    - function getPlayerByCode(bytes memory ...
•  contract Relationship is Ownable,I ...
•    - function setEnds(uint256 _end)
•    - function setStart(uint256 _start)
•    - function binding(bytes memory c)
•    - function isInvited(address player)
•    - function getInviteeList(address playe ...
•    - function getParent(address player)
•    - function getInviteCode(address player ...
•    - function getPlayerByCode(bytes memory ...
•    - function _genCode(address player)
• interface IMintNft is IERC721Enumerab ...
•    - function mint(address to)
• interface IERC20
•    - function transferFrom(address _from, ...
•  contract ERC721Distributor is Owna ... *
•    - function removePrice(address currency ...
•    - function setPrice(address currency, u ...
•    - function setTotal(uint256 q)
•    - function setNFT(address _nft)
•    - function setCashier(address _cashier)
•    - function claim(address currency, uint ...
•    - function transferStranded(address cur ...
•    - function _claim(address currency, uin ...
•    - function getInviteReward(address user ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-04-15
*/

// Sources flattened with hardhat v2.13.0 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT
// 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/[email protected]


// 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 @openzeppelin/contracts/utils/introspection/[email protected]


// 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/[email protected]


// OpenZeppelin Contracts (last updated v4.8.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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]


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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _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) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _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/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (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 // Deprecated in v4.8
    }

    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");
        }
    }

    /**
     * @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 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 @openzeppelin/contracts/security/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File contracts/interfaces/IRelationship.sol


pragma solidity ^0.8.0;
pragma abicoder v2;

interface IRelationship {
    // Invitee is the address of the person being invited
    struct Invitee {
        address invitee;
        uint256 timestamp;
    }

    // User is the address of the person who is inviting
    struct User {
        Invitee[] inviteeList;
        address inviter;
        bytes code;
        mapping(address => uint256) indexes;
    }

    function binding(bytes memory c) external;

    function isInvited(address player) external view returns (bool);

    function getInviteeList(address player) external view returns (Invitee[] memory);

    function getParent(address player) external view returns (address);

    function getInviteCode(address player) external view returns (bytes memory);

    function getPlayerByCode(bytes memory code) external view returns (address);
}


// File contracts/utils/Relationship.sol


pragma solidity ^0.8.0;


/* @title Relationship
 * @author [email protected]
 * @dev This contract is used to manage the invitation relationship.
 *
 * @rules can't invite someone who has already invited you
 * @rules can't invite someone who has already been invited
 * @rules maximum of invitees is limited by gas
*/
contract Relationship is Ownable,IRelationship {

    bytes public defaultCode = "space0";
    uint256 public beginsTime;
    uint256 public endsTime;
    // User is the address of the person who is invited
    mapping(address => User) private _relations;
    // code used to invite
    mapping(bytes => address) private _codeUsed;

    event Binding(address indexed inviter, address indexed invitee, bytes code);

    constructor(uint256 begins, uint256 ends) {
        beginsTime = begins;
        endsTime = ends;
        _relations[msg.sender].code = defaultCode;
        _relations[msg.sender].inviter = msg.sender;
        _codeUsed[defaultCode] = msg.sender;
    }

    modifier inDuration {
        require(block.timestamp < endsTime);
        _;
    }
    function setEnds(uint256 _end) public onlyOwner{
        endsTime = _end;
    }
    function setStart(uint256 _start) public onlyOwner{
        beginsTime = _start;
    }
    // @param inviter address of the person who is inviting
    function binding(bytes memory c) public override inDuration {
        address sender = msg.sender;
        address inviter = _codeUsed[c];
        require(inviter != address(0), "code not found");
        require(inviter != sender, "Not allow inviter by self");
        // invitee address info
        User storage self = _relations[sender];
        // inviter address info
        User storage parent = _relations[inviter];

        require(parent.indexes[sender] == 0, "Can not accept child invitation");
        require(self.inviter == address(0), "Already bond invite");
        parent.inviteeList.push(Invitee(sender, block.timestamp));
        parent.indexes[sender] = self.inviteeList.length;

        self.inviter = inviter;
        bytes memory code = _genCode(sender);
        require(_codeUsed[code] == address(0), "please try again");
        self.code = code;

        _codeUsed[code] = sender;
        emit Binding(inviter, sender, code);
    }

    // @param player address if not invited
    function isInvited(address player) public view override returns (bool){
        if (_relations[player].inviter != address(0)) return true;
        return false;
    }

    // @param get player address invitee list
    function getInviteeList(address player) public view override returns (Invitee[] memory){
        return _relations[player].inviteeList;
    }

    // @param get player address inviter
    function getParent(address player) public view override returns (address){
        return _relations[player].inviter;
    }

    // @param get player address invitation code
    function getInviteCode(address player) public view override returns (bytes memory){
        return _relations[player].code;
    }

    // @param get player address by invitation code
    function getPlayerByCode(bytes memory code) public view override returns (address){
        return _codeUsed[code];
    }

    function _genCode(address player) private view  returns (bytes memory){
        bytes32 hash = keccak256(abi.encode(player, block.number));
        bytes memory code = new bytes(6);
        for (uint256 i = 0; i < code.length; i++) {
            code[i] = hash[i];
        }
        return code;
    }
}


// File contracts/ERC721Distributor.sol



pragma solidity ^0.8.0;







interface IMintNft is IERC721Enumerable {
    function mint(address to) external;
}

interface IERC20 {
    function transferFrom(address _from, address _to, uint _value) external;
}

contract ERC721Distributor is Ownable, ReentrancyGuard, Relationship {
    using SafeMath for uint256;

    address public nft;

    address public cashier;

    //    uint256 public personalLimit;
    uint256 public started;
    uint256 public ended;
    uint256 public total;
    uint256 public sold;

    address public dead = 0x000000000000000000000000000000000000dEaD;
    //    mapping(address => uint256) public bought;
    mapping(address => mapping(address => uint256)) private bought;
    mapping(address => uint256) public prices;
    constructor(
        uint256 end,
        address _nft,
        uint256 _total
    )Relationship(block.timestamp, end) {
        started = block.timestamp;
        ended = end;
        nft = _nft;

        total = _total;
        cashier = msg.sender;
    }

    event Claim(uint256 indexed tokenID, address indexed user);

    modifier isFilled(uint256 quantity) {
        require(total >= sold.add(quantity), "sold out");
        _;
    }

    function removePrice(address currency) public onlyOwner {
        delete prices[currency];

    }
    function setPrice(address currency, uint256 amount) public onlyOwner {
        prices[currency] = amount;
    }

    function setTotal(uint256 q) public onlyOwner {
        total = q;
    }

    function setNFT(address _nft) external onlyOwner {
        require(_nft != address(0), "Is zero address");
        nft = _nft;
    }

    function setCashier(address _cashier) external onlyOwner {
        require(_cashier != address(0), "Is zero address");
        cashier = _cashier;
    }

    function claim(address currency, uint256 quantity, bool isBlack) external nonReentrant inDuration {
        require(isInvited(msg.sender), "not invited");
        _claim( currency, quantity, isBlack);
    }

    function transferStranded(address currency, uint256 quantity, bool isBlack) internal {
        require(prices[currency] != 0, 'not found this currency');
        if (getParent(msg.sender) == address(0)) {
            IERC20(currency).transferFrom(msg.sender, cashier, prices[currency].mul(quantity));
        } else {
            if (isBlack) {
                IERC20(currency).transferFrom(msg.sender, dead, prices[currency].mul(quantity).mul(90).div(100));
            }else {
                IERC20(currency).transferFrom(msg.sender, cashier, prices[currency].mul(quantity).mul(90).div(100));
            }
            IERC20(currency).transferFrom(msg.sender, getParent(msg.sender), prices[currency].mul(quantity).mul(10).div(100));
            bought[getParent(msg.sender)][currency] = bought[getParent(msg.sender)][currency].add(prices[currency].mul(quantity).mul(10).div(100));
        }
    }

    function _claim(address currency, uint256 quantity, bool isBlack) internal isFilled(quantity) {
        address user = msg.sender;
        transferStranded(currency, quantity, isBlack);

        for (uint256 i = 0; i < quantity; i++) {
            IMintNft(nft).mint(user);
            sold = sold.add(1);
            uint256 id = IMintNft(nft).totalSupply();
            emit Claim(id, user);
        }
    }

    function getInviteReward(address user, address currency) public view returns (uint256) {
        if (getParent(user) == address(0)) return 0;
        return bought[user][currency];
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"address","name":"_nft","type":"address"},{"internalType":"uint256","name":"_total","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"inviter","type":"address"},{"indexed":true,"internalType":"address","name":"invitee","type":"address"},{"indexed":false,"internalType":"bytes","name":"code","type":"bytes"}],"name":"Binding","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenID","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"beginsTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"c","type":"bytes"}],"name":"binding","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cashier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"bool","name":"isBlack","type":"bool"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dead","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultCode","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ended","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endsTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"getInviteCode","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"currency","type":"address"}],"name":"getInviteReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"getInviteeList","outputs":[{"components":[{"internalType":"address","name":"invitee","type":"address"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"internalType":"struct IRelationship.Invitee[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"getParent","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"code","type":"bytes"}],"name":"getPlayerByCode","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"isInvited","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"prices","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"currency","type":"address"}],"name":"removePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_cashier","type":"address"}],"name":"setCashier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_end","type":"uint256"}],"name":"setEnds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nft","type":"address"}],"name":"setNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"currency","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_start","type":"uint256"}],"name":"setStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"q","type":"uint256"}],"name":"setTotal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"started","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000661b8e26000000000000000000000000095ebcd862302e7f15b303d42ebe40a33f3794350000000000000000000000000000000000000000000000000000000000000c44

-----Decoded View---------------
Arg [0] : end (uint256): 1713081894
Arg [1] : _nft (address): 0x095EBCd862302e7f15b303d42EBE40A33f379435
Arg [2] : _total (uint256): 3140

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000661b8e26
Arg [1] : 000000000000000000000000095ebcd862302e7f15b303d42ebe40a33f379435
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000c44

59278:3401:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60413:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59571:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57984:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59517:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57760:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59488:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60534:74;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59544:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59599:64;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59389:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55826:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58552:123;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2884:103;;;:::i;:::-;;60922:209;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56485:81;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2236:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58360:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55752:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58177:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60759:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56727:980;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55794:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59793:41;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62487:189;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59416:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3142:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60307:100;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60616:135;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56572:88;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60413:113;2122:13;:11;:13::i;:::-;60512:6:::1;60493;:16;60500:8;60493:16;;;;;;;;;;;;;;;:25;;;;60413:113:::0;;:::o;59571:19::-;;;;:::o;57984:143::-;58054:16;58089:10;:18;58100:6;58089:18;;;;;;;;;;;;;;;:30;;58082:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57984:143;;;:::o;59517:20::-;;;;:::o;57760:169::-;57825:4;57883:1;57845:40;;:10;:18;57856:6;57845:18;;;;;;;;;;;;;;;:26;;;;;;;;;;;;:40;;;57841:57;;57894:4;57887:11;;;;57841:57;57916:5;57909:12;;57760:169;;;;:::o;59488:22::-;;;;:::o;60534:74::-;2122:13;:11;:13::i;:::-;60599:1:::1;60591:5;:9;;;;60534:74:::0;:::o;59544:20::-;;;;:::o;59599:64::-;;;;;;;;;;;;;:::o;59389:18::-;;;;;;;;;;;;;:::o;55826:23::-;;;;:::o;58552:123::-;58626:7;58652:9;58662:4;58652:15;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;58645:22;;58552:123;;;:::o;2884:103::-;2122:13;:11;:13::i;:::-;2949:30:::1;2976:1;2949:18;:30::i;:::-;2884:103::o:0;60922:209::-;37155:21;:19;:21::i;:::-;56450:8:::1;;56432:15;:26;56424:35;;;::::0;::::1;;61039:21:::2;61049:10;61039:9;:21::i;:::-;61031:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;61087:36;61095:8;61105;61115:7;61087:6;:36::i;:::-;37199:20:::0;:18;:20::i;:::-;60922:209;;;:::o;56485:81::-;2122:13;:11;:13::i;:::-;56554:4:::1;56543:8;:15;;;;56485:81:::0;:::o;2236:87::-;2282:7;2309:6;;;;;;;;;;;2302:13;;2236:87;:::o;58360:131::-;58429:12;58460:10;:18;58471:6;58460:18;;;;;;;;;;;;;;;:23;;58453:30;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58360:131;;;:::o;55752:35::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58177:125::-;58242:7;58268:10;:18;58279:6;58268:18;;;;;;;;;;;;;;;:26;;;;;;;;;;;;58261:33;;58177:125;;;:::o;60759:155::-;2122:13;:11;:13::i;:::-;60855:1:::1;60835:22;;:8;:22;;;;60827:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;60898:8;60888:7;;:18;;;;;;;;;;;;;;;;;;60759:155:::0;:::o;56727:980::-;56450:8;;56432:15;:26;56424:35;;;;;;56798:14:::1;56815:10;56798:27;;56836:15;56854:9;56864:1;56854:12;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;56836:30;;56904:1;56885:21;;:7;:21;;;;56877:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;56955:6;56944:17;;:7;:17;;;;56936:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;57035:17;57055:10;:18;57066:6;57055:18;;;;;;;;;;;;;;;57035:38;;57117:19;57139:10;:19;57150:7;57139:19;;;;;;;;;;;;;;;57117:41;;57205:1;57179:6;:14;;:22;57194:6;57179:22;;;;;;;;;;;;;;;;:27;57171:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;57285:1;57261:26;;:4;:12;;;;;;;;;;;;:26;;;57253:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;57322:6;:18;;57346:32;;;;;;;;57354:6;57346:32;;;;;;57362:15;57346:32;;::::0;57322:57:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57415:4;:16;;:23;;;;57390:6;:14;;:22;57405:6;57390:22;;;;;;;;;;;;;;;:48;;;;57466:7;57451:4;:12;;;:22;;;;;;;;;;;;;;;;;;57484:17;57504:16;57513:6;57504:8;:16::i;:::-;57484:36;;57566:1;57539:29;;:9;57549:4;57539:15;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:29;;;57531:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;57612:4;57600;:9;;:16;;;;;;;;;;;;:::i;:::-;;57647:6;57629:9;57639:4;57629:15;;;;;;:::i;:::-;;;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;57686:6;57669:30;;57677:7;57669:30;;;57694:4;57669:30;;;;;;:::i;:::-;;;;;;;;56787:920;;;;;56727:980:::0;:::o;55794:25::-;;;;:::o;59793:41::-;;;;;;;;;;;;;;;;;:::o;62487:189::-;62565:7;62616:1;62589:29;;:15;62599:4;62589:9;:15::i;:::-;:29;;;62585:43;;;62627:1;62620:8;;;;62585:43;62646:6;:12;62653:4;62646:12;;;;;;;;;;;;;;;:22;62659:8;62646:22;;;;;;;;;;;;;;;;62639:29;;62487:189;;;;;:::o;59416:22::-;;;;;;;;;;;;;:::o;3142:201::-;2122:13;:11;:13::i;:::-;3251:1:::1;3231:22;;:8;:22;;;;3223:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;3307:28;3326:8;3307:18;:28::i;:::-;3142:201:::0;:::o;60307:100::-;2122:13;:11;:13::i;:::-;60381:6:::1;:16;60388:8;60381:16;;;;;;;;;;;;;;;60374:23;;;60307:100:::0;:::o;60616:135::-;2122:13;:11;:13::i;:::-;60700:1:::1;60684:18;;:4;:18;;;;60676:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;60739:4;60733:3;;:10;;;;;;;;;;;;;;;;;;60616:135:::0;:::o;56572:88::-;2122:13;:11;:13::i;:::-;56646:6:::1;56633:10;:19;;;;56572:88:::0;:::o;2401:132::-;2476:12;:10;:12::i;:::-;2465:23;;:7;:5;:7::i;:::-;:23;;;2457:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2401:132::o;3503:191::-;3577:16;3596:6;;;;;;;;;;;3577:25;;3622:8;3613:6;;:17;;;;;;;;;;;;;;;;;;3677:8;3646:40;;3667:8;3646:40;;;;;;;;;;;;3566:128;3503:191;:::o;37235:293::-;36637:1;37369:7;;:19;;37361:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;36637:1;37502:7;:18;;;;37235:293::o;62060:419::-;62144:8;60248:18;60257:8;60248:4;;:8;;:18;;;;:::i;:::-;60239:5;;:27;;60231:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;62165:12:::1;62180:10;62165:25;;62201:45;62218:8;62228;62238:7;62201:16;:45::i;:::-;62264:9;62259:213;62283:8;62279:1;:12;62259:213;;;62322:3;;;;;;;;;;;62313:18;;;62332:4;62313:24;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;62359:11;62368:1;62359:4;;:8;;:11;;;;:::i;:::-;62352:4;:18;;;;62385:10;62407:3;;;;;;;;;;;62398:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62385:40;;62455:4;62445:15;;62451:2;62445:15;;;;;;;;;;62298:174;62293:3;;;;;:::i;:::-;;;;62259:213;;;;62154:325;62060:419:::0;;;;:::o;37536:213::-;36593:1;37719:7;:22;;;;37536:213::o;58683:308::-;58740:12;58764;58800:6;58808:12;58789:32;;;;;;;;;:::i;:::-;;;;;;;;;;;;;58779:43;;;;;;58764:58;;58833:17;58863:1;58853:12;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58833:32;;58881:9;58876:86;58900:4;:11;58896:1;:15;58876:86;;;58943:4;58948:1;58943:7;;;;;;;:::i;:::-;;;;;58933:4;58938:1;58933:7;;;;;;;;:::i;:::-;;;;;:17;;;;;;;;;;;58913:3;;;;;:::i;:::-;;;;58876:86;;;;58979:4;58972:11;;;;58683:308;;;:::o;781:98::-;834:7;861:10;854:17;;781:98;:::o;50209:::-;50267:7;50298:1;50294;:5;;;;:::i;:::-;50287:12;;50209:98;;;;:::o;61139:913::-;61263:1;61243:6;:16;61250:8;61243:16;;;;;;;;;;;;;;;;:21;;61235:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;61340:1;61307:35;;:21;61317:10;61307:9;:21::i;:::-;:35;;;61303:742;;;61366:8;61359:29;;;61389:10;61401:7;;;;;;;;;;;61410:30;61431:8;61410:6;:16;61417:8;61410:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;61359:82;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61303:742;;;61478:7;61474:283;;;61513:8;61506:29;;;61536:10;61548:4;;;;;;;;;;;61554:47;61597:3;61554:38;61589:2;61554:30;61575:8;61554:6;:16;61561:8;61554:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61506:96;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61474:283;;;61649:8;61642:29;;;61672:10;61684:7;;;;;;;;;;;61693:47;61736:3;61693:38;61728:2;61693:30;61714:8;61693:6;:16;61700:8;61693:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61642:99;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61474:283;61778:8;61771:29;;;61801:10;61813:21;61823:10;61813:9;:21::i;:::-;61836:47;61879:3;61836:38;61871:2;61836:30;61857:8;61836:6;:16;61843:8;61836:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61771:113;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61941:92;61985:47;62028:3;61985:38;62020:2;61985:30;62006:8;61985:6;:16;61992:8;61985:16;;;;;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;:34;;:38;;;;:::i;:::-;:42;;:47;;;;:::i;:::-;61941:6;:29;61948:21;61958:10;61948:9;:21::i;:::-;61941:29;;;;;;;;;;;;;;;:39;61971:8;61941:39;;;;;;;;;;;;;;;;:43;;:92;;;;:::i;:::-;61899:6;:29;61906:21;61916:10;61906:9;:21::i;:::-;61899:29;;;;;;;;;;;;;;;:39;61929:8;61899:39;;;;;;;;;;;;;;;:134;;;;61303:742;61139:913;;;:::o;50947:98::-;51005:7;51036:1;51032;:5;;;;:::i;:::-;51025:12;;50947:98;;;;:::o;51346:::-;51404:7;51435:1;51431;:5;;;;:::i;:::-;51424:12;;51346:98;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:139::-;469:5;507:6;494:20;485:29;;523:33;550:5;523:33;:::i;:::-;423:139;;;;:::o;568:133::-;611:5;649:6;636:20;627:29;;665:30;689:5;665:30;:::i;:::-;568:133;;;;:::o;720:338::-;775:5;824:3;817:4;809:6;805:17;801:27;791:122;;832:79;;:::i;:::-;791:122;949:6;936:20;974:78;1048:3;1040:6;1033:4;1025:6;1021:17;974:78;:::i;:::-;965:87;;781:277;720:338;;;;:::o;1064:139::-;1110:5;1148:6;1135:20;1126:29;;1164:33;1191:5;1164:33;:::i;:::-;1064:139;;;;:::o;1209:143::-;1266:5;1297:6;1291:13;1282:22;;1313:33;1340:5;1313:33;:::i;:::-;1209:143;;;;:::o;1358:329::-;1417:6;1466:2;1454:9;1445:7;1441:23;1437:32;1434:119;;;1472:79;;:::i;:::-;1434:119;1592:1;1617:53;1662:7;1653:6;1642:9;1638:22;1617:53;:::i;:::-;1607:63;;1563:117;1358:329;;;;:::o;1693:474::-;1761:6;1769;1818:2;1806:9;1797:7;1793:23;1789:32;1786:119;;;1824:79;;:::i;:::-;1786:119;1944:1;1969:53;2014:7;2005:6;1994:9;1990:22;1969:53;:::i;:::-;1959:63;;1915:117;2071:2;2097:53;2142:7;2133:6;2122:9;2118:22;2097:53;:::i;:::-;2087:63;;2042:118;1693:474;;;;;:::o;2173:::-;2241:6;2249;2298:2;2286:9;2277:7;2273:23;2269:32;2266:119;;;2304:79;;:::i;:::-;2266:119;2424:1;2449:53;2494:7;2485:6;2474:9;2470:22;2449:53;:::i;:::-;2439:63;;2395:117;2551:2;2577:53;2622:7;2613:6;2602:9;2598:22;2577:53;:::i;:::-;2567:63;;2522:118;2173:474;;;;;:::o;2653:613::-;2727:6;2735;2743;2792:2;2780:9;2771:7;2767:23;2763:32;2760:119;;;2798:79;;:::i;:::-;2760:119;2918:1;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2889:117;3045:2;3071:53;3116:7;3107:6;3096:9;3092:22;3071:53;:::i;:::-;3061:63;;3016:118;3173:2;3199:50;3241:7;3232:6;3221:9;3217:22;3199:50;:::i;:::-;3189:60;;3144:115;2653:613;;;;;:::o;3272:507::-;3340:6;3389:2;3377:9;3368:7;3364:23;3360:32;3357:119;;;3395:79;;:::i;:::-;3357:119;3543:1;3532:9;3528:17;3515:31;3573:18;3565:6;3562:30;3559:117;;;3595:79;;:::i;:::-;3559:117;3700:62;3754:7;3745:6;3734:9;3730:22;3700:62;:::i;:::-;3690:72;;3486:286;3272:507;;;;:::o;3785:329::-;3844:6;3893:2;3881:9;3872:7;3868:23;3864:32;3861:119;;;3899:79;;:::i;:::-;3861:119;4019:1;4044:53;4089:7;4080:6;4069:9;4065:22;4044:53;:::i;:::-;4034:63;;3990:117;3785:329;;;;:::o;4120:351::-;4190:6;4239:2;4227:9;4218:7;4214:23;4210:32;4207:119;;;4245:79;;:::i;:::-;4207:119;4365:1;4390:64;4446:7;4437:6;4426:9;4422:22;4390:64;:::i;:::-;4380:74;;4336:128;4120:351;;;;:::o;4477:279::-;4596:10;4617:96;4709:3;4701:6;4617:96;:::i;:::-;4745:4;4740:3;4736:14;4722:28;;4477:279;;;;:::o;4762:108::-;4839:24;4857:5;4839:24;:::i;:::-;4834:3;4827:37;4762:108;;:::o;4876:118::-;4963:24;4981:5;4963:24;:::i;:::-;4958:3;4951:37;4876:118;;:::o;5072:932::-;5241:3;5270:79;5343:5;5270:79;:::i;:::-;5365:111;5469:6;5464:3;5365:111;:::i;:::-;5358:118;;5500:81;5575:5;5500:81;:::i;:::-;5604:7;5635:1;5620:359;5645:6;5642:1;5639:13;5620:359;;;5721:6;5715:13;5748:113;5857:3;5842:13;5748:113;:::i;:::-;5741:120;;5884:85;5962:6;5884:85;:::i;:::-;5874:95;;5680:299;5667:1;5664;5660:9;5655:14;;5620:359;;;5624:14;5995:3;5988:10;;5246:758;;;5072:932;;;;:::o;6010:109::-;6091:21;6106:5;6091:21;:::i;:::-;6086:3;6079:34;6010:109;;:::o;6125:360::-;6211:3;6239:38;6271:5;6239:38;:::i;:::-;6293:70;6356:6;6351:3;6293:70;:::i;:::-;6286:77;;6372:52;6417:6;6412:3;6405:4;6398:5;6394:16;6372:52;:::i;:::-;6449:29;6471:6;6449:29;:::i;:::-;6444:3;6440:39;6433:46;;6215:270;6125:360;;;;:::o;6491:373::-;6595:3;6623:38;6655:5;6623:38;:::i;:::-;6677:88;6758:6;6753:3;6677:88;:::i;:::-;6670:95;;6774:52;6819:6;6814:3;6807:4;6800:5;6796:16;6774:52;:::i;:::-;6851:6;6846:3;6842:16;6835:23;;6599:265;6491:373;;;;:::o;6870:366::-;7012:3;7033:67;7097:2;7092:3;7033:67;:::i;:::-;7026:74;;7109:93;7198:3;7109:93;:::i;:::-;7227:2;7222:3;7218:12;7211:19;;6870:366;;;:::o;7242:::-;7384:3;7405:67;7469:2;7464:3;7405:67;:::i;:::-;7398:74;;7481:93;7570:3;7481:93;:::i;:::-;7599:2;7594:3;7590:12;7583:19;;7242:366;;;:::o;7614:::-;7756:3;7777:67;7841:2;7836:3;7777:67;:::i;:::-;7770:74;;7853:93;7942:3;7853:93;:::i;:::-;7971:2;7966:3;7962:12;7955:19;;7614:366;;;:::o;7986:::-;8128:3;8149:67;8213:2;8208:3;8149:67;:::i;:::-;8142:74;;8225:93;8314:3;8225:93;:::i;:::-;8343:2;8338:3;8334:12;8327:19;;7986:366;;;:::o;8358:365::-;8500:3;8521:66;8585:1;8580:3;8521:66;:::i;:::-;8514:73;;8596:93;8685:3;8596:93;:::i;:::-;8714:2;8709:3;8705:12;8698:19;;8358:365;;;:::o;8729:366::-;8871:3;8892:67;8956:2;8951:3;8892:67;:::i;:::-;8885:74;;8968:93;9057:3;8968:93;:::i;:::-;9086:2;9081:3;9077:12;9070:19;;8729:366;;;:::o;9101:::-;9243:3;9264:67;9328:2;9323:3;9264:67;:::i;:::-;9257:74;;9340:93;9429:3;9340:93;:::i;:::-;9458:2;9453:3;9449:12;9442:19;;9101:366;;;:::o;9473:::-;9615:3;9636:67;9700:2;9695:3;9636:67;:::i;:::-;9629:74;;9712:93;9801:3;9712:93;:::i;:::-;9830:2;9825:3;9821:12;9814:19;;9473:366;;;:::o;9845:::-;9987:3;10008:67;10072:2;10067:3;10008:67;:::i;:::-;10001:74;;10084:93;10173:3;10084:93;:::i;:::-;10202:2;10197:3;10193:12;10186:19;;9845:366;;;:::o;10217:::-;10359:3;10380:67;10444:2;10439:3;10380:67;:::i;:::-;10373:74;;10456:93;10545:3;10456:93;:::i;:::-;10574:2;10569:3;10565:12;10558:19;;10217:366;;;:::o;10589:::-;10731:3;10752:67;10816:2;10811:3;10752:67;:::i;:::-;10745:74;;10828:93;10917:3;10828:93;:::i;:::-;10946:2;10941:3;10937:12;10930:19;;10589:366;;;:::o;10961:::-;11103:3;11124:67;11188:2;11183:3;11124:67;:::i;:::-;11117:74;;11200:93;11289:3;11200:93;:::i;:::-;11318:2;11313:3;11309:12;11302:19;;10961:366;;;:::o;11401:505::-;11538:4;11533:3;11529:14;11628:4;11621:5;11617:16;11611:23;11647:63;11704:4;11699:3;11695:14;11681:12;11647:63;:::i;:::-;11553:167;11807:4;11800:5;11796:16;11790:23;11826:63;11883:4;11878:3;11874:14;11860:12;11826:63;:::i;:::-;11730:169;11507:399;11401:505;;:::o;11912:108::-;11989:24;12007:5;11989:24;:::i;:::-;11984:3;11977:37;11912:108;;:::o;12026:118::-;12113:24;12131:5;12113:24;:::i;:::-;12108:3;12101:37;12026:118;;:::o;12150:271::-;12280:3;12302:93;12391:3;12382:6;12302:93;:::i;:::-;12295:100;;12412:3;12405:10;;12150:271;;;;:::o;12427:222::-;12520:4;12558:2;12547:9;12543:18;12535:26;;12571:71;12639:1;12628:9;12624:17;12615:6;12571:71;:::i;:::-;12427:222;;;;:::o;12655:442::-;12804:4;12842:2;12831:9;12827:18;12819:26;;12855:71;12923:1;12912:9;12908:17;12899:6;12855:71;:::i;:::-;12936:72;13004:2;12993:9;12989:18;12980:6;12936:72;:::i;:::-;13018;13086:2;13075:9;13071:18;13062:6;13018:72;:::i;:::-;12655:442;;;;;;:::o;13103:332::-;13224:4;13262:2;13251:9;13247:18;13239:26;;13275:71;13343:1;13332:9;13328:17;13319:6;13275:71;:::i;:::-;13356:72;13424:2;13413:9;13409:18;13400:6;13356:72;:::i;:::-;13103:332;;;;;:::o;13441:473::-;13634:4;13672:2;13661:9;13657:18;13649:26;;13721:9;13715:4;13711:20;13707:1;13696:9;13692:17;13685:47;13749:158;13902:4;13893:6;13749:158;:::i;:::-;13741:166;;13441:473;;;;:::o;13920:210::-;14007:4;14045:2;14034:9;14030:18;14022:26;;14058:65;14120:1;14109:9;14105:17;14096:6;14058:65;:::i;:::-;13920:210;;;;:::o;14136:309::-;14247:4;14285:2;14274:9;14270:18;14262:26;;14334:9;14328:4;14324:20;14320:1;14309:9;14305:17;14298:47;14362:76;14433:4;14424:6;14362:76;:::i;:::-;14354:84;;14136:309;;;;:::o;14451:419::-;14617:4;14655:2;14644:9;14640:18;14632:26;;14704:9;14698:4;14694:20;14690:1;14679:9;14675:17;14668:47;14732:131;14858:4;14732:131;:::i;:::-;14724:139;;14451:419;;;:::o;14876:::-;15042:4;15080:2;15069:9;15065:18;15057:26;;15129:9;15123:4;15119:20;15115:1;15104:9;15100:17;15093:47;15157:131;15283:4;15157:131;:::i;:::-;15149:139;;14876:419;;;:::o;15301:::-;15467:4;15505:2;15494:9;15490:18;15482:26;;15554:9;15548:4;15544:20;15540:1;15529:9;15525:17;15518:47;15582:131;15708:4;15582:131;:::i;:::-;15574:139;;15301:419;;;:::o;15726:::-;15892:4;15930:2;15919:9;15915:18;15907:26;;15979:9;15973:4;15969:20;15965:1;15954:9;15950:17;15943:47;16007:131;16133:4;16007:131;:::i;:::-;15999:139;;15726:419;;;:::o;16151:::-;16317:4;16355:2;16344:9;16340:18;16332:26;;16404:9;16398:4;16394:20;16390:1;16379:9;16375:17;16368:47;16432:131;16558:4;16432:131;:::i;:::-;16424:139;;16151:419;;;:::o;16576:::-;16742:4;16780:2;16769:9;16765:18;16757:26;;16829:9;16823:4;16819:20;16815:1;16804:9;16800:17;16793:47;16857:131;16983:4;16857:131;:::i;:::-;16849:139;;16576:419;;;:::o;17001:::-;17167:4;17205:2;17194:9;17190:18;17182:26;;17254:9;17248:4;17244:20;17240:1;17229:9;17225:17;17218:47;17282:131;17408:4;17282:131;:::i;:::-;17274:139;;17001:419;;;:::o;17426:::-;17592:4;17630:2;17619:9;17615:18;17607:26;;17679:9;17673:4;17669:20;17665:1;17654:9;17650:17;17643:47;17707:131;17833:4;17707:131;:::i;:::-;17699:139;;17426:419;;;:::o;17851:::-;18017:4;18055:2;18044:9;18040:18;18032:26;;18104:9;18098:4;18094:20;18090:1;18079:9;18075:17;18068:47;18132:131;18258:4;18132:131;:::i;:::-;18124:139;;17851:419;;;:::o;18276:::-;18442:4;18480:2;18469:9;18465:18;18457:26;;18529:9;18523:4;18519:20;18515:1;18504:9;18500:17;18493:47;18557:131;18683:4;18557:131;:::i;:::-;18549:139;;18276:419;;;:::o;18701:::-;18867:4;18905:2;18894:9;18890:18;18882:26;;18954:9;18948:4;18944:20;18940:1;18929:9;18925:17;18918:47;18982:131;19108:4;18982:131;:::i;:::-;18974:139;;18701:419;;;:::o;19126:::-;19292:4;19330:2;19319:9;19315:18;19307:26;;19379:9;19373:4;19369:20;19365:1;19354:9;19350:17;19343:47;19407:131;19533:4;19407:131;:::i;:::-;19399:139;;19126:419;;;:::o;19551:222::-;19644:4;19682:2;19671:9;19667:18;19659:26;;19695:71;19763:1;19752:9;19748:17;19739:6;19695:71;:::i;:::-;19551:222;;;;:::o;19779:129::-;19813:6;19840:20;;:::i;:::-;19830:30;;19869:33;19897:4;19889:6;19869:33;:::i;:::-;19779:129;;;:::o;19914:75::-;19947:6;19980:2;19974:9;19964:19;;19914:75;:::o;19995:307::-;20056:4;20146:18;20138:6;20135:30;20132:56;;;20168:18;;:::i;:::-;20132:56;20206:29;20228:6;20206:29;:::i;:::-;20198:37;;20290:4;20284;20280:15;20272:23;;19995:307;;;:::o;20308:157::-;20400:4;20423:3;20415:11;;20453:4;20448:3;20444:14;20436:22;;20308:157;;;:::o;20471:139::-;20563:6;20597:5;20591:12;20581:22;;20471:139;;;:::o;20616:98::-;20667:6;20701:5;20695:12;20685:22;;20616:98;;;:::o;20720:138::-;20815:4;20847;20842:3;20838:14;20830:22;;20720:138;;;:::o;20864:209::-;20988:11;21022:6;21017:3;21010:19;21062:4;21057:3;21053:14;21038:29;;20864:209;;;;:::o;21079:168::-;21162:11;21196:6;21191:3;21184:19;21236:4;21231:3;21227:14;21212:29;;21079:168;;;;:::o;21253:147::-;21354:11;21391:3;21376:18;;21253:147;;;;:::o;21406:169::-;21490:11;21524:6;21519:3;21512:19;21564:4;21559:3;21555:14;21540:29;;21406:169;;;;:::o;21581:305::-;21621:3;21640:20;21658:1;21640:20;:::i;:::-;21635:25;;21674:20;21692:1;21674:20;:::i;:::-;21669:25;;21828:1;21760:66;21756:74;21753:1;21750:81;21747:107;;;21834:18;;:::i;:::-;21747:107;21878:1;21875;21871:9;21864:16;;21581:305;;;;:::o;21892:185::-;21932:1;21949:20;21967:1;21949:20;:::i;:::-;21944:25;;21983:20;22001:1;21983:20;:::i;:::-;21978:25;;22022:1;22012:35;;22027:18;;:::i;:::-;22012:35;22069:1;22066;22062:9;22057:14;;21892:185;;;;:::o;22083:348::-;22123:7;22146:20;22164:1;22146:20;:::i;:::-;22141:25;;22180:20;22198:1;22180:20;:::i;:::-;22175:25;;22368:1;22300:66;22296:74;22293:1;22290:81;22285:1;22278:9;22271:17;22267:105;22264:131;;;22375:18;;:::i;:::-;22264:131;22423:1;22420;22416:9;22405:20;;22083:348;;;;:::o;22437:96::-;22474:7;22503:24;22521:5;22503:24;:::i;:::-;22492:35;;22437:96;;;:::o;22539:90::-;22573:7;22616:5;22609:13;22602:21;22591:32;;22539:90;;;:::o;22635:126::-;22672:7;22712:42;22705:5;22701:54;22690:65;;22635:126;;;:::o;22767:77::-;22804:7;22833:5;22822:16;;22767:77;;;:::o;22850:154::-;22934:6;22929:3;22924;22911:30;22996:1;22987:6;22982:3;22978:16;22971:27;22850:154;;;:::o;23010:307::-;23078:1;23088:113;23102:6;23099:1;23096:13;23088:113;;;23187:1;23182:3;23178:11;23172:18;23168:1;23163:3;23159:11;23152:39;23124:2;23121:1;23117:10;23112:15;;23088:113;;;23219:6;23216:1;23213:13;23210:101;;;23299:1;23290:6;23285:3;23281:16;23274:27;23210:101;23059:258;23010:307;;;:::o;23323:320::-;23367:6;23404:1;23398:4;23394:12;23384:22;;23451:1;23445:4;23441:12;23472:18;23462:81;;23528:4;23520:6;23516:17;23506:27;;23462:81;23590:2;23582:6;23579:14;23559:18;23556:38;23553:84;;;23609:18;;:::i;:::-;23553:84;23374:269;23323:320;;;:::o;23649:281::-;23732:27;23754:4;23732:27;:::i;:::-;23724:6;23720:40;23862:6;23850:10;23847:22;23826:18;23814:10;23811:34;23808:62;23805:88;;;23873:18;;:::i;:::-;23805:88;23913:10;23909:2;23902:22;23692:238;23649:281;;:::o;23936:233::-;23975:3;23998:24;24016:5;23998:24;:::i;:::-;23989:33;;24044:66;24037:5;24034:77;24031:103;;;24114:18;;:::i;:::-;24031:103;24161:1;24154:5;24150:13;24143:20;;23936:233;;;:::o;24175:180::-;24223:77;24220:1;24213:88;24320:4;24317:1;24310:15;24344:4;24341:1;24334:15;24361:180;24409:77;24406:1;24399:88;24506:4;24503:1;24496:15;24530:4;24527:1;24520:15;24547:180;24595:77;24592:1;24585:88;24692:4;24689:1;24682:15;24716:4;24713:1;24706:15;24733:180;24781:77;24778:1;24771:88;24878:4;24875:1;24868:15;24902:4;24899:1;24892:15;24919:180;24967:77;24964:1;24957:88;25064:4;25061:1;25054:15;25088:4;25085:1;25078:15;25105:117;25214:1;25211;25204:12;25228:117;25337:1;25334;25327:12;25351:117;25460:1;25457;25450:12;25474:117;25583:1;25580;25573:12;25597:102;25638:6;25689:2;25685:7;25680:2;25673:5;25669:14;25665:28;25655:38;;25597:102;;;:::o;25705:161::-;25845:13;25841:1;25833:6;25829:14;25822:37;25705:161;:::o;25872:225::-;26012:34;26008:1;26000:6;25996:14;25989:58;26081:8;26076:2;26068:6;26064:15;26057:33;25872:225;:::o;26103:164::-;26243:16;26239:1;26231:6;26227:14;26220:40;26103:164;:::o;26273:175::-;26413:27;26409:1;26401:6;26397:14;26390:51;26273:175;:::o;26454:158::-;26594:10;26590:1;26582:6;26578:14;26571:34;26454:158;:::o;26618:165::-;26758:17;26754:1;26746:6;26742:14;26735:41;26618:165;:::o;26789:173::-;26929:25;26925:1;26917:6;26913:14;26906:49;26789:173;:::o;26968:181::-;27108:33;27104:1;27096:6;27092:14;27085:57;26968:181;:::o;27155:182::-;27295:34;27291:1;27283:6;27279:14;27272:58;27155:182;:::o;27343:166::-;27483:18;27479:1;27471:6;27467:14;27460:42;27343:166;:::o;27515:181::-;27655:33;27651:1;27643:6;27639:14;27632:57;27515:181;:::o;27702:169::-;27842:21;27838:1;27830:6;27826:14;27819:45;27702:169;:::o;27877:122::-;27950:24;27968:5;27950:24;:::i;:::-;27943:5;27940:35;27930:63;;27989:1;27986;27979:12;27930:63;27877:122;:::o;28005:116::-;28075:21;28090:5;28075:21;:::i;:::-;28068:5;28065:32;28055:60;;28111:1;28108;28101:12;28055:60;28005:116;:::o;28127:122::-;28200:24;28218:5;28200:24;:::i;:::-;28193:5;28190:35;28180:63;;28239:1;28236;28229:12;28180:63;28127:122;:::o

ipfs://0d3f075819e184ec4b48931367fc75e253d0843a55d9a082e5375610fb9f179e