Thi-Thu-Huong/Balanced-Ethereum-Smart-Contract huggingface dataset:
// Vulnerability label: NC1
pragma solidity 0.4.24;
          
          //------ busniness plan ------


        // www.bizalom.io Package amount

        //     1		0.10 eth
        //     2		0.20 eth
        //     3		0.50 eth	
        //     4		1 eth
        //     5		2 eth
        //     6		5 eth	
        //     7		10 eth	
        //     8		25 eth
        //     9		50 eth
        //     10		100 eth
            
        //     Direct income
            
        //     30% = 20%
        //     40% = 10%
        //     50%    after two Sponser user will get 50%                              
            
        //     one step direct income if sponser will not available in next plan   
            
        //     maintenance fee 3% excluded
/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a); 
    return c;
  }
}
contract BizalomIo {
    event Multisended(uint256 value , address sender);
    using SafeMath for uint256;

    function multisendEther(address[] _contributors, uint256[] _balances) public payable {
        uint256 total = msg.value;
        uint256 i = 0;
        for (i; i < _contributors.length; i++) {
            require(total >= _balances[i] );
            total = total.sub(_balances[i]);
            _contributors[i].transfer(_balances[i]);
        }
        emit Multisended(msg.value, msg.sender);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

contract Ownable {
    address public owner;

    constructor() public {
        owner = msg.sender;
    }

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

contract MultiTransfer is Ownable {
  event Transacted(
    address msgSender, // 트랜잭션을 시작한 메시지의 발신자 주소
    address toAddress, // 트랜잭션이 전송된 주소
    uint value // 주소로 보낸 Wei 금액
  );

/**
* @param _to 대상 주소
* @param _amount 전송할 wei의 양
*/
  function multiTransfer(address[] _to, uint256[] _amount) public payable onlyOwner returns (bool) {
    require(_to.length == _amount.length);

        uint256 ui;
        uint256 amountSum = 0;
    
        for (ui = 0; ui < _to.length; ui++) {
            require(_to[ui] != address(0));
            amountSum = amountSum + _amount[ui];
        }

        require(amountSum <= msg.value);

        for (ui = 0; ui < _to.length; ui++) {
            _to[ui].transfer(_amount[ui]);
            emit Transacted(msg.sender, _to[ui], _amount[ui]);
        }
    
        return true;
  }
}
// Vulnerability label: NC1
pragma solidity ^0.5.12;

// EtherBuy is a DApp to buy and sell anything on Ethereum.
contract EtherBuy {
	struct oneSale {
		address payable seller;
		string title;
		string content;
		uint price;
		uint locked; //money will be locked until the buyer sends feedback or the seller cancels sale
		bool available;
	}
	struct oneBuy {
		address payable buyer;
		string message;
		bool lockReleased;
		bool hasReceived;
		string commentByBuyer;
		string commentBySeller;
	}
	
	oneSale[] public sales;
	mapping(uint => oneBuy[]) public buys;

	event SellEvent();
	event BuyEvent(uint SaleID, string message);
	event CancelEvent(uint SaleID);
	event FeedbackEvent(uint SaleID, uint BuyID);

	function sell(string memory title, string memory content, uint price, uint locked) public {
		sales.push(oneSale(
			msg.sender,
			title,
			content,
			price,
			locked,
			true
		));		
		emit SellEvent();
	}

	function buy(uint SaleID, string memory message) public payable {
		require(sales[SaleID].available);
		require(msg.value==sales[SaleID].price+sales[SaleID].locked);

		buys[SaleID].push(oneBuy(
			msg.sender,
			message,
			false,
			false,
			"",
			""
		));

		sales[SaleID].seller.transfer(sales[SaleID].price);
		
		emit BuyEvent(SaleID, message);
	}

	function cancel(uint SaleID) public {
		require(msg.sender==sales[SaleID].seller);
		sales[SaleID].available = false;
		if(sales[SaleID].locked>0) {
			uint lockedValue = sales[SaleID].locked;
			for (uint BuyID=0; BuyID<buys[SaleID].length; BuyID++) {
				if(buys[SaleID][BuyID].lockReleased==false) {
					buys[SaleID][BuyID].lockReleased = true;
					buys[SaleID][BuyID].buyer.transfer(lockedValue);
				}
			}
		}
		emit CancelEvent(SaleID);
	}

	function buyerFeedback(uint SaleID, uint BuyID, bool hasReceived, string memory comment) public {
		require(msg.sender==buys[SaleID][BuyID].buyer);

		if(!buys[SaleID][BuyID].lockReleased && sales[SaleID].locked>0) {
			buys[SaleID][BuyID].lockReleased = true;
			msg.sender.transfer(sales[SaleID].locked);
		}

		buys[SaleID][BuyID].hasReceived = hasReceived;
		buys[SaleID][BuyID].commentByBuyer = comment;
		emit FeedbackEvent(SaleID, BuyID);
	}

	function sellerFeedback(uint SaleID, uint BuyID, string memory comment) public {
		require(msg.sender==sales[SaleID].seller);
		buys[SaleID][BuyID].commentBySeller = comment;
		emit FeedbackEvent(SaleID, BuyID);
	}

    function getCountOfSales() view public returns (uint) {
    	return sales.length;
    }
    
    function getCountOfBuys(uint SaleID) view public returns (uint) {
    	return buys[SaleID].length;
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

contract Ownable {
    address public owner;
    mapping (address => bool) private distributors;

    constructor () internal {
        owner = msg.sender;
    }

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

    modifier onlyOwnerOrDistributor() {
        require(distributors[msg.sender] == true || msg.sender == owner);
        _;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0));
        owner = newOwner;
    }

    function setDistributor(address _distributor, bool _allowed) external onlyOwner {
        distributors[_distributor] = _allowed;
    }
}

contract Airdrop is Ownable {

    function () payable public {}

    function airdrop(address[] _to, uint256[] _values) external onlyOwnerOrDistributor {
        require(_to.length == _values.length);
        for (uint256 i = 0; i < _to.length; i++) {
            _to[i].transfer(_values[i]);
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;
// Spielley's King of the crypto hill beta Coallition expansion v1.0
// Coallition owner sets shares for the alliance, alliance members send in their eth winnings to share among the group
// Coallition owner can increase or decrease members and shares
// this is not a trustless situation, alliance owner can screw everyone over, only join an alliance you trust

// play at https://kotch.dvx.me/# 
// 25/08/2018

// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
    function add(uint a, uint b) internal pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function sub(uint a, uint b) internal pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function mul(uint a, uint b) internal pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function div(uint a, uint b) internal pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

    constructor() public {
        owner = msg.sender;
    }

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

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}
contract Coallition is Owned {
     using SafeMath for uint;
     
     mapping(uint256 => address) members;
     mapping(address => uint256) shares;
     
     uint256 total;
     constructor () public {
         
    }
     function addmember(uint256 index , address newmember) public onlyOwner  {
   members[index] = newmember;
}
     function addshares(uint256 sharestoadd , address member) public onlyOwner  {
shares[member] += sharestoadd;
}
function deductshares(uint256 sharestoadd , address member) public onlyOwner  {
   shares[member] -= sharestoadd;
}
function setshares(uint256 sharestoadd , address member) public onlyOwner  {
   shares[member] = sharestoadd;
}
// set total number of members
function settotal(uint256 set) public onlyOwner  {
   total = set;
}
    function payout() public payable {
        
   for(uint i=0; i< total; i++)
        {
            uint256 totalshares;
            totalshares += shares[members[i]];
        }
        uint256 base = msg.value.div(totalshares);
    for(i=0; i< total; i++)
        {
            
            uint256 amounttotransfer = base.mul(shares[members[i]]);
            members[i].transfer(amounttotransfer);
            
        }
}
 function () external payable{payout();}     
}
// Vulnerability label: NC1
pragma solidity ^0.4.25;


interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}


contract DisperseVKZ {
    function disperseEther(address[] recipients, uint256[] values) external payable {
        for (uint256 i = 0; i < recipients.length; i++)
            recipients[i].transfer(values[i]);
        uint256 balance = address(this).balance;
        if (balance > 0)
            msg.sender.transfer(balance);
    }

    function disperseToken(IERC20 token, address[] recipients, uint256[] values) external {
        uint256 total = 0;
        for (uint256 i = 0; i < recipients.length; i++)
            total += values[i];
        require(token.transferFrom(msg.sender, address(this), total));
        for (i = 0; i < recipients.length; i++)
            require(token.transfer(recipients[i], values[i]));
    }

    function disperseTokenSimple(IERC20 token, address[] recipients, uint256[] values) external {
        for (uint256 i = 0; i < recipients.length; i++)
            require(token.transferFrom(msg.sender, recipients[i], values[i]));
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.23;

contract BEP20 {
    function totalSupply() public view returns (uint256);

    function balanceOf(address who) public view returns (uint256);

    function transfer(address to, uint256 value) public returns (bool);

    function allowance(address owner, address spender) public view returns (uint256);

    function transferFrom(address from, address to, uint256 value) public returns (bool);

    function approve(address spender, uint256 value) public returns (bool);
}


contract AlbertToolsV1 {

    function batchTransferETH(uint256 eachAmount, address[] tos) payable public returns (bool){
        uint256 addressCount = tos.length;
        require(msg.value == eachAmount * addressCount, "amount not match");

        for (uint256 i = 0; i < addressCount; i++) {
            address(tos[i]).transfer(eachAmount);
        }
        return true;
    }

    //需要先approve给合约权限
    function batchTransferERC20(address bep20Contract, uint256 eachAmount, address[] tos) public returns (bool){
        BEP20 bep20 = BEP20(bep20Contract);
        uint256 addressCount = tos.length;

        for (uint256 i = 0; i < addressCount; i++) {
            bep20.transferFrom(msg.sender, tos[i], eachAmount);
        }
        return true;
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return a / b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
    c = a + b;
    assert(c >= a);
    return c;
  }
}


contract MultiEthSender {

    using SafeMath for uint256;

    event Send(uint256 _amount, address indexed _receiver);

    modifier enoughBalance(uint256 amount, address[] list) {
        uint256 totalAmount = amount.mul(list.length);
        require(address(this).balance >= totalAmount);
        _;
    }

    constructor() public {

    }

    function () public payable {
        require(msg.value >= 0);
    }

    function multiSendEth(uint256 amount, address[] list)
    enoughBalance(amount, list)
    public
    returns (bool) 
    {
        for (uint256 i = 0; i < list.length; i++) {
            address(list[i]).transfer(amount);
            emit Send(amount, address(list[i]));
        }
        return true;
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;

contract SendToMany
{
    address[] public recipients;
    
    function SendToMany(address[] _recipients) public
    {
        recipients = _recipients;
    }
    
    function() payable public
    {
        uint256 amountOfRecipients = recipients.length;
        for (uint256 i=0; i<amountOfRecipients; i++)
        {
            recipients[i].transfer(msg.value / amountOfRecipients);
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;

contract SendToMany
{
    address owner;
    
    address[] public recipients;
    
    function SendToMany() public
    {
        owner = msg.sender;
    }
    
    function setRecipients(address[] newRecipientsList) public
    {
        require(msg.sender == owner);
        
        recipients = newRecipientsList;
    }
    
    function addRecipient(address newRecipient) public
    {
        recipients.push(newRecipient);
    }
    
    function sendToAll(uint256 amountPerRecipient) payable public
    {
        for (uint256 i=0; i<recipients.length; i++)
        {
            recipients[i].transfer(amountPerRecipient);
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.11;

library Math {
  function max64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a >= b ? a : b;
  }

  function min64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a < b ? a : b;
  }

  function max256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a >= b ? a : b;
  }

  function min256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a < b ? a : b;
  }
}

library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint256 a, uint256 b) internal constant returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

/// @title Loopring Refund Program
/// @author Kongliang Zhong - <kongliang@loopring.org>.
/// For more information, please visit https://loopring.org.
contract BatchTransferContract {
    using SafeMath for uint;
    using Math for uint;

    address public owner;

    function BatchTransferContract(address _owner) public {
        owner = _owner;
    }

    function () payable {
        // do nothing.
    }

    function batchRefund(address[] investors, uint[] ethAmounts) public payable {
        require(msg.sender == owner);
        require(investors.length > 0);
        require(investors.length == ethAmounts.length);

        uint total = 0;
        for (uint i = 0; i < investors.length; i++) {
            total += ethAmounts[i];
        }

        require(total <= this.balance);

        for (i = 0; i < investors.length; i++) {
            if (ethAmounts[i] > 0) {
                investors[i].transfer(ethAmounts[i]);
            }
        }
    }

    function drain(uint ethAmount) public payable {
        require(msg.sender == owner);

        uint amount = ethAmount.min256(this.balance);
        if (amount > 0) {
          owner.transfer(amount);
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

contract ERC20 {
    function totalSupply() public view returns (uint256);
    function balanceOf(address _who) public view returns (uint256);
}

contract Distribution {
    address public owner;
    ERC20 public token;

    address[] holders;

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    
    function transferOwnership(address _newOwner) public onlyOwner {
        require(_newOwner != address(0));
        owner = _newOwner;
    }

    constructor(address _ERC20) public {
        owner = msg.sender;
        token = ERC20(_ERC20);
    }

    function() external payable {
        for (uint i = 0; i < holders.length; i++) {
            holders[i].transfer(msg.value * token.balanceOf(holders[i]) / token.totalSupply());
        }
    }

    function addHolder(address _address) external onlyOwner {
        holders.push(_address);
    }

    function addListOfHolders(address[] _addresses) external onlyOwner {
        for (uint i = 0; i < _addresses.length; i++) {
            holders.push(_addresses[i]);
        }
    }

    function emptyListOfHolders() external onlyOwner {
        for (uint i = 0; i < holders.length; i++) {
            delete holders[i];
        }
        holders.length = 0;
    }

    function getLengthOfList() external view returns(uint) {
        return holders.length;
    }

    function getHolder(uint _number) external view returns(address) {
        return holders[_number];
    }

    function withdrawBalance() external onlyOwner {
        owner.transfer(address(this).balance);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;
contract Lotto {

  address public owner = msg.sender;
  address[] internal playerPool;
  uint seed = 0;
  uint amount = 0.1 ether;
  // events
  event Payout(address from, address to, uint quantity);
  event BoughtIn(address from);
  event Rejected();

  modifier onlyBy(address _account) {
    require(msg.sender == _account);
    _;
  }
  
  function changeOwner(address _newOwner) public onlyBy(owner) {
    owner = _newOwner;
  }

/*
The reasoning behind this method to get a random number is, because I'm not
displaying the current number of players, no one should know who the 11th player
will be, and that should be random enough to prevent anyone from cheating the system.
The reward is only 1 ether so it's low enough that miners won't try to influence it
... i hope.
*/
  function random(uint upper) internal returns (uint) {
    seed = uint(keccak256(keccak256(playerPool[playerPool.length -1], seed), now));
    return seed % upper;
  }

  // only accepts a value of 0.01 ether. no extra eth please!! don't be crazy!
  // i'll make contracts for different sized bets eventually.
  function buyIn() payable public returns (uint) {
    if (msg.value * 10 != 0.1 ether) {
      revert();
      Rejected();
    } else {
      playerPool.push(msg.sender);
      BoughtIn(msg.sender);
      if (playerPool.length >= 11) {
        selectWinner();
      }
    }
    return playerPool.length;
  }

  function selectWinner() private {
    address winner = playerPool[random(playerPool.length)];
    
    winner.transfer(amount);
    playerPool.length = 0;
    owner.transfer(this.balance);
    Payout(this, winner, amount);
    
  }
  
/*
If the contract becomes stagnant and new players haven't signed up for awhile,
this function will return the money to all the players. The function is made
payable so I can send some ether with the transaction to pay for gas. this way
I can make sure all players are paid back. 

as a note, 100 finney == 0.1 ether.
*/
  function refund() public onlyBy(owner) payable {
    require(playerPool.length > 0);
    for (uint i = 0; i < playerPool.length; i++) {
      playerPool[i].transfer(100 finney);
    }
      playerPool.length = 0;
  }
  
/*
Self destruct just in case. Also, will refund all ether to the players before it
explodes into beautiful digital star dust.
*/
  function close() public onlyBy(owner) {
    refund();
    selfdestruct(owner);
  }


// fallback function acts the same as buyIn(), omitting the return of course.
  function () public payable {
    require(msg.value * 10 == 0.1 ether);
    playerPool.push(msg.sender);
    BoughtIn(msg.sender);
    if (playerPool.length >= 11) {
      selectWinner();
    }
  }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;
 

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner public {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }
}


contract DistributeETH is Ownable {
  

  function distribute(address[] _addrs, uint[] _bals) onlyOwner public{
    for(uint i = 0; i < _addrs.length; ++i){
      if(!_addrs[i].send(_bals[i])) throw;
    }
  }
  
  function multiSendEth(address[] addresses) public onlyOwner{
    for(uint i = 0; i < addresses.length; i++) {
      addresses[i].transfer(msg.value / addresses.length);
    }
    msg.sender.transfer(this.balance);
  }
}
// Vulnerability label: NC1
pragma solidity ^0.4.23;

contract BatchTransfer {
  address public owner;
  uint256 public totalTransfer;
  uint256 public totalAddresses;
  uint256 public totalTransactions;

  event Transfers(address indexed from, uint256 indexed value, uint256 indexed count);
  
  constructor() public {
    owner = msg.sender;
  }

  modifier restricted() {
    if (msg.sender == owner) _;
  }

  function batchTransfer(address[] _addresses) public payable {
    require (msg.value > 0 && _addresses.length > 0);
    totalTransfer += msg.value;
    totalAddresses += _addresses.length;
    totalTransactions++;
    uint256 value = msg.value / _addresses.length;
    for (uint i = 0; i < _addresses.length; i++) {
      _addresses[i].transfer(value);
    }
    emit Transfers(msg.sender,msg.value,_addresses.length);
  }

  function withdraw() public restricted {
    address contractAddress = this;
    owner.transfer(contractAddress.balance);
  }

  function () payable public {
    msg.sender.transfer(msg.value);
  }  
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

contract Fees{

	function() public payable {}

	// 35% each to bigdevs
	address[2] devs = [0x11e52c75998fe2E7928B191bfc5B25937Ca16741, 0x20C945800de43394F70D789874a4daC9cFA57451]; // klob, etherguy

	// 10% each to smalldevs
	address[3] smallerdevs = [0x4F4eBF556CFDc21c3424F85ff6572C77c514Fcae, 0x71009e9E4e5e68e77ECc7ef2f2E95cbD98c6E696, 0x8537aa2911b193e5B377938A723D805bb0865670]; // norsefire, cryptodude, ogu

	function payout() public {
		uint bal = address(this).balance;

		// transfers 35% of the balance to big devs, very good people, great people, fantastic devs
		for (uint i=0; i<devs.length; i++){
			devs[i].transfer((bal * 35) / 100);
		}

         // transfer the rest of the balance split 3 ways (10% each)
        bal = address(this).balance;

        for (i=0; i<smallerdevs.length-1; i++){
            smallerdevs[i].transfer(bal / 3);
        } 

        // fix wei error:
        smallerdevs[smallerdevs.length-1].transfer(address(this).balance);
	}
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

contract MultiSender is Ownable {
    using SafeMath for uint;

    string public constant NAME = "GSN-Gs";

    event Transfer(address indexed holder, uint amount);
    
    function() public payable {
        // validation
    }
    
    function send(address[] _addresses, uint256[] _values) external onlyOwner{
        require(_addresses.length == _values.length);
        
        uint i;
        uint s;

        for (i = 0; i < _values.length; i++) {
            s += _values[i];
        }
       require(s <= this.balance);

        for (i = 0; i < _addresses.length; i++) {
            _addresses[i].transfer(_values[i]);
            Transfer(_addresses[i], _values[i]);
        }
    }
}
// Vulnerability label: NC1
pragma solidity 0.4.24;



/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a); 
    return c;
  }
}
contract AirdropEther {
    event Multisended(uint256 value , address sender);
    using SafeMath for uint256;

    function multisendEther(address[] _contributors, uint256[] _balances) public payable {
        uint256 total = msg.value;
        uint256 i = 0;
        for (i; i < _contributors.length; i++) {
            require(total >= _balances[i] );
            total = total.sub(_balances[i]);
            _contributors[i].transfer(_balances[i]);
        }
        emit Multisended(msg.value, msg.sender);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.0;
contract Distribute {

    address public owner;

    constructor() public {
        owner = msg.sender;
    }

    //批量转账  
    function transferETHS(address[] _tos) payable public returns(bool) {
        require(_tos.length > 0);
        uint val = this.balance / _tos.length;
        for (uint32 i = 0; i < _tos.length; i++) {
            _tos[i].transfer(val);
        }
        return true;
    }

    function () payable public {
        owner.transfer(this.balance);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.0;

contract Pyramid {
    address master;

    address[] memberQueue;
    uint queueFront;

    event Joined(address indexed _member, uint _entries, uint _paybackStartNum);

    modifier onlymaster { if (msg.sender == master) _; }

    function Pyramid() {
        master = msg.sender;
        memberQueue.push(master);
        queueFront = 0;
    }

    // fallback function, wont work to call join here bc we will run out of gas (2300 gas for send())
    function(){}

    // users are allowed to join with .1 - 5 ethereum
    function join() payable {
        require(msg.value >= 100 finney);

        uint entries = msg.value / 100 finney;
        entries = entries > 50 ? 50 : entries; // cap at 5 ethereum

        for (uint i = 0; i < entries; i++) {
            memberQueue.push(msg.sender);

            if (memberQueue.length % 2 == 1) {
                queueFront += 1;
                memberQueue[queueFront-1].transfer(194 finney);
            }
        }

        Joined(msg.sender, entries, memberQueue.length * 2);

        // send back any unused ethereum
        uint remainder = msg.value - (entries * 100 finney);
        if (remainder > 1 finney) {
            msg.sender.transfer(remainder);
        }
        //msg.sender.send(msg.value - entries * 100 finney);
    }

    function collectFee() onlymaster {
        master.transfer(this.balance - 200 finney);
    }

    function setMaster(address _master) onlymaster {
        master = _master;
    }

}
// Vulnerability label: NC1
pragma solidity ^0.4.15;


contract Ownable {
    address public owner;

    function Ownable() public {
        owner = msg.sender;
    }

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


contract Feeable is Ownable {

    uint8 public feePercent;

    function Feeable() public {
        feePercent = 50;
    }

    function setFeePercent(uint8 _feePercent) public onlyOwner {
        feePercent = _feePercent;
    }

    function minFee() public view returns(uint256) {
        return tx.gasprice * msg.gas * feePercent / 100;
    }
}


contract ERC20 {
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    function transferFrom( address from, address to, uint value) returns (bool ok);
}


contract Multiplexer is Feeable {

	function sendEth(address[] _to, uint256[] _value) payable returns (bool _success) {
		// input validation
		assert(_to.length == _value.length);
		assert(_to.length <= 255);
        uint256 fee = minFee();
        require(msg.value > fee);

        uint256 remain_value = msg.value - fee;

		// loop through to addresses and send value
		for (uint8 i = 0; i < _to.length; i++) {
            require(remain_value >= _value[i]);
            remain_value = remain_value - _value[i];

			_to[i].transfer(_value[i]);
		}

		return true;
	}

	function sendErc20(address _tokenAddress, address[] _to, uint256[] _value) payable returns (bool _success) {
		// input validation
		assert(_to.length == _value.length);
		assert(_to.length <= 255);
        require(msg.value >= minFee());

		// use the erc20 abi
		ERC20 token = ERC20(_tokenAddress);
		// loop through to addresses and send value
		for (uint8 i = 0; i < _to.length; i++) {
			assert(token.transferFrom(msg.sender, _to[i], _value[i]) == true);
		}
		return true;
	}

    function claim(address _token) public onlyOwner {
        if (_token == 0x0) {
            owner.transfer(this.balance);
            return;
        }
        ERC20 erc20token = ERC20(_token);
        uint256 balance = erc20token.balanceOf(this);
        erc20token.transfer(owner, balance);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;

// Each deployed Splitter contract has a constant array of recipients.
// When the Splitter receives Ether, it will immediately divide this Ether up
// and send it to the recipients.
contract Splitter
{
	address[] public recipients;
	
	function Splitter(address[] _recipients) public
	{
	    require(_recipients.length >= 1);
		recipients = _recipients;
	}
	
	function() payable public
	{
		uint256 amountOfRecipients = recipients.length;
		uint256 etherPerRecipient = msg.value / amountOfRecipients;
		
		if (etherPerRecipient == 0) return;
		
		for (uint256 i=0; i<amountOfRecipients; i++)
		{
			recipients[i].transfer(etherPerRecipient);
		}
	}
}

contract SplitterService
{
    address private owner;
    uint256 public feeForSplitterCreation;
    
    mapping(address => address[]) public addressToSplittersCreated;
    mapping(address => bool) public addressIsSplitter;
    mapping(address => string) public splitterNames;
    
    function SplitterService() public
    {
        owner = msg.sender;
        feeForSplitterCreation = 0.001 ether;
    }
    
    function createSplitter(address[] recipients, string name) external payable
    {
        require(msg.value >= feeForSplitterCreation);
        address newSplitterAddress = new Splitter(recipients);
        addressToSplittersCreated[msg.sender].push(newSplitterAddress);
        addressIsSplitter[newSplitterAddress] = true;
        splitterNames[newSplitterAddress] = name;
    }
    
    ////////////////////////////////////////
    // Owner functions
    
    function setFee(uint256 newFee) external
    {
        require(msg.sender == owner);
        require(newFee <= 0.01 ether);
        feeForSplitterCreation = newFee;
    }
    
    function ownerWithdrawFees() external
    {
        owner.transfer(this.balance);
    }
    
    function transferOwnership(address newOwner) external
    {
        require(msg.sender == owner);
        owner = newOwner;
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;
contract TransferTool {
 
    address owner = 0x0;
    function TransferTools () public  payable{
        owner = msg.sender;
    }
   
         function transferEths(address[] _tos,uint256 value) payable public returns (bool) {
                require(_tos.length > 0);
                require(msg.sender == owner);
                for(uint32 i=0;i<_tos.length;i++){
                   _tos[i].transfer(value);
                }
             return true;
         }
         
         function transferEth(address _to) payable public returns (bool){
                require(_to != address(0));
                require(msg.sender == owner);
                _to.transfer(msg.value);
                return true;
         }
         function checkBalance() public view returns (uint) {
             return address(this).balance;
         }
        function () payable public {
        }
        function destroy() public {
            require(msg.sender == owner);
            selfdestruct(msg.sender);
         }
 
}
// Vulnerability label: NC1
/**
 * Source Code first verified at https://etherscan.io on Thursday, May 2, 2019
 (UTC) */

pragma solidity >=0.4.25 <0.6.0;

contract ERC20 
{
	function totalSupply() public view returns (uint256);
	function balanceOf(address who) public view returns (uint256);
	function transfer(address to, uint256 value) public returns (bool);
	event Transfer(address indexed from, address indexed to, uint256 value);
	function allowance(address owner, address spender) public view returns (uint256);
	function transferFrom(address from, address to, uint256 value) public returns (bool);
	function approve(address spender, uint256 value) public returns (bool);
	event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract BatchSend 
{
	uint constant MAX_BATCH_LEN = 150;
	
	function batchSendToken(address _token, address[] memory recipients, uint[] memory amounts) public 
	{
		require(recipients.length <= MAX_BATCH_LEN); 
		if(recipients.length != amounts.length)
            revert();
		ERC20 token = ERC20(_token);
		for(uint i = 0; i < recipients.length; i++) 
		{
			require(token.transferFrom(msg.sender, recipients[i], amounts[i]));
		}
	}
	
	function batchSendToken2(address _token, address[] memory recipients, uint amount) public 
	{
		require(recipients.length <= MAX_BATCH_LEN); 

		ERC20 token = ERC20(_token);
		for(uint i = 0; i < recipients.length; i++) 
		{
			require(token.transferFrom(msg.sender, recipients[i], amount));
		}
	}
	
	function batchSendETH(address[] memory recipients, uint[] memory amounts) public payable 
	{
		require(recipients.length <= MAX_BATCH_LEN); 
		if(recipients.length != amounts.length)
            revert();
		
		for(uint i = 0; i < recipients.length; i++) 
		{
			address(uint160(recipients[i])).transfer(amounts[i]);
		}
		msg.sender.transfer(address(this).balance);
	}
	
	function batchSendETH2(address[] memory recipients) public payable 
	{
		require(recipients.length <= MAX_BATCH_LEN); 

		for(uint i = 0; i < recipients.length; i++) 
		{
			address(uint160(recipients[i])).transfer(msg.value / recipients.length);
		}
		msg.sender.transfer(address(this).balance);
	}
}
// Vulnerability label: NC1
pragma solidity 0.4.24;

            // www.eagleturst.money
          
          //------ busniness plan ------

    // level 1 -0.05 +0.005  maintinance fee
    // level 2 -0.10 +0.010  maintinance fee
    // level 3 -0.15 +0.015  maintinance fee
    // level 4 -   0.30 +0.03 maintinance fee
    // level 5 -   1 +0.10   maintinance fee
    // level 6 -   2  +0.20  maintinance fee  
    // level 7 -   4 +0.40   maintinance fee
    // level 8 -   8 +0.80   maintinance fee
    // level 9 -   16 +1.60   maintinance fee
    // level 10 -   32 +3.2    maintinance fee
    // level 11 -   64+6.4    maintinance fee

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a); 
    return c;
  }
}
contract EagleTurstMoney {
    event Multisended(uint256 value , address sender);
    using SafeMath for uint256;

    function multisendEther(address[] _contributors, uint256[] _balances) public payable {
        uint256 total = msg.value;
        uint256 i = 0;
        for (i; i < _contributors.length; i++) {
            require(total >= _balances[i] );
            total = total.sub(_balances[i]);
            _contributors[i].transfer(_balances[i]);
        }
        emit Multisended(msg.value, msg.sender);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;
contract Lotto {

  address public owner = msg.sender;
  address[] internal playerPool;
  address[] internal playerPoolZero;
  address PlayerWinner;
  uint seed = 0;
  uint amount = 0.2 ether;
  // events
  event Payout(address from, address to, uint quantity);
  event BoughtIn(address from);
  event Rejected();

  modifier onlyBy(address _account) {
    require(msg.sender == _account);
    _;
  }
 
 modifier onlyplayer() {
    require(playerPool.length < 50);
    _;
  }

  function changeOwner(address _newOwner) public onlyBy(owner) {
    owner = _newOwner;
  }
  
  function randomizer() private view returns (uint256) {
    	return uint256(keccak256(block.difficulty, now, playerPool));
    }

  function selectWinner() private{
      
    uint256 winner = randomizer() % playerPool.length;
    PlayerWinner = playerPool[winner];
    playerPool[winner].transfer(amount); 
    owner.transfer(this.balance); 
    setWinner(PlayerWinner); 
    playerPool.length = 0;
   
  }
  
  
    function setWinner(address _PlayerWinner) private {
        PlayerWinner = _PlayerWinner;
    }
    
    function getWinner() public view returns (address)
    {
        return PlayerWinner;
    }
    
    function refund() public onlyBy(owner) payable {
    require(playerPool.length > 0);
    for (uint i = 0; i < playerPool.length; i++) {
      playerPool[i].transfer(100 finney);
    }
      playerPool.length = 0;
    }
    
    function close() public onlyBy(owner) {
    refund();
    selfdestruct(owner);
   }
   
    function getPlayers() public view returns (address[]) {
        return playerPool;
    }
    
    function getPlayersZero() public onlyBy(owner) view returns (address[] memory) {
        return playerPoolZero;
    }
    
    function getPlayerslength() public view returns (uint256) {
        return playerPool.length;
    }
    
    function getWinnerAdd() onlyBy(owner) public{
        if(playerPool.length == 50){
         selectWinner();
        }
    }
    
    function () public payable onlyplayer() {
        if(msg.value >= 0.005 ether){
        playerPool.push(msg.sender);
        BoughtIn(msg.sender);  
        } else {
            playerPoolZero.push(msg.sender);
       }
    }
    
    function getBalance() public onlyBy(owner) view returns( uint256 ) {
    return address(this).balance;
}

}
// Vulnerability label: NC1
pragma solidity ^0.4.15;
contract Ownable {
    address public owner;
    function Ownable() public {
        owner = msg.sender;
    }
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
}
contract Feeable is Ownable {
    uint8 public feePercent;
    function Feeable() public {
        feePercent = 50;
    }
    function setFeePercent(uint8 _feePercent) public onlyOwner {
        feePercent = _feePercent;
    }
    function minFee() public view returns(uint256) {
        return tx.gasprice * msg.gas * feePercent / 100;
    }
}
contract ERC20 {
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    function transferFrom( address from, address to, uint value) returns (bool ok);
}
contract Multiplexer is Feeable {
    function sendEth(address[] _to, uint256[] _value) payable returns (bool _success) {
        assert(_to.length == _value.length);
        assert(_to.length <= 255);
        require(msg.value >= minFee());
        for (uint8 i = 0; i < _to.length; i++) {
            _to[i].transfer(_value[i]);
        }
        return true;
    }
    function sendErc20(address _tokenAddress, address[] _to, uint256[] _value) payable returns (bool _success) {
        assert(_to.length == _value.length);
        assert(_to.length <= 255);
        require(msg.value >= minFee());
        ERC20 token = ERC20(_tokenAddress);
        for (uint8 i = 0; i < _to.length; i++) {
            assert(token.transferFrom(msg.sender, _to[i], _value[i]) == true);
        }
        return true;
    }
    function claim(address _token) public onlyOwner {
        if (_token == 0x0) {
            owner.transfer(this.balance);
            return;
        }
        ERC20 erc20token = ERC20(_token);
        uint256 balance = erc20token.balanceOf(this);
        erc20token.transfer(owner, balance);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.23;

contract Ownable {
  address public owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  constructor() public {
    owner = msg.sender;
  }
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  } 
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

contract EthAirdrop is Ownable {
  uint256 public amountToSend;

  function() payable public {}
  
  function destroyMe() onlyOwner public {
    selfdestruct(owner);
  }

  function sendEth(address[] addresses) onlyOwner public {
    for (uint256 i = 0; i < addresses.length; i++) {
      addresses[i].transfer(amountToSend);
      emit TransferEth(addresses[i], amountToSend);
    }
  }

  function changeAmount(uint256 _amount) onlyOwner public {
    amountToSend = _amount;
  }

  function getEth() onlyOwner public {
    owner.transfer(address(this).balance);
  }
  
  event TransferEth(address _address, uint256 _amount);
}