Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC1363 is IERC20, IERC165
•    - function transferAndCall(address to, ...
•    - function transferAndCall(address to, ...
•    - function transferFromAndCall(address ...
•    - function transferFromAndCall(address ...
•    - function approveAndCall(address spend ...
•    - function approveAndCall(address spend ...
• library Errors
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function transferAndCallRelaxed(IERC1 ...
•    - function transferFromAndCallRelaxed(
•    - function approveAndCallRelaxed(IERC13 ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
• library Hashes
•    - function commutativeKeccak256(bytes32 ...
•    - function _efficientKeccak256(bytes32 ...
• library MerkleProof
•    - function verify(bytes32[] memory proo ...
•    - function processProof(bytes32[] memor ...
•    - function verify(
•    - function(bytes32, bytes32)
•    - function processProof(
•    - function(bytes32, bytes32)
•    - function verifyCalldata(bytes32[] cal ...
•    - function processProofCalldata(bytes32 ...
•    - function verifyCalldata(
•    - function(bytes32, bytes32)
•    - function processProofCalldata(
•    - function(bytes32, bytes32)
•    - function multiProofVerify(
•    - function processMultiProof(
•    - function multiProofVerify(
•    - function(bytes32, bytes32)
•    - function processMultiProof(
•    - function(bytes32, bytes32)
•    - function multiProofVerifyCalldata(
•    - function processMultiProofCalldata(
•    - function multiProofVerifyCalldata(
•    - function(bytes32, bytes32)
•    - function processMultiProofCalldata(
•    - function(bytes32, bytes32)
• interface IRouter
•    - function swapExactETHForTokens(
•    - function swapExactTokensForETH(
•    - function WETH()
•  contract Sanic *
•    - function compound(address ref)
•    - function withdraw()
•    - function depositS(uint minAmount, add ...
•    - function depositSanic(uint amount, ad ...
•    - function depositSanicWithProof(
•    - function _deposit(uint amount, addres ...
•    - function _swap(uint minTokenOut)
•    - function calculateTrade(
•    - function calculatePointSell(uint256 p ...
•    - function calculatePointBuy(
•    - function calculatePointBuySimple(uint ...
•    - function devFee(uint256 amount)
•    - function seedMarket()
•    - function getBalance()
•    - function getMyMiners()
•    - function getMyPoints()
•    - function getPointsSinceLastInk(addres ...
•    - function getHalvingPercentage()
•    - function min(uint256 a, uint256 b)

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-02-27
*/

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

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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);
}

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}




/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 *
 * _Available since v5.1._
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}





/**
 * @dev Library of standard hash functions.
 *
 * _Available since v5.1._
 */
library Hashes {
    /**
     * @dev Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when working with merkle proofs.
     *
     * NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
     */
    function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) {
        return a < b ? _efficientKeccak256(a, b) : _efficientKeccak256(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientKeccak256(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly ("memory-safe") {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

/**
 * @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.
 *
 * IMPORTANT: Consider memory side-effects when using custom hashing functions
 * that access memory in an unsafe way.
 *
 * NOTE: This library supports proof verification for merkle trees built using
 * custom _commutative_ hashing functions (i.e. `H(a, b) == H(b, a)`). Proving
 * leaf inclusion in trees built using non-commutative hashing functions requires
 * additional logic that is not supported by this library.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @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.
     *
     * This version handles proofs in memory with the default hashing function.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(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 leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with the default hashing function.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @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.
     *
     * This version handles proofs in memory with a custom hashing function.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processProof(proof, leaf, hasher) == 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 leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with a custom hashing function.
     */
    function processProof(
        bytes32[] memory proof,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = hasher(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @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.
     *
     * This version handles proofs in calldata with the default hashing function.
     */
    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 leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with the default hashing function.
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @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.
     *
     * This version handles proofs in calldata with a custom hashing function.
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processProofCalldata(proof, leaf, hasher) == 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 leaves & pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with a custom hashing function.
     */
    function processProofCalldata(
        bytes32[] calldata proof,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = hasher(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}.
     *
     * This version handles multiproofs in memory with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProof}.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(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.
     *
     * This version handles multiproofs in memory with the default hashing function.
     *
     * 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).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds 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 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // 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[](proofFlagsLen);
        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 from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = Hashes.commutativeKeccak256(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @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}.
     *
     * This version handles multiproofs in memory with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProof}.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processMultiProof(proof, proofFlags, leaves, hasher) == 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.
     *
     * This version handles multiproofs in memory with a custom hashing function.
     *
     * 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).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32 merkleRoot) {
        // This function rebuilds 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 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // 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[](proofFlagsLen);
        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 from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = hasher(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @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}.
     *
     * This version handles multiproofs in calldata with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProofCalldata}.
     */
    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.
     *
     * This version handles multiproofs in calldata with the default hashing function.
     *
     * 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).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds 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 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // 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[](proofFlagsLen);
        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 from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = Hashes.commutativeKeccak256(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @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}.
     *
     * This version handles multiproofs in calldata with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProofCalldata}.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves, hasher) == 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.
     *
     * This version handles multiproofs in calldata with a custom hashing function.
     *
     * 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).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32 merkleRoot) {
        // This function rebuilds 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 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // 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[](proofFlagsLen);
        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 from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = hasher(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }
}

interface IRouter {
    /**
     * @notice Swap exact ETH for tokens on Uniswap.
     * @param amountOutMin Minimum amount of token to receive.
     * @param path The path of the trade, with the first address being the input token (ETH) and the last one the output token (SANIC).
     * @param to The address to send the resulting tokens.
     * @param deadline The time by which the transaction must be confirmed.
     * @return amounts Array of amounts (input amount, intermediary amounts, and output amount).
     */
    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    /**
     * @notice Swap exact tokens for ETH on Uniswap.
     * @param amountIn Amount of token to swap.
     * @param amountOutMin Minimum amount of ETH to receive.
     * @param path The path of the trade, with the first address being the input token (SANIC) and the last one the output token (WETH).
     * @param to The address to send the resulting ETH.
     * @param deadline The time by which the transaction must be confirmed.
     * @return amounts Array of amounts (input amount, intermediary amounts, and output amount).
     */
    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    /**
     * @notice Retourne l'adresse du WETH (Wrapped ETH) sur la blockchain Base.
     * @return L'adresse de WETH.
     */
    function WETH() external view returns (address);
}


contract Sanic {
    using SafeERC20 for IERC20;

    uint256 public POINTS_TO_GENERATE_1MINER = 864000;
    uint256 PSN = 10000;
    uint256 PSNH = 5000;
    bool public initialized = false;

    IERC20 public SANIC;
    IRouter public ROUTER;
    bytes32 public merkleRoot;

    address public treasuryAddress;
    address public owner;

    mapping(address => uint256) public inkjetMiners;
    mapping(address => uint256) public claimedPoints;
    mapping(address => uint256) public lastInk;
    mapping(address => uint256) public lastWithdraw;
    mapping(address => address) public referrals;

    uint256 constant INK_STEP = 1 days;
    uint256 constant INK_STEP_MODIFIER = 0.1e18;
    uint256 constant BASE_PERCENTAGE = 0.5e18;

    uint256 public marketPoints;

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    constructor(address _treasuryAddress, bytes32 _merkleRoot) {
        owner = msg.sender;

        
        SANIC = IERC20(0x7B1B1BABE3eC9412D89DC2D8800cC4FD9291ec9e);
        ROUTER = IRouter(0x95a7e403d7cF20F675fF9273D66e94d35ba49fA3);

        treasuryAddress = _treasuryAddress;
        merkleRoot = _merkleRoot;
    }

    function compound(address ref) public {
        require(initialized, "Not initialized");
        if (ref == msg.sender) {
            ref = address(0);
        }
        if (
            referrals[msg.sender] == address(0) &&
            referrals[msg.sender] != msg.sender
        ) {
            referrals[msg.sender] = ref;
        }
        uint256 pointsUsed = getMyPoints();

        uint256 newMiners = pointsUsed / POINTS_TO_GENERATE_1MINER;
        inkjetMiners[msg.sender] += newMiners;
        claimedPoints[msg.sender] = 0;
        lastInk[msg.sender] = block.timestamp;

        
        claimedPoints[referrals[msg.sender]] += pointsUsed / 10;

        
        marketPoints += pointsUsed / 2;
    }

    function withdraw() external {
        require(initialized, "Not initialized");
        uint256 hasPoints = getMyPoints();

        require(hasPoints > 0, "No points to withdraw");
        uint256 pointValue = calculatePointSell(hasPoints);
        uint256 fee = devFee(pointValue);

        claimedPoints[msg.sender] = 0;
        lastInk[msg.sender] = block.timestamp;
        lastWithdraw[msg.sender] = block.timestamp;

        
        marketPoints += hasPoints;

        SANIC.safeTransfer(treasuryAddress, fee);
        SANIC.safeTransfer(msg.sender, pointValue - fee);
    }

    function depositS(uint minAmount, address ref) external payable {
    require(initialized, "Not initialized");
    require(msg.value > 0, "Invalid amount");

    uint amount = _swap(minAmount); 
    _deposit(amount, ref, false, false); 
}


    function depositSanic(uint amount, address ref) external {
    require(initialized, "Not initialized");
    require(amount > 0, "Invalid amount");

    SANIC.safeTransferFrom(msg.sender, address(this), amount);
    _deposit(amount, ref, false, true); 
}


    function depositSanicWithProof(
    uint amount,
    address ref,
    bytes32[] memory proof
    ) external {
    require(initialized, "Not initialized");
    require(amount > 0, "Invalid amount");

    bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
    require(MerkleProof.verify(proof, merkleRoot, leaf), "Invalid proof");

    SANIC.safeTransferFrom(msg.sender, address(this), amount);
    _deposit(amount, ref, true, true); // true → swapNeeded 
    }


    function _deposit(uint amount, address ref, bool holder, bool swapNeeded) internal {
    uint256 pointsBought = calculatePointBuy(amount, getBalance() - amount);

    if (holder) {
        pointsBought += (pointsBought * 2) / 100; 
    }

    pointsBought -= devFee(pointsBought);

    if (swapNeeded) {
        uint256 fee = devFee(amount); 

        SANIC.safeTransfer(treasuryAddress, fee);
    }

    claimedPoints[msg.sender] += pointsBought;
    compound(ref);
}




    function _swap(uint minTokenOut) internal returns (uint) {
    uint treasuryAmount = (msg.value * 5) / 100;  
    uint swapAmount = msg.value - treasuryAmount; 


    (bool success, ) = treasuryAddress.call{value: treasuryAmount}("");
    require(success, "ETH Transfer to treasury failed");

    uint initialBalance = getBalance();

    address[] memory path = new address[](2);
    path[0] = ROUTER.WETH();
    path[1] = address(SANIC);

    
    ROUTER.swapExactETHForTokens{value: swapAmount}(
        minTokenOut,
        path,
        address(this),
        block.timestamp
    );

    return getBalance() - initialBalance;
}


    function calculateTrade(
        uint256 rt,
        uint256 rs,
        uint256 bs
    ) public view returns (uint256) {
        return (PSN * bs) / (PSNH + ((PSN * rs + PSNH * rt) / rt));
    }

    function calculatePointSell(uint256 points) public view returns (uint256) {
        if (points == 0) return 0;
        return calculateTrade(points, marketPoints, getBalance());
    }

    function calculatePointBuy(
        uint256 eth,
        uint256 contractBalance
    ) public view returns (uint256) {
        return calculateTrade(eth, contractBalance, marketPoints);
    }

    function calculatePointBuySimple(uint256 eth) public view returns (uint256) {
        return calculatePointBuy(eth, getBalance());
    }

    function devFee(uint256 amount) public pure returns (uint256) {
        return (amount * 5) / 100;
    }

    function seedMarket() public payable onlyOwner {
        require(marketPoints == 0, "Market already seeded");
        initialized = true;
        marketPoints = 86400000000;
    }

    function getBalance() public view returns (uint256) {
        return SANIC.balanceOf(address(this));
    }

    function getMyMiners() public view returns (uint256) {
        return inkjetMiners[msg.sender];
    }

    function getMyPoints() public view returns (uint256) {
        return claimedPoints[msg.sender] + getPointsSinceLastInk(msg.sender);
    }

    function getPointsSinceLastInk(address adr) public view returns (uint256) {
        uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
            INK_STEP;

        uint256 percentage = min(
            1e18,
            BASE_PERCENTAGE + steps * INK_STEP_MODIFIER
        );

        uint256 secondsPassed = min(
            POINTS_TO_GENERATE_1MINER,
            block.timestamp - lastInk[adr]
        );
        return ((secondsPassed * inkjetMiners[adr]) * percentage) / 1e18;
    }

    function getHalvingPercentage() public view returns (uint256) {
        uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
            INK_STEP;

        return min(1e18, BASE_PERCENTAGE + steps * INK_STEP_MODIFIER);
    }

    function min(uint256 a, uint256 b) private pure returns (uint256) {
        return a < b ? a : b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"POINTS_TO_GENERATE_1MINER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROUTER","outputs":[{"internalType":"contract IRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SANIC","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"eth","type":"uint256"},{"internalType":"uint256","name":"contractBalance","type":"uint256"}],"name":"calculatePointBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"eth","type":"uint256"}],"name":"calculatePointBuySimple","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"points","type":"uint256"}],"name":"calculatePointSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rt","type":"uint256"},{"internalType":"uint256","name":"rs","type":"uint256"},{"internalType":"uint256","name":"bs","type":"uint256"}],"name":"calculateTrade","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimedPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"ref","type":"address"}],"name":"compound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"}],"name":"depositS","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"}],"name":"depositSanic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"depositSanicWithProof","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"devFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHalvingPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMyMiners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMyPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"getPointsSinceLastInk","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"inkjetMiners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastInk","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"referrals","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"seedMarket","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e7d9d1878e6f537eaf3c8a900f2e6bb7f955a4820000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _treasuryAddress (address): 0xE7d9D1878E6F537eaF3c8A900f2E6bb7f955A482
Arg [1] : _merkleRoot (bytes32): 0x0000000000000000000000000000000000000000000000000000000000000000

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e7d9d1878e6f537eaf3c8a900f2e6bb7f955a482
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000

51248:7074:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57187:103;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51661:48;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57071:108;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54361:479;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51413:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51716:42;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56013:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52488:736;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51507:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51479:21;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56766:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51305:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56880:183;;;:::i;:::-;;53232:598;;;;;;;;;;;;;:::i;:::-;;52013:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51765:47;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56416:196;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54092:259;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56620:138;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51578:20;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51819:44;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56222:186;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51607:47;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57298:140;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51541:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57967:239;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53838:244;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51453:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57446:513;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57187:103;57231:7;57258:12;:24;57271:10;57258:24;;;;;;;;;;;;;;;;57251:31;;57187:103;:::o;51661:48::-;;;;;;;;;;;;;;;;;:::o;57071:108::-;57114:7;57141:5;;;;;;;;;;;:15;;;57165:4;57141:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57134:37;;57071:108;:::o;54361:479::-;54488:11;;;;;;;;;;;54480:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;54543:1;54534:6;:10;54526:37;;;;;;;;;;;;:::i;:::-;;;;;;;;;54572:12;54614:10;54597:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;54587:39;;;;;;54572:54;;54641:43;54660:5;54667:10;;54679:4;54641:18;:43::i;:::-;54633:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;54711:57;54734:10;54754:4;54761:6;54711:5;;;;;;;;;;;:22;;;;:57;;;;;;:::i;:::-;54775:33;54784:6;54792:3;54797:4;54803;54775:8;:33::i;:::-;54473:367;54361:479;;;:::o;51413:31::-;;;;;;;;;;;;;:::o;51716:42::-;;;;;;;;;;;;;;;;;:::o;56013:201::-;56128:7;56202:2;56196;56189:4;;:9;;;;:::i;:::-;56184:2;56178:3;;:8;;;;:::i;:::-;:20;;;;:::i;:::-;56177:27;;;;:::i;:::-;56169:4;;:36;;;;:::i;:::-;56162:2;56156:3;;:8;;;;:::i;:::-;56155:51;;;;:::i;:::-;56148:58;;56013:201;;;;;:::o;52488:736::-;52545:11;;;;;;;;;;;52537:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;52598:10;52591:17;;:3;:17;;;52587:66;;52639:1;52625:16;;52587:66;52714:1;52681:35;;:9;:21;52691:10;52681:21;;;;;;;;;;;;;;;;;;;;;;;;;:35;;;:87;;;;;52758:10;52733:35;;:9;:21;52743:10;52733:21;;;;;;;;;;;;;;;;;;;;;;;;;:35;;;;52681:87;52663:171;;;52819:3;52795:9;:21;52805:10;52795:21;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;52663:171;52844:18;52865:13;:11;:13::i;:::-;52844:34;;52891:17;52924:25;;52911:10;:38;;;;:::i;:::-;52891:58;;52988:9;52960:12;:24;52973:10;52960:24;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;53036:1;53008:13;:25;53022:10;53008:25;;;;;;;;;;;;;;;:29;;;;53070:15;53048:7;:19;53056:10;53048:19;;;;;;;;;;;;;;;:37;;;;53161:2;53148:10;:15;;;;:::i;:::-;53108:13;:36;53122:9;:21;53132:10;53122:21;;;;;;;;;;;;;;;;;;;;;;;;;53108:36;;;;;;;;;;;;;;;;:55;;;;;;;:::i;:::-;;;;;;;;53215:1;53202:10;:14;;;;:::i;:::-;53186:12;;:30;;;;;;;:::i;:::-;;;;;;;;52526:698;;52488:736;:::o;51507:25::-;;;;:::o;51479:21::-;;;;;;;;;;;;;:::o;56766:106::-;56819:7;56861:3;56856:1;56847:6;:10;;;;:::i;:::-;56846:18;;;;:::i;:::-;56839:25;;56766:106;;;:::o;51305:49::-;;;;:::o;56880:183::-;52103:5;;;;;;;;;;;52089:19;;:10;:19;;;52081:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;56962:1:::1;56946:12;;:17;56938:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;57014:4;57000:11;;:18;;;;;;;;;;;;;;;;;;57044:11;57029:12;:26;;;;56880:183::o:0;53232:598::-;53280:11;;;;;;;;;;;53272:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;53322:17;53342:13;:11;:13::i;:::-;53322:33;;53388:1;53376:9;:13;53368:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;53426:18;53447:29;53466:9;53447:18;:29::i;:::-;53426:50;;53487:11;53501:18;53508:10;53501:6;:18::i;:::-;53487:32;;53560:1;53532:13;:25;53546:10;53532:25;;;;;;;;;;;;;;;:29;;;;53594:15;53572:7;:19;53580:10;53572:19;;;;;;;;;;;;;;;:37;;;;53647:15;53620:12;:24;53633:10;53620:24;;;;;;;;;;;;;;;:42;;;;53701:9;53685:12;;:25;;;;;;;:::i;:::-;;;;;;;;53723:40;53742:15;;;;;;;;;;;53759:3;53723:5;;;;;;;;;;;:18;;;;:40;;;;;:::i;:::-;53774:48;53793:10;53818:3;53805:10;:16;;;;:::i;:::-;53774:5;;;;;;;;;;;:18;;;;:48;;;;;:::i;:::-;53261:569;;;53232:598::o;52013:27::-;;;;:::o;51765:47::-;;;;;;;;;;;;;;;;;:::o;56416:196::-;56527:7;56554:50;56569:3;56574:15;56591:12;;56554:14;:50::i;:::-;56547:57;;56416:196;;;;:::o;54092:259::-;54164:11;;;;;;;;;;;54156:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;54219:1;54210:6;:10;54202:37;;;;;;;;;;;;:::i;:::-;;;;;;;;;54248:57;54271:10;54291:4;54298:6;54248:5;;;;;;;;;;;:22;;;;:57;;;;;;:::i;:::-;54312:34;54321:6;54329:3;54334:5;54341:4;54312:8;:34::i;:::-;54092:259;;:::o;56620:138::-;56687:7;56714:36;56732:3;56737:12;:10;:12::i;:::-;56714:17;:36::i;:::-;56707:43;;56620:138;;;:::o;51578:20::-;;;;;;;;;;;;;:::o;51819:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;56222:186::-;56287:7;56321:1;56311:6;:11;56307:25;;56331:1;56324:8;;;;56307:25;56350:50;56365:6;56373:12;;56387;:10;:12::i;:::-;56350:14;:50::i;:::-;56343:57;;56222:186;;;;:::o;51607:47::-;;;;;;;;;;;;;;;;;:::o;57298:140::-;57342:7;57397:33;57419:10;57397:21;:33::i;:::-;57369:13;:25;57383:10;57369:25;;;;;;;;;;;;;;;;:61;;;;:::i;:::-;57362:68;;57298:140;:::o;51541:30::-;;;;;;;;;;;;;:::o;57967:239::-;58020:7;58040:13;51900:6;58075:12;:24;58088:10;58075:24;;;;;;;;;;;;;;;;58057:15;:42;;;;:::i;:::-;58056:68;;;;:::i;:::-;58040:84;;58144:54;58148:4;51950:6;58172:5;:25;;;;:::i;:::-;51998:6;58154:43;;;;:::i;:::-;58144:3;:54::i;:::-;58137:61;;;57967:239;:::o;53838:244::-;53917:11;;;;;;;;;;;53909:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;53975:1;53963:9;:13;53955:40;;;;;;;;;;;;:::i;:::-;;;;;;;;;54004:11;54018:16;54024:9;54018:5;:16::i;:::-;54004:30;;54042:35;54051:6;54059:3;54064:5;54071;54042:8;:35::i;:::-;53902:180;53838:244;;:::o;51453:19::-;;;;;;;;;;;;;:::o;57446:513::-;57511:7;57531:13;51900:6;57566:12;:24;57579:10;57566:24;;;;;;;;;;;;;;;;57548:15;:42;;;;:::i;:::-;57547:68;;;;:::i;:::-;57531:84;;57628:18;57649:91;57667:4;51950:6;57704:5;:25;;;;:::i;:::-;51998:6;57686:43;;;;:::i;:::-;57649:3;:91::i;:::-;57628:112;;57753:21;57777:99;57795:25;;57853:7;:12;57861:3;57853:12;;;;;;;;;;;;;;;;57835:15;:30;;;;:::i;:::-;57777:3;:99::i;:::-;57753:123;;57947:4;57933:10;57912:12;:17;57925:3;57912:17;;;;;;;;;;;;;;;;57896:13;:33;;;;:::i;:::-;57895:48;;;;:::i;:::-;57894:57;;;;:::i;:::-;57887:64;;;;;57446:513;;;:::o;26624:156::-;26715:4;26768;26739:25;26752:5;26759:4;26739:12;:25::i;:::-;:33;26732:40;;26624:156;;;;;:::o;16091:190::-;16192:81;16212:5;16234;:18;;;16255:4;16261:2;16265:5;16219:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16192:19;:81::i;:::-;16091:190;;;;:::o;54850:485::-;54940:20;54963:48;54981:6;55004;54989:12;:10;:12::i;:::-;:21;;;;:::i;:::-;54963:17;:48::i;:::-;54940:71;;55024:6;55020:72;;;55080:3;55075:1;55060:12;:16;;;;:::i;:::-;55059:24;;;;:::i;:::-;55043:40;;;;;:::i;:::-;;;55020:72;55116:20;55123:12;55116:6;:20::i;:::-;55100:36;;;;;:::i;:::-;;;55149:10;55145:117;;;55172:11;55186:14;55193:6;55186;:14::i;:::-;55172:28;;55214:40;55233:15;;;;;;;;;;;55250:3;55214:5;;;;;;;;;;;:18;;;;:40;;;;;:::i;:::-;55161:101;55145:117;55299:12;55270:13;:25;55284:10;55270:25;;;;;;;;;;;;;;;;:41;;;;;;;:::i;:::-;;;;;;;;55318:13;55327:3;55318:8;:13::i;:::-;54933:402;54850:485;;;;:::o;15684:162::-;15767:71;15787:5;15809;:14;;;15826:2;15830:5;15794:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15767:19;:71::i;:::-;15684:162;;;:::o;58214:105::-;58271:7;58302:1;58298;:5;:13;;58310:1;58298:13;;;58306:1;58298:13;58291:20;;58214:105;;;;:::o;55349:654::-;55400:4;55413:19;55453:3;55448:1;55436:9;:13;;;;:::i;:::-;55435:21;;;;:::i;:::-;55413:43;;55465:15;55495:14;55483:9;:26;;;;:::i;:::-;55465:44;;55522:12;55540:15;;;;;;;;;;;:20;;55568:14;55540:47;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55521:66;;;55602:7;55594:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;55654:19;55676:12;:10;:12::i;:::-;55654:34;;55697:21;55735:1;55721:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55697:40;;55754:6;;;;;;;;;;;:11;;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55744:4;55749:1;55744:7;;;;;;;;:::i;:::-;;;;;;;:23;;;;;;;;;;;55792:5;;;;;;;;;;;55774:4;55779:1;55774:7;;;;;;;;:::i;:::-;;;;;;;:24;;;;;;;;;;;55813:6;;;;;;;;;;;:28;;;55849:10;55871:11;55893:4;55916;55932:15;55813:141;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;55985:14;55970:12;:10;:12::i;:::-;:29;;;;:::i;:::-;55963:36;;;;;;;55349:654;;;:::o;27191:314::-;27274:7;27294:20;27317:4;27294:27;;27337:9;27332:136;27356:5;:12;27352:1;:16;27332:136;;;27405:51;27433:12;27447:5;27453:1;27447:8;;;;;;;;:::i;:::-;;;;;;;;27405:27;:51::i;:::-;27390:66;;27370:3;;;;;;;27332:136;;;;27485:12;27478:19;;;27191:314;;;;:::o;22277:738::-;22358:18;22387:19;22527:4;22524:1;22517:4;22511:11;22504:4;22498;22494:15;22491:1;22484:5;22477;22472:60;22586:7;22576:180;;22631:4;22625:11;22677:16;22674:1;22669:3;22654:40;22724:16;22719:3;22712:29;22576:180;22784:16;22770:30;;22835:1;22829:8;22814:23;;22442:406;22878:1;22864:10;:15;:68;;22931:1;22916:11;:16;;22864:68;;;22912:1;22890:5;22882:26;;;:31;22864:68;22860:148;;;22989:5;22956:40;;;;;;;;;;;:::i;:::-;;;;;;;;22860:148;22347:668;;22277:738;;:::o;24408:171::-;24483:7;24514:1;24510;:5;:61;;24546:25;24566:1;24569;24546:19;:25::i;:::-;24510:61;;;24518:25;24538:1;24541;24518:19;:25::i;:::-;24510:61;24503:68;;24408:171;;;;:::o;24704:245::-;24777:13;24856:1;24850:4;24843:15;24885:1;24879:4;24872:15;24926:4;24920;24910:21;24901:30;;24704:245;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:75::-;475:6;508:2;502:9;492:19;;442:75;:::o;523:117::-;632:1;629;622:12;646:117;755:1;752;745:12;769:126;806:7;846:42;839:5;835:54;824:65;;769:126;;;:::o;901:96::-;938:7;967:24;985:5;967:24;:::i;:::-;956:35;;901:96;;;:::o;1003:122::-;1076:24;1094:5;1076:24;:::i;:::-;1069:5;1066:35;1056:63;;1115:1;1112;1105:12;1056:63;1003:122;:::o;1131:139::-;1177:5;1215:6;1202:20;1193:29;;1231:33;1258:5;1231:33;:::i;:::-;1131:139;;;;:::o;1276:329::-;1335:6;1384:2;1372:9;1363:7;1359:23;1355:32;1352:119;;;1390:79;;:::i;:::-;1352:119;1510:1;1535:53;1580:7;1571:6;1560:9;1556:22;1535:53;:::i;:::-;1525:63;;1481:117;1276:329;;;;:::o;1611:122::-;1684:24;1702:5;1684:24;:::i;:::-;1677:5;1674:35;1664:63;;1723:1;1720;1713:12;1664:63;1611:122;:::o;1739:139::-;1785:5;1823:6;1810:20;1801:29;;1839:33;1866:5;1839:33;:::i;:::-;1739:139;;;;:::o;1884:117::-;1993:1;1990;1983:12;2007:102;2048:6;2099:2;2095:7;2090:2;2083:5;2079:14;2075:28;2065:38;;2007:102;;;:::o;2115:180::-;2163:77;2160:1;2153:88;2260:4;2257:1;2250:15;2284:4;2281:1;2274:15;2301:281;2384:27;2406:4;2384:27;:::i;:::-;2376:6;2372:40;2514:6;2502:10;2499:22;2478:18;2466:10;2463:34;2460:62;2457:88;;;2525:18;;:::i;:::-;2457:88;2565:10;2561:2;2554:22;2344:238;2301:281;;:::o;2588:129::-;2622:6;2649:20;;:::i;:::-;2639:30;;2678:33;2706:4;2698:6;2678:33;:::i;:::-;2588:129;;;:::o;2723:311::-;2800:4;2890:18;2882:6;2879:30;2876:56;;;2912:18;;:::i;:::-;2876:56;2962:4;2954:6;2950:17;2942:25;;3022:4;3016;3012:15;3004:23;;2723:311;;;:::o;3040:117::-;3149:1;3146;3139:12;3163:77;3200:7;3229:5;3218:16;;3163:77;;;:::o;3246:122::-;3319:24;3337:5;3319:24;:::i;:::-;3312:5;3309:35;3299:63;;3358:1;3355;3348:12;3299:63;3246:122;:::o;3374:139::-;3420:5;3458:6;3445:20;3436:29;;3474:33;3501:5;3474:33;:::i;:::-;3374:139;;;;:::o;3536:710::-;3632:5;3657:81;3673:64;3730:6;3673:64;:::i;:::-;3657:81;:::i;:::-;3648:90;;3758:5;3787:6;3780:5;3773:21;3821:4;3814:5;3810:16;3803:23;;3874:4;3866:6;3862:17;3854:6;3850:30;3903:3;3895:6;3892:15;3889:122;;;3922:79;;:::i;:::-;3889:122;4037:6;4020:220;4054:6;4049:3;4046:15;4020:220;;;4129:3;4158:37;4191:3;4179:10;4158:37;:::i;:::-;4153:3;4146:50;4225:4;4220:3;4216:14;4209:21;;4096:144;4080:4;4075:3;4071:14;4064:21;;4020:220;;;4024:21;3638:608;;3536:710;;;;;:::o;4269:370::-;4340:5;4389:3;4382:4;4374:6;4370:17;4366:27;4356:122;;4397:79;;:::i;:::-;4356:122;4514:6;4501:20;4539:94;4629:3;4621:6;4614:4;4606:6;4602:17;4539:94;:::i;:::-;4530:103;;4346:293;4269:370;;;;:::o;4645:829::-;4747:6;4755;4763;4812:2;4800:9;4791:7;4787:23;4783:32;4780:119;;;4818:79;;:::i;:::-;4780:119;4938:1;4963:53;5008:7;4999:6;4988:9;4984:22;4963:53;:::i;:::-;4953:63;;4909:117;5065:2;5091:53;5136:7;5127:6;5116:9;5112:22;5091:53;:::i;:::-;5081:63;;5036:118;5221:2;5210:9;5206:18;5193:32;5252:18;5244:6;5241:30;5238:117;;;5274:79;;:::i;:::-;5238:117;5379:78;5449:7;5440:6;5429:9;5425:22;5379:78;:::i;:::-;5369:88;;5164:303;4645:829;;;;;:::o;5480:90::-;5514:7;5557:5;5550:13;5543:21;5532:32;;5480:90;;;:::o;5576:109::-;5657:21;5672:5;5657:21;:::i;:::-;5652:3;5645:34;5576:109;;:::o;5691:210::-;5778:4;5816:2;5805:9;5801:18;5793:26;;5829:65;5891:1;5880:9;5876:17;5867:6;5829:65;:::i;:::-;5691:210;;;;:::o;5907:619::-;5984:6;5992;6000;6049:2;6037:9;6028:7;6024:23;6020:32;6017:119;;;6055:79;;:::i;:::-;6017:119;6175:1;6200:53;6245:7;6236:6;6225:9;6221:22;6200:53;:::i;:::-;6190:63;;6146:117;6302:2;6328:53;6373:7;6364:6;6353:9;6349:22;6328:53;:::i;:::-;6318:63;;6273:118;6430:2;6456:53;6501:7;6492:6;6481:9;6477:22;6456:53;:::i;:::-;6446:63;;6401:118;5907:619;;;;;:::o;6532:118::-;6619:24;6637:5;6619:24;:::i;:::-;6614:3;6607:37;6532:118;;:::o;6656:222::-;6749:4;6787:2;6776:9;6772:18;6764:26;;6800:71;6868:1;6857:9;6853:17;6844:6;6800:71;:::i;:::-;6656:222;;;;:::o;6884:60::-;6912:3;6933:5;6926:12;;6884:60;;;:::o;6950:142::-;7000:9;7033:53;7051:34;7060:24;7078:5;7060:24;:::i;:::-;7051:34;:::i;:::-;7033:53;:::i;:::-;7020:66;;6950:142;;;:::o;7098:126::-;7148:9;7181:37;7212:5;7181:37;:::i;:::-;7168:50;;7098:126;;;:::o;7230:142::-;7296:9;7329:37;7360:5;7329:37;:::i;:::-;7316:50;;7230:142;;;:::o;7378:163::-;7481:53;7528:5;7481:53;:::i;:::-;7476:3;7469:66;7378:163;;:::o;7547:254::-;7656:4;7694:2;7683:9;7679:18;7671:26;;7707:87;7791:1;7780:9;7776:17;7767:6;7707:87;:::i;:::-;7547:254;;;;:::o;7807:329::-;7866:6;7915:2;7903:9;7894:7;7890:23;7886:32;7883:119;;;7921:79;;:::i;:::-;7883:119;8041:1;8066:53;8111:7;8102:6;8091:9;8087:22;8066:53;:::i;:::-;8056:63;;8012:117;7807:329;;;;:::o;8142:474::-;8210:6;8218;8267:2;8255:9;8246:7;8242:23;8238:32;8235:119;;;8273:79;;:::i;:::-;8235:119;8393:1;8418:53;8463:7;8454:6;8443:9;8439:22;8418:53;:::i;:::-;8408:63;;8364:117;8520:2;8546:53;8591:7;8582:6;8571:9;8567:22;8546:53;:::i;:::-;8536:63;;8491:118;8142:474;;;;;:::o;8622:::-;8690:6;8698;8747:2;8735:9;8726:7;8722:23;8718:32;8715:119;;;8753:79;;:::i;:::-;8715:119;8873:1;8898:53;8943:7;8934:6;8923:9;8919:22;8898:53;:::i;:::-;8888:63;;8844:117;9000:2;9026:53;9071:7;9062:6;9051:9;9047:22;9026:53;:::i;:::-;9016:63;;8971:118;8622:474;;;;;:::o;9102:118::-;9189:24;9207:5;9189:24;:::i;:::-;9184:3;9177:37;9102:118;;:::o;9226:222::-;9319:4;9357:2;9346:9;9342:18;9334:26;;9370:71;9438:1;9427:9;9423:17;9414:6;9370:71;:::i;:::-;9226:222;;;;:::o;9454:139::-;9517:9;9550:37;9581:5;9550:37;:::i;:::-;9537:50;;9454:139;;;:::o;9599:157::-;9699:50;9743:5;9699:50;:::i;:::-;9694:3;9687:63;9599:157;;:::o;9762:248::-;9868:4;9906:2;9895:9;9891:18;9883:26;;9919:84;10000:1;9989:9;9985:17;9976:6;9919:84;:::i;:::-;9762:248;;;;:::o;10016:143::-;10073:5;10104:6;10098:13;10089:22;;10120:33;10147:5;10120:33;:::i;:::-;10016:143;;;;:::o;10165:351::-;10235:6;10284:2;10272:9;10263:7;10259:23;10255:32;10252:119;;;10290:79;;:::i;:::-;10252:119;10410:1;10435:64;10491:7;10482:6;10471:9;10467:22;10435:64;:::i;:::-;10425:74;;10381:128;10165:351;;;;:::o;10522:169::-;10606:11;10640:6;10635:3;10628:19;10680:4;10675:3;10671:14;10656:29;;10522:169;;;;:::o;10697:165::-;10837:17;10833:1;10825:6;10821:14;10814:41;10697:165;:::o;10868:366::-;11010:3;11031:67;11095:2;11090:3;11031:67;:::i;:::-;11024:74;;11107:93;11196:3;11107:93;:::i;:::-;11225:2;11220:3;11216:12;11209:19;;10868:366;;;:::o;11240:419::-;11406:4;11444:2;11433:9;11429:18;11421:26;;11493:9;11487:4;11483:20;11479:1;11468:9;11464:17;11457:47;11521:131;11647:4;11521:131;:::i;:::-;11513:139;;11240:419;;;:::o;11665:164::-;11805:16;11801:1;11793:6;11789:14;11782:40;11665:164;:::o;11835:366::-;11977:3;11998:67;12062:2;12057:3;11998:67;:::i;:::-;11991:74;;12074:93;12163:3;12074:93;:::i;:::-;12192:2;12187:3;12183:12;12176:19;;11835:366;;;:::o;12207:419::-;12373:4;12411:2;12400:9;12396:18;12388:26;;12460:9;12454:4;12450:20;12446:1;12435:9;12431:17;12424:47;12488:131;12614:4;12488:131;:::i;:::-;12480:139;;12207:419;;;:::o;12632:94::-;12665:8;12713:5;12709:2;12705:14;12684:35;;12632:94;;;:::o;12732:::-;12771:7;12800:20;12814:5;12800:20;:::i;:::-;12789:31;;12732:94;;;:::o;12832:100::-;12871:7;12900:26;12920:5;12900:26;:::i;:::-;12889:37;;12832:100;;;:::o;12938:157::-;13043:45;13063:24;13081:5;13063:24;:::i;:::-;13043:45;:::i;:::-;13038:3;13031:58;12938:157;;:::o;13101:256::-;13213:3;13228:75;13299:3;13290:6;13228:75;:::i;:::-;13328:2;13323:3;13319:12;13312:19;;13348:3;13341:10;;13101:256;;;;:::o;13363:163::-;13503:15;13499:1;13491:6;13487:14;13480:39;13363:163;:::o;13532:366::-;13674:3;13695:67;13759:2;13754:3;13695:67;:::i;:::-;13688:74;;13771:93;13860:3;13771:93;:::i;:::-;13889:2;13884:3;13880:12;13873:19;;13532:366;;;:::o;13904:419::-;14070:4;14108:2;14097:9;14093:18;14085:26;;14157:9;14151:4;14147:20;14143:1;14132:9;14128:17;14121:47;14185:131;14311:4;14185:131;:::i;:::-;14177:139;;13904:419;;;:::o;14329:180::-;14377:77;14374:1;14367:88;14474:4;14471:1;14464:15;14498:4;14495:1;14488:15;14515:410;14555:7;14578:20;14596:1;14578:20;:::i;:::-;14573:25;;14612:20;14630:1;14612:20;:::i;:::-;14607:25;;14667:1;14664;14660:9;14689:30;14707:11;14689:30;:::i;:::-;14678:41;;14868:1;14859:7;14855:15;14852:1;14849:22;14829:1;14822:9;14802:83;14779:139;;14898:18;;:::i;:::-;14779:139;14563:362;14515:410;;;;:::o;14931:191::-;14971:3;14990:20;15008:1;14990:20;:::i;:::-;14985:25;;15024:20;15042:1;15024:20;:::i;:::-;15019:25;;15067:1;15064;15060:9;15053:16;;15088:3;15085:1;15082:10;15079:36;;;15095:18;;:::i;:::-;15079:36;14931:191;;;;:::o;15128:180::-;15176:77;15173:1;15166:88;15273:4;15270:1;15263:15;15297:4;15294:1;15287:15;15314:185;15354:1;15371:20;15389:1;15371:20;:::i;:::-;15366:25;;15405:20;15423:1;15405:20;:::i;:::-;15400:25;;15444:1;15434:35;;15449:18;;:::i;:::-;15434:35;15491:1;15488;15484:9;15479:14;;15314:185;;;;:::o;15505:159::-;15645:11;15641:1;15633:6;15629:14;15622:35;15505:159;:::o;15670:365::-;15812:3;15833:66;15897:1;15892:3;15833:66;:::i;:::-;15826:73;;15908:93;15997:3;15908:93;:::i;:::-;16026:2;16021:3;16017:12;16010:19;;15670:365;;;:::o;16041:419::-;16207:4;16245:2;16234:9;16230:18;16222:26;;16294:9;16288:4;16284:20;16280:1;16269:9;16265:17;16258:47;16322:131;16448:4;16322:131;:::i;:::-;16314:139;;16041:419;;;:::o;16466:171::-;16606:23;16602:1;16594:6;16590:14;16583:47;16466:171;:::o;16643:366::-;16785:3;16806:67;16870:2;16865:3;16806:67;:::i;:::-;16799:74;;16882:93;16971:3;16882:93;:::i;:::-;17000:2;16995:3;16991:12;16984:19;;16643:366;;;:::o;17015:419::-;17181:4;17219:2;17208:9;17204:18;17196:26;;17268:9;17262:4;17258:20;17254:1;17243:9;17239:17;17232:47;17296:131;17422:4;17296:131;:::i;:::-;17288:139;;17015:419;;;:::o;17440:171::-;17580:23;17576:1;17568:6;17564:14;17557:47;17440:171;:::o;17617:366::-;17759:3;17780:67;17844:2;17839:3;17780:67;:::i;:::-;17773:74;;17856:93;17945:3;17856:93;:::i;:::-;17974:2;17969:3;17965:12;17958:19;;17617:366;;;:::o;17989:419::-;18155:4;18193:2;18182:9;18178:18;18170:26;;18242:9;18236:4;18232:20;18228:1;18217:9;18213:17;18206:47;18270:131;18396:4;18270:131;:::i;:::-;18262:139;;17989:419;;;:::o;18414:194::-;18454:4;18474:20;18492:1;18474:20;:::i;:::-;18469:25;;18508:20;18526:1;18508:20;:::i;:::-;18503:25;;18552:1;18549;18545:9;18537:17;;18576:1;18570:4;18567:11;18564:37;;;18581:18;;:::i;:::-;18564:37;18414:194;;;;:::o;18614:442::-;18763:4;18801:2;18790:9;18786:18;18778:26;;18814:71;18882:1;18871:9;18867:17;18858:6;18814:71;:::i;:::-;18895:72;18963:2;18952:9;18948:18;18939:6;18895:72;:::i;:::-;18977;19045:2;19034:9;19030:18;19021:6;18977:72;:::i;:::-;18614:442;;;;;;:::o;19062:332::-;19183:4;19221:2;19210:9;19206:18;19198:26;;19234:71;19302:1;19291:9;19287:17;19278:6;19234:71;:::i;:::-;19315:72;19383:2;19372:9;19368:18;19359:6;19315:72;:::i;:::-;19062:332;;;;;:::o;19400:147::-;19501:11;19538:3;19523:18;;19400:147;;;;:::o;19553:114::-;;:::o;19673:398::-;19832:3;19853:83;19934:1;19929:3;19853:83;:::i;:::-;19846:90;;19945:93;20034:3;19945:93;:::i;:::-;20063:1;20058:3;20054:11;20047:18;;19673:398;;;:::o;20077:379::-;20261:3;20283:147;20426:3;20283:147;:::i;:::-;20276:154;;20447:3;20440:10;;20077:379;;;:::o;20462:181::-;20602:33;20598:1;20590:6;20586:14;20579:57;20462:181;:::o;20649:366::-;20791:3;20812:67;20876:2;20871:3;20812:67;:::i;:::-;20805:74;;20888:93;20977:3;20888:93;:::i;:::-;21006:2;21001:3;20997:12;20990:19;;20649:366;;;:::o;21021:419::-;21187:4;21225:2;21214:9;21210:18;21202:26;;21274:9;21268:4;21264:20;21260:1;21249:9;21245:17;21238:47;21302:131;21428:4;21302:131;:::i;:::-;21294:139;;21021:419;;;:::o;21446:143::-;21503:5;21534:6;21528:13;21519:22;;21550:33;21577:5;21550:33;:::i;:::-;21446:143;;;;:::o;21595:351::-;21665:6;21714:2;21702:9;21693:7;21689:23;21685:32;21682:119;;;21720:79;;:::i;:::-;21682:119;21840:1;21865:64;21921:7;21912:6;21901:9;21897:22;21865:64;:::i;:::-;21855:74;;21811:128;21595:351;;;;:::o;21952:180::-;22000:77;21997:1;21990:88;22097:4;22094:1;22087:15;22121:4;22118:1;22111:15;22138:114;22205:6;22239:5;22233:12;22223:22;;22138:114;;;:::o;22258:184::-;22357:11;22391:6;22386:3;22379:19;22431:4;22426:3;22422:14;22407:29;;22258:184;;;;:::o;22448:132::-;22515:4;22538:3;22530:11;;22568:4;22563:3;22559:14;22551:22;;22448:132;;;:::o;22586:108::-;22663:24;22681:5;22663:24;:::i;:::-;22658:3;22651:37;22586:108;;:::o;22700:179::-;22769:10;22790:46;22832:3;22824:6;22790:46;:::i;:::-;22868:4;22863:3;22859:14;22845:28;;22700:179;;;;:::o;22885:113::-;22955:4;22987;22982:3;22978:14;22970:22;;22885:113;;;:::o;23034:732::-;23153:3;23182:54;23230:5;23182:54;:::i;:::-;23252:86;23331:6;23326:3;23252:86;:::i;:::-;23245:93;;23362:56;23412:5;23362:56;:::i;:::-;23441:7;23472:1;23457:284;23482:6;23479:1;23476:13;23457:284;;;23558:6;23552:13;23585:63;23644:3;23629:13;23585:63;:::i;:::-;23578:70;;23671:60;23724:6;23671:60;:::i;:::-;23661:70;;23517:224;23504:1;23501;23497:9;23492:14;;23457:284;;;23461:14;23757:3;23750:10;;23158:608;;;23034:732;;;;:::o;23772:704::-;23999:4;24037:3;24026:9;24022:19;24014:27;;24051:71;24119:1;24108:9;24104:17;24095:6;24051:71;:::i;:::-;24169:9;24163:4;24159:20;24154:2;24143:9;24139:18;24132:48;24197:108;24300:4;24291:6;24197:108;:::i;:::-;24189:116;;24315:72;24383:2;24372:9;24368:18;24359:6;24315:72;:::i;:::-;24397;24465:2;24454:9;24450:18;24441:6;24397:72;:::i;:::-;23772:704;;;;;;;:::o;24482:311::-;24559:4;24649:18;24641:6;24638:30;24635:56;;;24671:18;;:::i;:::-;24635:56;24721:4;24713:6;24709:17;24701:25;;24781:4;24775;24771:15;24763:23;;24482:311;;;:::o;24816:732::-;24923:5;24948:81;24964:64;25021:6;24964:64;:::i;:::-;24948:81;:::i;:::-;24939:90;;25049:5;25078:6;25071:5;25064:21;25112:4;25105:5;25101:16;25094:23;;25165:4;25157:6;25153:17;25145:6;25141:30;25194:3;25186:6;25183:15;25180:122;;;25213:79;;:::i;:::-;25180:122;25328:6;25311:231;25345:6;25340:3;25337:15;25311:231;;;25420:3;25449:48;25493:3;25481:10;25449:48;:::i;:::-;25444:3;25437:61;25527:4;25522:3;25518:14;25511:21;;25387:155;25371:4;25366:3;25362:14;25355:21;;25311:231;;;25315:21;24929:619;;24816:732;;;;;:::o;25571:385::-;25653:5;25702:3;25695:4;25687:6;25683:17;25679:27;25669:122;;25710:79;;:::i;:::-;25669:122;25820:6;25814:13;25845:105;25946:3;25938:6;25931:4;25923:6;25919:17;25845:105;:::i;:::-;25836:114;;25659:297;25571:385;;;;:::o;25962:554::-;26057:6;26106:2;26094:9;26085:7;26081:23;26077:32;26074:119;;;26112:79;;:::i;:::-;26074:119;26253:1;26242:9;26238:17;26232:24;26283:18;26275:6;26272:30;26269:117;;;26305:79;;:::i;:::-;26269:117;26410:89;26491:7;26482:6;26471:9;26467:22;26410:89;:::i;:::-;26400:99;;26203:306;25962:554;;;;:::o

ipfs://bd6a30ebcb2287dfff6694a05e6d161600d25439a60dd8c73f9c5f1053afd9e6