contract BaseToken is ERC20 {

    
    string public standard = 'Token 1.0';
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    uint256 public initialSupply;


    address public owner;
    
    

    /* This creates an array with all balances */
    mapping( address => uint256) public balanceOf;
    mapping( uint => address) public accountIndex;
    mapping (address => bool) public frozenAccount;
    uint accountCount;
    
   
    mapping(address => mapping(address => uint256)) public allowance;

    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint value);
    event FrozenFunds ( address target, bool frozen );

    /* This notifies clients about the amount burnt */
   // event Burn(address indexed from, uint256 value);

    /* Initializes contract with initial supply tokens to the creator of the contract */
    function BaseToken( uint256 _initialSupply, uint8 _decimalUnits, string _name, string _symbol, address _owner ) {

        appendTokenHolders( _owner );
        balanceOf[ _owner ] = _initialSupply; // Give the creator all initial tokens
        totalSupply = _initialSupply; // Update total supply
        initialSupply = _initialSupply;
        name = _name; // Set the name for display purposes
        symbol = _symbol; // Set the symbol for display purposes
        decimals = _decimalUnits; // Amount of decimals for display purposes
        owner = msg.sender;
            

    }

    // Function allows for external access to tokenHoler's Balance
    function balanceOf(address tokenHolder) constant returns(uint256) {

        return balanceOf[tokenHolder];
    }

    function totalSupply() constant returns(uint256) {

        return totalSupply;
    }

    // Function allows for external access to number of accounts that are holding or once held Studio
    //tokens

    function getAccountCount() constant returns(uint256) {

        return accountCount;
    }

    //function allows for external access to tokenHolders
    function getAddress(uint slot) constant returns(address) {

        return accountIndex[slot];

    }

    // checks to see if tokenholder has a balance, if not it appends the tokenholder to the accountIndex
   // which the getAddress() can later access externally

    function appendTokenHolders(address tokenHolder) private {

        if (balanceOf[tokenHolder] == 0) {
            accountIndex[accountCount] = tokenHolder;
            accountCount++;
        }

    }

    /* Send coins */
    function transfer(address _to, uint256 _value) returns(bool ok) {
        
        if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
        if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
       //if ( frozenAccount[ msg.sender ]  ) throw;
        appendTokenHolders(_to);
        balanceOf[msg.sender] -= _value; // Subtract from the sender
        balanceOf[_to] += _value; // Add the same to the recipient
        Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
        return true;
        
    }

    /* Allow another contract to spend some tokens in your behalf */
    function approve(address _spender, uint256 _value) returns(bool success) {
        
        allowance[msg.sender][_spender] = _value;
        Approval( msg.sender ,_spender, _value);
        return true;
        
    }

    /* Approve and then communicate the approved contract in a single tx */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success) {
        
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
        
    }

    function allowance(address _owner, address _spender) constant returns(uint256 remaining) {
        
        return allowance[_owner][_spender];
    
        
    }

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns(bool success) {
        
        if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
        if (balanceOf[_from] < _value) throw; // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw; // Check allowance
        //if ( frozenAccount[ _from ]  ) throw;
        appendTokenHolders(_to);
        balanceOf[_from] -= _value; // Subtract from the sender
        balanceOf[_to] += _value; // Add the same to the recipient
        allowance[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
    }
  /*
    function burn(uint256 _value) returns(bool success) {
        
        if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
        balanceOf[msg.sender] -= _value; // Subtract from the sender
        totalSupply -= _value; // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    
        
    }

    function burnFrom(address _from, uint256 _value) returns(bool success) {
        
        if (balanceOf[_from] < _value) throw; // Check if the sender has enough
        if (_value > allowance[_from][msg.sender]) throw; // Check allowance
        if ( (totalSupply - _value) <  ( initialSupply / 2 )) throw;
        balanceOf[_from] -= _value; // Subtract from the sender
        totalSupply -= _value; // Updates totalSupply
        Burn(_from, _value);
        return true;
        
    }
*/
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

   
    /*
    function freezeAccount ( address _account ) public onlyOwner {
        
        frozenAccount [ _account ] = true;
        FrozenFunds ( _account , true );
        
        
    }
    
    function unfreezeAccount ( address _account ) public onlyOwner{
        
         frozenAccount [ _account ] = false;
         FrozenFunds ( _account , false );
        
        
    }
    */
    
   
    
}
function getAddress(uint slot) constant returns(address) {

    return accountIndex[slot];

}

//function allows for external access to tokenHolders