// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.0;

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

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

interface ITokenStandard {
    event Transfer(address indexed src, address indexed dst, uint256 amt);
    event Approval(address indexed owner, address indexed spender, uint256 amt);

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amt) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amt) external returns (bool);
    function transferFrom(address from, address to, uint256 amt) external returns (bool);
}

interface ITokenMetadata is ITokenStandard {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

contract TokenBase is ExecutionContext, ITokenStandard, ITokenMetadata {
    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowed;

    uint256 private supplyTotal;
    string private tokenTitle;
    string private tokenTicker;

    constructor(string memory tName, string memory tSymbol) {
        tokenTitle = tName;
        tokenTicker = tSymbol;
    }

    function name() override external view returns (string memory) {
        return tokenTitle;
    }

    function symbol() override external view returns (string memory) {
        return tokenTicker;
    }

    function decimals() override external pure returns (uint8) {
        return 18;
    }

    function totalSupply() override external view returns (uint256) {
        return supplyTotal;
    }

    function balanceOf(address user) override external view returns (uint256) {
        return balances[user];
    }

    function transfer(address to, uint256 amt) override external returns (bool) {
        address from = _origin();
        _internalTransfer(from, to, amt);
        return true;
    }

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

    function approve(address spender, uint256 amt) override external returns (bool) {
        address sender = _origin();
        _approve(sender, spender, amt);
        return true;
    }

    function transferFrom(address src, address dst, uint256 amt) override external returns (bool) {
        address caller = _origin();
        _spendAllowance(src, caller, amt);
        _internalTransfer(src, dst, amt);
        return true;
    }

    function increaseAllowance(address spender, uint256 addAmt) external returns (bool) {
        address sender = _origin();
        _approve(sender, spender, allowed[sender][spender] + addAmt);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subAmt) external returns (bool) {
        address sender = _origin();
        uint256 current = allowed[sender][spender];
        require(current >= subAmt, "Allowance too low");
        unchecked {
            _approve(sender, spender, current - subAmt);
        }
        return true;
    }

    function _internalTransfer(address src, address dst, uint256 amt) internal virtual {
        require(src != address(0), "Cannot transfer from 0x0");
        require(dst != address(0), "Cannot transfer to 0x0");

        uint256 srcBal = balances[src];
        require(srcBal >= amt, "Balance too low");
        unchecked {
            balances[src] = srcBal - amt;
            balances[dst] += amt;
        }

        emit Transfer(src, dst, amt);
    }

    function _mint(address recipient, uint256 amt) internal virtual {
        require(recipient != address(0), "Mint to 0x0 not allowed");

        supplyTotal += amt;
        unchecked {
            balances[recipient] += amt;
        }

        emit Transfer(address(0), recipient, amt);
    }

    function _burn(address from, uint256 amt) internal virtual {
        require(from != address(0), "Burn from 0x0 not allowed");

        uint256 bal = balances[from];
        require(bal >= amt, "Burn exceeds balance");
        unchecked {
            balances[from] = bal - amt;
            supplyTotal -= amt;
        }

        emit Transfer(from, address(0), amt);
    }

    function _approve(address owner, address spender, uint256 amt) internal virtual {
        require(owner != address(0), "Approve from 0x0");
        require(spender != address(0), "Approve to 0x0");

        allowed[owner][spender] = amt;
        emit Approval(owner, spender, amt);
    }

    function _spendAllowance(address owner, address spender, uint256 amt) internal virtual {
        uint256 current = allowed[owner][spender];
        if (current != type(uint256).max) {
            require(current >= amt, "Not enough allowance");
            unchecked {
                _approve(owner, spender, current - amt);
            }
        }
    }
}

contract OrangeManSummer is TokenBase {
    constructor() TokenBase("OrangeManSummer", "OMS") {
        _mint(_origin(), 100_000_000 * 10 ** 18); // Fixed: hardcoded decimals
    }
}

{
  "compilationTarget": {
    "OrangeManSummer.sol": "OrangeManSummer"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}