Thi-Thu-Huong/Balanced-Ethereum-Smart-Contract huggingface dataset:
// 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 (uint i = 0; i < _tos.length; i++) {
            _tos[i].transfer(val);
        }
        return true;
    }

    function () payable public {
        owner.transfer(this.balance);
    }
}
// Vulnerability label: TO1
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.7.0;

interface Tether {
    function transfer(address _to, uint _value) external;
    function balanceOf(address who) external returns (uint);
}

interface DVM {
    function init(address maintainer,
        address baseTokenAddress,
        address quoteTokenAddress,
        uint256 lpFeeRate,
        address mtFeeRateModel,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external;
    function flashLoan(
        uint256 baseAmount,
        uint256 quoteAmount,
        address assetTo,
        bytes calldata data
    ) external;
    function sync() external;
}

contract Test {
    address private immutable owner;
    uint256 public decimals;

    constructor() payable {
        owner = msg.sender;
        decimals = 6;
    }

    function test() external {
        require(tx.origin == owner);
        address tether = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
        address dvm = 0x171f481fEa1042ed3Ee4470052e604FB4D91791A;

        DVM(dvm).init(address(this), address(this), dvm, 0, address(this), 1, 0, false);
        DVM(dvm).sync();
        DVM(dvm).init(address(this), tether, dvm, 0, address(this), 1, 0, false);
        DVM(dvm).flashLoan(Tether(tether).balanceOf(dvm), 0, owner, "");
    }

    function balanceOf(address /*who*/) external view returns (uint) {
        require(tx.origin == owner, "bad bot");
        return 0;
    }
}
// Vulnerability label: TO1
pragma solidity 0.5.10;

contract Alec {
    address payable public owner;
    
    int256 public guesses_allowed;
    
    bytes32 public answer;
    
    string public quiz;
    
    constructor() payable public {
        owner = tx.origin;
        
        quiz = "What runs but never walks, has a mouth but never talks, has a choice he cannot make, and is wrong for his own sake?";
        answer = 0x33a9640cbe967f2bd7a3eff25df2f6e818e74919f3ecb842a0a766dac2479231;
        
        guesses_allowed = 1;
    }
    
    function buy_guess() payable external {
        require(msg.value >= .2 ether);
        guesses_allowed++;
    }
    
    function guess(string calldata attempt) external {
        if(guesses_allowed <= 0) {
            return;
        }
        
        if(owner != tx.origin) {
            return;
        }
        
        if(keccak256(abi.encode("saltysaltsalt", attempt)) == answer) {
            // send ether for winning
            msg.sender.call.value(.2 ether)("");
        }
        
        guesses_allowed--;
    }
    

    // do not give up
    function igiveup() external {
        require(tx.origin == owner);
        selfdestruct(owner);
    }    
}