Code

pragmasolidity >=0.4.22<0.6.0;

contractowned{
  addresspublicowner;
  constructor()public{
    owner=msg.sender;
  }
  
  modifieronlyOwner{
    require(msg.sender==owner);
    _;
  }
  function transferOwnership(addressnewOwner)onlyOwnerpublic{
    owner=newOwner;
    }
 }
  interfacetokenRecipient{functionreceiveApproval(address_from,uint256_value,address_token,bytescalldata_extraData)external;}
  
contractTokenERC20{
  // Public variables of the token
  stringpublicname;
  stringpublicsymbol;
  uint8publicdecimals=18;
  // 18 decimals is the strongly suggested default, avoid changing it
  uint256publictotalSupply;
  
  // This creates an array with all balances
  mapping(address=>uint256)publicbalanceOf;
  mapping(address=>mapping(address=>uint256))publicallowance;
  
  // This generates a public event on the blockchain that will notify clients
  eventTransfer(addressindexedfrom,addressindexedto,uint256value);
  
  // This generates a public event on the blockchain that will notify clients
eventApproval(addressindexed_owner,addressindexed_spender,uint256_value);
  
  // This notifies clients about the amount burnt
   eventBurn(addressindexedfrom,uint256value);
  
  /**     
  * Constrctor function     
  *     
  * Initializes contract with initial supply tokens to the creator of the contract     */
  
  constructor(
    uint256initialSupply,
    stringmemorytokenName,
    stringmemorytokenSymbol
    )
  public{
  totalSupply=initialSupply * 10 ** uint256(decimals);
  // Update total supply with the decimal amount
  balanceOf[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
  }
  
  /**     
  * Internal transfer, only can be called by this contract     
  */
  function_transfer(address_from,address_to,uint_value)internal{
    // Prevent transfer to 0x0 address. Use burn() instead
    require(_to != address(0x0));
    // Check if the sender has enough
    require(balanceOf[_from] >= _value);
    // Check for overflows
    require(balanceOf[_to]+_value>balanceOf[_to]);
    // Save this for an assertion in the future
    uintpreviousBalances=balanceOf[_from]+balanceOf[_to];
    // Subtract from the sender
    balanceOf[_from]-=_value;
    // Add the same to the recipient
    balanceOf[_to]+=_value;
    emitTransfer(_from,_to,_value);
    // Asserts are used to use static analysis to find bugs in your code. They should never fail
    assert(balanceOf[_from]+balanceOf[_to]==previousBalances);
    }
    
    /**     
    * Transfer tokens     
    *     
    * Send `_value` tokens to `_to` from your account     
    *     
    * @param _to The address of the recipient     
    * @param _value the amount to send     
    */
    
    function transfer(address_to,uint256_value)public returns(boolsuccess){
    _transfer(msg.sender,_to,_value);
    return true;
    }
    
    /**     
    * Transfer tokens from other address     
    *     
    * Send `_value` tokens to `_to` in behalf of `_from`     
    *     
    * @param _from The address of the sender     
    * @param _to The address of the recipient     
    * @param _value the amount to send     
    */
    function transferFrom(address_from,address_to,uint256_value)public returns(boolsuccess){
    require(_value <= allowance[_from][msg.sender]);
    // Check allowance
    allowance[_from][msg.sender]-=_value;_
    transfer(_from,_to,_value);
    return true;
    }
    
    /**     
    * Set allowance for other address     
    *     
    * Allows `_spender` to spend no more than `_value` tokens in your behalf     
    *     
    * @param _spender The address authorized to spend     
    * @param _value the max amount they can spend     
    */
    function approve(address_spender,uint256_value)
    public returns(boolsuccess){
    allowance[msg.sender][_spender]=_value;
    emitApproval(msg.sender,_spender,_value);
    returntrue;
    }
    
    /**     
    * 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,bytesmemory_extraData) 
    public 
    returns(boolsuccess){tokenRecipientspender=tokenRecipient(_spender);
    if(approve(_spender,_value)){
   spender.receiveApproval(msg.sender,_value,address(this),_extraData);
      return true;
      }
      }
      
      /**     
      * Destroy tokens     
      *     
      * Remove `_value` tokens from the system irreversibly     
      *     
      * @param _value the amount of money to burn     
      */
      
      function burn(uint256_value)public returns(boolsuccess){
      require(balanceOf[msg.sender] >= _value);
      // Check if the sender has enough
      balanceOf[msg.sender]-=_value;
      // Subtract from the sender
      totalSupply-=_value;
      // Updates totalSupply
      emit Burn(msg.sender,_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)
      public returns(boolsuccess){
      require(balanceOf[_from] >= _value);
      // Check if the targeted balance is enough
      require(_value <= allowance[_from][msg.sender]);
      // Check allowance
      balanceOf[_from]-=_value;
      // Subtract from the targeted balance
      allowance[_from][msg.sender]-=_value;
      // Subtract from the sender's allowance
      totalSupply-=_value;
      // Update totalSupply
      emit Burn(_from,_value);
      returntrue;
      }
    }
    
 /******************************************//*       
 ADVANCED TOKEN STARTS HERE       *//******************************************/
 
 contract SibiCoin isowned,TokenERC20{
     uint256publicsellPrice;
     uint256publicbuyPrice;
     
     mapping(address=>bool)publicfrozenAccount;
      
      /* This generates a public event on the blockchain that will notify clients 
      */
      event FrozenFunds(addresstarget,boolfrozen);
      
      /* Initializes contract with initial supply tokens to the creator of the contract */
      
      constructor(
        uint256initialSupply,
        stringmemorytokenName,
        stringmemorytokenSymbol)
      TokenERC20(initialSupply,tokenName,tokenSymbol)public{}
      
      /* Internal transfer, only can be called by this contract */
      
      function_transfer(address_from,address_to,uint_value)internal{
      require(_to != address(0x0));
      // Prevent transfer to 0x0 address. Use burn() instead
      require(balanceOf[_from] >= _value);
      // Check if the sender has enough
      require(balanceOf[_to]+_value >= balanceOf[_to]);
      // Check for overflows
      require(!frozenAccount[_from]);
      // Check if sender is frozen
      require(!frozenAccount[_to]);
      // Check if recipient is frozen
      balanceOf[_from]-=_value;
      // Subtract from the sender
      balanceOf[_to]+=_value;
      // Add the same to the recipient
      emit Transfer(_from,_to,_value);
      }
      
      /// @notice Create `mintedAmount` tokens and send it to `target`
      /// @param target Address to receive the tokens
      /// @param mintedAmount the amount of tokens it will receive
      
       function mintToken(address target,uint256mintedAmount)
       onlyOwner public{
         balanceOf[target]+=mintedAmount;
         totalSupply+=mintedAmount;
         emit Transfer(address(0),address(this),mintedAmount);
         emit Transfer(address(this),target,mintedAmount);
         }
         
  /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
  /// @param target Address to be frozen/// @param freeze either to freeze it or not
  
  function freezeAccount(addresstarget,boolfreeze)onlyOwner public{
    frozenAccount[target]=freeze;
    emit FrozenFunds(target,freeze);
  }
  
  /// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
  /// @param newSellPrice Price the users can sell to the contract
  /// @param newBuyPrice Price users can buy from the contract
  
  function setPrices(uint256newSellPrice, uint256newBuyPrice)
  onlyOwner public{
  sellPrice=newSellPrice;
  buyPrice=newBuyPrice;
  }
  /// @notice Buy tokens from contract by sending ether
  
  function buy()payablepublic{uintamount=msg.value / buyPrice;
  // calculates the amount
  _transfer(address(this),msg.sender,amount);
  // makes the transfers
  }
  
      /// @notice Sell `amount` tokens to contract
      /// @param amount amount of tokens to be sold
      
      function sell(uint256amount)public{addressmyAddress=address(this);
      require(myAddress.balance >= amount * sellPrice);
      // checks if the contract has enough ether to buy
      _transfer(msg.sender,address(this),amount);
      // makes the transfers
      msg.sender.transfer(amount * sellPrice);
      // sends ether to the seller. It's important to do this last to avoid recursion attacks
      }
   }