Upload 190 files

benchmark2/integer overflow/21.sol

@@ -0,0 +1,137 @@
+pragma solidity ^0.4.24;
+
+
+library SafeMath {
+  function mul(uint256 a, uint256 b) pure internal returns (uint256) {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function div(uint256 a, uint256 b) pure internal returns (uint256) {
+    
+    uint256 c = a / b;
+    
+    return c;
+  }
+
+  function sub(uint256 a, uint256 b) pure internal returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint256 a, uint256 b) pure internal returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+contract ERC20Basic {
+  uint256 public totalSupply;
+  function balanceOf(address who) public constant returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  function balanceOf(address _owner) public constant returns (uint256 balance) {
+    return balances[_owner];
+  }
+
+}
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public constant returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    Transfer(_from, _to, _value);
+    return true;
+  }
+
+
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    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];
+  }
+
+
+  function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
+    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+
+contract WPAYCoin is StandardToken {
+
+  string public constant name = "WPAYCoin";
+  string public constant symbol = "WPY";
+  uint8 public constant decimals = 6;
+
+  uint256 public constant INITIAL_SUPPLY = 600000000 * (10 ** uint256(decimals));
+
+
+  function WPAYCoin() public {
+    totalSupply = INITIAL_SUPPLY;
+    balances[msg.sender] = INITIAL_SUPPLY;
+  }
+
+}

benchmark2/integer overflow/22.sol

@@ -0,0 +1,418 @@
+pragma solidity ^0.4.24;
+
+contract ERC20Basic {
+    function totalSupply() public view returns (uint256);
+    function balanceOf(address _who) public view returns (uint256);
+    function transfer(address _to, uint256 _value) public returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+library SafeMath {
+
+    
+    function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+        
+        
+        
+        if (_a == 0) {
+            return 0;
+        }
+
+        c = _a * _b;
+        assert(c / _a == _b);
+        return c;
+    }
+
+    
+    function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        
+        
+        
+        return _a / _b;
+    }
+
+    
+    function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        assert(_b <= _a);
+        return _a - _b;
+    }
+
+    
+    function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+        c = _a + _b;
+        assert(c >= _a);
+        return c;
+    }
+}
+
+contract BasicToken is ERC20Basic {
+    using SafeMath for uint256;
+
+    mapping(address => uint256) internal balances;
+
+    uint256 internal totalSupply_;
+
+    
+    function totalSupply() public view returns (uint256) {
+        return totalSupply_;
+    }
+
+    
+    function transfer(address _to, uint256 _value) public returns (bool) {
+        require(_value <= balances[msg.sender]);
+        require(_to != address(0));
+
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    
+    function balanceOf(address _owner) public view returns (uint256) {
+        return balances[_owner];
+    }
+
+}
+
+contract ERC20 is ERC20Basic {
+    function allowance(address _owner, address _spender)
+    public view returns (uint256);
+
+    function transferFrom(address _from, address _to, uint256 _value)
+    public returns (bool);
+
+    function approve(address _spender, uint256 _value) public returns (bool);
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}
+
+
+contract StandardToken is ERC20, BasicToken {
+
+    mapping (address => mapping (address => uint256)) internal allowed;
+
+
+    
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+    public
+    returns (bool)
+    {
+        require(_value <= balances[_from]);
+        require(_value <= allowed[_from][msg.sender]);
+        require(_to != address(0));
+
+        balances[_from] = balances[_from].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    
+    function approve(address _spender, uint256 _value) public returns (bool) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function allowance(
+        address _owner,
+        address _spender
+    )
+    public
+    view
+    returns (uint256)
+    {
+        return allowed[_owner][_spender];
+    }
+
+    
+    function increaseApproval(
+        address _spender,
+        uint256 _addedValue
+    )
+    public
+    returns (bool)
+    {
+        allowed[msg.sender][_spender] = (
+        allowed[msg.sender][_spender].add(_addedValue));
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    
+    function decreaseApproval(
+        address _spender,
+        uint256 _subtractedValue
+    )
+    public
+    returns (bool)
+    {
+        uint256 oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue >= oldValue) {
+            allowed[msg.sender][_spender] = 0;
+        } else {
+            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+}
+
+contract XinCoin is StandardToken {
+    address public admin;
+    string public name = "XinCoin";
+    string public symbol = "XC";
+    uint8 public decimals = 8;
+    uint256 public INITIAL_SUPPLY = 100000000000000000;
+
+    mapping (address => bool) public frozenAccount; 
+    mapping (address => uint256) public frozenTimestamp; 
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Burn(address indexed from, uint256 value);
+
+    constructor() public {
+        totalSupply_ = INITIAL_SUPPLY;
+        admin = msg.sender;
+        balances[msg.sender] = INITIAL_SUPPLY;
+    }
+
+    function() public payable {
+        require(msg.value > 0);
+    }
+
+    function changeAdmin(
+        address _newAdmin
+    )
+    public returns (bool)  {
+        require(msg.sender == admin);
+        require(_newAdmin != address(0));
+        balances[_newAdmin] = balances[_newAdmin].add(balances[admin]);
+        balances[admin] = 0;
+        admin = _newAdmin;
+        return true;
+    }
+
+    function generateToken(
+        address _target,
+        uint256 _amount
+    )
+    public returns (bool)  {
+        require(msg.sender == admin);
+        require(_target != address(0));
+        balances[_target] = balances[_target].add(_amount);
+        totalSupply_ = totalSupply_.add(_amount);
+        INITIAL_SUPPLY = totalSupply_;
+        return true;
+    }
+
+    function withdraw (
+        uint256 _amount
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        msg.sender.transfer(_amount);
+        return true;
+    }
+
+    function freeze(
+        address _target,
+        bool _freeze
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        require(_target != address(0));
+        frozenAccount[_target] = _freeze;
+        return true;
+    }
+
+    function freezeWithTimestamp(
+        address _target,
+        uint256 _timestamp
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        require(_target != address(0));
+        frozenTimestamp[_target] = _timestamp;
+        return true;
+    }
+
+    function multiFreeze(
+        address[] _targets,
+        bool[] _freezes
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        require(_targets.length == _freezes.length);
+        uint256 len = _targets.length;
+        require(len > 0);
+        for (uint256 i = 0; i < len; i = i.add(1)) {
+            address _target = _targets[i];
+            require(_target != address(0));
+            bool _freeze = _freezes[i];
+            frozenAccount[_target] = _freeze;
+        }
+        return true;
+    }
+
+    function multiFreezeWithTimestamp(
+        address[] _targets,
+        uint256[] _timestamps
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        require(_targets.length == _timestamps.length);
+        uint256 len = _targets.length;
+        require(len > 0);
+        for (uint256 i = 0; i < len; i = i.add(1)) {
+            address _target = _targets[i];
+            require(_target != address(0));
+            uint256 _timestamp = _timestamps[i];
+            frozenTimestamp[_target] = _timestamp;
+        }
+        return true;
+    }
+
+    function multiTransfer(
+        address[] _tos,
+        uint256[] _values
+    )
+    public returns (bool) {
+        require(!frozenAccount[msg.sender]);
+        require(now > frozenTimestamp[msg.sender]);
+        require(_tos.length == _values.length);
+        uint256 len = _tos.length;
+        require(len > 0);
+        uint256 amount = 0;
+        for (uint256 i = 0; i < len; i = i.add(1)) {
+            amount = amount.add(_values[i]);
+        }
+        require(amount <= balances[msg.sender]);
+        for (uint256 j = 0; j < len; j = j.add(1)) {
+            address _to = _tos[j];
+            require(_to != address(0));
+            balances[_to] = balances[_to].add(_values[j]);
+            balances[msg.sender] = balances[msg.sender].sub(_values[j]);
+            emit Transfer(msg.sender, _to, _values[j]);
+        }
+        return true;
+    }
+
+    function transfer(
+        address _to,
+        uint256 _value
+    )
+    public returns (bool) {
+        require(!frozenAccount[msg.sender]);
+        require(now > frozenTimestamp[msg.sender]);
+        require(_to != address(0));
+        require(_value <= balances[msg.sender]);
+
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+    public returns (bool)
+    {
+        require(!frozenAccount[_from]);
+        require(now > frozenTimestamp[msg.sender]);
+        require(_to != address(0));
+        require(_value <= balances[_from]);
+        require(_value <= allowed[_from][msg.sender]);
+
+        balances[_from] = balances[_from].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    function approve(
+        address _spender,
+        uint256 _value
+    )
+    public returns (bool) {
+        require(_value <= balances[_spender]);
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function burn(uint256 _value)
+    public returns (bool) {
+        require(_value <= balances[msg.sender]);   
+        balances[msg.sender] = balances[msg.sender].sub(_value);            
+        totalSupply_ = totalSupply_.sub(_value);
+        INITIAL_SUPPLY = totalSupply_;
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    function getFrozenTimestamp(
+        address _target
+    )
+    public view returns (uint256) {
+        require(_target != address(0));
+        return frozenTimestamp[_target];
+    }
+
+    function getFrozenAccount(
+        address _target
+    )
+    public view returns (bool) {
+        require(_target != address(0));
+        return frozenAccount[_target];
+    }
+
+    function getBalance(address _owner)
+    public view returns (uint256) {
+        return balances[_owner];
+    }
+
+    function setName (
+        string _value
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        name = _value;
+        return true;
+    }
+
+    function setSymbol (
+        string _value
+    )
+    public returns (bool) {
+        require(msg.sender == admin);
+        symbol = _value;
+        return true;
+    }
+
+    function kill()
+    public {
+        require(msg.sender == admin);
+        selfdestruct(admin);
+    }
+
+}

benchmark2/integer overflow/225.sol

@@ -0,0 +1,183 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+  function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    if (_a == 0) {
+      return 0;
+    }
+
+    uint256 c = _a * _b;
+    require(c / _a == _b);
+
+    return c;
+  }
+
+  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    require(_b > 0); 
+    uint256 c = _a / _b;
+    
+
+    return c;
+  }
+  
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    require(_b <= _a);
+    uint256 c = _a - _b;
+
+    return c;
+  }
+
+  function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    uint256 c = _a + _b;
+    require(c >= _a);
+
+    return c;
+  }
+  
+  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b != 0);
+    return a % b;
+  }
+}
+
+contract ERC20 {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address _who) public view returns (uint256);
+  function allowance(address _owner, address _spender)
+    public view returns (uint256);
+	
+  function transfer(address _to, uint256 _value) public returns (bool);
+  function approve(address _spender, uint256 _value)
+    public returns (bool);
+
+  function transferFrom(address _from, address _to, uint256 _value)
+    public returns (bool);
+
+  event Transfer(
+    address indexed from,
+    address indexed to,
+    uint256 value
+  );
+
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+contract StandardToken is ERC20 {
+  using SafeMath for uint256;
+
+  mapping (address => uint256) private balances;
+
+  mapping (address => mapping (address => uint256)) private allowed;
+
+  uint256 private totalSupply_;
+
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_value <= balances[msg.sender]);
+    require(_to != address(0));
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+    require(_to != address(0));
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue >= oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  function _mint(address _account, uint256 _amount) internal {
+    require(_account != 0);
+    totalSupply_ = totalSupply_.add(_amount);
+    balances[_account] = balances[_account].add(_amount);
+    emit Transfer(address(0), _account, _amount);
+  }
+  
+  function _burn(address _account, uint256 _amount) internal {
+    require(_account != 0);
+    require(_amount <= balances[_account]);
+
+    totalSupply_ = totalSupply_.sub(_amount);
+    balances[_account] = balances[_account].sub(_amount);
+    emit Transfer(_account, address(0), _amount);
+  }
+  
+  function _burnFrom(address _account, uint256 _amount) internal {
+    require(_amount <= allowed[_account][msg.sender]);
+    allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount);
+    _burn(_account, _amount);
+  }
+}

benchmark2/integer overflow/241.sol

@@ -0,0 +1,287 @@
+pragma solidity ^0.4.19;
+
+library SafeMath {
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a / b;
+    return c;
+  }
+
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract ForeignToken {
+    function balanceOf(address _owner) constant public returns (uint256);
+    function transfer(address _to, uint256 _value) public returns (bool);
+}
+
+contract ERC20Basic {
+    uint256 public totalSupply;
+    function balanceOf(address who) public constant returns (uint256);
+    function transfer(address to, uint256 value) public returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+    function allowance(address owner, address spender) public constant returns (uint256);
+    function transferFrom(address from, address to, uint256 value) public returns (bool);
+    function approve(address spender, uint256 value) public returns (bool);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+interface Token { 
+    function distr(address _to, uint256 _value) public returns (bool);
+    function totalSupply() constant public returns (uint256 supply);
+    function balanceOf(address _owner) constant public returns (uint256 balance);
+}
+
+contract BEN is ERC20 {
+    
+    using SafeMath for uint256;
+    address owner = msg.sender;
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+    mapping (address => bool) public blacklist;
+
+    string public constant name = "BENetwork";
+    string public constant symbol = "BEN";
+    uint public constant decimals = 8;
+    
+        uint256 public totalSupply = 100000000e8;
+    uint256 public totalDistributed = 10000000e8;
+    uint256 public totalRemaining = totalSupply.sub(totalDistributed);
+    uint256 public value;
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+    
+    event Distr(address indexed to, uint256 amount);
+    event DistrFinished();
+    
+    event Burn(address indexed burner, uint256 value);
+
+    bool public distributionFinished = false;
+    
+    modifier canDistr() {
+        require(!distributionFinished);
+        _;
+    }
+    
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+    
+    modifier onlyWhitelist() {
+        require(blacklist[msg.sender] == false);
+        _;
+    }
+    
+    function BEN () public {
+        owner = msg.sender;
+        value = 400e8;
+        distr(owner, totalDistributed);
+    }
+    
+    function transferOwnership(address newOwner) onlyOwner public {
+        if (newOwner != address(0)) {
+            owner = newOwner;
+        }
+    }
+    
+    function enableWhitelist(address[] addresses) onlyOwner public {
+        for (uint i = 0; i < addresses.length; i++) {
+            blacklist[addresses[i]] = false;
+        }
+    }
+
+    function disableWhitelist(address[] addresses) onlyOwner public {
+        for (uint i = 0; i < addresses.length; i++) {
+            blacklist[addresses[i]] = true;
+        }
+    }
+
+    function finishDistribution() onlyOwner canDistr public returns (bool) {
+        distributionFinished = true;
+        DistrFinished();
+        return true;
+    }
+    
+    function distr(address _to, uint256 _amount) canDistr private returns (bool) {
+        totalDistributed = totalDistributed.add(_amount);
+        totalRemaining = totalRemaining.sub(_amount);
+        balances[_to] = balances[_to].add(_amount);
+        Distr(_to, _amount);
+        Transfer(address(0), _to, _amount);
+        return true;
+        
+        if (totalDistributed >= totalSupply) {
+            distributionFinished = true;
+        }
+    }
+    
+    function airdrop(address[] addresses) onlyOwner canDistr public {
+        
+        require(addresses.length <= 255);
+        require(value <= totalRemaining);
+        
+        for (uint i = 0; i < addresses.length; i++) {
+            require(value <= totalRemaining);
+            distr(addresses[i], value);
+        }
+	
+        if (totalDistributed >= totalSupply) {
+            distributionFinished = true;
+        }
+    }
+    
+    function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
+        
+        require(addresses.length <= 255);
+        require(amount <= totalRemaining);
+        
+        for (uint i = 0; i < addresses.length; i++) {
+            require(amount <= totalRemaining);
+            distr(addresses[i], amount);
+        }
+	
+        if (totalDistributed >= totalSupply) {
+            distributionFinished = true;
+        }
+    }
+    
+    function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
+
+        require(addresses.length <= 255);
+        require(addresses.length == amounts.length);
+        
+        for (uint8 i = 0; i < addresses.length; i++) {
+            require(amounts[i] <= totalRemaining);
+            distr(addresses[i], amounts[i]);
+            
+            if (totalDistributed >= totalSupply) {
+                distributionFinished = true;
+            }
+        }
+    }
+    
+    function () external payable {
+            getTokens();
+     }
+    
+    function getTokens() payable canDistr onlyWhitelist public {
+        
+        if (value > totalRemaining) {
+            value = totalRemaining;
+        }
+        
+        require(value <= totalRemaining);
+        
+        address investor = msg.sender;
+        uint256 toGive = value;
+        
+        distr(investor, toGive);
+        
+        if (toGive > 0) {
+            blacklist[investor] = true;
+        }
+
+        if (totalDistributed >= totalSupply) {
+            distributionFinished = true;
+        }
+        
+        value = value.div(100000).mul(99999);
+    }
+
+    function balanceOf(address _owner) constant public returns (uint256) {
+	    return balances[_owner];
+    }
+
+    // mitigates the ERC20 short address attack
+    modifier onlyPayloadSize(uint size) {
+        assert(msg.data.length >= size + 4);
+        _;
+    }
+    
+    function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
+
+        require(_to != address(0));
+        require(_amount <= balances[msg.sender]);
+        
+        balances[msg.sender] = balances[msg.sender].sub(_amount);
+        balances[_to] = balances[_to].add(_amount);
+        Transfer(msg.sender, _to, _amount);
+        return true;
+    }
+    
+    function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
+
+        require(_to != address(0));
+        require(_amount <= balances[_from]);
+        require(_amount <= allowed[_from][msg.sender]);
+        
+        balances[_from] = balances[_from].sub(_amount);
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
+        balances[_to] = balances[_to].add(_amount);
+        Transfer(_from, _to, _amount);
+        return true;
+    }
+    
+    function approve(address _spender, uint256 _value) public returns (bool success) {
+        // mitigates the ERC20 spend/approval race condition
+        if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+    
+    function allowance(address _owner, address _spender) constant public returns (uint256) {
+        return allowed[_owner][_spender];
+    }
+    
+    function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
+        ForeignToken t = ForeignToken(tokenAddress);
+        uint bal = t.balanceOf(who);
+        return bal;
+    }
+    
+    function withdraw() onlyOwner public {
+        uint256 etherBalance = this.balance;
+        owner.transfer(etherBalance);
+    }
+    
+    function burn(uint256 _value) onlyOwner public {
+        require(_value <= balances[msg.sender]);
+        // no need to require value <= totalSupply, since that would imply the
+        // sender's balance is greater than the totalSupply, which *should* be an assertion failure
+
+        address burner = msg.sender;
+        balances[burner] = balances[burner].sub(_value);
+        totalSupply = totalSupply.sub(_value);
+        totalDistributed = totalDistributed.sub(_value);
+        Burn(burner, _value);
+    }
+    
+    function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
+        ForeignToken token = ForeignToken(_tokenContract);
+        uint256 amount = token.balanceOf(address(this));
+        return token.transfer(owner, amount);
+    }
+
+
+}

benchmark2/integer overflow/253.sol

@@ -0,0 +1,317 @@
+pragma solidity ^0.4.24;
+
+contract SafeMath {
+    function safeMul(uint a, uint b) internal returns (uint) {
+        uint c = a * b;
+        assert(a == 0 || c / a == b);
+        return c;
+    }
+
+    function safeSub(uint a, uint b) internal returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    function safeAdd(uint a, uint b) internal returns (uint) {
+        uint c = a + b;
+        assert(c>=a && c>=b);
+        return c;
+    }
+
+    function assert(bool assertion) internal {
+        if (!assertion) throw;
+    }
+}
+
+contract AccessControl is SafeMath{
+
+    
+    event ContractUpgrade(address newContract);
+
+    
+    address public ceoAddress;
+    address public cfoAddress;
+    address public cooAddress;
+
+    address newContractAddress;
+
+    uint public tip_total = 0;
+    uint public tip_rate = 20000000000000000;
+
+    
+    bool public paused = false;
+
+    
+    modifier onlyCEO() {
+        require(msg.sender == ceoAddress);
+        _;
+    }
+
+    
+    modifier onlyCFO() {
+        require(msg.sender == cfoAddress);
+        _;
+    }
+
+    
+    modifier onlyCOO() {
+        require(msg.sender == cooAddress);
+        _;
+    }
+
+    modifier onlyCLevel() {
+        require(
+            msg.sender == cooAddress ||
+            msg.sender == ceoAddress ||
+            msg.sender == cfoAddress
+        );
+        _;
+    }
+
+    function () public payable{
+        tip_total = safeAdd(tip_total, msg.value);
+    }
+
+    
+    
+    function amountWithTip(uint amount) internal returns(uint){
+        uint tip = safeMul(amount, tip_rate) / (1 ether);
+        tip_total = safeAdd(tip_total, tip);
+        return safeSub(amount, tip);
+    }
+
+    
+    function withdrawTip(uint amount) external onlyCFO {
+        require(amount > 0 && amount <= tip_total);
+        require(msg.sender.send(amount));
+        tip_total = tip_total - amount;
+    }
+
+    
+    function setNewAddress(address newContract) external onlyCEO whenPaused {
+        newContractAddress = newContract;
+        emit ContractUpgrade(newContract);
+    }
+
+    
+    
+    function setCEO(address _newCEO) external onlyCEO {
+        require(_newCEO != address(0));
+
+        ceoAddress = _newCEO;
+    }
+
+    
+    
+    function setCFO(address _newCFO) external onlyCEO {
+        require(_newCFO != address(0));
+
+        cfoAddress = _newCFO;
+    }
+
+    
+    
+    function setCOO(address _newCOO) external onlyCEO {
+        require(_newCOO != address(0));
+
+        cooAddress = _newCOO;
+    }
+
+    
+
+    
+    modifier whenNotPaused() {
+        require(!paused);
+        _;
+    }
+
+    
+    modifier whenPaused {
+        require(paused);
+        _;
+    }
+
+    
+    
+    function pause() external onlyCLevel whenNotPaused {
+        paused = true;
+    }
+
+    
+    
+    
+    
+    
+    function unpause() public onlyCEO whenPaused {
+        
+        paused = false;
+    }
+}
+
+
+contract RpsGame is SafeMath , AccessControl{
+
+    
+    uint8 constant public NONE = 0;
+    uint8 constant public ROCK = 10;
+    uint8 constant public PAPER = 20;
+    uint8 constant public SCISSORS = 30;
+    uint8 constant public DEALERWIN = 201;
+    uint8 constant public PLAYERWIN = 102;
+    uint8 constant public DRAW = 101;
+
+    
+    event CreateGame(uint gameid, address dealer, uint amount);
+    event JoinGame(uint gameid, address player, uint amount);
+    event Reveal(uint gameid, address player, uint8 choice);
+    event CloseGame(uint gameid,address dealer,address player, uint8 result);
+
+    
+    struct Game {
+        uint expireTime;
+        address dealer;
+        uint dealerValue;
+        bytes32 dealerHash;
+        uint8 dealerChoice;
+        address player;
+        uint8 playerChoice;
+        uint playerValue;
+        uint8 result;
+        bool closed;
+    }
+
+    
+    mapping (uint => mapping(uint => uint8)) public payoff;
+    mapping (uint => Game) public games;
+    mapping (address => uint[]) public gameidsOf;
+
+    
+    uint public maxgame = 0;
+    uint public expireTimeLimit = 30 minutes;
+
+    
+    function RpsGame() {
+        payoff[ROCK][ROCK] = DRAW;
+        payoff[ROCK][PAPER] = PLAYERWIN;
+        payoff[ROCK][SCISSORS] = DEALERWIN;
+        payoff[PAPER][ROCK] = DEALERWIN;
+        payoff[PAPER][PAPER] = DRAW;
+        payoff[PAPER][SCISSORS] = PLAYERWIN;
+        payoff[SCISSORS][ROCK] = PLAYERWIN;
+        payoff[SCISSORS][PAPER] = DEALERWIN;
+        payoff[SCISSORS][SCISSORS] = DRAW;
+        payoff[NONE][NONE] = DRAW;
+        payoff[ROCK][NONE] = DEALERWIN;
+        payoff[PAPER][NONE] = DEALERWIN;
+        payoff[SCISSORS][NONE] = DEALERWIN;
+        payoff[NONE][ROCK] = PLAYERWIN;
+        payoff[NONE][PAPER] = PLAYERWIN;
+        payoff[NONE][SCISSORS] = PLAYERWIN;
+
+        ceoAddress = msg.sender;
+        cooAddress = msg.sender;
+        cfoAddress = msg.sender;
+    }
+
+    
+    function createGame(bytes32 dealerHash, address player) public payable whenNotPaused returns (uint){
+        require(dealerHash != 0x0);
+
+        maxgame += 1;
+        Game storage game = games[maxgame];
+        game.dealer = msg.sender;
+        game.player = player;
+        game.dealerHash = dealerHash;
+        game.dealerChoice = NONE;
+        game.dealerValue = msg.value;
+        game.expireTime = expireTimeLimit + now;
+
+        gameidsOf[msg.sender].push(maxgame);
+
+        emit CreateGame(maxgame, game.dealer, game.dealerValue);
+
+        return maxgame;
+    }
+
+    
+    function joinGame(uint gameid, uint8 choice) public payable whenNotPaused returns (uint){
+        Game storage game = games[gameid];
+
+        require(msg.value == game.dealerValue && game.dealer != address(0) && game.dealer != msg.sender && game.playerChoice==NONE);
+        require(game.player == address(0) || game.player == msg.sender);
+        require(!game.closed);
+        require(now < game.expireTime);
+        require(checkChoice(choice));
+
+        game.player = msg.sender;
+        game.playerChoice = choice;
+        game.playerValue = msg.value;
+        game.expireTime = expireTimeLimit + now;
+
+        gameidsOf[msg.sender].push(gameid);
+
+        emit JoinGame(gameid, game.player, game.playerValue);
+
+        return gameid;
+    }
+
+    
+    function reveal(uint gameid, uint8 choice, bytes32 randomSecret) public returns (bool) {
+        Game storage game = games[gameid];
+        bytes32 proof = getProof(msg.sender, choice, randomSecret);
+
+        require(!game.closed);
+        require(now < game.expireTime);
+        require(game.dealerHash != 0x0);
+        require(checkChoice(choice));
+        require(checkChoice(game.playerChoice));
+        require(game.dealer == msg.sender && proof == game.dealerHash );
+
+        game.dealerChoice = choice;
+
+        Reveal(gameid, msg.sender, choice);
+
+        close(gameid);
+
+        return true;
+    }
+
+    
+    function close(uint gameid) public returns(bool) {
+        Game storage game = games[gameid];
+
+        require(!game.closed);
+        require(now > game.expireTime || (game.dealerChoice != NONE && game.playerChoice != NONE));
+
+        uint8 result = payoff[game.dealerChoice][game.playerChoice];
+
+        if(result == DEALERWIN){
+            require(game.dealer.send(amountWithTip(safeAdd(game.dealerValue, game.playerValue))));
+        }else if(result == PLAYERWIN){
+            require(game.player.send(amountWithTip(safeAdd(game.dealerValue, game.playerValue))));
+        }else if(result == DRAW){
+            require(game.dealer.send(game.dealerValue) && game.player.send(game.playerValue));
+        }
+
+        game.closed = true;
+        game.result = result;
+
+        emit CloseGame(gameid, game.dealer, game.player, result);
+
+        return game.closed;
+    }
+
+
+    function getProof(address sender, uint8 choice, bytes32 randomSecret) public view returns (bytes32){
+        return sha3(sender, choice, randomSecret);
+    }
+
+    function gameCountOf(address owner) public view returns (uint){
+        return gameidsOf[owner].length;
+    }
+
+    function checkChoice(uint8 choice) public view returns (bool){
+        return choice==ROCK||choice==PAPER||choice==SCISSORS;
+    }
+
+}

benchmark2/integer overflow/262.sol

