// SPDX-License-Identifier: MIT 
pragma solidity ^0.8.0; 
 
interface IERC20 { 
    event Transfer(address indexed from, address indexed to, uint256 value); 
    event Approval(address indexed owner, address indexed spender, uint256 value); 
 
    function totalSupply() external view returns (uint256); 
    function balanceOf(address account) external view returns (uint256); 
    function transfer(address to, uint256 amount) external returns (bool); 
    function allowance(address owner, address spender) external view returns (uint256); 
    function approve(address spender, uint256 amount) external returns (bool); 
    function transferFrom(address from, address to, uint256 amount) external returns (bool); 
} 
 
interface IERC20Metadata is IERC20 { 
    function name() external view returns (string memory); 
    function symbol() external view returns (string memory); 
    function decimals() external view returns (uint8); 
} 
 
abstract contract Context { 
    function _msgSender() internal view virtual returns (address) { 
        return msg.sender; 
    } 
 
    function _msgData() internal view virtual returns (bytes calldata) { 
        return msg.data; 
    } 
} 
 
contract ERC20 is Context, IERC20, IERC20Metadata { 
    mapping(address => uint256) private _balances; 
    mapping(address => mapping(address => uint256)) private _allowances; 
    uint256 private _totalSupply; 
    string private _name; 
    string private _symbol; 
 
    constructor(string memory name_, string memory symbol_) { 
        _name = name_; 
        _symbol = symbol_; 
    } 
 
    function name() public view virtual override returns (string memory) { 
        return _name; 
    } 
 
    function symbol() public view virtual override returns (string memory) { 
        return _symbol; 
    } 
 
    function decimals() public view virtual override returns (uint8) { 
        return 18; 
    } 
 
    function totalSupply() public view virtual override returns (uint256) { 
        return _totalSupply; 
    } 
 
    function balanceOf(address account) public view virtual override returns (uint256) { 
        return _balances[account]; 
    } 
 
    function transfer(address to, uint256 amount) public virtual override returns (bool) { 
        address owner = _msgSender(); 
        _transfer(owner, to, amount); 
        return true; 
    } 
 
    function allowance(address owner, address spender) public view virtual override returns (uint256) { 
        return _allowances[owner][spender]; 
    } 
 
    function approve(address spender, uint256 amount) public virtual override returns (bool) { 
        address owner = _msgSender(); 
        _approve(owner, spender, amount); 
        return true; 
    } 
 
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) { 
        address spender = _msgSender(); 
        _spendAllowance(from, spender, amount); 
        _transfer(from, to, amount); 
        return true; 
    } 
 
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { 
        address owner = _msgSender(); 
        _approve(owner, spender, allowance(owner, spender) + addedValue); 
        return true; 
    } 
 
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { 
        address owner = _msgSender(); 
        uint256 currentAllowance = allowance(owner, spender); 
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); 
        unchecked { 
            _approve(owner, spender, currentAllowance - subtractedValue); 
        } 
        return true; 
    } 
 
    function _transfer(address from, address to, uint256 amount) internal virtual { 
        require(from != address(0), "ERC20: transfer from the zero address"); 
        require(to != address(0), "ERC20: transfer to the zero address"); 
 
        _beforeTokenTransfer(from, to, amount); 
 
        uint256 fromBalance = _balances[from]; 
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); 

        unchecked { 
            _balances[from] = fromBalance - amount; 
            _balances[to] += amount; 
        } 
 
        emit Transfer(from, to, amount); 
 
        _afterTokenTransfer(from, to, amount); 
    } 
 
    function _mint(address account, uint256 amount) internal virtual { 
        require(account != address(0), "ERC20: mint to the zero address"); 
 
        _beforeTokenTransfer(address(0), account, amount); 
 
        _totalSupply += amount; 
        unchecked { 
            _balances[account] += amount; 
        } 
        emit Transfer(address(0), account, amount); 
 
        _afterTokenTransfer(address(0), account, amount); 
    } 
 
    function _burn(address account, uint256 amount) internal virtual { 
        require(account != address(0), "ERC20: burn from the zero address"); 
 
        _beforeTokenTransfer(account, address(0), amount); 
 
        uint256 accountBalance = _balances[account]; 
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); 
        unchecked { 
            _balances[account] = accountBalance - amount; 
            _totalSupply -= amount; 
        } 
 
        emit Transfer(account, address(0), amount); 
 
        _afterTokenTransfer(account, address(0), amount); 
    } 
 
    function _approve(address owner, address spender, uint256 amount) internal virtual { 
        require(owner != address(0), "ERC20: approve from the zero address"); 
        require(spender != address(0), "ERC20: approve to the zero address"); 
 
        _allowances[owner][spender] = amount; 
        emit Approval(owner, spender, amount); 
    } 
 
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual { 
        uint256 currentAllowance = allowance(owner, spender); 
        if (currentAllowance != type(uint256).max) { 
            require(currentAllowance >= amount, "ERC20: insufficient allowance"); 
            unchecked { 
                _approve(owner, spender, currentAllowance - amount); 
            } 
        } 
    } 
 
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} 
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {} 
} 
 
contract Ownable { 
    address private _owner; 
 
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 
 
    constructor() { 
        _transferOwnership(msg.sender); 
    } 
 
    modifier onlyOwner() { 
        require(isOwner(), "Ownable: caller is not the owner"); 
        _; 
    } 
 
    function isOwner() public view returns (bool) { 
        return msg.sender == _owner; 
    } 
 
    function transferOwnership(address newOwner) public onlyOwner { 
        require(newOwner != address(0), "Ownable: new owner is the zero address"); 
        _transferOwnership(newOwner); 
    } 
 
    function renounceOwnership() public onlyOwner { 
        _transferOwnership(address(0)); 
    } 
 
    function _transferOwnership(address newOwner) internal { 
        address oldOwner = _owner; 
        _owner = newOwner; 
        emit OwnershipTransferred(oldOwner, newOwner); 
    } 
} 
 
contract XElon is ERC20, Ownable { 
    address private _devWallet; 
    address private _marketingWallet; 
    uint256 private _tax; 
 
    constructor(address devWallet, address marketingWallet) ERC20("XElon", "XLN") { 
        _mint(msg.sender, 1000000000 * 10 ** decimals()); 
        _devWallet = devWallet; 
        _marketingWallet = marketingWallet; 
        _tax = 1; 
    } 
 
    function updateTaxWallet(address devWallet, address marketingWallet) public onlyOwner { 
        _devWallet = devWallet; 
        _marketingWallet = marketingWallet; 
    } 
 
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) { 
        uint256 taxAmount = (amount * _tax) / 100; 
        uint256 transferAmount = amount - taxAmount; 
        _transfer(_msgSender(), _devWallet, (taxAmount * 75) / 100); 
        _transfer(_msgSender(), _marketingWallet,
(taxAmount * 25) / 100); 
        _transfer(_msgSender(), recipient, transferAmount); 
        return true; 
    } 
 
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) { 
        address spender = _msgSender(); 
        _spendAllowance(from, spender, amount); 
        uint256 taxAmount = (amount * _tax) / 100; 
        uint256 transferAmount = amount - taxAmount; 
        _transfer(from, _devWallet, (taxAmount * 75) / 100); 
        _transfer(from, _marketingWallet, (taxAmount * 25) / 100); 
        _transfer(from, to, transferAmount); 
        return true; 
    } 
}