title: Total Supply reading in as zero for deployed Ether Token contract
body: <p>I tried editing this contract I made dozens of time with Ethereum's solidity platform and it keeps reading in the total supply as zero. Infact here are the variables it reads in:</p>
  
  <ol>
  <li>name    Sample Token string</li>
  <li>totalSupply    0 uint256</li>
  <li>decimals    3 uint8</li>
  <li>_totalSupply    10000000 uint256</li>
  <li>RATE    350 uint256</li>
  <li>symbol SAMP string</li>
  </ol>
  
  <p>I did constant returns total supply, and I know there is an error but can't figure out where. I need help fixing this issue so the total supply reads in the actual amount, and have tried 15 times both on the regular and test network.</p>
  
  <p>Code:</p>
  
  <pre><code>    pragma solidity ^0.4.11;
  
  interface IERC20 {
      function totalSupply() constant returns (uint256 totalSupply);
      function balanceOf(address _owner) constant returns (uint256 balance);
      function transfer(address _to, uint256 _value) returns (bool success);
      function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
      function approve (address _spender, uint256 _value) returns (bool success);
      function allowance(address _owner, address _spender) constant returns (uint256 remaining);
      event Transfer(address indexed _from, address indexed_to, uint256 _value);
      event Approval(address indexed_owner, address indexed_spender, uint256 _value);
  }
  contract SampleToken is IERC20 {
  
      using SafeMath for uint256;
      uint public _totalSupply = 10000000;
  
      string public constant symbol ="SAMP";
      string public constant name = "Sample Token";
      uint8 public constant decimals = 3;
  
      //1 ether = 350 SAMP
      uint256 public constant RATE = 350;
  
      address public owner;
  
  
  
      mapping(address =&gt; uint256) balances;
      mapping(address =&gt; mapping(address =&gt; uint256)) allowed;
  
      function () payable {
          createTokens();
      }
  
      function SampleToken () {
          owner = msg.sender;
      }
  
      function createTokens() payable {
          require(msg.value &gt; 0);
  
          uint256 tokens = msg.value.mul(RATE);
          balances[msg.sender] = balances[msg.sender].add(tokens);
          _totalSupply = _totalSupply.add(tokens);
  
          owner.transfer(msg.value);
      }
  
      function totalSupply() constant returns (uint256 _totalSupply) {
          return _totalSupply;
  
      }
  
      function balanceOf(address _owner) constant returns (uint256 balance) {
          return balances[_owner]; 
      }
  
      function transfer(address _to, uint256 _value) returns (bool success) {
          require(
            balances[msg.sender] &gt;= _value
            &amp;&amp; _value &gt; 0
          );
          balances[msg.sender] -= balances[msg.sender].sub(_value);
          balances[_to] = balances[_to].add(_value);
          Transfer(msg.sender, _to, _value);
          return true;
      }
  
      function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
          require(
              allowed[_from][msg.sender] &gt;= _value
              &amp;&amp; balances[_from] &gt;= _value
              &amp;&amp; _value &gt; 0
          );
          balances[_from] = balances[_from].sub( _value);
          balances[_to] = balances [_to].add(_value);
          allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
          Transfer(_from, _to, _value);
          return true;
      }
  
      function approve (address _spender, uint256 _value) returns (bool success) {
          allowed[msg.sender][_spender] =_value;
          Approval(msg.sender, _spender, _value);
          return true;
      }
  
      function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
          return allowed[_owner][_spender];
      }
  
      event Transfer(address indexed _from, address indexed_to, uint256 _value);
      event Approval(address indexed_owner, address indexed_spender, uint256 _value);
      function mul(uint256 a, uint256 b) internal constant returns (uint256) {
      uint256 c = a * b;
      assert(a == 0 || c / a == b);
      return c;
    }
    function bytes32ToString(bytes32 x) constant returns (string) {
          bytes memory bytesString = new bytes(32);
          uint charCount = 0;
          for (uint j = 0; j &lt; 32; j++) {
              byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
              if (char != 0) {
                  bytesString[charCount] = char;
                  charCount++;
              }
          }
          bytes memory bytesStringTrimmed = new bytes(charCount);
          for (j = 0; j &lt; charCount; j++) {
              bytesStringTrimmed[j] = bytesString[j];
          }
          return string(bytesStringTrimmed);
      }
  
  }
  
  library SafeMath {
    function mul(uint256 a, uint256 b) internal constant returns (uint256) {
      uint256 c = a * b;
      assert(a == 0 || c / a == b);
      return c;
    }
  
    function div(uint256 a, uint256 b) internal constant returns (uint256) {
      // assert(b &gt; 0); // Solidity automatically throws when dividing by 0
      uint256 c = a / b;
      // assert(a == b * c + a % b); // There is no case in which this doesn't hold
      return c;
    }
  
    function sub(uint256 a, uint256 b) internal constant returns (uint256) {
      assert(b &lt;= a);
      return a - b;
    }
  
    function add(uint256 a, uint256 b) internal constant returns (uint256) {
      uint256 c = a + b;
      assert(c &gt;= a);
      return c;
    }
  }
  </code></pre>