Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

/**
 * FlowAI - Voice Operating System for AI Automations                                                                                                                                                                                                                                     ........................
 * 
 * 
 * Official Links:
 * Telegram: https://t.me/FlowAI_Entry_Portal
 * Twitter: https://x.com/UseFlowAI  
 * Website: https://useflowai.app/
 * Documentation: https://docs.useflowai.app
 * 
 * FlowAI inaugurates a new era of human–machine collaboration.
 * Where assistants merely answer, FlowAI works. Where interfaces demand effort, FlowAI listens.
 * 
 * This is more than automation, more than conversation. It is collaboration redefined.
 * By making the voice the operating system of work, FlowAI dissolves friction and 
 * allows execution to flow at the speed of thought.
 */

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

/**
 * @title FlowAI Token
 * @notice A reflection token with fee-on-transfer mechanics and automated tax collection
 */
contract FlowAI is IERC20Metadata, Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using Address for address;

    // Token metadata
    string private constant _name = "FlowAI";
    string private constant _symbol = "FLW";
    uint8 private constant _decimals = 9;
    uint256 private constant _tTotal = 100_000_000 * 10**_decimals;

    // Balances (simplified - standard ERC20)
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    // Fee exclusions
    mapping(address => bool) private _isExcludedFromFee;

    // Fee structure
    uint256 public _taxFeeOnBuy = 40; // 40%
    uint256 public _taxFeeOnSell = 40;  // 40%
    
    // Tax lock mechanism - fees cannot exceed these values once set
    uint256 public maxAllowedBuyFee = MAX_TAX_FEE;  // Initially 40%
    uint256 public maxAllowedSellFee = MAX_TAX_FEE; // Initially 40%

    // Limits
    uint256 public _maxTxAmount = 200_000 * 10**_decimals; // 200,000 tokens (0.2% of total supply)
    uint256 public _maxWalletSize = 200_000 * 10**_decimals; // 200,000 tokens (0.2% of total supply)
    uint256 public _swapTokensAtAmount = 25_000 * 10**_decimals; // 25,000 tokens = (0.025% of total supply)

    // AMM integration
    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable mainAMMPair;

    // Trading and swap control
    bool public tradingActive = false;
    bool public swapEnabled = true;
    bool private inSwap = false;
    
    // Tax receiver
    address public taxReceiver;
    
    // Trading enabler (can activate trading once, then gets reset)
    address public tradingEnabler;
    
    // Launchpad support
    mapping(address => bool) public isExcludedFromLimits;
    bool public limitsActive = true;

    // Events
    event FeesUpdated(uint256 taxBuy, uint256 taxSell);
    event TaxLockUpdated(uint256 maxBuyFee, uint256 maxSellFee);
    event TradingActivated(bool enabled);
    event SwapToggled(bool enabled);
    event SwapThresholdUpdated(uint256 threshold);
    event MaxTxUpdated(uint256 maxTx);
    event MaxWalletUpdated(uint256 maxWallet);
    event LimitsToggled(bool enabled);

    event ManualSwap(uint256 tokens);
    event ManualSend(uint256 amount);
    event FeeExemptionUpdated(address[] accounts, bool excluded);
    event LimitExemptionUpdated(address[] accounts, bool excluded);
    event TaxReceiverUpdated(address oldReceiver, address newReceiver);
    event AutoSwapExecuted(uint256 tokensSwapped, uint256 ethReceived);
    event TaxCollected(address from, address to, uint256 taxAmount);
    event TokensRescued(address indexed tokenAddress, address indexed recipient, uint256 amount);

    // Constants
    uint256 private constant PERCENTAGE_BASE = 100;
    uint256 private constant MAX_TAX_FEE = 40; // 40% to avoid bots
    uint256 private constant MIN_LIMIT_PERCENTAGE = 100; // 0.1% of total supply (basis: 100000)
    
    // Custom errors
    error TradingNotActive();
    error ExceedsMaxTx();
    error ExceedsMaxWallet();
    error InvalidFeeRange();
    error ExceedsTaxLock();
    error InsufficientBalance();
    error InvalidAddress();
    error InvalidAmount();
    error ExceedsReasonableThreshold();
    error BelowMinimumThreshold();
    error SwapFailed();
    error TransferFailed();
    error ContractNotAllowed();

    modifier lockTheSwap {
        inSwap = true;
        _;
        inSwap = false;
    }

    /**
     * @notice Constructor initializes the FlowAI token
     * @dev Mints total supply to deployer, sets initial exclusions, and creates AMM pair for immediate DEX visibility
     * @param routerAddress Address of the AMM router (e.g., Uniswap V2 Router)
     * @param initialTaxReceiver Address that will receive tax fees (can be different from owner)
     * @param _tradingEnabler Address that can activate trading (along with owner)
     */
    constructor(address routerAddress, address initialTaxReceiver, address _tradingEnabler) Ownable(msg.sender) {
        if (routerAddress == address(0)) revert InvalidAddress();
        if (initialTaxReceiver == address(0)) revert InvalidAddress();
        if (_tradingEnabler == address(0)) revert InvalidAddress();
        
        // Ensure initial tax receiver is EOA, not a contract
        if (initialTaxReceiver.code.length > 0) revert ContractNotAllowed();
        
        // Initialize AMM Router
        uniswapV2Router = IUniswapV2Router02(routerAddress);
        
        // Set initial tax receiver and trading enabler
        taxReceiver = initialTaxReceiver;
        tradingEnabler = _tradingEnabler;
        
        // Mint total supply to deployer (msg.sender)
        _balances[msg.sender] = _tTotal;
        emit Transfer(address(0), msg.sender, _tTotal);
        
        // Exclude key addresses from fees and limits
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;
        isExcludedFromLimits[owner()] = true;
        isExcludedFromLimits[address(this)] = true;
        isExcludedFromLimits[initialTaxReceiver] = true;
        
        // Exclude router from limits to allow liquidity additions
        isExcludedFromLimits[address(uniswapV2Router)] = true;

        address factory = uniswapV2Router.factory();
        address weth = uniswapV2Router.WETH();
        
        address pairAddress = IUniswapV2Factory(factory).getPair(address(this), weth);
        if (pairAddress == address(0)) {
            pairAddress = IUniswapV2Factory(factory).createPair(address(this), weth);
        }
        
        mainAMMPair = pairAddress;
    }

    // ERC20 Interface Implementation
    function name() public pure override returns (string memory) {
        return _name;
    }

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

    function decimals() public pure override 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 to, uint256 amount) public override returns (bool) {
        address owner = msg.sender;
        _transfer(owner, to, 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) {
        address owner = msg.sender;
        _approve(owner, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
        address spender = msg.sender;
        uint256 currentAllowance = allowance(from, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < amount) revert InsufficientBalance();
        }
        
        _transfer(from, to, amount);
        
        if (currentAllowance != type(uint256).max) {
            unchecked {
                _approve(from, spender, currentAllowance - amount);
            }
        }
        return true;
    }

    // Simplified fee calculation
    function _calculateTax(uint256 amount, uint256 taxRate) private pure returns (uint256) {
        return (amount * taxRate) / PERCENTAGE_BASE;
    }

    /**
     * @dev Determines if contract should perform automatic token swap
     * @param contractBalance Current token balance of contract
     * @param from Transfer sender address
     * @param to Transfer recipient address
     * @return bool Whether swap should occur (only when trading is active and liquidity exists)
     */
    function _shouldSwap(uint256 contractBalance, address from, address to) private view returns (bool) {
        return contractBalance >= _swapTokensAtAmount &&
               !inSwap &&
               from != mainAMMPair &&
               swapEnabled &&
               tradingActive &&  // Only swap when trading is active
               !_isExcludedFromFee[from] &&
               !_isExcludedFromFee[to];
    }

    /**
     * @dev Determines the appropriate tax fee based on transaction type
     * @param sender Transfer sender address
     * @param recipient Transfer recipient address
     * @return taxFee The tax fee percentage
     */
    function _getTaxFee(address sender, address recipient) private view returns (uint256 taxFee) {
        // Buy transaction: from AMM pair to user (user must not be excluded)
        if (sender == mainAMMPair && !_isExcludedFromFee[recipient]) {
            return _taxFeeOnBuy;
        }
        // Sell transaction: from user to AMM pair (user must not be excluded)
        if (recipient == mainAMMPair && !_isExcludedFromFee[sender]) {
            return _taxFeeOnSell;
        }
        // No fees for other transaction types or excluded addresses
        return 0;
    }

    // Core transfer function
    function _transfer(address from, address to, uint256 amount) private {
        if (from == address(0)) revert InvalidAddress();
        if (to == address(0)) revert InvalidAddress();
        if (amount == 0) revert InvalidAmount();

        // Cache owner to reduce gas usage
        address contractOwner = owner();
        
        // Trading restriction - only apply to AMM transactions
        if (!tradingActive && from != contractOwner && to != contractOwner && 
            from != taxReceiver && to != taxReceiver) {
            if (from == mainAMMPair || to == mainAMMPair) {
                revert TradingNotActive();
            }
        }

        // Limits (only active when trading is enabled and not applied to owner or excluded addresses)
        if (limitsActive && tradingActive && from != contractOwner && to != contractOwner && 
            !isExcludedFromLimits[from] && !isExcludedFromLimits[to]) {
            
            if (to != mainAMMPair) {
                uint256 recipientBalance = balanceOf(to);
                if (recipientBalance + amount > _maxWalletSize) {
                    revert ExceedsMaxWallet();
                }
            }
            
            // Max transaction check only applies to AMM transactions
            if (from == mainAMMPair || to == mainAMMPair) {
                if (amount > _maxTxAmount) {
                    revert ExceedsMaxTx();
                }
            }
        }

        // Auto-swap conditions
        uint256 contractTokenBalance = balanceOf(address(this));
        
        if (_shouldSwap(contractTokenBalance, from, to)) {
            uint256 initialETH = address(this).balance;
            swapTokensForEth(contractTokenBalance);
            uint256 receivedETH = address(this).balance - initialETH;
            
            emit AutoSwapExecuted(contractTokenBalance, receivedETH);
            
            uint256 contractETHBalance = address(this).balance;
            if (contractETHBalance > 0) {
                sendETHToFee(contractETHBalance);
            }
        }

        _tokenTransfer(from, to, amount);
    }

    function _tokenTransfer(address sender, address recipient, uint256 amount) private {
        uint256 taxFee = _getTaxFee(sender, recipient);
        
        if (taxFee == 0) {
            _transferStandard(sender, recipient, amount);
        } else {
            _transferWithFees(sender, recipient, amount, taxFee);
        }
    }

    function _transferStandard(address sender, address recipient, uint256 amount) private {
        _balances[sender] -= amount;
        _balances[recipient] += amount;
        
        emit Transfer(sender, recipient, amount);
    }

    function _transferWithFees(address sender, address recipient, uint256 amount, uint256 taxFee) private {
        // Calculate tax amount
        uint256 taxAmount = _calculateTax(amount, taxFee);
        uint256 transferAmount = amount - taxAmount;
        
        // Update balances
        _balances[sender] -= amount;
        _balances[recipient] += transferAmount;
        
        if (taxAmount > 0) {
            _balances[address(this)] += taxAmount;
            emit Transfer(sender, address(this), taxAmount);
            emit TaxCollected(sender, recipient, taxAmount);
        }
        
        emit Transfer(sender, recipient, transferAmount);
    }

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

        // Get expected output - will revert if no liquidity (SECURE)
        uint256[] memory expectedOutputs = uniswapV2Router.getAmountsOut(tokenAmount, path);
        uint256 expectedETH = expectedOutputs[1];
        uint256 minETHOut = (expectedETH * 95) / 100; // 5% slippage protection

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            minETHOut,
            path,
            address(this),
            block.timestamp + 300
        );
    }

    function sendETHToFee(uint256 amount) private {
        // Use transfer() for EOA to prevent reentrancy and gas limit attacks
        payable(taxReceiver).transfer(amount);
    }

    // Standard ERC20 helper functions
    function _approve(address owner, address spender, uint256 amount) private {
        if (owner == address(0)) revert InvalidAddress();
        if (spender == address(0)) revert InvalidAddress();

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }


    
    // Admin Functions
    
    /**
     * @notice Activate trading (one-way switch)
     * @dev Once activated, trading cannot be deactivated. Can only be called by owner or tradingEnabler
     */
    function activateTrading() external {
        if (msg.sender != owner() && msg.sender != tradingEnabler) {
            revert InvalidAddress();
        }
        
        tradingActive = true;
        
        // Reset trading enabler after activation (only needed once)
        tradingEnabler = address(0);
        
        emit TradingActivated(true);
    }

    /**
     * @notice Manually swap contract's token balance for ETH
     * @dev Can only be called by owner
     */
    function manualSwap() external onlyOwner {
        uint256 contractBalance = balanceOf(address(this));
        if (contractBalance > 0) {
            swapTokensForEth(contractBalance);
            emit ManualSwap(contractBalance);
        }
    }

    /**
     * @notice Manually send contract's ETH balance to owner
     * @dev Can only be called by owner
     */
    function manualSend() external onlyOwner {
        uint256 contractETHBalance = address(this).balance;
        if (contractETHBalance > 0) {
            sendETHToFee(contractETHBalance);
            emit ManualSend(contractETHBalance);
        }
    }



    /**
     * @notice Set tax fee structure (fees can only be reduced, never increased beyond current max)
     * @param taxBuy Tax fee on buys (cannot exceed current maxAllowedBuyFee)
     * @param taxSell Tax fee on sells (cannot exceed current maxAllowedSellFee)
     */
    function setFee(uint256 taxBuy, uint256 taxSell) external onlyOwner {
        if (taxBuy > MAX_TAX_FEE || taxSell > MAX_TAX_FEE) {
            revert InvalidFeeRange();
        }
        
        // Tax lock: fees cannot exceed their current maximum allowed values
        if (taxBuy > maxAllowedBuyFee || taxSell > maxAllowedSellFee) {
            revert ExceedsTaxLock();
        }
        
        _taxFeeOnBuy = taxBuy;
        _taxFeeOnSell = taxSell;
        
        // Update the tax lock to the new (lower) values
        maxAllowedBuyFee = taxBuy;
        maxAllowedSellFee = taxSell;
        
        emit FeesUpdated(taxBuy, taxSell);
        emit TaxLockUpdated(taxBuy, taxSell);
    }

    /**
     * @notice Set minimum token threshold for auto-swap
     * @param swapTokensAtAmount Threshold amount
     */
    function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) external onlyOwner {
        if (swapTokensAtAmount == 0) revert InvalidAmount();
        if (swapTokensAtAmount > _tTotal / PERCENTAGE_BASE) revert ExceedsReasonableThreshold();
        
        _swapTokensAtAmount = swapTokensAtAmount;
        emit SwapThresholdUpdated(swapTokensAtAmount);
    }

    /**
     * @notice Toggle auto-swap functionality
     * @param _swapEnabled Whether auto-swap should be enabled
     */
    function toggleSwap(bool _swapEnabled) external onlyOwner {
        swapEnabled = _swapEnabled;
        emit SwapToggled(_swapEnabled);
    }

    /**
     * @notice Set maximum transaction amount
     * @param maxTxAmount Maximum transaction amount (must be at least 0.1% of total supply)
     */
    function setMaxTxnAmount(uint256 maxTxAmount) external onlyOwner {
        if (maxTxAmount == 0) revert InvalidAmount();
        if (maxTxAmount > _tTotal) revert ExceedsReasonableThreshold();
        
        uint256 minLimit = (_tTotal * MIN_LIMIT_PERCENTAGE) / 100000;
        if (maxTxAmount < minLimit) revert BelowMinimumThreshold();
        
        _maxTxAmount = maxTxAmount;
        emit MaxTxUpdated(maxTxAmount);
    }

    /**
     * @notice Set maximum wallet size
     * @param maxWalletSize Maximum wallet size (must be at least 0.1% of total supply)
     */
    function setMaxWalletSize(uint256 maxWalletSize) external onlyOwner {
        if (maxWalletSize == 0) revert InvalidAmount();
        if (maxWalletSize > _tTotal) revert ExceedsReasonableThreshold();
        
        uint256 minLimit = (_tTotal * MIN_LIMIT_PERCENTAGE) / 100000;
        if (maxWalletSize < minLimit) revert BelowMinimumThreshold();
        
        _maxWalletSize = maxWalletSize;
        emit MaxWalletUpdated(maxWalletSize);
    }

    /**
     * @notice Exclude or include multiple accounts from fees
     * @param accounts Array of accounts to update
     * @param excluded Whether accounts should be excluded from fees
     */
    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner {
        for (uint256 i = 0; i < accounts.length; i++) {
            _isExcludedFromFee[accounts[i]] = excluded;
        }
        emit FeeExemptionUpdated(accounts, excluded);
    }
    
    /**
     * @notice Exclude or include multiple accounts from limits (for launchpad support)
     * @param accounts Array of accounts to update
     * @param excluded Whether accounts should be excluded from limits
     */
    function excludeMultipleAccountsFromLimits(address[] calldata accounts, bool excluded) external onlyOwner {
        for (uint256 i = 0; i < accounts.length; i++) {
            isExcludedFromLimits[accounts[i]] = excluded;
        }
        emit LimitExemptionUpdated(accounts, excluded);
    }
    
    /**
     * @notice Toggle transaction and wallet limits
     * @param _limitsActive Whether limits should be active (only enforced when trading is active)
     */
    function toggleLimits(bool _limitsActive) external onlyOwner {
        limitsActive = _limitsActive;
        emit LimitsToggled(_limitsActive);
    }
    
    /**
     * @notice Set tax receiver address (must be EOA, not contract)
     * @param newTaxReceiver Address that will receive tax fees (must be EOA)
     */
    function setTaxReceiver(address newTaxReceiver) external onlyOwner {
        if (newTaxReceiver == address(0)) revert InvalidAddress();
        
        // Ensure tax receiver is EOA, not a contract
        if (newTaxReceiver.code.length > 0) revert ContractNotAllowed();
        
        address oldTaxReceiver = taxReceiver;
        taxReceiver = newTaxReceiver;
        
        // Automatically exclude new tax receiver from limits for operational flexibility
        isExcludedFromLimits[newTaxReceiver] = true;
        
        emit TaxReceiverUpdated(oldTaxReceiver, newTaxReceiver);
    }

    /**
     * @notice Transfer ownership and automatically exclude new owner from limits
     * @param newOwner Address of the new owner
     */
    function transferOwnership(address newOwner) public override onlyOwner {
        if (newOwner == address(0)) revert InvalidAddress();
        
        // Automatically exclude new owner from limits for administrative flexibility
        isExcludedFromLimits[newOwner] = true;
        
        // Call parent transferOwnership function
        super.transferOwnership(newOwner);
    }

    /**
     * @notice Emergency function to rescue tokens accidentally sent to this contract
     * @dev Can rescue the contract's own tokens
     * @param tokenAddress Address of the token to rescue (cannot be this contract's token)
     * @param amount Amount of tokens to rescue
     * @param recipient Address to send the rescued tokens to
     */
    function rescueTokens(address tokenAddress, uint256 amount, address recipient) external onlyOwner {
        if (tokenAddress == address(0)) revert InvalidAddress();
        if (recipient == address(0)) revert InvalidAddress();
        if (amount == 0) revert InvalidAmount();
        
        IERC20 token = IERC20(tokenAddress);
        uint256 contractBalance = token.balanceOf(address(this));
        
        if (contractBalance < amount) revert InsufficientBalance();
        
        token.safeTransfer(recipient, amount);
        
        emit TokensRescued(tokenAddress, recipient, amount);
    }

    // View functions
    function isExcludedFromFee(address account) external view returns (bool) {
        return _isExcludedFromFee[account];
    }
    
    function isExcludedFromLimitsView(address account) external view returns (bool) {
        return isExcludedFromLimits[account];
    }
    
    /**
     * @notice Get main AMM pair address
     * @return Address of the main AMM pair
     */
    function getMainAMMPair() external view returns (address) {
        return mainAMMPair;
    }
    
    /**
     * @notice Get current tax receiver address
     * @return Address of current tax receiver
     */
    function getTaxReceiver() external view returns (address) {
        return taxReceiver;
    }
    
    /**
     * @notice Get minimum allowed limit for max transaction and max wallet (0.1% of total supply)
     * @return Minimum limit value
     */
    function getMinimumLimit() external pure returns (uint256) {
        return (_tTotal * MIN_LIMIT_PERCENTAGE) / 100000;
    }
    
    /**
     * @notice Get current maximum allowed buy fee (tax lock value)
     * @return Maximum allowed buy fee percentage
     */
    function getMaxAllowedBuyFee() external view returns (uint256) {
        return maxAllowedBuyFee;
    }
    
    /**
     * @notice Get current maximum allowed sell fee (tax lock value)
     * @return Maximum allowed sell fee percentage
     */
    function getMaxAllowedSellFee() external view returns (uint256) {
        return maxAllowedSellFee;
    }
    
    /**
     * @notice Get current trading enabler address
     * @return Address of current trading enabler (address(0) if trading already activated)
     */
    function getTradingEnabler() external view returns (address) {
        return tradingEnabler;
    }

    // Receive ETH
    receive() external payable {}
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

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

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @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 Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _callOptionalReturnBool(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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/Address.sol)