@@ -0,0 +1,223 @@
+pragma solidity ^0.4.18;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+contract SafeMath {
+    function safeAdd(uint a, uint b) public pure returns (uint c) {
+        c = a + b;
+        require(c >= a);
+    }
+    function safeSub(uint a, uint b) public pure returns (uint c) {
+        require(b <= a);
+        c = a - b;
+    }
+    function safeMul(uint a, uint b) public pure returns (uint c) {
+        c = a * b;
+        require(a == 0 || c / a == b);
+    }
+    function safeDiv(uint a, uint b) public pure returns (uint c) {
+        require(b > 0);
+        c = a / b;
+    }
+}
+
+
+
+
+
+
+contract ERC20Interface {
+    function totalSupply() public constant returns (uint);
+    function balanceOf(address tokenOwner) public constant returns (uint balance);
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
+    function transfer(address to, uint tokens) public returns (bool success);
+    function approve(address spender, uint tokens) public returns (bool success);
+    function transferFrom(address from, address to, uint tokens) public returns (bool success);
+
+    event Transfer(address indexed from, address indexed to, uint tokens);
+    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
+}
+
+
+
+
+
+
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
+}
+
+
+
+
+
+contract Owned {
+    address public owner;
+    address public newOwner;
+
+    event OwnershipTransferred(address indexed _from, address indexed _to);
+
+    function Owned() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address _newOwner) public onlyOwner {
+        newOwner = _newOwner;
+    }
+    function acceptOwnership() public {
+        require(msg.sender == newOwner);
+        OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+        newOwner = address(0);
+    }
+}
+
+
+
+
+
+
+contract GroovaToken is ERC20Interface, Owned, SafeMath {
+    string public symbol;
+    string public  name;
+    uint8 public decimals;
+    uint public _totalSupply;
+
+    mapping(address => uint) balances;
+    mapping(address => mapping(address => uint)) allowed;
+
+
+    
+    
+    
+    constructor() public {
+        symbol = "GRV";
+        name = "Groova Token";
+        decimals = 0;
+        _totalSupply = 1000000;
+        balances[0x7f0f94823D1b0fc4D251A72e9375F2AfdA2faba3] = _totalSupply;
+        Transfer(address(0), 0x7f0f94823D1b0fc4D251A72e9375F2AfdA2faba3, _totalSupply);
+    }
+
+
+    
+    
+    
+    function totalSupply() public constant returns (uint) {
+        return _totalSupply  - balances[address(0)];
+    }
+
+
+    
+    
+    
+    function balanceOf(address tokenOwner) public constant returns (uint balance) {
+        return balances[tokenOwner];
+    }
+
+
+    
+    
+    
+    
+    
+    function transfer(address to, uint tokens) public returns (bool success) {
+        balances[msg.sender] = safeSub(balances[msg.sender], tokens);
+        balances[to] = safeAdd(balances[to], tokens);
+        Transfer(msg.sender, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    function approve(address spender, uint tokens) public returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        Approval(msg.sender, spender, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
+        balances[from] = safeSub(balances[from], tokens);
+        allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
+        balances[to] = safeAdd(balances[to], tokens);
+        Transfer(from, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
+        return allowed[tokenOwner][spender];
+    }
+
+
+    
+    
+    
+    
+    
+    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        Approval(msg.sender, spender, tokens);
+        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
+        return true;
+    }
+
+
+    
+    
+    
+    function () public payable {
+        revert();
+    }
+
+
+    
+    
+    
+    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
+        return ERC20Interface(tokenAddress).transfer(owner, tokens);
+    }
+}

benchmark2/integer overflow/274.sol

@@ -0,0 +1,109 @@
+pragma solidity ^0.4.16;
+
+interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
+
+contract Hacienda {
+    
+    string public name;
+    string public symbol;
+    uint8 public decimals = 18;
+    
+    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);
+
+    
+    event Burn(address indexed from, uint256 value);
+
+    
+    function TokenERC20(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) public {
+        totalSupply = initialSupply * 10 ** uint256(decimals);  
+        balanceOf[msg.sender] = totalSupply;                
+        name = tokenName;                                   
+        symbol = tokenSymbol;                               
+    }
+
+    
+    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;
+        emit Transfer(_from, _to, _value);
+        
+        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
+    }
+
+    
+    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;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
+        public
+        returns (bool success) {
+        tokenRecipient spender = tokenRecipient(_spender);
+        if (approve(_spender, _value)) {
+            spender.receiveApproval(msg.sender, _value, this, _extraData);
+            return true;
+        }
+    }
+
+    
+    function burn(uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);   
+        balanceOf[msg.sender] -= _value;            
+        totalSupply -= _value;                      
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    
+    function burnFrom(address _from, uint256 _value) public returns (bool success) {
+        require(balanceOf[_from] >= _value);                
+        require(_value <= allowance[_from][msg.sender]);    
+        balanceOf[_from] -= _value;                         
+        allowance[_from][msg.sender] -= _value;             
+        totalSupply -= _value;                              
+        emit Burn(_from, _value);
+        return true;
+    }
+}

benchmark2/integer overflow/276.sol

@@ -0,0 +1,325 @@
+pragma solidity ^0.4.24;
+
+
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address _who) public view returns (uint256);
+  function transfer(address _to, uint256 _value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (_a == 0) {
+      return 0;
+    }
+
+    c = _a * _b;
+    assert(c / _a == _b);
+    return c;
+  }
+
+  
+  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    
+    
+    
+    return _a / _b;
+  }
+
+  
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    assert(_b <= _a);
+    return _a - _b;
+  }
+
+  
+  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    c = _a + _b;
+    assert(c >= _a);
+    return c;
+  }
+}
+
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) internal balances;
+
+  uint256 internal totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_value <= balances[msg.sender]);
+    require(_to != address(0));
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address _owner, address _spender)
+    public view returns (uint256);
+
+  function transferFrom(address _from, address _to, uint256 _value)
+    public returns (bool);
+
+  function approve(address _spender, uint256 _value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+    require(_to != address(0));
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue >= oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+
+
+contract DetailedERC20 is ERC20 {
+  string public name;
+  string public symbol;
+  uint8 public decimals;
+
+  constructor(string _name, string _symbol, uint8 _decimals) public {
+    name = _name;
+    symbol = _symbol;
+    decimals = _decimals;
+  }
+}
+
+
+
+
+contract BurnableToken is BasicToken {
+
+  event Burn(address indexed burner, uint256 value);
+
+  
+  function burn(uint256 _value) public {
+    _burn(msg.sender, _value);
+  }
+
+  function _burn(address _who, uint256 _value) internal {
+    require(_value <= balances[_who]);
+    
+    
+
+    balances[_who] = balances[_who].sub(_value);
+    totalSupply_ = totalSupply_.sub(_value);
+    emit Burn(_who, _value);
+    emit Transfer(_who, address(0), _value);
+  }
+}
+
+
+
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+  
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+  
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+  
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+
+
+
+contract MintableToken is StandardToken, Ownable {
+  event Mint(address indexed to, uint256 amount);
+  event MintFinished();
+
+  bool public mintingFinished = false;
+
+
+  modifier canMint() {
+    require(!mintingFinished);
+    _;
+  }
+
+  modifier hasMintPermission() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function mint(
+    address _to,
+    uint256 _amount
+  )
+    public
+    hasMintPermission
+    canMint
+    returns (bool)
+  {
+    totalSupply_ = totalSupply_.add(_amount);
+    balances[_to] = balances[_to].add(_amount);
+    emit Mint(_to, _amount);
+    emit Transfer(address(0), _to, _amount);
+    return true;
+  }
+
+  
+  function finishMinting() public onlyOwner canMint returns (bool) {
+    mintingFinished = true;
+    emit MintFinished();
+    return true;
+  }
+}
+
+
+
+contract BSPCP is StandardToken, DetailedERC20, BurnableToken, MintableToken {
+
+    constructor(string _name, string _symbol, uint8 _decimals) 
+        DetailedERC20(_name, _symbol, _decimals) 
+        public 
+    {
+
+    }
+
+}

benchmark2/integer overflow/281.sol

@@ -0,0 +1,298 @@
+pragma solidity ^0.4.22;
+
+
+
+library SafeMath {
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a * b;
+        assert(a == 0 || c / a == b);
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        
+        uint256 c = a / b;
+        
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}
+
+
+
+contract Ownable {
+    address public owner;
+
+    
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    
+    function transferOwnership(address newOwner) public onlyOwner {
+        if (newOwner != address(0)) {
+            owner = newOwner;
+        }
+    }
+}
+
+
+
+contract Haltable is Ownable {
+    bool public halted;
+
+    modifier inNormalState {
+        assert(!halted);
+        _;
+    }
+
+    modifier inEmergencyState {
+        assert(halted);
+        _;
+    }
+
+    
+    function halt() external onlyOwner inNormalState {
+        halted = true;
+    }
+
+    
+    function resume() external onlyOwner inEmergencyState {
+        halted = false;
+    }
+
+}
+
+
+
+contract ERC20Basic {
+    uint256 public totalSupply;
+
+    function balanceOf(address who) public constant returns (uint256);
+
+    function transfer(address to, uint256 value) public returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+contract ERC20 is ERC20Basic {
+    function allowance(address owner, address spender) public constant returns (uint256);
+
+    function transferFrom(address from, address to, uint256 value) public returns (bool);
+
+    function approve(address spender, uint256 value) public returns (bool);
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+
+contract BasicToken is ERC20Basic {
+    using SafeMath for uint256;
+
+    mapping(address => uint256) public balances;
+
+    
+    function transfer(address _to, uint256 _value) public returns (bool) {
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    
+    function balanceOf(address _owner) public constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+}
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+    mapping(address => mapping(address => uint256)) public allowed;
+
+    
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+        uint256 _allowance;
+        _allowance = allowed[_from][msg.sender];
+
+        
+        
+
+        balances[_to] = balances[_to].add(_value);
+        balances[_from] = balances[_from].sub(_value);
+        allowed[_from][msg.sender] = _allowance.sub(_value);
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    
+    function approve(address _spender, uint256 _value) public returns (bool) {
+
+        
+        
+        
+        
+        require((_value == 0) || (allowed[msg.sender][_spender] == 0));
+
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+}
+
+
+
+contract Burnable is StandardToken {
+    using SafeMath for uint;
+
+    
+    event Burn(address indexed from, uint256 value);
+
+    function burn(uint256 _value) public returns (bool success) {
+        require(balances[msg.sender] >= _value);
+        
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        
+        totalSupply = totalSupply.sub(_value);
+        
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    function burnFrom(address _from, uint256 _value) public returns (bool success) {
+        require(balances[_from] >= _value);
+        
+        require(_value <= allowed[_from][msg.sender]);
+        
+        balances[_from] = balances[_from].sub(_value);
+        
+        totalSupply = totalSupply.sub(_value);
+        
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+        emit Burn(_from, _value);
+        return true;
+    }
+
+    function transfer(address _to, uint _value) public returns (bool success) {
+        require(_to != 0x0);
+        
+
+        return super.transfer(_to, _value);
+    }
+
+    function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
+        require(_to != 0x0);
+        
+
+        return super.transferFrom(_from, _to, _value);
+    }
+}
+
+
+
+contract Centive is Burnable, Ownable {
+
+    string public name;
+    string public symbol;
+    uint8 public decimals = 18;
+
+    
+    address public releaseAgent;
+
+    
+    bool public released = false;
+
+    
+    mapping(address => bool) public transferAgents;
+
+    
+    modifier canTransfer(address _sender) {
+        require(transferAgents[_sender] || released);
+        _;
+    }
+
+    
+    modifier inReleaseState(bool releaseState) {
+        require(releaseState == released);
+        _;
+    }
+
+    
+    modifier onlyReleaseAgent() {
+        require(msg.sender == releaseAgent);
+        _;
+    }
+
+    
+    constructor(uint256 initialSupply, string tokenName, string tokenSymbol) public {
+        totalSupply = initialSupply * 10 ** uint256(decimals);
+        
+        balances[msg.sender] = totalSupply;
+        
+        name = tokenName;
+        
+        symbol = tokenSymbol;
+        
+    }
+
+    
+    function setReleaseAgent(address addr) external onlyOwner inReleaseState(false) {
+
+        
+        releaseAgent = addr;
+    }
+
+    function release() external onlyReleaseAgent inReleaseState(false) {
+        released = true;
+    }
+
+    
+    function setTransferAgent(address addr, bool state) external onlyOwner inReleaseState(false) {
+        transferAgents[addr] = state;
+    }
+
+    function transfer(address _to, uint _value) public canTransfer(msg.sender) returns (bool success) {
+        
+        return super.transfer(_to, _value);
+    }
+
+    function transferFrom(address _from, address _to, uint _value) public canTransfer(_from) returns (bool success) {
+        
+        return super.transferFrom(_from, _to, _value);
+    }
+
+    function burn(uint256 _value) public onlyOwner returns (bool success) {
+        return super.burn(_value);
+    }
+
+    function burnFrom(address _from, uint256 _value) public onlyOwner returns (bool success) {
+        return super.burnFrom(_from, _value);
+    }
+}

benchmark2/integer overflow/286.sol

@@ -0,0 +1,232 @@
+pragma solidity ^0.4.24;
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+contract LineageCode is StandardToken {
+    string public name = 'LineageCode';
+    string public symbol = 'LIN';
+    uint public decimals = 10;
+    uint public INITIAL_SUPPLY = 80 * 100000000 * (10 ** decimals);
+    address owner;
+    bool public released = false;
+
+    constructor() public {
+        totalSupply_ = INITIAL_SUPPLY;
+        balances[msg.sender] = INITIAL_SUPPLY;
+        owner = msg.sender;
+    }
+
+    function release() public {
+        require(owner == msg.sender);
+        require(!released);
+        released = true;
+    }
+
+    function lock() public {
+        require(owner == msg.sender);
+        require(released);
+        released = false;
+    }
+
+    function get_Release() view public returns (bool) {
+        return released;
+    }
+
+    modifier onlyReleased() {
+        if (owner != msg.sender)
+          require(released);
+        _;
+    }
+
+    function transfer(address to, uint256 value) public onlyReleased returns (bool) {
+        super.transfer(to, value);
+    }
+
+    function allowance(address _owner, address _spender) public onlyReleased view returns (uint256) {
+        super.allowance(_owner, _spender);
+    }
+
+    function transferFrom(address from, address to, uint256 value) public onlyReleased returns (bool) {
+        super.transferFrom(from, to, value);
+    }
+
+    function approve(address spender, uint256 value) public onlyReleased returns (bool) {
+        super.approve(spender, value);
+    }
+}

benchmark2/integer overflow/291.sol

@@ -0,0 +1,213 @@
+pragma solidity ^0.4.20;
+
+contract SafeMath {
+  function safeMul(uint256 a, uint256 b) public pure  returns (uint256)  {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function safeDiv(uint256 a, uint256 b)public pure returns (uint256) {
+    assert(b > 0);
+    uint256 c = a / b;
+    assert(a == b * c + a % b);
+    return c;
+  }
+
+  function safeSub(uint256 a, uint256 b)public pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function safeAdd(uint256 a, uint256 b)public pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c>=a && c>=b);
+    return c;
+  }
+
+  function _assert(bool assertion)public pure {
+    assert(!assertion);
+  }
+}
+
+
+contract ERC20Interface {
+  string public name;
+  string public symbol;
+  uint8 public  decimals;
+  uint public totalSupply;
+  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) 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 ERC20 is ERC20Interface,SafeMath {
+
+    
+    mapping(address => uint256) public balanceOf;
+
+    
+    mapping(address => mapping(address => uint256)) allowed;
+
+    constructor(string _name) public {
+       name = _name;  
+       symbol = "REL";
+       decimals = 18;
+       totalSupply = 10000000000000000000000000000;
+       balanceOf[msg.sender] = totalSupply;
+    }
+
+  
+  function transfer(address _to, uint256 _value) returns (bool success) {
+      require(_to != address(0));
+      require(balanceOf[msg.sender] >= _value);
+      require(balanceOf[ _to] + _value >= balanceOf[ _to]);  
+
+      balanceOf[msg.sender] =SafeMath.safeSub(balanceOf[msg.sender],_value) ;
+      balanceOf[_to] =SafeMath.safeAdd(balanceOf[_to] ,_value);
+
+   
+      emit Transfer(msg.sender, _to, _value);
+
+      return true;
+  }
+
+
+  function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+      require(_to != address(0));
+      require(allowed[_from][msg.sender] >= _value);
+      require(balanceOf[_from] >= _value);
+      require(balanceOf[_to] + _value >= balanceOf[_to]);
+
+      balanceOf[_from] =SafeMath.safeSub(balanceOf[_from],_value) ;
+      balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to],_value);
+
+      allowed[_from][msg.sender] =SafeMath.safeSub(allowed[_from][msg.sender], _value);
+
+      emit Transfer(msg.sender, _to, _value);
+      return true;
+  }
+
+  function approve(address _spender, uint256 _value) returns (bool success) {
+      allowed[msg.sender][_spender] = _value;
+
+      emit Approval(msg.sender, _spender, _value);
+      return true;
+  }
+
+  function allowance(address _owner, address _spender) view returns (uint256 remaining) {
+      return allowed[_owner][_spender];
+  }
+
+}
+
+
+contract owned {
+    address public owner;
+
+    constructor () public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnerShip(address newOwer) public onlyOwner {
+        owner = newOwer;
+    }
+
+}
+
+contract SelfDesctructionContract is owned {
+   
+   string  public someValue;
+   modifier ownerRestricted {
+      require(owner == msg.sender);
+      _;
+   } 
+ 
+   function SelfDesctructionContract() {
+      owner = msg.sender;
+   }
+   
+   function setSomeValue(string value){
+      someValue = value;
+   } 
+
+   function destroyContract() ownerRestricted {
+     selfdestruct(owner);
+   }
+}
+
+
+
+contract AdvanceToken is ERC20, owned,SelfDesctructionContract{
+
+    mapping (address => bool) public frozenAccount;
+
+    event FrozenFunds(address target, bool frozen);
+    event Burn(address target, uint amount);
+
+    constructor (string _name) ERC20(_name) public {
+
+    }
+
+  function freezeAccount(address target, bool freeze) public onlyOwner {
+        frozenAccount[target] = freeze;
+        emit FrozenFunds(target, freeze);
+    }
+
+
+  function transfer(address _to, uint256 _value) public returns (bool success) {
+        success = _transfer(msg.sender, _to, _value);
+  }
+
+
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        require(allowed[_from][msg.sender] >= _value);
+        success =  _transfer(_from, _to, _value);
+        allowed[_from][msg.sender] =SafeMath.safeSub(allowed[_from][msg.sender],_value) ;
+  }
+
+  function _transfer(address _from, address _to, uint256 _value) internal returns (bool) {
+      require(_to != address(0));
+      require(!frozenAccount[_from]);
+
+      require(balanceOf[_from] >= _value);
+      require(balanceOf[ _to] + _value >= balanceOf[ _to]);
+
+      balanceOf[_from] =SafeMath.safeSub(balanceOf[_from],_value) ;
+      balanceOf[_to] =SafeMath.safeAdd(balanceOf[_to],_value) ;
+
+      emit Transfer(_from, _to, _value);
+      return true;
+  }
+
+    function burn(uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);
+
+        totalSupply =SafeMath.safeSub(totalSupply,_value) ;
+        balanceOf[msg.sender] =SafeMath.safeSub(balanceOf[msg.sender],_value) ;
+
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    function burnFrom(address _from, uint256 _value)  public returns (bool success) {
+        require(balanceOf[_from] >= _value);
+        require(allowed[_from][msg.sender] >= _value);
+
+        totalSupply =SafeMath.safeSub(totalSupply,_value) ;
+        balanceOf[msg.sender] =SafeMath.safeSub(balanceOf[msg.sender], _value);
+        allowed[_from][msg.sender] =SafeMath.safeSub(allowed[_from][msg.sender],_value);
+
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+}

benchmark2/integer overflow/311.sol

@@ -0,0 +1,232 @@
+pragma solidity ^0.4.24;
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+contract LineageCode is StandardToken {
+    string public name = 'LinageCode';
+    string public symbol = 'LIN';
+    uint public decimals = 10;
+    uint public INITIAL_SUPPLY = 80 * 100000000 * (10 ** decimals);
+    address owner;
+    bool public released = false;
+
+    constructor() public {
+        totalSupply_ = INITIAL_SUPPLY;
+        balances[msg.sender] = INITIAL_SUPPLY;
+        owner = msg.sender;
+    }
+
+    function release() public {
+        require(owner == msg.sender);
+        require(!released);
+        released = true;
+    }
+
+    function lock() public {
+        require(owner == msg.sender);
+        require(released);
+        released = false;
+    }
+
+    function get_Release() view public returns (bool) {
+        return released;
+    }
+
+    modifier onlyReleased() {
+        if (owner != msg.sender)
+          require(released);
+        _;
+    }
+
+    function transfer(address to, uint256 value) public onlyReleased returns (bool) {
+        super.transfer(to, value);
+    }
+
+    function allowance(address _owner, address _spender) public onlyReleased view returns (uint256) {
+        super.allowance(_owner, _spender);
+    }
+
+    function transferFrom(address from, address to, uint256 value) public onlyReleased returns (bool) {
+        super.transferFrom(from, to, value);
+    }
+
+    function approve(address spender, uint256 value) public onlyReleased returns (bool) {
+        super.approve(spender, value);
+    }
+}

benchmark2/integer overflow/333.sol

@@ -0,0 +1,219 @@
+pragma solidity ^0.4.18;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+contract SafeMath {
+    function safeAdd(uint a, uint b) public pure returns (uint c) {
+        c = a + b;
+        require(c >= a);
+    }
+    function safeSub(uint a, uint b) public pure returns (uint c) {
+        require(b <= a);
+        c = a - b;
+    }
+    function safeMul(uint a, uint b) public pure returns (uint c) {
+        c = a * b;
+        require(a == 0 || c / a == b);
+    }
+    function safeDiv(uint a, uint b) public pure returns (uint c) {
+        require(b > 0);
+        c = a / b;
+    }
+}
+
+
+
+
+
+
+contract ERC20Interface {
+    function totalSupply() public constant returns (uint);
+    function balanceOf(address tokenOwner) public constant returns (uint balance);
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
+    function transfer(address to, uint tokens) public returns (bool success);
+    function approve(address spender, uint tokens) public returns (bool success);
+    function transferFrom(address from, address to, uint tokens) public returns (bool success);
+
+    event Transfer(address indexed from, address indexed to, uint tokens);
+    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
+}
+
+
+
+
+
+
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
+}
+
+
+
+
+
+contract Owned {
+    address public owner;
+    address public newOwner;
+
+    event OwnershipTransferred(address indexed _from, address indexed _to);
+
+    function Owned() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address _newOwner) public onlyOwner {
+        newOwner = _newOwner;
+    }
+    function acceptOwnership() public {
+        require(msg.sender == newOwner);
+        OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+        newOwner = address(0);
+    }
+}
+
+
+
+
+
+
+contract CoinDisplayNetwork is ERC20Interface, Owned, SafeMath {
+    string public symbol;
+    string public  name;
+    uint8 public decimals;
+    uint public _totalSupply;
+
+    mapping(address => uint) balances;
+    mapping(address => mapping(address => uint)) allowed;
+
+
+    
+    
+    
+    function CoinDisplayNetwork() public {
+        symbol = "CDN";
+        name = "Coin Display Network";
+        decimals = 18;
+        _totalSupply = 100000000000000000000000000;
+        balances[0xd76618b352D0bFC8014Fc44BF31Bd0F947331660] = _totalSupply;
+        Transfer(address(0), 0xd76618b352D0bFC8014Fc44BF31Bd0F947331660, _totalSupply);
+    }
+
+
+    
+    
+    
+    function totalSupply() public constant returns (uint) {
+        return _totalSupply  - balances[address(0)];
+    }
+
+
+    
+    
+    
+    function balanceOf(address tokenOwner) public constant returns (uint balance) {
+        return balances[tokenOwner];
+    }
+
+
+    
+    
+    
+    
+    
+    function transfer(address to, uint tokens) public returns (bool success) {
+        balances[msg.sender] = safeSub(balances[msg.sender], tokens);
+        balances[to] = safeAdd(balances[to], tokens);
+        Transfer(msg.sender, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    function approve(address spender, uint tokens) public returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        Approval(msg.sender, spender, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
+        balances[from] = safeSub(balances[from], tokens);
+        allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
+        balances[to] = safeAdd(balances[to], tokens);
+        Transfer(from, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
+        return allowed[tokenOwner][spender];
+    }
+
+
+    
+    
+    
+    
+    
+    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        Approval(msg.sender, spender, tokens);
+        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
+        return true;
+    }
+
+
+    
+    
+    
+    function () public payable {
+        revert();
+    }
+
+
+    
+    
+    
+    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
+        return ERC20Interface(tokenAddress).transfer(owner, tokens);
+    }
+}

benchmark2/integer overflow/338.sol

@@ -0,0 +1,316 @@
+pragma solidity ^0.4.24;
+
+contract SafeMath {
+    function safeMul(uint a, uint b) internal returns (uint) {
+        uint c = a * b;
+        assert(a == 0 || c / a == b);
+        return c;
+    }
+
+    function safeSub(uint a, uint b) internal returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    function safeAdd(uint a, uint b) internal returns (uint) {
+        uint c = a + b;
+        assert(c>=a && c>=b);
+        return c;
+    }
+
+    function assert(bool assertion) internal {
+        if (!assertion) throw;
+    }
+}
+
+contract AccessControl is SafeMath{
+
+    
+    event ContractUpgrade(address newContract);
+
+    
+    address public ceoAddress;
+    address public cfoAddress;
+    address public cooAddress;
+
+    address newContractAddress;
+
+    uint public tip_total = 0;
+    uint public tip_rate = 20000000000000000;
+
+    
+    bool public paused = false;
+
+    
+    modifier onlyCEO() {
+        require(msg.sender == ceoAddress);
+        _;
+    }
+
+    
+    modifier onlyCFO() {
+        require(msg.sender == cfoAddress);
+        _;
+    }
+
+    
+    modifier onlyCOO() {
+        require(msg.sender == cooAddress);
+        _;
+    }
+
+    modifier onlyCLevel() {
+        require(
+            msg.sender == cooAddress ||
+            msg.sender == ceoAddress ||
+            msg.sender == cfoAddress
+        );
+        _;
+    }
+
+    function () public payable{
+        tip_total = safeAdd(tip_total, msg.value);
+    }
+
+    
+    
+    function amountWithTip(uint amount) internal returns(uint){
+        uint tip = safeMul(amount, tip_rate) / (1 ether);
+        tip_total = safeAdd(tip_total, tip);
+        return safeSub(amount, tip);
+    }
+
+    
+    function withdrawTip(uint amount) external onlyCFO {
+        require(amount > 0 && amount <= tip_total);
+        require(msg.sender.send(amount));
+        tip_total = tip_total - amount;
+    }
+
+    
+    function setNewAddress(address newContract) external onlyCEO whenPaused {
+        newContractAddress = newContract;
+        emit ContractUpgrade(newContract);
+    }
+
+    
+    
+    function setCEO(address _newCEO) external onlyCEO {
+        require(_newCEO != address(0));
+
+        ceoAddress = _newCEO;
+    }
+
+    
+    
+    function setCFO(address _newCFO) external onlyCEO {
+        require(_newCFO != address(0));
+
+        cfoAddress = _newCFO;
+    }
+
+    
+    
+    function setCOO(address _newCOO) external onlyCEO {
+        require(_newCOO != address(0));
+
+        cooAddress = _newCOO;
+    }
+
+    
+
+    
+    modifier whenNotPaused() {
+        require(!paused);
+        _;
+    }
+
+    
+    modifier whenPaused {
+        require(paused);
+        _;
+    }
+
+    
+    
+    function pause() external onlyCLevel whenNotPaused {
+        paused = true;
+    }
+
+    
+    
+    
+    
+    
+    function unpause() public onlyCEO whenPaused {
+        
+        paused = false;
+    }
+}
+
+
+contract RpsGame is SafeMath , AccessControl{
+
+    
+    uint8 constant public NONE = 0;
+    uint8 constant public ROCK = 10;
+    uint8 constant public PAPER = 20;
+    uint8 constant public SCISSORS = 30;
+    uint8 constant public DEALERWIN = 201;
+    uint8 constant public PLAYERWIN = 102;
+    uint8 constant public DRAW = 101;
+
+    
+    event CreateGame(uint gameid, address dealer, uint amount);
+    event JoinGame(uint gameid, address player, uint amount);
+    event Reveal(uint gameid, address player, uint8 choice);
+    event CloseGame(uint gameid,address dealer,address player, uint8 result);
+
+    
+    struct Game {
+        uint expireTime;
+        address dealer;
+        uint dealerValue;
+        bytes32 dealerHash;
+        uint8 dealerChoice;
+        address player;
+        uint8 playerChoice;
+        uint playerValue;
+        uint8 result;
+        bool closed;
+    }
+
+    
+    mapping (uint => mapping(uint => uint8)) public payoff;
+    mapping (uint => Game) public games;
+    mapping (address => uint[]) public gameidsOf;
+
+    
+    uint public maxgame = 0;
+    uint public expireTimeLimit = 30 minutes;
+
+    
+    function RpsGame() {
+        payoff[ROCK][ROCK] = DRAW;
+        payoff[ROCK][PAPER] = PLAYERWIN;
+        payoff[ROCK][SCISSORS] = DEALERWIN;
+        payoff[PAPER][ROCK] = DEALERWIN;
+        payoff[PAPER][PAPER] = DRAW;
+        payoff[PAPER][SCISSORS] = PLAYERWIN;
+        payoff[SCISSORS][ROCK] = PLAYERWIN;
+        payoff[SCISSORS][PAPER] = DEALERWIN;
+        payoff[SCISSORS][SCISSORS] = DRAW;
+        payoff[NONE][NONE] = DRAW;
+        payoff[ROCK][NONE] = DEALERWIN;
+        payoff[PAPER][NONE] = DEALERWIN;
+        payoff[SCISSORS][NONE] = DEALERWIN;
+        payoff[NONE][ROCK] = PLAYERWIN;
+        payoff[NONE][PAPER] = PLAYERWIN;
+        payoff[NONE][SCISSORS] = PLAYERWIN;
+
+        ceoAddress = msg.sender;
+        cooAddress = msg.sender;
+        cfoAddress = msg.sender;
+    }
+
+    
+    function createGame(bytes32 dealerHash, address player) public payable whenNotPaused returns (uint){
+        require(dealerHash != 0x0);
+        maxgame += 1;
+        Game storage game = games[maxgame];
+        game.dealer = msg.sender;
+        game.player = player;
+        game.dealerHash = dealerHash;
+        game.dealerChoice = NONE;
+        game.dealerValue = msg.value;
+        game.expireTime = expireTimeLimit + now;
+
+        gameidsOf[msg.sender].push(maxgame);
+
+        emit CreateGame(maxgame, game.dealer, game.dealerValue);
+
+        return maxgame;
+    }
+
+    
+    function joinGame(uint gameid, uint8 choice) public payable whenNotPaused returns (uint){
+        Game storage game = games[gameid];
+        require(msg.value == game.dealerValue && game.dealer != address(0) && game.dealer != msg.sender && game.playerChoice==NONE);
+        require(game.player == address(0) || game.player == msg.sender);
+        require(!game.closed);
+        require(now < game.expireTime);
+        require(checkChoice(choice));
+
+        game.player = msg.sender;
+        game.playerChoice = choice;
+        game.playerValue = msg.value;
+        game.expireTime = expireTimeLimit + now;
+
+        gameidsOf[msg.sender].push(gameid);
+
+        emit JoinGame(gameid, game.player, game.playerValue);
+
+        return gameid;
+    }
+
+    
+    function reveal(uint gameid, uint8 choice, bytes32 randomSecret) public returns (bool) {
+        Game storage game = games[gameid];
+        bytes32 proof = getProof(msg.sender, choice, randomSecret);
+
+        require(!game.closed);
+        require(now < game.expireTime);
+        require(game.dealerHash != 0x0);
+        require(checkChoice(choice));
+        require(checkChoice(game.playerChoice));
+        require(game.dealer == msg.sender && proof == game.dealerHash );
+
+        game.dealerChoice = choice;
+
+        Reveal(gameid, msg.sender, choice);
+
+        close(gameid);
+
+        return true;
+    }
+
+    
+    function close(uint gameid) public returns(bool) {
+        Game storage game = games[gameid];
+        require(!game.closed);
+        require(now > game.expireTime || (game.dealerChoice != NONE && game.playerChoice != NONE));
+
+        uint totalAmount = safeAdd(game.dealerValue, game.playerValue);
+        uint reward = amountWithTip(totalAmount);
+        uint8 result = payoff[game.dealerChoice][game.playerChoice];
+
+        if(result == DEALERWIN){
+            require(game.dealer.send(reward));
+        }else if(result == PLAYERWIN){
+            require(game.player.send(reward));
+        }else if(result == DRAW){
+            require(game.dealer.send(game.dealerValue) && game.player.send(game.playerValue));
+        }
+
+        game.closed = true;
+        game.result = result;
+
+        emit CloseGame(gameid, game.dealer, game.player, result);
+
+        return game.closed;
+    }
+
+
+    function getProof(address sender, uint8 choice, bytes32 randomSecret) public view returns (bytes32){
+        return sha3(sender, choice, randomSecret);
+    }
+
+    function gameCountOf(address owner) public view returns (uint){
+        return gameidsOf[owner].length;
+    }
+
+    function checkChoice(uint8 choice) public view returns (bool){
+        return choice==ROCK||choice==PAPER||choice==SCISSORS;
+    }
+
+}

benchmark2/integer overflow/339.sol

@@ -0,0 +1,115 @@
+pragma solidity ^0.4.10;
+
+
+contract SafeMath {
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+
+}
+
+contract Token {
+    uint256 public 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 Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+}
+
+
+
+contract StandardToken is Token , SafeMath {
+
+    bool public status = true;
+    modifier on() {
+        require(status == true);
+        _;
+    }
+
+    function transfer(address _to, uint256 _value) on returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0 && _to != 0X0) {
+            balances[msg.sender] -= _value;
+            balances[_to] = safeAdd(balances[_to],_value);
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) on returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] = safeAdd(balances[_to],_value);
+            balances[_from] = safeSubtract(balances[_from],_value);
+            allowed[_from][msg.sender] = safeSubtract(allowed[_from][msg.sender],_value);
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function balanceOf(address _owner) on constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) on returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) on constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+
+
+
+contract ExShellToken is StandardToken {
+    string public name = "ExShellToken";
+    uint8 public decimals = 8;
+    string public symbol = "ET";
+    bool private init =true;
+    function turnon() controller {
+        status = true;
+    }
+    function turnoff() controller {
+        status = false;
+    }
+    function ExShellToken() {
+        require(init==true);
+        totalSupply = 2000000000;
+        balances[0xa089a405b1df71a6155705fb2bce87df2a86a9e4] = totalSupply;
+        init = false;
+    }
+    address public controller1 =0xa089a405b1df71a6155705fb2bce87df2a86a9e4;
+    address public controller2 =0x5aa64423529e43a53c7ea037a07f94abc0c3a111;
+
+    modifier controller () {
+        require(msg.sender == controller1||msg.sender == controller2);
+        _;
+    }
+}

