contract botXcoin is ERC20 {

    using SafeMath for uint256;
    address owner = msg.sender;

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
	mapping (address => bool) public holdAccount;
 
    string public constant name = "botXcoin";
    string public constant symbol = "BOTX";
    uint public constant decimals = 18;

    uint256 public totalSupply = 5000000000e18; // Supply
    uint256 public totalDistributed = 0;
    uint256 public min_contribution = 1 ether / 100; // 0.01 Ether
    uint256 public tokensPerEth = 10000e18;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    event Distr(address indexed to, uint256 amount);
    event DistrFinished();
    event Airdrop(address indexed _owner, uint _amount, uint _balance);
    event ICO(address indexed _owner, uint _amount, uint _balance);
	event MinContributionUpdated(uint _mincontribution);
    event TokensPerEthUpdated(uint _tokensPerEth);
    event Burn(address indexed burner, uint256 value);
	event HoldFunds(address target, bool hold);

    bool public distributionFinished = false;

    modifier canDistr() {
        require(!distributionFinished);
        _;
    }

    modifier cantDistr() {
        require(distributionFinished);
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

//    function RandiCoin () public {
//        owner = msg.sender;
//        distr(owner, totalDistributed);
//    }

    function transferOwnership(address newOwner) onlyOwner public {
        if (newOwner != address(0)) {
            owner = newOwner;
        }
    }

    function finishDistribution() onlyOwner canDistr public returns (bool) {
        distributionFinished = true;
        emit DistrFinished();
        return true;
    }

    function startDistribution() onlyOwner cantDistr public returns (bool) {
        distributionFinished = false;
        emit DistrFinished();
        return true;
    }

    function distr(address _to, uint256 _amount) canDistr private returns (bool) {
        totalDistributed = totalDistributed.add(_amount);
        balances[_to] = balances[_to].add(_amount);
        emit Distr(_to, _amount);
        emit Transfer(address(0), _to, _amount);
        return true;
    }

    function doAirdrop(address _participant, uint _amount) internal {

        require( _amount > 0 );
        require( totalDistributed < totalSupply );
        balances[_participant] = balances[_participant].add(_amount);
        totalDistributed = totalDistributed.add(_amount);
        if (totalDistributed >= totalSupply) {
            distributionFinished = true;
        }

        emit Airdrop(_participant, _amount, balances[_participant]);
        emit Transfer(address(0), _participant, _amount);
    }

    function doICO(address _participant, uint _amount) internal {

        require( _amount > 0 );
        require( totalDistributed < totalSupply );
        balances[_participant] = balances[_participant].add(_amount);
        totalDistributed = totalDistributed.add(_amount);
        if (totalDistributed >= totalSupply) {
            distributionFinished = true;
        }
        emit ICO(_participant, _amount, balances[_participant]);
        emit Transfer(address(0), _participant, _amount);
    }

    function adminClaimICO(address[] _addresses, uint[] _amount) public onlyOwner {
        for (uint i = 0; i < _addresses.length; i++) doICO(_addresses[i], _amount[i]); 
    }

    function adminClaimAirdrop(address _participant, uint _amount) public onlyOwner {
        doAirdrop(_participant, _amount);
    }

    function adminClaimAirdropMultiple1(address[] _addresses, uint _amount) public onlyOwner {
        for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i], _amount);
    }

    function adminClaimAirdropMultiple2(address[] _addresses, uint[] _amount) public onlyOwner {
        for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i], _amount[i]);
    }

    function updateMinContribution(uint _mincontribution) public onlyOwner {
        min_contribution = _mincontribution;
        emit MinContributionUpdated(_mincontribution);
    }

    function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
        tokensPerEth = _tokensPerEth;
        emit TokensPerEthUpdated(_tokensPerEth);
    }
	
    function () external payable {
        getTokens();
     }

    function getTokens() payable canDistr  public {
        uint256 tokens = 0;

        require( msg.value >= min_contribution );

        require( msg.value > 0 );

        tokens = tokensPerEth.mul(msg.value) / 1 ether;
        address investor = msg.sender;

        if (tokens > 0) {
            distr(investor, tokens);
        }

        if (totalDistributed >= totalSupply) {
            distributionFinished = true;
        }
    }

    function balanceOf(address _owner) constant public returns (uint256) {
        return balances[_owner];
    }

    function holdAccountOf(address _owner) constant public returns (bool) {
        return holdAccount[_owner];
    }

    // mitigates the ERC20 short address attack
    modifier onlyPayloadSize(uint size) {
        assert(msg.data.length >= size + 4);
        _;
    }

    function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {

        require(_to != address(0));
        require(_amount <= balances[msg.sender]);
		require(!holdAccount[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_amount);
        balances[_to] = balances[_to].add(_amount);
        emit Transfer(msg.sender, _to, _amount);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {

        require(_to != address(0));
        require(_amount <= balances[_from]);
        require(_amount <= allowed[_from][msg.sender]);

        balances[_from] = balances[_from].sub(_amount);
        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
        balances[_to] = balances[_to].add(_amount);
        emit Transfer(_from, _to, _amount);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        // mitigates the ERC20 spend/approval race condition
        if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function HoldAccount(address target, bool hold) onlyOwner public {
        holdAccount[target] = hold;
        emit HoldFunds(target, hold);
    }
	
    function HoldAccountMulti(address[] _target, bool _hold) onlyOwner public {
        for (uint i = 0; i < _target.length; i++) {
			holdAccount[_target[i]] = _hold;
			emit HoldFunds(_target[i], _hold);
		}
    }

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

    function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
        ForeignToken t = ForeignToken(tokenAddress);
        uint bal = t.balanceOf(who);
        return bal;
    }

    function withdraw() onlyOwner public {
        address myAddress = this;
        uint256 etherBalance = myAddress.balance;
        owner.transfer(etherBalance);
    }

    function burn(uint256 _value) onlyOwner public {
        require(_value <= balances[msg.sender]);

        address burner = msg.sender;
        balances[burner] = balances[burner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        totalDistributed = totalDistributed.sub(_value);
        emit Burn(burner, _value);
    }

    function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
        ForeignToken token = ForeignToken(_tokenContract);
        uint256 amount = token.balanceOf(address(this));
        return token.transfer(owner, amount);
    }
}
function transferOwnership(address newOwner) onlyOwner public {
        if (newOwner != address(0)) {
            owner = newOwner;
        }
    }
//    function RandiCoin () public {
//        owner = msg.sender;
//        distr(owner, totalDistributed);
//    }