pragma solidity ^0.8.20;

import {Errors} from "./Errors.sol";

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

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

        (bool success, bytes memory returndata) = recipient.call{value: amount}("");
        if (!success) {
            _revert(returndata);
        }
    }

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

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

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

pragma solidity ^0.8.20;

import {Context} from "../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.
 *
 * 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.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)

pragma solidity ^0.8.20;

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../utils/introspection/IERC165.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

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

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"routerAddress","type":"address"},{"internalType":"address","name":"initialTaxReceiver","type":"address"},{"internalType":"address","name":"_tradingEnabler","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BelowMinimumThreshold","type":"error"},{"inputs":[],"name":"ContractNotAllowed","type":"error"},{"inputs":[],"name":"ExceedsMaxTx","type":"error"},{"inputs":[],"name":"ExceedsMaxWallet","type":"error"},{"inputs":[],"name":"ExceedsReasonableThreshold","type":"error"},{"inputs":[],"name":"ExceedsTaxLock","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidFeeRange","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"SwapFailed","type":"error"},{"inputs":[],"name":"TradingNotActive","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"}],"name":"AutoSwapExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"accounts","type":"address[]"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"FeeExemptionUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"taxBuy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"taxSell","type":"uint256"}],"name":"FeesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"accounts","type":"address[]"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"LimitExemptionUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"LimitsToggled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ManualSend","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"ManualSwap","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxTx","type":"uint256"}],"name":"MaxTxUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxWallet","type":"uint256"}],"name":"MaxWalletUpdated","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":false,"internalType":"uint256","name":"threshold","type":"uint256"}],"name":"SwapThresholdUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"SwapToggled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"taxAmount","type":"uint256"}],"name":"TaxCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxBuyFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maxSellFee","type":"uint256"}],"name":"TaxLockUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldReceiver","type":"address"},{"indexed":false,"internalType":"address","name":"newReceiver","type":"address"}],"name":"TaxReceiverUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensRescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"TradingActivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_maxTxAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxWalletSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_taxFeeOnBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_taxFeeOnSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activateTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeMultipleAccountsFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeMultipleAccountsFromLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getMainAMMPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxAllowedBuyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxAllowedSellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinimumLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getTaxReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradingEnabler","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromLimits","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromLimitsView","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limitsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mainAMMPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manualSend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"manualSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxAllowedBuyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxAllowedSellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"taxBuy","type":"uint256"},{"internalType":"uint256","name":"taxSell","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxTxAmount","type":"uint256"}],"name":"setMaxTxnAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxWalletSize","type":"uint256"}],"name":"setMaxWalletSize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"swapTokensAtAmount","type":"uint256"}],"name":"setMinSwapTokensThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTaxReceiver","type":"address"}],"name":"setTaxReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"taxReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_limitsActive","type":"bool"}],"name":"toggleLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_swapEnabled","type":"bool"}],"name":"toggleSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"tradingActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingEnabler","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x60806040526004361061028e575f3560e01c80638da5cb5b11610155578063c492f046116100be578063e6ef73d611610078578063e6ef73d614610831578063ea1644d514610857578063ef8c14f214610876578063f2fde38b1461088a578063f4293890146108a9578063ffbc3052146108bd575f5ffd5b8063c492f0461461073a578063c6e5a5ab14610759578063cd8de42c14610778578063cda885cb14610797578063dd62ed3e146107bb578063e38ab29a146107ff575f5ffd5b8063b2563a1b1161010f578063b2563a1b14610683578063b256f7b714610697578063b37fd190146106b6578063b775fc70146106d5578063bbc0c7421461070c578063bf5976d314610725575f5ffd5b80638da5cb5b146105d45780638f9a55c0146105f057806395d89b411461060557806398a5c31514610630578063a5e347c21461064f578063a9059cbb14610664575f5ffd5b806352f7c988116101f7578063715018a6116101b1578063715018a61461054357806374010ece146105575780637a29bc67146105765780637c4c83351461058b5780637d1db4a5146105aa5780638199040e146105bf575f5ffd5b806352f7c9881461044e5780635342acb41461046d5780635cce86cd146104a45780636d8aa8f8146104d25780636ddd1713146104f157806370a082311461050f575f5ffd5b806323b872dd1161024857806323b872dd146103a45780632d187f5f146103c35780632fd689e3146103f6578063313ce5671461040b57806348e39c2d1461042657806351bc3c851461043a575f5ffd5b806306fdde0314610299578063095ea7b3146102d95780630bd05b69146103085780631694505e1461031e57806318160ddd146103695780631cce34ee1461038b575f5ffd5b3661029557005b5f5ffd5b3480156102a4575f5ffd5b50604080518082019091526006815265466c6f77414960d01b60208201525b6040516102d0919061202f565b60405180910390f35b3480156102e4575f5ffd5b506102f86102f3366004612078565b6108da565b60405190151581526020016102d0565b348015610313575f5ffd5b5061031c6108f3565b005b348015610329575f5ffd5b506103517f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d81565b6040516001600160a01b0390911681526020016102d0565b348015610374575f5ffd5b5061037d61098b565b6040519081526020016102d0565b348015610396575f5ffd5b50600f546102f89060ff1681565b3480156103af575f5ffd5b506102f86103be3660046120a2565b6109ab565b3480156103ce575f5ffd5b506103517f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a81565b348015610401575f5ffd5b5061037d600b5481565b348015610416575f5ffd5b50604051600981526020016102d0565b348015610431575f5ffd5b5060075461037d565b348015610445575f5ffd5b5061031c610a23565b348015610459575f5ffd5b5061031c6104683660046120e0565b610a81565b348015610478575f5ffd5b506102f8610487366004612100565b6001600160a01b03165f9081526004602052604090205460ff1690565b3480156104af575f5ffd5b506102f86104be366004612100565b600e6020525f908152604090205460ff1681565b3480156104dd575f5ffd5b5061031c6104ec36600461212f565b610b70565b3480156104fc575f5ffd5b50600c546102f890610100900460ff1681565b34801561051a575f5ffd5b5061037d610529366004612100565b6001600160a01b03165f9081526002602052604090205490565b34801561054e575f5ffd5b5061031c610bc1565b348015610562575f5ffd5b5061031c610571366004612148565b610bd4565b348015610581575f5ffd5b5061037d60085481565b348015610596575f5ffd5b50600d54610351906001600160a01b031681565b3480156105b5575f5ffd5b5061037d60095481565b3480156105ca575f5ffd5b5061037d60065481565b3480156105df575f5ffd5b505f546001600160a01b0316610351565b3480156105fb575f5ffd5b5061037d600a5481565b348015610610575f5ffd5b50604080518082019091526003815262464c5760e81b60208201526102c3565b34801561063b575f5ffd5b5061031c61064a366004612148565b610cc3565b34801561065a575f5ffd5b5061037d60075481565b34801561066f575f5ffd5b506102f861067e366004612078565b610d66565b34801561068e575f5ffd5b5061037d610d73565b3480156106a2575f5ffd5b5061031c6106b136600461212f565b610da8565b3480156106c1575f5ffd5b5061031c6106d036600461215f565b610df1565b3480156106e0575f5ffd5b506102f86106ef366004612100565b6001600160a01b03165f908152600e602052604090205460ff1690565b348015610717575f5ffd5b50600c546102f89060ff1681565b348015610730575f5ffd5b5061037d60055481565b348015610745575f5ffd5b5061031c61075436600461219e565b610f5c565b348015610764575f5ffd5b5061031c61077336600461219e565b611009565b348015610783575f5ffd5b5061031c610792366004612100565b6110a9565b3480156107a2575f5ffd5b50600c54630100000090046001600160a01b0316610351565b3480156107c6575f5ffd5b5061037d6107d536600461221d565b6001600160a01b039182165f90815260036020908152604080832093909416825291909152205490565b34801561080a575f5ffd5b507f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a610351565b34801561083c575f5ffd5b50600c5461035190630100000090046001600160a01b031681565b348015610862575f5ffd5b5061031c610871366004612148565b61118f565b348015610881575f5ffd5b5060085461037d565b348015610895575f5ffd5b5061031c6108a4366004612100565b61127e565b3480156108b4575f5ffd5b5061031c6112d8565b3480156108c8575f5ffd5b50600d546001600160a01b0316610351565b5f336108e7818585611320565b60019150505b92915050565b5f546001600160a01b031633148015906109185750600d546001600160a01b03163314155b156109365760405163e6c4247b60e01b815260040160405180910390fd5b600c805460ff19166001908117909155600d80546001600160a01b03191690556040519081527f10cbdaa9da572a6586325ac920fff5d091e67fb26d94180f7b6376cbcda1a09e9060200160405180910390a1565b5f6109986009600a61234b565b6109a6906305f5e100612359565b905090565b6001600160a01b0383165f9081526003602090815260408083203380855292528220545f1981146109f757838110156109f757604051631e9acf1760e31b815260040160405180910390fd5b610a028686866113cf565b5f198114610a1757610a178683868403611320565b50600195945050505050565b610a2b6117af565b305f908152600260205260409020548015610a7e57610a49816117e0565b6040518181527f56ca8a41f09235158a6ec58694576046f629be9f03fef67962686e88113418b8906020015b60405180910390a15b50565b610a896117af565b6028821180610a985750602881115b15610ab65760405163c15a4e6d60e01b815260040160405180910390fd5b600754821180610ac7575060085481115b15610ae5576040516369db291b60e11b815260040160405180910390fd5b600582905560068190556007829055600881905560408051838152602081018390527f5c6323bf1c2d7aaea2c091a4751c1c87af7f2864650c336507a77d0557af37a1910160405180910390a160408051838152602081018390527fbf6999fbd63f10a57b9d4de3a17e4f6fcda091b7bf4a98be528a178c5c6d75e491015b60405180910390a15050565b610b786117af565b600c80548215156101000261ff00199091161790556040517f2bf14f4b0db6ab582b97553bc4a68d845fa84a9b98e3660cb1d9143e481b4c8990610a7590831515815260200190565b610bc96117af565b610bd25f611a8e565b565b610bdc6117af565b805f03610bfc5760405163162908e360e11b815260040160405180910390fd5b610c086009600a61234b565b610c16906305f5e100612359565b811115610c365760405163dc8ad03f60e01b815260040160405180910390fd5b5f620186a06064610c496009600a61234b565b610c57906305f5e100612359565b610c619190612359565b610c6b9190612370565b905080821015610c8e576040516307a97e1760e21b815260040160405180910390fd5b60098290556040518281527fff3dd5e80294197918c284bbfc3dadd97d0b40ce92106110946329088f80068a90602001610b64565b610ccb6117af565b805f03610ceb5760405163162908e360e11b815260040160405180910390fd5b6064610cf96009600a61234b565b610d07906305f5e100612359565b610d119190612370565b811115610d315760405163dc8ad03f60e01b815260040160405180910390fd5b600b8190556040518181527f18ff2fc8464635e4f668567019152095047e34d7a2ab4b97661ba4dc7fd0647690602001610a75565b5f336108e78185856113cf565b5f620186a06064610d866009600a61234b565b610d94906305f5e100612359565b610d9e9190612359565b6109a69190612370565b610db06117af565b600f805460ff19168215159081179091556040519081527fbf2321f2e60a67a985992f927edcacdf59841fa1a43089ec49a1b61b5b2ae8d990602001610a75565b610df96117af565b6001600160a01b038316610e205760405163e6c4247b60e01b815260040160405180910390fd5b6001600160a01b038116610e475760405163e6c4247b60e01b815260040160405180910390fd5b815f03610e675760405163162908e360e11b815260040160405180910390fd5b6040516370a0823160e01b815230600482015283905f906001600160a01b038316906370a0823190602401602060405180830381865afa158015610ead573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ed1919061238f565b905083811015610ef457604051631e9acf1760e31b815260040160405180910390fd5b610f086001600160a01b0383168486611add565b826001600160a01b0316856001600160a01b03167f77023e19c7343ad491fd706c36335ca0e738340a91f29b1fd81e2673d44896c486604051610f4d91815260200190565b60405180910390a35050505050565b610f646117af565b5f5b82811015610fc8578160045f868685818110610f8457610f846123a6565b9050602002016020810190610f999190612100565b6001600160a01b0316815260208101919091526040015f20805460ff1916911515919091179055600101610f66565b507f708ba8194772510cb62312de46c16bdf563135c62d01d2bf88cd12fcec866a5e838383604051610ffc939291906123ba565b60405180910390a1505050565b6110116117af565b5f5b828110156110755781600e5f868685818110611031576110316123a6565b90506020020160208101906110469190612100565b6001600160a01b0316815260208101919091526040015f20805460ff1916911515919091179055600101611013565b507f3759a4af6b9f2d47438241a8252b3c574d45e3429b9d6f0f8d9e13c234747dbb838383604051610ffc939291906123ba565b6110b16117af565b6001600160a01b0381166110d85760405163e6c4247b60e01b815260040160405180910390fd5b6001600160a01b0381163b15611101576040516311970e2d60e31b815260040160405180910390fd5b600c80546001600160a01b0383811663010000008181026301000000600160b81b03198516179094555f908152600e602052604090819020805460ff19166001179055519290910416907ff970bc488f38cdc7caf559de1924e9c564d90c54d1767c82df2cbc55c9829a5e90610b6490839085906001600160a01b0392831681529116602082015260400190565b6111976117af565b805f036111b75760405163162908e360e11b815260040160405180910390fd5b6111c36009600a61234b565b6111d1906305f5e100612359565b8111156111f15760405163dc8ad03f60e01b815260040160405180910390fd5b5f620186a060646112046009600a61234b565b611212906305f5e100612359565b61121c9190612359565b6112269190612370565b905080821015611249576040516307a97e1760e21b815260040160405180910390fd5b600a8290556040518281527f12528a3c61e0f3b2d6fc707a9fc58b1af86e252cad0d7f4c154ebeabb162dace90602001610b64565b6112866117af565b6001600160a01b0381166112ad5760405163e6c4247b60e01b815260040160405180910390fd5b6001600160a01b0381165f908152600e60205260409020805460ff19166001179055610a7e81611b34565b6112e06117af565b478015610a7e576112f081611b6e565b6040518181527f3a38922c43b9e48140354754476c00d0cfbb2b4ba42d28fa55613d2b30a23acd90602001610a75565b6001600160a01b0383166113475760405163e6c4247b60e01b815260040160405180910390fd5b6001600160a01b03821661136e5760405163e6c4247b60e01b815260040160405180910390fd5b6001600160a01b038381165f8181526003602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591015b60405180910390a3505050565b6001600160a01b0383166113f65760405163e6c4247b60e01b815260040160405180910390fd5b6001600160a01b03821661141d5760405163e6c4247b60e01b815260040160405180910390fd5b805f0361143d5760405163162908e360e11b815260040160405180910390fd5b5f54600c546001600160a01b039091169060ff161580156114705750806001600160a01b0316846001600160a01b031614155b801561148e5750806001600160a01b0316836001600160a01b031614155b80156114af5750600c546001600160a01b0385811663010000009092041614155b80156114d05750600c546001600160a01b0384811663010000009092041614155b15611564577f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316846001600160a01b0316148061154657507f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316836001600160a01b0316145b1561156457604051632924508760e21b815260040160405180910390fd5b600f5460ff1680156115785750600c5460ff165b80156115965750806001600160a01b0316846001600160a01b031614155b80156115b45750806001600160a01b0316836001600160a01b031614155b80156115d857506001600160a01b0384165f908152600e602052604090205460ff16155b80156115fc57506001600160a01b0383165f908152600e602052604090205460ff16155b15611719577f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316836001600160a01b031614611680576001600160a01b0383165f90815260026020526040902054600a5461165f8483612412565b111561167e57604051630ebe2dbd60e41b815260040160405180910390fd5b505b7f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316846001600160a01b031614806116f157507f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316836001600160a01b0316145b156117195760095482111561171957604051632b70fd5560e01b815260040160405180910390fd5b305f90815260026020526040902054611733818686611baf565b1561179d5747611742826117e0565b5f61174d8247612425565b60408051858152602081018390529192507f2b16bc93342cfba8827c2c5811bfc478551a0ea553ecea999984c9f4871320c2910160405180910390a14780156117995761179981611b6e565b5050505b6117a8858585611c7a565b5050505050565b5f546001600160a01b03163314610bd25760405163118cdaa760e01b81523360048201526024015b60405180910390fd5b600c805462ff00001916620100001790556040805160028082526060820183525f9260208301908036833701905050905030815f81518110611824576118246123a6565b60200260200101906001600160a01b031690816001600160a01b0316815250507f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa1580156118a0573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906118c4919061244c565b816001815181106118d7576118d76123a6565b60200260200101906001600160a01b031690816001600160a01b031681525050611922307f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d84611320565b60405163d06ca61f60e01b81525f906001600160a01b037f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d169063d06ca61f9061197290869086906004016124aa565b5f60405180830381865afa15801561198c573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526119b391908101906124c2565b90505f816001815181106119c9576119c96123a6565b602002602001015190505f606482605f6119e39190612359565b6119ed9190612370565b90506001600160a01b037f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d1663791ac94786838730611a2e4261012c612412565b6040518663ffffffff1660e01b8152600401611a4e95949392919061258a565b5f604051808303815f87803b158015611a65575f5ffd5b505af1158015611a77573d5f5f3e3d5ffd5b5050600c805462ff00001916905550505050505050565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052611b2f908490611cb0565b505050565b611b3c6117af565b6001600160a01b038116611b6557604051631e4fbdf760e01b81525f60048201526024016117d7565b610a7e81611a8e565b600c5460405163010000009091046001600160a01b0316906108fc8315029083905f818181858888f19350505050158015611bab573d5f5f3e3d5ffd5b5050565b5f600b548410158015611bcb5750600c5462010000900460ff16155b8015611c0957507f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316836001600160a01b031614155b8015611c1c5750600c54610100900460ff165b8015611c2a5750600c5460ff165b8015611c4e57506001600160a01b0383165f9081526004602052604090205460ff16155b8015611c7257506001600160a01b0382165f9081526004602052604090205460ff16155b949350505050565b5f611c858484611d1c565b9050805f03611c9e57611c99848484611df3565b611caa565b611caa84848484611e92565b50505050565b5f5f60205f8451602086015f885af180611ccf576040513d5f823e3d81fd5b50505f513d91508115611ce6578060011415611cf3565b6001600160a01b0384163b155b15611caa57604051635274afe760e01b81526001600160a01b03851660048201526024016117d7565b5f7f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316836001600160a01b0316148015611d7657506001600160a01b0382165f9081526004602052604090205460ff16155b15611d8457506005546108ed565b7f000000000000000000000000040e9e49b56cae9a71f0dc5ec799210047e3223a6001600160a01b0316826001600160a01b0316148015611ddd57506001600160a01b0383165f9081526004602052604090205460ff16155b15611deb57506006546108ed565b505f92915050565b6001600160a01b0383165f9081526002602052604081208054839290611e1a908490612425565b90915550506001600160a01b0382165f9081526002602052604081208054839290611e46908490612412565b92505081905550816001600160a01b0316836001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516113c291815260200190565b5f611e9d8383612011565b90505f611eaa8285612425565b6001600160a01b0387165f90815260026020526040812080549293508692909190611ed6908490612425565b90915550506001600160a01b0385165f9081526002602052604081208054839290611f02908490612412565b90915550508115611fbc57305f9081526002602052604081208054849290611f2b908490612412565b909155505060405182815230906001600160a01b038816907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a3604080516001600160a01b038089168252871660208201529081018390527f5d37fd68fe66745a199f8c603e00ae02183f4aabb8ec0089589b0b40c4ead5e19060600160405180910390a15b846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161200191815260200190565b60405180910390a3505050505050565b5f606461201e8385612359565b6120289190612370565b9392505050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b6001600160a01b0381168114610a7e575f5ffd5b5f5f60408385031215612089575f5ffd5b823561209481612064565b946020939093013593505050565b5f5f5f606084860312156120b4575f5ffd5b83356120bf81612064565b925060208401356120cf81612064565b929592945050506040919091013590565b5f5f604083850312156120f1575f5ffd5b50508035926020909101359150565b5f60208284031215612110575f5ffd5b813561202881612064565b8035801515811461212a575f5ffd5b919050565b5f6020828403121561213f575f5ffd5b6120288261211b565b5f60208284031215612158575f5ffd5b5035919050565b5f5f5f60608486031215612171575f5ffd5b833561217c81612064565b925060208401359150604084013561219381612064565b809150509250925092565b5f5f5f604084860312156121b0575f5ffd5b833567ffffffffffffffff8111156121c6575f5ffd5b8401601f810186136121d6575f5ffd5b803567ffffffffffffffff8111156121ec575f5ffd5b8660208260051b8401011115612200575f5ffd5b60209182019450925061221490850161211b565b90509250925092565b5f5f6040838503121561222e575f5ffd5b823561223981612064565b9150602083013561224981612064565b809150509250929050565b634e487b7160e01b5f52601160045260245ffd5b6001815b60018411156122a35780850481111561228757612287612254565b600184161561229557908102905b60019390931c92800261226c565b935093915050565b5f826122b9575060016108ed565b816122c557505f6108ed565b81600181146122db57600281146122e557612301565b60019150506108ed565b60ff8411156122f6576122f6612254565b50506001821b6108ed565b5060208310610133831016604e8410600b8410161715612324575081810a6108ed565b6123305f198484612268565b805f190482111561234357612343612254565b029392505050565b5f61202860ff8416836122ab565b80820281158282048414176108ed576108ed612254565b5f8261238a57634e487b7160e01b5f52601260045260245ffd5b500490565b5f6020828403121561239f575f5ffd5b5051919050565b634e487b7160e01b5f52603260045260245ffd5b604080825281018390525f8460608301825b868110156123fc5782356123df81612064565b6001600160a01b03168252602092830192909101906001016123cc565b5080925050508215156020830152949350505050565b808201808211156108ed576108ed612254565b818103818111156108ed576108ed612254565b634e487b7160e01b5f52604160045260245ffd5b5f6020828403121561245c575f5ffd5b815161202881612064565b5f8151808452602084019350602083015f5b828110156124a05781516001600160a01b0316865260209586019590910190600101612479565b5093949350505050565b828152604060208201525f611c726040830184612467565b5f602082840312156124d2575f5ffd5b815167ffffffffffffffff8111156124e8575f5ffd5b8201601f810184136124f8575f5ffd5b805167ffffffffffffffff81111561251257612512612438565b8060051b604051601f19603f830116810181811067ffffffffffffffff8211171561253f5761253f612438565b60405291825260208184018101929081018784111561255c575f5ffd5b6020850194505b8385101561257f57845180825260209586019590935001612563565b509695505050505050565b85815284602082015260a060408201525f6125a860a0830186612467565b6001600160a01b039490941660608301525060800152939250505056fea264697066735822122008b0eeb15c98a3117b707234336a9ba7730b55d26fd7bd228ebe84451d06549f64736f6c634300081e0033

0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000009aaf86efbeed3a8e26ea5ab89d6701f3e834c35e0000000000000000000000001b3c943c2ac615c804f8571b4ef4954e48e83b63

-----Decoded View---------------
Arg [0] : routerAddress (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [1] : initialTaxReceiver (address): 0x9aAF86eFbeed3a8E26Ea5Ab89D6701f3E834C35E
Arg [2] : _tradingEnabler (address): 0x1b3c943c2aC615C804f8571B4eF4954E48e83B63

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [1] : 0000000000000000000000009aaf86efbeed3a8e26ea5ab89d6701f3e834c35e
Arg [2] : 0000000000000000000000001b3c943c2ac615c804f8571b4ef4954e48e83b63