benchmark2/integer overflow/355.sol

@@ -0,0 +1,198 @@
+pragma solidity ^0.4.24;
+
+
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+
+contract PeopleWaveToken is StandardToken {
+    string public constant name = "PeopleWave Token";
+    string public constant symbol = "PPL";
+    uint8 public constant decimals = 18;
+    uint public constant initialSupply = 1200000000000000000000000000;
+
+    constructor() public {
+        totalSupply_ = initialSupply;
+        balances[msg.sender] = initialSupply;
+    }
+}

benchmark2/integer overflow/373.sol

@@ -0,0 +1,414 @@
+pragma solidity ^0.4.24;
+
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+  
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+  
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+  
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+
+contract ERC20 {
+  function totalSupply() public view returns (uint256);
+
+  function balanceOf(address _who) public view returns (uint256);
+
+  function allowance(address _owner, address _spender)
+    public view returns (uint256);
+
+  function transfer(address _to, uint256 _value) public returns (bool);
+
+  function approve(address _spender, uint256 _value)
+    public returns (bool);
+
+  function transferFrom(address _from, address _to, uint256 _value)
+    public returns (bool);
+
+  event Transfer(
+    address indexed from,
+    address indexed to,
+    uint256 value
+  );
+
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+contract StandardToken is ERC20 {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_value <= balances[msg.sender]);
+    require(_to != address(0));
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+    require(_to != address(0));
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue >= oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+
+
+contract Pausable is Ownable {
+  event Pause();
+  event Unpause();
+
+  bool public paused = false;
+
+
+  
+  modifier whenNotPaused() {
+    require(!paused);
+    _;
+  }
+
+  
+  modifier whenPaused() {
+    require(paused);
+    _;
+  }
+
+  
+  function pause() public onlyOwner whenNotPaused {
+    paused = true;
+    emit Pause();
+  }
+
+  
+  function unpause() public onlyOwner whenPaused {
+    paused = false;
+    emit Unpause();
+  }
+}
+
+
+
+
+contract BurnableToken is StandardToken {
+
+  event Burn(address indexed burner, uint256 value);
+
+  
+  function burn(uint256 _value) public {
+    _burn(msg.sender, _value);
+  }
+
+  
+  function burnFrom(address _from, uint256 _value) public {
+    require(_value <= allowed[_from][msg.sender]);
+    
+    
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    _burn(_from, _value);
+  }
+
+  function _burn(address _who, uint256 _value) internal {
+    require(_value <= balances[_who]);
+    
+    
+
+    balances[_who] = balances[_who].sub(_value);
+    totalSupply_ = totalSupply_.sub(_value);
+    emit Burn(_who, _value);
+    emit Transfer(_who, address(0), _value);
+  }
+}
+
+
+
+contract MintableToken is StandardToken, Ownable {
+  event Mint(address indexed to, uint256 amount);
+  event MintFinished();
+
+  bool public mintingFinished = false;
+
+
+  modifier canMint() {
+    require(!mintingFinished);
+    _;
+  }
+
+  modifier hasMintPermission() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function mint(
+    address _to,
+    uint256 _amount
+  )
+    public
+    hasMintPermission
+    canMint
+    returns (bool)
+  {
+    totalSupply_ = totalSupply_.add(_amount);
+    balances[_to] = balances[_to].add(_amount);
+    emit Mint(_to, _amount);
+    emit Transfer(address(0), _to, _amount);
+    return true;
+  }
+
+  
+  function finishMinting() public onlyOwner canMint returns (bool) {
+    mintingFinished = true;
+    emit MintFinished();
+    return true;
+  }
+}
+
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (_a == 0) {
+      return 0;
+    }
+
+    c = _a * _b;
+    assert(c / _a == _b);
+    return c;
+  }
+
+  
+  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    
+    
+    
+    return _a / _b;
+  }
+
+  
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    assert(_b <= _a);
+    return _a - _b;
+  }
+
+  
+  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    c = _a + _b;
+    assert(c >= _a);
+    return c;
+  }
+}
+
+
+contract PausableToken is StandardToken, Pausable {
+
+  function transfer(
+    address _to,
+    uint256 _value
+  )
+    public
+    whenNotPaused
+    returns (bool)
+  {
+    return super.transfer(_to, _value);
+  }
+
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    whenNotPaused
+    returns (bool)
+  {
+    return super.transferFrom(_from, _to, _value);
+  }
+
+  function approve(
+    address _spender,
+    uint256 _value
+  )
+    public
+    whenNotPaused
+    returns (bool)
+  {
+    return super.approve(_spender, _value);
+  }
+
+  function increaseApproval(
+    address _spender,
+    uint _addedValue
+  )
+    public
+    whenNotPaused
+    returns (bool success)
+  {
+    return super.increaseApproval(_spender, _addedValue);
+  }
+
+  function decreaseApproval(
+    address _spender,
+    uint _subtractedValue
+  )
+    public
+    whenNotPaused
+    returns (bool success)
+  {
+    return super.decreaseApproval(_spender, _subtractedValue);
+  }
+}
+
+
+
+
+contract SCAVOToken is StandardToken, MintableToken, PausableToken, BurnableToken {
+
+  string public constant name = "SCAVO Token";
+  string public constant symbol = "SCAVO";
+  string public constant version = "1.1";
+  uint8 public constant decimals = 18;
+
+  uint256 public constant INITIAL_SUPPLY = 200000000 * (10 ** uint256(decimals));
+
+  
+  constructor() public {
+    totalSupply_ = INITIAL_SUPPLY;
+    balances[msg.sender] = INITIAL_SUPPLY;
+    emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
+  }
+  
+  
+
+}

benchmark2/integer overflow/375.sol

@@ -0,0 +1,366 @@
+pragma solidity ^0.4.18;
+
+/*
+// --
+// --
+// --
+//   ___       ___       ___       ___       ___
+//   /\  \     /\__\     /\  \     /\__\     /\  \
+//   /::\  \   /:/ _/_   /::\  \   /::L_L_    \:\  \
+//   /\:\:\__\ /:/_/\__\ /::\:\__\ /:/L:\__\   /::\__\
+//   \:\:\/__/ \:\/:/  / \/\::/  / \/_/:/  /  /:/\/__/
+//   \::/  /   \::/  /     \/__/    /:/  /   \/__/
+//   \/__/     \/__/               \/__/
+// --
+// --
+// --
+*/
+
+// Contract must have an owner
+contract Owned {
+    address public owner;
+
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function setOwner(address _owner) onlyOwner public {
+        owner = _owner;
+    }
+}
+
+// SafeMath methods
+contract SafeMath {
+    function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        uint256 c = _a + _b;
+        assert(c >= _a);
+        return c;
+    }
+
+    function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        assert(_a >= _b);
+        return _a - _b;
+    }
+
+    function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        uint256 c = _a * _b;
+        assert(_a == 0 || c / _a == _b);
+        return c;
+    }
+}
+
+// for safety methods
+interface ERC20Token {
+  function transfer(address _to, uint256 _value) external returns (bool);
+  function balanceOf(address _addr) external view returns (uint256);
+  function decimals() external view returns (uint8);
+}
+
+// the main ERC20-compliant contract
+contract Token is SafeMath, Owned {
+    uint256 constant DAY_IN_SECONDS = 86400;
+    string public constant standard = "0.66";
+    string public name = "";
+    string public symbol = "";
+    uint8 public decimals = 0;
+    uint256 public totalSupply = 0;
+    mapping (address => uint256) public balanceP;
+    mapping (address => mapping (address => uint256)) public allowance;
+
+    mapping (address => uint256[]) public lockTime;
+    mapping (address => uint256[]) public lockValue;
+    mapping (address => uint256) public lockNum;
+    mapping (address => bool) public locker;
+    uint256 public later = 0;
+    uint256 public earlier = 0;
+
+    // standard ERC20 events
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+    // timelock-related events
+    event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
+    event TokenUnlocked(address indexed _address, uint256 _value);
+
+    // safety method-related events
+    event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
+    event WrongEtherEmptied(address indexed _addr, uint256 _amount);
+
+    // constructor for the ERC20 Token
+    constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
+        require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
+
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+        totalSupply = _totalSupply;
+
+        balanceP[msg.sender] = _totalSupply;
+
+    }
+
+    modifier validAddress(address _address) {
+        require(_address != 0x0);
+        _;
+    }
+
+    // owner may add or remove a locker address for the contract
+    function addLocker(address _address) public validAddress(_address) onlyOwner {
+        locker[_address] = true;
+    }
+
+    function removeLocker(address _address) public validAddress(_address) onlyOwner {
+        locker[_address] = false;
+    }
+
+    // fast-forward the timelocks for all accounts
+    function setUnlockEarlier(uint256 _earlier) public onlyOwner {
+        earlier = add(earlier, _earlier);
+    }
+
+    // delay the timelocks for all accounts
+    function setUnlockLater(uint256 _later) public onlyOwner {
+        later = add(later, _later);
+    }
+
+    // show unlocked balance of an account
+    function balanceUnlocked(address _address) public view returns (uint256 _balance) {
+        _balance = balanceP[_address];
+        uint256 i = 0;
+        while (i < lockNum[_address]) {
+            if (add(now, earlier) > add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
+            i++;
+        }
+        return _balance;
+    }
+
+    // show timelocked balance of an account
+    function balanceLocked(address _address) public view returns (uint256 _balance) {
+        _balance = 0;
+        uint256 i = 0;
+        while (i < lockNum[_address]) {
+            if (add(now, earlier) < add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
+            i++;
+        }
+        return  _balance;
+    }
+
+    // standard ERC20 balanceOf with timelock added
+    function balanceOf(address _address) public view returns (uint256 _balance) {
+        _balance = balanceP[_address];
+        uint256 i = 0;
+        while (i < lockNum[_address]) {
+            _balance = add(_balance, lockValue[_address][i]);
+            i++;
+        }
+        return _balance;
+    }
+
+    // show timelocks in an account
+    function showTime(address _address) public view validAddress(_address) returns (uint256[] _time) {
+        uint i = 0;
+        uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
+        while (i < lockNum[_address]) {
+            tempLockTime[i] = sub(add(lockTime[_address][i], later), earlier);
+            i++;
+        }
+        return tempLockTime;
+    }
+
+    // show values locked in an account's timelocks
+    function showValue(address _address) public view validAddress(_address) returns (uint256[] _value) {
+        return lockValue[_address];
+    }
+
+    // Calculate and process the timelock states of an account
+    function calcUnlock(address _address) private {
+        uint256 i = 0;
+        uint256 j = 0;
+        uint256[] memory currentLockTime;
+        uint256[] memory currentLockValue;
+        uint256[] memory newLockTime = new uint256[](lockNum[_address]);
+        uint256[] memory newLockValue = new uint256[](lockNum[_address]);
+        currentLockTime = lockTime[_address];
+        currentLockValue = lockValue[_address];
+        while (i < lockNum[_address]) {
+            if (add(now, earlier) > add(currentLockTime[i], later)) {
+                balanceP[_address] = add(balanceP[_address], currentLockValue[i]);
+                emit TokenUnlocked(_address, currentLockValue[i]);
+            } else {
+                newLockTime[j] = currentLockTime[i];
+                newLockValue[j] = currentLockValue[i];
+                j++;
+            }
+            i++;
+        }
+        uint256[] memory trimLockTime = new uint256[](j);
+        uint256[] memory trimLockValue = new uint256[](j);
+        i = 0;
+        while (i < j) {
+            trimLockTime[i] = newLockTime[i];
+            trimLockValue[i] = newLockValue[i];
+            i++;
+        }
+        lockTime[_address] = trimLockTime;
+        lockValue[_address] = trimLockValue;
+        lockNum[_address] = j;
+    }
+
+    // standard ERC20 transfer
+    function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool success) {
+        if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
+        if (balanceP[msg.sender] >= _value && _value > 0) {
+            balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
+            balanceP[_to] = add(balanceP[_to], _value);
+            emit Transfer(msg.sender, _to, _value);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    // transfer Token with timelocks
+    function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool success) {
+        require(_value.length == _time.length);
+
+        if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
+        uint256 i = 0;
+        uint256 totalValue = 0;
+        while (i < _value.length) {
+            totalValue = add(totalValue, _value[i]);
+            i++;
+        }
+        if (balanceP[msg.sender] >= totalValue && totalValue > 0) {
+            i = 0;
+            while (i < _time.length) {
+                balanceP[msg.sender] = sub(balanceP[msg.sender], _value[i]);
+                lockTime[_to].length = lockNum[_to]+1;
+                lockValue[_to].length = lockNum[_to]+1;
+                lockTime[_to][lockNum[_to]] = add(now, _time[i]);
+                lockValue[_to][lockNum[_to]] = _value[i];
+
+                // emit custom TransferLocked event
+                emit TransferLocked(msg.sender, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
+
+                // emit standard Transfer event for wallets
+                emit Transfer(msg.sender, _to, lockValue[_to][lockNum[_to]]);
+                lockNum[_to]++;
+                i++;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    // lockers set by owners may transfer Token with timelocks
+    function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
+	    validAddress(_from) validAddress(_to) returns (bool success) {
+        require(locker[msg.sender]);
+        require(_value.length == _time.length);
+
+        if (lockNum[_from] > 0) calcUnlock(_from);
+        uint256 i = 0;
+        uint256 totalValue = 0;
+        while (i < _value.length) {
+            totalValue = add(totalValue, _value[i]);
+            i++;
+        }
+        if (balanceP[_from] >= totalValue && totalValue > 0 && allowance[_from][msg.sender] >= totalValue) {
+            i = 0;
+            while (i < _time.length) {
+                balanceP[_from] = sub(balanceP[_from], _value[i]);
+                allowance[_from][msg.sender] = sub(allowance[_from][msg.sender], _value[i]);
+                lockTime[_to].length = lockNum[_to]+1;
+                lockValue[_to].length = lockNum[_to]+1;
+                lockTime[_to][lockNum[_to]] = add(now, _time[i]);
+                lockValue[_to][lockNum[_to]] = _value[i];
+
+                // emit custom TransferLocked event
+                emit TransferLocked(_from, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
+
+                // emit standard Transfer event for wallets
+                emit Transfer(_from, _to, lockValue[_to][lockNum[_to]]);
+                lockNum[_to]++;
+                i++;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    // standard ERC20 transferFrom
+    function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool success) {
+        if (lockNum[_from] > 0) calcUnlock(_from);
+        if (balanceP[_from] >= _value && _value > 0 && allowance[_from][msg.sender] >= _value) {
+            allowance[_from][msg.sender] = sub(allowance[_from][msg.sender], _value);
+            balanceP[_from] = sub(balanceP[_from], _value);
+            balanceP[_to] = add(balanceP[_to], _value);
+            emit Transfer(_from, _to, _value);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    // should only be called when first setting an allowance
+    function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool success) {
+        require(allowance[msg.sender][_spender] == 0);
+
+        if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
+        allowance[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    // increase or decrease allowance
+    function increaseApproval(address _spender, uint _value) public returns (bool) {
+      allowance[msg.sender][_spender] = add(allowance[msg.sender][_spender], _value);
+      emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
+      return true;
+    }
+
+    function decreaseApproval(address _spender, uint _value) public returns (bool) {
+      if(_value > allowance[msg.sender][_spender]) {
+        allowance[msg.sender][_spender] = 0;
+      } else {
+        allowance[msg.sender][_spender] = sub(allowance[msg.sender][_spender], _value);
+      }
+      emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
+      return true;
+    }
+
+    // safety methods
+    function () public payable {
+        revert();
+    }
+
+    function emptyWrongToken(address _addr) onlyOwner public {
+      ERC20Token wrongToken = ERC20Token(_addr);
+      uint256 amount = wrongToken.balanceOf(address(this));
+      require(amount > 0);
+      require(wrongToken.transfer(msg.sender, amount));
+
+      emit WrongTokenEmptied(_addr, msg.sender, amount);
+    }
+
+    // shouldn't happen, just in case
+    function emptyWrongEther() onlyOwner public {
+      uint256 amount = address(this).balance;
+      require(amount > 0);
+      msg.sender.transfer(amount);
+
+      emit WrongEtherEmptied(msg.sender, amount);
+    }
+
+}

benchmark2/integer overflow/382.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.20;
+
+contract SafeMath {
+  function safeMul(uint256 a, uint256 b) public pure  returns (uint256)  {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function safeDiv(uint256 a, uint256 b)public pure returns (uint256) {
+    assert(b > 0);
+    uint256 c = a / b;
+    assert(a == b * c + a % b);
+    return c;
+  }
+
+  function safeSub(uint256 a, uint256 b)public pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function safeAdd(uint256 a, uint256 b)public pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c>=a && c>=b);
+    return c;
+  }
+
+  function _assert(bool assertion)public pure {
+    assert(!assertion);
+  }
+}
+
+
+contract ERC20Interface {
+  string public name;
+  string public symbol;
+  uint8 public  decimals;
+  uint public totalSupply;
+  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) 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 ERC20 is ERC20Interface,SafeMath {
+
+    
+    mapping(address => uint256) public balanceOf;
+
+    
+    mapping(address => mapping(address => uint256)) allowed;
+
+    constructor(string _name) public {
+       name = _name;  
+       symbol = "IMTC";
+       decimals = 4;
+       totalSupply = 3600000000000;
+       balanceOf[msg.sender] = totalSupply;
+    }
+
+  
+  function transfer(address _to, uint256 _value) returns (bool success) {
+      require(_to != address(0));
+      require(balanceOf[msg.sender] >= _value);
+      require(balanceOf[ _to] + _value >= balanceOf[ _to]);  
+
+      balanceOf[msg.sender] =SafeMath.safeSub(balanceOf[msg.sender],_value) ;
+      balanceOf[_to] =SafeMath.safeAdd(balanceOf[_to] ,_value);
+
+   
+      emit Transfer(msg.sender, _to, _value);
+
+      return true;
+  }
+
+
+  function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+      require(_to != address(0));
+      require(allowed[_from][msg.sender] >= _value);
+      require(balanceOf[_from] >= _value);
+      require(balanceOf[_to] + _value >= balanceOf[_to]);
+
+      balanceOf[_from] =SafeMath.safeSub(balanceOf[_from],_value) ;
+      balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to],_value);
+
+      allowed[_from][msg.sender] =SafeMath.safeSub(allowed[_from][msg.sender], _value);
+
+      emit Transfer(msg.sender, _to, _value);
+      return true;
+  }
+
+  function approve(address _spender, uint256 _value) returns (bool success) {
+      allowed[msg.sender][_spender] = _value;
+
+      emit Approval(msg.sender, _spender, _value);
+      return true;
+  }
+
+  function allowance(address _owner, address _spender) view returns (uint256 remaining) {
+      return allowed[_owner][_spender];
+  }
+
+}
+
+
+contract owned {
+    address public owner;
+
+    constructor () public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnerShip(address newOwer) public onlyOwner {
+        owner = newOwer;
+    }
+
+}
+
+contract SelfDesctructionContract is owned {
+   
+   string  public someValue;
+   modifier ownerRestricted {
+      require(owner == msg.sender);
+      _;
+   } 
+ 
+   function SelfDesctructionContract() {
+      owner = msg.sender;
+   }
+   
+   function setSomeValue(string value){
+      someValue = value;
+   } 
+
+   function destroyContract() ownerRestricted {
+     selfdestruct(owner);
+   }
+}
+
+
+
+contract AdvanceToken is ERC20, owned,SelfDesctructionContract{
+
+    mapping (address => bool) public frozenAccount;
+
+    event AddSupply(uint amount);
+    event FrozenFunds(address target, bool frozen);
+    event Burn(address target, uint amount);
+
+    constructor (string _name) ERC20(_name) public {
+
+    }
+
+    function mine(address target, uint amount) public onlyOwner {
+        totalSupply =SafeMath.safeAdd(totalSupply,amount) ;
+        balanceOf[target] = SafeMath.safeAdd(balanceOf[target],amount);
+
+        emit AddSupply(amount);
+        emit Transfer(0, target, amount);
+    }
+
+    function freezeAccount(address target, bool freeze) public onlyOwner {
+        frozenAccount[target] = freeze;
+        emit FrozenFunds(target, freeze);
+    }
+
+
+  function transfer(address _to, uint256 _value) public returns (bool success) {
+        success = _transfer(msg.sender, _to, _value);
+  }
+
+
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        require(allowed[_from][msg.sender] >= _value);
+        success =  _transfer(_from, _to, _value);
+        allowed[_from][msg.sender] =SafeMath.safeSub(allowed[_from][msg.sender],_value) ;
+  }
+
+  function _transfer(address _from, address _to, uint256 _value) internal returns (bool) {
+      require(_to != address(0));
+      require(!frozenAccount[_from]);
+
+      require(balanceOf[_from] >= _value);
+      require(balanceOf[ _to] + _value >= balanceOf[ _to]);
+
+      balanceOf[_from] =SafeMath.safeSub(balanceOf[_from],_value) ;
+      balanceOf[_to] =SafeMath.safeAdd(balanceOf[_to],_value) ;
+
+      emit Transfer(_from, _to, _value);
+      return true;
+  }
+
+    function burn(uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);
+
+        totalSupply =SafeMath.safeSub(totalSupply,_value) ;
+        balanceOf[msg.sender] =SafeMath.safeSub(balanceOf[msg.sender],_value) ;
+
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    function burnFrom(address _from, uint256 _value)  public returns (bool success) {
+        require(balanceOf[_from] >= _value);
+        require(allowed[_from][msg.sender] >= _value);
+
+        totalSupply =SafeMath.safeSub(totalSupply,_value) ;
+        balanceOf[msg.sender] =SafeMath.safeSub(balanceOf[msg.sender], _value);
+        allowed[_from][msg.sender] =SafeMath.safeSub(allowed[_from][msg.sender],_value);
+
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+}

benchmark2/integer overflow/39.sol

@@ -0,0 +1 @@
+pragma solidity ^0.4.23;contract Ownable {address public owner;event OwnershipRenounced(address indexed previousOwner);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;}function renounceOwnership() public onlyOwner {emit OwnershipRenounced(owner);owner = address(0);}}library SafeMath {function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {if (a == 0) {return 0;}c = a * b;assert(c / a == b);return c;}function div(uint256 a, uint256 b) internal pure returns (uint256) {return a / b;}function sub(uint256 a, uint256 b) internal pure returns (uint256) {assert(b <= a);return a - b;}function add(uint256 a, uint256 b) internal pure returns (uint256 c) {c = a + b;assert(c >= a);return c;}}contract ERC20Basic {function totalSupply() public view returns (uint256);function balanceOf(address who) public view returns (uint256);function transfer(address to, uint256 value) public returns (bool);event Transfer(address indexed from, address indexed to, uint256 value);}contract ERC20 is ERC20Basic {function allowance(address owner, address spender) public view returns (uint256);function transferFrom(address from, address to, uint256 value) public returns(bool);function approve(address spender, uint256 value) public returns (bool);event Approval(address indexed owner, address indexed spender, uint256 value);}contract BasicToken is ERC20Basic {using SafeMath for uint256;mapping(address => uint256) balances;uint256 totalSupply_;function totalSupply() public view returns (uint256) {return totalSupply_;}function transfer(address _to, uint256 _value) public returns (bool) {require(_to != address(0));require(_value <= balances[msg.sender]);balances[msg.sender] = balances[msg.sender].sub(_value);balances[_to] = balances[_to].add(_value);emit Transfer(msg.sender, _to, _value);return true;}function balanceOf(address _owner) public view returns (uint256) {return balances[_owner];}}contract StandardToken is ERC20, BasicToken {mapping (address => mapping (address => uint256)) internal allowed;function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {require(_to != address(0));require(_value <= balances[_from]);require(_value <= allowed[_from][msg.sender]);balances[_from] = balances[_from].sub(_value);balances[_to] = balances[_to].add(_value);allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);emit Transfer(_from, _to, _value);return true;}function approve(address _spender, uint256 _value) public returns (bool) {require((_value == 0 ) || (allowed[msg.sender][_spender] == 0));allowed[msg.sender][_spender] = _value;emit Approval(msg.sender, _spender, _value);return true;}function allowance(address _owner, address _spender) public view returns (uint256) {return allowed[_owner][_spender];}function increaseApproval(address _spender, uint _addedValue) public returns (bool){allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);return true;}function decreaseApproval(address _spender, uint _subtractedValue) public returns(bool) {uint oldValue = allowed[msg.sender][_spender];if (_subtractedValue > oldValue) {allowed[msg.sender][_spender] = 0;} else {allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);}emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);return true;}}contract TokenContract is StandardToken{string public constant name="SDKTOKEN";string public constant symbol="SDK"; uint8 public constant decimals=18;uint256 public constant INITIAL_SUPPLY=100000000000000000000;uint256 public constant MAX_SUPPLY = 100 * 10000 * 10000 * (10 **uint256(decimals));address public constant holder=0x968c9f1e66f40e2851de40e84e37d62566aab393;constructor() TokenContract() public {totalSupply_ = INITIAL_SUPPLY;balances[holder] = INITIAL_SUPPLY;emit Transfer(0x0, holder, INITIAL_SUPPLY);}function() payable public {revert();}}

benchmark2/integer overflow/394.sol

@@ -0,0 +1,115 @@
+pragma solidity ^0.4.10;
+
+
+contract SafeMath {
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+
+}
+
+contract Token {
+    uint256 public 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 Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+}
+
+
+
+contract StandardToken is Token , SafeMath {
+
+    bool public status = true;
+    modifier on() {
+        require(status == true);
+        _;
+    }
+
+    function transfer(address _to, uint256 _value) on returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0 && _to != 0X0) {
+            balances[msg.sender] -= _value;
+            balances[_to] = safeAdd(balances[_to],_value);
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) on returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] = safeAdd(balances[_to],_value);
+            balances[_from] = safeSubtract(balances[_from],_value);
+            allowed[_from][msg.sender] = safeSubtract(allowed[_from][msg.sender],_value);
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function balanceOf(address _owner) on constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) on returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) on constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+
+
+
+contract ExShellToken is StandardToken {
+    string public name = "ExShellToken";
+    uint8 public decimals = 8;
+    string public symbol = "ET";
+    bool private init =true;
+    function turnon() controller {
+        status = true;
+    }
+    function turnoff() controller {
+        status = false;
+    }
+    function ExShellToken() {
+        require(init==true);
+        totalSupply = 2000000000;
+        balances[0xa089a405b1df71a6155705fb2bce87df2a86a9e4] = totalSupply;
+        init = false;
+    }
+    address public controller1 =0xa089a405b1df71a6155705fb2bce87df2a86a9e4;
+    address public controller2 =0x5aa64423529e43a53c7ea037a07f94abc0c3a111;
+
+    modifier controller () {
+        require(msg.sender == controller1||msg.sender == controller2);
+        _;
+    }
+}

