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 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 ...
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
• interface IERC20Errors
• interface IERC721Errors
• interface IERC1155Errors
•    - function name()
•    - function symbol()
•    - function decimals()
•    - 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 ...
•    - function _transfer(address from, addr ...
•    - function _update(address from, addres ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _approve(address owner, addr ...
•    - function _spendAllowance(address owne ...
• interface IVoter
•    - function isBribeWhitelisted(address t ...
•    - function setWhitelistedBribe(address ...
•    - function bribe(uint256 pid, address r ...
•    - function _lastEpoch()
•    - function _epochLength()
•    - function _unlockTokens(address owner)
•  contract MemeToken is ERC20, Ownab ...
•    - function totalSupply()
•    - function mint( address account, uint2 ...
•    - function burn(uint256 amount)
•    - function maxSupply()
•    - function setVoter(IVoter _voter)
•    - function lockTokens(uint256 amount, a ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(address from, a ...
•    - function isLockExpired(address user)
• interface IOnlyMemesERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(
• interface IOnlyMemesPair is IOnlyMeme ...
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function kLast()
•    - function mint(address to)
•    - function burn(
•    - function swap(
•    - function skim(address to)
•    - function sync()
•    - function initialize(address, address)
•    - function setPID(uint256 pid)
•    - function setFeeAddresses(IVoter, addr ...
•  contract GhostChef is Ownable *
•    - function poolLength()
•    - function checkForDuplicate(IERC20 _lp ...
•    - function add(uint256 _allocPoint, IER ...
•    - function set(uint256 _pid, uint256 _a ...
•    - function getMultiplier(uint256 _from, ...
•    - function pendingOnly(uint256 _pid, ad ...
•    - function massUpdatePools()
•    - function updatePool(uint256 _pid)
•    - function deposit(uint256 _pid, uint25 ...
•    - function withdraw(uint256 _pid, uint2 ...
•    - function harvestAll()
•    - function emergencyWithdraw(uint256 _p ...
•    - function safeOnlyTransfer(address _to ...
•    - function getPID(address lp)
•    - function readPoolList()
•    - function getPoolInfo(uint256 pid)
•    - function setVoter(address voter)

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at SonicScan.org on 2025-01-25
*/

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





pragma solidity ^0.8.20;

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




pragma solidity ^0.8.20;



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



pragma solidity ^0.8.20;



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


pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}



pragma solidity ^0.8.20;


/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}





pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * 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;
        }
    }
}


pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}



pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}





pragma solidity ^0.8.4;

interface IVoter {
    function isBribeWhitelisted(address token) external view returns (bool);
    function setWhitelistedBribe(address token, bool status) external;
    function bribe(uint256 pid, address reward, uint256 amount) external;
    function _lastEpoch() external view returns (uint256);
    function _epochLength() external view returns(uint256);
    function _unlockTokens(address owner) external;
}


pragma solidity 0.8.27;





contract MemeToken is ERC20, Ownable {

    struct UserLocks{
        uint256 epoch;
        uint256 amount;
    }

    uint256 internal _totalSupply;
    uint256 internal _maxSupply;
    mapping (address => UserLocks) public locks;
    IVoter voter;

    constructor(uint256 initialSupply, uint256 maximumSupply)ERC20("Only Memes", "ONLY")Ownable(msg.sender){
        _totalSupply = initialSupply;
        _maxSupply = maximumSupply;
        _mint(msg.sender, initialSupply);
    }

     function totalSupply() public view override returns (uint256) {
        return _totalSupply - balanceOf(address(0));
    }

    function mint( address account, uint256 amount) external onlyOwner {
        
            uint256 _maxMint = _maxSupply - totalSupply();
     
          if (amount > _maxMint){ 
             amount = _maxMint; }
 
             _mint(account, amount);
             _totalSupply += amount;
    }

    function burn(uint256 amount) external {
        _totalSupply -= amount; 
        _burn(msg.sender, amount);
  
    }

    function maxSupply() external view returns (uint256) {
        return _maxSupply;
    }
    
    function setVoter(IVoter _voter) external onlyOwner{
        require(address(voter) == address(0)); 
        voter = _voter;  
 }
    function lockTokens(uint256 amount, address user) external {
        require (msg.sender == address(voter), "only Voter can lock");
        require (amount + locks[user].amount <= balanceOf(user), "Fully Locked");
        locks[user].amount += amount;
        locks[user].epoch = voter._lastEpoch();

 }

 function transfer(address to, uint256 value) public override returns (bool) {
        address owner = msg.sender;
        uint256 lockedAmount = locks[owner].amount;
    
    // Most common case first - no locks
    if (lockedAmount == 0) {
        _transfer(owner, to, value);
        return true;
    }
    
    // Check if lock expired and handle it
    if (isLockExpired(owner)) {
        // Unlock tokens if lock expired
        voter._unlockTokens(owner);
        // Reset locked amount since tokens are unlocked
        locks[owner].amount = 0; 
    }
    
    // Check transfer amount against available balance
    uint256 availableBalance = balanceOf(owner) - lockedAmount;
    require(value <= availableBalance, "Value exceeds unlocked balance");
    
    _transfer(owner, to, value);
    return true;

    }
  function transferFrom(address from, address to, uint256 value) public override returns (bool) {
    uint256 locked = locks[from].amount;
    
    if (locked > 0) {
        if (isLockExpired(from)) {
            voter._unlockTokens(from);
        } else {
            require(
                value <= balanceOf(from) - locked,
                "Value exceeds unlocked balance"
            );
        }
    }
    
    _spendAllowance(from, _msgSender(), value);
    _transfer(from, to, value);
    return true;
}

    function isLockExpired(address user) public view returns (bool) {
        if (locks[user].epoch < voter._lastEpoch()) {
            return true;
        }
        else return false;
    } 
 } 







pragma solidity ^0.8.4;

interface IOnlyMemesERC20 {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}




pragma solidity ^0.8.4;



interface IOnlyMemesPair is IOnlyMemesERC20 {
    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(
        address to
    ) external returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;

    function setPID(uint256 pid) external;
    function setFeeAddresses(IVoter, address, address) external;
}
 



pragma solidity ^0.8.20;  







// The OnlyMeme's MEMEChef is a fork of 0xDao Garden by 0xDaov1
// The biggest change made from SushiSwap is using per second instead of per block for rewards
// This is due to Sonic extremely fast block times
// The other biggest change was the removal of the migration functions
// It also has some view functions for Quality Of Life such as PoolId lookup and a query of all pool addresses.
// Note that it's ownable and the owner wields tremendous power. 
//
// Have fun reading it. Hopefully it's bug-free. 
contract GhostChef is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of Only
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accOnlyPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accOnlyPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. ONLYs to distribute per block.
        uint256 lastRewardTime;  // Last block time that ONLYs distribution occurs.
        uint256 accOnlyPerShare; // Accumulated Only per share, times 1e12. See below.

    }

    // such a cool token!
    MemeToken public only;
    address multiSig;
    // Only tokens created per second.
    uint256 public immutable OnlyPerSecond;
    uint256 public constant MaxAllocPoint = 4000;
    IVoter public Voter;
    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    mapping (address => uint256) public poolId;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block time when Only mining starts.
    uint256 public immutable startTime;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        MemeToken _only,
        uint256 _onlyPerSecond,
        uint256 _startTime,
        address _multiSig
    ) Ownable(msg.sender){
        only = _only;
        OnlyPerSecond = _onlyPerSecond;
        startTime = _startTime;
        multiSig = _multiSig;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    function checkForDuplicate(IERC20 _lpToken) internal view {
        uint256 length = poolInfo.length;
        for (uint256 _pid = 0; _pid < length; _pid++) {
            require(poolInfo[_pid].lpToken != _lpToken, "add: pool already exists!!!!");
        }

    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(uint256 _allocPoint, IERC20 _lpToken) external onlyOwner {
        require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");

        checkForDuplicate(_lpToken); // ensure you cant add duplicate pools

        massUpdatePools();

        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardTime: lastRewardTime,
            accOnlyPerShare: 0
        }));
        poolId[address(_lpToken)] = poolInfo.length - 1;
        IOnlyMemesPair(address (_lpToken)).setPID(poolId[address(_lpToken)]);
        address tokenA = IOnlyMemesPair(address (_lpToken)).token0();
        address tokenB = IOnlyMemesPair(address (_lpToken)).token1();
        
        if (!Voter.isBribeWhitelisted(tokenA)) {
            Voter.setWhitelistedBribe(tokenA, true);
        }
        if (!Voter.isBribeWhitelisted(tokenB)) { 
            Voter.setWhitelistedBribe(tokenB, true);
        }

    }

    // Update the given pool's Only allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint) external {
        require (address(Voter) == msg.sender , "only Voter can set");
        require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");


        massUpdatePools();

        totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
    }
    
    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        _from = _from > startTime ? _from : startTime;
        if (_to < startTime) {
            return 0;
        }
        return _to - _from;
    }

    // View function to see pending Onlys on frontend.
    function pendingOnly(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accOnlyPerShare = pool.accOnlyPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 OnlyReward = multiplier.mul(OnlyPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
            accOnlyPerShare = accOnlyPerShare.add(OnlyReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accOnlyPerShare).div(1e12).sub(user.rewardDebt);
        }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
     uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 OnlyReward = multiplier.mul(OnlyPerSecond).mul(pool.allocPoint).div(totalAllocPoint);

        
        only.mint(address(this), OnlyReward);

        pool.accOnlyPerShare = pool.accOnlyPerShare.add(OnlyReward.mul(1e12).div(lpSupply));
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens to MasterChef for Only allocation.
      function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);

        uint256 pending = user.amount.mul(pool.accOnlyPerShare).div(1e12).sub(user.rewardDebt);

        user.amount = user.amount.add(_amount);
        user.rewardDebt = user.amount.mul(pool.accOnlyPerShare).div(1e12);

        if(pending > 0) {
            safeOnlyTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);

        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public {  
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        require(user.amount >= _amount, "withdraw: not good");

        updatePool(_pid);

  

        uint256 pending = user.amount.mul(pool.accOnlyPerShare).div(1e12).sub(user.rewardDebt);

        user.amount = user.amount.sub(_amount);
        user.rewardDebt = user.amount.mul(pool.accOnlyPerShare).div(1e12);

        if(pending > 0) {
            safeOnlyTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransfer(address(msg.sender), _amount);
        
        emit Withdraw(msg.sender, _pid, _amount);
    }

    function harvestAll() public {
        uint256 length = poolInfo.length;
        uint calc;
        uint pending;
        UserInfo storage user;
        PoolInfo storage pool;
        uint totalPending;
        for (uint256 pid = 0; pid < length; ++pid) {
            user = userInfo[pid][msg.sender];
            if (user.amount > 0) {
                pool = poolInfo[pid];
                updatePool(pid);

                calc = user.amount.mul(pool.accOnlyPerShare).div(1e12);
                pending = calc.sub(user.rewardDebt);
                user.rewardDebt = calc;

                if(pending > 0) {
                    totalPending+=pending;
                }
            }
        }
        if (totalPending > 0) {
            safeOnlyTransfer(msg.sender, totalPending);
        }
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
     
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        uint oldUserAmount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        pool.lpToken.safeTransfer(address(msg.sender), oldUserAmount);
        emit EmergencyWithdraw(msg.sender, _pid, oldUserAmount);

    }

    // Safe Only transfer function, just in case if rounding error causes pool to not have enough ONLYs.
    function safeOnlyTransfer(address _to, uint256 _amount) internal {
        uint256 OnlyBal = only.balanceOf(address(this));
        if (_amount > OnlyBal) {
            only.transfer(_to, OnlyBal);
        } else {
            only.transfer(_to, _amount);
        }
    }
  
  
    function getPID(address lp) external view returns (uint256 pid){
        pid = poolId[lp]; 
    }
  
    function readPoolList() external view returns (IERC20[] memory ){
         uint256 length = poolInfo.length;
         IERC20 [] memory result = new IERC20 [](length);
           for (uint256 i = 0; i < length; ++i){
                result[i] = poolInfo[i].lpToken;               
           }
            return result;   
            }
    
     function getPoolInfo(uint256 pid) external view returns (IERC20 _lpToken, uint256 allocPoint, uint256 lastRewardTime, uint256 accOnlyPerShare) {
           _lpToken = poolInfo[pid].lpToken;
        allocPoint = poolInfo[pid].allocPoint;
        lastRewardTime = poolInfo[pid].lastRewardTime;
        accOnlyPerShare = poolInfo[pid].accOnlyPerShare;

        }
     function setVoter(address voter) external onlyOwner {
           require(address(Voter) == address(0));
        Voter = IVoter(voter); 
     }


    }

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract MemeToken","name":"_only","type":"address"},{"internalType":"uint256","name":"_onlyPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"address","name":"_multiSig","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MaxAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OnlyPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Voter","outputs":[{"internalType":"contract IVoter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"lp","type":"address"}],"name":"getPID","outputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"getPoolInfo","outputs":[{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accOnlyPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvestAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"only","outputs":[{"internalType":"contract MemeToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingOnly","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"poolId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accOnlyPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"readPoolList","outputs":[{"internalType":"contract IERC20[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"voter","type":"address"}],"name":"setVoter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000c29dbfcdb73eeee2579b768812642aa7296848e00000000000000000000000000000000000000000000000000957588590e500000000000000000000000000000000000000000000000000000000000678d9200000000000000000000000000db118f41289fdfa124b5da95012e621fff9a3441

-----Decoded View---------------
Arg [0] : _only (address): 0x0c29DBfCdb73eEEE2579b768812642AA7296848e
Arg [1] : _onlyPerSecond (uint256): 42069000000000000
Arg [2] : _startTime (uint256): 1737331200
Arg [3] : _multiSig (address): 0xDB118F41289fdFa124b5DA95012e621fff9A3441

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000c29dbfcdb73eeee2579b768812642aa7296848e
Arg [1] : 00000000000000000000000000000000000000000000000000957588590e5000
Arg [2] : 00000000000000000000000000000000000000000000000000000000678d9200
Arg [3] : 000000000000000000000000db118f41289fdfa124b5da95012e621fff9a3441

53419:11123:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56011:95;56083:8;:15;56011:95;;;160:25:1;;;148:2;133:18;56011:95:0;;;;;;;;55039:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;689:32:1;;;671:51;;753:2;738:18;;731:34;;;;781:18;;;774:34;839:2;824:18;;817:34;658:3;643:19;55039:26:0;427:430:1;55331:34:0;;;;;;57694:387;;;;;;:::i;:::-;;:::i;:::-;;56458:1140;;;;;;:::i;:::-;;:::i;64014:365::-;;;;;;:::i;:::-;;:::i;61104:722::-;;;;;;:::i;:::-;;:::i;64386:145::-;;;;;;:::i;:::-;;:::i;63658:343::-;;;:::i;:::-;;;;;;;:::i;59572:752::-;;;;;;:::i;:::-;;:::i;62727:416::-;;;;;;:::i;:::-;;:::i;58465:768::-;;;;;;:::i;:::-;;:::i;59316:180::-;;;:::i;20429:103::-;;;:::i;55420:34::-;;;;;19754:87;19800:7;19827:6;-1:-1:-1;;;;;19827:6:0;19754:87;;;-1:-1:-1;;;;;3209:32:1;;;3191:51;;3179:2;3164:18;19754:87:0;3045:203:1;58161:240:0;;;;;;:::i;:::-;;:::i;61834:822::-;;;:::i;55121:66::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3427:25:1;;;3483:2;3468:18;;3461:34;;;;3400:18;55121:66:0;3253:248:1;54799:21:0;;;;;-1:-1:-1;;;;;54799:21:0;;;63549:99;;;;;;:::i;:::-;-1:-1:-1;;;;;63629:10:0;63600:11;63629:10;;;:6;:10;;;;;;;63549:99;54890:38;;;;;60395:657;;;;;;:::i;:::-;;:::i;20687:220::-;;;;;;:::i;:::-;;:::i;54935:44::-;;54975:4;54935:44;;54986:19;;;;;-1:-1:-1;;;;;54986:19:0;;;55194:42;;;;;;:::i;:::-;;;;;;;;;;;;;;55039:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55039:26:0;;;;-1:-1:-1;55039:26:0;;;:::o;57694:387::-;57779:5;;-1:-1:-1;;;;;57779:5:0;57789:10;57771:28;57762:61;;;;-1:-1:-1;;;57762:61:0;;4157:2:1;57762:61:0;;;4139:21:1;4196:2;4176:18;;;4169:30;-1:-1:-1;;;4215:18:1;;;4208:48;4273:18;;57762:61:0;;;;;;;;;54975:4;57842:11;:28;;57834:69;;;;-1:-1:-1;;;57834:69:0;;4504:2:1;57834:69:0;;;4486:21:1;4543:2;4523:18;;;4516:30;4582;4562:18;;;4555:58;4630:18;;57834:69:0;4302:352:1;57834:69:0;57918:17;:15;:17::i;:::-;58012:11;57984:8;57993:4;57984:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;57966:15;;:43;;;;:::i;:::-;:57;;;;:::i;:::-;57948:15;:75;;;;58062:11;58034:8;58043:4;58034:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;57694:387;;:::o;56458:1140::-;19640:13;:11;:13::i;:::-;54975:4:::1;56547:11;:28;;56539:69;;;::::0;-1:-1:-1;;;56539:69:0;;4504:2:1;56539:69:0::1;::::0;::::1;4486:21:1::0;4543:2;4523:18;;;4516:30;4582;4562:18;;;4555:58;4630:18;;56539:69:0::1;4302:352:1::0;56539:69:0::1;56621:27;56639:8;56621:17;:27::i;:::-;56700:17;:15;:17::i;:::-;56730:22;56773:9;56755:15;:27;:57;;56803:9;56755:57;;;56785:15;56755:57;56841:15;::::0;56730:82;;-1:-1:-1;56841:32:0::1;::::0;56861:11;56841:19:::1;:32::i;:::-;56823:15;:50:::0;56898:169:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;56898:169:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;56898:169:0;;;;;;56884:8:::1;:184:::0;;::::1;::::0;;::::1;::::0;;;;;;;;;;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;56884:184:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;57107:15;:19:::1;::::0;56884:184;57107:19:::1;:::i;:::-;-1:-1:-1::0;;;;;57079:25:0;::::1;;::::0;;;:6:::1;:25;::::0;;;;;;:47;;;57137:68;-1:-1:-1;;;57137:68:0;;::::1;::::0;::::1;160:25:1::0;;;;57079::0;57137:41:::1;::::0;133:18:1;;57137:68:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57216:14;57257:8;-1:-1:-1::0;;;;;57233:41:0::1;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57216:60;;57287:14;57328:8;-1:-1:-1::0;;;;;57304:41:0::1;;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57373:5;::::0;:32:::1;::::0;-1:-1:-1;;;57373:32:0;;-1:-1:-1;;;;;3209:32:1;;;57373::0::1;::::0;::::1;3191:51:1::0;57287:60:0;;-1:-1:-1;57373:5:0;::::1;::::0;:24:::1;::::0;3164:18:1;;57373:32:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57368:105;;57422:5;::::0;:39:::1;::::0;-1:-1:-1;;;57422:39:0;;-1:-1:-1;;;;;5918:32:1;;;57422:39:0::1;::::0;::::1;5900:51:1::0;57422:5:0;5967:18:1;;;5960:50;57422:5:0;;::::1;::::0;:25:::1;::::0;5873:18:1;;57422:39:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57368:105;57488:5;::::0;:32:::1;::::0;-1:-1:-1;;;57488:32:0;;-1:-1:-1;;;;;3209:32:1;;;57488::0::1;::::0;::::1;3191:51:1::0;57488:5:0;;::::1;::::0;:24:::1;::::0;3164:18:1;;57488:32:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57483:106;;57538:5;::::0;:39:::1;::::0;-1:-1:-1;;;57538:39:0;;-1:-1:-1;;;;;5918:32:1;;;57538:39:0::1;::::0;::::1;5900:51:1::0;57538:5:0;5967:18:1;;;5960:50;57538:5:0;;::::1;::::0;:25:::1;::::0;5873:18:1;;57538:39:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57483:106;56528:1070;;;56458:1140:::0;;:::o;64014:365::-;64071:15;64088:18;64108:22;64132:23;64182:8;64191:3;64182:13;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:21;64227:13;;-1:-1:-1;;;;;64182:21:0;;;;-1:-1:-1;64236:3:0;;64227:13;;;;;;:::i;:::-;;;;;;;;;;;:24;;;64214:37;;64279:8;64288:3;64279:13;;;;;;;;:::i;:::-;;;;;;;;;;;:28;;;64262:45;;64336:8;64345:3;64336:13;;;;;;;;:::i;:::-;;;;;;;;;;;:29;;;64318:47;;64014:365;;;;;:::o;61104:722::-;61173:21;61197:8;61206:4;61197:14;;;;;;;;:::i;:::-;;;;;;;;;61246;;;:8;:14;;;;;;61261:10;61246:26;;;;;;;61293:11;;61197:14;;;;;;;;-1:-1:-1;61293:22:0;-1:-1:-1;61293:22:0;61285:53;;;;-1:-1:-1;;;61285:53:0;;6223:2:1;61285:53:0;;;6205:21:1;6262:2;6242:18;;;6235:30;-1:-1:-1;;;6281:18:1;;;6274:48;6339:18;;61285:53:0;6021:342:1;61285:53:0;61351:16;61362:4;61351:10;:16::i;:::-;61386:15;61404:68;61456:4;:15;;;61404:47;61446:4;61404:37;61420:4;:20;;;61404:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47::i;:::-;:51;;:68::i;:::-;61499:11;;61386:86;;-1:-1:-1;61499:24:0;;61515:7;61499:15;:24::i;:::-;61485:38;;;61568:20;;;;61552:47;;61594:4;;61552:37;;61485:38;61552:15;:37::i;:47::-;61534:15;;;:65;61615:11;;61612:80;;61643:37;61660:10;61672:7;61643:16;:37::i;:::-;61702:12;;:55;;-1:-1:-1;;;;;61702:12:0;61736:10;61749:7;61702:25;:55::i;:::-;61783:35;;160:25:1;;;61804:4:0;;61792:10;;61783:35;;148:2:1;133:18;61783:35:0;;;;;;;;61160:666;;;61104:722;;:::o;64386:145::-;19640:13;:11;:13::i;:::-;64468:5:::1;::::0;-1:-1:-1;;;;;64468:5:0::1;64460:28:::0;64452:37:::1;;;;;;64500:5;:21:::0;;-1:-1:-1;;;;;;64500:21:0::1;-1:-1:-1::0;;;;;64500:21:0;;;::::1;::::0;;;::::1;::::0;;64386:145::o;63658:343::-;63751:8;:15;63705;;63734:14;63751:15;63804:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63804:21:0;-1:-1:-1;63778:47:0;-1:-1:-1;63844:9:0;63839:116;63863:6;63859:1;:10;63839:116;;;63906:8;63915:1;63906:11;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:19;63894:9;;-1:-1:-1;;;;;63906:19:0;;;;63894:6;;63901:1;;63894:9;;;;;;:::i;:::-;-1:-1:-1;;;;;63894:31:0;;;:9;;;;;;;;;;;:31;63871:3;;63839:116;;;-1:-1:-1;63976:6:0;63658:343;-1:-1:-1;;63658:343:0:o;59572:752::-;59624:21;59648:8;59657:4;59648:14;;;;;;;;:::i;:::-;;;;;;;;;;;59624:38;;59696:4;:19;;;59677:15;:38;59673:77;;59732:7;59572:752;:::o;59673:77::-;59776:12;;:37;;-1:-1:-1;;;59776:37:0;;59807:4;59776:37;;;3191:51:1;59757:16:0;;-1:-1:-1;;;;;59776:12:0;;:22;;3164:18:1;;59776:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59757:56;;59828:8;59840:1;59828:13;59824:104;;-1:-1:-1;59880:15:0;59858:19;;;;:37;-1:-1:-1;59572:752:0:o;59824:104::-;59938:18;59959:51;59973:4;:19;;;59994:15;59959:13;:51::i;:::-;59938:72;;60021:18;60042:71;60097:15;;60042:50;60076:4;:15;;;60042:29;60057:13;60042:10;:14;;:29;;;;:::i;:::-;:33;;:50::i;:71::-;60136:4;;:36;;-1:-1:-1;;;60136:36:0;;60154:4;60136:36;;;6863:51:1;6930:18;;;6923:34;;;60021:92:0;;-1:-1:-1;;;;;;60136:4:0;;:9;;6836:18:1;;60136:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60208:60;60233:34;60258:8;60233:20;60248:4;60233:10;:14;;:20;;;;:::i;:34::-;60208:20;;;;;:24;:60::i;:::-;60185:20;;;:83;-1:-1:-1;;60301:15:0;60279:19;;;;:37;;;;-1:-1:-1;;59572:752:0:o;62727:416::-;62793:21;62817:8;62826:4;62817:14;;;;;;;;:::i;:::-;;;;;;;;;62866;;;:8;:14;;;;;;62881:10;62866:26;;;;;;;62926:11;;62948:15;;;-1:-1:-1;62974:15:0;;:19;;;;62817:14;;;;;63006:12;;62817:14;;-1:-1:-1;62866:26:0;;62926:11;63006:61;;-1:-1:-1;;;;;63006:12:0;;;;;62926:11;63006:25;:61::i;:::-;63083:50;;160:25:1;;;63113:4:0;;63101:10;;63083:50;;148:2:1;133:18;63083:50:0;;;;;;;62775:368;;;62727:416;:::o;58465:768::-;58538:7;58558:21;58582:8;58591:4;58582:14;;;;;;;;:::i;:::-;;;;;;;;;58631;;;:8;:14;;;;;;-1:-1:-1;;;;;58631:21:0;;;;;;;;;;58582:14;;;;;;;58689:20;;;;58739:12;;:37;;-1:-1:-1;;;58739:37:0;;58770:4;58739:37;;;3191:51:1;;;;58582:14:0;;-1:-1:-1;58631:21:0;;58689:20;;58582:14;;58739:12;;:22;;3164:18:1;;58739:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58720:56;;58809:4;:19;;;58791:15;:37;:54;;;;-1:-1:-1;58832:13:0;;;58791:54;58787:354;;;58862:18;58883:51;58897:4;:19;;;58918:15;58883:13;:51::i;:::-;58862:72;;58949:18;58970:71;59025:15;;58970:50;59004:4;:15;;;58970:29;58985:13;58970:10;:14;;:29;;;;:::i;:71::-;58949:92;-1:-1:-1;59074:55:0;59094:34;59119:8;59094:20;58949:92;59109:4;59094:14;:20::i;:34::-;59074:15;;:19;:55::i;:::-;59056:73;;58847:294;;58787:354;59158:63;59205:4;:15;;;59158:42;59195:4;59158:32;59174:15;59158:4;:11;;;:15;;:32;;;;:::i;:63::-;59151:70;;;;;;58465:768;;;;;:::o;59316:180::-;59378:8;:15;59361:14;59404:85;59432:6;59426:3;:12;59404:85;;;59462:15;59473:3;59462:10;:15::i;:::-;59440:5;;59404:85;;;;59350:146;59316:180::o;20429:103::-;19640:13;:11;:13::i;:::-;20494:30:::1;20521:1;20494:18;:30::i;:::-;20429:103::o:0;58161:240::-;58233:7;58269:9;58261:5;:17;:37;;58289:9;58261:37;;;58281:5;58261:37;58253:45;;58319:9;58313:3;:15;58309:56;;;-1:-1:-1;58352:1:0;58345:8;;58309:56;58382:11;58388:5;58382:3;:11;:::i;:::-;58375:18;58161:240;-1:-1:-1;;;58161:240:0:o;61834:822::-;61891:8;:15;61874:14;;;;;;62052:496;62080:6;62074:3;:12;62052:496;;;62117:13;;;;:8;:13;;;;;;;;62131:10;62117:25;;;;;;;62161:11;;62117:25;;-1:-1:-1;62161:15:0;62157:380;;62204:8;62213:3;62204:13;;;;;;;;:::i;:::-;;;;;;;;;;;62197:20;;62236:15;62247:3;62236:10;:15::i;:::-;62295:20;;;;62279:11;;:47;;62321:4;;62279:37;;:15;:37::i;:47::-;62272:54;;62355:25;62364:4;:15;;;62355:4;:8;;:25;;;;:::i;:::-;62399:15;;;:22;;;62345:35;-1:-1:-1;62445:11:0;;62442:80;;62481:21;62495:7;62481:21;;:::i;:::-;;;62442:80;62088:5;;62052:496;;;-1:-1:-1;62562:16:0;;62558:91;;62595:42;62612:10;62624:12;62595:16;:42::i;:::-;61863:793;;;;;;61834:822::o;60395:657::-;60461:21;60485:8;60494:4;60485:14;;;;;;;;:::i;:::-;;;;;;;;;60534;;;:8;:14;;;;;;60549:10;60534:26;;;;;;;60485:14;;;;;;;;-1:-1:-1;60573:16:0;60543:4;60573:10;:16::i;:::-;60602:15;60620:68;60672:4;:15;;;60620:47;60662:4;60620:37;60636:4;:20;;;60620:4;:11;;;:15;;:37;;;;:::i;:68::-;60715:11;;60602:86;;-1:-1:-1;60715:24:0;;60731:7;60715:15;:24::i;:::-;60701:38;;;60784:20;;;;60768:47;;60810:4;;60768:37;;60701:38;60768:15;:37::i;:47::-;60750:15;;;:65;60831:11;;60828:80;;60859:37;60876:10;60888:7;60859:16;:37::i;:::-;60918:12;;:74;;-1:-1:-1;;;;;60918:12:0;60956:10;60977:4;60984:7;60918:29;:74::i;:::-;61010:34;;160:25:1;;;61030:4:0;;61018:10;;61010:34;;148:2:1;133:18;61010:34:0;14:177:1;20687:220:0;19640:13;:11;:13::i;:::-;-1:-1:-1;;;;;20772:22:0;::::1;20768:93;;20818:31;::::0;-1:-1:-1;;;20818:31:0;;20846:1:::1;20818:31;::::0;::::1;3191:51:1::0;3164:18;;20818:31:0::1;3045:203:1::0;20768:93:0::1;20871:28;20890:8;20871:18;:28::i;:::-;20687:220:::0;:::o;19919:166::-;19800:7;19827:6;-1:-1:-1;;;;;19827:6:0;17968:10;19979:23;19975:103;;20026:40;;-1:-1:-1;;;20026:40:0;;17968:10;20026:40;;;3191:51:1;3164:18;;20026:40:0;3045:203:1;56114:269:0;56200:8;:15;56183:14;56226:148;56256:6;56249:4;:13;56226:148;;;56321:8;-1:-1:-1;;;;;56295:34:0;:8;56304:4;56295:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:22;-1:-1:-1;;;;;56295:22:0;:34;56287:75;;;;-1:-1:-1;;;56287:75:0;;7170:2:1;56287:75:0;;;7152:21:1;7209:2;7189:18;;;7182:30;7248;7228:18;;;7221:58;7296:18;;56287:75:0;6968:352:1;56287:75:0;56264:6;;56226:148;;;;56172:211;56114:269;:::o;23718:98::-;23776:7;23803:5;23807:1;23803;:5;:::i;24456:98::-;24514:7;24541:5;24545:1;24541;:5;:::i;24855:98::-;24913:7;24940:5;24944:1;24940;:5;:::i;24099:98::-;24157:7;24184:5;24188:1;24184;:5;:::i;63257:278::-;63351:4;;:29;;-1:-1:-1;;;63351:29:0;;63374:4;63351:29;;;3191:51:1;63333:15:0;;-1:-1:-1;;;;;63351:4:0;;:14;;3164:18:1;;63351:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63333:47;;63405:7;63395;:17;63391:137;;;63429:4;;:27;;-1:-1:-1;;;63429:27:0;;-1:-1:-1;;;;;6881:32:1;;;63429:27:0;;;6863:51:1;6930:18;;;6923:34;;;63429:4:0;;;;:13;;6836:18:1;;63429:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;56226:148;56172:211;56114:269;:::o;63391:137::-;63489:4;;:27;;-1:-1:-1;;;63489:27:0;;-1:-1:-1;;;;;6881:32:1;;;63489:27:0;;;6863:51:1;6930:18;;;6923:34;;;63489:4:0;;;;:13;;6836:18:1;;63489:27:0;6689:274:1;8978:162:0;9088:43;;-1:-1:-1;;;;;6881:32:1;;;9088:43:0;;;6863:51:1;6930:18;;;6923:34;;;9061:71:0;;9081:5;;9103:14;;;;;6836:18:1;;9088:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9088:43:0;;;;;;;;;;;9061:19;:71::i;21067:191::-;21141:16;21160:6;;-1:-1:-1;;;;;21177:17:0;;;-1:-1:-1;;;;;;21177:17:0;;;;;;21210:40;;21160:6;;;;;;;21210:40;;21141:16;21210:40;21130:128;21067:191;:::o;9385:190::-;9513:53;;-1:-1:-1;;;;;7940:32:1;;;9513:53:0;;;7922:51:1;8009:32;;;7989:18;;;7982:60;8058:18;;;8051:34;;;9486:81:0;;9506:5;;9528:18;;;;;7895::1;;9513:53:0;7720:371:1;15571:738:0;15652:18;15681:19;15821:4;15818:1;15811:4;15805:11;15798:4;15792;15788:15;15785:1;15778:5;15771;15766:60;15880:7;15870:180;;15925:4;15919:11;15971:16;15968:1;15963:3;15948:40;16018:16;16013:3;16006:29;15870:180;-1:-1:-1;;16129:1:0;16123:8;16078:16;;-1:-1:-1;16158:15:0;;:68;;16210:11;16225:1;16210:16;;16158:68;;;-1:-1:-1;;;;;16176:26:0;;;:31;16158:68;16154:148;;;16250:40;;-1:-1:-1;;;16250:40:0;;-1:-1:-1;;;;;3209:32:1;;16250:40:0;;;3191:51:1;3164:18;;16250:40:0;3045:203:1;196:226;255:6;308:2;296:9;287:7;283:23;279:32;276:52;;;324:1;321;314:12;276:52;-1:-1:-1;369:23:1;;196:226;-1:-1:-1;196:226:1:o;862:346::-;930:6;938;991:2;979:9;970:7;966:23;962:32;959:52;;;1007:1;1004;997:12;959:52;-1:-1:-1;;1052:23:1;;;1172:2;1157:18;;;1144:32;;-1:-1:-1;862:346:1:o;1213:139::-;-1:-1:-1;;;;;1296:31:1;;1286:42;;1276:70;;1342:1;1339;1332:12;1357:388;1438:6;1446;1499:2;1487:9;1478:7;1474:23;1470:32;1467:52;;;1515:1;1512;1505:12;1467:52;1560:23;;;-1:-1:-1;1659:2:1;1644:18;;1631:32;1672:41;1631:32;1672:41;:::i;:::-;1732:7;1722:17;;;1357:388;;;;;:::o;1750:255::-;1809:6;1862:2;1850:9;1841:7;1837:23;1833:32;1830:52;;;1878:1;1875;1868:12;1830:52;1917:9;1904:23;1936:39;1969:5;1936:39;:::i;2010:650::-;2213:2;2225:21;;;2295:13;;2198:18;;;2317:22;;;2165:4;;2396:15;;;2370:2;2355:18;;;2165:4;2439:195;2453:6;2450:1;2447:13;2439:195;;;2518:13;;-1:-1:-1;;;;;2514:39:1;2502:52;;2583:2;2609:15;;;;2574:12;;;;2550:1;2468:9;2439:195;;;-1:-1:-1;2651:3:1;;2010:650;-1:-1:-1;;;;;2010:650:1:o;4659:127::-;4720:10;4715:3;4711:20;4708:1;4701:31;4751:4;4748:1;4741:15;4775:4;4772:1;4765:15;4791:127;4852:10;4847:3;4843:20;4840:1;4833:31;4883:4;4880:1;4873:15;4907:4;4904:1;4897:15;4923:128;4990:9;;;5011:11;;;5008:37;;;5025:18;;:::i;5056:125::-;5121:9;;;5142:10;;;5139:36;;;5155:18;;:::i;5186:259::-;5256:6;5309:2;5297:9;5288:7;5284:23;5280:32;5277:52;;;5325:1;5322;5315:12;5277:52;5357:9;5351:16;5376:39;5409:5;5376:39;:::i;5450:277::-;5517:6;5570:2;5558:9;5549:7;5545:23;5541:32;5538:52;;;5586:1;5583;5576:12;5538:52;5618:9;5612:16;5671:5;5664:13;5657:21;5650:5;5647:32;5637:60;;5693:1;5690;5683:12;6368:127;6429:10;6424:3;6420:20;6417:1;6410:31;6460:4;6457:1;6450:15;6484:4;6481:1;6474:15;6500:184;6570:6;6623:2;6611:9;6602:7;6598:23;6594:32;6591:52;;;6639:1;6636;6629:12;6591:52;-1:-1:-1;6662:16:1;;6500:184;-1:-1:-1;6500:184:1:o;7325:168::-;7398:9;;;7429;;7446:15;;;7440:22;;7426:37;7416:71;;7467:18;;:::i;7498:217::-;7538:1;7564;7554:132;;7608:10;7603:3;7599:20;7596:1;7589:31;7643:4;7640:1;7633:15;7671:4;7668:1;7661:15;7554:132;-1:-1:-1;7700:9:1;;7498:217::o

ipfs://f57729ea781a7daebba0a4482007397f897483919a03bf8cf7285d6357a2fc1f