pragma solidity 0.4.25;

library SafeMath {
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    require(c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b > 0);
    uint256 c = a / b;
    return c;
  }

  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b <= a);
    uint256 c = a - b;
    return c;
  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a);
    return c;
  }

  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0);
    return a % b;
  }
}

contract Token {
  function totalSupply() pure public returns (uint256 supply);
  function balanceOf(address _owner) pure public returns (uint256 balance);
  function transfer(address _to, uint256 _value) public returns (bool success);
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
  function approve(address _spender, uint256 _value) public returns (bool success);
  function allowance(address _owner, address _spender) pure public returns (uint256 remaining);

  event Transfer(address indexed _from, address indexed _to, uint256 _value);
  event Approval(address indexed _owner, address indexed _spender, uint256 _value);

  uint public decimals;
  string public name;
}

contract Ownable {
  address private _owner;

  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner
  );

  constructor() internal {
    _owner = msg.sender;
    emit OwnershipTransferred(address(0), _owner);
  }

  function owner() public view returns(address) {
    return _owner;
  }

  modifier onlyOwner() {
    require(isOwner());
    _;
  }

  function isOwner() public view returns(bool) {
    return msg.sender == _owner;
  }

  function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);
  }

  function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
  }

  function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0));
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }
}

contract AirDrop is Ownable {
  address public tokenAddress;
  Token public token;
  uint256 public valueAirDrop;
  mapping (address => uint8) public payedAddress; 
  constructor() public{
    tokenAddress = 0x4Ba012f6e411a1bE55b98E9E62C3A4ceb16eC88B;
    token = Token(tokenAddress); 
    valueAirDrop = 1e22;
  } 
  function setValueAirDrop(uint256 _valueAirDrop) public onlyOwner{
    valueAirDrop = _valueAirDrop;
  } 
  function setTokenAddress(address _address) onlyOwner public{
    tokenAddress = _address;
    token = Token(tokenAddress);  
  }
  function sendAirDrop() external payable {
    require(msg.value == 0);
    require(payedAddress[msg.sender] == 0);  
    payedAddress[msg.sender] = 1;  
    token.transfer(msg.sender, valueAirDrop);
  }
  function multisend(address[] _addressDestination)
    onlyOwner
    public {
        uint256 i = 0;
        while (i < _addressDestination.length) {
           token.transfer(_addressDestination[i], valueAirDrop);
           i += 1;
        }
    }  
}