benchmark2/integer overflow/423.sol

@@ -0,0 +1,234 @@
+pragma solidity 0.4.16;
+
+
+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 ERC20Basic {
+  uint256 public totalSupply;
+  function balanceOf(address who) public constant returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value > 0 && _value <= balances[msg.sender]);
+
+    
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public constant returns (uint256 balance) {
+    return balances[_owner];
+  }
+}
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public constant returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value > 0 && _value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    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];
+  }
+}
+
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+
+  
+  function Ownable() {
+    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 Pausable is Ownable {
+  event Pause();
+  event Unpause();
+
+  bool public paused = false;
+
+
+  
+  modifier whenNotPaused() {
+    require(!paused);
+    _;
+  }
+
+  
+  modifier whenPaused() {
+    require(paused);
+    _;
+  }
+
+  
+  function pause() onlyOwner whenNotPaused public {
+    paused = true;
+    Pause();
+  }
+
+  
+  function unpause() onlyOwner whenPaused public {
+    paused = false;
+    Unpause();
+  }
+}
+
+
+
+contract PausableToken is StandardToken, Pausable {
+  mapping (address => bool) public frozenAccount;
+  event FrozenFunds(address target, bool frozen);
+
+  function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
+    require(!frozenAccount[msg.sender]);
+    return super.transfer(_to, _value);
+  }
+
+  function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
+    require(!frozenAccount[_from]);
+    return super.transferFrom(_from, _to, _value);
+  }
+
+  function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
+    
+    return super.approve(_spender, _value);
+  }
+  
+  function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
+    require(!frozenAccount[msg.sender]);
+    uint cnt = _receivers.length;
+    uint256 amount = uint256(cnt).mul(_value);
+    require(cnt > 0 && cnt <= 121);
+    require(_value > 0 && balances[msg.sender] >= amount);
+    
+    balances[msg.sender] = balances[msg.sender].sub(amount);
+    for (uint i = 0; i < cnt; i++) {
+        require (_receivers[i] != 0x0);
+        balances[_receivers[i]] = balances[_receivers[i]].add(_value);
+        Transfer(msg.sender, _receivers[i], _value);
+    }
+    return true;
+  }
+  
+  function freezeAccount(address target, bool freeze) onlyOwner public {
+    frozenAccount[target] = freeze;
+    FrozenFunds(target, freeze);
+  }
+  
+  function batchFreeze(address[] addresses, bool freeze) onlyOwner public {
+    for (uint i = 0; i < addresses.length; i++) {
+        frozenAccount[addresses[i]] = freeze;
+        FrozenFunds(addresses[i], freeze);
+    }
+  }
+}
+
+
+contract AdvancedToken is PausableToken {
+    
+    string public name = "Thailand Tourism Chain";
+    string public symbol = "THTC";
+    string public version = '3.0.0';
+    uint8 public decimals = 18;
+
+    
+    function AdvancedToken() {
+      totalSupply = 9 * 10000 * 10000 * (10**(uint256(decimals)));
+      balances[msg.sender] = totalSupply;    
+    }
+
+    function () external payable {
+        
+        revert();
+    }
+}

benchmark2/integer overflow/440.sol

@@ -0,0 +1,106 @@
+pragma solidity 0.4.24;
+
+contract ERC20 {
+    function totalSupply() constant public returns (uint256 supply);
+    function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+library SafeMath {
+  function safeSub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function safeAdd(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract EmanateToken is ERC20 {
+
+  using SafeMath for uint256;
+
+  string public constant name = "Emanate (MN8) Token";
+  string public constant symbol = "MN8";
+  uint256 public constant decimals = 18;
+  uint256 public constant totalTokens = 208000000 * (10 ** decimals);
+
+  mapping (address => uint256) public balances;
+  mapping (address => mapping (address => uint256)) public allowed;
+
+  bool public locked = true;
+  bool public burningEnabled = false;
+  address public owner;
+  address public burnAddress;
+
+  modifier unlocked (address _to) {
+    require(
+      owner == msg.sender ||
+      locked == false ||
+      allowance(owner, msg.sender) > 0 ||
+      (_to == burnAddress && burningEnabled == true)
+    );
+    _;
+  }
+
+  constructor () public {
+    balances[msg.sender] = totalTokens;
+    owner = msg.sender;
+  }
+
+  function totalSupply() public view returns (uint256) {
+    return totalTokens;
+  }
+
+  
+  function transfer(address _to, uint _tokens) unlocked(_to) public returns (bool success) {
+    balances[msg.sender] = balances[msg.sender].safeSub(_tokens);
+    balances[_to] = balances[_to].safeAdd(_tokens);
+    emit Transfer(msg.sender, _to, _tokens);
+    return true;
+  }
+
+  function transferFrom(address from, address _to, uint _tokens) unlocked(_to) public returns (bool success) {
+    balances[from] = balances[from].safeSub(_tokens);
+    allowed[from][msg.sender] = allowed[from][msg.sender].safeSub(_tokens);
+    balances[_to] = balances[_to].safeAdd(_tokens);
+    emit Transfer(from, _to, _tokens);
+    return true;
+  }
+
+  function balanceOf(address _owner) constant public returns (uint256) {
+    return balances[_owner];
+  }
+  
+
+  function approve(address _spender, uint256 _value) unlocked(_spender) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
+    return allowed[_owner][_spender];
+  }
+
+  function setBurnAddress (address _burnAddress) public {
+    require(msg.sender == owner);
+    burningEnabled = true;
+    burnAddress = _burnAddress;
+  }
+
+  function unlock () public {
+    require(msg.sender == owner);
+    locked = false;
+    owner = 0x0000000000000000000000000000000000000001;
+  }
+}

benchmark2/integer overflow/451.sol

@@ -0,0 +1,115 @@
+pragma solidity ^0.4.10;
+
+
+contract SafeMath {
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+
+}
+
+contract Token {
+    uint256 public 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 Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+}
+
+
+
+contract StandardToken is Token , SafeMath {
+
+    bool public status = true;
+    modifier on() {
+        require(status == true);
+        _;
+    }
+
+    function transfer(address _to, uint256 _value) on returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0 && _to != 0X0) {
+            balances[msg.sender] -= _value;
+            balances[_to] = safeAdd(balances[_to],_value);
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) on returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] = safeAdd(balances[_to],_value);
+            balances[_from] = safeSubtract(balances[_from],_value);
+            allowed[_from][msg.sender] = safeSubtract(allowed[_from][msg.sender],_value);
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function balanceOf(address _owner) on constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) on returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) on constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+
+
+
+contract HuobiPoolToken is StandardToken {
+    string public name = "HuobiPoolToken";
+    uint8 public decimals = 8;
+    string public symbol = "HPT";
+    bool private init =true;
+    function turnon() controller {
+        status = true;
+    }
+    function turnoff() controller {
+        status = false;
+    }
+    function HuobiPoolToken() {
+        require(init==true);
+        totalSupply = 100000000000;
+        balances[0x3567cafb8bf2a83bbea4e79f3591142fb4ebe86d] = totalSupply;
+        init = false;
+    }
+    address public controller1 =0x14de73a5602ee3769fb7a968daAFF23A4A6D4Bb5;
+    address public controller2 =0x3567cafb8bf2a83bbea4e79f3591142fb4ebe86d;
+
+    modifier controller () {
+        require(msg.sender == controller1||msg.sender == controller2);
+        _;
+    }
+}

benchmark2/integer overflow/453.sol

@@ -0,0 +1,152 @@
+pragma solidity ^0.4.17;
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    uint256 c = a / b;
+    
+    return c;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256 balance) {
+    return balances[_owner];
+  }
+
+}
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(address _owner, address _spender) public view returns (uint256) {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
+    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+contract DAPL is StandardToken {
+
+            string public name = "DAPL";
+
+            string public symbol = "DAPL";
+
+            uint8 public decimals = 8;
+
+            uint public INITIAL_SUPPLY = 1000000000e8;
+
+             constructor() public {
+                
+                    totalSupply_ = INITIAL_SUPPLY;
+                    balances[msg.sender] = INITIAL_SUPPLY;
+                 
+            }
+
+}

benchmark2/integer overflow/462.sol

@@ -0,0 +1,398 @@
+pragma solidity ^0.4.24;
+
+
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+  
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+  
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+  
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+
+
+
+contract MintableToken is StandardToken, Ownable {
+  event Mint(address indexed to, uint256 amount);
+  event MintFinished();
+
+  bool public mintingFinished = false;
+
+
+  modifier canMint() {
+    require(!mintingFinished);
+    _;
+  }
+
+  modifier hasMintPermission() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function mint(
+    address _to,
+    uint256 _amount
+  )
+    hasMintPermission
+    canMint
+    public
+    returns (bool)
+  {
+    totalSupply_ = totalSupply_.add(_amount);
+    balances[_to] = balances[_to].add(_amount);
+    emit Mint(_to, _amount);
+    emit Transfer(address(0), _to, _amount);
+    return true;
+  }
+
+  
+  function finishMinting() onlyOwner canMint public returns (bool) {
+    mintingFinished = true;
+    emit MintFinished();
+    return true;
+  }
+}
+
+
+
+
+contract Pausable is Ownable {
+  event Pause();
+  event Unpause();
+
+  bool public paused = false;
+
+
+  
+  modifier whenNotPaused() {
+    require(!paused);
+    _;
+  }
+
+  
+  modifier whenPaused() {
+    require(paused);
+    _;
+  }
+
+  
+  function pause() onlyOwner whenNotPaused public {
+    paused = true;
+    emit Pause();
+  }
+
+  
+  function unpause() onlyOwner whenPaused public {
+    paused = false;
+    emit Unpause();
+  }
+}
+
+
+
+contract ApprovalAndCallFallBack {
+  function receiveApproval(address _owner, uint256 _amount, address _token, bytes _data) public returns (bool);
+}
+
+
+
+contract TransferAndCallFallBack {
+  function receiveToken(address _owner, uint256 _amount, address _token, bytes _data) public returns (bool);
+}
+
+
+
+contract MuzikaCoin is MintableToken, Pausable {
+  string public name = 'Muzika';
+  string public symbol = 'MZK';
+  uint8 public decimals = 18;
+
+  event Burn(address indexed burner, uint256 value);
+
+  constructor(uint256 initialSupply) public {
+    totalSupply_ = initialSupply;
+    balances[msg.sender] = initialSupply;
+    emit Transfer(address(0), msg.sender, initialSupply);
+  }
+
+  
+  function burn(uint256 _value) public onlyOwner {
+    _burn(msg.sender, _value);
+  }
+
+  function _burn(address _who, uint256 _value) internal {
+    require(_value <= balances[_who]);
+    
+    
+
+    balances[_who] = balances[_who].sub(_value);
+    totalSupply_ = totalSupply_.sub(_value);
+    emit Burn(_who, _value);
+    emit Transfer(_who, address(0), _value);
+  }
+
+  function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
+    return super.transfer(_to, _value);
+  }
+
+  function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
+    return super.transferFrom(_from, _to, _value);
+  }
+
+  function increaseApprovalAndCall(address _spender, uint _addedValue, bytes _data) public returns (bool) {
+    require(_spender != address(this));
+
+    increaseApproval(_spender, _addedValue);
+
+    require(
+      ApprovalAndCallFallBack(_spender).receiveApproval(
+        msg.sender,
+        _addedValue,
+        address(this),
+        _data
+      )
+    );
+
+    return true;
+  }
+
+  function transferAndCall(address _to, uint _value, bytes _data) public returns (bool) {
+    require(_to != address(this));
+
+    transfer(_to, _value);
+
+    require(
+      TransferAndCallFallBack(_to).receiveToken(
+        msg.sender,
+        _value,
+        address(this),
+        _data
+      )
+    );
+
+    return true;
+  }
+
+  function tokenDrain(ERC20 _token, uint256 _amount) public onlyOwner {
+    _token.transfer(owner, _amount);
+  }
+}

benchmark2/integer overflow/465.sol

@@ -0,0 +1,115 @@
+pragma solidity ^0.4.10;
+
+
+contract SafeMath {
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+
+}
+
+contract Token {
+    uint256 public 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 Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+}
+
+
+
+contract StandardToken is Token , SafeMath {
+
+    bool public status = true;
+    modifier on() {
+        require(status == true);
+        _;
+    }
+
+    function transfer(address _to, uint256 _value) on returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0 && _to != 0X0) {
+            balances[msg.sender] -= _value;
+            balances[_to] = safeAdd(balances[_to],_value);
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) on returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] = safeAdd(balances[_to],_value);
+            balances[_from] = safeSubtract(balances[_from],_value);
+            allowed[_from][msg.sender] = safeSubtract(allowed[_from][msg.sender],_value);
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function balanceOf(address _owner) on constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) on returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) on constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+
+
+
+contract ExShellToken is StandardToken {
+    string public name = "ExShellToken";
+    uint8 public decimals = 8;
+    string public symbol = "ET";
+    bool private init =true;
+    function turnon() controller {
+        status = true;
+    }
+    function turnoff() controller {
+        status = false;
+    }
+    function ExShellToken() {
+        require(init==true);
+        totalSupply = 2000000000;
+        balances[0xa089a405b1df71a6155705fb2bce87df2a86a9e4] = totalSupply;
+        init = false;
+    }
+    address public controller1 =0xa089a405b1df71a6155705fb2bce87df2a86a9e4;
+    address public controller2 =0x5aa64423529e43a53c7ea037a07f94abc0c3a111;
+
+    modifier controller () {
+        require(msg.sender == controller1||msg.sender == controller2);
+        _;
+    }
+}

benchmark2/integer overflow/469.sol

