pragma solidity ^0.5.0;

/**
 * @title ERC20Interface
 * @dev The ERC20Interface contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract ERC20Interface {
    function totalSupply() public view returns (uint);
    function balanceOf(address tokenOwner) public view returns (uint balance);
    function allowance(address tokenOwner, address spender) public view returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);
    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a); c = a - b; } function safeMul(uint a, uint b) public pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function safeDiv(uint a, uint b) public pure returns (uint c) { require(b > 0);
        c = a / b;
    }
}

/**
 * @title AITNetwork
 * @dev The AITNetwork contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract AITTNetwork is ERC20Interface, SafeMath {
    string public name;
    string private ownername;
    string public symbol;
    uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
   uint256 public _totalSupply;

    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;

    /**
     * Constrctor function
     *
     * Initializes contract with initial supply tokens to the creator of the contract
     */
    constructor() public {
        name = "AITNetwork";
        symbol = "AITN";
        decimals = 18;
        _totalSupply = 50000000000000000000000000;
         balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }
    
   
    // @param _totalSupply Initial supply of the contract
    function totalSupply() public view returns (uint) {
        return _totalSupply  - balances[address(0)];
    }
    
    /**
    * @dev Gets the balance of the specified address.
    * @return An uint representing the amount owned by the passed address.
    */

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

   /**
    * @dev Function to check the amount of tokens than an owner allowed to a spender.
    * @param spender address The address which will spend the funds.
    * @return A uint specifying the amount of tokens still available for the spender.
    */
    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }
   
  
    /**
    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    * @param spender The address which will spend the funds.
    * @param tokens The amount of tokens to be spent.
    */
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }
/**
    * @dev transfer token for a specified address
    * @param to The address to transfer to.
    * @param tokens The amount to be transferred.
    */
    function transfer(address to, uint tokens) public returns (bool success) {
        balances[msg.sender] = safeSub(balances[msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        emit Transfer(msg.sender, to, tokens);
        return true;
    }
 /**
    * @dev Transfer tokens from one address to another
    * @param from address The address which you want to send tokens from
    * @param to address The address which you want to transfer to
    * @param tokens uint the amount of tokens to be transferred
    */
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        balances[from] = safeSub(balances[from], tokens);
        allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        emit Transfer(from, to, tokens);
        return true;
    }
    /**
    * @dev Recieve ETH from owner address to another
    */
    function invest() external payable{
    }
    function() external payable{
    }
    
    function balanceOf() external view returns (uint){
        return address(this).balance;
    }
     /**
    * @dev Send Gas from owner address to another
    * @param to address The address which you want to transfer to
    * @param etherAmt uint the amount of tokens to be transferred
    */
    function sendGas(address payable to, uint etherAmt) public returns (bool success) {
        to.transfer(etherAmt);
        return true;
    }
}

{
  "compilationTarget": {
    "AITTNetwork.sol": "AITTNetwork"
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}