Bitcoin Forum

pragma solidity ^0.4.10; 

contract minereum { 

string public name; 
string public symbol; 
uint8 public decimals; 
uint256 public initialSupplyPerAddress;
uint256 public initialBlockCount;
uint256 public rewardPerBlockPerAddress;
uint256 public totalGenesisAddresses;
uint256 private availableAmount;
uint256 private availableBalance;
uint256 private minedBlocks;
uint256 private totalMaxAvailableAmount;
uint256 private balanceOfAddress;



mapping (address => uint256) public balanceOf; 
mapping (address => bool) public genesisAddress; 

event Transfer(address indexed from, address indexed to, uint256 value); 

function minereum() { 

name = "minereum"; 
symbol = "MNE"; 
decimals = 8; 
initialSupplyPerAddress = 3200000000000;
initialBlockCount = 3516521;
rewardPerBlockPerAddress = 32000;
totalGenesisAddresses = 4269;

balanceOf[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = initialSupplyPerAddress;
genesisAddress[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = true;
balanceOf[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = initialSupplyPerAddress;
genesisAddress[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = true;
balanceOf[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = initialSupplyPerAddress;
genesisAddress[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = true;
balanceOf[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = initialSupplyPerAddress;
genesisAddress[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = true;
balanceOf[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = initialSupplyPerAddress;
genesisAddress[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = true;
...
function currentEthBlock() constant returns (uint256 blockNumber)
{
	return block.number;
}

function currentBlock() constant returns (uint256 blockNumber)
{
	return block.number - initialBlockCount;
}

function availableBalanceOf(address _address) constant returns (uint256 Balance)
{
	if (genesisAddress[_address])
	{
		minedBlocks = block.number - initialBlockCount;
		
		if (minedBlocks >= 100000000) return balanceOf[_address];
		
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
		
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[_address] - totalMaxAvailableAmount;
		
		return availableBalance;
	}
	else
		return balanceOf[_address];
}

function totalSupply() constant returns (uint256 totalSupply)
{	
	minedBlocks = block.number - initialBlockCount;
	availableAmount = rewardPerBlockPerAddress*minedBlocks;
	return availableAmount*totalGenesisAddresses;
}

function maxTotalSupply() constant returns (uint256 maxSupply)
{	
	return initialSupplyPerAddress*totalGenesisAddresses;
}

function transfer(address _to, uint256 _value) { 

if (genesisAddress[_to]) throw;

if (balanceOf[msg.sender] < _value) throw; 

if (balanceOf[_to] + _value < balanceOf[_to]) throw; 

if (genesisAddress[msg.sender])
{
	minedBlocks = block.number - initialBlockCount;
	if (minedBlocks < 100000000)
	{
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
			
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[msg.sender] - totalMaxAvailableAmount;
			
		if (_value > availableBalance) throw;
	}
}

balanceOf[msg.sender] -= _value; 
balanceOf[_to] += _value; 
Transfer(msg.sender, _to, _value); 
} 
}

pragma solidity ^0.4.11;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}
 
contract Autoria is SafeMath {
    // ERC20 variables
    string public constant symbol = "AUT";
    string public constant name = "Autorium";
    uint8 public constant decimals = 18;
    uint256 public _totalSupply = 100000000000000000000000000;

    // Autoria specific variables
    uint256 creationTime = now;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 public earlySalePrice = 1000000000000000000;
    uint256 public regularSalePrice = 1300000000000000000;
    uint256 public exchangeRate = 17500;
    uint256 public freeTokenSupply = _totalSupply;
    uint256 public retainedSupplyPercentage = 30;
    
    // Owner of this contract
    address issuer;
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    // Balances and aquifers for each account
    mapping(address => uint256) public balances;
    mapping(address => uint256) public aquifers;
    mapping(address => uint256) public initialStake;
    
    // Flag for whether or not address is a well
    mapping (address => bool) public isWell;
 
    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;
 
    // Functions with this modifier can only be executed by the owner
    // modifiers for permissions on functions
    modifier onlyIssuer() { if (msg.sender == issuer) _; }
    modifier onlyInvestor() { if (msg.sender != issuer) _; }
 
    function aquiferOf(address _owner) public constant returns (uint256 tokens) { return aquifers[_owner]; }
    function getIssuerAddress() public constant returns(address issuerAddress) { return issuer; }
    function getFreeTokenSupply() public constant returns(uint256 tokens) { return freeTokenSupply; }
    function getRetainedSupplyPercentage() public constant returns(uint256 percentage) { return retainedSupplyPercentage; }
    function getCreationTime() public constant returns(uint256 time) { return creationTime; }
    function getGensisBlock() public constant returns(uint256 block) { return gensisBlock; }
    function getBlocksUntilExhaustion() public constant returns(uint256 blocks) { return blocksUntilExhaustion; }
    function getCurrentBlock() public returns(uint256 blocks) { return block.number; }
    
    // Constructor
    function Autoria() {
        // Establish the Issuer
        issuer = msg.sender;
        balances[msg.sender] += 30000000000000000000000000;
        aquifers[msg.sender] = 0;
        freeTokenSupply -= 30000000000000000000000000;
        // Send retainer coins to Issuer
    }

    // ICO Methods
    function paymentProcessor() onlyInvestor payable returns(uint256 tokens){
        
        // see if ICO is still running
        if (freeTokenSupply <= 0) { return 0; }
        if (isWell[msg.sender]) { return 0; }
        // determine exchange rate of AUT (increases if over 1 week after inception)
        uint price = earlySale() ? earlySalePrice : regularSalePrice;

        // set up some basic mapping stuff that we know will exist
        isWell[msg.sender] = true;

        uint requestedTokens = (msg.value / price) * exchangeRate;
        if (requestedTokens > freeTokenSupply) {
            return 0;
        }
        else {
            // send tokents to user
            aquifers[msg.sender] += requestedTokens;
            initialStake[msg.sender] += requestedTokens;
            // send eth to issuer
            issuer.transfer(msg.value);
            // update free token supply
            freeTokenSupply -= requestedTokens;
            return(requestedTokens);
        }
    }

    function earlySale() constant returns (bool ifSo) {
        if ((now - creationTime) > 1 weeks) return false;
        return true;
    }

    // ERC20 Methods 
    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
        return totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount 
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) public returns (bool success) {
        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    // Autoria specific methods
    
    function availableDraw(address _owner) constant returns(uint256) {
        uint256 x = (initialStake[_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        return aquifers[_owner] - (initialStake[_owner] - x);
    }
    
    function drawWell(address _owner) returns(bool) {
        if (isWell[_owner]) {
            //initial aquifer amount - initial aquifer amount 
            uint256 draw = availableDraw(_owner);
            if (draw > 0 && aquifers[_owner] > 0) {
                balances[_owner] += draw;
                aquifers[_owner] -= draw;
            }
            return true;
        }
        return false;
    }
    
}

pragma solidity ^0.4.10; 

contract minereum { 

string public name; 
string public symbol; 
uint8 public decimals; 
uint256 public initialSupplyPerAddress;
uint256 public initialBlockCount;
uint256 public rewardPerBlockPerAddress;
uint256 public totalGenesisAddresses;
uint256 private availableAmount;
uint256 private availableBalance;
uint256 private minedBlocks;
uint256 private totalMaxAvailableAmount;
uint256 private balanceOfAddress;



mapping (address => uint256) public balanceOf; 
mapping (address => bool) public genesisAddress; 

event Transfer(address indexed from, address indexed to, uint256 value); 

function minereum() { 

name = "minereum"; 
symbol = "MNE"; 
decimals = 8; 
initialSupplyPerAddress = 3200000000000;
initialBlockCount = 3516521;
rewardPerBlockPerAddress = 32000;
totalGenesisAddresses = 4269;

balanceOf[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = initialSupplyPerAddress;
genesisAddress[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = true;
balanceOf[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = initialSupplyPerAddress;
genesisAddress[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = true;
balanceOf[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = initialSupplyPerAddress;
genesisAddress[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = true;
balanceOf[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = initialSupplyPerAddress;
genesisAddress[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = true;
balanceOf[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = initialSupplyPerAddress;
genesisAddress[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = true;
...
function currentEthBlock() constant returns (uint256 blockNumber)
{
	return block.number;
}

function currentBlock() constant returns (uint256 blockNumber)
{
	return block.number - initialBlockCount;
}

function availableBalanceOf(address _address) constant returns (uint256 Balance)
{
	if (genesisAddress[_address])
	{
		minedBlocks = block.number - initialBlockCount;
		
		if (minedBlocks >= 100000000) return balanceOf[_address];
		
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
		
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[_address] - totalMaxAvailableAmount;
		
		return availableBalance;
	}
	else
		return balanceOf[_address];
}

function totalSupply() constant returns (uint256 totalSupply)
{	
	minedBlocks = block.number - initialBlockCount;
	availableAmount = rewardPerBlockPerAddress*minedBlocks;
	return availableAmount*totalGenesisAddresses;
}

function maxTotalSupply() constant returns (uint256 maxSupply)
{	
	return initialSupplyPerAddress*totalGenesisAddresses;
}

function transfer(address _to, uint256 _value) { 

if (genesisAddress[_to]) throw;

if (balanceOf[msg.sender] < _value) throw; 

if (balanceOf[_to] + _value < balanceOf[_to]) throw; 

if (genesisAddress[msg.sender])
{
	minedBlocks = block.number - initialBlockCount;
	if (minedBlocks < 100000000)
	{
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
			
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[msg.sender] - totalMaxAvailableAmount;
			
		if (_value > availableBalance) throw;
	}
}

balanceOf[msg.sender] -= _value; 
balanceOf[_to] += _value; 
Transfer(msg.sender, _to, _value); 
} 
}

pragma solidity ^0.4.11;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}
 
contract Autoria is SafeMath {
    // ERC20 variables
    string public constant symbol = "AUT";
    string public constant name = "Autorium";
    uint8 public constant decimals = 18;
    uint256 public _totalSupply = 100000000000000000000000000;

    // Autoria specific variables
    uint256 creationTime = now;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 public earlySalePrice = 1000000000000000000;
    uint256 public regularSalePrice = 1300000000000000000;
    uint256 public exchangeRate = 17500;
    uint256 public freeTokenSupply = _totalSupply;
    uint256 public retainedSupplyPercentage = 30;
    
    // Owner of this contract
    address issuer;
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    // Balances and aquifers for each account
    mapping(address => uint256) public balances;
    mapping(address => uint256) public aquifers;
    mapping(address => uint256) public initialStake;
    
    // Flag for whether or not address is a well
    mapping (address => bool) public isWell;
 
    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;
 
    // Functions with this modifier can only be executed by the owner
    // modifiers for permissions on functions
    modifier onlyIssuer() { if (msg.sender == issuer) _; }
    modifier onlyInvestor() { if (msg.sender != issuer) _; }
 
    function aquiferOf(address _owner) public constant returns (uint256 tokens) { return aquifers[_owner]; }
    function getIssuerAddress() public constant returns(address issuerAddress) { return issuer; }
    function getFreeTokenSupply() public constant returns(uint256 tokens) { return freeTokenSupply; }
    function getRetainedSupplyPercentage() public constant returns(uint256 percentage) { return retainedSupplyPercentage; }
    function getCreationTime() public constant returns(uint256 time) { return creationTime; }
    function getGensisBlock() public constant returns(uint256 block) { return gensisBlock; }
    function getBlocksUntilExhaustion() public constant returns(uint256 blocks) { return blocksUntilExhaustion; }
    function getCurrentBlock() public returns(uint256 blocks) { return block.number; }
    
    // Constructor
    function Autoria() {
        // Establish the Issuer
        issuer = msg.sender;
        balances[msg.sender] += 30000000000000000000000000;
        aquifers[msg.sender] = 0;
        freeTokenSupply -= 30000000000000000000000000;
        // Send retainer coins to Issuer
    }

    // ICO Methods
    function paymentProcessor() onlyInvestor payable returns(uint256 tokens){
        
        // see if ICO is still running
        if (freeTokenSupply <= 0) { return 0; }
        if (isWell[msg.sender]) { return 0; }
        // determine exchange rate of AUT (increases if over 1 week after inception)
        uint price = earlySale() ? earlySalePrice : regularSalePrice;

        // set up some basic mapping stuff that we know will exist
        isWell[msg.sender] = true;

        uint requestedTokens = (msg.value / price) * exchangeRate;
        if (requestedTokens > freeTokenSupply) {
            return 0;
        }
        else {
            // send tokents to user
            aquifers[msg.sender] += requestedTokens;
            initialStake[msg.sender] += requestedTokens;
            // send eth to issuer
            issuer.transfer(msg.value);
            // update free token supply
            freeTokenSupply -= requestedTokens;
            return(requestedTokens);
        }
    }

    function earlySale() constant returns (bool ifSo) {
        if ((now - creationTime) > 1 weeks) return false;
        return true;
    }

    // ERC20 Methods 
    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
        return totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount 
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) public returns (bool success) {
        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    // Autoria specific methods
    
    function availableDraw(address _owner) constant returns(uint256) {
        uint256 x = (initialStake[_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        return aquifers[_owner] - (initialStake[_owner] - x);
    }
    
    function drawWell(address _owner) returns(bool) {
        if (isWell[_owner]) {
            //initial aquifer amount - initial aquifer amount 
            uint256 draw = availableDraw(_owner);
            if (draw > 0 && aquifers[_owner] > 0) {
                balances[_owner] += draw;
                aquifers[_owner] -= draw;
            }
            return true;
        }
        return false;
    }
    
}

pragma solidity ^0.4.10; 

contract minereum { 

string public name; 
string public symbol; 
uint8 public decimals; 
uint256 public initialSupplyPerAddress;
uint256 public initialBlockCount;
uint256 public rewardPerBlockPerAddress;
uint256 public totalGenesisAddresses;
uint256 private availableAmount;
uint256 private availableBalance;
uint256 private minedBlocks;
uint256 private totalMaxAvailableAmount;
uint256 private balanceOfAddress;



mapping (address => uint256) public balanceOf; 
mapping (address => bool) public genesisAddress; 

event Transfer(address indexed from, address indexed to, uint256 value); 

function minereum() { 

name = "minereum"; 
symbol = "MNE"; 
decimals = 8; 
initialSupplyPerAddress = 3200000000000;
initialBlockCount = 3516521;
rewardPerBlockPerAddress = 32000;
totalGenesisAddresses = 4269;

balanceOf[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = initialSupplyPerAddress;
genesisAddress[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = true;
balanceOf[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = initialSupplyPerAddress;
genesisAddress[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = true;
balanceOf[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = initialSupplyPerAddress;
genesisAddress[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = true;
balanceOf[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = initialSupplyPerAddress;
genesisAddress[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = true;
balanceOf[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = initialSupplyPerAddress;
genesisAddress[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = true;
...
function currentEthBlock() constant returns (uint256 blockNumber)
{
	return block.number;
}

function currentBlock() constant returns (uint256 blockNumber)
{
	return block.number - initialBlockCount;
}

function availableBalanceOf(address _address) constant returns (uint256 Balance)
{
	if (genesisAddress[_address])
	{
		minedBlocks = block.number - initialBlockCount;
		
		if (minedBlocks >= 100000000) return balanceOf[_address];
		
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
		
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[_address] - totalMaxAvailableAmount;
		
		return availableBalance;
	}
	else
		return balanceOf[_address];
}

function totalSupply() constant returns (uint256 totalSupply)
{	
	minedBlocks = block.number - initialBlockCount;
	availableAmount = rewardPerBlockPerAddress*minedBlocks;
	return availableAmount*totalGenesisAddresses;
}

function maxTotalSupply() constant returns (uint256 maxSupply)
{	
	return initialSupplyPerAddress*totalGenesisAddresses;
}

function transfer(address _to, uint256 _value) { 

if (genesisAddress[_to]) throw;

if (balanceOf[msg.sender] < _value) throw; 

if (balanceOf[_to] + _value < balanceOf[_to]) throw; 

if (genesisAddress[msg.sender])
{
	minedBlocks = block.number - initialBlockCount;
	if (minedBlocks < 100000000)
	{
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
			
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[msg.sender] - totalMaxAvailableAmount;
			
		if (_value > availableBalance) throw;
	}
}

balanceOf[msg.sender] -= _value; 
balanceOf[_to] += _value; 
Transfer(msg.sender, _to, _value); 
} 
}

pragma solidity ^0.4.11;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}
 
contract Autoria is SafeMath {
    // ERC20 variables
    string public constant symbol = "AUT";
    string public constant name = "Autorium";
    uint8 public constant decimals = 18;
    uint256 public _totalSupply = 100000000000000000000000000;

    // Autoria specific variables
    uint256 creationTime = now;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 public earlySalePrice = 1000000000000000000;
    uint256 public regularSalePrice = 1300000000000000000;
    uint256 public exchangeRate = 17500;
    uint256 public freeTokenSupply = _totalSupply;
    uint256 public retainedSupplyPercentage = 30;
    
    // Owner of this contract
    address issuer;
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    // Balances and aquifers for each account
    mapping(address => uint256) public balances;
    mapping(address => uint256) public aquifers;
    mapping(address => uint256) public initialStake;
    
    // Flag for whether or not address is a well
    mapping (address => bool) public isWell;
 
    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;
 
    // Functions with this modifier can only be executed by the owner
    // modifiers for permissions on functions
    modifier onlyIssuer() { if (msg.sender == issuer) _; }
    modifier onlyInvestor() { if (msg.sender != issuer) _; }
 
    function aquiferOf(address _owner) public constant returns (uint256 tokens) { return aquifers[_owner]; }
    function getIssuerAddress() public constant returns(address issuerAddress) { return issuer; }
    function getFreeTokenSupply() public constant returns(uint256 tokens) { return freeTokenSupply; }
    function getRetainedSupplyPercentage() public constant returns(uint256 percentage) { return retainedSupplyPercentage; }
    function getCreationTime() public constant returns(uint256 time) { return creationTime; }
    function getGensisBlock() public constant returns(uint256 block) { return gensisBlock; }
    function getBlocksUntilExhaustion() public constant returns(uint256 blocks) { return blocksUntilExhaustion; }
    function getCurrentBlock() public returns(uint256 blocks) { return block.number; }
    
    // Constructor
    function Autoria() {
        // Establish the Issuer
        issuer = msg.sender;
        balances[msg.sender] += 30000000000000000000000000;
        aquifers[msg.sender] = 0;
        freeTokenSupply -= 30000000000000000000000000;
        // Send retainer coins to Issuer
    }

    // ICO Methods
    function paymentProcessor() onlyInvestor payable returns(uint256 tokens){
        
        // see if ICO is still running
        if (freeTokenSupply <= 0) { return 0; }
        if (isWell[msg.sender]) { return 0; }
        // determine exchange rate of AUT (increases if over 1 week after inception)
        uint price = earlySale() ? earlySalePrice : regularSalePrice;

        // set up some basic mapping stuff that we know will exist
        isWell[msg.sender] = true;

        uint requestedTokens = (msg.value / price) * exchangeRate;
        if (requestedTokens > freeTokenSupply) {
            return 0;
        }
        else {
            // send tokents to user
            aquifers[msg.sender] += requestedTokens;
            initialStake[msg.sender] += requestedTokens;
            // send eth to issuer
            issuer.transfer(msg.value);
            // update free token supply
            freeTokenSupply -= requestedTokens;
            return(requestedTokens);
        }
    }

    function earlySale() constant returns (bool ifSo) {
        if ((now - creationTime) > 1 weeks) return false;
        return true;
    }

    // ERC20 Methods 
    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
        return totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount 
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) public returns (bool success) {
        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    // Autoria specific methods
    
    function availableDraw(address _owner) constant returns(uint256) {
        uint256 x = (initialStake[_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        return aquifers[_owner] - (initialStake[_owner] - x);
    }
    
    function drawWell(address _owner) returns(bool) {
        if (isWell[_owner]) {
            //initial aquifer amount - initial aquifer amount 
            uint256 draw = availableDraw(_owner);
            if (draw > 0 && aquifers[_owner] > 0) {
                balances[_owner] += draw;
                aquifers[_owner] -= draw;
            }
            return true;
        }
        return false;
    }
    
}

pragma solidity ^0.4.11;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}
 
contract Autoria is SafeMath {
    // ERC20 variables
    string public constant symbol = "AUT";
    string public constant name = "Autorium";
    uint8 public constant decimals = 18;
    uint256 public _totalSupply = 100000000000000000000000000;

    // Autoria specific variables
    uint256 creationTime = now;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 public earlySalePrice = 1000000000000000000;
    uint256 public regularSalePrice = 1300000000000000000;
    uint256 public exchangeRate = 17500;
    uint256 public freeTokenSupply = _totalSupply;
    uint256 public retainedSupplyPercentage = 30;
    
    // Owner of this contract
    address issuer;
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    // Balances and aquifers for each account
    mapping(address => uint256) public balances;
    mapping(address => uint256) public aquifers;
    mapping(address => uint256) public initialStake;
    
    // Flag for whether or not address is a well
    mapping (address => bool) public isWell;
 
    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;
 
    // Functions with this modifier can only be executed by the owner
    // modifiers for permissions on functions
    modifier onlyIssuer() { if (msg.sender == issuer) _; }
    modifier onlyInvestor() { if (msg.sender != issuer) _; }
 
    function aquiferOf(address _owner) public constant returns (uint256 tokens) { return aquifers[_owner]; }
    function getIssuerAddress() public constant returns(address issuerAddress) { return issuer; }
    function getFreeTokenSupply() public constant returns(uint256 tokens) { return freeTokenSupply; }
    function getRetainedSupplyPercentage() public constant returns(uint256 percentage) { return retainedSupplyPercentage; }
    function getCreationTime() public constant returns(uint256 time) { return creationTime; }
    function getGensisBlock() public constant returns(uint256 block) { return gensisBlock; }
    function getBlocksUntilExhaustion() public constant returns(uint256 blocks) { return blocksUntilExhaustion; }
    function getCurrentBlock() public returns(uint256 blocks) { return block.number; }
    
    // Constructor
    function Autoria() {
        // Establish the Issuer
        issuer = msg.sender;
        balances[msg.sender] += 30000000000000000000000000;
        aquifers[msg.sender] = 0;
        freeTokenSupply -= 30000000000000000000000000;
        // Send retainer coins to Issuer
    }

    // ICO Methods
    function paymentProcessor() onlyInvestor payable returns(uint256 tokens){
        
        // see if ICO is still running
        if (freeTokenSupply <= 0) { return 0; }
        if (isWell[msg.sender]) { return 0; }
        // determine exchange rate of AUT (increases if over 1 week after inception)
        uint price = earlySale() ? earlySalePrice : regularSalePrice;

        // set up some basic mapping stuff that we know will exist
        isWell[msg.sender] = true;

        uint requestedTokens = (msg.value / price) * exchangeRate;
        if (requestedTokens > freeTokenSupply) {
            return 0;
        }
        else {
            // send tokents to user
            aquifers[msg.sender] += requestedTokens;
            initialStake[msg.sender] += requestedTokens;
            // send eth to issuer
            issuer.transfer(msg.value);
            // update free token supply
            freeTokenSupply -= requestedTokens;
            return(requestedTokens);
        }
    }

    function earlySale() constant returns (bool ifSo) {
        if ((now - creationTime) > 1 weeks) return false;
        return true;
    }

    // ERC20 Methods 
    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
        return totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount 
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) public returns (bool success) {
        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    // Autoria specific methods
    
    function availableDraw(address _owner) constant returns(uint256) {
        uint256 x = (initialStake[_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        return aquifers[_owner] - (initialStake[_owner] - x);
    }
    
    function drawWell(address _owner) returns(bool) {
        if (isWell[_owner]) {
            //initial aquifer amount - initial aquifer amount 
            uint256 draw = availableDraw(_owner);
            if (draw > 0 && aquifers[_owner] > 0) {
                balances[_owner] += draw;
                aquifers[_owner] -= draw;
            }
            return true;
        }
        return false;
    }
    
}