@@ -0,0 +1,172 @@
+pragma solidity ^0.4.24;
+
+
+library SafeMath {
+
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    return a / b;
+  }
+
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+contract ERC20 {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);   
+    
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+contract BasicToken is ERC20 {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+contract ShopCornToken is StandardToken {
+
+  string public constant name = "ShopCornToken";
+  string public constant symbol = "SHC";           
+  uint8 public constant decimals = 8;
+
+  uint256 public constant INITIAL_SUPPLY = 2000000000 * (10 ** uint256(decimals));
+
+  
+  constructor() public {
+    totalSupply_ = INITIAL_SUPPLY;
+    balances[msg.sender] = INITIAL_SUPPLY;
+    emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
+  }
+
+}

benchmark2/integer overflow/480.sol

@@ -0,0 +1,195 @@
+pragma solidity ^0.4.23;
+
+
+contract ERC20 {
+    function totalSupply() public view returns (uint256);
+    function balanceOf(address who) public view returns (uint256);
+    function transfer(address to, uint256 value) public returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);    
+
+    function allowance(address owner, address spender)
+        public view returns (uint256);
+
+    function transferFrom(address from, address to, uint256 value)
+        public returns (bool);
+
+    function approve(address spender, uint256 value) public returns (bool);
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}
+
+
+library SafeMath {
+    
+    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        if (a == 0) {
+            return 0;
+        }
+        c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+    
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        
+        
+        
+        return a / b;
+    }
+
+    
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    
+    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}
+
+
+contract MyanmarGoldToken is ERC20 {
+    using SafeMath for uint256;
+
+    mapping(address => uint256) balances;
+    mapping (address => mapping (address => uint256)) internal allowed;
+
+    uint256 totalSupply_;
+    string public constant name = "MyanmarGoldToken"; 
+    string public constant symbol = "MGC"; 
+    uint8 public constant decimals = 18; 
+
+    event Burn(address indexed burner, uint256 value);
+
+    constructor(address _icoAddress) public {
+        totalSupply_ = 1000000000 * (10 ** uint256(decimals));
+        balances[_icoAddress] = totalSupply_;
+        emit Transfer(address(0), _icoAddress, totalSupply_);
+    }
+
+    
+    function totalSupply() public view returns (uint256) {
+        return totalSupply_;
+    }
+
+    
+    function transfer(address _to, uint256 _value) public returns (bool) {
+        require(_to != address(0));
+        require(_value <= balances[msg.sender]);
+
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    
+    function batchTransfer(address[] _tos, uint256[] _values) public returns (bool) {
+        require(_tos.length == _values.length);
+        uint256 arrayLength = _tos.length;
+        for(uint256 i = 0; i < arrayLength; i++) {
+            transfer(_tos[i], _values[i]);
+        }
+        return true;
+    }
+
+    
+    function balanceOf(address _owner) public view returns (uint256) {
+        return balances[_owner];
+    }
+
+    
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+        public
+        returns (bool)
+    {
+        require(_to != address(0));
+        require(_value <= balances[_from]);
+        require(_value <= allowed[_from][msg.sender]);
+        
+        balances[_from] = balances[_from].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    
+    function approve(address _spender, uint256 _value) public returns (bool) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function allowance(
+        address _owner,
+        address _spender
+    )
+        public
+        view
+        returns (uint256)
+    {
+        return allowed[_owner][_spender];
+    }
+
+    
+    function increaseApproval(
+        address _spender,
+        uint _addedValue
+    )
+        public
+        returns (bool)
+    {
+        allowed[msg.sender][_spender] = (
+        allowed[msg.sender][_spender].add(_addedValue));
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    
+    function decreaseApproval(
+        address _spender,
+        uint _subtractedValue
+    )
+        public
+        returns (bool)
+    {
+        uint oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue > oldValue) {
+            allowed[msg.sender][_spender] = 0;
+        } else {
+            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    
+    function burn(uint256 _value) public {
+        _burn(msg.sender, _value);
+    }
+
+    function _burn(address _who, uint256 _value) internal {
+        require(_value <= balances[_who]);
+        
+        
+
+        balances[_who] = balances[_who].sub(_value);
+        totalSupply_ = totalSupply_.sub(_value);
+        emit Burn(_who, _value);
+        emit Transfer(_who, address(0), _value);
+    }
+}

benchmark2/integer overflow/508.sol

@@ -0,0 +1,1089 @@
+pragma solidity ^0.4.23;
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    if (a == 0) {
+      return 0;
+    }
+    c = a * b;
+    require(c / a == b, "Overflow - Multiplication");
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b <= a, "Underflow - Subtraction");
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    require(c >= a, "Overflow - Addition");
+    return c;
+  }
+}
+
+library Contract {
+
+  using SafeMath for uint;
+
+  
+
+  
+  modifier conditions(function () pure first, function () pure last) {
+    first();
+    _;
+    last();
+  }
+
+  bytes32 internal constant EXEC_PERMISSIONS = keccak256('script_exec_permissions');
+
+  
+  
+  
+  
+  
+  
+  
+  
+  function authorize(address _script_exec) internal view {
+    
+    initialize();
+
+    
+    bytes32 perms = EXEC_PERMISSIONS;
+    bool authorized;
+    assembly {
+      
+      mstore(0, _script_exec)
+      mstore(0x20, perms)
+      
+      mstore(0, keccak256(0x0c, 0x34))
+      
+      mstore(0x20, mload(0x80))
+      
+      authorized := sload(keccak256(0, 0x40))
+    }
+    if (!authorized)
+      revert("Sender is not authorized as a script exec address");
+  }
+
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  function initialize() internal view {
+    
+    
+    require(freeMem() == 0x80, "Memory allocated prior to execution");
+    
+    assembly {
+      mstore(0x80, sload(0))     
+      mstore(0xa0, sload(1))     
+      mstore(0xc0, 0)            
+      mstore(0xe0, 0)            
+      mstore(0x100, 0)           
+      mstore(0x120, 0)           
+      mstore(0x140, 0)           
+      mstore(0x160, 0)           
+
+      
+      mstore(0x40, 0x180)
+    }
+    
+    assert(execID() != bytes32(0) && sender() != address(0));
+  }
+
+  
+  
+  function checks(function () view _check) conditions(validState, validState) internal view {
+    _check();
+  }
+
+  
+  
+  function checks(function () pure _check) conditions(validState, validState) internal pure {
+    _check();
+  }
+
+  
+  
+  function commit() conditions(validState, none) internal pure {
+    
+    bytes32 ptr = buffPtr();
+    require(ptr >= 0x180, "Invalid buffer pointer");
+
+    assembly {
+      
+      let size := mload(add(0x20, ptr))
+      mstore(ptr, 0x20) 
+      
+      revert(ptr, add(0x40, size))
+    }
+  }
+
+  
+
+  
+  function validState() private pure {
+    if (freeMem() < 0x180)
+      revert('Expected Contract.execute()');
+
+    if (buffPtr() != 0 && buffPtr() < 0x180)
+      revert('Invalid buffer pointer');
+
+    assert(execID() != bytes32(0) && sender() != address(0));
+  }
+
+  
+  function buffPtr() private pure returns (bytes32 ptr) {
+    assembly { ptr := mload(0xc0) }
+  }
+
+  
+  function freeMem() private pure returns (bytes32 ptr) {
+    assembly { ptr := mload(0x40) }
+  }
+
+  
+  function currentAction() private pure returns (bytes4 action) {
+    if (buffPtr() == bytes32(0))
+      return bytes4(0);
+
+    assembly { action := mload(0xe0) }
+  }
+
+  
+  function isStoring() private pure {
+    if (currentAction() != STORES)
+      revert('Invalid current action - expected STORES');
+  }
+
+  
+  function isEmitting() private pure {
+    if (currentAction() != EMITS)
+      revert('Invalid current action - expected EMITS');
+  }
+
+  
+  function isPaying() private pure {
+    if (currentAction() != PAYS)
+      revert('Invalid current action - expected PAYS');
+  }
+
+  
+  function startBuffer() private pure {
+    assembly {
+      
+      let ptr := msize()
+      mstore(0xc0, ptr)
+      
+      mstore(ptr, 0)            
+      mstore(add(0x20, ptr), 0) 
+      
+      mstore(0x40, add(0x40, ptr))
+      
+      mstore(0x100, 1)
+    }
+  }
+
+  
+  function validStoreBuff() private pure {
+    
+    if (buffPtr() == bytes32(0))
+      startBuffer();
+
+    
+    
+    if (stored() != 0 || currentAction() == STORES)
+      revert('Duplicate request - stores');
+  }
+
+  
+  function validEmitBuff() private pure {
+    
+    if (buffPtr() == bytes32(0))
+      startBuffer();
+
+    
+    
+    if (emitted() != 0 || currentAction() == EMITS)
+      revert('Duplicate request - emits');
+  }
+
+  
+  function validPayBuff() private pure {
+    
+    if (buffPtr() == bytes32(0))
+      startBuffer();
+
+    
+    
+    if (paid() != 0 || currentAction() == PAYS)
+      revert('Duplicate request - pays');
+  }
+
+  
+  function none() private pure { }
+
+  
+
+  
+  function execID() internal pure returns (bytes32 exec_id) {
+    assembly { exec_id := mload(0x80) }
+    require(exec_id != bytes32(0), "Execution id overwritten, or not read");
+  }
+
+  
+  function sender() internal pure returns (address addr) {
+    assembly { addr := mload(0xa0) }
+    require(addr != address(0), "Sender address overwritten, or not read");
+  }
+
+  
+
+  
+  
+  function read(bytes32 _location) internal view returns (bytes32 data) {
+    data = keccak256(_location, execID());
+    assembly { data := sload(data) }
+  }
+
+  
+
+  bytes4 internal constant EMITS = bytes4(keccak256('Emit((bytes32[],bytes)[])'));
+  bytes4 internal constant STORES = bytes4(keccak256('Store(bytes32[])'));
+  bytes4 internal constant PAYS = bytes4(keccak256('Pay(bytes32[])'));
+  bytes4 internal constant THROWS = bytes4(keccak256('Error(string)'));
+
+  
+  enum NextFunction {
+    INVALID, NONE, STORE_DEST, VAL_SET, VAL_INC, VAL_DEC, EMIT_LOG, PAY_DEST, PAY_AMT
+  }
+
+  
+  function validStoreDest() private pure {
+    
+    if (expected() != NextFunction.STORE_DEST)
+      revert('Unexpected function order - expected storage destination to be pushed');
+
+    
+    isStoring();
+  }
+
+  
+  function validStoreVal() private pure {
+    
+    if (
+      expected() != NextFunction.VAL_SET &&
+      expected() != NextFunction.VAL_INC &&
+      expected() != NextFunction.VAL_DEC
+    ) revert('Unexpected function order - expected storage value to be pushed');
+
+    
+    isStoring();
+  }
+
+  
+  function validPayDest() private pure {
+    
+    if (expected() != NextFunction.PAY_DEST)
+      revert('Unexpected function order - expected payment destination to be pushed');
+
+    
+    isPaying();
+  }
+
+  
+  function validPayAmt() private pure {
+    
+    if (expected() != NextFunction.PAY_AMT)
+      revert('Unexpected function order - expected payment amount to be pushed');
+
+    
+    isPaying();
+  }
+
+  
+  function validEvent() private pure {
+    
+    if (expected() != NextFunction.EMIT_LOG)
+      revert('Unexpected function order - expected event to be pushed');
+
+    
+    isEmitting();
+  }
+
+  
+  
+  function storing() conditions(validStoreBuff, isStoring) internal pure {
+    bytes4 action_req = STORES;
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), action_req)
+      
+      mstore(add(0x24, add(ptr, mload(ptr))), 0)
+      
+      mstore(ptr, add(0x24, mload(ptr)))
+      
+      mstore(0xe0, action_req)
+      
+      mstore(0x100, 2)
+      
+      mstore(sub(ptr, 0x20), add(ptr, mload(ptr)))
+    }
+    
+    setFreeMem();
+  }
+
+  
+  function set(bytes32 _field) conditions(validStoreDest, validStoreVal) internal pure returns (bytes32) {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _field)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 3)
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x120, add(1, mload(0x120)))
+    }
+    
+    setFreeMem();
+    return _field;
+  }
+
+  
+  function to(bytes32, bytes32 _val) conditions(validStoreVal, validStoreDest) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _val)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 2)
+    }
+    
+    setFreeMem();
+  }
+
+  
+  function to(bytes32 _field, uint _val) internal pure {
+    to(_field, bytes32(_val));
+  }
+
+  
+  function to(bytes32 _field, address _val) internal pure {
+    to(_field, bytes32(_val));
+  }
+
+  
+  function to(bytes32 _field, bool _val) internal pure {
+    to(
+      _field,
+      _val ? bytes32(1) : bytes32(0)
+    );
+  }
+
+  function increase(bytes32 _field) conditions(validStoreDest, validStoreVal) internal view returns (bytes32 val) {
+    
+    val = keccak256(_field, execID());
+    assembly {
+      val := sload(val)
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _field)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 4)
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x120, add(1, mload(0x120)))
+    }
+    
+    setFreeMem();
+    return val;
+  }
+
+  function decrease(bytes32 _field) conditions(validStoreDest, validStoreVal) internal view returns (bytes32 val) {
+    
+    val = keccak256(_field, execID());
+    assembly {
+      val := sload(val)
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _field)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 5)
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x120, add(1, mload(0x120)))
+    }
+    
+    setFreeMem();
+    return val;
+  }
+
+  function by(bytes32 _val, uint _amt) conditions(validStoreVal, validStoreDest) internal pure {
+    
+    
+    if (expected() == NextFunction.VAL_INC)
+      _amt = _amt.add(uint(_val));
+    else if (expected() == NextFunction.VAL_DEC)
+      _amt = uint(_val).sub(_amt);
+    else
+      revert('Expected VAL_INC or VAL_DEC');
+
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _amt)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 2)
+    }
+    
+    setFreeMem();
+  }
+
+  
+  function byMaximum(bytes32 _val, uint _amt) conditions(validStoreVal, validStoreDest) internal pure {
+    
+    
+    if (expected() == NextFunction.VAL_DEC) {
+      if (_amt >= uint(_val))
+        _amt = 0;
+      else
+        _amt = uint(_val).sub(_amt);
+    } else {
+      revert('Expected VAL_DEC');
+    }
+
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _amt)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 2)
+    }
+    
+    setFreeMem();
+  }
+
+  
+  
+  function emitting() conditions(validEmitBuff, isEmitting) internal pure {
+    bytes4 action_req = EMITS;
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), action_req)
+      
+      mstore(add(0x24, add(ptr, mload(ptr))), 0)
+      
+      mstore(ptr, add(0x24, mload(ptr)))
+      
+      mstore(0xe0, action_req)
+      
+      mstore(0x100, 6)
+      
+      mstore(sub(ptr, 0x20), add(ptr, mload(ptr)))
+    }
+    
+    setFreeMem();
+  }
+
+  function log(bytes32 _data) conditions(validEvent, validEvent) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), 0)
+      
+      if eq(_data, 0) {
+        mstore(add(0x40, add(ptr, mload(ptr))), 0)
+        
+        mstore(ptr, add(0x40, mload(ptr)))
+      }
+      
+      if iszero(eq(_data, 0)) {
+        
+        mstore(add(0x40, add(ptr, mload(ptr))), 0x20)
+        
+        mstore(add(0x60, add(ptr, mload(ptr))), _data)
+        
+        mstore(ptr, add(0x60, mload(ptr)))
+      }
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x140, add(1, mload(0x140)))
+    }
+    
+    setFreeMem();
+  }
+
+  function log(bytes32[1] memory _topics, bytes32 _data) conditions(validEvent, validEvent) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), 1)
+      
+      mstore(add(0x40, add(ptr, mload(ptr))), mload(_topics))
+      
+      if eq(_data, 0) {
+        mstore(add(0x60, add(ptr, mload(ptr))), 0)
+        
+        mstore(ptr, add(0x60, mload(ptr)))
+      }
+      
+      if iszero(eq(_data, 0)) {
+        
+        mstore(add(0x60, add(ptr, mload(ptr))), 0x20)
+        
+        mstore(add(0x80, add(ptr, mload(ptr))), _data)
+        
+        mstore(ptr, add(0x80, mload(ptr)))
+      }
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x140, add(1, mload(0x140)))
+    }
+    
+    setFreeMem();
+  }
+
+  function log(bytes32[2] memory _topics, bytes32 _data) conditions(validEvent, validEvent) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), 2)
+      
+      mstore(add(0x40, add(ptr, mload(ptr))), mload(_topics))
+      mstore(add(0x60, add(ptr, mload(ptr))), mload(add(0x20, _topics)))
+      
+      if eq(_data, 0) {
+        mstore(add(0x80, add(ptr, mload(ptr))), 0)
+        
+        mstore(ptr, add(0x80, mload(ptr)))
+      }
+      
+      if iszero(eq(_data, 0)) {
+        
+        mstore(add(0x80, add(ptr, mload(ptr))), 0x20)
+        
+        mstore(add(0xa0, add(ptr, mload(ptr))), _data)
+        
+        mstore(ptr, add(0xa0, mload(ptr)))
+      }
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x140, add(1, mload(0x140)))
+    }
+    
+    setFreeMem();
+  }
+
+  function log(bytes32[3] memory _topics, bytes32 _data) conditions(validEvent, validEvent) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), 3)
+      
+      mstore(add(0x40, add(ptr, mload(ptr))), mload(_topics))
+      mstore(add(0x60, add(ptr, mload(ptr))), mload(add(0x20, _topics)))
+      mstore(add(0x80, add(ptr, mload(ptr))), mload(add(0x40, _topics)))
+      
+      if eq(_data, 0) {
+        mstore(add(0xa0, add(ptr, mload(ptr))), 0)
+        
+        mstore(ptr, add(0xa0, mload(ptr)))
+      }
+      
+      if iszero(eq(_data, 0)) {
+        
+        mstore(add(0xa0, add(ptr, mload(ptr))), 0x20)
+        
+        mstore(add(0xc0, add(ptr, mload(ptr))), _data)
+        
+        mstore(ptr, add(0xc0, mload(ptr)))
+      }
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x140, add(1, mload(0x140)))
+    }
+    
+    setFreeMem();
+  }
+
+  function log(bytes32[4] memory _topics, bytes32 _data) conditions(validEvent, validEvent) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), 4)
+      
+      mstore(add(0x40, add(ptr, mload(ptr))), mload(_topics))
+      mstore(add(0x60, add(ptr, mload(ptr))), mload(add(0x20, _topics)))
+      mstore(add(0x80, add(ptr, mload(ptr))), mload(add(0x40, _topics)))
+      mstore(add(0xa0, add(ptr, mload(ptr))), mload(add(0x60, _topics)))
+      
+      if eq(_data, 0) {
+        mstore(add(0xc0, add(ptr, mload(ptr))), 0)
+        
+        mstore(ptr, add(0xc0, mload(ptr)))
+      }
+      
+      if iszero(eq(_data, 0)) {
+        
+        mstore(add(0xc0, add(ptr, mload(ptr))), 0x20)
+        
+        mstore(add(0xe0, add(ptr, mload(ptr))), _data)
+        
+        mstore(ptr, add(0xe0, mload(ptr)))
+      }
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x140, add(1, mload(0x140)))
+    }
+    
+    setFreeMem();
+  }
+
+  
+  
+  function paying() conditions(validPayBuff, isPaying) internal pure {
+    bytes4 action_req = PAYS;
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), action_req)
+      
+      mstore(add(0x24, add(ptr, mload(ptr))), 0)
+      
+      mstore(ptr, add(0x24, mload(ptr)))
+      
+      mstore(0xe0, action_req)
+      
+      mstore(0x100, 8)
+      
+      mstore(sub(ptr, 0x20), add(ptr, mload(ptr)))
+    }
+    
+    setFreeMem();
+  }
+
+  
+  function pay(uint _amount) conditions(validPayAmt, validPayDest) internal pure returns (uint) {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _amount)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 7)
+      
+      mstore(
+        mload(sub(ptr, 0x20)),
+        add(1, mload(mload(sub(ptr, 0x20))))
+      )
+      
+      mstore(0x160, add(1, mload(0x160)))
+    }
+    
+    setFreeMem();
+    return _amount;
+  }
+
+  
+  function toAcc(uint, address _dest) conditions(validPayDest, validPayAmt) internal pure {
+    assembly {
+      
+      let ptr := add(0x20, mload(0xc0))
+      
+      mstore(add(0x20, add(ptr, mload(ptr))), _dest)
+      
+      mstore(ptr, add(0x20, mload(ptr)))
+      
+      mstore(0x100, 8)
+    }
+    
+    setFreeMem();
+  }
+
+  
+  function setFreeMem() private pure {
+    assembly { mstore(0x40, msize) }
+  }
+
+  
+  function expected() private pure returns (NextFunction next) {
+    assembly { next := mload(0x100) }
+  }
+
+  
+  function emitted() internal pure returns (uint num_emitted) {
+    if (buffPtr() == bytes32(0))
+      return 0;
+
+    
+    assembly { num_emitted := mload(0x140) }
+  }
+
+  
+  function stored() internal pure returns (uint num_stored) {
+    if (buffPtr() == bytes32(0))
+      return 0;
+
+    
+    assembly { num_stored := mload(0x120) }
+  }
+
+  
+  function paid() internal pure returns (uint num_paid) {
+    if (buffPtr() == bytes32(0))
+      return 0;
+
+    
+    assembly { num_paid := mload(0x160) }
+  }
+}
+
+library Provider {
+
+  using Contract for *;
+
+  
+  function appIndex() internal pure returns (bytes32)
+    { return keccak256('index'); }
+
+  
+  function execPermissions(address _exec) internal pure returns (bytes32)
+    { return keccak256(_exec, keccak256('script_exec_permissions')); }
+
+  
+  function appSelectors(bytes4 _selector) internal pure returns (bytes32)
+    { return keccak256(_selector, 'implementation'); }
+
+  
+  function registeredApps() internal pure returns (bytes32)
+    { return keccak256(bytes32(Contract.sender()), 'app_list'); }
+
+  
+  function appBase(bytes32 _app) internal pure returns (bytes32)
+    { return keccak256(_app, keccak256(bytes32(Contract.sender()), 'app_base')); }
+
+  
+  function appVersionList(bytes32 _app) internal pure returns (bytes32)
+    { return keccak256('versions', appBase(_app)); }
+
+  
+  function versionBase(bytes32 _app, bytes32 _version) internal pure returns (bytes32)
+    { return keccak256(_version, 'version', appBase(_app)); }
+
+  
+  function versionIndex(bytes32 _app, bytes32 _version) internal pure returns (bytes32)
+    { return keccak256('index', versionBase(_app, _version)); }
+
+  
+  function versionSelectors(bytes32 _app, bytes32 _version) internal pure returns (bytes32)
+    { return keccak256('selectors', versionBase(_app, _version)); }
+
+  
+  function versionAddresses(bytes32 _app, bytes32 _version) internal pure returns (bytes32)
+    { return keccak256('addresses', versionBase(_app, _version)); }
+
+  
+  function previousVersion(bytes32 _app, bytes32 _version) internal pure returns (bytes32)
+    { return keccak256("previous version", versionBase(_app, _version)); }
+
+  
+  function appVersionListAt(bytes32 _app, uint _index) internal pure returns (bytes32)
+    { return bytes32((32 * _index) + uint(appVersionList(_app))); }
+
+  
+  function registerApp(bytes32 _app, address _index, bytes4[] _selectors, address[] _implementations) external view {
+    
+    Contract.authorize(msg.sender);
+
+    
+    if (Contract.read(appBase(_app)) != bytes32(0))
+      revert("app is already registered");
+
+    if (_selectors.length != _implementations.length || _selectors.length == 0)
+      revert("invalid input arrays");
+
+    
+    Contract.storing();
+
+    
+    uint num_registered_apps = uint(Contract.read(registeredApps()));
+
+    Contract.increase(registeredApps()).by(uint(1));
+
+    Contract.set(
+      bytes32(32 * (num_registered_apps + 1) + uint(registeredApps()))
+    ).to(_app);
+
+    
+    Contract.set(appBase(_app)).to(_app);
+
+    
+    Contract.set(versionBase(_app, _app)).to(_app);
+
+    
+    Contract.set(appVersionList(_app)).to(uint(1));
+
+    Contract.set(
+      bytes32(32 + uint(appVersionList(_app)))
+    ).to(_app);
+
+    
+    Contract.set(versionIndex(_app, _app)).to(_index);
+
+    
+    
+    Contract.set(versionSelectors(_app, _app)).to(_selectors.length);
+    Contract.set(versionAddresses(_app, _app)).to(_implementations.length);
+    for (uint i = 0; i < _selectors.length; i++) {
+      Contract.set(bytes32(32 * (i + 1) + uint(versionSelectors(_app, _app)))).to(_selectors[i]);
+      Contract.set(bytes32(32 * (i + 1) + uint(versionAddresses(_app, _app)))).to(_implementations[i]);
+    }
+
+    
+    Contract.set(previousVersion(_app, _app)).to(uint(0));
+
+    
+    Contract.commit();
+  }
+
+  function registerAppVersion(bytes32 _app, bytes32 _version, address _index, bytes4[] _selectors, address[] _implementations) external view {
+    
+    Contract.authorize(msg.sender);
+
+    
+    
+    if (Contract.read(appBase(_app)) == bytes32(0))
+      revert("App has not been registered");
+
+    if (Contract.read(versionBase(_app, _version)) != bytes32(0))
+      revert("Version already exists");
+
+    if (
+      _selectors.length != _implementations.length ||
+      _selectors.length == 0
+    ) revert("Invalid input array lengths");
+
+    
+    Contract.storing();
+
+    
+    Contract.set(versionBase(_app, _version)).to(_version);
+
+    
+    uint num_versions = uint(Contract.read(appVersionList(_app)));
+    Contract.set(appVersionListAt(_app, (num_versions + 1))).to(_version);
+    Contract.set(appVersionList(_app)).to(num_versions + 1);
+
+    
+    Contract.set(versionIndex(_app, _version)).to(_index);
+
+    
+    
+    Contract.set(versionSelectors(_app, _version)).to(_selectors.length);
+    Contract.set(versionAddresses(_app, _version)).to(_implementations.length);
+    for (uint i = 0; i < _selectors.length; i++) {
+      Contract.set(bytes32(32 * (i + 1) + uint(versionSelectors(_app, _version)))).to(_selectors[i]);
+      Contract.set(bytes32(32 * (i + 1) + uint(versionAddresses(_app, _version)))).to(_implementations[i]);
+    }
+
+    
+    bytes32 prev_version = Contract.read(bytes32(32 * num_versions + uint(appVersionList(_app))));
+    Contract.set(previousVersion(_app, _version)).to(prev_version);
+
+    
+    Contract.commit();
+  }
+
+  
+  function updateInstance(bytes32 _app_name, bytes32 _current_version, bytes32 _registry_id) external view {
+    
+    Contract.authorize(msg.sender);
+
+    
+    require(_app_name != 0 && _current_version != 0 && _registry_id != 0, 'invalid input');
+
+    
+    bytes4[] memory current_selectors = getVersionSelectors(_app_name, _current_version, _registry_id);
+    require(current_selectors.length != 0, 'invalid current version');
+
+    
+    bytes32 latest_version = getLatestVersion(_app_name, _registry_id);
+    require(latest_version != _current_version, 'current version is already latest');
+    require(latest_version != 0, 'invalid latest version');
+
+    
+    
+    address latest_idx = getVersionIndex(_app_name, latest_version, _registry_id);
+    bytes4[] memory latest_selectors = getVersionSelectors(_app_name, latest_version, _registry_id);
+    address[] memory latest_impl = getVersionImplementations(_app_name, latest_version, _registry_id);
+    require(latest_idx != 0, 'invalid version idx address');
+    require(latest_selectors.length != 0 && latest_selectors.length == latest_impl.length, 'invalid implementation specification');
+
+    
+    Contract.storing();
+
+    
+    for (uint i = 0; i < current_selectors.length; i++)
+      Contract.set(appSelectors(current_selectors[i])).to(address(0));
+
+    
+    Contract.set(appIndex()).to(latest_idx);
+
+    
+    for (i = 0; i < latest_selectors.length; i++) {
+      require(latest_selectors[i] != 0 && latest_impl[i] != 0, 'invalid input - expected nonzero implementation');
+      Contract.set(appSelectors(latest_selectors[i])).to(latest_impl[i]);
+    }
+
+    
+    Contract.commit();
+  }
+
+  
+  function updateExec(address _new_exec_addr) external view {
+    
+    Contract.authorize(msg.sender);
+
+    
+    require(_new_exec_addr != 0, 'invalid replacement');
+
+    
+    Contract.storing();
+
+    
+    Contract.set(execPermissions(msg.sender)).to(false);
+
+    
+    Contract.set(execPermissions(_new_exec_addr)).to(true);
+
+    
+    Contract.commit();
+  }
+
+  
+
+  function registryRead(bytes32 _location, bytes32 _registry_id) internal view returns (bytes32 value) {
+    _location = keccak256(_location, _registry_id);
+    assembly { value := sload(_location) }
+  }
+
+  
+
+  
+  function getLatestVersion(bytes32 _app, bytes32 _registry_id) internal view returns (bytes32) {
+    uint length = uint(registryRead(appVersionList(_app), _registry_id));
+    
+    return registryRead(appVersionListAt(_app, length), _registry_id);
+  }
+
+  
+  function getVersionIndex(bytes32 _app, bytes32 _version, bytes32 _registry_id) internal view returns (address) {
+    return address(registryRead(versionIndex(_app, _version), _registry_id));
+  }
+
+  
+  function getVersionImplementations(bytes32 _app, bytes32 _version, bytes32 _registry_id) internal view returns (address[] memory impl) {
+    
+    uint length = uint(registryRead(versionAddresses(_app, _version), _registry_id));
+    
+    impl = new address[](length);
+    
+    for (uint i = 0; i < length; i++) {
+      bytes32 location = bytes32(32 * (i + 1) + uint(versionAddresses(_app, _version)));
+      impl[i] = address(registryRead(location, _registry_id));
+    }
+  }
+
+  
+  function getVersionSelectors(bytes32 _app, bytes32 _version, bytes32 _registry_id) internal view returns (bytes4[] memory sels) {
+    
+    uint length = uint(registryRead(versionSelectors(_app, _version), _registry_id));
+    
+    sels = new bytes4[](length);
+    
+    for (uint i = 0; i < length; i++) {
+      bytes32 location = bytes32(32 * (i + 1) + uint(versionSelectors(_app, _version)));
+      sels[i] = bytes4(registryRead(location, _registry_id));
+    }
+  }
+
+}

benchmark2/integer overflow/528.sol

