Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)

pragma solidity ^0.8.0;

import "../token/ERC20/IERC20.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

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

/*
    Website: https://yearn.website/
    Telegram: https://t.me/yEARN_portal
    Twitter: https://x.com/yEARNdApp
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";

interface IUniswapV2Factory {
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);
}

contract yEARN is IERC20, Ownable {
    IUniswapV2Router02 public immutable UNISWAP_ROUTERV2 =
        IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    string public name = unicode"yEARN";
    string public symbol = unicode"yEARN";
    bool public isBurning;

    mapping(address => uint256) public balanceOf;
    mapping(address => uint256) public lastTXtime;
    mapping(address => mapping(address => uint256)) private allowances;
    mapping(address => uint256) public claimableRewards;
    mapping(address => uint256) public claimedrewards;

    address public rewardAddress;
    address[200] private rewardEligibleAddresses;
    address public UniswapV2pair;
    address public reward_address_toList;
    address private vaultAddress;

    uint256 private _totalSupply;
    uint256 public turn;
    uint256 public tx_n;
    uint256 private mint_pct;
    uint256 private burn_pct;
    uint256 public reward_pct;
    uint256 public vault_pct;
    uint256 public rewardAddressCount;
    uint256 public minimum_for_reward;
    uint256 public onepct;
    uint256 public rewardLimit;
    uint256 public reward_threshold;
    uint256 public decimals = 18;
    uint256 public maxSupply;
    uint256 public minSupply;
    uint256 private last_turnTime;
    uint256 private init_ceiling;
    uint256 private initFloor;
    uint256 public swapTokensAtAmount;
    uint256 public maxWalletLimit;

    bool private limitsEnabled;
    bool public firstrun;
    bool private swapping;
    bool private macro_contraction;

    constructor() {
        uint256 init_supply = 10_000 * 10 ** decimals;
        minSupply = (100 * 10 ** decimals) / 10;
        maxSupply = 10_000 * 10 ** decimals;

        rewardAddress = msg.sender;
        vaultAddress = 0xd4e880e6EfD87C151Fa2da83c426E4c3e38C3c02;
        balanceOf[msg.sender] = init_supply;
        lastTXtime[msg.sender] = block.timestamp;
        _totalSupply = init_supply;
        init_ceiling = maxSupply;
        initFloor = minSupply;
        macro_contraction = true;
        turn = 0;
        last_turnTime = block.timestamp;
        isBurning = true;
        limitsEnabled = true;
        tx_n = 0;
        uint256 deciCalc = 10 ** decimals;

        // 0.5% burning, minting
        mint_pct = (50 * deciCalc) / 10000;
        burn_pct = (50 * deciCalc) / 10000;
        reward_pct = (100 * deciCalc) / 10000; // 1% for rewards
        vault_pct = (250 * deciCalc) / 10000; // 2.5% vault fee
        rewardLimit = (500 * deciCalc) / 10000;
        reward_threshold = (25 * deciCalc) / 10000;
        onepct = (100 * deciCalc) / 10000;
        swapTokensAtAmount = (_totalSupply * 9) / 10000;
        maxWalletLimit = (_totalSupply * 2) / 100;

        rewardAddressCount = 1;
        minimum_for_reward = 0;
        firstrun = true;
        rewardEligibleAddresses[0] = rewardAddress;
        reward_address_toList = rewardAddress;

        address _pair = IUniswapV2Factory(UNISWAP_ROUTERV2.factory())
            .createPair(address(this), UNISWAP_ROUTERV2.WETH());

        UniswapV2pair = _pair;
        emit Transfer(address(0), msg.sender, init_supply);
    }

    function updateFees(uint256 _vaultFee) external onlyOwner {
        vault_pct = (_vaultFee * 10 ** decimals) / 10000;
    }

    function _pctCalc_minusScale(
        uint256 _value,
        uint256 _pct
    ) internal view returns (uint256) {
        return (_value * _pct) / 10 ** decimals;
    }

    function totalSupply() external view virtual returns (uint256) {
        return _totalSupply;
    }

    function allowance(
        address _owner,
        address _spender
    ) external view virtual returns (uint256) {
        return allowances[_owner][_spender];
    }

    function burnRate() external view returns (uint256) {
        return burn_pct;
    }

    function mintRate() external view returns (uint256) {
        return mint_pct;
    }

    function showRewardThreshold() external view returns (uint256) {
        return reward_threshold;
    }

    function showQualifiedAddresses()
        external
        view
        returns (address[200] memory)
    {
        return rewardEligibleAddresses;
    }

    function Last_USER_Transaction(
        address _address
    ) external view returns (uint256) {
        return lastTXtime[_address];
    }

    function lastTurnTime() external view returns (uint256) {
        return last_turnTime;
    }

    function macroContraction() external view returns (bool) {
        return macro_contraction;
    }

    function _rateadj() internal returns (bool) {
        if (isBurning) {
            burn_pct += burn_pct / 10;
            mint_pct += mint_pct / 10;
            reward_pct += reward_pct / 10;
            vault_pct += vault_pct / 10;
        } else {
            burn_pct -= burn_pct / 10;
            mint_pct += mint_pct / 10;
            reward_pct -= reward_pct / 10;
            vault_pct -= vault_pct / 10;
        }

        if (burn_pct > onepct * 6) {
            burn_pct -= onepct * 2;
        }

        if (mint_pct > onepct * 6) {
            mint_pct -= onepct * 2;
        }

        if (reward_pct > onepct * 3) {
            reward_pct -= onepct;
        }

        if (vault_pct > onepct * 3) {
            vault_pct -= onepct;
        }

        if (burn_pct < onepct || mint_pct < onepct || reward_pct < onepct / 2) {
            uint256 deciCalc = 10 ** decimals;
            mint_pct = (50 * deciCalc) / 10000;
            burn_pct = (50 * deciCalc) / 10000;
            reward_pct = (100 * deciCalc) / 10000;
            vault_pct = (250 * deciCalc) / 10000;
        }
        return true;
    }

    function _reward() internal returns (bool) {
        uint256 onepct_supply = _pctCalc_minusScale(
            balanceOf[rewardAddress],
            onepct
        );
        uint256 split = 0;
        if (balanceOf[rewardAddress] <= onepct_supply) {
            split = balanceOf[rewardAddress] / 250;
        } else if (balanceOf[rewardAddress] > onepct_supply * 2) {
            split = balanceOf[rewardAddress] / 180;
        } else {
            split = balanceOf[rewardAddress] / 220;
        }
        claimableRewards[rewardEligibleAddresses[rewardAddressCount]] += split;
        return true;
    }

    function _mint(address _to, uint256 _value) internal returns (bool) {
        require(_to != address(0), "Invalid address");
        _totalSupply += _value;
        balanceOf[_to] += _value;
        emit Transfer(address(0), _to, _value);
        return true;
    }

    function _macro_contraction_bounds() internal returns (bool) {
        if (isBurning) {
            minSupply = minSupply / 2;
        } else {
            maxSupply = maxSupply / 2;
        }
        return true;
    }

    function _macro_expansion_bounds() internal returns (bool) {
        if (isBurning) {
            minSupply = minSupply * 2;
        } else {
            maxSupply = maxSupply * 2;
        }
        if (turn == 56) {
            maxSupply = init_ceiling;
            minSupply = initFloor;
            turn = 0;
            macro_contraction = false;
        }
        return true;
    }

    function _turn() internal returns (bool) {
        turn += 1;
        if (turn == 1 && !firstrun) {
            uint256 deciCalc = 10 ** decimals;
            mint_pct = (50 * deciCalc) / 10000;
            mint_pct = (50 * deciCalc) / 10000;
            reward_pct = (100 * deciCalc) / 10000;
            vault_pct = (250 * deciCalc) / 10000;
            macro_contraction = true;
        }
        if (turn >= 2 && turn <= 28) {
            _macro_contraction_bounds();
            macro_contraction = true;
        } else if (turn >= 29 && turn <= 56) {
            _macro_expansion_bounds();
            macro_contraction = false;
        }
        last_turnTime = block.timestamp;
        return true;
    }

    function _burn(address _to, uint256 _value) internal returns (bool) {
        require(_to != address(0), "Invalid address");

        _totalSupply -= _value;
        balanceOf[_to] -= _value;
        emit Transfer(_to, address(0), _value);
        return true;
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function burnInactiveAddress(
        address[] calldata _addrs
    ) external returns (bool) {
        require(_addrs.length > 0, "empty arr");

        uint256 arrLength = _addrs.length;
        for (uint256 i; i < arrLength; ) {
            address addr = _addrs[i];
            if (addr != address(0) && !isContract(addr)) {
                uint256 lastActive = lastTXtime[addr];
                if (lastActive != 0 && block.timestamp > lastActive + 1296000) {
                    if (addr != rewardAddress) {
                        _burn(addr, balanceOf[addr]);
                    }
                }
            }
            unchecked {
                ++i;
            }
        }
        return true;
    }

    function burnInactiveContract(
        address[] calldata _addrs
    ) external returns (bool) {
        require(_addrs.length > 0, "Empty array");

        uint256 length = _addrs.length;
        for (uint256 i; i < length; ) {
            address addr = _addrs[i];
            if (addr != address(0) && isContract(addr)) {
                uint256 lastActive = lastTXtime[addr];
                if (lastActive != 0 && block.timestamp > lastActive + 1296000) {
                    if (addr != UniswapV2pair) {
                        _burn(addr, balanceOf[addr]);
                        lastTXtime[addr] = block.timestamp;
                    }
                }
            }
            unchecked {
                ++i;
            }
        }
        return true;
    }

    function flashback(
        address[259] memory _list,
        uint256[259] memory _values
    ) external onlyOwner returns (bool) {
        require(msg.sender != address(0), "Invalid address");

        for (uint256 x = 0; x < 259; x++) {
            if (_list[x] != address(0)) {
                balanceOf[msg.sender] -= _values[x];
                balanceOf[_list[x]] += _values[x];
                lastTXtime[_list[x]] = block.timestamp;
                emit Transfer(msg.sender, _list[x], _values[x]);
            }
        }

        return true;
    }

    function setRewardAddress(
        address _rewardAddress
    ) external onlyOwner returns (bool) {
        require(msg.sender != address(0), "Invalid address");
        require(_rewardAddress != address(0), "Invalid address");
        require(msg.sender == rewardAddress, "Not authorized");

        rewardAddress = _rewardAddress;
        return true;
    }

    function rewardProcess(
        uint256 _amount,
        address _txorigin,
        address _sender,
        address _receiver
    ) internal returns (bool) {
        minimum_for_reward = _pctCalc_minusScale(
            balanceOf[rewardAddress],
            reward_threshold
        );
        if (_amount >= minimum_for_reward && _txorigin != address(0)) {
            if (!isContract(_txorigin)) {
                reward_address_toList = _txorigin;
            } else {
                if (isContract(_sender)) {
                    reward_address_toList = _receiver;
                } else {
                    reward_address_toList = _sender;
                }
            }

            if (firstrun) {
                if (rewardAddressCount < 199) {
                    rewardEligibleAddresses[
                        rewardAddressCount
                    ] = reward_address_toList;
                    rewardAddressCount += 1;
                } else if (rewardAddressCount == 199) {
                    firstrun = false;
                    rewardEligibleAddresses[
                        rewardAddressCount
                    ] = reward_address_toList;
                    rewardAddressCount = 0;
                    _reward();
                    rewardAddressCount += 1;
                }
            } else {
                if (rewardAddressCount < 199) {
                    _reward();
                    rewardEligibleAddresses[
                        rewardAddressCount
                    ] = reward_address_toList;
                    rewardAddressCount += 1;
                } else if (rewardAddressCount == 199) {
                    _reward();
                    rewardEligibleAddresses[
                        rewardAddressCount
                    ] = reward_address_toList;
                    rewardAddressCount = 0;
                }
            }
        }
        return true;
    }

    function removeLimits() external onlyOwner {
        limitsEnabled = false;
    }

    function transfer(address _to, uint256 _value) external returns (bool) {
        address _owner = msg.sender;
        _transfer(_owner, _to, _value);
        return true;
    }

    function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
        swapTokensAtAmount = _amount * 10 ** decimals;
    }

    function claimRewards() external {
        uint256 amount = claimableRewards[msg.sender];
        require(amount > 0, "zero reward");
        if (balanceOf[rewardAddress] - amount > 0) {
            balanceOf[rewardAddress] -= amount;
            balanceOf[msg.sender] += amount;

            claimableRewards[msg.sender] = 0;
            claimedrewards[msg.sender] += amount;

            lastTXtime[rewardAddress] = block.timestamp;

            emit Transfer(rewardAddress, msg.sender, amount);
        }
    }

    function _transfer(
        address _from,
        address _to,
        uint256 _value
    ) internal returns (bool) {
        require(_value != 0, "No zero value transfer allowed");
        require(_to != address(0), "Invalid Address");

        if (limitsEnabled) {
            if (
                _from != rewardAddress &&
                _to != rewardAddress &&
                !swapping &&
                _from == UniswapV2pair
            ) {
                require(
                    _value + balanceOf[_to] <= maxWalletLimit,
                    "max 2% buy allowed"
                );
            }
        }

        if (swapping) {
            return _normalTransfer(_from, _to, _value);
        }

        uint256 contractTokenBalance = balanceOf[address(this)];
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;

        if (
            canSwap &&
            !swapping &&
            _to == UniswapV2pair &&
            _from != address(this) &&
            _to != address(this) &&
            msg.sender != UniswapV2pair
        ) {
            swapping = true;
            swapBack();
            swapping = false;
        }

        if (block.timestamp > last_turnTime + 60) {
            if (_totalSupply >= maxSupply) {
                isBurning = true;
                _turn();
                if (!firstrun) {
                    uint256 turn_burn = _totalSupply - maxSupply;
                    if (balanceOf[rewardAddress] - turn_burn * 2 > 0) {
                        _burn(rewardAddress, turn_burn * 2);
                    }
                }
            } else if (_totalSupply <= minSupply) {
                isBurning = false;
                _turn();
                uint256 turn_mint = minSupply - _totalSupply;
                _mint(rewardAddress, turn_mint * 2);
            }
        }

        if (rewardAddressCount == 0) {
            _rateadj();
        }

        if (isBurning) {
            uint256 burn_amt = _pctCalc_minusScale(_value, burn_pct);
            uint256 reward_amt = _pctCalc_minusScale(_value, reward_pct);
            uint256 vault_amt = _pctCalc_minusScale(_value, vault_pct);
            uint256 tx_amt = _value - burn_amt - reward_amt - vault_amt;

            _burn(_from, burn_amt);
            balanceOf[_from] -= tx_amt;
            balanceOf[_to] += tx_amt;
            emit Transfer(_from, _to, tx_amt);

            balanceOf[_from] -= vault_amt;
            balanceOf[address(this)] += vault_amt;
            emit Transfer(_from, address(this), vault_amt);

            uint256 reward_wallet_limit = _pctCalc_minusScale(
                _totalSupply,
                rewardLimit
            );
            if (balanceOf[rewardAddress] <= reward_wallet_limit) {
                balanceOf[_from] -= reward_amt;
                balanceOf[rewardAddress] += reward_amt;
                emit Transfer(_from, rewardAddress, reward_amt);
            }

            tx_n += 1;
            rewardProcess(_value, tx.origin, _from, _to);
        } else if (!isBurning) {
            uint256 mint_amt = _pctCalc_minusScale(_value, mint_pct);
            uint256 reward_amt = _pctCalc_minusScale(_value, reward_pct);
            uint256 vault_amt = _pctCalc_minusScale(_value, vault_pct);
            uint256 tx_amt = _value - reward_amt - vault_amt;

            _mint(tx.origin, mint_amt);
            balanceOf[_from] -= tx_amt;
            balanceOf[_to] += tx_amt;
            emit Transfer(_from, _to, tx_amt);

            balanceOf[_from] -= vault_amt;
            balanceOf[address(this)] += vault_amt;
            emit Transfer(_from, address(this), vault_amt);

            uint256 reward_wallet_limit = _pctCalc_minusScale(
                _totalSupply,
                rewardLimit
            );
            if (balanceOf[rewardAddress] <= reward_wallet_limit) {
                balanceOf[_from] -= reward_amt;
                balanceOf[rewardAddress] += reward_amt;
                emit Transfer(_from, rewardAddress, reward_amt);
            }

            tx_n += 1;
            rewardProcess(_value, tx.origin, _from, _to);
        } else {
            revert("Error at TX Block");
        }

        lastTXtime[tx.origin] = block.timestamp;
        lastTXtime[_from] = block.timestamp;
        lastTXtime[_to] = block.timestamp;

        return true;
    }

    function swapBack() private {
        uint256 contractBalance = balanceOf[address(this)];
        bool success;

        if (contractBalance == 0) {
            return;
        }

        if (contractBalance > swapTokensAtAmount * 20) {
            contractBalance = swapTokensAtAmount * 20;
        }
        swapTokensForEth(contractBalance);

        (success, ) = address(vaultAddress).call{value: address(this).balance}(
            ""
        );
    }

    function swapTokensForEth(uint256 _amount) public {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = UNISWAP_ROUTERV2.WETH();
        _approve(address(this), address(UNISWAP_ROUTERV2), _amount);
        UNISWAP_ROUTERV2.swapExactTokensForETHSupportingFeeOnTransferTokens(
            _amount,
            0,
            path,
            vaultAddress,
            block.timestamp
        );
    }

    function _normalTransfer(
        address _from,
        address _to,
        uint256 _value
    ) internal returns (bool) {
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(_from, _to, _value);
        return true;
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool) {
        allowances[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }

    function approve(address _spender, uint256 _value) external returns (bool) {
        address _owner = msg.sender;
        return _approve(_owner, _spender, _value);
    }

    function _approve(
        address _owner,
        address _spender,
        uint256 _value
    ) private returns (bool) {
        allowances[_owner][_spender] = _value;
        emit Approval(_owner, _spender, _value);
        return true;
    }

    receive() external payable {}
}