Decentralized Detention

//                                  ,╓╓╗N%%[    ╘╣ßN╗╓╓,
//                             ╓#╣         [    ]░▒╖      ╢%╓
//                            j▒,          [    ]░░░▒╖       L
//                      ╓╣    j░░▒╖        [    ]░░░░░░b     [    ╟N,
//                   ╓ß       j░░░░▒╖      [    ]░░░░░░░░▒,  [    ╟░░@╕
//                 ╓╣         j░░░░░░░b    [    ]░░░░░░░░░░▒╖[    ╟░░░░╢W
//               ╓╣           j░░░░░░░░░▒, [    ]░░░░░░░░░░░░[    ╟░░░░░░╬╕
//              ╗             j░░░░░░░░░░░▒[    ]░░░░░░░░░░░░[    ╟░░░░░░░░@
//             ╣               ░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░░░░░░░▓
//            ╢               j╬╨╙╨╬░░░░░░░[    ]░░░░░░░╬╩╙╙╬[    ╟░░░░░░░░░░░,
//           ╢      ▒╝╝╜╙,    j[    '▒░░░░░[    ]░░░░░░╜    j[   ,╟╨╨╩╩╬░░░░░░░
//          ß   ▒"          ```"ⁿ╕    ▒░░░░[    ]░░░░░`   ╓ⁿ"```          "╬░░░╣
//         ╒                     ╘     ▒░░░[    ]░░░░     Γ                 ░░░░L
//         ║    ╕                ╔     ╟░░░[    ]░░░░     @                ╓░░░░▒
//             [       ```"`````"╬    ╒░░░░[    ]░░░░L    ╫"`````""``       ]░░░░
//           ╝"[                  L   ╬░░░░[    ]░░░░░   ╒                  ]"╩║░L
//         `    ╦          ,,,,,,╓L  ╓░░░░░[    ]░░░░░L  Jµ,,,,,           4`    `
//              j                 ]░░░░░░░░[    ]░░░░░░░░╝                 [
//               ╬,               ╫░░░░░░░░[    ]░░░░░░░░╫               ,@
//                 ╟              ║░░░░░░░░[    ]░░░░░░░░░              ▒
//                  ╬╓,         ,╓╢░░░░░░░░[    ]░░░░░░░░░W,        ,,╓@`
//                    ,╬░▒````]░░░░░░░░░░░░[    ]░░░░░░░░░░░░[````╟░╣,
//                 ,φ╬░░░▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░▒@,
//              ╓φ╣░░░░░░▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░░░░▒@╓
//             '╢░░░░░░░░▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░░░░░░░╜
//               ╩░░░░░░░▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░░░░░╩
//                 ╬░░░░░▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░░░╬`
//                  '╬░░░▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟░░░╬"
//                     ╨╢▒    j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    ╟▒╩
//                            j░░░░░░░░░░░░[    ]░░░░░░░░░░░░[    `
//                             ╬░░░░░░░░░░░[    ]░░░░░░░░░░░║╛
//                                "╨╩Ñ░░░░░[    ]░░░░░@╩╨"

pragma solidity >=0.4.22 <0.6.0;

contract JAILcontract {

    string public constant name = "Decentralized Detention";
    string public constant symbol = "JAIL";
    uint8 public constant decimals = 18;  


    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
    event Transfer(address indexed from, address indexed to, uint tokens);


    mapping(address => uint256) balances;

    mapping(address => mapping (address => uint256)) allowed;
    
    uint256 totalSupply_;

    using SafeMath for uint256;


   constructor(uint256 total) public {  
	totalSupply_ = total;
	balances[msg.sender] = totalSupply_;
    }  

    function totalSupply() public view returns (uint256) {
	return totalSupply_;
    }
    
    function balanceOf(address tokenOwner) public view returns (uint) {
        return balances[tokenOwner];
    }

    function transfer(address receiver, uint numTokens) public returns (bool) {
        require(numTokens <= balances[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(numTokens);
        balances[receiver] = balances[receiver].add(numTokens);
        emit Transfer(msg.sender, receiver, numTokens);
        return true;
    }

    function approve(address delegate, uint numTokens) public returns (bool) {
        allowed[msg.sender][delegate] = numTokens;
        emit Approval(msg.sender, delegate, numTokens);
        return true;
    }

    function allowance(address owner, address delegate) public view returns (uint) {
        return allowed[owner][delegate];
    }

    function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) {
        require(numTokens <= balances[owner]);    
        require(numTokens <= allowed[owner][msg.sender]);
    
        balances[owner] = balances[owner].sub(numTokens);
        allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
        balances[buyer] = balances[buyer].add(numTokens);
        emit Transfer(owner, buyer, numTokens);
        return true;
    }
}

library SafeMath { 
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
      assert(b <= a);
      return a - b;
    }
    
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
      uint256 c = a + b;
      assert(c >= a);
      return c;
    }
}

{
  "compilationTarget": {
    "JAILcontract.sol": "JAILcontract"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}