contract TansalCoin is StandardToken{
 using SafeMath for uint;


    /* Public variables of the token */

    
    string public name;                   
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 
    string public version = 'V1.0';       //Version 0.1 standard. Just an arbitrary versioning scheme.
    uint256 private fulltoken;
    // This notifies clients about the amount burnt
    event Burn(address indexed from, uint256 value);


// ERC20Token

    constructor(
        ) public{
        fulltoken = 700000000;       
        decimals = 3;                            // Amount of decimals for display purposes
        _totalSupply = fulltoken.mul(10 ** uint256(decimals)); // Update total supply (100000 for example)
        balances[msg.sender] = _totalSupply;               // Give the creator all initial tokens (100000 for example)
        name = "Tansal Coin";                                   // Set the name for display purposes
        symbol = "TANSAL";                               // Set the symbol for display purposes
    }
     function() public {
         //not payable fallback function
          revert();
    }
        /**
     * Set allowance for other address and notify
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     * @param _extraData some extra information to send to the approved contract
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
           }
    }
    
      /// @return total amount of tokens
    function totalSupply() public view returns (uint256 supply){
        
        return _totalSupply;
    }

    /**
     * Destroy tokens
     *
     * Remove `_value` tokens from the system irreversibly
     *
     * @param _value the amount of money to burn
     */
    function burn(uint256 _value) onlyOwner public returns (bool success) {
        require(balances[msg.sender] >= _value);   // Check if the sender has enough
        balances[msg.sender] = balances[msg.sender].sub(_value);            // Subtract from the sender
        _totalSupply = _totalSupply.sub(_value);                      // Updates totalSupply
        emit Burn(msg.sender, _value);
        emit Transfer(msg.sender, address(0), _value);
        return true;
    }

    /**
     * Destroy tokens from other account
     *
     * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
     *
     * @param _from the address of the sender
     * @param _value the amount of money to burn
     */
    function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) {
        require(balances[_from] >= _value);                // Check if the targeted balance is enough
        require(_value <= allowed[_from][msg.sender]);    // Check allowance
        balances[_from] = balances[_from].sub(_value);                         // Subtract from the targeted balance
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);             // Subtract from the sender's allowance
        _totalSupply = _totalSupply.sub(_value);                              // Update totalSupply
        emit Burn(_from, _value);
        emit Transfer(_from, address(0), _value);
        return true;
    }
     function onlyPayForFuel() public payable onlyOwner{
        // Owner will pay in contract to bear the gas price if transactions made from contract
        
    }
    function withdrawEtherFromcontract(uint _amountInwei) public onlyOwner{
        require(address(this).balance > _amountInwei);
      require(msg.sender == owner);
      owner.transfer(_amountInwei);
     
    }
	 function withdrawTokensFromContract(uint _amountOfTokens) public onlyOwner{
        require(balances[this] >= _amountOfTokens);
        require(msg.sender == owner);
	    balances[msg.sender] = balances[msg.sender].add(_amountOfTokens);                        // adds the amount to owner's balance
        balances[this] = balances[this].sub(_amountOfTokens);                  // subtracts the amount from contract balance
		emit Transfer(this, msg.sender, _amountOfTokens);               // execute an event reflecting the change
     
    }
     /* Get the contract constant _name */
    function name() public view returns (string _name) {
        return name;
    }

    /* Get the contract constant _symbol */
    function symbol() public view returns (string _symbol) {
        return symbol;
    }

    /* Get the contract constant _decimals */
    function decimals() public view returns (uint8 _decimals) {
        return decimals;
    }
      
}
//The Contract Name
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
       }
}

/**
 * Set allowance for other address and notify
 *
 * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 * @param _extraData some extra information to send to the approved contract
 */