@@ -0,0 +1,269 @@
+pragma solidity 0.4.21;
+
+contract Ownable {
+    address public owner;
+    address public newOwner;
+
+    event OwnershipTransferred(address indexed _from, address indexed _to);
+
+    function Ownable() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address _newOwner) public onlyOwner {
+        newOwner = _newOwner;
+    }
+    function acceptOwnership() public {
+        require(msg.sender == newOwner);
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+        newOwner = address(0);
+    }
+}
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    if (a == 0) {
+      return 0;
+    }
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Pausable is Ownable {
+	event Pause();
+	event Unpause();
+
+	bool public paused = false;
+
+
+	
+	modifier whenNotPaused() {
+		require(!paused);
+		_;
+	}
+
+	
+	modifier whenPaused {
+		require(paused);
+		_;
+	}
+
+	
+	function pause() onlyOwner whenNotPaused public returns (bool) {
+		paused = true;
+		emit Pause();
+		return true;
+	}
+
+	
+	function unpause() onlyOwner whenPaused public returns (bool) {
+		paused = false;
+		emit Unpause();
+		return true;
+	}
+}
+
+
+
+
+
+
+
+contract ERC20Interface {
+    function totalSupply() public constant returns (uint);
+    function balanceOf(address tokenOwner) public constant returns (uint balance);
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
+    function transfer(address to, uint tokens) public returns (bool success);
+    function approve(address spender, uint tokens) public returns (bool success);
+    function transferFrom(address from, address to, uint tokens) public returns (bool success);
+
+    event Transfer(address indexed from, address indexed to, uint tokens);
+    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
+}
+
+
+
+
+
+
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
+}
+
+
+
+
+
+
+contract ROC is ERC20Interface, Pausable {
+    using SafeMath for uint;
+
+    string public symbol;
+    string public  name;
+    uint8 public decimals;
+    uint public _totalSupply;
+
+    mapping(address => uint) balances;
+    mapping(address => mapping(address => uint)) allowed;
+
+
+    
+    
+    
+    function ROC() public {
+        symbol = "ROC";
+        name = "NeoWorld Rare Ore C";
+        decimals = 18;
+        _totalSupply = 10000000 * 10**uint(decimals);
+        balances[owner] = _totalSupply;
+        emit Transfer(address(0), owner, _totalSupply);
+    }
+
+    
+    
+    
+    function totalSupply() public constant returns (uint) {
+        return _totalSupply  - balances[address(0)];
+    }
+
+    
+    
+    
+    function balanceOf(address tokenOwner) public constant returns (uint balance) {
+        return balances[tokenOwner];
+    }
+
+
+    
+    
+    
+    
+    
+    function transfer(address to, uint tokens) public whenNotPaused returns (bool success) {
+        balances[msg.sender] = balances[msg.sender].sub(tokens);
+        balances[to] = balances[to].add(tokens);
+        emit Transfer(msg.sender, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    function approve(address spender, uint tokens) public whenNotPaused returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        emit Approval(msg.sender, spender, tokens);
+        return true;
+    }
+
+    function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
+        returns (bool success) {
+        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    function decreaseApproval (address _spender, uint _subtractedValue) public whenNotPaused
+        returns (bool success) {
+        uint oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue > oldValue) {
+          allowed[msg.sender][_spender] = 0;
+        } else {
+          allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool success) {
+        balances[from] = balances[from].sub(tokens);
+        allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
+        balances[to] = balances[to].add(tokens);
+        emit Transfer(from, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
+        return allowed[tokenOwner][spender];
+    }
+
+
+    
+    
+    
+    
+    
+    function approveAndCall(address spender, uint tokens, bytes data) public whenNotPaused returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        emit Approval(msg.sender, spender, tokens);
+        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
+        return true;
+    }
+
+
+    
+    
+    
+    function () public payable {
+        revert();
+    }
+
+
+    
+    
+    
+    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
+        return ERC20Interface(tokenAddress).transfer(owner, tokens);
+    }
+}

benchmark2/integer overflow/548.sol

@@ -0,0 +1,259 @@
+pragma solidity ^0.4.23;
+
+
+
+
+
+ 
+ 
+
+contract SafeMath {
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    uint256 c = a / b;
+    
+    return c;
+  }
+
+  function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+
+
+
+contract Token {
+  
+  function totalSupply() constant returns (uint256 supply);
+  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 Transfer(address indexed _from, address indexed _to, uint256 _value);
+  event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+
+
+
+
+contract AbstractToken is Token, SafeMath {
+  
+  function AbstractToken () {
+    
+  }
+  
+  
+  function balanceOf(address _owner) constant returns (uint256 balance) {
+    return accounts [_owner];
+  }
+
+  
+  function transfer(address _to, uint256 _value) returns (bool success) {
+    require(_to != address(0));
+    if (accounts [msg.sender] < _value) return false;
+    if (_value > 0 && msg.sender != _to) {
+      accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
+      accounts [_to] = safeAdd (accounts [_to], _value);
+    }
+    emit Transfer (msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function transferFrom(address _from, address _to, uint256 _value)
+  returns (bool success) {
+    require(_to != address(0));
+    if (allowances [_from][msg.sender] < _value) return false;
+    if (accounts [_from] < _value) return false; 
+
+    if (_value > 0 && _from != _to) {
+	  allowances [_from][msg.sender] = safeSub (allowances [_from][msg.sender], _value);
+      accounts [_from] = safeSub (accounts [_from], _value);
+      accounts [_to] = safeAdd (accounts [_to], _value);
+    }
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+   function approve (address _spender, uint256 _value) returns (bool success) {
+    allowances [msg.sender][_spender] = _value;
+    emit Approval (msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(address _owner, address _spender) constant
+  returns (uint256 remaining) {
+    return allowances [_owner][_spender];
+  }
+
+  
+  mapping (address => uint256) accounts;
+
+  
+  mapping (address => mapping (address => uint256)) private allowances;
+  
+}
+
+
+
+contract IDXToken is AbstractToken {
+  
+   
+   
+  uint256 constant MAX_TOKEN_COUNT = 50000000 * (10**18);
+   
+  
+  address private owner;
+  
+  
+  mapping (address => bool) private frozenAccount;
+
+  
+  uint256 tokenCount = 0;
+  
+ 
+  
+  bool frozen = false;
+  
+ 
+  
+  function IDXToken () {
+    owner = msg.sender;
+  }
+
+  
+  function totalSupply() constant returns (uint256 supply) {
+    return tokenCount;
+  }
+
+  string constant public name = "INDEX TOKEN";
+  string constant public symbol = "IDX";
+  uint8 constant public decimals = 18;
+  
+  
+  function transfer(address _to, uint256 _value) returns (bool success) {
+    require(!frozenAccount[msg.sender]);
+	if (frozen) return false;
+    else return AbstractToken.transfer (_to, _value);
+  }
+
+  
+  function transferFrom(address _from, address _to, uint256 _value)
+    returns (bool success) {
+	require(!frozenAccount[_from]);
+    if (frozen) return false;
+    else return AbstractToken.transferFrom (_from, _to, _value);
+  }
+
+   
+  function approve (address _spender, uint256 _value)
+    returns (bool success) {
+	require(allowance (msg.sender, _spender) == 0 || _value == 0);
+    return AbstractToken.approve (_spender, _value);
+  }
+
+  
+  function createTokens(uint256 _value)
+    returns (bool success) {
+    require (msg.sender == owner);
+
+    if (_value > 0) {
+      if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
+	  
+      accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
+      tokenCount = safeAdd (tokenCount, _value);
+	  
+	  
+	  emit Transfer(0x0, msg.sender, _value);
+	  
+	  return true;
+    }
+	
+	  return false;
+    
+  }
+  
+
+  
+  function setOwner(address _newOwner) {
+    require (msg.sender == owner);
+
+    owner = _newOwner;
+  }
+
+  
+  function freezeTransfers () {
+    require (msg.sender == owner);
+
+    if (!frozen) {
+      frozen = true;
+      emit Freeze ();
+    }
+  }
+
+  
+  function unfreezeTransfers () {
+    require (msg.sender == owner);
+
+    if (frozen) {
+      frozen = false;
+      emit Unfreeze ();
+    }
+  }
+  
+  
+  
+  
+  function refundTokens(address _token, address _refund, uint256 _value) {
+    require (msg.sender == owner);
+    require(_token != address(this));
+    AbstractToken token = AbstractToken(_token);
+    token.transfer(_refund, _value);
+    emit RefundTokens(_token, _refund, _value);
+  }
+  
+  
+  function freezeAccount(address _target, bool freeze) {
+      require (msg.sender == owner);
+	  require (msg.sender != _target);
+      frozenAccount[_target] = freeze;
+      emit FrozenFunds(_target, freeze);
+ }
+
+  
+  event Freeze ();
+
+  
+  event Unfreeze ();
+  
+  
+  
+  event FrozenFunds(address target, bool frozen);
+
+
+  
+  
+  
+  event RefundTokens(address _token, address _refund, uint256 _value);
+}

benchmark2/integer overflow/564.sol

@@ -0,0 +1 @@
+pragma solidity ^0.4.23;contract Ownable {address public owner;event OwnershipRenounced(address indexed previousOwner);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;}function renounceOwnership() public onlyOwner {emit OwnershipRenounced(owner);owner = address(0);}}library SafeMath {function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {if (a == 0) {return 0;}c = a * b;assert(c / a == b);return c;}function div(uint256 a, uint256 b) internal pure returns (uint256) {return a / b;}function sub(uint256 a, uint256 b) internal pure returns (uint256) {assert(b <= a);return a - b;}function add(uint256 a, uint256 b) internal pure returns (uint256 c) {c = a + b;assert(c >= a);return c;}}contract ERC20Basic {function totalSupply() public view returns (uint256);function balanceOf(address who) public view returns (uint256);function transfer(address to, uint256 value) public returns (bool);event Transfer(address indexed from, address indexed to, uint256 value);}contract ERC20 is ERC20Basic {function allowance(address owner, address spender) public view returns (uint256);function transferFrom(address from, address to, uint256 value) public returns(bool);function approve(address spender, uint256 value) public returns (bool);event Approval(address indexed owner, address indexed spender, uint256 value);}contract BasicToken is ERC20Basic {using SafeMath for uint256;mapping(address => uint256) balances;uint256 totalSupply_;function totalSupply() public view returns (uint256) {return totalSupply_;}function transfer(address _to, uint256 _value) public returns (bool) {require(_to != address(0));require(_value <= balances[msg.sender]);balances[msg.sender] = balances[msg.sender].sub(_value);balances[_to] = balances[_to].add(_value);emit Transfer(msg.sender, _to, _value);return true;}function balanceOf(address _owner) public view returns (uint256) {return balances[_owner];}}contract StandardToken is ERC20, BasicToken {mapping (address => mapping (address => uint256)) internal allowed;function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {require(_to != address(0));require(_value <= balances[_from]);require(_value <= allowed[_from][msg.sender]);balances[_from] = balances[_from].sub(_value);balances[_to] = balances[_to].add(_value);allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);emit Transfer(_from, _to, _value);return true;}function approve(address _spender, uint256 _value) public returns (bool) {require((_value == 0 ) || (allowed[msg.sender][_spender] == 0));allowed[msg.sender][_spender] = _value;emit Approval(msg.sender, _spender, _value);return true;}function allowance(address _owner, address _spender) public view returns (uint256) {return allowed[_owner][_spender];}function increaseApproval(address _spender, uint _addedValue) public returns (bool){allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);return true;}function decreaseApproval(address _spender, uint _subtractedValue) public returns(bool) {uint oldValue = allowed[msg.sender][_spender];if (_subtractedValue > oldValue) {allowed[msg.sender][_spender] = 0;} else {allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);}emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);return true;}}contract TokenContract is StandardToken{string public constant name="bbb";string public constant symbol="BBBB"; uint8 public constant decimals=18;uint256 public constant INITIAL_SUPPLY=10000000000000000000000;uint256 public constant MAX_SUPPLY = 100 * 10000 * 10000 * (10 **uint256(decimals));constructor() TokenContract() public {totalSupply_ = INITIAL_SUPPLY;balances[msg.sender] = INITIAL_SUPPLY;emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);}function() payable public {revert();}}

benchmark2/integer overflow/571.sol

@@ -0,0 +1,306 @@
+pragma solidity ^0.4.24;
+
+
+
+contract Owned {
+    address public owner;
+
+    function Owned() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function setOwner(address _owner) onlyOwner public {
+        owner = _owner;
+    }
+}
+
+
+contract SafeMath {
+    function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        uint256 c = _a + _b;
+        assert(c >= _a); 
+        return c;
+    }
+
+    function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        assert(_a >= _b); 
+        return _a - _b;
+    }
+
+    function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        uint256 c = _a * _b;
+        assert(_a == 0 || c / _a == _b); 
+        return c;
+    }
+}
+
+
+contract Token is SafeMath, Owned {
+    uint256 constant DAY_IN_SECONDS = 86400;
+    string public constant standard = "0.777";
+    string public name = "";
+    string public symbol = "";
+    uint8 public decimals = 0;
+    uint256 public totalSupply = 0;
+    mapping (address => uint256) public balanceP;
+    mapping (address => mapping (address => uint256)) public allowance;
+
+    mapping (address => uint256[]) public lockTime;
+    mapping (address => uint256[]) public lockValue;
+    mapping (address => uint256) public lockNum;
+    mapping (address => bool) public locker;
+    uint256 public later = 0;
+    uint256 public earlier = 0;
+
+
+    
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+    
+    event TransferredLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
+    event TokenUnlocked(address indexed _address, uint256 _value);
+
+    
+    function Token(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
+        require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
+
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+        totalSupply = _totalSupply;
+
+        balanceP[msg.sender] = _totalSupply;
+
+    }
+
+    
+    modifier validAddress(address _address) {
+        require(_address != 0x0);
+        _;
+    }
+
+    
+    function addLocker(address _address) public validAddress(_address) onlyOwner {
+        locker[_address] = true;
+    }
+
+    function removeLocker(address _address) public validAddress(_address) onlyOwner {
+        locker[_address] = false;
+    }
+
+    
+    function setUnlockEarlier(uint256 _earlier) public onlyOwner {
+        earlier = add(earlier, _earlier);
+    }
+
+    function setUnlockLater(uint256 _later) public onlyOwner {
+        later = add(later, _later);
+    }
+
+    
+    function balanceUnlocked(address _address) public view returns (uint256 _balance) {
+        _balance = balanceP[_address];
+        uint256 i = 0;
+        while (i < lockNum[_address]) {
+            if (add(now, earlier) > add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
+            i++;
+        }
+        return _balance;
+    }
+
+    
+    function balanceLocked(address _address) public view returns (uint256 _balance) {
+        _balance = 0;
+        uint256 i = 0;
+        while (i < lockNum[_address]) {
+            if (add(now, earlier) < add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
+            i++;
+        }
+        return  _balance;
+    }
+
+    
+    function balanceOf(address _address) public view returns (uint256 _balance) {
+        _balance = balanceP[_address];
+        uint256 i = 0;
+        while (i < lockNum[_address]) {
+            _balance = add(_balance, lockValue[_address][i]);
+            i++;
+        }
+        return _balance;
+    }
+
+    
+    function showTime(address _address) public view validAddress(_address) returns (uint256[] _time) {
+        uint i = 0;
+        uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
+        while (i < lockNum[_address]) {
+            tempLockTime[i] = sub(add(lockTime[_address][i], later), earlier);
+            i++;
+        }
+        return tempLockTime;
+    }
+
+    function showValue(address _address) public view validAddress(_address) returns (uint256[] _value) {
+        return lockValue[_address];
+    }
+
+    
+    function calcUnlock(address _address) private {
+        uint256 i = 0;
+        uint256 j = 0;
+        uint256[] memory currentLockTime;
+        uint256[] memory currentLockValue;
+        uint256[] memory newLockTime = new uint256[](lockNum[_address]);
+        uint256[] memory newLockValue = new uint256[](lockNum[_address]);
+        currentLockTime = lockTime[_address];
+        currentLockValue = lockValue[_address];
+        while (i < lockNum[_address]) {
+            if (add(now, earlier) > add(currentLockTime[i], later)) {
+                balanceP[_address] = add(balanceP[_address], currentLockValue[i]);
+
+                
+                emit TokenUnlocked(_address, currentLockValue[i]);
+            } else {
+                newLockTime[j] = currentLockTime[i];
+                newLockValue[j] = currentLockValue[i];
+                j++;
+            }
+            i++;
+        }
+        uint256[] memory trimLockTime = new uint256[](j);
+        uint256[] memory trimLockValue = new uint256[](j);
+        i = 0;
+        while (i < j) {
+            trimLockTime[i] = newLockTime[i];
+            trimLockValue[i] = newLockValue[i];
+            i++;
+        }
+        lockTime[_address] = trimLockTime;
+        lockValue[_address] = trimLockValue;
+        lockNum[_address] = j;
+    }
+
+    
+    function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool success) {
+        if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
+        if (balanceP[msg.sender] >= _value && _value > 0) {
+            balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
+            balanceP[_to] = add(balanceP[_to], _value);
+            emit Transfer(msg.sender, _to, _value);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    
+    function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool success) {
+        require(_value.length == _time.length);
+
+        if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
+        uint256 i = 0;
+        uint256 totalValue = 0;
+        while (i < _value.length) {
+            totalValue = add(totalValue, _value[i]);
+            i++;
+        }
+        if (balanceP[msg.sender] >= totalValue && totalValue > 0) {
+            i = 0;
+            while (i < _time.length) {
+                balanceP[msg.sender] = sub(balanceP[msg.sender], _value[i]);
+                lockTime[_to].length = lockNum[_to]+1;
+                lockValue[_to].length = lockNum[_to]+1;
+                lockTime[_to][lockNum[_to]] = add(now, _time[i]);
+                lockValue[_to][lockNum[_to]] = _value[i];
+
+                
+                emit TransferredLocked(msg.sender, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
+
+                
+                emit Transfer(msg.sender, _to, lockValue[_to][lockNum[_to]]);
+                lockNum[_to]++;
+                i++;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    
+    function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
+	    validAddress(_from) validAddress(_to) returns (bool success) {
+        require(locker[msg.sender]);
+        require(_value.length == _time.length);
+
+        if (lockNum[_from] > 0) calcUnlock(_from);
+        uint256 i = 0;
+        uint256 totalValue = 0;
+        while (i < _value.length) {
+            totalValue = add(totalValue, _value[i]);
+            i++;
+        }
+        if (balanceP[_from] >= totalValue && totalValue > 0) {
+            i = 0;
+            while (i < _time.length) {
+                balanceP[_from] = sub(balanceP[_from], _value[i]);
+                lockTime[_to].length = lockNum[_to]+1;
+                lockValue[_to].length = lockNum[_to]+1;
+                lockTime[_to][lockNum[_to]] = add(now, _time[i]);
+                lockValue[_to][lockNum[_to]] = _value[i];
+
+                
+                emit TransferredLocked(_from, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
+
+                
+                emit Transfer(_from, _to, lockValue[_to][lockNum[_to]]);
+                lockNum[_to]++;
+                i++;
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    
+    function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool success) {
+        if (lockNum[_from] > 0) calcUnlock(_from);
+        if (balanceP[_from] >= _value && _value > 0) {
+            allowance[_from][msg.sender] = sub(allowance[_from][msg.sender], _value);
+            balanceP[_from] = sub(balanceP[_from], _value);
+            balanceP[_to] = add(balanceP[_to], _value);
+            emit Transfer(_from, _to, _value);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    
+    function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool success) {
+        require(_value == 0 || allowance[msg.sender][_spender] == 0);
+
+        if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
+        allowance[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function () public payable {
+        revert();
+    }
+
+}

benchmark2/integer overflow/574.sol

@@ -0,0 +1,269 @@
+pragma solidity ^0.4.21;
+
+contract Ownable {
+    address public owner;
+    address public newOwner;
+
+    event OwnershipTransferred(address indexed _from, address indexed _to);
+
+    function Ownable() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address _newOwner) public onlyOwner {
+        newOwner = _newOwner;
+    }
+    function acceptOwnership() public {
+        require(msg.sender == newOwner);
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+        newOwner = address(0);
+    }
+}
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    if (a == 0) {
+      return 0;
+    }
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Pausable is Ownable {
+	event Pause();
+	event Unpause();
+
+	bool public paused = false;
+
+
+	
+	modifier whenNotPaused() {
+		require(!paused);
+		_;
+	}
+
+	
+	modifier whenPaused {
+		require(paused);
+		_;
+	}
+
+	
+	function pause() onlyOwner whenNotPaused public returns (bool) {
+		paused = true;
+		emit Pause();
+		return true;
+	}
+
+	
+	function unpause() onlyOwner whenPaused public returns (bool) {
+		paused = false;
+		emit Unpause();
+		return true;
+	}
+}
+
+
+
+
+
+
+
+contract ERC20Interface {
+    function totalSupply() public constant returns (uint);
+    function balanceOf(address tokenOwner) public constant returns (uint balance);
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
+    function transfer(address to, uint tokens) public returns (bool success);
+    function approve(address spender, uint tokens) public returns (bool success);
+    function transferFrom(address from, address to, uint tokens) public returns (bool success);
+
+    event Transfer(address indexed from, address indexed to, uint tokens);
+    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
+}
+
+
+
+
+
+
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
+}
+
+
+
+
+
+
+contract ROA is ERC20Interface, Pausable {
+    using SafeMath for uint;
+
+    string public symbol;
+    string public  name;
+    uint8 public decimals;
+    uint public _totalSupply;
+
+    mapping(address => uint) balances;
+    mapping(address => mapping(address => uint)) allowed;
+
+
+    
+    
+    
+    function ROA() public {
+        symbol = "ROA";
+        name = "NeoWorld Rare Ore A";
+        decimals = 18;
+        _totalSupply = 10000000 * 10**uint(decimals);
+        balances[owner] = _totalSupply;
+        emit Transfer(address(0), owner, _totalSupply);
+    }
+
+    
+    
+    
+    function totalSupply() public constant returns (uint) {
+        return _totalSupply  - balances[address(0)];
+    }
+
+    
+    
+    
+    function balanceOf(address tokenOwner) public constant returns (uint balance) {
+        return balances[tokenOwner];
+    }
+
+
+    
+    
+    
+    
+    
+    function transfer(address to, uint tokens) public whenNotPaused returns (bool success) {
+        balances[msg.sender] = balances[msg.sender].sub(tokens);
+        balances[to] = balances[to].add(tokens);
+        emit Transfer(msg.sender, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    function approve(address spender, uint tokens) public whenNotPaused returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        emit Approval(msg.sender, spender, tokens);
+        return true;
+    }
+
+    function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
+        returns (bool success) {
+        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    function decreaseApproval (address _spender, uint _subtractedValue) public whenNotPaused
+        returns (bool success) {
+        uint oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue > oldValue) {
+          allowed[msg.sender][_spender] = 0;
+        } else {
+          allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool success) {
+        balances[from] = balances[from].sub(tokens);
+        allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
+        balances[to] = balances[to].add(tokens);
+        emit Transfer(from, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
+        return allowed[tokenOwner][spender];
+    }
+
+
+    
+    
+    
+    
+    
+    function approveAndCall(address spender, uint tokens, bytes data) public whenNotPaused returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        emit Approval(msg.sender, spender, tokens);
+        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
+        return true;
+    }
+
+
+    
+    
+    
+    function () public payable {
+        revert();
+    }
+
+
+    
+    
+    
+    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
+        return ERC20Interface(tokenAddress).transfer(owner, tokens);
+    }
+}

benchmark2/integer overflow/575.sol

@@ -0,0 +1,270 @@
+pragma solidity ^0.4.21;
+
+contract Ownable {
+    address public owner;
+    address public newOwner;
+
+    event OwnershipTransferred(address indexed _from, address indexed _to);
+
+    function Ownable() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address _newOwner) public onlyOwner {
+        newOwner = _newOwner;
+    }
+    function acceptOwnership() public {
+        require(msg.sender == newOwner);
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+        newOwner = address(0);
+    }
+}
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    if (a == 0) {
+      return 0;
+    }
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Pausable is Ownable {
+	event Pause();
+	event Unpause();
+
+	bool public paused = false;
+
+
+	
+	modifier whenNotPaused() {
+		require(!paused);
+		_;
+	}
+
+	
+	modifier whenPaused {
+		require(paused);
+		_;
+	}
+
+	
+	function pause() onlyOwner whenNotPaused public returns (bool) {
+		paused = true;
+		emit Pause();
+		return true;
+	}
+
+	
+	function unpause() onlyOwner whenPaused public returns (bool) {
+		paused = false;
+		emit Unpause();
+		return true;
+	}
+}
+
+
+
+
+
+
+
+contract ERC20Interface {
+    function totalSupply() public constant returns (uint);
+    function balanceOf(address tokenOwner) public constant returns (uint balance);
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
+    function transfer(address to, uint tokens) public returns (bool success);
+    function approve(address spender, uint tokens) public returns (bool success);
+    function transferFrom(address from, address to, uint tokens) public returns (bool success);
+
+    event Transfer(address indexed from, address indexed to, uint tokens);
+    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
+}
+
+
+
+
+
+
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
+}
+
+
+
+
+
+
+contract ROB is ERC20Interface, Pausable {
+    using SafeMath for uint;
+
+    string public symbol;
+    string public  name;
+    uint8 public decimals;
+    uint public _totalSupply;
+
+    mapping(address => uint) balances;
+    mapping(address => mapping(address => uint)) allowed;
+
+
+    
+    
+    
+    function ROB() public {
+        symbol = "ROB";
+        name = "NeoWorld Rare Ore B";
+        decimals = 18;
+        _totalSupply = 10000000 * 10**uint(decimals);
+        balances[owner] = _totalSupply;
+        emit Transfer(address(0), owner, _totalSupply);
+    }
+
+
+    
+    
+    
+    function totalSupply() public constant returns (uint) {
+        return _totalSupply  - balances[address(0)];
+    }
+
+    
+    
+    
+    function balanceOf(address tokenOwner) public constant returns (uint balance) {
+        return balances[tokenOwner];
+    }
+
+
+    
+    
+    
+    
+    
+    function transfer(address to, uint tokens) public whenNotPaused returns (bool success) {
+        balances[msg.sender] = balances[msg.sender].sub(tokens);
+        balances[to] = balances[to].add(tokens);
+        emit Transfer(msg.sender, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    
+    
+    
+    
+    function approve(address spender, uint tokens) public whenNotPaused returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        emit Approval(msg.sender, spender, tokens);
+        return true;
+    }
+
+    function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
+        returns (bool success) {
+        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    function decreaseApproval (address _spender, uint _subtractedValue) public whenNotPaused
+        returns (bool success) {
+        uint oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue > oldValue) {
+          allowed[msg.sender][_spender] = 0;
+        } else {
+          allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool success) {
+        balances[from] = balances[from].sub(tokens);
+        allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
+        balances[to] = balances[to].add(tokens);
+        emit Transfer(from, to, tokens);
+        return true;
+    }
+
+
+    
+    
+    
+    
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
+        return allowed[tokenOwner][spender];
+    }
+
+
+    
+    
+    
+    
+    
+    function approveAndCall(address spender, uint tokens, bytes data) public whenNotPaused returns (bool success) {
+        allowed[msg.sender][spender] = tokens;
+        emit Approval(msg.sender, spender, tokens);
+        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
+        return true;
+    }
+
+
+    
+    
+    
+    function () public payable {
+        revert();
+    }
+
+
+    
+    
+    
+    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
+        return ERC20Interface(tokenAddress).transfer(owner, tokens);
+    }
+}

benchmark2/integer overflow/6.sol

@@ -0,0 +1,144 @@
+pragma solidity ^0.4.18;
+
+
+contract SafeMath {
+  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
+    assert(b > 0);
+    uint256 c = a / b;
+    assert(a == b * c + a % b);
+    return c;
+  }
+
+  function safeSub(uint256 a, uint256 b) internal returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
+    uint256 c = a + b;
+    assert(c>=a && c>=b);
+    return c;
+  }
+
+  function assert(bool assertion) internal {
+    if (!assertion) {
+      throw;
+    }
+  }
+}
+contract REL is SafeMath{
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    uint256 public totalSupply;
+	address public owner;
+
+    
+    mapping (address => uint256) public balanceOf;
+	mapping (address => uint256) public freezeOf;
+    mapping (address => mapping (address => uint256)) public allowance;
+
+    
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    
+    event Burn(address indexed from, uint256 value);
+	
+	
+    event Freeze(address indexed from, uint256 value);
+	
+	
+    event Unfreeze(address indexed from, uint256 value);
+
+    
+    function REL(
+        uint256 initialSupply,
+        string tokenName,
+        uint8 decimalUnits,
+        string tokenSymbol
+        ) {
+        balanceOf[msg.sender] = initialSupply;              
+        totalSupply = initialSupply;                        
+        name = tokenName;                                   
+        symbol = tokenSymbol;                               
+        decimals = decimalUnits;                            
+		owner = msg.sender;
+    }
+
+    
+    function transfer(address _to, uint256 _value) {
+        if (_to == 0x0) throw;                               
+		if (_value <= 0) throw; 
+        if (balanceOf[msg.sender] < _value) throw;           
+        if (balanceOf[_to] + _value < balanceOf[_to]) throw; 
+        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     
+        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            
+        Transfer(msg.sender, _to, _value);                   
+    }
+
+    
+    function approve(address _spender, uint256 _value)
+        returns (bool success) {
+		if (_value <= 0) throw; 
+        allowance[msg.sender][_spender] = _value;
+        return true;
+    }
+       
+
+    
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (_to == 0x0) throw;                                
+		if (_value <= 0) throw; 
+        if (balanceOf[_from] < _value) throw;                 
+        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  
+        if (_value > allowance[_from][msg.sender]) throw;     
+        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           
+        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             
+        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
+        Transfer(_from, _to, _value);
+        return true;
+    }
+
+    function burn(uint256 _value) returns (bool success) {
+        if (balanceOf[msg.sender] < _value) throw;            
+		if (_value <= 0) throw; 
+        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      
+        totalSupply = SafeMath.safeSub(totalSupply,_value);                                
+        Burn(msg.sender, _value);
+        return true;
+    }
+	
+	function freeze(uint256 _value) returns (bool success) {
+        if (balanceOf[msg.sender] < _value) throw;            
+		if (_value <= 0) throw; 
+        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      
+        freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);                                
+        Freeze(msg.sender, _value);
+        return true;
+    }
+	
+	function unfreeze(uint256 _value) returns (bool success) {
+        if (freezeOf[msg.sender] < _value) throw;            
+		if (_value <= 0) throw; 
+        freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);                      
+		balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
+        Unfreeze(msg.sender, _value);
+        return true;
+    }
+	
+	
+	function withdrawEther(uint256 amount) {
+		if(msg.sender != owner)throw;
+		owner.transfer(amount);
+	}
+	
+	
+	function() payable {
+    }
+}

benchmark2/integer overflow/600.sol

@@ -0,0 +1,154 @@
+pragma solidity ^0.4.24;
+
+
+library SafeMath {
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        assert(a >= b);
+        return a - b;
+    }
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}
+
+
+contract Owned {
+    address public owner;
+
+    event OwnershipTransfered(address indexed owner);
+
+    constructor() public {
+        owner = msg.sender;
+        emit OwnershipTransfered(owner);
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        owner = newOwner;
+        emit OwnershipTransfered(owner);
+    }
+}
+
+
+contract ERC20Token {
+    using SafeMath for uint256;
+
+    string public constant name = "Ansforce Intelligence Token";
+    string public constant symbol = "AIT";
+    uint8 public constant decimals = 18;
+    uint256 public totalSupply = 0;
+
+    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 from, uint256 value, address indexed to, bytes extraData);
+
+    constructor() public {
+    }
+
+    
+    function _transfer(address from, address to, uint256 value) internal {
+        
+        require(balanceOf[from] >= value);
+
+        
+        require(balanceOf[to] + value > balanceOf[to]);
+
+        
+        uint256 previousBalances = balanceOf[from].add(balanceOf[to]);
+
+        balanceOf[from] = balanceOf[from].sub(value);
+        balanceOf[to] = balanceOf[to].add(value);
+
+        emit Transfer(from, to, value);
+
+        
+        assert(balanceOf[from].add(balanceOf[to]) == previousBalances);
+    }
+
+    
+    function transfer(address to, uint256 value) public {
+        _transfer(msg.sender, to, value);
+    }
+
+    
+    function transferFrom(address from, address to, uint256 value) public returns (bool success) {
+        require(value <= allowance[from][msg.sender]);
+        allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
+        _transfer(from, to, value);
+        return true;
+    }
+
+    
+    function approve(address spender, uint256 value, bytes extraData) public returns (bool success) {
+        allowance[msg.sender][spender] = value;
+        emit Approval(msg.sender, value, spender, extraData);
+        return true;
+    }
+}
+
+
+contract AnsforceIntelligenceToken is Owned, ERC20Token {
+    constructor() public {
+    }
+    
+    function init(uint256 _supply, address _vault) public onlyOwner {
+        require(totalSupply == 0);
+        require(_supply > 0);
+        require(_vault != address(0));
+        totalSupply = _supply;
+        balanceOf[_vault] = totalSupply;
+    }
+    
+    
+    bool public stopped = false;
+    
+    modifier isRunning {
+        require (!stopped);
+        _;
+    }
+    
+    function transfer(address to, uint256 value) isRunning public {
+        ERC20Token.transfer(to, value);
+    }
+    
+    function stop() public onlyOwner {
+        stopped = true;
+    }
+
+    function start() public onlyOwner {
+        stopped = false;
+    }
+    
+    
+    mapping (address => uint256) public freezeOf;
+    
+    
+    event Freeze(address indexed target, uint256 value);
+
+    
+    event Unfreeze(address indexed target, uint256 value);
+    
+    function freeze(address target, uint256 _value) public onlyOwner returns (bool success) {
+        require( _value > 0 );
+        balanceOf[target] = SafeMath.sub(balanceOf[target], _value);
+        freezeOf[target] = SafeMath.add(freezeOf[target], _value);
+        emit Freeze(target, _value);
+        return true;
+    }
+
+    function unfreeze(address target, uint256 _value) public onlyOwner returns (bool success) {
+        require( _value > 0 );
+        freezeOf[target] = SafeMath.sub(freezeOf[target], _value);
+        balanceOf[target] = SafeMath.add(balanceOf[target], _value);
+        emit Unfreeze(target, _value);
+        return true;
+    }
+}

benchmark2/integer overflow/607.sol

@@ -0,0 +1,311 @@
+pragma solidity ^0.4.21;
+
+// File: contracts/ownership/Ownable.sol
+
+/**
+ * @title Ownable
+ * @dev The Ownable contract has an owner address, and provides basic authorization control
+ * functions, this simplifies the implementation of "user permissions".
+ */
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+
+  /**
+   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+   * account.
+   */
+  function Ownable() public {
+    owner = msg.sender;
+  }
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  /**
+   * @dev Allows the current owner to transfer control of the contract to a newOwner.
+   * @param newOwner The address to transfer ownership to.
+   */
+  function transferOwnership(address newOwner) public onlyOwner {
+    require(newOwner != address(0));
+    emit OwnershipTransferred(owner, newOwner);
+    owner = newOwner;
+  }
+
+  /**
+   * @dev Allows the current owner to relinquish control of the contract.
+   */
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+}
+
+// File: contracts/math/SafeMath.sol
+
+/**
+ * @title SafeMath
+ * @dev Math operations with safety checks that throw on error
+ */
+library SafeMath {
+
+  /**
+  * @dev Multiplies two numbers, throws on overflow.
+  */
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    if (a == 0) {
+      return 0;
+    }
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  /**
+  * @dev Integer division of two numbers, truncating the quotient.
+  */
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    // assert(b > 0); // Solidity automatically throws when dividing by 0
+    // uint256 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    return a / b;
+  }
+
+  /**
+  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
+  */
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  /**
+  * @dev Adds two numbers, throws on overflow.
+  */
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+// File: contracts/token/ERC20/ERC20Basic.sol
+
+/**
+ * @title ERC20Basic
+ * @dev Simpler version of ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/179
+ */
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+// File: contracts/token/ERC20/BasicToken.sol
+
+/**
+ * @title Basic token
+ * @dev Basic version of StandardToken, with no allowances.
+ */
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  /**
+  * @dev total number of tokens in existence
+  */
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  /**
+  * @dev transfer token for a specified address
+  * @param _to The address to transfer to.
+  * @param _value The amount to be transferred.
+  */
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  /**
+  * @dev Gets the balance of the specified address.
+  * @param _owner The address to query the the balance of.
+  * @return An uint256 representing the amount owned by the passed address.
+  */
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+ 
+
+// File: contracts/token/ERC20/ERC20.sol
+
+/**
+ * @title ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/20
+ */
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+// File: contracts/token/ERC20/StandardToken.sol
+
+/**
+ * @title Standard ERC20 token
+ *
+ * @dev Implementation of the basic standard token.
+ * @dev https://github.com/ethereum/EIPs/issues/20
+ * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
+ */
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  /**
+   * @dev Transfer tokens from one address to another
+   * @param _from address The address which you want to send tokens from
+   * @param _to address The address which you want to transfer to
+   * @param _value uint256 the amount of tokens to be transferred
+   */
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  /**
+   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+   *
+   * Beware that changing an allowance with this method brings the risk that someone may use both the old
+   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+   * @param _spender The address which will spend the funds.
+   * @param _value The amount of tokens to be spent.
+   */
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  /**
+   * @dev Function to check the amount of tokens that an owner allowed to a spender.
+   * @param _owner address The address which owns the funds.
+   * @param _spender address The address which will spend the funds.
+   * @return A uint256 specifying the amount of tokens still available for the spender.
+   */
+  function allowance(address _owner, address _spender) public view returns (uint256) {
+    return allowed[_owner][_spender];
+  }
+
+  /**
+   * @dev Increase the amount of tokens that an owner allowed to a spender.
+   *
+   * approve should be called when allowed[_spender] == 0. To increment
+   * allowed value is better to use this function to avoid 2 calls (and wait until
+   * the first transaction is mined)
+   * From MonolithDAO Token.sol
+   * @param _spender The address which will spend the funds.
+   * @param _addedValue The amount of tokens to increase the allowance by.
+   */
+  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
+    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  /**
+   * @dev Decrease the amount of tokens that an owner allowed to a spender.
+   *
+   * approve should be called when allowed[_spender] == 0. To decrement
+   * allowed value is better to use this function to avoid 2 calls (and wait until
+   * the first transaction is mined)
+   * From MonolithDAO Token.sol
+   * @param _spender The address which will spend the funds.
+   * @param _subtractedValue The amount of tokens to decrease the allowance by.
+   */
+  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+contract DubaiGreenBlockChain is StandardToken, Ownable {
+    // Constants
+    string  public constant name = "Dubai Green BlockChain";
+    string  public constant symbol = "DGBC";
+    uint8   public constant decimals = 4;
+    uint256 public constant INITIAL_SUPPLY      = 1000000000 * (10 ** uint256(decimals));
+   
+    
+    mapping(address => bool) touched;
+ 
+
+    function DubaiGreenBlockChain() public {
+      totalSupply_ = INITIAL_SUPPLY;
+
+      
+
+      balances[msg.sender] = INITIAL_SUPPLY;
+      emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
+    }
+
+    function _transfer(address _from, address _to, uint _value) internal {     
+        require (balances[_from] >= _value);               // Check if the sender has enough
+        require (balances[_to] + _value > balances[_to]); // Check for overflows
+   
+        balances[_from] = balances[_from].sub(_value);                         // Subtract from the sender
+        balances[_to] = balances[_to].add(_value);                            // Add the same to the recipient
+         
+        emit Transfer(_from, _to, _value);
+    }
+ 
+    
+    function safeWithdrawal(uint _value ) onlyOwner public {
+       if (_value == 0) 
+           owner.transfer(address(this).balance);
+       else
+           owner.transfer(_value);
+    }
+
+}

benchmark2/integer overflow/609.sol

@@ -0,0 +1,262 @@
+pragma solidity ^0.4.13;
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+  
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+  
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+  
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+contract ArtBlockchainToken is StandardToken, Ownable {
+    string public name = "Art Blockchain Token";
+    string public symbol = "ARTCN";
+    uint public decimals = 18;
+    uint internal INITIAL_SUPPLY = (10 ** 9) * (10 ** decimals);
+
+    mapping(address => uint256) private userLockedTokens;
+    event Freeze(address indexed account, uint256 value);
+    event UnFreeze(address indexed account, uint256 value);
+
+
+    constructor(address _addressFounder) public {
+        totalSupply_ = INITIAL_SUPPLY;
+        balances[_addressFounder] = INITIAL_SUPPLY;
+        emit Transfer(0x0, _addressFounder, INITIAL_SUPPLY);
+    }
+
+    function balance(address _owner) internal view returns (uint256 token) {
+        return balances[_owner].sub(userLockedTokens[_owner]);
+    }
+
+    function lockedTokens(address _owner) public view returns (uint256 token) {
+        return userLockedTokens[_owner];
+    }
+
+	function freezeAccount(address _userAddress, uint256 _amount) onlyOwner public returns (bool success) {
+        require(balance(_userAddress) >= _amount);
+        userLockedTokens[_userAddress] = userLockedTokens[_userAddress].add(_amount);
+        emit Freeze(_userAddress, _amount);
+        return true;
+    }
+
+    function unfreezeAccount(address _userAddress, uint256 _amount) onlyOwner public returns (bool success) {
+        require(userLockedTokens[_userAddress] >= _amount);
+        userLockedTokens[_userAddress] = userLockedTokens[_userAddress].sub(_amount);
+        emit UnFreeze(_userAddress, _amount);
+        return true;
+    }
+
+     function transfer(address _to, uint256 _value)  public returns (bool success) {
+        require(balance(msg.sender) >= _value);
+        return super.transfer(_to, _value);
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        require(balance(_from) >= _value);
+        return super.transferFrom(_from, _to, _value);
+    }
+
+
+}

benchmark2/integer overflow/626.sol

@@ -0,0 +1,185 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+  
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    
+    
+    
+    return a / b;
+  }
+
+  
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue > oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+contract VerityToken is StandardToken {
+  string public name = "VerityToken";
+  string public symbol = "VTY";
+  uint8 public decimals = 18;
+  uint public INITIAL_SUPPLY = 500000000 * 10 ** uint(decimals);
+
+  function VerityToken() public {
+    totalSupply_ = INITIAL_SUPPLY;
+    balances[msg.sender] = INITIAL_SUPPLY;
+  }
+}

