pragma solidity >=0.4.24 <0.6.0;

contract ERC20Basic {
  uint public totalSupply;
  event Transfer(address indexed from, address indexed to, uint value);
  function balanceOf(address who) public view returns (uint);
  function transfer(address to, uint value) public;
}

contract ERC20 is ERC20Basic {
  event Approval(address indexed owner, address indexed spender, uint value);
  function allowance(address owner, address spender) public view returns (uint);
  function transferFrom(address from, address to, uint value) public;
  function approve(address spender, uint value) public;
  
}

contract BasicToken is ERC20Basic {
  using SafeMath for uint;
  mapping(address => uint) public balances;
  function transfer(address _to, uint _value) public{
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    emit Transfer(msg.sender, _to, _value);
  }

  function balanceOf(address _owner) public view returns (uint balance) {
    return balances[_owner];
  }
}

contract StandardToken is BasicToken, ERC20 {  
  mapping (address => mapping (address => uint)) allowed;
  function transferFrom(address _from, address _to, uint _value) public {
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    emit Transfer(_from, _to, _value);
  }

  function approve(address _spender, uint _value) public{
    require((_value == 0) || (allowed[msg.sender][_spender] == 0)) ;
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
  }
  
  function allowance(address _owner, address _spender) public view returns (uint remaining) {
    return allowed[_owner][_spender];
  }
}

contract Erc20Token is StandardToken {

  string public name;
  string public symbol;
  uint8 public decimals ;
  // 18 decimals is the strongly suggested default, avoid changing it
  /**
   * @dev Contructor that gives msg.sender all of existing tokens.
   */
  constructor(uint256 initialSupply,string memory tokenName ,string memory tokenSymbol,uint8 tokenDecimals) public {
     if(tokenDecimals > 18)
        tokenDecimals = 18;
     decimals = tokenDecimals;
     totalSupply = initialSupply.mul(10 ** uint256(decimals)); // Update total supply with the decimal amount
     balances[msg.sender] = totalSupply;                   // Give the creator all initial tokens
     name = tokenName;                                      // Set the name for display purposes
     symbol = tokenSymbol;                                  // Set the symbol for display purposes
  }

}

library SafeMath {
    
  function mul(uint a, uint b) internal pure  returns (uint) {
    uint c = a * b;
    require(a == 0 || c / a == b);
    return c;
  }
  function div(uint a, uint b) internal pure returns (uint) {
    require(b > 0);
    uint c = a / b;
    require(a == b * c + a % b);
    return c;
  }
  function sub(uint a, uint b) internal pure returns (uint) {
    require(b <= a);
    return a - b;
  }
  function add(uint a, uint b) internal pure returns (uint) {
    uint c = a + b;
    require(c >= a);
    return c;
  }
  function max64(uint64 a, uint64 b) internal  pure returns (uint64) {
    return a >= b ? a : b;
  }
  function min64(uint64 a, uint64 b) internal  pure returns (uint64) {
    return a < b ? a : b;
  }
  function max256(uint256 a, uint256 b) internal  pure returns (uint256) {
    return a >= b ? a : b;
  }
  function min256(uint256 a, uint256 b) internal  pure returns (uint256) {
    return a < b ? a : b;
  }
}

{
  "compilationTarget": {
    "browser/ballot.sol": "Erc20Token"
  },
  "evmVersion": "petersburg",
  "libraries": {},
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}