contract SomeCoin is Utils, ERC20Interface, Owned, SafeMath, bundinha {
	uint myVariable;
	string bundinha;

	string public name = '';
	string public symbol = '';
	uint8 public decimals = 0;
	uint256 public totalSupply = 0;
	uint256 public maxSupply = 50000000000000000000000;
							// 50000.

	mapping (address => uint256) public balanceOf;
	mapping (address => mapping (address => uint256)) public allowance;

	event Transfer(address indexed _from, address indexed _to, uint256 _value);
	event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    event Issuance(uint256 _amount);

	// function SomeCoin(string _name, string _symbol, uint8 _decimals, uint256 supply) {
	function SomeCoin(string _name, string _symbol, uint8 _decimals) {
		require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input

		name = _name;
		symbol = _symbol;
		decimals = _decimals;
		// totalSupply = supply;
	}

	function validSupply() private returns(bool) {
		return totalSupply <= maxSupply;
	}

	function transfer(address _to, uint256 _value)
		public
		validAddress(_to)
		returns (bool success)
	{
		balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
		balanceOf[_to] = safeAdd(balanceOf[_to], _value);
		Transfer(msg.sender, _to, _value);
		return true;
	}

	function transferFrom(address _from, address _to, uint256 _value)
		public
		validAddress(_from)
		validAddress(_to)
		returns (bool success)
	{
		allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
		balanceOf[_from] = safeSub(balanceOf[_from], _value);
		balanceOf[_to] = safeAdd(balanceOf[_to], _value);
		Transfer(_from, _to, _value);
		return true;
	}

	function approve(address _spender, uint256 _value)
		public
		validAddress(_spender)
		returns (bool success)
	{
		require(_value == 0 || allowance[msg.sender][_spender] == 0);

		allowance[msg.sender][_spender] = _value;
		Approval(msg.sender, _spender, _value);
		return true;
	}

	function issue(address _to, uint256 _amount)
	    public
	    ownerOnly
	    validAddress(_to)
	    notThis(_to)
	{
	    totalSupply = safeAdd(totalSupply, _amount);
	    balanceOf[_to] = safeAdd(balanceOf[_to], _amount);

	    require(validSupply());

	    Issuance(_amount);
	    Transfer(this, _to, _amount);
	}

	function transferAnyERC20Token(address _token, address _to, uint256 _amount)
		public
		ownerOnly
	    validAddress(_token)
		returns (bool success)
	{
		return ERC20Interface(_token).transfer(_to, _amount);
	}

	// Don't accept ETH
	function () payable {
		revert();
	}
}
function SomeCoin(string _name, string _symbol, uint8 _decimals) {
	require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input

	name = _name;
	symbol = _symbol;
	decimals = _decimals;
	// totalSupply = supply;
}

// function SomeCoin(string _name, string _symbol, uint8 _decimals, uint256 supply) {