benchmark2/integer overflow/634.sol

@@ -0,0 +1,179 @@
+pragma solidity ^0.4.16;
+
+contract owned {
+    address public owner;
+
+    function owned() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        owner = newOwner;
+    }
+}
+
+interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
+
+contract TokenERC20 {
+    
+    string public name;
+    string public symbol;
+    uint8 public decimals = 18;
+    
+    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);
+
+    
+    event Burn(address indexed from, uint256 value);
+
+    
+    function TokenERC20(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) public {
+        totalSupply = initialSupply * 10 ** uint256(decimals);  
+        balanceOf[msg.sender] = totalSupply;                
+        name = tokenName;                                   
+        symbol = tokenSymbol;                               
+    }
+
+    
+    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;
+        emit Transfer(_from, _to, _value);
+        
+        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
+    }
+
+    
+    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;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
+        public
+        returns (bool success) {
+        tokenRecipient spender = tokenRecipient(_spender);
+        if (approve(_spender, _value)) {
+            spender.receiveApproval(msg.sender, _value, this, _extraData);
+            return true;
+        }
+    }
+
+    
+    function burn(uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);   
+        balanceOf[msg.sender] -= _value;            
+        totalSupply -= _value;                      
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    
+    function burnFrom(address _from, uint256 _value) public returns (bool success) {
+        require(balanceOf[_from] >= _value);                
+        require(_value <= allowance[_from][msg.sender]);    
+        balanceOf[_from] -= _value;                         
+        allowance[_from][msg.sender] -= _value;             
+        totalSupply -= _value;                              
+        emit Burn(_from, _value);
+        return true;
+    }
+}
+
+
+
+
+
+contract INCRYPTHEDGE is owned, TokenERC20 {
+
+    
+
+    mapping (address => bool) public frozenAccount;
+
+    
+    event FrozenFunds(address target, bool frozen);
+
+    
+    function INCRYPTHEDGE(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
+
+    
+    function _transfer(address _from, address _to, uint _value) internal {
+        require (_to != 0x0);                               
+        require (balanceOf[_from] >= _value);               
+        require (balanceOf[_to] + _value >= balanceOf[_to]); 
+        require(!frozenAccount[_from]);                     
+        require(!frozenAccount[_to]);                       
+        balanceOf[_from] -= _value;                         
+        balanceOf[_to] += _value;                           
+        emit Transfer(_from, _to, _value);
+    }
+
+    
+    
+    
+    function mintToken(address target, uint256 mintedAmount) onlyOwner public {
+        balanceOf[target] += mintedAmount;
+        totalSupply += mintedAmount;
+        emit Transfer(0, this, mintedAmount);
+        emit Transfer(this, target, mintedAmount);
+    }
+
+    
+    
+    
+    function freezeAccount(address target, bool freeze) onlyOwner public {
+        frozenAccount[target] = freeze;
+        emit FrozenFunds(target, freeze);
+    }
+
+    
+}

benchmark2/integer overflow/635.sol

@@ -0,0 +1,179 @@
+pragma solidity ^0.4.16;
+
+contract owned {
+    address public owner;
+
+    function owned() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        owner = newOwner;
+    }
+}
+
+interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
+
+contract TokenERC20 {
+    
+    string public name;
+    string public symbol;
+    uint8 public decimals = 18;
+    
+    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);
+
+    
+    event Burn(address indexed from, uint256 value);
+
+    
+    function TokenERC20(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) public {
+        totalSupply = initialSupply * 10 ** uint256(decimals);  
+        balanceOf[msg.sender] = totalSupply;                
+        name = tokenName;                                   
+        symbol = tokenSymbol;                               
+    }
+
+    
+    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;
+        emit Transfer(_from, _to, _value);
+        
+        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
+    }
+
+    
+    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;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
+        public
+        returns (bool success) {
+        tokenRecipient spender = tokenRecipient(_spender);
+        if (approve(_spender, _value)) {
+            spender.receiveApproval(msg.sender, _value, this, _extraData);
+            return true;
+        }
+    }
+
+    
+    function burn(uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);   
+        balanceOf[msg.sender] -= _value;            
+        totalSupply -= _value;                      
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    
+    function burnFrom(address _from, uint256 _value) public returns (bool success) {
+        require(balanceOf[_from] >= _value);                
+        require(_value <= allowance[_from][msg.sender]);    
+        balanceOf[_from] -= _value;                         
+        allowance[_from][msg.sender] -= _value;             
+        totalSupply -= _value;                              
+        emit Burn(_from, _value);
+        return true;
+    }
+}
+
+
+
+
+
+contract INCRYPT is owned, TokenERC20 {
+
+    
+
+    mapping (address => bool) public frozenAccount;
+
+    
+    event FrozenFunds(address target, bool frozen);
+
+    
+    function INCRYPT(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
+
+    
+    function _transfer(address _from, address _to, uint _value) internal {
+        require (_to != 0x0);                               
+        require (balanceOf[_from] >= _value);               
+        require (balanceOf[_to] + _value >= balanceOf[_to]); 
+        require(!frozenAccount[_from]);                     
+        require(!frozenAccount[_to]);                       
+        balanceOf[_from] -= _value;                         
+        balanceOf[_to] += _value;                           
+        emit Transfer(_from, _to, _value);
+    }
+
+    
+    
+    
+    function mintToken(address target, uint256 mintedAmount) onlyOwner public {
+        balanceOf[target] += mintedAmount;
+        totalSupply += mintedAmount;
+        emit Transfer(0, this, mintedAmount);
+        emit Transfer(this, target, mintedAmount);
+    }
+
+    
+    
+    
+    function freezeAccount(address target, bool freeze) onlyOwner public {
+        frozenAccount[target] = freeze;
+        emit FrozenFunds(target, freeze);
+    }
+
+    
+}

benchmark2/integer overflow/638.sol

@@ -0,0 +1,153 @@
+pragma solidity ^0.4.24;
+
+
+contract SafeMath {
+  function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b > 0);
+    uint256 c = a / b;
+    assert(a == b * c + a % b);
+    return c;
+  }
+
+  function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c>=a && c>=b);
+    return c;
+  }
+
+}
+
+contract AMeiToken is SafeMath {
+    address public owner;
+    string public name;
+    string public symbol;
+    uint 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 Burn(address indexed from, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    
+    mapping (address => bool) public frozenAccount;
+    event FrozenFunds(address target, bool frozen);
+
+    bool lock = false;
+
+    constructor(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol,
+        uint decimalUnits
+    ) public {
+        owner = msg.sender;
+        name = tokenName;
+        symbol = tokenSymbol; 
+        decimals = decimalUnits;
+        totalSupply = initialSupply * 10 ** uint256(decimals);
+        balanceOf[msg.sender] = totalSupply;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    modifier isLock {
+        require(!lock);
+        _;
+    }
+    
+    function setLock(bool _lock) onlyOwner public{
+        lock = _lock;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        if (newOwner != address(0)) {
+            owner = newOwner;
+        }
+    }
+ 
+
+    function _transfer(address _from, address _to, uint _value) isLock internal {
+        require (_to != 0x0);
+        require (balanceOf[_from] >= _value);
+        require (balanceOf[_to] + _value > balanceOf[_to]);
+        require(!frozenAccount[_from]);
+        require(!frozenAccount[_to]);
+        balanceOf[_from] -= _value;
+        balanceOf[_to] += _value;
+        emit 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;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function burn(uint256 _value) onlyOwner public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);
+        balanceOf[msg.sender] -= _value;
+        totalSupply -= _value;
+        emit Burn(msg.sender, _value);
+        return true;
+    }
+
+    function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) {
+        require(balanceOf[_from] >= _value); 
+        require(_value <= allowance[_from][msg.sender]); 
+        balanceOf[_from] -= _value;
+        allowance[_from][msg.sender] -= _value;
+        totalSupply -= _value;
+        emit Burn(_from, _value);
+        return true;
+    }
+
+    function mintToken(address target, uint256 mintedAmount) onlyOwner public {
+        uint256 _amount = mintedAmount * 10 ** uint256(decimals);
+        balanceOf[target] += _amount;
+        totalSupply += _amount;
+        emit Transfer(this, target, _amount);
+    }
+    
+    function freezeAccount(address target, bool freeze) onlyOwner public {
+        frozenAccount[target] = freeze;
+        emit FrozenFunds(target, freeze);
+    }
+
+    function transferBatch(address[] _to, uint256 _value) public returns (bool success) {
+        for (uint i=0; i<_to.length; i++) {
+            _transfer(msg.sender, _to[i], _value);
+        }
+        return true;
+    }
+}

benchmark2/integer overflow/640.sol

@@ -0,0 +1,203 @@
+pragma solidity ^0.4.16;
+/* 创建一个父类， 账户管理员 */
+contract owned {
+
+    address public owner;
+
+    function owned() public {
+    owner = msg.sender;
+    }
+
+    /* modifier是修改标志 */
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    /* 修改管理员账户， onlyOwner代表只能是用户管理员来修改 */
+    function transferOwnership(address newOwner) onlyOwner public {
+        owner = newOwner;
+    }   
+}
+
+/* receiveApproval服务合约指示代币合约将代币从发送者的账户转移到服务合约的账户（通过调用服务合约的 */
+interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
+
+contract TokenERC20 {
+    // 代币（token）的公共变量
+    string public name;             //代币名字
+    string public symbol;           //代币符号
+    uint8 public decimals = 18;     //代币小数点位数， 18是默认， 尽量不要更改
+
+    uint256 public totalSupply;     //代币总量
+
+    // 记录各个账户的代币数目
+    mapping (address => uint256) public balanceOf;
+
+    // A账户存在B账户资金
+    mapping (address => mapping (address => uint256)) public allowance;
+
+    // 转账通知事件
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    // 销毁金额通知事件
+    event Burn(address indexed from, uint256 value);
+
+    /* 构造函数 */
+    function TokenERC20(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) public {
+        totalSupply = initialSupply * 10 ** uint256(decimals);  // 根据decimals计算代币的数量
+        balanceOf[msg.sender] = totalSupply;                    // 给生成者所有的代币数量
+        name = tokenName;                                       // 设置代币的名字
+        symbol = tokenSymbol;                                   // 设置代币的符号
+    }
+
+    /* 私有的交易函数 */
+    function _transfer(address _from, address _to, uint _value) internal {
+        // 防止转移到0x0， 用burn代替这个功能
+        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;
+        Transfer(_from, _to, _value);
+        // 断言检测， 不应该为错
+        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
+    }
+
+    /* 传递tokens */
+    function transfer(address _to, uint256 _value) public {
+        _transfer(msg.sender, _to, _value);
+    }
+
+    /* 从其他账户转移资产 */
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        require(_value <= allowance[_from][msg.sender]);     // Check allowance
+        allowance[_from][msg.sender] -= _value;
+        _transfer(_from, _to, _value);
+        return true;
+    }
+
+    /*  授权第三方从发送者账户转移代币，然后通过transferFrom()函数来执行第三方的转移操作 */
+    function approve(address _spender, uint256 _value) public
+        returns (bool success) {
+        allowance[msg.sender][_spender] = _value;
+        return true;
+    }
+
+    /*
+    为其他地址设置津贴， 并通知
+    发送者通知代币合约, 代币合约通知服务合约receiveApproval, 服务合约指示代币合约将代币从发送者的账户转移到服务合约的账户（通过调用服务合约的transferFrom)
+    */
+
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
+        public
+        returns (bool success) {
+        tokenRecipient spender = tokenRecipient(_spender);
+        if (approve(_spender, _value)) {
+            spender.receiveApproval(msg.sender, _value, this, _extraData);
+            return true;
+        }
+    }
+
+    /**
+    * 销毁代币
+    */
+    function burn(uint256 _value) public returns (bool success) {
+        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
+        balanceOf[msg.sender] -= _value;            // Subtract from the sender
+        totalSupply -= _value;                      // Updates totalSupply
+        Burn(msg.sender, _value);
+        return true;
+    }
+
+    /**
+    * 从其他账户销毁代币
+    */
+    function burnFrom(address _from, uint256 _value) public returns (bool success) {
+        require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
+        require(_value <= allowance[_from][msg.sender]);    // Check allowance
+        balanceOf[_from] -= _value;                         // Subtract from the targeted balance
+        allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
+        totalSupply -= _value;                              // Update totalSupply
+        Burn(_from, _value);
+        return true;
+    }
+}
+
+/******************************************/
+/*       ADVANCED TOKEN STARTS HERE       */
+/******************************************/
+
+contract ROSCtoken is owned, TokenERC20 {
+
+    uint256 public sellPrice;
+    uint256 public buyPrice;
+
+    /* 冻结账户 */
+    mapping (address => bool) public frozenAccount;
+
+    /* This generates a public event on the blockchain that will notify clients */
+    event FrozenFunds(address target, bool frozen);
+
+    /* 构造函数 */
+    function ROSCtoken(
+        uint256 initialSupply,
+        string tokenName,
+        string tokenSymbol
+    ) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
+
+    /* 转账， 比父类加入了账户冻结 */
+    function _transfer(address _from, address _to, uint _value) internal {
+        require (_to != 0x0);                               // Prevent transfer to 0x0 address. Use burn() instead
+        require (balanceOf[_from] >= _value);               // Check if the sender has enough
+        require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
+        require(!frozenAccount[_from]);                     // Check if sender is frozen
+        require(!frozenAccount[_to]);                       // Check if recipient is frozen
+        balanceOf[_from] -= _value;                         // Subtract from the sender
+        balanceOf[_to] += _value;                           // Add the same to the recipient
+        Transfer(_from, _to, _value);
+    }
+
+/// 向指定账户增发资金
+    function mintToken(address target, uint256 mintedAmount) onlyOwner public {
+        balanceOf[target] += mintedAmount;
+        totalSupply += mintedAmount;
+        Transfer(0, this, mintedAmount);
+        Transfer(this, target, mintedAmount);
+
+    }
+
+
+    /// 冻结 or 解冻账户
+    function freezeAccount(address target, bool freeze) onlyOwner public {
+        frozenAccount[target] = freeze;
+        FrozenFunds(target, freeze);
+    }
+
+    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
+        sellPrice = newSellPrice;
+        buyPrice = newBuyPrice;
+    }
+
+    /// @notice Buy tokens from contract by sending ether
+    function buy() payable public {
+        uint amount = msg.value / buyPrice;               // calculates the amount
+        _transfer(this, msg.sender, amount);              // makes the transfers
+    }
+
+    function sell(uint256 amount) public {
+        require(this.balance >= amount * sellPrice);      // checks if the contract has enough ether to buy
+        _transfer(msg.sender, this, amount);              // makes the transfers
+        msg.sender.transfer(amount * sellPrice);          // sends ether to the seller. It's important to do this last to avoid recursion attacks
+    }
+}

benchmark2/integer overflow/651.sol

@@ -0,0 +1,339 @@
+pragma solidity ^0.4.24;
+
+
+
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address _who) public view returns (uint256);
+  function transfer(address _to, uint256 _value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+
+
+library SafeMath {
+
+  
+  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    
+    
+    
+    if (_a == 0) {
+      return 0;
+    }
+
+    c = _a * _b;
+    assert(c / _a == _b);
+    return c;
+  }
+
+  
+  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    
+    
+    
+    return _a / _b;
+  }
+
+  
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    assert(_b <= _a);
+    return _a - _b;
+  }
+
+  
+  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    c = _a + _b;
+    assert(c >= _a);
+    return c;
+  }
+}
+
+
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) internal balances;
+
+  uint256 internal totalSupply_;
+
+  
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+  
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_value <= balances[msg.sender]);
+    require(_to != address(0));
+
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    emit Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  
+  function balanceOf(address _owner) public view returns (uint256) {
+    return balances[_owner];
+  }
+
+}
+
+
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address _owner, address _spender)
+    public view returns (uint256);
+
+  function transferFrom(address _from, address _to, uint256 _value)
+    public returns (bool);
+
+  function approve(address _spender, uint256 _value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}
+
+
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+
+  
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    returns (bool)
+  {
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+    require(_to != address(0));
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    emit Transfer(_from, _to, _value);
+    return true;
+  }
+
+  
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    emit Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  
+  function allowance(
+    address _owner,
+    address _spender
+   )
+    public
+    view
+    returns (uint256)
+  {
+    return allowed[_owner][_spender];
+  }
+
+  
+  function increaseApproval(
+    address _spender,
+    uint256 _addedValue
+  )
+    public
+    returns (bool)
+  {
+    allowed[msg.sender][_spender] = (
+      allowed[msg.sender][_spender].add(_addedValue));
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+  
+  function decreaseApproval(
+    address _spender,
+    uint256 _subtractedValue
+  )
+    public
+    returns (bool)
+  {
+    uint256 oldValue = allowed[msg.sender][_spender];
+    if (_subtractedValue >= oldValue) {
+      allowed[msg.sender][_spender] = 0;
+    } else {
+      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+    }
+    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+    return true;
+  }
+
+}
+
+
+
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+  
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+  
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+  
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+
+
+
+contract Pausable is Ownable {
+  event Pause();
+  event Unpause();
+
+  bool public paused = false;
+
+
+  
+  modifier whenNotPaused() {
+    require(!paused);
+    _;
+  }
+
+  
+  modifier whenPaused() {
+    require(paused);
+    _;
+  }
+
+  
+  function pause() public onlyOwner whenNotPaused {
+    paused = true;
+    emit Pause();
+  }
+
+  
+  function unpause() public onlyOwner whenPaused {
+    paused = false;
+    emit Unpause();
+  }
+}
+
+
+
+
+contract PausableToken is StandardToken, Pausable {
+
+  function transfer(
+    address _to,
+    uint256 _value
+  )
+    public
+    whenNotPaused
+    returns (bool)
+  {
+    return super.transfer(_to, _value);
+  }
+
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _value
+  )
+    public
+    whenNotPaused
+    returns (bool)
+  {
+    return super.transferFrom(_from, _to, _value);
+  }
+
+  function approve(
+    address _spender,
+    uint256 _value
+  )
+    public
+    whenNotPaused
+    returns (bool)
+  {
+    return super.approve(_spender, _value);
+  }
+
+  function increaseApproval(
+    address _spender,
+    uint _addedValue
+  )
+    public
+    whenNotPaused
+    returns (bool success)
+  {
+    return super.increaseApproval(_spender, _addedValue);
+  }
+
+  function decreaseApproval(
+    address _spender,
+    uint _subtractedValue
+  )
+    public
+    whenNotPaused
+    returns (bool success)
+  {
+    return super.decreaseApproval(_spender, _subtractedValue);
+  }
+}
+
+
+
+contract TangguoTaoToken is PausableToken{
+   string public name = "TangguoTao Token";
+   string public symbol = "TCA";
+   uint8 public decimals = 18;
+   uint public INITIAL_SUPPLY = 60000000000000000000000000000;
+
+   constructor() public {
+       totalSupply_ = INITIAL_SUPPLY;
+       balances[msg.sender] = INITIAL_SUPPLY;
+   }
+}

benchmark2/integer overflow/655.sol

