title: Remix error The transaction has been reverted to the initial state
body: <p>I am testing my smart contract on remix. While testing Start Airdrop function is running successfully but as I approach getAirrop function I receive error :</p>
  <blockquote>
  <p>transact to getAirdrop errored: VM error: revert. revert The transaction has been reverted to the initial state. Note: The called function should be payable if you send value and the value you send should be less than your current balance. Debug the transaction to get more information.</p>
  </blockquote>
  <p>my smart contract code is :</p>
  <pre><code>/**
   *Submitted for verification at BscScan.com on 2021-05-29
  */
  
  // SPDX-License-Identifier: GPL-3.0
  
  pragma solidity &gt;=0.5.10;
  
  library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
      c = a + b;
      require(c &gt;= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
      require(b &lt;= a);
      c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c) {
      c = a * b;
      require(a == 0 || c / a == b);
    }
    function div(uint a, uint b) internal pure returns (uint c) {
      require(b &gt; 0);
      c = a / b;
    }
  }
  
  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);
  }
  
  contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
  }
  
  contract Owned {
    address public owner;
    address public newOwner;
  
    event OwnershipTransferred(address indexed _from, address indexed _to);
  
    constructor() public {
      owner = msg.sender;
    }
  
    modifier onlyOwner {
      require(msg.sender == owner);
      _;
    }
  
    function transferOwnership(address _newOwner) public onlyOwner {
      newOwner = _newOwner;
    }
    function acceptOwnership() public {
      require(msg.sender == newOwner);
      emit OwnershipTransferred(owner, newOwner);
      owner = newOwner;
      newOwner = address(0);
    }
  }
  
  contract TokenERC20 is ERC20Interface, Owned{
    using SafeMath for uint;
  
    string public symbol;
    string public name;
    uint8 public decimals;
    uint _totalSupply;
  
    mapping(address =&gt; uint) balances;
    mapping(address =&gt; mapping(address =&gt; uint)) allowed;
  
    constructor() public {
      symbol = &quot;SHIB&quot;;
      name = &quot;Shiba&quot;;
      decimals = 0;
      _totalSupply =  1000000000000000;
      balances[owner] = _totalSupply;
      emit Transfer(address(0), owner, _totalSupply);
    }
  
    function totalSupply() public view returns (uint) {
      return _totalSupply.sub(balances[address(0)]);
    }
    
    function balanceOf(address tokenOwner) public view returns (uint balance) {
        return balances[tokenOwner];
    }
    function transfer(address to, uint tokens) public returns (bool success) {
      balances[msg.sender] = balances[msg.sender].sub(tokens);
      balances[to] = balances[to].add(tokens);
      emit Transfer(msg.sender, to, tokens);
      return true;
    }
    function approve(address spender, uint tokens) public returns (bool success) {
      allowed[msg.sender][spender] = tokens;
      emit Approval(msg.sender, spender, tokens);
      return true;
    }
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
      balances[from] = balances[from].sub(tokens);
      allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
      balances[to] = balances[to].add(tokens);
      emit Transfer(from, to, tokens);
      return true;
    }
    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
      return allowed[tokenOwner][spender];
    }
    function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
      allowed[msg.sender][spender] = tokens;
      emit Approval(msg.sender, spender, tokens);
      ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
      return true;
    }
    function () external payable {
      revert();
    }
  }
  
  contract Shiba is TokenERC20 {
  
    
    uint256 public aSBlock; 
    uint256 public aEBlock; 
    uint256 public aCap; 
    uint256 public aTot; 
    uint256 public aAmt; 
  
   
    uint256 public sSBlock; 
    uint256 public sEBlock; 
    uint256 public sCap; 
    uint256 public sTot; 
    uint256 public sChunk; 
    uint256 public sPrice; 
  
    function getAirdrop(address _refer) public returns (bool success){
      require(aSBlock &lt;= block.number &amp;&amp; block.number &lt;= aEBlock);
      require(aTot &lt; aCap || aCap == 0);
      aTot ++;
      if(msg.sender != _refer &amp;&amp; balanceOf(_refer) != 0 &amp;&amp; _refer != 0x0000000000000000000000000000000000000000){
        balances[address(this)] = balances[address(this)].sub(aAmt / 1);
        balances[_refer] = balances[_refer].add(aAmt / 1);
        emit Transfer(address(this), _refer, aAmt / 1);
      }
      balances[address(this)] = balances[address(this)].sub(aAmt);
      balances[msg.sender] = balances[msg.sender].add(aAmt);
      emit Transfer(address(this), msg.sender, aAmt);
      return true;
    }
  
    function tokenSale(address _refer) public payable returns (bool success){
      require(sSBlock &lt;= block.number &amp;&amp; block.number &lt;= sEBlock);
      require(sTot &lt; sCap || sCap == 0);
      uint256 _eth = msg.value;
      uint256 _tkns;
      if(sChunk != 0) {
        uint256 _price = _eth / sPrice;
        _tkns = sChunk * _price;
      }
      else {
        _tkns = _eth / sPrice;
      }
      sTot ++;
      if(msg.sender != _refer &amp;&amp; balanceOf(_refer) != 0 &amp;&amp; _refer != 0x0000000000000000000000000000000000000000){
        balances[address(this)] = balances[address(this)].sub(_tkns / 2);
        balances[_refer] = balances[_refer].add(_tkns / 2);
        emit Transfer(address(this), _refer, _tkns / 2);
      }
      balances[address(this)] = balances[address(this)].sub(_tkns);
      balances[msg.sender] = balances[msg.sender].add(_tkns);
      emit Transfer(address(this), msg.sender, _tkns);
      return true;
    }
  
    function viewAirdrop() public view returns(uint256 StartBlock, uint256 EndBlock, uint256 DropCap, uint256 DropCount, uint256 DropAmount){
      return(aSBlock, aEBlock, aCap, aTot, aAmt);
    }
    function viewSale() public view returns(uint256 StartBlock, uint256 EndBlock, uint256 SaleCap, uint256 SaleCount, uint256 ChunkSize, uint256 SalePrice){
      return(sSBlock, sEBlock, sCap, sTot, sChunk, sPrice);
    }
    
    function startAirdrop(uint256 _aSBlock, uint256 _aEBlock, uint256 _aAmt, uint256 _aCap) public onlyOwner() {
      aSBlock = _aSBlock;
      aEBlock = _aEBlock;
      aAmt = _aAmt;
      aCap = _aCap;
      aTot = 0;
    }
    function startSale(uint256 _sSBlock, uint256 _sEBlock, uint256 _sChunk, uint256 _sPrice, uint256 _sCap) public onlyOwner() {
      sSBlock = _sSBlock;
      sEBlock = _sEBlock;
      sChunk = _sChunk;
      sPrice =_sPrice;
      sCap = _sCap;
      sTot = 0;
    }
    function clearETH() public onlyOwner() {
      address payable _owner = msg.sender;
      _owner.transfer(address(this).balance);
    }
    function() external payable {
  
    }
  
  }
  </code></pre>