@@ -0,0 +1,1134 @@
+pragma solidity ^0.4.24;
+
+ 
+
+ 
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    if (a == 0) {
+      return 0;
+    }
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+ 
+
+ 
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  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;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+}
+
+ 
+
+ 
+contract Pausable is Ownable {
+  event Pause();
+  event Unpause();
+
+  bool public paused = false;
+
+
+   
+  modifier whenNotPaused() {
+    require(!paused);
+    _;
+  }
+
+   
+  modifier whenPaused() {
+    require(paused);
+    _;
+  }
+
+   
+  function pause() onlyOwner whenNotPaused public {
+    paused = true;
+    emit Pause();
+  }
+
+   
+  function unpause() onlyOwner whenPaused public {
+    paused = false;
+    emit Unpause();
+  }
+}
+
+ 
+
+ 
+contract ERC721Basic {
+    function balanceOf(address _owner) public view returns (uint256 _balance);
+    function ownerOf(uint256 _tokenId) public view returns (address _owner);
+    function exists(uint256 _tokenId) public view returns (bool _exists);
+
+    function approve(address _to, uint256 _tokenId) public;
+    function getApproved(uint256 _tokenId) public view returns (address _operator);
+
+    function transferFrom(address _from, address _to, uint256 _tokenId) public;
+}
+
+ 
+contract HorseyExchange is Pausable {  
+
+    using SafeMath for uint256;
+
+    event HorseyDeposit(uint256 tokenId, uint256 price);
+    event SaleCanceled(uint256 tokenId);
+    event HorseyPurchased(uint256 tokenId, address newOwner, uint256 totalToPay);
+
+     
+    uint256 public marketMakerFee = 3;
+
+     
+    uint256 collectedFees = 0;
+
+     
+    ERC721Basic public token;
+
+     
+    struct SaleData {
+        uint256 price;
+        address owner;
+    }
+
+     
+    mapping (uint256 => SaleData) market;
+
+     
+    mapping (address => uint256[]) userBarn;
+
+     
+    constructor() Pausable() public {
+    }
+
+     
+    function setStables(address _token) external
+    onlyOwner()
+    {
+        require(address(_token) != 0,"Address of token is zero");
+        token = ERC721Basic(_token);
+    }
+
+     
+    function setMarketFees(uint256 fees) external
+    onlyOwner()
+    {
+        marketMakerFee = fees;
+    }
+
+     
+    function getTokensOnSale(address user) external view returns(uint256[]) {
+        return userBarn[user];
+    }
+
+     
+    function getTokenPrice(uint256 tokenId) public view
+    isOnMarket(tokenId) returns (uint256) {
+        return market[tokenId].price + (market[tokenId].price.div(100).mul(marketMakerFee));
+    }
+
+     
+    function depositToExchange(uint256 tokenId, uint256 price) external
+    whenNotPaused()
+    isTokenOwner(tokenId)
+    nonZeroPrice(price)
+    tokenAvailable() {
+        require(token.getApproved(tokenId) == address(this),"Exchange is not allowed to transfer");
+         
+        token.transferFrom(msg.sender, address(this), tokenId);
+        
+         
+        market[tokenId] = SaleData(price,msg.sender);
+
+         
+        userBarn[msg.sender].push(tokenId);
+
+        emit HorseyDeposit(tokenId, price);
+    }
+
+     
+    function cancelSale(uint256 tokenId) external 
+    whenNotPaused()
+    originalOwnerOf(tokenId) 
+    tokenAvailable() returns (bool) {
+         
+        token.transferFrom(address(this),msg.sender,tokenId);
+        
+         
+        delete market[tokenId];
+
+         
+        _removeTokenFromBarn(tokenId, msg.sender);
+
+        emit SaleCanceled(tokenId);
+
+         
+         
+        return userBarn[msg.sender].length > 0;
+    }
+
+     
+    function purchaseToken(uint256 tokenId) external payable 
+    whenNotPaused()
+    isOnMarket(tokenId) 
+    tokenAvailable()
+    notOriginalOwnerOf(tokenId)
+    {
+         
+        uint256 totalToPay = getTokenPrice(tokenId);
+        require(msg.value >= totalToPay, "Not paying enough");
+
+         
+        SaleData memory sale = market[tokenId];
+
+         
+        collectedFees += totalToPay - sale.price;
+
+         
+        sale.owner.transfer(sale.price);
+
+         
+        _removeTokenFromBarn(tokenId,  sale.owner);
+
+         
+        delete market[tokenId];
+
+         
+         
+        token.transferFrom(address(this), msg.sender, tokenId);
+
+         
+        if(msg.value > totalToPay)  
+        {
+            msg.sender.transfer(msg.value.sub(totalToPay));
+        }
+
+        emit HorseyPurchased(tokenId, msg.sender, totalToPay);
+    }
+
+     
+    function withdraw() external
+    onlyOwner()
+    {
+        assert(collectedFees <= address(this).balance);
+        owner.transfer(collectedFees);
+        collectedFees = 0;
+    }
+
+     
+    function _removeTokenFromBarn(uint tokenId, address barnAddress)  internal {
+        uint256[] storage barnArray = userBarn[barnAddress];
+        require(barnArray.length > 0,"No tokens to remove");
+        int index = _indexOf(tokenId, barnArray);
+        require(index >= 0, "Token not found in barn");
+
+         
+        for (uint256 i = uint256(index); i<barnArray.length-1; i++){
+            barnArray[i] = barnArray[i+1];
+        }
+
+         
+         
+        barnArray.length--;
+    }
+
+     
+    function _indexOf(uint item, uint256[] memory array) internal pure returns (int256){
+
+         
+        for(uint256 i = 0; i < array.length; i++){
+            if(array[i] == item){
+                return int256(i);
+            }
+        }
+
+         
+        return -1;
+    }
+
+     
+    modifier isOnMarket(uint256 tokenId) {
+        require(token.ownerOf(tokenId) == address(this),"Token not on market");
+        _;
+    }
+    
+     
+    modifier isTokenOwner(uint256 tokenId) {
+        require(token.ownerOf(tokenId) == msg.sender,"Not tokens owner");
+        _;
+    }
+
+     
+    modifier originalOwnerOf(uint256 tokenId) {
+        require(market[tokenId].owner == msg.sender,"Not the original owner of");
+        _;
+    }
+
+     
+    modifier notOriginalOwnerOf(uint256 tokenId) {
+        require(market[tokenId].owner != msg.sender,"Is the original owner");
+        _;
+    }
+
+     
+    modifier nonZeroPrice(uint256 price){
+        require(price > 0,"Price is zero");
+        _;
+    }
+
+     
+    modifier tokenAvailable(){
+        require(address(token) != 0,"Token address not set");
+        _;
+    }
+}
+
+ 
+
+contract BettingControllerInterface {
+    address public owner;
+}
+ 
+contract EthorseRace {
+
+     
+    struct chronus_info {
+        bool  betting_open;  
+        bool  race_start;  
+        bool  race_end;  
+        bool  voided_bet;  
+        uint32  starting_time;  
+        uint32  betting_duration;
+        uint32  race_duration;  
+        uint32 voided_timestamp;
+    }
+
+    address public owner;
+    
+     
+    chronus_info public chronus;
+
+     
+    mapping (bytes32 => bool) public winner_horse;
+     
+     
+    function getCoinIndex(bytes32 index, address candidate) external constant returns (uint, uint, uint, bool, uint);
+}
+
+ 
+contract EthorseHelpers {
+
+     
+    bytes32[] public all_horses = [bytes32("BTC"),bytes32("ETH"),bytes32("LTC")];
+    mapping(address => bool) private _legitOwners;
+
+     
+    function _addHorse(bytes32 newHorse) internal {
+        all_horses.push(newHorse);
+    }
+
+    function _addLegitOwner(address newOwner) internal
+    {
+        _legitOwners[newOwner] = true;
+    }
+
+    function getall_horsesCount() public view returns(uint) {
+        return all_horses.length;
+    }
+
+     
+    function _isWinnerOf(address raceAddress, address eth_address) internal view returns (bool,bytes32)
+    {
+         
+        EthorseRace race = EthorseRace(raceAddress);
+         
+        BettingControllerInterface bc = BettingControllerInterface(race.owner());
+         
+        require(_legitOwners[bc.owner()]);
+         
+        bool  voided_bet;  
+        bool  race_end;  
+        (,,race_end,voided_bet,,,,) = race.chronus();
+
+         
+        if(voided_bet || !race_end)
+            return (false,bytes32(0));
+
+         
+        bytes32 horse;
+        bool found = false;
+        uint256 arrayLength = all_horses.length;
+
+         
+        for(uint256 i = 0; i < arrayLength; i++)
+        {
+            if(race.winner_horse(all_horses[i])) {
+                horse = all_horses[i];
+                found = true;
+                break;
+            }
+        }
+         
+        if(!found)
+            return (false,bytes32(0));
+
+         
+        uint256 bet_amount = 0;
+        if(eth_address != address(0)) {
+            (,,,, bet_amount) = race.getCoinIndex(horse, eth_address);
+        }
+        
+         
+        return (bet_amount > 0, horse);
+    }
+}
+
+ 
+
+contract RoyalStablesInterface {
+    
+    struct Horsey {
+        address race;
+        bytes32 dna;
+        uint8 feedingCounter;
+        uint8 tier;
+    }
+
+    mapping(uint256 => Horsey) public horseys;
+    mapping(address => uint32) public carrot_credits;
+    mapping(uint256 => string) public names;
+    address public master;
+
+    function getOwnedTokens(address eth_address) public view returns (uint256[]);
+    function storeName(uint256 tokenId, string newName) public;
+    function storeCarrotsCredit(address client, uint32 amount) public;
+    function storeHorsey(address client, uint256 tokenId, address race, bytes32 dna, uint8 feedingCounter, uint8 tier) public;
+    function modifyHorsey(uint256 tokenId, address race, bytes32 dna, uint8 feedingCounter, uint8 tier) public;
+    function modifyHorseyDna(uint256 tokenId, bytes32 dna) public;
+    function modifyHorseyFeedingCounter(uint256 tokenId, uint8 feedingCounter) public;
+    function modifyHorseyTier(uint256 tokenId, uint8 tier) public;
+    function unstoreHorsey(uint256 tokenId) public;
+    function ownerOf(uint256 tokenId) public returns (address);
+}
+
+ 
+contract HorseyToken is EthorseHelpers,Pausable {
+    using SafeMath for uint256;
+
+     
+    event Claimed(address raceAddress, address eth_address, uint256 tokenId);
+    
+     
+    event Feeding(uint256 tokenId);
+
+     
+    event ReceivedCarrot(uint256 tokenId, bytes32 newDna);
+
+     
+    event FeedingFailed(uint256 tokenId);
+
+     
+    event HorseyRenamed(uint256 tokenId, string newName);
+
+     
+    event HorseyFreed(uint256 tokenId);
+
+     
+    RoyalStablesInterface public stables;
+
+     
+    uint8 public carrotsMultiplier = 1;
+
+     
+    uint8 public rarityMultiplier = 1;
+
+     
+    uint256 public claimingFee = 0.008 ether;
+
+     
+    struct FeedingData {
+        uint256 blockNumber;     
+        uint256 horsey;          
+    }
+
+     
+    mapping(address => FeedingData) public pendingFeedings;
+
+     
+    uint256 public renamingCostsPerChar = 0.001 ether;
+
+     
+    constructor(address stablesAddress) 
+    EthorseHelpers() 
+    Pausable() public {
+        stables = RoyalStablesInterface(stablesAddress);
+    }
+
+     
+    function setRarityMultiplier(uint8 newRarityMultiplier) external 
+    onlyOwner()  {
+        rarityMultiplier = newRarityMultiplier;
+    }
+
+     
+    function setCarrotsMultiplier(uint8 newCarrotsMultiplier) external 
+    onlyOwner()  {
+        carrotsMultiplier = newCarrotsMultiplier;
+    }
+
+     
+    function setRenamingCosts(uint256 newRenamingCost) external 
+    onlyOwner()  {
+        renamingCostsPerChar = newRenamingCost;
+    }
+
+     
+    function setClaimingCosts(uint256 newClaimingFee) external
+    onlyOwner()  {
+        claimingFee = newClaimingFee;
+    }
+
+     
+    function addLegitDevAddress(address newAddress) external
+    onlyOwner() {
+        _addLegitOwner(newAddress);
+    }
+
+     
+    function withdraw() external 
+    onlyOwner()  {
+        owner.transfer(address(this).balance);  
+    }
+
+     
+     
+    function addHorseIndex(bytes32 newHorse) external
+    onlyOwner() {
+        _addHorse(newHorse);
+    }
+
+     
+    function getOwnedTokens(address eth_address) public view returns (uint256[]) {
+        return stables.getOwnedTokens(eth_address);
+    }
+    
+     
+    function can_claim(address raceAddress, address eth_address) public view returns (bool) {
+        bool res;
+        (res,) = _isWinnerOf(raceAddress, eth_address);
+        return res;
+    }
+
+     
+    function claim(address raceAddress) external payable
+    costs(claimingFee)
+    whenNotPaused()
+    {
+         
+        bytes32 winner;
+        (,winner) = _isWinnerOf(raceAddress, address(0));
+        require(winner != bytes32(0),"Winner is zero");
+        require(can_claim(raceAddress, msg.sender),"can_claim return false");
+         
+        uint256 id = _generate_special_horsey(raceAddress, msg.sender, winner);
+        emit Claimed(raceAddress, msg.sender, id);
+    }
+
+     
+    function renameHorsey(uint256 tokenId, string newName) external 
+    whenNotPaused()
+    onlyOwnerOf(tokenId) 
+    costs(renamingCostsPerChar * bytes(newName).length)
+    payable {
+        uint256 renamingFee = renamingCostsPerChar * bytes(newName).length;
+         
+        if(msg.value > renamingFee)  
+        {
+            msg.sender.transfer(msg.value.sub(renamingFee));
+        }
+         
+        stables.storeName(tokenId,newName);
+        emit HorseyRenamed(tokenId,newName);
+    }
+
+     
+    function freeForCarrots(uint256 tokenId) external 
+    whenNotPaused()
+    onlyOwnerOf(tokenId) {
+        require(pendingFeedings[msg.sender].horsey != tokenId,"");
+         
+        uint8 feedingCounter;
+        (,,feedingCounter,) = stables.horseys(tokenId);
+        stables.storeCarrotsCredit(msg.sender,stables.carrot_credits(msg.sender) + uint32(feedingCounter * carrotsMultiplier));
+        stables.unstoreHorsey(tokenId);
+        emit HorseyFreed(tokenId);
+    }
+
+     
+    function getCarrotCredits() external view returns (uint32) {
+        return stables.carrot_credits(msg.sender);
+    }
+
+     
+    function getHorsey(uint256 tokenId) public view returns (address, bytes32, uint8, string) {
+        RoyalStablesInterface.Horsey memory temp;
+        (temp.race,temp.dna,temp.feedingCounter,temp.tier) = stables.horseys(tokenId);
+        return (temp.race,temp.dna,temp.feedingCounter,stables.names(tokenId));
+    }
+
+     
+    function feed(uint256 tokenId) external 
+    whenNotPaused()
+    onlyOwnerOf(tokenId) 
+    carrotsMeetLevel(tokenId)
+    noFeedingInProgress()
+    {
+        pendingFeedings[msg.sender] = FeedingData(block.number,tokenId);
+        uint8 feedingCounter;
+        (,,feedingCounter,) = stables.horseys(tokenId);
+        stables.storeCarrotsCredit(msg.sender,stables.carrot_credits(msg.sender) - uint32(feedingCounter));
+        emit Feeding(tokenId);
+    }
+
+     
+    function stopFeeding() external
+    feedingInProgress() returns (bool) {
+        uint256 blockNumber = pendingFeedings[msg.sender].blockNumber;
+        uint256 tokenId = pendingFeedings[msg.sender].horsey;
+         
+        require(block.number - blockNumber >= 1,"feeding and stop feeding are in same block");
+
+        delete pendingFeedings[msg.sender];
+
+         
+         
+        if(block.number - blockNumber > 255) {
+             
+             
+            emit FeedingFailed(tokenId);
+            return false; 
+        }
+
+         
+        if(stables.ownerOf(tokenId) != msg.sender) {
+             
+             
+            emit FeedingFailed(tokenId);
+            return false; 
+        }
+        
+         
+        _feed(tokenId, blockhash(blockNumber));
+        bytes32 dna;
+        (,dna,,) = stables.horseys(tokenId);
+        emit ReceivedCarrot(tokenId, dna);
+        return true;
+    }
+
+     
+    function() external payable {
+        revert("Not accepting donations");
+    }
+
+     
+    function _feed(uint256 tokenId, bytes32 blockHash) internal {
+         
+        uint8 tier;
+        uint8 feedingCounter;
+        (,,feedingCounter,tier) = stables.horseys(tokenId);
+        uint256 probabilityByRarity = 10 ** (uint256(tier).add(1));
+        uint256 randNum = uint256(keccak256(abi.encodePacked(tokenId, blockHash))) % probabilityByRarity;
+
+         
+        if(randNum <= (feedingCounter * rarityMultiplier)){
+            _increaseRarity(tokenId, blockHash);
+        }
+
+         
+         
+        if(feedingCounter < 255) {
+            stables.modifyHorseyFeedingCounter(tokenId,feedingCounter+1);
+        }
+    }
+
+     
+    function _makeSpecialId(address race, address sender, bytes32 coinIndex) internal pure returns (uint256) {
+        return uint256(keccak256(abi.encodePacked(race, sender, coinIndex)));
+    }
+
+     
+    function _generate_special_horsey(address race, address eth_address, bytes32 coinIndex) internal returns (uint256) {
+        uint256 id = _makeSpecialId(race, eth_address, coinIndex);
+         
+        bytes32 dna = _shiftRight(keccak256(abi.encodePacked(race, coinIndex)),16);
+          
+        stables.storeHorsey(eth_address,id,race,dna,1,0);
+        return id;
+    }
+    
+     
+    function _increaseRarity(uint256 tokenId, bytes32 blockHash) private {
+        uint8 tier;
+        bytes32 dna;
+        (,dna,,tier) = stables.horseys(tokenId);
+        if(tier < 255)
+            stables.modifyHorseyTier(tokenId,tier+1);
+        uint256 random = uint256(keccak256(abi.encodePacked(tokenId, blockHash)));
+         
+        bytes32 rarityMask = _shiftLeft(bytes32(1), (random % 16 + 240));
+        bytes32 newdna = dna | rarityMask;  
+        stables.modifyHorseyDna(tokenId,newdna);
+    }
+
+     
+    function _shiftLeft(bytes32 data, uint n) internal pure returns (bytes32) {
+        return bytes32(uint256(data)*(2 ** n));
+    }
+
+     
+    function _shiftRight(bytes32 data, uint n) internal pure returns (bytes32) {
+        return bytes32(uint256(data)/(2 ** n));
+    }
+
+     
+    modifier carrotsMeetLevel(uint256 tokenId){
+        uint256 feedingCounter;
+        (,,feedingCounter,) = stables.horseys(tokenId);
+        require(feedingCounter <= stables.carrot_credits(msg.sender),"Not enough carrots");
+        _;
+    }
+
+     
+    modifier costs(uint256 amount) {
+        require(msg.value >= amount,"Not enough funds");
+        _;
+    }
+
+     
+    modifier validAddress(address addr) {
+        require(addr != address(0),"Address is zero");
+        _;
+    }
+
+     
+    modifier noFeedingInProgress() {
+         
+        require(pendingFeedings[msg.sender].blockNumber == 0,"Already feeding");
+        _;
+    }
+
+     
+    modifier feedingInProgress() {
+         
+        require(pendingFeedings[msg.sender].blockNumber != 0,"No pending feeding");
+        _;
+    }
+
+     
+    modifier onlyOwnerOf(uint256 tokenId) {
+        require(stables.ownerOf(tokenId) == msg.sender, "Caller is not owner of this token");
+        _;
+    }
+}
+
+ 
+
+ 
+
+contract HorseyPilot {
+    
+    using SafeMath for uint256;
+
+     
+    event NewProposal(uint8 methodId, uint parameter, address proposer);
+
+     
+    event ProposalPassed(uint8 methodId, uint parameter, address proposer);
+
+     
+     
+    uint8 constant votingThreshold = 2;
+
+     
+     
+    uint256 constant proposalLife = 7 days;
+
+     
+     
+    uint256 constant proposalCooldown = 1 days;
+
+     
+    uint256 cooldownStart;
+
+     
+    address public jokerAddress;
+    address public knightAddress;
+    address public paladinAddress;
+
+     
+    address[3] public voters;
+
+     
+    uint8 constant public knightEquity = 40;
+    uint8 constant public paladinEquity = 10;
+
+     
+    address public exchangeAddress;
+    address public tokenAddress;
+
+     
+    mapping(address => uint) internal _cBalance;
+
+     
+    struct Proposal{
+        address proposer;            
+        uint256 timestamp;           
+        uint256 parameter;           
+        uint8   methodId;            
+        address[] yay;               
+        address[] nay;               
+    }
+
+     
+    Proposal public currentProposal;
+
+     
+    bool public proposalInProgress = false;
+
+     
+    uint256 public toBeDistributed;
+
+     
+    bool deployed = false;
+
+     
+    constructor(
+    address _jokerAddress,
+    address _knightAddress,
+    address _paladinAddress,
+    address[3] _voters
+    ) public {
+        jokerAddress = _jokerAddress;
+        knightAddress = _knightAddress;
+        paladinAddress = _paladinAddress;
+
+        for(uint i = 0; i < 3; i++) {
+            voters[i] = _voters[i];
+        }
+
+         
+        cooldownStart = block.timestamp - proposalCooldown;
+    }
+
+     
+    function deployChildren(address stablesAddress) external {
+        require(!deployed,"already deployed");
+         
+        exchangeAddress = new HorseyExchange();
+        tokenAddress = new HorseyToken(stablesAddress);
+
+         
+        HorseyExchange(exchangeAddress).setStables(stablesAddress);
+
+        deployed = true;
+    }
+
+     
+    function transferJokerOwnership(address newJoker) external 
+    validAddress(newJoker) {
+        require(jokerAddress == msg.sender,"Not right role");
+        _moveBalance(newJoker);
+        jokerAddress = newJoker;
+    }
+
+     
+    function transferKnightOwnership(address newKnight) external 
+    validAddress(newKnight) {
+        require(knightAddress == msg.sender,"Not right role");
+        _moveBalance(newKnight);
+        knightAddress = newKnight;
+    }
+
+     
+    function transferPaladinOwnership(address newPaladin) external 
+    validAddress(newPaladin) {
+        require(paladinAddress == msg.sender,"Not right role");
+        _moveBalance(newPaladin);
+        paladinAddress = newPaladin;
+    }
+
+     
+    function withdrawCeo(address destination) external 
+    onlyCLevelAccess()
+    validAddress(destination) {
+         
+         
+        if(toBeDistributed > 0){
+            _updateDistribution();
+        }
+        
+         
+        uint256 balance = _cBalance[msg.sender];
+        
+         
+        if(balance > 0 && (address(this).balance >= balance)) {
+            destination.transfer(balance);  
+            _cBalance[msg.sender] = 0;
+        }
+    }
+
+     
+    function syncFunds() external {
+        uint256 prevBalance = address(this).balance;
+        HorseyToken(tokenAddress).withdraw();
+        HorseyExchange(exchangeAddress).withdraw();
+        uint256 newBalance = address(this).balance;
+         
+        toBeDistributed = toBeDistributed.add(newBalance - prevBalance);
+    }
+
+     
+    function getNobleBalance() external view
+    onlyCLevelAccess() returns (uint256) {
+        return _cBalance[msg.sender];
+    }
+
+     
+    function makeProposal( uint8 methodId, uint256 parameter ) external
+    onlyCLevelAccess()
+    proposalAvailable()
+    cooledDown()
+    {
+        currentProposal.timestamp = block.timestamp;
+        currentProposal.parameter = parameter;
+        currentProposal.methodId = methodId;
+        currentProposal.proposer = msg.sender;
+        delete currentProposal.yay;
+        delete currentProposal.nay;
+        proposalInProgress = true;
+        
+        emit NewProposal(methodId,parameter,msg.sender);
+    }
+
+     
+    function voteOnProposal(bool voteFor) external 
+    proposalPending()
+    onlyVoters()
+    notVoted() {
+         
+        require((block.timestamp - currentProposal.timestamp) <= proposalLife);
+        if(voteFor)
+        {
+            currentProposal.yay.push(msg.sender);
+             
+            if( currentProposal.yay.length >= votingThreshold )
+            {
+                _doProposal();
+                proposalInProgress = false;
+                 
+                return;
+            }
+
+        } else {
+            currentProposal.nay.push(msg.sender);
+             
+            if( currentProposal.nay.length >= votingThreshold )
+            {
+                proposalInProgress = false;
+                cooldownStart = block.timestamp;
+                return;
+            }
+        }
+    }
+
+     
+    function _moveBalance(address newAddress) internal
+    validAddress(newAddress) {
+        require(newAddress != msg.sender);  
+        _cBalance[newAddress] = _cBalance[msg.sender];
+        _cBalance[msg.sender] = 0;
+    }
+
+     
+    function _updateDistribution() internal {
+        require(toBeDistributed != 0,"nothing to distribute");
+        uint256 knightPayday = toBeDistributed.div(100).mul(knightEquity);
+        uint256 paladinPayday = toBeDistributed.div(100).mul(paladinEquity);
+
+         
+        uint256 jokerPayday = toBeDistributed.sub(knightPayday).sub(paladinPayday);
+
+        _cBalance[jokerAddress] = _cBalance[jokerAddress].add(jokerPayday);
+        _cBalance[knightAddress] = _cBalance[knightAddress].add(knightPayday);
+        _cBalance[paladinAddress] = _cBalance[paladinAddress].add(paladinPayday);
+         
+        toBeDistributed = 0;
+    }
+
+     
+    function _doProposal() internal {
+         
+        if( currentProposal.methodId == 0 ) HorseyToken(tokenAddress).setRenamingCosts(currentProposal.parameter);
+        
+         
+        if( currentProposal.methodId == 1 ) HorseyExchange(exchangeAddress).setMarketFees(currentProposal.parameter);
+
+         
+        if( currentProposal.methodId == 2 ) HorseyToken(tokenAddress).addLegitDevAddress(address(currentProposal.parameter));
+
+         
+        if( currentProposal.methodId == 3 ) HorseyToken(tokenAddress).addHorseIndex(bytes32(currentProposal.parameter));
+
+         
+        if( currentProposal.methodId == 4 ) {
+            if(currentProposal.parameter == 0) {
+                HorseyExchange(exchangeAddress).unpause();
+                HorseyToken(tokenAddress).unpause();
+            } else {
+                HorseyExchange(exchangeAddress).pause();
+                HorseyToken(tokenAddress).pause();
+            }
+        }
+
+         
+        if( currentProposal.methodId == 5 ) HorseyToken(tokenAddress).setClaimingCosts(currentProposal.parameter);
+
+         
+        if( currentProposal.methodId == 8 ){
+            HorseyToken(tokenAddress).setCarrotsMultiplier(uint8(currentProposal.parameter));
+        }
+
+         
+        if( currentProposal.methodId == 9 ){
+            HorseyToken(tokenAddress).setRarityMultiplier(uint8(currentProposal.parameter));
+        }
+
+        emit ProposalPassed(currentProposal.methodId,currentProposal.parameter,currentProposal.proposer);
+    }
+
+     
+    modifier validAddress(address addr) {
+        require(addr != address(0),"Address is zero");
+        _;
+    }
+
+     
+    modifier onlyCLevelAccess() {
+        require((jokerAddress == msg.sender) || (knightAddress == msg.sender) || (paladinAddress == msg.sender),"not c level");
+        _;
+    }
+
+     
+     
+    modifier proposalAvailable(){
+        require(((!proposalInProgress) || ((block.timestamp - currentProposal.timestamp) > proposalLife)),"proposal already pending");
+        _;
+    }
+
+     
+     
+    modifier cooledDown( ){
+        if(msg.sender == currentProposal.proposer && (block.timestamp - cooldownStart < 1 days)){
+            revert("Cool down period not passed yet");
+        }
+        _;
+    }
+
+     
+    modifier proposalPending() {
+        require(proposalInProgress,"no proposal pending");
+        _;
+    }
+
+     
+    modifier notVoted() {
+        uint256 length = currentProposal.yay.length;
+        for(uint i = 0; i < length; i++) {
+            if(currentProposal.yay[i] == msg.sender) {
+                revert("Already voted");
+            }
+        }
+
+        length = currentProposal.nay.length;
+        for(i = 0; i < length; i++) {
+            if(currentProposal.nay[i] == msg.sender) {
+                revert("Already voted");
+            }
+        }
+        _;
+    }
+
+     
+    modifier onlyVoters() {
+        bool found = false;
+        uint256 length = voters.length;
+        for(uint i = 0; i < length; i++) {
+            if(voters[i] == msg.sender) {
+                found = true;
+                break;
+            }
+        }
+        if(!found) {
+            revert("not a voter");
+        }
+        _;
+    }
+}

benchmark2/integer overflow/682.sol

@@ -0,0 +1,147 @@
+pragma solidity ^0.4.24;
+
+
+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 ERC20Basic {
+  uint256 public totalSupply;
+  function balanceOf(address who) constant returns (uint256);
+  function transfer(address to, uint256 value) returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+
+  function transfer(address _to, uint256 _value) returns (bool) {
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+
+  function balanceOf(address _owner) constant returns (uint256 balance) {
+    return balances[_owner];
+  }
+
+}
+
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) constant returns (uint256);
+  function transferFrom(address from, address to, uint256 value) returns (bool);
+  function approve(address spender, uint256 value) returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract StandardToken is ERC20, BasicToken {
+
+  mapping (address => mapping (address => uint256)) allowed;
+
+
+  
+  function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
+    var _allowance = allowed[_from][msg.sender];
+    balances[_to] = balances[_to].add(_value);
+    balances[_from] = balances[_from].sub(_value);
+    allowed[_from][msg.sender] = _allowance.sub(_value);
+    Transfer(_from, _to, _value);
+    return true;
+  }
+
+ 
+  function approve(address _spender, uint256 _value) returns (bool) {
+
+    require((_value == 0) || (allowed[msg.sender][_spender] == 0));
+
+    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];
+  }
+
+}
+
+contract Ownable {
+  address public owner;
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+  
+   
+    
+  
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+  
+  function transferOwnership(address newOwner) public onlyOwner {
+    require(newOwner != address(0));
+    emit OwnershipTransferred(owner, newOwner);
+    owner = newOwner;
+  }
+}
+
+
+
+
+
+
+contract IPM is StandardToken ,Ownable {
+
+  string public constant name = "IPMCOIN";
+  string public constant symbol = "IPM";
+  uint256 public constant decimals = 18;
+  
+  uint256 public constant INITIAL_SUPPLY = 3000000000 * 10 ** uint256(decimals);
+
+  
+  function IPM() {
+    totalSupply = INITIAL_SUPPLY;
+    balances[msg.sender] = INITIAL_SUPPLY;
+    owner=msg.sender;
+  }
+  
+
+  function Airdrop(ERC20 token, address[] _addresses, uint256 amount) public {
+        for (uint256 i = 0; i < _addresses.length; i++) {
+            token.transfer(_addresses[i], amount);
+        }
+    }
+ 
+
+ 
+}

benchmark2/integer overflow/683.sol

@@ -0,0 +1,196 @@
+pragma solidity ^0.4.23;
+
+contract Ownable {
+    address public owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address newOwner) public onlyOwner {
+        require(newOwner != address(0));
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+}
+
+contract Pausable is Ownable {
+    event Pause();
+    event Unpause();
+
+    bool public paused = false;
+
+    modifier whenNotPaused() {
+        if (msg.sender != owner) {
+            require(!paused);
+        }
+        _;
+    }
+
+    modifier whenPaused() {
+        if (msg.sender != owner) {
+            require(paused);
+        }
+        _;
+    }
+
+    function pause() onlyOwner public {
+        paused = true;
+        emit Pause();
+    }
+
+    function unpause() onlyOwner public {
+        paused = false;
+        emit Unpause();
+    }
+}
+
+library SafeMath {
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(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;
+        assert(c >= a);
+        return c;
+    }
+}
+
+contract ERC20 {
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    uint public totalSupply;
+    constructor(string _name, string _symbol, uint8 _decimals) public {
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+    }
+    function balanceOf(address who) public view returns (uint);
+    function transfer(address to, uint value) public returns (bool);
+    function allowance(address owner, address spender) public view returns (uint);
+    function transferFrom(address from, address to, uint value) public returns (bool);
+    function approve(address spender, uint value) public returns (bool);
+    event Transfer(address indexed from, address indexed to, uint value);
+    event Approval(address indexed owner, address indexed spender, uint value);
+}
+
+contract Token is Pausable, ERC20 {
+    using SafeMath for uint;
+    event Burn(address indexed burner, uint256 value);
+
+    mapping(address => uint) balances;
+    mapping (address => mapping (address => uint)) internal allowed;
+    mapping(address => uint) public balanceOfLocked;
+    mapping(address => bool) public addressLocked;
+
+    constructor() ERC20("OCP", "OCP", 18) public {
+        totalSupply = 10000000000 * 10 ** uint(decimals);
+        balances[msg.sender] = totalSupply;
+    }
+
+    modifier lockCheck(address from, uint value) { 
+        require(addressLocked[from] == false);
+        require(balances[from] >= balanceOfLocked[from]);
+        require(value <= balances[from] - balanceOfLocked[from]);
+        _;
+    }
+
+    function burn(uint _value) onlyOwner public {
+        balances[owner] = balances[owner].sub(_value);
+        totalSupply = totalSupply.sub(_value);
+        emit Burn(msg.sender, _value);
+    }
+
+    function lockAddressValue(address _addr, uint _value) onlyOwner public {
+        balanceOfLocked[_addr] = _value;
+    }
+
+    function lockAddress(address addr) onlyOwner public {
+        addressLocked[addr] = true;
+    }
+
+    function unlockAddress(address addr) onlyOwner public {
+        addressLocked[addr] = false;
+    }
+
+    function transfer(address _to, uint _value) lockCheck(msg.sender, _value) whenNotPaused public returns (bool) {
+        require(_to != address(0));
+        require(_value <= balances[msg.sender]);
+
+        
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        emit Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    function balanceOf(address _owner) public view returns (uint balance) {
+        return balances[_owner];
+    }
+
+    function transferFrom(address _from, address _to, uint _value) public lockCheck(_from, _value) whenNotPaused returns (bool) {
+        require(_to != address(0));
+        require(_value <= balances[_from]);
+        require(_value <= allowed[_from][msg.sender]);
+
+        balances[_from] = balances[_from].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+        emit Transfer(_from, _to, _value);
+        return true;
+    }
+
+    function approve(address _spender, uint _value) public whenNotPaused returns (bool) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) public view returns (uint) {
+        return allowed[_owner][_spender];
+    }
+
+    function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool) {
+        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+
+    function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool) {
+        uint oldValue = allowed[msg.sender][_spender];
+        if (_subtractedValue > oldValue) {
+            allowed[msg.sender][_spender] = 0;
+        } else {
+            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+        }
+        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+        return true;
+    }
+}

benchmark2/integer overflow/727.sol

@@ -0,0 +1,137 @@
+pragma solidity 0.4.24;
+
+
+
+
+
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        c = a + b; assert(c >= a); return c; }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+        if (a == 0){return 0;} c = a * b; assert(c / a == b); return c; }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; }
+}
+
+
+
+contract ERC20Token {
+    function totalSupply() public view returns (uint256);
+    function balanceOf(address _targetAddress) public view returns (uint256);
+    function transfer(address _targetAddress, uint256 _value) public returns (bool);
+    event Transfer(address indexed _originAddress, address indexed _targetAddress, uint256 _value);
+    
+    function allowance(address _originAddress, address _targetAddress) public view returns (uint256);
+    function approve(address _originAddress, uint256 _value) public returns (bool);
+    function transferFrom(address _originAddress, address _targetAddress, uint256 _value) public returns (bool);
+    event Approval(address indexed _originAddress, address indexed _targetAddress, uint256 _value);
+}
+
+
+
+contract Ownership {
+    address public owner;
+
+    modifier onlyOwner() { require(msg.sender == owner); _; }
+    modifier validDestination(address _targetAddress) { require(_targetAddress != address(0x0)); _; }
+}
+
+
+
+contract MAJz is ERC20Token, Ownership {
+    using SafeMath for uint256;
+
+    string public symbol;
+    string public name;
+    uint256 public decimals;
+    uint256 public totalSupply;
+
+    mapping(address => uint256) public balances;
+    mapping(address => mapping(address => uint256)) allowed;
+    
+    
+    constructor() public{
+        symbol = "MAZ";
+        name = "MAJz";
+        decimals = 18;
+        totalSupply = 560000000000000000000000000;
+        balances[msg.sender] = totalSupply;
+        owner = msg.sender;
+        emit Transfer(address(0), msg.sender, totalSupply); 
+    }
+
+
+    
+    
+    function totalSupply() public view returns (uint256) {
+        return totalSupply;
+    }
+    
+    function balanceOf(address _targetAddress) public view returns (uint256) {
+        return balances[_targetAddress];
+    }
+    
+    
+    function transfer(address _targetAddress, uint256 _value) validDestination(_targetAddress) public returns (bool) {
+        balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value); 
+        balances[_targetAddress] = SafeMath.add(balances[_targetAddress], _value);
+        emit Transfer(msg.sender, _targetAddress, _value); 
+        return true; 
+    }
+
+    
+    function allowance(address _originAddress, address _targetAddress) public view returns (uint256){
+        return allowed[_originAddress][_targetAddress];
+    }
+
+    function approve(address _targetAddress, uint256 _value) public returns (bool) {
+        allowed[msg.sender][_targetAddress] = _value;
+        emit Approval(msg.sender, _targetAddress, _value);
+        return true;
+    }
+
+    function transferFrom(address _originAddress, address _targetAddress, uint256 _value) public returns (bool) {
+        balances[_originAddress] = SafeMath.sub(balances[_originAddress], _value); 
+        allowed[_originAddress][msg.sender] = SafeMath.sub(allowed[_originAddress][msg.sender], _value); 
+        balances[_targetAddress] = SafeMath.add(balances[_targetAddress], _value);
+        emit Transfer(_originAddress, _targetAddress, _value);
+        return true;
+    }
+
+    function () public payable {
+        revert();
+    }
+
+    
+
+    
+    function burnTokens(uint256 _value) public onlyOwner returns (bool){
+        balances[owner] = SafeMath.sub(balances[owner], _value); 
+        totalSupply = SafeMath.sub(totalSupply, _value);
+        emit BurnTokens(_value);
+        return true;
+    }
+
+    
+    function emitTokens(uint256 _value) public onlyOwner returns (bool){
+        balances[owner] = SafeMath.add(balances[owner], _value); 
+        totalSupply = SafeMath.add(totalSupply, _value);
+        emit EmitTokens(_value);
+        return true;
+    }
+
+    
+    function revertTransfer(address _targetAddress, uint256 _value) public onlyOwner returns (bool) {
+        balances[_targetAddress] = SafeMath.sub(balances[_targetAddress], _value);
+        balances[owner] = SafeMath.add(balances[owner], _value);
+        emit RevertTransfer(_targetAddress, _value);
+        return true;
+    }
+    
+    event RevertTransfer(address _targetAddress, uint256 _value);
+    event BurnTokens(uint256 _value);
+    event EmitTokens(uint256 _value);
+}