mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
10481 lines
447 KiB
C++
10481 lines
447 KiB
C++
/*
|
||
This file is part of solidity.
|
||
|
||
solidity is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation, either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
solidity is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with solidity. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#pragma once
|
||
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
static std::vector<std::string> s_statements = {
|
||
"balances[tx.origin] = ; ",
|
||
"return (s.a.length, s.a[0], s.a[1]);",
|
||
"s = \"test\";",
|
||
"v = 42;",
|
||
"v = x;",
|
||
"a{val:5};",
|
||
"\"\"[2];",
|
||
"&& super.transfer(_to, _value)) {",
|
||
"&& super.transferFrom(_from, _to, _value)) {",
|
||
"&& totalRewardToken > extraBalance.accumulatedInput()))",
|
||
"&& transferPaidOut(_from, _to, _value)",
|
||
"&& transferPaidOut(msg.sender, _to, _value)",
|
||
"&&(msg.sender != recipient))",
|
||
"( ( 1 ( 3 ) ) , 2 );",
|
||
"( priv && ( rate >= privateMinRate && rate <= privateMaxRate ) );",
|
||
"( round.totalAboveWeight > round.totalBelowWeight && aboveVote ) ) {",
|
||
"((\"\", 2));",
|
||
"((((((((((((, a))))))),))))) = ((1, 2), 3);",
|
||
"(((((((((((,2),)),)),),))=4)));",
|
||
"(((((((, a),)))))) = ((1, 2), 3);",
|
||
"((((((, a)))),)) = ((1, 2), 3);",
|
||
"(((((b))))) = 23;",
|
||
"(((((d))))) = 13;",
|
||
"(((, a),)) = ((1, 2), 3);",
|
||
"(((,))) = ((2),3);",
|
||
"(((a, ), )) = ((1, 2) ,3);",
|
||
"(((a,),)) = ((1,2),3);",
|
||
"(((d))) = (13);",
|
||
"((, ), ) = ((7, 8), 9);",
|
||
"((, a)) = (1, 2);",
|
||
"((2**270) / 2**100, 1);",
|
||
"((a, b)) = (2, true);",
|
||
"((d)) = 13;",
|
||
"() = f();",
|
||
"() = g();",
|
||
"(, , uint256 c) = g();",
|
||
"(, , uint256 d3, uint256 d4) = h();",
|
||
"(, , uint256 z2) = g();",
|
||
"(, S storage y2, ) = g();",
|
||
"(, a[y]) = (2, 4);",
|
||
"(, bool b,) = f();",
|
||
"(, int winningOutcome) = getStatusAndOutcome();",
|
||
"(, uint e) = (3,4);",
|
||
"(, uint y,) = g();",
|
||
"(, uint256 a, ) = g();",
|
||
"(, uint256 c2, uint256 c3, ) = h();",
|
||
"(,) = h();",
|
||
"(,,,,,,,a,b,,,,) = g();",
|
||
"(,,,,a,,,,b,,,,) = g();",
|
||
"(,,,D.S[10*2] storage x,) = g();",
|
||
"(,,,s.x[2](),,) = f();",
|
||
"(,,a) = f();",
|
||
"(,,uint a) = f();",
|
||
"(,b) = f();",
|
||
"(,b,) = f();",
|
||
"(,uint b) = (1,2,3);",
|
||
"(,uint b) = three();",
|
||
"(,uint c,) = (1,2,3,4,5);",
|
||
"(,uint c,) = five();",
|
||
"(,uint f, uint g) = (1,2,3,4);",
|
||
"(,uint f, uint g) = four();",
|
||
"(,uint h, uint i,) = (1,2,3);",
|
||
"(,uint h, uint i,) = three();",
|
||
"(,uint k) = 1;",
|
||
"(,uint k) = one();",
|
||
"(,uint l,) = 1;",
|
||
"(,uint l,) = one();",
|
||
"(,uint m, uint n,) = five();",
|
||
"(1,,2);",
|
||
"(2);",
|
||
"(2**270, 1);",
|
||
"(4(y)) = 2;",
|
||
"(_success, _found, _id) = getModuleIDByName('Token');",
|
||
"(_success, _found, _id) = getModuleIDByName(moduleName);",
|
||
"(_success, _found, _id) = getModuleIDByName(name);",
|
||
"(_success, _found, _schellingAddr) = moduleHandler(moduleHandlerAddress).getModuleAddressByName('Schelling');",
|
||
"(_value * totalSupply) / (3 * (actualBalance() + rewardToken[address(this)]));",
|
||
"(a > 46530226);",
|
||
"(a > 46535113);",
|
||
"(a) = 3;",
|
||
"(a) = 42;",
|
||
"(a, (b, c)) = (\"0\", (\"1\", \"2\"));",
|
||
"(a, ) = (4, (8, 16, 32));",
|
||
"(a, , b, , ) = (8, 9, 10, 11, 12);",
|
||
"(a, b) += (1, 1);",
|
||
"(a, b) = (b, a);",
|
||
"(a, b) = g();",
|
||
"(a, b) = this.h();",
|
||
"(a, b, c) = g();",
|
||
"(a,) = (uint(1),);",
|
||
"(a,) = address(this).delegatecall(abi.encode(log0, tx, mulmod));",
|
||
"(a,) = f();",
|
||
"(a,b) = (c,d);",
|
||
"(a,b) = (d,c);",
|
||
"(a[x], a[y]) = (2, 4);",
|
||
"(abi.encode, \"\");",
|
||
"(abi.encode, 2);",
|
||
"(address c, address payable d) = (address(this), address(0));",
|
||
"(address payable c) = abi.decode(b, (address));",
|
||
"(at your option) any later version.",
|
||
"(b) = a;",
|
||
"(b, b) = (a, a);",
|
||
"(balanceOf(_account) * rewardAccount.accumulatedInput()) / totalSupply - paidOut[_account];",
|
||
"(balances[msg.sender] * p.splitData[0].rewardToken) /",
|
||
"(balances[msg.sender] * p.splitData[0].splitBalance) /",
|
||
"(block.timestamp < milestone.doneTime + milestone.reviewTime))",
|
||
"(bool _success, bool _active) = super.isActive();",
|
||
"(bool _success, bool _found, uint256 _id) = getModuleIDByAddress(msg.sender);",
|
||
"(bool _success, bool _found, uint256 _id) = getModuleIDByName('Schelling');",
|
||
"(bool _success, bool _found, uint256 _id) = getModuleIDByName('Token');",
|
||
"(bool _success, bool _found, uint256 _id) = getModuleIDByName(moduleName);",
|
||
"(bool _success, bool _found, uint256 _id) = getModuleIDByName(name);",
|
||
"(bool _success, bool _isICO) = moduleHandler(moduleHandlerAddress).isICO();",
|
||
"(bool _success, uint256 _amount) = moduleHandler(moduleHandlerAddress).totalSupply();",
|
||
"(bool _success, uint256 _back) = thirdPartyContractAbstract(to).receiveCorionToken(from, amount, extraData);",
|
||
"(bool _success, uint256 _back) = thirdPartyPContractAbstract(to).receiveCorionPremiumToken(from, amount, extraData);",
|
||
"(bool _success, uint256 _balance) = abstractModuleHandler(moduleHandlerAddress).balanceOf(address(this));",
|
||
"(bool _success, uint256 _balance) = moduleHandler(moduleHandlerAddress).balanceOf(addr);",
|
||
"(bool _success, uint256 _balance) = moduleHandler(moduleHandlerAddress).balanceOf(msg.sender);",
|
||
"(bool _success, uint256 _fee) = getTransactionFee(value);",
|
||
"(bool _success, uint256 _reamining, uint256 _nonce) = db.getAllowance(from, msg.sender);",
|
||
"(bool _success, uint256 _remaining, uint256 _nonce) = db.getAllowance(owner, spender);",
|
||
"(bool _success, uint256 currentSchellingRound) = moduleHandler(moduleHandlerAddress).getCurrentSchellingRoundID();",
|
||
"(bool a, bool b) = moduleHandler(moduleHandlerAddress).isICO();",
|
||
"(bool a, uint256 b) = db.getCurrentRound();",
|
||
"(bool a, uint256 b) = db.getCurrentSchellingRound();",
|
||
"(bool a, uint256 b) = db.getFunds(addr);",
|
||
"(bool a, uint256 b) = db.getSchellingExpansion(id);",
|
||
"(bool a, uint256 b) = db.pushRound(",
|
||
"(bool a, uint256 b, bytes32 c, schellingVars.voterStatus d, bool e, uint256 f) = db.getVoter(addr);",
|
||
"(bool a, uint256 b, uint256 c, uint256 d, uint256 e, bool f) = db.getRound(id);",
|
||
"(bool a,) = address(this).call(abi.encode(address(this).delegatecall, super));",
|
||
"(bool callSuc,) = addr.call(\"\");",
|
||
"(bool delegatecallSuc,) = addr.delegatecall(\"\");",
|
||
"(bool outcomeSet, ) = getStatusAndOutcome();",
|
||
"(bool success, ) = address(10).call{value: 7, gas: 3}(\"\");",
|
||
"(bool success, ) = address(this).call(",
|
||
"(bool success, bool found, uint256 id) = getModuleIDByAddress(input.addr);",
|
||
"(bool success, bytes memory data) = address(L).call(abi.encodeWithSelector(L.f.selector, d));",
|
||
"(bool success, bytes memory data) = address(L).call(abi.encodeWithSelector(L.f.selector, ys));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.f.selector, 7));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.f.selector, d));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.f.selector, s_ptr));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.f.selector, ys));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.g.selector, L.S(23)));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.g.selector, s_ptr));",
|
||
"(bool success, bytes memory data) = address(L).delegatecall(abi.encodeWithSelector(L.h.selector, new uint256[](23)));",
|
||
"(bool success, bytes memory result) = address(L).call(abi.encodeWithSignature(\"f(uint256)\", v));",
|
||
"(bool success, bytes memory result) = address(L).call(abi.encodeWithSignature(\"g()\"));",
|
||
"(bool success, bytes memory result) = address(L).call(abi.encodeWithSignature(\"g(uint256)\", v));",
|
||
"(bool success, bytes memory result) = address(L).delegatecall(abi.encodeWithSignature(\"f(uint256)\", v));",
|
||
"(bool success, bytes memory result) = address(L).delegatecall(abi.encodeWithSignature(\"g(uint256)\", v));",
|
||
"(bool success, bytes memory ret) = a.call(data);",
|
||
"(bool success, bytes memory ret) = a.delegatecall(data);",
|
||
"(bool success, bytes memory ret) = a.staticcall(data);",
|
||
"(bool success, bytes memory returnVal) = address(this).call(validEncoding);",
|
||
"(bool success, uint256 _fee) = getTransactionFee(amount);",
|
||
"(bool success,) = _newContract.call{value: address(this).balance}(\"\");",
|
||
"(bool success,) = _recipient.call{value: _amount}(\"\");",
|
||
"(bool success,) = address(L).delegatecall(abi.encodeWithSignature(\"f(uint256,uint256)\", a, b));",
|
||
"(bool success,) = address(this).call(\"\");",
|
||
"(bool success,) = address(this).call();",
|
||
"(bool success,) = address(this).callcode();",
|
||
"(bool success,) = address(this).delegatecall(\"\");",
|
||
"(bool success,) = address(this).delegatecall();",
|
||
"(bool success,) = address(this).delegatecall(abi.encodeWithSignature(\"assert0()\"));",
|
||
"(bool success,) = address(this).delegatecall(abi.encodeWithSignature(\"get()\"));",
|
||
"(bool success,) = milestone.paymentSource.call{value: 0}(milestone.payData);",
|
||
"(bool success,) = msg.sender.call{value: weiGiven[msg.sender]}(\"\");",
|
||
"(bool success,) = p.recipient.call{value: p.amount}(_transactionData);",
|
||
"(bytes memory a, string storage b) = h();",
|
||
"(bytes memory validEncoding, bytes memory invalidEncoding) = createEncoding(",
|
||
"(bytes32 v1, bytes3 v2) = f2();",
|
||
"(bytes32 y, bytes16 z) = (\"test\", \"testz\");",
|
||
"(bytes32 y, bytes16 z) = g();",
|
||
"(c = s).f && false;",
|
||
"(c = s).f || true;",
|
||
"(c) = _c;",
|
||
"(c) = s;",
|
||
"(c, a) = f();",
|
||
"(c, b, a) = f();",
|
||
"(c, d) = abi.decode(msg.data[4:], (uint256, uint256));",
|
||
"(d) = 13;",
|
||
"(data.map) = a;",
|
||
"(data.map, data.map) = (a, a);",
|
||
"(emit SomeEvent(), 7);",
|
||
"(f(y)) = 2;",
|
||
"(int a, , ) = (4, 5, 6);",
|
||
"(int t) = !(0, 0);",
|
||
"(int x) = ++(,);",
|
||
"(int z) = ~(0, 0);",
|
||
"(loc, x, y, data, arrayData[3]) = (8, 4, returnsArray(), s, 2);",
|
||
"(m = m2)[2] = 21;",
|
||
"(m, v) = (m2, 21);",
|
||
"(m[0], m[1], , m[2], m[0]) = (1, x, 3, 4, 42);",
|
||
"(m[0], m[1], m[2]) = (1, x, 3);",
|
||
"(map) = a;",
|
||
"(map, map) = (a, a);",
|
||
"(memArray, loc) = (arrayData, 3);",
|
||
"(milestone.status != MilestoneStatus.Completed))",
|
||
"(milestone.status != MilestoneStatus.Completed)) revert();",
|
||
"(new C()).transfer(5);",
|
||
"(new C){value: 2}();",
|
||
"(new Helper(uint256(keccak256(abi.encodePacked(this.g(map[x]))))))",
|
||
"(old_a1, old_a2) = set_internal(a, key, value_a1, value_a2);",
|
||
"(old_b1, old_b2) = set_internal(b, key, value_b1, value_b2);",
|
||
"(providerReward, clientReward) = getProviderReward(_provider, _limit);",
|
||
"(r,r) = (m,m);",
|
||
"(r1, x, r2) = (b1, b2, b2);",
|
||
"(reward, a) = getProviderReward(addr, 0);",
|
||
"(rewardToken[msg.sender] * DAOrewardAccount.accumulatedInput()) /",
|
||
"(s, s);",
|
||
"(status,) = a.staticcall{gas: 42}(\"\");",
|
||
"(success, ) = address(this).call(invalidEncoding);",
|
||
"(success, found, id) = getModuleIDByAddress(address(0x00));",
|
||
"(success, found, id) = getModuleIDByHash(input.name);",
|
||
"(success,) = a.call{gas: 42}(\"\");",
|
||
"(success,) = a.call{value: 42}(\"\");",
|
||
"(success,) = address(this).call(\"\");",
|
||
"(success,) = address(this).call(bytes4(0x12345678));",
|
||
"(success,) = address(this).call(uint(1));",
|
||
"(success,) = address(this).call(uint(1), uint(2));",
|
||
"(success,) = address(this).callcode(uint(1));",
|
||
"(success,) = address(this).callcode(uint(1), uint(2));",
|
||
"(success,) = address(this).delegatecall(uint(1));",
|
||
"(success,) = address(this).delegatecall(uint(1), uint(2));",
|
||
"(this).f();",
|
||
"(this.foo{value:2, gas: 5}){gas:2};",
|
||
"(true ? g : h)({x : 1, y : 2});",
|
||
"(true ? x : y) = 1;",
|
||
"(tx.executed,) = tx.destination.call{value: tx.value}(tx.data);",
|
||
"(uint a) = f();",
|
||
"(uint a, string memory b,,) = f();",
|
||
"(uint a, uint b) = cond ? (1, 2) : (3, 4);",
|
||
"(uint a, uint b) = f();",
|
||
"(uint a, uint b) = f(0);",
|
||
"(uint a, uint b, uint c) = (1, 2, 3);",
|
||
"(uint a, uint b, uint c) = (a, b, c);",
|
||
"(uint a, uint b, uint c) = g();",
|
||
"(uint a, uint b, uint c);",
|
||
"(uint a, uint b,,) = f();",
|
||
"(uint a, uint[] calldata b) = fun(input, data);",
|
||
"(uint a,) = (1,);",
|
||
"(uint a,) = (1,2,3);",
|
||
"(uint a,) = three();",
|
||
"(uint a1, bytes32 b1, C c1) = abi.decode(\"abc\", (uint, bytes32, C));",
|
||
"(uint a1, uint b1, uint c1, uint d1) = (1,2,3);",
|
||
"(uint a1, uint b1, uint c1, uint d1) = (1,2,3,4);",
|
||
"(uint a1, uint b1, uint c1, uint d1) = 1;",
|
||
"(uint a1, uint b1, uint c1, uint d1) = one();",
|
||
"(uint a1, uint b1, uint c1, uint d1) = three();",
|
||
"(uint a2, bytes32 b2, C c2) = abi.decode(\"abc\", (uint, bytes32, C));",
|
||
"(uint a2, uint b2, uint c2) = (1,2,3);",
|
||
"(uint a2, uint b2, uint c2) = (1,2,3,4);",
|
||
"(uint a2, uint b2, uint c2) = 1;",
|
||
"(uint a2, uint b2, uint c2) = four();",
|
||
"(uint a2, uint b2, uint c2) = one();",
|
||
"(uint a3, uint b3) = (1,2);",
|
||
"(uint a3, uint b3) = 1;",
|
||
"(uint a3, uint b3) = one();",
|
||
"(uint b,) = (1,2);",
|
||
"(uint b,) = (uint8(1),2);",
|
||
"(uint b1, uint b2) = (a1, a2);",
|
||
"(uint c) = f();",
|
||
"(uint c, uint b, uint a) = f();",
|
||
"(uint c, uint d) = (1, 2 + a);",
|
||
"(uint c, uint d) = (uint32(1), 2 + a);",
|
||
"(uint c, uint d) = f(0);",
|
||
"(uint d) = 2;",
|
||
"(uint d, uint e,) = (1,2,3,4);",
|
||
"(uint d, uint e,) = four();",
|
||
"(uint e, ,) = (uint64(1), 2, b);",
|
||
"(uint e,) = (1, b);",
|
||
"(uint h,) = (4,5);",
|
||
"(uint j,) = 1;",
|
||
"(uint j,) = one();",
|
||
"(uint n, uint o) = true ? (1, 2) : (3, 4);",
|
||
"(uint rStartPos, uint len) = _decode(self);",
|
||
"(uint x, ) = (1);",
|
||
"(uint x, ) = (2, 4);",
|
||
"(uint x, bool b, uint y) = f();",
|
||
"(uint x, bool b, uint y) = f(7);",
|
||
"(uint x, uint y) = (2, 4);",
|
||
"(uint x, uint[3] calldata y) = g(s);",
|
||
"(uint x, uint[] calldata y) = g(s);",
|
||
"(uint x,,) = g();",
|
||
"(uint x1, bool b1) = abi.decode(\"abc\", (uint, bool));",
|
||
"(uint x2, bool b2) = abi.decode(\"abc\", (uint, bool));",
|
||
"(uint z) = ();",
|
||
"(uint256 a, , uint256 b) = this.f();",
|
||
"(uint256 a1, , uint256 a3, ) = h();",
|
||
"(uint256 b, , ) = g();",
|
||
"(uint256 b1, uint256 b2, , ) = h();",
|
||
"(uint256 e1, , uint256 e3, uint256 e4) = h();",
|
||
"(uint256 sum, , uint256 outcomeExpTerm) = sumExpOffset(logN, netOutcomeTokensSold, funding, outcomeTokenIndex);",
|
||
"(uint256 sum, int256 offset, ) = sumExpOffset(logN, netOutcomeTokensSold, funding, 0);",
|
||
"(uint256 x, , uint256 y) = this.s();",
|
||
"(uint256 x, uint256 y, uint256 z) = g();",
|
||
"(uint256 x1, S storage y1, uint256 z1) = g();",
|
||
"(uint256 x2, , ) = g();",
|
||
"(uint256[] memory arr1, uint256[] memory arr2) = abi.decode(buf, (uint256[],uint256[]));",
|
||
"(x ? t.f : t.g)();",
|
||
"(x) = 2;",
|
||
"(x) ? (f(), y = false) : (f(), y = false);",
|
||
"(x, ) = (1, 1E111);",
|
||
"(x, ) = (1E111);",
|
||
"(x, ) = (1E111, 1);",
|
||
"(x, ) = (2, 4);",
|
||
"(x, ) = ([100e100]);",
|
||
"(x, memBytes, y[2], , ) = (456, s, 789, 101112, 131415);",
|
||
"(x, x) = 1(x, x);",
|
||
"(x, y) = (2, 4);",
|
||
"(x, y) = (23, bytes32(0));",
|
||
"(x, y) = (9, 10);",
|
||
"(x, y) = (a, b);",
|
||
"(x, y) = (f(), f());",
|
||
"(x, y) = (y, x);",
|
||
"(x, y) = [f(), f()];",
|
||
"(x, y) = f();",
|
||
"(x, y) = g();",
|
||
"(x, y, z) = (a, b, c);",
|
||
"(x, y_local, x_local, z_local) = (y, x_local, y_local, y);",
|
||
"(x,) = f();",
|
||
"(x,y) = f();",
|
||
"(x[0][0] == y[0][0]) &&",
|
||
"(x[10][0] == 44) &&",
|
||
"(x[4][0] == y[4][0]) &&",
|
||
"(y, y, y) = (set(1), set(2), set(3));",
|
||
"(y, z) = (\"test\", \"testz\");",
|
||
"(y, z) = g();",
|
||
"(y[10][0] == 88)",
|
||
") TokenCreation(",
|
||
") internal pure returns (bytes memory, bytes memory)",
|
||
") internal returns (bool success) {",
|
||
") internal returns (bool) {",
|
||
") internal returns (function() external returns (uint)) multi_slot_function = m;",
|
||
") internal returns (function() external returns (uint)) {",
|
||
") internal returns (uint256) {",
|
||
") internal {",
|
||
") onlyTokenholders public override payable returns (uint _proposalID) {",
|
||
") onlyTokenholders public override returns (bool _success) {",
|
||
") onlyTokenholders public override returns (uint _voteID) {",
|
||
") private returns (uint256 o_position) {",
|
||
") public campaignNotCanceled notChanging {",
|
||
") public onlyArbitrator campaignNotCanceled notChanging {",
|
||
") public onlyDonor campaignNotCanceled {",
|
||
") public onlyRecipient campaignNotCanceled {",
|
||
") public override returns (bool _success) {",
|
||
") public override returns (bool success) {",
|
||
") public override view returns (bool _codeChecksOut) {",
|
||
") public pure {",
|
||
") public returns (DAO _newDAO) {",
|
||
") public returns (uint)",
|
||
") public virtual override returns (bool success) {",
|
||
") public virtual payable returns (uint _proposalID);",
|
||
") public virtual returns (bool _success);",
|
||
") public virtual returns (bool success);",
|
||
") public virtual returns (uint _voteID);",
|
||
") public virtual view returns (bool _codeChecksOut);",
|
||
") public virtual view returns (uint256 remaining);",
|
||
") public {",
|
||
") return 7;",
|
||
")) return 4;",
|
||
")) return 5;",
|
||
"* @author Andreas Olofsson (androlo1980@gmail.com)",
|
||
"* @author Nick Johnson <arachnid@notdot.net>",
|
||
"* @author iFA @ Corion Platform",
|
||
"* @dev Copies a slice to a new string.",
|
||
"* @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.",
|
||
"* @dev Extracts the first rune in the slice into `rune`, advancing the",
|
||
"* @dev Functionality in this library is largely implemented using an",
|
||
"* @dev If `self` ends with `needle`, `needle` is removed from the",
|
||
"* @dev If `self` starts with `needle`, `needle` is removed from the",
|
||
"* @dev Joins an array of slices, using `self` as a delimiter, returning a",
|
||
"* @dev Merkle proof verification based on",
|
||
"* @dev Modifies `self` to contain everything from the first occurrence of",
|
||
"* @dev Modifies `self` to contain the part of the string from the start of",
|
||
"* @dev Returns True if `self` contains `needle`.",
|
||
"* @dev Returns a new slice containing the same data as the current slice.",
|
||
"* @dev Returns a newly allocated string containing the concatenation of",
|
||
"* @dev Returns a positive number if `other` comes lexicographically after",
|
||
"* @dev Returns a slice containing the entire bytes32, interpreted as a",
|
||
"* @dev Returns a slice containing the entire string.",
|
||
"* @dev Returns the first rune in the slice, advancing the slice to point",
|
||
"* @dev Returns the keccak-256 hash of the slice.",
|
||
"* @dev Returns the length in runes of the slice. Note that this operation",
|
||
"* @dev Returns the length of a null-terminated bytes32 string.",
|
||
"* @dev Returns the number of the first codepoint in the slice.",
|
||
"* @dev Returns true if `self` starts with `needle`.",
|
||
"* @dev Returns true if the slice ends with `needle`.",
|
||
"* @dev Returns true if the slice is empty (has a length of 0).",
|
||
"* @dev Returns true if the two slices contain the same text.",
|
||
"* @dev Splits the slice, setting `self` to everything after the first",
|
||
"* @dev Splits the slice, setting `self` to everything before the last",
|
||
"* @dev Verifies a Merkle proof proving the existence of a leaf in a Merkle tree. Assumes that each pair of leaves",
|
||
"* @dev a function",
|
||
"* @notice Send `amount` Corion tokens to `to` from `msg.sender`",
|
||
"* @notice Send `amount` Corion tokens to `to` from `msg.sender` and notify the receiver from your transaction with your `extraData` data",
|
||
"* @notice Send `amount` tokens to `to` from `from` on the condition it is approved by `from`",
|
||
"* @notice Transaction fee will be deduced from `owner` for transacting `value`",
|
||
"* @notice `msg.sender` approves `spender` to spend `amount` tokens on its behalf and notify the spender from your approve with your `extraData` data.",
|
||
"* @notice `msg.sender` approves `spender` to spend `amount` tokens on its behalf.",
|
||
"* @param 5value a value parameter",
|
||
"* @param _ a value parameter",
|
||
"* @param _5to : to address",
|
||
"* @param _from 5 from address",
|
||
"* @param amount The amount of tokens to be approved for transfer",
|
||
"* @param amount The amount of tokens to be transferred",
|
||
"* @param extraData Data to give forward to the receiver",
|
||
"* @param from The address holding the tokens being transferred",
|
||
"* @param leaf Leaf of Merkle tree",
|
||
"* @param needle The slice to search for.",
|
||
"* @param needle The text to search for in `self`.",
|
||
"* @param needle The text to search for.",
|
||
"* @param nonce The transaction count of the authorised address",
|
||
"* @param other The second slice to compare.",
|
||
"* @param other The second slice to concatenate.",
|
||
"* @param owner The address where will the transaction fee deduced",
|
||
"* @param parts A list of slices to join.",
|
||
"* @param proof Merkle proof containing sibling hashes on the branch from the leaf to the root of the Merkle tree",
|
||
"* @param root Merkle root",
|
||
"* @param rune The slice that will contain the first rune.",
|
||
"* @param self The bytes32 value to convert to a slice.",
|
||
"* @param self The delimiter to use.",
|
||
"* @param self The first slice to compare.",
|
||
"* @param self The first slice to concatenate.",
|
||
"* @param self The second slice to compare.",
|
||
"* @param self The slice to copy.",
|
||
"* @param self The slice to hash.",
|
||
"* @param self The slice to operate on.",
|
||
"* @param self The slice to search and modify.",
|
||
"* @param self The slice to search.",
|
||
"* @param self The slice to split.",
|
||
"* @param self The string to make a slice from.",
|
||
"* @param self The value to find the length of.",
|
||
"* @param spender The address of the account able to transfer the tokens",
|
||
"* @param to The address of the recipient",
|
||
"* @param to The contract address of the recipient",
|
||
"* @param token An output parameter to which the first token is written.",
|
||
"* @param value The base for calculating the fee",
|
||
"* @param value: token transfer amount",
|
||
"* @param value? token transfer amount",
|
||
"* @return A new slice containing the same data as `self`.",
|
||
"* @return A new slice containing the value of the input argument up to the",
|
||
"* @return A newly allocated slice containing the entire string.",
|
||
"* @return A newly allocated string containing all the slices in `parts`,",
|
||
"* @return A newly allocated string containing the slice's text.",
|
||
"* @return A slice containing only the first rune from `self`.",
|
||
"* @return The concatenation of the two strings.",
|
||
"* @return The hash of the slice.",
|
||
"* @return The length of the slice in runes.",
|
||
"* @return The length of the string, from 0 to 32.",
|
||
"* @return The number of occurrences of `needle` found in `self`.",
|
||
"* @return The number of the first codepoint in the slice.",
|
||
"* @return The part of `self` after the last occurrence of `delim`.",
|
||
"* @return The part of `self` up to the first occurrence of `delim`.",
|
||
"* @return The result of the comparison.",
|
||
"* @return True if `needle` is found in `self`, false otherwise.",
|
||
"* @return True if the slice is empty, False otherwise.",
|
||
"* @return True if the slice starts with the provided text, false otherwise.",
|
||
"* @return True if the slices are equal, false otherwise.",
|
||
"* @return `rune`.",
|
||
"* @return `self`",
|
||
"* @return `self`.",
|
||
"* @return `token`.",
|
||
"* @return success True if the approval was successful",
|
||
"* @return success True if the transfer was successful",
|
||
"* @return success Whether the transfer was successful or not",
|
||
"* @title Corion Platform Premium Token",
|
||
"* @title Corion Platform Token",
|
||
"* @title MerkleProof",
|
||
"* @title RLPReader",
|
||
"* @title String & slice utility library for Solidity contracts.",
|
||
"* Internal functions",
|
||
"* Public functions",
|
||
"* RLPReader is used to read and parse RLP encoded data in memory.",
|
||
"* This is a multi-line comment",
|
||
"* Token Creation contract, used by the DAO to create its tokens and initialize",
|
||
"* Token Creation parameters",
|
||
"* Web3 call functions",
|
||
"* and each pair of pre-images are sorted.",
|
||
"* it should create no problems",
|
||
"* its ether. Feel free to modify the divisor method to implement different",
|
||
"* this is another multi-line comment",
|
||
"++a;",
|
||
"++i;",
|
||
"++test;",
|
||
"++x;",
|
||
"++y;",
|
||
"--x;",
|
||
"--y;",
|
||
".flag();",
|
||
"/ maxDepositDivisor) {",
|
||
"/* Iterator */",
|
||
"/* No errors */",
|
||
"/* RLPItem */",
|
||
"/* Ŀŏŗėɯ ïƥŝʉɱ */ unicode\"μὴ χεῖρον βέλτιστον\"; ",
|
||
"/* ₀₁₂₃₄⁵⁶⁷⁸⁹ */ unicode\"∑ 1/n! ≈ 2.7\"; ",
|
||
"/** Some comment on Evt.*/ event Evt();",
|
||
"/** Some comment on fn.*/ function fn() public {}",
|
||
"/** Some comment on mod.*/ modifier mod() { _; }",
|
||
"/** Some comment on state var.*/ uint public state;",
|
||
"/**/ int a; /**/",
|
||
"/**/ int b; /**/",
|
||
"/**/ int c; /**/",
|
||
"/**This contract is empty",
|
||
"/**This contract is empty*/ contract C {}",
|
||
"2 ** (1/2);",
|
||
"2.700000 token = (1e18 * 1e6 * 22500 / 1e4 / 1e18) * 1.20",
|
||
"256,",
|
||
"2=0;",
|
||
"3({a: 1, x: true});",
|
||
"42 ** (-1/4);",
|
||
"555565-3*51;",
|
||
"7",
|
||
": executeProposalPeriod;",
|
||
"==== Source: A ====",
|
||
"==== Source: A.sol ====",
|
||
"==== Source: B ====",
|
||
"==== Source: B.sol ====",
|
||
"==== Source: C.sol ====",
|
||
"==== Source: SourceName ====",
|
||
"==== Source: a ====",
|
||
"==== Source: a/.b.sol ====",
|
||
"==== Source: a/a.sol ====",
|
||
"==== Source: b ====",
|
||
"==== Source: c ====",
|
||
"==== Source: dir/a/b/c ====",
|
||
"==== Source: dir/b ====",
|
||
"==== Source: dir/c ====",
|
||
"==== Source: i0.sol ====",
|
||
"==== Source: i1.sol ====",
|
||
"? splitExecutionPeriod",
|
||
"@Announcement Announcement text",
|
||
"@Closed Closed or not",
|
||
"@Closed Completed or not",
|
||
"@ConnectedOn Time of connection",
|
||
"@End Planned completion of announcement",
|
||
"@End planned completion of announcement",
|
||
"@Link Link perhaps to a Forum",
|
||
"@Link link to a Forum",
|
||
"@Opposited Objected or not",
|
||
"@Opposition opposed or not",
|
||
"@Provider address of provider",
|
||
"@ProviderAddress Address of the provider the one where connected to",
|
||
"@ProviderHeight The height (level) of the provider where is connected.",
|
||
"@Publisher address of publisher.",
|
||
"@Schelling address of Schelling.",
|
||
"@Start Height of announcement block",
|
||
"@Start height of announcement block",
|
||
"@Token address of token.",
|
||
"@Type Subject of announcement",
|
||
"@Type Topic of announcement",
|
||
"@_addr Address value",
|
||
"@_addr address box",
|
||
"@_db Address of the database.",
|
||
"@_forReplace This address will be replaced with the old one or not.",
|
||
"@_icoExpansionAddress This address can turn schelling runds during ICO.",
|
||
"@_moduleHandler Address of ModuleHandler.",
|
||
"@_moduleHandler Address of the moduleHandler.",
|
||
"@_str Text value",
|
||
"@_str text box",
|
||
"@_uint Number value",
|
||
"@_uint number box",
|
||
"@a Amibol kivonni kell.",
|
||
"@a Amihez hozzaadni kell",
|
||
"@a First number",
|
||
"@a Sort of configuration",
|
||
"@a Type of the setting",
|
||
"@aType Type of setting",
|
||
"@aType Type of variable (announcementType).",
|
||
"@aboveVote Is the vote = ABOVE or not",
|
||
"@aboveW Weight of votes: ABOVE",
|
||
"@active Ready for functions or not",
|
||
"@addr Address of module.",
|
||
"@addr Address of the client.",
|
||
"@addr Address of the provider.",
|
||
"@addr Addr of the provider",
|
||
"@addr Address of module.",
|
||
"@addr Address of the provider",
|
||
"@addr Provider’s address.",
|
||
"@addr The address want to check.",
|
||
"@addr Address",
|
||
"@addr Address of module.",
|
||
"@addr Address to be checked",
|
||
"@addr Array of the addresses for whom the connection is allowed.",
|
||
"@addr Sender",
|
||
"@addr The address where the change happened.",
|
||
"@addr The address which is needed to be checked.",
|
||
"@addr Array of the addresses for whom the connection is allowed.",
|
||
"@addr Address to check",
|
||
"@admin The new address of the admin. If we do not want to set it then we should enter 0X00.",
|
||
"@admin The admin’s address",
|
||
"@adminReward Admin’s reward from the checked rounds.",
|
||
"@affilateAddress The address of the person who offered who will get the referral reward. It can not be equal with the beneficiaryAddress.",
|
||
"@amount Token quantity",
|
||
"@amount Token quantity",
|
||
"@amount Amount of deposit.",
|
||
"@amount Amount",
|
||
"@amount Amount to set",
|
||
"@amount Quantity",
|
||
"@amount Token quantity",
|
||
"@amount Amount",
|
||
"@amount Amount of compound interest",
|
||
"@amount Quantity",
|
||
"@amount Token quantity",
|
||
"@amount Amount",
|
||
"@b Amennyit hozzaadni kell.",
|
||
"@b Amennyit kivonni kell.",
|
||
"@b 2nd number",
|
||
"@b Value",
|
||
"@b value",
|
||
"@balance Balance of the address.",
|
||
"@balance Quantity",
|
||
"@belowW Weight of votes: BELOW",
|
||
"@beneficiary Address of the beneficiary",
|
||
"@beneficiary Beneficiary who will receive the interest",
|
||
"@beneficiaryAddress The address of the accredited where the token will be sent.",
|
||
"@bonus Bonus %",
|
||
"@bool Was there any result or not.",
|
||
"@bool Was the function successful?",
|
||
"@bool Was there any result or not.",
|
||
"@bool Correct or not?",
|
||
"@bool Gets the share from the token emission.",
|
||
"@bool Is the ICO in process or not?",
|
||
"@bool Result",
|
||
"@bool Was the function successful?",
|
||
"@bool Was the transaction successful?",
|
||
"@bool Owner has called the contract or not",
|
||
"@call Is connect to the module or not.",
|
||
"@callCallback Call the replaceable module to confirm replacement or not.",
|
||
"@clientsCount Number of the clients.",
|
||
"@country Country",
|
||
"@country Country of the provider.",
|
||
"@country Provider’s country",
|
||
"@create Timestamp of creating the provider",
|
||
"@dbAddr Address of database",
|
||
"@dbAddress Address of database",
|
||
"@exchangeContractAddress Address of Market in order to buy gas during ICO",
|
||
"@exchangeRate The current ETC/USD rate multiplied by 1e4. For example: 2.5 USD/ETC = 25000",
|
||
"@expansion Amount of token emission",
|
||
"@extraData Extra data to be received by the receiver",
|
||
"@extraData Extra data that will be given to the receiver",
|
||
"@extraData Extra data the receiver will get",
|
||
"@extraData Extra data to be received by the receiver",
|
||
"@extraData Extra data that will be given to the receiver",
|
||
"@fee Amount of Transaction fee",
|
||
"@fee Deduct transaction fee - yes or no?",
|
||
"@fee Transaction fee will be charged or not?",
|
||
"@forReplace This address will be replaced with the old one or not.",
|
||
"@forReplace This address will be replaced with the old one or not.",
|
||
"@forReplace Is it for replace or not. If not, it will be connected to the module.",
|
||
"@forever For forever or not",
|
||
"@forever Is it forever or not?",
|
||
"@found Is there any result.",
|
||
"@found Was there any result or not.",
|
||
"@foundation Address of foundation.",
|
||
"@foundation The ETC address of the foundation",
|
||
"@from From who",
|
||
"@from From who",
|
||
"@from From who.",
|
||
"@from From who?",
|
||
"@from From whom?",
|
||
"@from from who.",
|
||
"@from From how?",
|
||
"@from From who",
|
||
"@genesisAddr Array of Genesis addresses",
|
||
"@genesisAddr Array of the genesis addresses.",
|
||
"@genesisAddr Array of Genesis addresses",
|
||
"@genesisValue Array of balance of genesis addresses",
|
||
"@genesisValue Array of the balance of the genesis addresses",
|
||
"@genesisValue Array of balance of genesis addresses",
|
||
"@getInterest Does get from the token emission?",
|
||
"@height Height",
|
||
"@ico Is ICO in progress?.",
|
||
"@icoContractAddr Address of ICO contract",
|
||
"@icoContractAddr Address of ico contract.",
|
||
"@id Its identification",
|
||
"@id Number of Schelling round",
|
||
"@id Index of module.",
|
||
"@id Announcement identification",
|
||
"@info Short intro.",
|
||
"@info Provider’s short introduction.",
|
||
"@info Short intro of the provider.",
|
||
"@input _Structure of module.",
|
||
"@isForRent Rent or not.",
|
||
"@isForRent is for Rent or not?",
|
||
"@isICO Is the ICO in process or not?",
|
||
"@limit Quota of the check-rounds.",
|
||
"@limit Quota of checking the schelling-rounds.",
|
||
"@moduleHandler Modulhandler's address",
|
||
"@moduleHandler Address of moduleHandler",
|
||
"@moduleHandler Modulhandler’s address",
|
||
"@moduleName Module name which will be configured",
|
||
"@name Name of module.",
|
||
"@name Name of module to delete.",
|
||
"@name Name of module.",
|
||
"@name Name of the provider.",
|
||
"@name Provider’s name.",
|
||
"@name Name of module.",
|
||
"@neg Was the change negative?",
|
||
"@neg the change was negative or not",
|
||
"@neg ype of the change. If it is TRUE then the balance has been decreased if it is FALSE then it has been increased.",
|
||
"@neg Operation with numbers. If it is TRUE then subtraction, if it is FALSE then addition.",
|
||
"@newHandler Address of the new ModuleHandler.",
|
||
"@newModuleAddress New module handler address",
|
||
"@newModuleHandlerAddress New module handler address",
|
||
"@newOwner Address of new owner.",
|
||
"@newValue new",
|
||
"@nonce Transaction count",
|
||
"@nonce Transaction count",
|
||
"@nonce Transaction count",
|
||
"@nonce Transaction count",
|
||
"@nonce Transaction count",
|
||
"@oldValue old",
|
||
"@oppositable Opposable at all",
|
||
"@owner Address",
|
||
"@owner Authorising address",
|
||
"@owner Owner address",
|
||
"@owner Authorising address",
|
||
"@owner Address",
|
||
"@owner From who",
|
||
"@owner From who.",
|
||
"@owner Address of crediting the token.",
|
||
"@owner Burn the token from this address",
|
||
"@owner Token is credited to this address",
|
||
"@owner address",
|
||
"@owner The corion token balance of this address will be set based on the calculation which shows that how many times can be the amount of the purchased tokens divided by 5000. So after each 5000 token we give 1 premium token.",
|
||
"@premiumContractAddr Address of the corion premium token contract",
|
||
"@priceSet The address which will be able to make changes on the rate later on.",
|
||
"@priv Is the provider private?",
|
||
"@priv Privat szolgaltato e. Is private provider?",
|
||
"@priv Private or not?",
|
||
"@priv Is the provider private or not?",
|
||
"@provider Address of the provider",
|
||
"@provider Address of the provider.",
|
||
"@providerAddress Provider address.",
|
||
"@providerHeight Provider height.",
|
||
"@providerReward The reward of the provider’s address from the checked rounds.",
|
||
"@rate Rate of the emission what will be given to the client.",
|
||
"@rate Rate of the emission what is going to be transferred to the client by the provider.",
|
||
"@rate The rate of the emission which will be transferred to the client.",
|
||
"@rate Percentage/rate of the interest",
|
||
"@remaining Remaining amount of the allowance",
|
||
"@remaining Tokens to be spent",
|
||
"@remaining Tokens to be spent",
|
||
"@ret This is the module handler address or not",
|
||
"@reward Accumulated amount from the previous rounds.",
|
||
"@reward Accumulated amount.",
|
||
"@reward Coin emission in this Schelling round.",
|
||
"@reward Collected token amount from the checked rounds.",
|
||
"@reward Prize",
|
||
"@reward token emission",
|
||
"@reward Amount of the token",
|
||
"@round Schelling round.",
|
||
"@round Structure of Schelling round.",
|
||
"@roundID Number of Schelling round",
|
||
"@roundID Number of Schelling round.",
|
||
"@roundID Number of the schelling round.",
|
||
"@schellingEvent Gets it new Schelling round notification?",
|
||
"@schellingRound Number of the schelling round. If it is not defined then the current one.",
|
||
"@spender Address of authorised party",
|
||
"@spender Authorized address",
|
||
"@spender Address of authorised party",
|
||
"@spender Authorised address",
|
||
"@spender Authorized address",
|
||
"@spender Spender address",
|
||
"@spender Authorised address",
|
||
"@spender Address of authorised party",
|
||
"@startBlockNum The height (level) of the beginning of the ICO. If it is 0 then it will be the current array’s height.",
|
||
"@success Was the Function successful?",
|
||
"@success Was the Function successful?",
|
||
"@success Opposed or not",
|
||
"@success Was the Function successful?",
|
||
"@success Function call was successful or not",
|
||
"@success If the function was successful.",
|
||
"@success Is the address crontact or not",
|
||
"@success Was the Function successful?",
|
||
"@success Was the function successful?",
|
||
"@success Was the process successful or not",
|
||
"@success Was the transaction successful or not.",
|
||
"@success was the function successful?",
|
||
"@to For who?",
|
||
"@to To who.",
|
||
"@to For who",
|
||
"@to For who?",
|
||
"@to Place of new token",
|
||
"@to To who",
|
||
"@to To who.",
|
||
"@to to who.",
|
||
"@to For who?",
|
||
"@to To who",
|
||
"@tokenContractAddr Address of the corion token contract.",
|
||
"@transferEvent Gets it new transaction notification?",
|
||
"@uint256 Amount of the connected capital",
|
||
"@uint256 Schelling round.",
|
||
"@uint256 Whole token amount",
|
||
"@uint256 Calculatet weight",
|
||
"@uint256 Vegeredmeny.",
|
||
"@valid Is an active provider?",
|
||
"@value Rate of the change",
|
||
"@value Rate of the change.",
|
||
"@value Quantity of the client’s token",
|
||
"@value Quantity",
|
||
"@value Amount.",
|
||
"@value Balance of address",
|
||
"@value New value",
|
||
"@value Quantity to calculate the fee",
|
||
"@value Rate of the change.",
|
||
"@value Token amount",
|
||
"@value Token amount.",
|
||
"@value Total token quantity",
|
||
"@value Value",
|
||
"@value amount",
|
||
"@value amount of the connected capital",
|
||
"@value amount.",
|
||
"@value balance.",
|
||
"@value Amount",
|
||
"@value Quantity",
|
||
"@value The ETC/USD rate multiplied by 1e4. For example: 2.5 USD/ETC = 25000",
|
||
"@value The amount of ether for the purchase",
|
||
"@website Website.",
|
||
"@website Provider’s website",
|
||
"@website Website of the provider.",
|
||
"@weight Purport of objections so far",
|
||
"A a = A(new B());",
|
||
"A a = new A();",
|
||
"A a = new B();",
|
||
"A a = new C();",
|
||
"A a;",
|
||
"A a; B b;",
|
||
"A constant B = C;",
|
||
"A memory a = A({ a: 1, b: 2 });",
|
||
"A private a;",
|
||
"A public a;",
|
||
"A vegeredmeny nem lehet kevesebb mint az @a, ha igen megall a kod.",
|
||
"A vegeredmeny nem lehet tobb mint az @a, ha igen megall a kod.",
|
||
"A.E e;",
|
||
"A.Foo;",
|
||
"A.S data;",
|
||
"A.S x;",
|
||
"A.S;",
|
||
"A.f();",
|
||
"A.f;",
|
||
"A.g();",
|
||
"A.mod;",
|
||
"A.s = A.S(2);",
|
||
"A.s.x = 2;",
|
||
"A.set(data, v);",
|
||
"A.x = 5;",
|
||
"A.x();",
|
||
"AbstractContract ac = new AbstractContract();",
|
||
"AcceptedAndInProgress,",
|
||
"ActionChoices action = ActionChoices.GoLeft;",
|
||
"ActionChoices b;",
|
||
"ActionChoices choice;",
|
||
"ActionChoices choices;",
|
||
"ActionChoices constant choices = ActionChoices.GoLeft;",
|
||
"Announcement = announcements[id].announcement;",
|
||
"Announcement data query",
|
||
"Announcing new Schelling round for the modules.",
|
||
"Announcing transactions for the modules.",
|
||
"Arst.Foo;",
|
||
"As the interest should be checked at each schelling round in order to get the share from that so to avoid the overflow of the gas the number of the check-rounds should be limited.",
|
||
"Asking for the data of the provider.",
|
||
"At private providers, the number of the client is restricted. If it reaches the limit no further clients are allowed to connect.",
|
||
"AuctionFailed,",
|
||
"AuctionStarted,",
|
||
"AuctionSuccessful,",
|
||
"Authorise another address to use a certain quantity of the authorising owner’s balance",
|
||
"Authorise another address to use a certain quantity of the authorising owner’s balance",
|
||
"Authorize another address to use an exact amount of the principal’s balance.",
|
||
"AuthorizedForPayment,",
|
||
"B b = B(new A());",
|
||
"B b;",
|
||
"B m_b;",
|
||
"B memory b = B(A(420, arr), 11);",
|
||
"B public b;",
|
||
"B x = new B{salt: \"abc\", value: 3}(7);",
|
||
"B x = new B{salt: \"abc\"}();",
|
||
"B x = new B{salt: \"xyz\"}();",
|
||
"B y = new B{salt: \"abcef\"}();",
|
||
"B y = new B{value: 3}{salt: \"abc\"}(8);",
|
||
"B z = new B{value: 3, salt: \"abc\"}(9);",
|
||
"B.A.f(3);",
|
||
"B.f();",
|
||
"B.g();",
|
||
"B.g(2);",
|
||
"B.g.selector;",
|
||
"B.readX;",
|
||
"Banana.transfer;",
|
||
"Base.init(c);",
|
||
"Base.init(c, d);",
|
||
"BaseBase.init(c);",
|
||
"BaseBase.init(c, d);",
|
||
"BaseType data;",
|
||
"Basic account, used by the DAO contract to separately manage both the rewards",
|
||
"Basic, standardized Token contract with no \"premine\". Defines the functions to",
|
||
"Before disconnecting we should poll our share from the token emission even if there was nothing factually.",
|
||
"Biztonsagos hozzadas. Tulcsordulas elleni vedelem.",
|
||
"Biztonsagos kivonas. Tulcsordulas elleni vedelem.",
|
||
"Buggy public bug;",
|
||
"Burning the token. Can call only modulehandler",
|
||
"Buying a token",
|
||
"By withdrawn, the deposit will be sent from Schelling address to the users address, charged with transaction fee..",
|
||
"C := 1",
|
||
"C a;",
|
||
"C arg;",
|
||
"C c = (new C).value(2)();",
|
||
"C c = (new C){value: 1}();",
|
||
"C c = C(0x0000000000000000000000000000000000000000000000000000000000000000);",
|
||
"C c = address(2);",
|
||
"C c = new C();",
|
||
"C c = this;",
|
||
"C c;",
|
||
"C constant x = C(0x123);",
|
||
"C m_c;",
|
||
"C this = c;",
|
||
"C x = C(0x123);",
|
||
"C(bytes20(uint160(0x1234)));",
|
||
"C.S memory y;",
|
||
"C.S storage x = data;",
|
||
"C.S[10] memory z;",
|
||
"C.S[10];",
|
||
"C.f();",
|
||
"C.selector.selector;",
|
||
"C.selector;",
|
||
"C.x = g;",
|
||
"C1 c = new C1(C1(9));",
|
||
"C1 public bla;",
|
||
"C[0];",
|
||
"C[3] memory z;",
|
||
"C[3] x;",
|
||
"C[] y = new C[](3);",
|
||
"Callback function. Simply calls the buy function as a beneficiary and there is no affiliate address.",
|
||
"Can be called only by the ModuleHandler.",
|
||
"Can be called only by the Schelling module.",
|
||
"Can be called only by the publisher.",
|
||
"Can be called only by the token module.",
|
||
"Canceled",
|
||
"CategoricalEvent public categoricalEvent;",
|
||
"Changing configuration of a module. Can be called only by Publisher or while debug mode by owners.",
|
||
"Charge transaction fee. It can be called only by moduleHandler",
|
||
"Check of owner address.",
|
||
"Check self for ready for functions or not.",
|
||
"Check vote (Envelope opening)",
|
||
"Checking votes.",
|
||
"Child asset = new Child();",
|
||
"Close announcement. It can be closed only by those in the admin list. Windup is allowed only after the announcement is completed.",
|
||
"Closed = ! announcements[id].open;",
|
||
"Closing and deactivating the provider.",
|
||
"Closing the ICO.",
|
||
"Collecting the data of the client.",
|
||
"Common enumerations and structures of the Schelling and Database contract.",
|
||
"Completed,",
|
||
"Configuration of the provider. Can be invited just by the moduleHandler.",
|
||
"Connected,",
|
||
"ConnectedOn = clients[addr].providerConnected;",
|
||
"Connection to the provider.",
|
||
"Constants",
|
||
"Constructor",
|
||
"Contract can’t call this function, only a natural address.",
|
||
"ContractWithFunctionCalled c = new ContractWithFunctionCalled();",
|
||
"Copyright 2016, Jordi Baylina",
|
||
"Creating a provider.",
|
||
"Crediting the premium token",
|
||
"Crypto d;",
|
||
"Current Schelling Round",
|
||
"D _a = D(x);",
|
||
"D d = D(0x1212);",
|
||
"D d = new D();",
|
||
"D d;",
|
||
"D.s x;",
|
||
"DAO dao = DAO(msg.sender);",
|
||
"DAO newDAO;",
|
||
"DAO_Creator _daoCreator,",
|
||
"DAO_Creator public daoCreator;",
|
||
"DAO_Creator(this),",
|
||
"DAOpaidOut[_newContract] += DAOpaidOut[address(this)];",
|
||
"DAOpaidOut[address(p.splitData[0].newDAO)] += paidOutToBeMoved;",
|
||
"DAOpaidOut[address(this)] -= paidOutToBeMoved;",
|
||
"DAOpaidOut[address(this)] = 0;",
|
||
"DAOpaidOut[msg.sender] += reward;",
|
||
"DAOrewardAccount = new ManagedAccount(address(this), false);",
|
||
"Data public a;",
|
||
"Data public data;",
|
||
"Data storage x = a;",
|
||
"Data[2**10] data;",
|
||
"Data[] data;",
|
||
"Decrease of balance of the address in database. Only owner can call it.",
|
||
"Deleting module from the database. Can be called only by the Publisher contract.",
|
||
"Deposit taking.",
|
||
"Deposit will be lost, if the vote wrong, or invalid.",
|
||
"Deposit withdrawn.",
|
||
"Disable of the user not to be able to connect to the provider.",
|
||
"Disable the module for one week, if the forever true then for forever.",
|
||
"Disabled",
|
||
"Disconnect the module from the ModuleHandler.",
|
||
"Disconnected,",
|
||
"Disconnecting from the provider.",
|
||
"During ICO transactions are allowed only from genesis addresses.",
|
||
"During the ICO its not allowed to create provider.",
|
||
"During the ICO transactions are only possible from the genesis address.",
|
||
"E e = E.A;",
|
||
"E e = new E();",
|
||
"E f;",
|
||
"End = announcements[id].end;",
|
||
"Envelope opening only in the next Schelling round.",
|
||
"Ethers which are situated in this contract will be sent to the address of the foundation.",
|
||
"Event _eventContract,",
|
||
"Event eventContract,",
|
||
"Event public eventContract;",
|
||
"Event(_collateralToken, _oracle, 2)",
|
||
"Event(_collateralToken, _oracle, outcomeCount)",
|
||
"EventFactory eventFactory,",
|
||
"EventFactory eventFactory;",
|
||
"Every module will be informed about the ModuleHandler replacement.",
|
||
"Every participant entry with his own deposit.",
|
||
"Expected token volume at token purchase",
|
||
"Extend the period of the ICO with one segment.",
|
||
"Externals",
|
||
"Finishing the ICO. Can be invited only by an ICO contract.",
|
||
"First,",
|
||
"Following the transaction the receiver address `approvedCorionToken` function is called by the given data",
|
||
"For opening, has to have enough capital.",
|
||
"Freeze can not be recalled!",
|
||
"Freezing CORION Platform. Can be called only by the owner.",
|
||
"From the remaining amount calculate the reward with the help of the getIcoReward function.",
|
||
"Funds",
|
||
"FutarchyOracle futarchyOracle,",
|
||
"G1Point memory a1, G2Point memory a2,",
|
||
"G1Point memory b1, G2Point memory b2,",
|
||
"G1Point memory c1, G2Point memory c2",
|
||
"G1Point memory c1, G2Point memory c2,",
|
||
"G1Point memory d1, G2Point memory d2",
|
||
"G1Point[] memory p1 = new G1Point[](2);",
|
||
"G1Point[] memory p1 = new G1Point[](3);",
|
||
"G1Point[] memory p1 = new G1Point[](4);",
|
||
"G2Point[] memory p2 = new G2Point[](2);",
|
||
"G2Point[] memory p2 = new G2Point[](3);",
|
||
"G2Point[] memory p2 = new G2Point[](4);",
|
||
"GNU General Public License for more details.",
|
||
"GNU lesser General Public License for more details.",
|
||
"Generating tokens. It can be called only by ICO contract or the moduleHandler.",
|
||
"Generating tokens. It can be called only by ICO contract.",
|
||
"Get allowance from the database.",
|
||
"Get the quantity of tokens given to be used",
|
||
"Ground(Paper.Up);",
|
||
"HelloWorld i;",
|
||
"HelloWorldDerived i;",
|
||
"Helper h;",
|
||
"I a;",
|
||
"I i = I(new A());",
|
||
"ICO finished. It can be called only by ICO contract",
|
||
"If a transaction is carried out from or to an address which participated in the objection of an announcement, its objection purport is automatically set",
|
||
"If an ICOaddress is defined then the balance of the genesis addresses will be set as well.",
|
||
"If announcement is opposable, anyone owning a token can oppose it",
|
||
"If forReaplace is true, than the ModuleHandler will be replaced. Before the publishing of its replace, the new contract must be already on the blockchain.",
|
||
"If is a client at any provider, then it is not possible to connect to other provider one.",
|
||
"If is an active provider then the client can only connect, if address is permitted at the provider (Whitelist).",
|
||
"If is neither a client nor a provider then the function is not available.",
|
||
"If receiver is not a natural address but a person, he will be called",
|
||
"If the address is a provider and the balance is decreasing than can not let it go under the minimum level.",
|
||
"If the call is false, won't happen any direct call.",
|
||
"If the deposit isn’t lost, it can be withdrawn.",
|
||
"If the module is not connected then returns always false.",
|
||
"If the quantity of his tokens changes, the purport of his opposition changes automatically",
|
||
"If the receiver is not a natural address but also a person then she/he will be invited as well",
|
||
"If the receiver is not a natural address but also a person then she/he will be invited as well.",
|
||
"If the transaction count not match the authorise fails.",
|
||
"If the vote invalid, the deposit will be lost.",
|
||
"If the “envelope” was opened later than 1,5 Schelling round, the vote is automatically invalid, and deposit can be lost.",
|
||
"If there is a valid affiliate address then calculate and credit the reward as well in the following way:",
|
||
"If there is not at least 0.2 ether balance on the beneficiaryAddress then the amount of the ether which was intended for the purchase will be reduced by 0.2 and that will be sent to the address of the beneficiary.",
|
||
"If they call the contract without any function then this process will be taken place.",
|
||
"If this contract is the receiver, the amount will be added to the prize pool of the current round.",
|
||
"In case is a private provider it has to be checked if it has enough connected capital to be able to accept share from the token emission.",
|
||
"In case of wrong vote only this amount of deposit will be burn.",
|
||
"In case the client/provider was far behind then it is possible that this function should be called several times to check the total generated schelling rounds and to collect the share.",
|
||
"In case the height is unknown then the system will use the last known height.",
|
||
"In case the provider is not able to get the share from the token emission then the connected capital will not count to the value of the globalFunds, to the current schelling round.",
|
||
"In this case the address gets back the 90% of the amount which was spent for token during the ICO period.",
|
||
"In this case we are checking if despite the changes the provider is still entitled to the token emission. In case the legitimacy changes then the global supply should be set as well.",
|
||
"In this case we check if the provider despite the changes is still entitled to the token emission.",
|
||
"Increase of balance of the address in database. Only owner can call it.",
|
||
"Initializing manual vote.",
|
||
"Inner function for perceiving the changes of the balance and updating the database.",
|
||
"Inner function for polling the current height and the current quantity of the connected capital of the schelling round.",
|
||
"Inner function for the changes of the numbers",
|
||
"Inner function for the client in order to collect the share from the token emission",
|
||
"Inner function for the provider in order to collect the share from the token emission",
|
||
"Inner function for updating the database in case token change has happened.",
|
||
"Inner function for updating the database when some token change has happened.",
|
||
"Inner function in order to check if the given address is a natural address or a contract.",
|
||
"Inner function in order to poll the token balance of the address.",
|
||
"Inner function in order to transact a contract.",
|
||
"Inner function to authorize another address to use an exact amount of the principal’s balance.",
|
||
"Inner function to check the ICO status.",
|
||
"Inner function to create a token.",
|
||
"Inner function to launch a transaction.",
|
||
"Inner function which checks if the amount of interest what is given by the provider is fits to the criteria.",
|
||
"Inside function for calculating the result of the game.",
|
||
"Inside function for calculating the weights of the votes.",
|
||
"Inside function for querying the whole amount of the tokens.",
|
||
"Inside function for registration of the modules in the database.",
|
||
"Inside function, checks the time of the Schelling round and if its needed, creates a new Schelling round.",
|
||
"Install function.",
|
||
"Installation function",
|
||
"Installation function which joins the two token contracts with this contract.",
|
||
"Installation function.",
|
||
"Installation function. The installer will be registered in the admin list automatically",
|
||
"Internal Function to authorise another address to use a certain quantity of the authorising owner’s balance.",
|
||
"Internal function to burn the token",
|
||
"Internal function to charge the transaction fee. A certain quantity is burnt, the rest is sent to the Schelling game prize pool.",
|
||
"Internal function to check if the given address is natural, or a contract",
|
||
"Internal function to generate tokens",
|
||
"Internal function to start transactions to a contract",
|
||
"Internal function to start transactions. When Tokens are sent, transaction fee is charged",
|
||
"Internals",
|
||
"It checks if the provider has enough connected captital to be able to get from the token emission.",
|
||
"It is can called only for the admin of the provider.",
|
||
"It is only possible during the ICO and only callable by the owner.",
|
||
"It is only possible during the ICO period.",
|
||
"It is only possible to close that active provider which is owned by the sender itself after calling the whole share of the emission.",
|
||
"It is only possible to connect to valid and active providers.",
|
||
"It is only possible to disconnect those providers who were connected by us before.",
|
||
"It is only possible when the ICO period passed and only by the owner.",
|
||
"It is optionally possible to give an address of a beneficiary for whom we can transfer the accumulated amount. In case we don’t enter any address then the amount will be transferred to the caller’s address.",
|
||
"It should be checked if the sender or the acceptor does not connect to the provider or it is not a provider itself if so than the change should be recorded.",
|
||
"Iterator memory it = iterator(self);",
|
||
"L x;",
|
||
"L.E x = L.E.A;",
|
||
"L.S memory x;",
|
||
"L.S s;",
|
||
"L.S t;",
|
||
"L.S[][] memory x = new L.S[][](10);",
|
||
"L.f(2);",
|
||
"L.f(x);",
|
||
"L.l.value;",
|
||
"L.libFun(s);",
|
||
"L.l{value: 1}();",
|
||
"L.set(table, k, v);",
|
||
"LTSID = providers[addr].data[currHeight].lastOwnSupplyID;",
|
||
"Launch a transaction where the token is sent from the sender’s address to the receiver’s address.",
|
||
"Launch a transaction where we transfer from a given address to another one.",
|
||
"Launch a transaction where we transfer from a given address to another one. It can only be called by an address which was allowed before.",
|
||
"Lib.S memory x = Lib.S({a: 2, b: 3});",
|
||
"Link = announcements[id].link;",
|
||
"Loading modulest to ModuleHandler.",
|
||
"Lost deposits will be 100% burned.",
|
||
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
|
||
"ManagedAccount public DAOrewardAccount;",
|
||
"ManagedAccount public extraBalance;",
|
||
"ManagedAccount public rewardAccount;",
|
||
"Market market = markets[i];",
|
||
"Market market = markets[uint(getOutcome())];",
|
||
"Market public market;",
|
||
"MarketClosed",
|
||
"MarketCreated,",
|
||
"MarketFactory _marketFactory,",
|
||
"MarketFactory marketFactory,",
|
||
"MarketFactory public marketFactory;",
|
||
"MarketFunded,",
|
||
"MarketMaker _marketMaker,",
|
||
"MarketMaker marketMaker,",
|
||
"MarketMaker public marketMaker;",
|
||
"Market[] public markets;",
|
||
"Migrations upgraded = Migrations(new_address);",
|
||
"Milestone storage milestone = milestones.push();",
|
||
"Milestone storage milestone = milestones[_idMilestone];",
|
||
"Milestone[] public milestones;",
|
||
"Modifying the data of the provider.",
|
||
"Module",
|
||
"Module constructor function for registering ModuleHandler address.",
|
||
"Module replace, can be called only by the Publisher contract.",
|
||
"More than 1e10 token: 3%",
|
||
"More than 1e11 token: 4%",
|
||
"More than 1e9 token: 2% below 1%",
|
||
"MultiSigWallet(_owners, _required)",
|
||
"MyStructName x;",
|
||
"MyStructName1 x;",
|
||
"MyStructName1[1] x;",
|
||
"MyStructName1[] x;",
|
||
"MyStructName2 x;",
|
||
"MyStructName2[1] x;",
|
||
"MyStructName2[1][1] x;",
|
||
"MyStructName2[] x;",
|
||
"MyStructName3 x;",
|
||
"MyStructName4[1] x;",
|
||
"MyStructName[1] x;",
|
||
"MyStructName[] x;",
|
||
"Nested nested;",
|
||
"New announcement. Can be called only by those in the admin list",
|
||
"New schelling round. This function is only available for the moduleHandler.",
|
||
"New,",
|
||
"No transaction fee during ICO.",
|
||
"Non y;",
|
||
"Number of actual Schelling round.",
|
||
"One address is entitled to be in oppositon only once. An opposition cannot be withdrawn.",
|
||
"Only ModuleHandler can call it",
|
||
"Only callable by the owner",
|
||
"Only callable by the owner.",
|
||
"Only that affiliate address is valid which has some token on it’s account.",
|
||
"Only the configured modules get notifications( schellingEvent ).",
|
||
"Only the configured modules get notifications.( transferEvent )",
|
||
"Only the hash of vote will be sent. (Envelope sending).",
|
||
"Only the owner is allowed to call it.",
|
||
"Only the sent “envelopes” can be opened.",
|
||
"Opcionalisan megadhato az ellenorzes koreinek szama. It is possible to enter optionally the number of the check-rounds. If it is 0 then it is automatic.",
|
||
"Opposited = true;",
|
||
"Opposition is automatically with the total amount of tokens",
|
||
"Opposition of announcement",
|
||
"Optionally there can be an address of a beneficiary added, which address the prize will be sent to. Without beneficiary, the owner is the default address.",
|
||
"Oracle _forwardedOracle,",
|
||
"Oracle _oracle,",
|
||
"Oracle oracle,",
|
||
"Oracle public forwardedOracle;",
|
||
"Oracle public oracle;",
|
||
"Oracle[] public oracles;",
|
||
"Other o;",
|
||
"OutcomeToken outcomeToken = new OutcomeToken();",
|
||
"OutcomeToken[] public outcomeTokens;",
|
||
"Owner replace.",
|
||
"P x;",
|
||
"P y;",
|
||
"P[101] x;",
|
||
"P[102] y;",
|
||
"Pairing.G1Point A;",
|
||
"Pairing.G1Point A_p;",
|
||
"Pairing.G1Point B;",
|
||
"Pairing.G1Point B_p;",
|
||
"Pairing.G1Point C;",
|
||
"Pairing.G1Point C_p;",
|
||
"Pairing.G1Point H;",
|
||
"Pairing.G1Point K;",
|
||
"Pairing.G1Point gammaBeta1;",
|
||
"Pairing.G1Point memory explict_sum = Pairing.add(p1, p2);",
|
||
"Pairing.G1Point memory p1;",
|
||
"Pairing.G1Point memory p2;",
|
||
"Pairing.G1Point memory p;",
|
||
"Pairing.G1Point memory scalar_prod = Pairing.mul(p1, 2);",
|
||
"Pairing.G1Point memory vk_x = Pairing.G1Point(0, 0);",
|
||
"Pairing.G1Point memory x = Pairing.add(Pairing.P1(), Pairing.negate(Pairing.P1()));",
|
||
"Pairing.G1Point[] IC;",
|
||
"Pairing.G1Point[] memory g1points = new Pairing.G1Point[](2);",
|
||
"Pairing.G2Point A;",
|
||
"Pairing.G2Point B;",
|
||
"Pairing.G2Point C;",
|
||
"Pairing.G2Point Z;",
|
||
"Pairing.G2Point gamma;",
|
||
"Pairing.G2Point gammaBeta2;",
|
||
"Pairing.G2Point memory fiveTimesP2 = Pairing.G2Point(",
|
||
"Pairing.G2Point[] memory g2points = new Pairing.G2Point[](2);",
|
||
"Pairing.add(vk_x, proof.A), proof.B,",
|
||
"Pairing.negate(Pairing.add(vk_x, Pairing.add(proof.A, proof.C))), vk.gammaBeta2,",
|
||
"Pairing.negate(proof.C), Pairing.P2()",
|
||
"Pairing.negate(proof.H), vk.Z,",
|
||
"Pairing.negate(vk.gammaBeta1), proof.B",
|
||
"Parent p = new Impl();",
|
||
"Permission of the user to be able to connect to the provider.",
|
||
"Polling the share from the token emission for clients and for providers.",
|
||
"Polling the share from the token emission token emission for clients and for providers.",
|
||
"Pool",
|
||
"Privates",
|
||
"Prize will be sent from the Schelling address without any transaction fee.",
|
||
"Proof memory proof;",
|
||
"Proposal storage p = proposals.push();",
|
||
"Proposal storage p = proposals[_proposalID];",
|
||
"Proposal storage p = proposals[blocked[_account]];",
|
||
"Proposal[] public proposals;",
|
||
"Provider module",
|
||
"Provider variable should only be entered if the real owner of the provider is not the caller’s address.",
|
||
"ProviderAddress = clients[addr].providerAddress;",
|
||
"ProviderHeight = clients[addr].providerHeight;",
|
||
"Providers can not connect to other providers.",
|
||
"Q0 q0;",
|
||
"Q1 q1;",
|
||
"Q2 q2;",
|
||
"Q3 q3;",
|
||
"Q4 q4;",
|
||
"Query of ICO state",
|
||
"Query of compound interest",
|
||
"Query of current bonus",
|
||
"Query of number of the actual Schelling round.",
|
||
"Query of the whole token amount.",
|
||
"Query of token balance.",
|
||
"R1 x;",
|
||
"R2[][] x;",
|
||
"RLP.Iterator memory itrProposal = itmProposal.iterator();",
|
||
"RLP.Iterator memory itrProposals = itmProposals.iterator();",
|
||
"RLP.RLPItem memory itmProposal = itrProposals.next();",
|
||
"RLP.RLPItem memory itmProposals = mProposedMilestones.toRLPItem(true);",
|
||
"RLPItem memory item = self._unsafe_item;",
|
||
"RLPItem memory item = toRLPItem(self);",
|
||
"Receiver r = new Receiver();",
|
||
"RecursiveStruct [ 1 ] memory val ;",
|
||
"RecursiveStruct[1] memory val = [ RecursiveStruct(new RecursiveStruct[](42)) ];",
|
||
"RecursiveStruct[1] memory val;",
|
||
"RecursiveStruct[] vals;",
|
||
"Redeem of prize.",
|
||
"Refund the amount which was purchased during the ICO period.",
|
||
"Registering and/or connecting-to ModuleHandler.",
|
||
"Replace the ModuleHandler address.",
|
||
"Replace the module for an another new module.",
|
||
"Replacing ModuleHandler.",
|
||
"Request of compound interest. This is deleted from the database after the ICO closed and following the query of the compound interest.",
|
||
"Rounds",
|
||
"Running announcements can be opposed only.",
|
||
"S constant x = S(5, new uint[](4));",
|
||
"S data;",
|
||
"S m_x;",
|
||
"S memory c;",
|
||
"S memory data = combine(1, 2, 3);",
|
||
"S memory m = s;",
|
||
"S memory ms1;",
|
||
"S memory ms2;",
|
||
"S memory s ;",
|
||
"S memory s = S(1);",
|
||
"S memory s = S(1, s2, X(4, 5));",
|
||
"S memory s = S(1, true);",
|
||
"S memory s = S(2,0x02);",
|
||
"S memory s = S(42);",
|
||
"S memory s = S(I(1,2));",
|
||
"S memory s = S(I(1,2, this.o));",
|
||
"S memory s = S(address(this));",
|
||
"S memory s = S(this.dummy);",
|
||
"S memory s = S({a: 1, x: true});",
|
||
"S memory s = S({a: 1});",
|
||
"S memory s = data[2];",
|
||
"S memory s;",
|
||
"S memory smem = S(v);",
|
||
"S memory st;",
|
||
"S memory x;",
|
||
"S memory y;",
|
||
"S public override f;",
|
||
"S public override test;",
|
||
"S public s;",
|
||
"S public x;",
|
||
"S public y;",
|
||
"S s1;",
|
||
"S s2;",
|
||
"S s;",
|
||
"S sstorage;",
|
||
"S storage c;",
|
||
"S storage r;",
|
||
"S storage s = array.push();",
|
||
"S storage s1 = data.push();",
|
||
"S storage s2 = data.push();",
|
||
"S storage x = s;",
|
||
"S storage x_local = x;",
|
||
"S storage y = x;",
|
||
"S storage y_local = y;",
|
||
"S storage z_local = x;",
|
||
"S x = m_x;",
|
||
"S x;",
|
||
"S x; S y;",
|
||
"S y = x;",
|
||
"S y;",
|
||
"S z = z;",
|
||
"S({a: 1});",
|
||
"S0 s0;",
|
||
"S0 sv_0;",
|
||
"S1 s1;",
|
||
"S1 s;",
|
||
"S1 x;",
|
||
"S2 memory m = s;",
|
||
"S2 memory x = s2;",
|
||
"S2 s2;",
|
||
"S2[1][] x;",
|
||
"S[2**20] x;",
|
||
"S[2] memory d;",
|
||
"S[2] memory x = [S({a: 1, b: \"fish\"}), S({a: 2, b: \"fish\"})];",
|
||
"S[5] data;",
|
||
"S[] array;",
|
||
"S[] data;",
|
||
"S[] memory c;",
|
||
"S[] memory m = s;",
|
||
"S[] memory s;",
|
||
"S[] memory z = new S[](180);",
|
||
"S[] s;",
|
||
"S[] x;",
|
||
"ScalarEvent scalarEvent = eventFactory.createScalarEvent(",
|
||
"Schelling Token emission",
|
||
"Schelling contract",
|
||
"Schelling database contract.",
|
||
"Schelling database functions.",
|
||
"Schelling module",
|
||
"Search by ethereum address for module. The result is an index array.",
|
||
"Search by hash of name in the module array. The result is an index array.",
|
||
"Search by name for module. The result is an Ethereum address.",
|
||
"Search by name for module. The result is an index array.",
|
||
"Second",
|
||
"Set allowance in the database. Only owner can call it.",
|
||
"Setting interest database. It can be requested by Token contract only.",
|
||
"Setting of the ICO ETC USD rates which can only be called by a pre-defined address.",
|
||
"Setup function.",
|
||
"SplitData[] splitData;",
|
||
"St destination;",
|
||
"St destination_indirect_1;",
|
||
"St destination_indirect_2;",
|
||
"St source;",
|
||
"St storage ref = destination_indirect_1;",
|
||
"Stages public stage;",
|
||
"Standard smart contract for a Decentralized Autonomous Organization (DAO)",
|
||
"Start = announcements[id].start;",
|
||
"Start transaction to send a quantity from a given address to another address",
|
||
"Start transaction to send a quantity from a given address to another address. (approve / allowance). This can be called only by the address approved in advance",
|
||
"Start transaction, token is sent from caller’s address to receiver’s address",
|
||
"State s;",
|
||
"Struct data1;",
|
||
"Struct data2;",
|
||
"Struct memory x = data1;",
|
||
"Struct s;",
|
||
"SubA sa = new Impl();",
|
||
"SubB sb = new Impl();",
|
||
"SubStruct subStruct1;",
|
||
"SubStruct subStruct2;",
|
||
"T t;",
|
||
"T1 x;",
|
||
"T2[][1] x;",
|
||
"T;",
|
||
"T[] t;",
|
||
"Test for ModuleHandler address.",
|
||
"Thank you ConsenSys, this contract originated from:",
|
||
"The 0xa636a97578d26a3b76b060bbc18226d954cf3757 address are blacklisted.",
|
||
"The 96% of the whole amount of the token is generated to the address of the foundation.",
|
||
"The DAO is distributed in the hope that it will be useful,",
|
||
"The DAO is free software: you can redistribute it and/or modify",
|
||
"The address must be in default state, that is there are no vote in progress.",
|
||
"The admin can only be changed by the address of the provider.",
|
||
"The deposit will be sent to the address of Schelling, charged with transaction fee.",
|
||
"The emission rate is only valid for the next schelling round for this one it is not.",
|
||
"The prime time is the windup of the announcement, because this is the moment when the number of tokens in opposition are counted.",
|
||
"The prizes will be collected here, and with this function can be transferred to the account of the user.",
|
||
"The provider can be start as a rent as well, in this case the isForRent has to be true/correct. In case it runs as a rent the 20% of the profit will belong to the leser and the rest goes to the admin.",
|
||
"The provider’s account counts as a capital for the emission as well.",
|
||
"The right votes take share of deposits.",
|
||
"The tokens will be sent to the beneficiary from the address of the provider without any transaction fees.",
|
||
"This can only be invited by the provider’s admin.",
|
||
"This file is part of the DAO.",
|
||
"This function calls the Publisher module.",
|
||
"This function is called by ModuleHandler load or by Publisher.",
|
||
"This module can be called only once and only by the owner, if every single module and its database are already put on the blockchain.",
|
||
"This one is only callable if the ICO is withdrawn.",
|
||
"This process has a transaction fee based on the senders whole token quantity.",
|
||
"This program is distributed in the hope that it will be useful,",
|
||
"This program is free software: you can redistribute it and/or modify",
|
||
"To one address only one provider can belong to.",
|
||
"Token _collateralToken,",
|
||
"Token balance query",
|
||
"Token burn. Can be called only by Schelling.",
|
||
"Token collateralToken,",
|
||
"Token emission request. Can be called only by the provider.",
|
||
"Token public collateralToken;",
|
||
"Token settings configuration.It can be call only by moduleHandler",
|
||
"Token transaction fee. Can be called only by the provider.",
|
||
"Token transaction request. Can be called only by a module.",
|
||
"Total token quantity query",
|
||
"Transaction completed. This function can be called only by the ModuleHandler.",
|
||
"Transaction completed. This function is available only for moduleHandler",
|
||
"Transaction completed. This function is only available for the modulehandler.",
|
||
"Transaction fee is going to be added as well.",
|
||
"Transaction fee is to be deducted",
|
||
"Transaction fee is to be deducted.",
|
||
"Transaction fee query.",
|
||
"Transaction fee will be charged too.",
|
||
"Transaction storage tx = transactions[transactionId];",
|
||
"Tree childStorageTree;",
|
||
"Tree memory memoryTree;",
|
||
"Tree storageTree;",
|
||
"Tree[] children;",
|
||
"Type = uint256(announcements[id].Type);",
|
||
"U[] u;",
|
||
"UltimateOracle ultimateOracle,",
|
||
"VerifyingKey memory vk = verifyingKey();",
|
||
"Veto check",
|
||
"VoteTiming.init(1);",
|
||
"Votes can be sent only on the actually Schelling round.",
|
||
"We are recording the new schelling round and we are storing the whole current quantity of the tokens.",
|
||
"We generate a reward quantity of tokens directed to the providers address. The collected interest will be transferred from this contract.",
|
||
"We just call this only if the private provider and it’s own capital bears emission.",
|
||
"We send every Token and ether to the new module.",
|
||
"When _icoAddr is defined, 0.2 ether has to be attached as many times as many genesis addresses are given",
|
||
"When sending an amount, it is possible the total amount cannot be processed, the remaining amount is sent back with no fee charged",
|
||
"Which is itself based on the Ethereum standardized contract APIs:",
|
||
"Whom were connected to the provider those clients will have to disconnect after they’ve called their share of emission which was not called before.",
|
||
"With more than 1e12 token contract credit 5% reward based on the calculation that how many tokens did they buy when he was added as an affiliate.",
|
||
"With this kind of call only 100 address can be permitted.",
|
||
"With this process avoiding the sudden rate changes.",
|
||
"WithModifier.withMod(_value);",
|
||
"Withdraw announcement. Only those in the admin list can withdraw it.",
|
||
"Withdraw of the amount of the prize (it’s only information).",
|
||
"Withdrawal of the ICO.",
|
||
"X abc;",
|
||
"X garbled = X.A;",
|
||
"X garbled;",
|
||
"X m_x;",
|
||
"X memory d = combine(1, 2, 3, 4);",
|
||
"X memory d = m_x;",
|
||
"X memory d;",
|
||
"X ofg;",
|
||
"X public x;",
|
||
"X s3 ;",
|
||
"X s3;",
|
||
"X tmp;",
|
||
"Y a;",
|
||
"Y[] x;",
|
||
"[1, 2, 3] = [4, 5, 6];",
|
||
"[1, 2, 3]++;",
|
||
"[4082367875863433681332203403145435568316851327593401208105741076214120093531,",
|
||
"[4540444681147253467785307942530223364530218361853237193970751657229138047649, 20954117799226682825035885491234530437475518021362091509513177301640194298072],",
|
||
"[8176651290984905087450403379100573157708110416512446269839297438960217797614, 15588556568726919713003060429893850972163943674590384915350025440408631945055],",
|
||
"[a];",
|
||
"[d.f{value: 1}, d.g][0](8);",
|
||
"[g, h][1]({x : 1, y : 2});",
|
||
"[msg];",
|
||
"[t.f, t.g][0]();",
|
||
"[t.f, x][0]({a: 8});",
|
||
"[type(C)];",
|
||
"_; f(3);",
|
||
"_; f(_x);",
|
||
"_; f(x);",
|
||
"_; x = 1;",
|
||
"_; x = 23;",
|
||
"_a = simple[2 + _off];",
|
||
"_addOwner(addr);",
|
||
"_addOwner(newOwners[a]);",
|
||
"_addr = announcements[id]._addr;",
|
||
"_allowances[owner][spender] = value;",
|
||
"_amount != 0",
|
||
"_amount += _tamount;",
|
||
"_amount,",
|
||
"_approve(account, msg.sender, _allowances[account][msg.sender] - value);",
|
||
"_approve(from, msg.sender, _allowances[from][msg.sender] - value);",
|
||
"_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);",
|
||
"_approve(msg.sender, spender, _allowances[msg.sender][spender] - subtractedValue);",
|
||
"_approve(msg.sender, spender, value);",
|
||
"_approve(spender, amount, nonce);",
|
||
"_b = 0x12;",
|
||
"_b = simple[3 + _off];",
|
||
"_b2 = 0x1223;",
|
||
"_b22 = hex\"325235235325325325235325\";",
|
||
"_b32 = hex\"032523532532523532523532523532\";",
|
||
"_b5 = hex\"043245\";",
|
||
"_b6 = hex\"2345532532\";",
|
||
"_b7 = hex\"03252353253253\";",
|
||
"_balances[account] = _balances[account] + value;",
|
||
"_balances[account] = _balances[account] - value;",
|
||
"_balances[from] = _balances[from] - value;",
|
||
"_balances[to] = _balances[to] + value;",
|
||
"_blit = hex\"123498\";",
|
||
"_burn(account, value);",
|
||
"_burn(owner, _fee);",
|
||
"_burn(owner, _forBurn);",
|
||
"_burn(owner, value);",
|
||
"_c = simple[uint(-1)];",
|
||
"_closingTime,",
|
||
"_codeLength := extcodesize(addr)",
|
||
"_confirmations = new address[](count);",
|
||
"_confirmations[i] = confirmationsTemp[i];",
|
||
"_connectModule();",
|
||
"_copyToBytes(rStartPos, bts, len);",
|
||
"_copyToBytes(self._unsafe_memPtr, bts, len);",
|
||
"_curator,",
|
||
"_d = E.Left;",
|
||
"_d = E.Right;",
|
||
"_data = mappingAccess[20];",
|
||
"_data.slot := slot",
|
||
"_data[3] = 2;",
|
||
"_decimalPlaces",
|
||
"_decimalPlaces) public {",
|
||
"_delOwner(addr);",
|
||
"_description",
|
||
"_disableModule(forever);",
|
||
"_disconnectModule();",
|
||
"_empty = _idb.empty;",
|
||
"_f = this.f;",
|
||
"_f();",
|
||
"_g();",
|
||
"_hash,",
|
||
"_idb = interestDB[addr][r];",
|
||
"_idb = interestDB[msg.sender][r];",
|
||
"_lastBal += _tamount;",
|
||
"_lastBal = 0;",
|
||
"_lastBal = _idb.amount + _amount;",
|
||
"_lastBal = _idb.amount + amount;",
|
||
"_lastBal = _idb.amount;",
|
||
"_minTokensToCreate,",
|
||
"_mint(msg.sender, 20);",
|
||
"_mint(owner, value);",
|
||
"_newCurator,",
|
||
"_nonce = safeAdd(_nonce, 1);",
|
||
"_out = _in;",
|
||
"_privateCreation,",
|
||
"_processTransactionFee(from, amount - _back);",
|
||
"_processTransactionFee(owner, value);",
|
||
"_proposalDeposit,",
|
||
"_proposalID = proposals.length - 1;",
|
||
"_proposalID,",
|
||
"_reamining = safeSub(_reamining, amount);",
|
||
"_recipient,",
|
||
"_replaceModule(newModuleAddress);",
|
||
"_replaceModuleHandler(newModuleHandlerAddress);",
|
||
"_ret := 5",
|
||
"_ret = Choice.B;",
|
||
"_ret = _arg * 2;",
|
||
"_ret = base.Choice.B;",
|
||
"_ret = test.Choice.B;",
|
||
"_ret = tmp;",
|
||
"_rewards",
|
||
"_roundID,",
|
||
"_rounds memory newRound;",
|
||
"_rounds memory prevRound;",
|
||
"_rounds memory round = getRound(currentRound);",
|
||
"_rounds memory round;",
|
||
"_rounds[] private rounds;",
|
||
"_s.d = 1;",
|
||
"_s.data[3] = 2;",
|
||
"_status,",
|
||
"_str = \"heidy\";",
|
||
"_str = announcements[id]._str;",
|
||
"_success = true;",
|
||
"_tamount = _lastBal * interestOnICO / interestOnICOM / 100;",
|
||
"_tokenName,",
|
||
"_tokenSymbol,",
|
||
"_totalSupply = _totalSupply + value;",
|
||
"_totalSupply = _totalSupply - value;",
|
||
"_transactionIds = new uint[](to - from);",
|
||
"_transactionIds[i - from] = transactionIdsTemp[i];",
|
||
"_transfer( from, to, amount);",
|
||
"_transfer( from, to, amount, fee);",
|
||
"_transfer( from, to, amount, true);",
|
||
"_transfer( msg.sender, to, amount);",
|
||
"_transfer( msg.sender, to, amount, true);",
|
||
"_transfer(from, to, amount);",
|
||
"_transfer(from, to, amount, exchangeAddress == to);",
|
||
"_transfer(from, to, value);",
|
||
"_transfer(msg.sender, to, amount);",
|
||
"_transfer(msg.sender, to, value);",
|
||
"_transfer(to, from, _back);",
|
||
"_transfer(to, from, _back, false);",
|
||
"_transferToContract(from, to, amount, _data);",
|
||
"_transferToContract(msg.sender, to, amount, _data);",
|
||
"_transferToContract(msg.sender, to, amount, extraData);",
|
||
"_uint = announcements[id]._uint;",
|
||
"_value = safeSub(_value, 0.2 ether);",
|
||
"_value.withMod();",
|
||
"_x = 3;",
|
||
"_x = x;",
|
||
"_x.f();",
|
||
"_y = 4;",
|
||
"_y = y;",
|
||
"a ** (1/2);",
|
||
"a ** 1E1233;",
|
||
"a += ((((b))));",
|
||
"a += (1, 1);",
|
||
"a += (b += c);",
|
||
"a += a += a;",
|
||
"a += b += c;",
|
||
"a += b;",
|
||
"a += x;",
|
||
"a -= 2;",
|
||
"a -= b;",
|
||
"a := 0x0f0f0f0f0f",
|
||
"a := 0x12345678",
|
||
"a := 0x9C",
|
||
"a := 0xf0",
|
||
"a := 0xfffffff0",
|
||
"a := 0xffffffff",
|
||
"a := 1",
|
||
"a := 2",
|
||
"a := abc",
|
||
"a := byte(31, x)",
|
||
"a := byte(x, 31)",
|
||
"a := mload(selfptr)",
|
||
"a := tmp1",
|
||
"a := x",
|
||
"a <<= 8;",
|
||
"a <<= b;",
|
||
"a = (1<<4095)*(1<<4095);",
|
||
"a = (m[0] == 0x01);",
|
||
"a = (y = x);",
|
||
"a = -1 ** 1E1233;",
|
||
"a = -1E1233 ** -1E1233;",
|
||
"a = -1E1233 ** -2;",
|
||
"a = -1E1233 ** 1E1233;",
|
||
"a = -1E1233 ** 2;",
|
||
"a = -2 ** -1E1233;",
|
||
"a = -2 ** 1E1233;",
|
||
"a = -2;",
|
||
"a = -4 ** 4 ** 2 ** 4 ** 4 ** 4 ** 4 ** 4;",
|
||
"a = 0 ** 1E1233;",
|
||
"a = 0;",
|
||
"a = 0E123456789;",
|
||
"a = 0x0000000000000000000000000000000000000100;",
|
||
"a = 0x0000000000000000000000000000000000000200;",
|
||
"a = 0x4200;",
|
||
"a = 0x42;",
|
||
"a = 1 ** 1E1233;",
|
||
"a = 1 wei * 100 wei + 7 gwei - 3;",
|
||
"a = 1 wei;",
|
||
"a = 1/(2<<4094)/(2<<4094);",
|
||
"a = 115792089237316195423570985008687907853269984665640564039458 ether;",
|
||
"a = 115792089237316195423570985008687907853269984665640564039458;",
|
||
"a = 1;",
|
||
"a = 1E1233 ** -1E1233;",
|
||
"a = 1E1233 ** -2;",
|
||
"a = 1E1233 ** 1E1233;",
|
||
"a = 1E1233 ** 2;",
|
||
"a = 2 ** -1E1233;",
|
||
"a = 2 ** 1E1233;",
|
||
"a = 2;",
|
||
"a = 3;",
|
||
"a = 4 ** (-(2 ** 4 ** 4 ** 4 ** 4 ** 4));",
|
||
"a = 4 ** 4 ** 2 ** 4 ** 4 ** 4 ** 4;",
|
||
"a = 4;",
|
||
"a = 5;",
|
||
"a = 7;",
|
||
"a = ActionChoices.GoStraight;",
|
||
"a = L.f.selector;",
|
||
"a = [,2,3];",
|
||
"a = [1,2,3];",
|
||
"a = _a;",
|
||
"a = a ** 1E5;",
|
||
"a = a + 1;",
|
||
"a = a - 1;",
|
||
"a = abd;",
|
||
"a = ac;",
|
||
"a = address(0) * address(0);",
|
||
"a = address(0) + address(0);",
|
||
"a = address(0) - address(0);",
|
||
"a = address(0) / address(0);",
|
||
"a = address(0);",
|
||
"a = address(1);",
|
||
"a = ade;",
|
||
"a = b;",
|
||
"a = cd;",
|
||
"a = d.x;",
|
||
"a = d;",
|
||
"a = d[0].a[1];",
|
||
"a = data2[1];",
|
||
"a = data[k].a;",
|
||
"a = extract(d, 0);",
|
||
"a = f;",
|
||
"a = false;",
|
||
"a = g();",
|
||
"a = g;",
|
||
"a = int[](b);",
|
||
"a = land;",
|
||
"a = lang;",
|
||
"a = lost;",
|
||
"a = m[0].a;",
|
||
"a = m_a;",
|
||
"a = m_x.x;",
|
||
"a = new A(address(this));",
|
||
"a = s.a;",
|
||
"a = s.a[1];",
|
||
"a = s1.a;",
|
||
"a = s;",
|
||
"a = s[0].a;",
|
||
"a = s[0];",
|
||
"a = this.f;",
|
||
"a = twodim[3][2];",
|
||
"a = uint256(ActionChoices.GoStraight);",
|
||
"a = validEnum.Value3;",
|
||
"a = x.length;",
|
||
"a = x;",
|
||
"a = ~a;",
|
||
"a >>= 8;",
|
||
"a >>= b;",
|
||
"a++;",
|
||
"a--;",
|
||
"a.NeverReachedByParser();",
|
||
"a.call{gas: 42};",
|
||
"a.call{value: 42};",
|
||
"a.delegatecall{gas: 42};",
|
||
"a.double();",
|
||
"a.double;",
|
||
"a.g();",
|
||
"a.length,",
|
||
"a.pop();",
|
||
"a.push();",
|
||
"a.push(x);",
|
||
"a.push(x[2]);",
|
||
"a.send();",
|
||
"a.staticcall{gas: 42};",
|
||
"a.transfer();",
|
||
"a.transfer(600);",
|
||
"a1 = d.a[0];",
|
||
"a1 = m_x.a[0];",
|
||
"a1, b1, c1 := asmfun(1, 2, 3)",
|
||
"a1; b1; c1; d1; a2; b2; c2; a3; b3;",
|
||
"a2 = d.a[1];",
|
||
"a2 = m_x.a[1];",
|
||
"a;",
|
||
"a; b;",
|
||
"a; b; c;",
|
||
"a; b; c; d;",
|
||
"a; b; c; d; e; f; g;",
|
||
"a; b; c; d; e; g;",
|
||
"a; b; c; d; e; h; x; y;",
|
||
"a; d;",
|
||
"a;b;c;d;e;",
|
||
"a;b;c;d;e;f;g;h;i;j;k;l;",
|
||
"a;b;c;d;e;f;g;h;i;j;k;l;m;n;",
|
||
"a[-1];",
|
||
"a[.5];",
|
||
"a[0] = 0;",
|
||
"a[0] = 2;",
|
||
"a[0] = this.getter1;",
|
||
"a[0] = x;",
|
||
"a[0].length,",
|
||
"a[0].pop();",
|
||
"a[0].push();",
|
||
"a[0].push(y);",
|
||
"a[0];",
|
||
"a[0][0] = 16;",
|
||
"a[0][0];",
|
||
"a[1] = 2;",
|
||
"a[1] = this.getter2;",
|
||
"a[1] = x;",
|
||
"a[1].length,",
|
||
"a[1].pop();",
|
||
"a[1].push(3);",
|
||
"a[1].push(4);",
|
||
"a[1][1] = 512;",
|
||
"a[1][1] = n;",
|
||
"a[1][1][1] = n;",
|
||
"a[2] = 3;",
|
||
"a[2] = byte(uint8(7));",
|
||
"a[2] = this.getter3;",
|
||
"a[2];",
|
||
"a[2][3] = 4;",
|
||
"a[64];",
|
||
"a[8**90][8**90][1 - 8**90];",
|
||
"a[8**90][8**90][8**90*0.1];",
|
||
"a[888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888];",
|
||
"a[] public foo;",
|
||
"a[];",
|
||
"a[a.length - 1][key] = value;",
|
||
"a[i] = new uint[](3);",
|
||
"a[i] = new uint[][](3);",
|
||
"a[i][j] = new uint[](4);",
|
||
"a[x] = v;",
|
||
"a[x] = y;",
|
||
"a_hash = keccak256(\"\x7b\");",
|
||
"abi.decode(\"\", (byte[999999999]));",
|
||
"abi.decode(\"\", (s));",
|
||
"abi.decode(\"abc\", ());",
|
||
"abi.decode(\"abc\", (bytes calldata));",
|
||
"abi.decode(\"abc\", (bytes memory, uint[][2] memory));",
|
||
"abi.decode(\"abc\", (bytes storage));",
|
||
"abi.decode(\"abc\", f());",
|
||
"abi.decode(\"abc\", this);",
|
||
"abi.decode(\"abc\", uint);",
|
||
"abi.decode();",
|
||
"abi.decode(msg.data);",
|
||
"abi.decode(msg.data, uint, uint);",
|
||
"abi.decode(uint, uint);",
|
||
"abi.decode(x[cond ? 1 : 2 : ], (uint256));",
|
||
"abi.decode(x[cond ? 1 : 2 : cond ? 3 : 4], (uint256));",
|
||
"abi.decode;",
|
||
"abi.encode(s);",
|
||
"abi.encode(s, t);",
|
||
"abi.encode(this.f{gas: 2});",
|
||
"abi.encode(this.f{value: 2, gas: 1});",
|
||
"abi.encode(this.f{value: 2});",
|
||
"abi.encode(x[1:2]);",
|
||
"abi.encode;",
|
||
"abi.encodePacked(m);",
|
||
"abi.encodePacked(s);",
|
||
"abi.encodePacked(s, t);",
|
||
"abi.encodePacked(st);",
|
||
"abi.encodePacked;",
|
||
"abi.encodeWithSelector();",
|
||
"abi.encodeWithSelector(uint(2), 2);",
|
||
"abi.encodeWithSelector({selector:\"abc\"});",
|
||
"abi.encodeWithSelector;",
|
||
"abi.encodeWithSignature(\"c(uint256,uint256[])\", a, b)",
|
||
"abi.encodeWithSignature();",
|
||
"abi.encodeWithSignature(uint(2), 2);",
|
||
"abi.encodeWithSignature;",
|
||
"aborted = true;",
|
||
"abstract",
|
||
"abstract A { }",
|
||
"abstract contract A is I",
|
||
"abstract contract A is I {",
|
||
"abstract contract A is I, J {",
|
||
"abstract contract A is IJ",
|
||
"abstract contract A {",
|
||
"abstract contract A { constructor() {} }",
|
||
"abstract contract A { function f() public pure virtual; }",
|
||
"abstract contract A { modifier mod(uint a) virtual;}",
|
||
"abstract contract AbstractContract {",
|
||
"abstract contract B is A {",
|
||
"abstract contract B is C {",
|
||
"abstract contract B is I",
|
||
"abstract contract B is I {",
|
||
"abstract contract B is IJ",
|
||
"abstract contract B {",
|
||
"abstract contract B {modifier m virtual;}",
|
||
"abstract contract B1 is C {",
|
||
"abstract contract Base1 is Base {",
|
||
"abstract contract C",
|
||
"abstract contract C is A {",
|
||
"abstract contract C is A, B {",
|
||
"abstract contract C is A, B {}",
|
||
"abstract contract C is B {",
|
||
"abstract contract C is D {}",
|
||
"abstract contract C is I {",
|
||
"abstract contract C {",
|
||
"abstract contract Crypto {",
|
||
"abstract contract D",
|
||
"abstract contract D is A, B, C {",
|
||
"abstract contract D is B, A {",
|
||
"abstract contract D is C {",
|
||
"abstract contract D is E {",
|
||
"abstract contract D {",
|
||
"abstract contract D {modifier m;}",
|
||
"abstract contract DAOInterface {",
|
||
"abstract contract E is F {}",
|
||
"abstract contract ERC165MappingImplementation is ERC165 {",
|
||
"abstract contract Event {",
|
||
"abstract contract I",
|
||
"abstract contract IJ is I, J {",
|
||
"abstract contract M {",
|
||
"abstract contract ManagedAccountInterface {",
|
||
"abstract contract Market {",
|
||
"abstract contract MarketFactory {",
|
||
"abstract contract MarketMaker {",
|
||
"abstract contract Oracle {",
|
||
"abstract contract Other {",
|
||
"abstract contract T is A {",
|
||
"abstract contract Test",
|
||
"abstract contract Token {",
|
||
"abstract contract TokenCreationInterface {",
|
||
"abstract contract TokenInterface {",
|
||
"abstract contract V is I",
|
||
"abstract contract X is A {",
|
||
"abstract contract X is A, B {",
|
||
"abstract contract X is A, B, C, D {",
|
||
"abstract contract X { function test() external virtual returns (uint256); }",
|
||
"abstract contract X { function test() internal virtual returns (uint256); }",
|
||
"abstract contract X { function test() private virtual returns (uint256); }",
|
||
"abstract contract a {",
|
||
"abstract contract base { function foo() public virtual; }",
|
||
"abstract contract test {",
|
||
"abstract contract tokenRecipient {",
|
||
"abstract interface A { }",
|
||
"abstract library A { }",
|
||
"abstract library T {",
|
||
"abstractModule(modules[_id].addr).disableModule(true);",
|
||
"accumulatedInput += msg.value;",
|
||
"addModule( modules_s(Premium, keccak256('Premium'), false, false), ! forReplace);",
|
||
"addModule( modules_s(Provider, keccak256('Provider'), true, true), ! forReplace);",
|
||
"addModule( modules_s(Publisher, keccak256('Publisher'), false, true), ! forReplace);",
|
||
"addModule( modules_s(Schelling, keccak256('Schelling'), false, true), ! forReplace);",
|
||
"addModule( modules_s(Token, keccak256('Token'), false, false), ! forReplace);",
|
||
"addModule( modules_s(addr, keccak256(bytes(name)), schellingEvent, transferEvent), true);",
|
||
"addmod(0, 1, 2);",
|
||
"addmod(1, 0, 2);",
|
||
"addmod(1, 2, d);",
|
||
"addr.transfer(1);",
|
||
"addr_1 = msg.sender;",
|
||
"address",
|
||
"address _addr = beneficiary;",
|
||
"address _arbitrator,",
|
||
"address _beneficiary = beneficiary;",
|
||
"address _beneficiary = msg.sender;",
|
||
"address _creator,",
|
||
"address _donor,",
|
||
"address _from,",
|
||
"address _owner,",
|
||
"address _privateCreation,",
|
||
"address _provider = provider;",
|
||
"address _recipient",
|
||
"address _schellingAddr;",
|
||
"address _spender",
|
||
"address _to,",
|
||
"address a = address(0);",
|
||
"address a = address(2);",
|
||
"address a = address(c);",
|
||
"address a = address(this);",
|
||
"address a = g();",
|
||
"address a = h();",
|
||
"address a = msg.sender;",
|
||
"address a = this;",
|
||
"address a1 = msg.sender;",
|
||
"address a;",
|
||
"address addr;",
|
||
"address addr_1;",
|
||
"address addr_2;",
|
||
"address admin;",
|
||
"address arg;",
|
||
"address b = 0x0123456789012345678901234567890123456789;",
|
||
"address b = a;",
|
||
"address b = g();",
|
||
"address b = g.address;",
|
||
"address b = msg.sender;",
|
||
"address b;",
|
||
"address c = a;",
|
||
"address c = address(this);",
|
||
"address constant a = address(0);",
|
||
"address constant e = 0x1212121212121212121212121000002134593163;",
|
||
"address constant payable b = address(0);",
|
||
"address constant public MY_ADDRESS = 0xE0f5206BBD039e7b0592d8918820024e2a7437b9;",
|
||
"address constant x = 0x1212121212121212121212121212121212121212;",
|
||
"address constant x = msg.sender;",
|
||
"address creator;",
|
||
"address d = b;",
|
||
"address destination;",
|
||
"address indexed _owner,",
|
||
"address indexed _spender,",
|
||
"address indexed creator,",
|
||
"address milestoneLeadLink;",
|
||
"address not_constant = msg.sender;",
|
||
"address oracle = ecrecover(descriptionHash, v, r, s);",
|
||
"address owner;",
|
||
"address payable _addr;",
|
||
"address payable _curator,",
|
||
"address payable _from,",
|
||
"address payable _newCurator",
|
||
"address payable _recipient,",
|
||
"address payable a = address payable(this);",
|
||
"address payable a = address(0);",
|
||
"address payable a = address(this);",
|
||
"address payable a = m[arg];",
|
||
"address payable a = this;",
|
||
"address payable a;",
|
||
"address payable addr;",
|
||
"address payable b = 0x0123456789012345678901234567890123456789;",
|
||
"address payable b;",
|
||
"address payable c = a;",
|
||
"address payable constant a = address(0);",
|
||
"address payable constant b = address(0);",
|
||
"address payable constant e = 0x1212121212121212121212121212121212121212;",
|
||
"address payable constant ee = e;",
|
||
"address payable creator;",
|
||
"address payable d ;",
|
||
"address payable d = b;",
|
||
"address payable p = payable(msg.sender);",
|
||
"address payable p = payable(this);",
|
||
"address payable public b;",
|
||
"address payable public curator;",
|
||
"address payable public exchangeAddress;",
|
||
"address payable public foundationAddress;",
|
||
"address payable public icoAddr;",
|
||
"address payable public moduleHandlerAddress;",
|
||
"address payable public owner;",
|
||
"address payable public premiumAddr;",
|
||
"address payable public tokenAddr;",
|
||
"address payable q = payable(address(msg.sender));",
|
||
"address payable q = payable(address(this));",
|
||
"address payable q = payable;",
|
||
"address payable recipient;",
|
||
"address payable z = address(y);",
|
||
"address payable;",
|
||
"address payable[] a;",
|
||
"address payable[] b;",
|
||
"address payable[] c;",
|
||
"address payable[] memory a = new address payable[](4);",
|
||
"address payable[] memory b;",
|
||
"address payable[] public d;",
|
||
"address payable[] storage c = a;",
|
||
"address prevOwner = owner;",
|
||
"address private _owner;",
|
||
"address private owner;",
|
||
"address provAddr;",
|
||
"address provider = clients[msg.sender].providerAddress;",
|
||
"address providerAddress;",
|
||
"address public an_address;",
|
||
"address public ch;",
|
||
"address public creator;",
|
||
"address public eventContract;",
|
||
"address public foundationAddress;",
|
||
"address public icoAddr;",
|
||
"address public icoEtcPriceAddr;",
|
||
"address public immutable user = address(0x0);",
|
||
"address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979;",
|
||
"address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E;",
|
||
"address public owner;",
|
||
"address public payable a;",
|
||
"address public privateCreation;",
|
||
"address public signer;",
|
||
"address public test = \"0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c\";",
|
||
"address pure b;",
|
||
"address pure m_b;",
|
||
"address recipient,",
|
||
"address source;",
|
||
"address thisAddr;",
|
||
"address three = address(new ContractWithFunctionNotCalled());",
|
||
"address view a;",
|
||
"address view m_a;",
|
||
"address view[] m_c;",
|
||
"address x = 0xA0bFc97E48458494Ccd857e1A85DC91F7F0046E;",
|
||
"address x = 0xFA0bFc97E48458494Ccd857e1A85DC91F7F0046E0;",
|
||
"address x = 0xFA0bFc97E48458494Ccd857e1A85DC91F7F0046E;",
|
||
"address x = 0xfa0bfc97e48458494ccd857e1a85dc91f7f0046e;",
|
||
"address x;",
|
||
"address z = address(y);",
|
||
"address z = ecrecover(bytes32(uint256(1)), uint8(2), bytes32(uint256(3)), bytes32(uint256(4)));",
|
||
"address(0).balance = 7;",
|
||
"address(0x12).call(\"abc\");",
|
||
"address(0x12).callcode;",
|
||
"address(0x12).call{value: 2}(\"abc\");",
|
||
"address(0x12).delegatecall(\"abc\");",
|
||
"address(0x12).send(1);",
|
||
"address(10).delegatecall{value: 7, gas: 3}(\"\");",
|
||
"address(a).transfer(1 wei);",
|
||
"address(a).transfer(100 ether);",
|
||
"address(a).transfer(100);",
|
||
"address(extraBalance).call{value: msg.value - token}(\"\");",
|
||
"address(this).call(\"123\");",
|
||
"address(this).send(10);",
|
||
"address(this).transfer(1);",
|
||
"address(this).transfer(10);",
|
||
"address(this).transfer;",
|
||
"addressArray.pop();",
|
||
"addressArray.push();",
|
||
"address[] addressArray;",
|
||
"address[] b;",
|
||
"address[] memory b = new address[](4);",
|
||
"address[] memory confirmationsTemp = new address[](owners.length);",
|
||
"address[] public owners;",
|
||
"address[] storage d = b;",
|
||
"adminReward = reward - providerReward;",
|
||
"affilateAddress = address(0x00);",
|
||
"affiliate[affilateAddress].paid = safeAdd(affiliate[affilateAddress].paid, extra);",
|
||
"affiliate[affilateAddress].weight = safeAdd(affiliate[affilateAddress].weight, _reward);",
|
||
"afterPrepareVote,",
|
||
"afterSendVoteBad",
|
||
"afterSendVoteOk,",
|
||
"allowance[owner][spender].amount = amount;",
|
||
"allowance[owner][spender].nonce = nonce;",
|
||
"allowances[from][msg.sender] -= value;",
|
||
"allowances[msg.sender][spender] = value;",
|
||
"allowedRecipients[_recipient] = _allowed;",
|
||
"allowedRecipients[address(this)] = true;",
|
||
"allowedRecipients[curator] = true;",
|
||
"allowed[_from][msg.sender] -= _amount;",
|
||
"allowed[_from][msg.sender] -= _value;",
|
||
"allowed[msg.sender][_spender] = _amount;",
|
||
"allowed[msg.sender][_spender] = _value;",
|
||
"along with the DAO. If not, see <http:",
|
||
"amount += _tamount;",
|
||
"amount = maxAmount;",
|
||
"amount = totalAmount.mul(outcomeAmounts[msg.sender][frontRunner]) / totalOutcomeAmounts[frontRunner];",
|
||
"an_address = address(0x1337);",
|
||
"and has a line-breaking comment.*/",
|
||
"and the extraBalance accounts.",
|
||
"and 😈\";",
|
||
"announcementID = opponents[msg.sender][a];",
|
||
"announcementType Type;",
|
||
"announcementsLength++;",
|
||
"announcements[announcementID].oppositionWeight = safeAdd(announcements[a].oppositionWeight, value);",
|
||
"announcements[announcementID].oppositionWeight = safeSub(announcements[a].oppositionWeight, value);",
|
||
"announcements[announcementsLength].Type = Type;",
|
||
"announcements[announcementsLength]._addr = _addr;",
|
||
"announcements[announcementsLength]._str = _str;",
|
||
"announcements[announcementsLength]._uint = _uint;",
|
||
"announcements[announcementsLength].announcement = Announcement;",
|
||
"announcements[announcementsLength].end = block.number + minAnnouncementDelay;",
|
||
"announcements[announcementsLength].end = block.number + minAnnouncementDelayOnICO;",
|
||
"announcements[announcementsLength].link = Link;",
|
||
"announcements[announcementsLength].open = true;",
|
||
"announcements[announcementsLength].oppositable = Oppositable;",
|
||
"announcements[announcementsLength].oppositionWeight = 0;",
|
||
"announcements[announcementsLength].result = false;",
|
||
"announcements[announcementsLength].start = block.number;",
|
||
"announcements[id].Type == announcementType.providerGasProtect ||",
|
||
"announcements[id].Type == announcementType.providerInterestMinFunds ||",
|
||
"announcements[id].Type == announcementType.providerPrivateClientLimit ||",
|
||
"announcements[id].Type == announcementType.providerPrivateFunds ||",
|
||
"announcements[id].Type == announcementType.providerPrivateMaxRate ||",
|
||
"announcements[id].Type == announcementType.providerPrivateMinRate ||",
|
||
"announcements[id].Type == announcementType.providerPublicMaxRate ||",
|
||
"announcements[id].Type == announcementType.providerPublicMinRate ||",
|
||
"announcements[id].Type == announcementType.providerRentRate ) {",
|
||
"announcements[id].Type == announcementType.schellingCheckAboves ||",
|
||
"announcements[id].Type == announcementType.schellingCheckRounds ||",
|
||
"announcements[id].Type == announcementType.schellingRate ) {",
|
||
"announcements[id].Type == announcementType.transactionFeeBurn ) {",
|
||
"announcements[id].Type == announcementType.transactionFeeMax ||",
|
||
"announcements[id].Type == announcementType.transactionFeeMin ||",
|
||
"announcements[id].end = block.number;",
|
||
"announcements[id].open = false;",
|
||
"announcements[id].oppositionWeight += _balance;",
|
||
"announcements[id].result = true;",
|
||
"applyShift(leftByteShift, 3);",
|
||
"arbitrator = _arbitrator;",
|
||
"arbitrator = _newArbitrator;",
|
||
"argumentEncoding,",
|
||
"arr = arr2;",
|
||
"arr = marr;",
|
||
"arr2 = arr;",
|
||
"arr2[2] = 3;",
|
||
"arr[0] = 31; arr[2] = 84;",
|
||
"arr[0] = a;",
|
||
"arr[0] = input;",
|
||
"arr[1] = ++input;",
|
||
"arr[1] = b;",
|
||
"arr[1];",
|
||
"arr[2] = ++input;",
|
||
"arr[2] = c;",
|
||
"arr[2][333] = 444;",
|
||
"arr[3] = ++input;",
|
||
"arr[3] = d;",
|
||
"arr[4] = ++input;",
|
||
"arr[4] = e;",
|
||
"arr[5] = arr[8];",
|
||
"arr[a][b]();",
|
||
"arr[i] = new function() external returns (uint)[](m);",
|
||
"arr[i] = new function() internal returns (uint)[](m);",
|
||
"arr[m]();",
|
||
"arr[start:end];",
|
||
"array.push() = bytes1(uint8(i));",
|
||
"array.push() = value;",
|
||
"array.push().x = y;",
|
||
"array.push();",
|
||
"array2d.push().push() = value;",
|
||
"array2d.push().push().push();",
|
||
"array2d.push().push();",
|
||
"array2d.push();",
|
||
"array2d[0][0] = 42;",
|
||
"array2d[2].push();",
|
||
"arrayData = new uint256[](9);",
|
||
"arrayData[2] = 5;",
|
||
"arrayData[7] = 4;",
|
||
"array[0] = 1;",
|
||
"array[0] = 42;",
|
||
"array[i] = i + 1;",
|
||
"array[p] *= array[p] + x;",
|
||
"array[p] += array[p] + x;",
|
||
"array[p] -= array[p] - x;",
|
||
"array[p] /= array[p] / x;",
|
||
"array[p] = 100;",
|
||
"array[p] = 10;",
|
||
"array[p] = 200;",
|
||
"array[x] = 200;",
|
||
"array[x] = 2;",
|
||
"array[x] = 5;",
|
||
"assembly",
|
||
"assembly \"evmasm\" {}",
|
||
"assembly \"failasm\" {}",
|
||
"assembly {",
|
||
"assembly { a := 0x12345678 }",
|
||
"assembly { b := 0xffff }",
|
||
"assembly { b := and(mload(ptr), 0xFF) }",
|
||
"assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }",
|
||
"assembly { check := iszero(val) }",
|
||
"assembly { for {} 1 { pop(sload(0)) } { break continue } }",
|
||
"assembly { for {} 1 { pop(sload(0)) } { } pop(gas()) }",
|
||
"assembly { function f() { leave } }",
|
||
"assembly { function g() { pop(blockhash(20)) } g() }",
|
||
"assembly { function g() { pop(blockhash(20)) } }",
|
||
"assembly { hash := extcodehash(d) }",
|
||
"assembly { hash := keccak256(needleptr, needlelen) }",
|
||
"assembly { let x := \"abc\" }",
|
||
"assembly { let x := s.offset let y := mul(s.slot, 2) }",
|
||
"assembly { mstore(keccak256(0, 20), mul(s.slot, 2)) }",
|
||
"assembly { mstore(s, a) }",
|
||
"assembly { needledata := and(mload(needleptr), mask) }",
|
||
"assembly { pop(call(0, 1, 2, 3, 4, 5, 6)) }",
|
||
"assembly { pop(call(gas(), 1, 2, 3, 4, 5, 6)) }",
|
||
"assembly { pop(s.slot) }",
|
||
"assembly { pop(x) }",
|
||
"assembly { ptrdata := and(mload(ptr), mask) }",
|
||
"assembly { r := calldataload(4) }",
|
||
"assembly { r := x }",
|
||
"assembly { retptr := add(ret, 32) }",
|
||
"assembly { revert(add(revertMsg, 0x20), mload(revertMsg)) }",
|
||
"assembly { s_ptr := s.slot }",
|
||
"assembly { switch 0 case 0 {} default {} }",
|
||
"assembly { testHash := keccak256(ptr, needlelen) }",
|
||
"assembly { word:= mload(mload(add(self, 32))) }",
|
||
"assembly { x := 0x0100 }",
|
||
"assembly { x := 0x0101 }",
|
||
"assembly { x := 0x80 }",
|
||
"assembly { x := 0xffff0001 }",
|
||
"assembly { x := 7 }",
|
||
"assembly { x := a }",
|
||
"assembly { x := caller() }",
|
||
"assembly { x := not(0xFF) }",
|
||
"assembly { x, y := 7 }",
|
||
"assembly { y := 0x0101 }",
|
||
"assembly { y := create(value, add(c, 0x20), mload(c)) }",
|
||
"assembly { y := shl(2, x) }",
|
||
"assembly { ys := y.slot }",
|
||
"assembly { z := e }",
|
||
"assembly { {} }",
|
||
"assembly { }",
|
||
"assert(",
|
||
"assert( a + b > a );",
|
||
"assert( a - b < a );",
|
||
"assert( genesisAddr.length == genesisValue.length );",
|
||
"assert(!(x && y) || z);",
|
||
"assert(!b);",
|
||
"assert(!f);",
|
||
"assert(!success);",
|
||
"assert(!x || a > 0);",
|
||
"assert(!x || b > 0);",
|
||
"assert(!x);",
|
||
"assert(!xor_x_y || a > 0);",
|
||
"assert((y % 2) == 0);",
|
||
"assert(-1 & -1 == -1);",
|
||
"assert(-1 & 127 == 127);",
|
||
"assert(-1 & 3 == 3);",
|
||
"assert(-x == x);",
|
||
"assert(0 <= x && x <= 2);",
|
||
"assert(1 & 0 != 0);",
|
||
"assert(C.a == 0);",
|
||
"assert(TON == 1000);",
|
||
"assert(TON == 2000);",
|
||
"assert(_a == D.Left);",
|
||
"assert(_d == E.Left);",
|
||
"assert(_x == y);",
|
||
"assert(_x == z);",
|
||
"assert(a != address(0));",
|
||
"assert(a != b);",
|
||
"assert(a * a == b);",
|
||
"assert(a < 20);",
|
||
"assert(a == \"0123456\");",
|
||
"assert(a == \"1234567\");",
|
||
"assert(a == 0);",
|
||
"assert(a == 1);",
|
||
"assert(a == 112);",
|
||
"assert(a == 2);",
|
||
"assert(a == 3);",
|
||
"assert(a == 4);",
|
||
"assert(a == 5);",
|
||
"assert(a == a1);",
|
||
"assert(a == a2);",
|
||
"assert(a == address(0));",
|
||
"assert(a == address(d));",
|
||
"assert(a == address(this));",
|
||
"assert(a == b);",
|
||
"assert(a == c && b == d);",
|
||
"assert(a == x + 1);",
|
||
"assert(a == x + 2);",
|
||
"assert(a == x + 5);",
|
||
"assert(a == x);",
|
||
"assert(a > 0);",
|
||
"assert(a > 0x0000000000000000000000000000000000000000 && b);",
|
||
"assert(a > 1);",
|
||
"assert(a >= 3);",
|
||
"assert(a.balance == 600);",
|
||
"assert(a.balance == 700);",
|
||
"assert(a.balance > b.balance);",
|
||
"assert(a.length == b.length);",
|
||
"assert(a1 != a2);",
|
||
"assert(a1 == a2);",
|
||
"assert(a[0] == 2 || cc[0][0] == 50 || eee[0][0][0] == 50);",
|
||
"assert(a[0] == 2);",
|
||
"assert(a[0] == 900);",
|
||
"assert(a[0].length == 0);",
|
||
"assert(a[0][0] == 16);",
|
||
"assert(a[0][a[0].length - 1] == 8);",
|
||
"assert(a[0][a[0].length - 1] == y);",
|
||
"assert(a[1] == 0);",
|
||
"assert(a[1] == b[1]);",
|
||
"assert(a[1][1] == 0);",
|
||
"assert(a[2] == 0);",
|
||
"assert(a[2] == x[2] && a[2] != y[2]);",
|
||
"assert(a[2] == y[2] && a[2] != x[2]);",
|
||
"assert(a[2][3] == 0);",
|
||
"assert(a[a.length - 1] == 0);",
|
||
"assert(a[a.length - 1] == 100);",
|
||
"assert(a[a.length - 1] == x);",
|
||
"assert(a[a.length - 1][0] == 0);",
|
||
"assert(a[a.length - 1][0] == 100);",
|
||
"assert(a[i] == b[i]);",
|
||
"assert(a[x] == 2);",
|
||
"assert(a[y] == 0);",
|
||
"assert(a[y] == 4);",
|
||
"assert(address(c) == a);",
|
||
"assert(address(c) == address(c));",
|
||
"assert(arr.length != y);",
|
||
"assert(arr.length != z);",
|
||
"assert(arr.length == arr2.length);",
|
||
"assert(arr.length == g().length);",
|
||
"assert(arr.length == y);",
|
||
"assert(arr.length == z);",
|
||
"assert(arr2.length == arr.length);",
|
||
"assert(arr2[0].length == arr[0].length);",
|
||
"assert(arr[2].length != x);",
|
||
"assert(arr[2].length == x);",
|
||
"assert(arr[3].length != y);",
|
||
"assert(arr[3].length == y);",
|
||
"assert(arr[5].length != t);",
|
||
"assert(arr[5].length == t);",
|
||
"assert(array2d.length > 0);",
|
||
"assert(array2d.length > 2);",
|
||
"assert(array2d[0][0] == 42);",
|
||
"assert(array2d[2].length > 0);",
|
||
"assert(array2d[array2d.length - 1].length > 0);",
|
||
"assert(array2d[array2d.length - 1].length > 3);",
|
||
"assert(array2d[array2d.length - 1][last - 1].length > 0);",
|
||
"assert(array2d[array2d.length - 1][last - 1].length > 4);",
|
||
"assert(array[0] == 1);",
|
||
"assert(array[0] == 42);",
|
||
"assert(array[p] < 110);",
|
||
"assert(array[p] < 300);",
|
||
"assert(array[p] < 50);",
|
||
"assert(array[p] < 90);",
|
||
"assert(array[p] <= 190);",
|
||
"assert(array[p] == 0);",
|
||
"assert(array[p] == x);",
|
||
"assert(array[p] >= 0);",
|
||
"assert(array[t][w][v] > 100);",
|
||
"assert(array[t][w][v] > 300);",
|
||
"assert(array[x] == 3);",
|
||
"assert(array[x] == 4);",
|
||
"assert(array[y] > 100);",
|
||
"assert(array[y] > 300);",
|
||
"assert(array[z][t] > 100);",
|
||
"assert(array[z][t] > 300);",
|
||
"assert(b < 3);",
|
||
"assert(b == 10 && a == 11);",
|
||
"assert(b == 17 && a == 28);",
|
||
"assert(b == (a < 0x0000000000000000000000000000000000000200));",
|
||
"assert(b == 0x12);",
|
||
"assert(b == 0x1234);",
|
||
"assert(b == 0x12340000);",
|
||
"assert(b == 0x5678);",
|
||
"assert(b == address(0));",
|
||
"assert(b == x + 10);",
|
||
"assert(b == x + 5);",
|
||
"assert(b == x + x + 2);",
|
||
"assert(b == x);",
|
||
"assert(b > 4);",
|
||
"assert(b);",
|
||
"assert(b1 != b2);",
|
||
"assert(b1 == b2);",
|
||
"assert(b1[0] == 1);",
|
||
"assert(b1[1] == b2[1]);",
|
||
"assert(b1[1] == b2[2]);",
|
||
"assert(b[0] == 1);",
|
||
"assert(b[0] == 42);",
|
||
"assert(b[0] == 900);",
|
||
"assert(b[0] == c[0]);",
|
||
"assert(b[b.length - 1] == 8);",
|
||
"assert(b[y][x] == 0);",
|
||
"assert(block.difficulty == block.gaslimit);",
|
||
"assert(block.difficulty == difficulty);",
|
||
"assert(block.number == block.timestamp);",
|
||
"assert(block.timestamp > 10);",
|
||
"assert(blockhash(2) > 0);",
|
||
"assert(blockhash(x) == blockhash(y));",
|
||
"assert(blockhash(x) > 0);",
|
||
"assert(bytes(s1).length == bytes(s2).length);",
|
||
"assert(c == 0);",
|
||
"assert(c == 0x12340000);",
|
||
"assert(c == 1);",
|
||
"assert(c == 4);",
|
||
"assert(c == d);",
|
||
"assert(c == e);",
|
||
"assert(c == msg.sender);",
|
||
"assert(c > 0);",
|
||
"assert(c >= 0);",
|
||
"assert(c.a[0] > 0);",
|
||
"assert(c.a[0][0] > 0);",
|
||
"assert(c.a[0][0][0] > 0);",
|
||
"assert(c[0] == 42);",
|
||
"assert(c[0] > 0);",
|
||
"assert(c[0].a[0][0] > 0);",
|
||
"assert(c[0][0] > 0);",
|
||
"assert(c[0][0][0] == 12);",
|
||
"assert(c[0][0][0] > 0);",
|
||
"assert(c[1] == 2);",
|
||
"assert(cc[0][0] == 42);",
|
||
"assert(d != _a);",
|
||
"assert(d != _d);",
|
||
"assert(d == 0x34);",
|
||
"assert(d == 13);",
|
||
"assert(d == _b);",
|
||
"assert(d[0] == 42);",
|
||
"assert(d[5] == 7);",
|
||
"assert(data[0] == 234);",
|
||
"assert(data[1] == 123);",
|
||
"assert(dd[0][0] == 10);",
|
||
"assert(dd[0][0] == 42);",
|
||
"assert(e == 0x12);",
|
||
"assert(eee[0][0][0] == 42);",
|
||
"assert(f1() == \"abc\");",
|
||
"assert(f1() == \"cde\");",
|
||
"assert(false);",
|
||
"assert(g < gasleft());",
|
||
"assert(g == h);",
|
||
"assert(g >= gasleft());",
|
||
"assert(g(2) == h(2));",
|
||
"assert(gasleft() > 0);",
|
||
"assert(gasleft() > 100);",
|
||
"assert(hash == keccak256(type(D).runtimeCode));",
|
||
"assert(last > 0);",
|
||
"assert(last > 3);",
|
||
"assert(localMap[0] == 0);",
|
||
"assert(map[0] == 0);",
|
||
"assert(map[0] == 42);",
|
||
"assert(map[0] == map[1]);",
|
||
"assert(map[0].length == map[1].length);",
|
||
"assert(map[2] == x);",
|
||
"assert(map[p] < 110);",
|
||
"assert(map[p] < 300);",
|
||
"assert(map[p] < 50);",
|
||
"assert(map[p] < 90);",
|
||
"assert(map[p] <= 190);",
|
||
"assert(map[p] == 0);",
|
||
"assert(map[p] == x);",
|
||
"assert(map[p] >= 0);",
|
||
"assert(map[x] == 3);",
|
||
"assert(map[x] == 4);",
|
||
"assert(map[x] == map[y]);",
|
||
"assert(map[x].length == map[y].length);",
|
||
"assert(map[x][0].length == map[y][0].length);",
|
||
"assert(marr.length == arr.length);",
|
||
"assert(msg.data.length > 0);",
|
||
"assert(msg.sender == block.coinbase);",
|
||
"assert(msg.sig == 0x00000000);",
|
||
"assert(off == 0);",
|
||
"assert(off1 == 0);",
|
||
"assert(off2 == 2);",
|
||
"assert(oldX == x);",
|
||
"assert(owner == address(0) || y != z);",
|
||
"assert(prevOwner == owner);",
|
||
"assert(s > 0);",
|
||
"assert(s.d == D.Left);",
|
||
"assert(s.length == 3);",
|
||
"assert(s.x == 0);",
|
||
"assert(s1.arr.length == s2.arr.length);",
|
||
"assert(s1.arr[0].length == s2.arr[0].length);",
|
||
"assert(severalMaps3d[0][0][0] == 42);",
|
||
"assert(severalMaps8[0][0] == 42);",
|
||
"assert(severalMaps[0][0] == 42);",
|
||
"assert(sig_1 == sig_2);",
|
||
"assert(startGas > gasleft());",
|
||
"assert(success);",
|
||
"assert(thisAddr == address(this));",
|
||
"assert(tinyArray[0] == 42);",
|
||
"assert(true);",
|
||
"assert(tx.gasprice == msg.value);",
|
||
"assert(tx.origin == msg.sender);",
|
||
"assert(v == 1);",
|
||
"assert(v > 0);",
|
||
"assert(v1 == \"abc\");",
|
||
"assert(v2 == \"cde\");",
|
||
"assert(val == true);",
|
||
"assert(val[0].vals.length == 42);",
|
||
"assert(value == 0);",
|
||
"assert(x != 2);",
|
||
"assert(x != 8);",
|
||
"assert(x != g());",
|
||
"assert(x != map[2]);",
|
||
"assert(x != map[a]);",
|
||
"assert(x != map[x]);",
|
||
"assert(x != y);",
|
||
"assert(x & y != 0);",
|
||
"assert(x & y == 0x0000);",
|
||
"assert(x & y == 0xff);",
|
||
"assert(x & y == 0xffff);",
|
||
"assert(x & y == 127);",
|
||
"assert(x & y == 3);",
|
||
"assert(x + 2 > block.number);",
|
||
"assert(x / y == -3);",
|
||
"assert(x / y == 3);",
|
||
"assert(x < 10);",
|
||
"assert(x < 1000);",
|
||
"assert(x < 11);",
|
||
"assert(x < 14);",
|
||
"assert(x < 2);",
|
||
"assert(x < 40);",
|
||
"assert(x < 9);",
|
||
"assert(x <= 10 && x > 2);",
|
||
"assert(x == 0);",
|
||
"assert(x == 1);",
|
||
"assert(x == 10);",
|
||
"assert(x == 102);",
|
||
"assert(x == 14);",
|
||
"assert(x == 2);",
|
||
"assert(x == 3);",
|
||
"assert(x == 4);",
|
||
"assert(x == 5);",
|
||
"assert(x == 7);",
|
||
"assert(x == 8);",
|
||
"assert(x == g());",
|
||
"assert(x == map[13][14]);",
|
||
"assert(x == map[13][14][15]);",
|
||
"assert(x == map[2]);",
|
||
"assert(x == map[s]);",
|
||
"assert(x == y + 1);",
|
||
"assert(x == y);",
|
||
"assert(x > 0);",
|
||
"assert(x > 1);",
|
||
"assert(x > 10);",
|
||
"assert(x > 15);",
|
||
"assert(x > 2);",
|
||
"assert(x > 8);",
|
||
"assert(x > 9);",
|
||
"assert(x >= 10);",
|
||
"assert(x >= 15);",
|
||
"assert(x >= 17);",
|
||
"assert(x >= 20);",
|
||
"assert(x || y);",
|
||
"assert(x);",
|
||
"assert(x.length == 35);",
|
||
"assert(x.length == y.length);",
|
||
"assert(x1 == x2);",
|
||
"assert(x[0] == 42 || x[0] == 23);",
|
||
"assert(x[0] == 42);",
|
||
"assert(x[0].length == 0);",
|
||
"assert(x[10].length == 0);",
|
||
"assert(x[4].length == 0);",
|
||
"assert(x[a] == b);",
|
||
"assert(x[i] == y[i]);",
|
||
"assert(y != \"testx\");",
|
||
"assert(y < 1000);",
|
||
"assert(y < 10000);",
|
||
"assert(y < 110);",
|
||
"assert(y < 300);",
|
||
"assert(y < 4);",
|
||
"assert(y < 50);",
|
||
"assert(y < 90);",
|
||
"assert(y <= 190);",
|
||
"assert(y == \"testx\");",
|
||
"assert(y == -128);",
|
||
"assert(y == -2);",
|
||
"assert(y == -56);",
|
||
"assert(y == 0);",
|
||
"assert(y == 1 && x == 3);",
|
||
"assert(y == 1);",
|
||
"assert(y == 127);",
|
||
"assert(y == 16);",
|
||
"assert(y == 2);",
|
||
"assert(y == 254);",
|
||
"assert(y == 255);",
|
||
"assert(y == 3);",
|
||
"assert(y == 4);",
|
||
"assert(y == 44);",
|
||
"assert(y == 999);",
|
||
"assert(y == x);",
|
||
"assert(y > 0);",
|
||
"assert(y > 1000);",
|
||
"assert(y >= 0);",
|
||
"assert(y >= 10);",
|
||
"assert(y >= 15);",
|
||
"assert(y >= 20);",
|
||
"assert(y[0].length == 0);",
|
||
"assert(y[10].length == 0);",
|
||
"assert(y[4].length == 0);",
|
||
"assert(z < 1000);",
|
||
"assert(z < 100_000);",
|
||
"assert(z < 150);",
|
||
"assert(z < y);",
|
||
"assert(z == \"test\");",
|
||
"assert(z == -1);",
|
||
"assert(z == _y);",
|
||
"assert(z == x + 1);",
|
||
"assert(z == y);",
|
||
"assert(z1 == z2);",
|
||
"atStage(Stages.AuctionFailed)",
|
||
"atStage(Stages.AuctionStarted)",
|
||
"atStage(Stages.AuctionSuccessful)",
|
||
"atStage(Stages.MarketClosed)",
|
||
"atStage(Stages.MarketCreated)",
|
||
"atStage(Stages.MarketFunded)",
|
||
"authorizePayment(_idMilestone);",
|
||
"b := 0xff0fff0fff",
|
||
"b := 2",
|
||
"b := 8",
|
||
"b := 9",
|
||
"b := fac(a)",
|
||
"b := i",
|
||
"b := mload(otherptr)",
|
||
"b := myAwesomeFunction(30)",
|
||
"b := tmp2",
|
||
"b := z",
|
||
"b = (f() == 0) || (f() > 0);",
|
||
"b = (f() > 0) || (f() > 0);",
|
||
"b = (m[0] == 0x0101);",
|
||
"b = (word / divisor) & 0xFF;",
|
||
"b = -uint8(a) * 2;",
|
||
"b = 0x9876543210987654321098765432109876543210;",
|
||
"b = 0x9876_5432_1098_7654_3210_9876_5432_1098_7654_3210;",
|
||
"b = 2 ether;",
|
||
"b = 2;",
|
||
"b = 3;",
|
||
"b = 4;",
|
||
"b = 5;",
|
||
"b = 9;",
|
||
"b = ActionChoices(a);",
|
||
"b = ActionChoices.Sit;",
|
||
"b = L.g.selector;",
|
||
"b = _b;",
|
||
"b = a + c;",
|
||
"b = a + x;",
|
||
"b = a;",
|
||
"b = address(0);",
|
||
"b = bytes(_s);",
|
||
"b = c;",
|
||
"b = data2[2];",
|
||
"b = f() > 0;",
|
||
"b = false;",
|
||
"b = m[0].b;",
|
||
"b = m_b;",
|
||
"b = msg.data[:];",
|
||
"b = s.b;",
|
||
"b = s1.b;",
|
||
"b = s[0].b;",
|
||
"b = s[1];",
|
||
"b = this.f;",
|
||
"b = this.h;",
|
||
"b = true;",
|
||
"b = twodim[2][3];",
|
||
"b = uint64(ActionChoices.Sit);",
|
||
"b = x + 10;",
|
||
"b = x;",
|
||
"b = x[i].length;",
|
||
"b.WeMustNotReachHere();",
|
||
"b.a.f();",
|
||
"b.push();",
|
||
"b.push(8);",
|
||
"b.transfer(100);",
|
||
"b.transfer(1000);",
|
||
"b0 := byte(0, mload(memPtr))",
|
||
"b0 := byte(0, mload(start))",
|
||
"b0 = s.b[0];",
|
||
"b1 := byte(1, mload(memPtr))",
|
||
"b1 = b2;",
|
||
"b1 = s.b[1];",
|
||
"b1 = x + a;",
|
||
"b1; b2; b3; b4; b5; b6; b7; b8;",
|
||
"b1; b2; b3; b4; b8;",
|
||
"b1; b2; b3; b4; b8; b16; b32;",
|
||
"b1[0] = 1;",
|
||
"b2 = x + a;",
|
||
"b;",
|
||
"b[-1];",
|
||
"b[0] = 0;",
|
||
"b[0] = 1;",
|
||
"b[0] = 32;",
|
||
"b[0] = 42;",
|
||
"b[0] = 6;",
|
||
"b[0] = 900;",
|
||
"b[0].length,",
|
||
"b[1] = 7;",
|
||
"b[1] = x;",
|
||
"b[64];",
|
||
"b[888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888];",
|
||
"b[];",
|
||
"b[b.length - 1][key] = value;",
|
||
"b[i] = i + 1;",
|
||
"b[uint8(x[2])];",
|
||
"b[x][y] = v;",
|
||
"b[x][y] = z;",
|
||
"balance = msg.value;",
|
||
"balance(3);",
|
||
"balance; callSuc; delegatecallSuc; sendRet;",
|
||
"balanceOf[owner] = safeAdd(balanceOf[owner], value);",
|
||
"balanceOf[owner] = safeSub(balanceOf[owner], value);",
|
||
"balances[_for] = balances[_for].add(outcomeTokenCount);",
|
||
"balances[_for] = balances[_for].sub(outcomeTokenCount);",
|
||
"balances[_from] -= _amount;",
|
||
"balances[_from] -= _value;",
|
||
"balances[_to] += _amount;",
|
||
"balances[_to] += _value;",
|
||
"balances[_tokenHolder] += token;",
|
||
"balances[from] -= value;",
|
||
"balances[msg.sender] -= _amount;",
|
||
"balances[msg.sender] -= _value;",
|
||
"balances[msg.sender] -= amount;",
|
||
"balances[msg.sender] -= value;",
|
||
"balances[msg.sender] = 0;",
|
||
"balances[msg.sender] = balances[msg.sender].add(msg.value);",
|
||
"balances[msg.sender] = balances[msg.sender].sub(value);",
|
||
"balances[receiver] += amount;",
|
||
"balances[to] += value;",
|
||
"base = dataBase;",
|
||
"base b;",
|
||
"base,",
|
||
"big y;",
|
||
"bla = x;",
|
||
"block := 1",
|
||
"block.timestamp + splitExecutionPeriod,",
|
||
"blockNumber = _blockNumber;",
|
||
"blocked[_account] = 0;",
|
||
"blocked[msg.sender] = _proposalID;",
|
||
"bool public isICO;",
|
||
"bool public isICO = true;",
|
||
"bool Aboola;",
|
||
"bool Aboolc;",
|
||
"bool _empty;",
|
||
"bool _found;",
|
||
"bool _newCurator",
|
||
"bool _supportsProposal",
|
||
"bool a = rightForInterest(oldValue, priv);",
|
||
"bool a;",
|
||
"bool b = (f() == 0) && (f() == 0);",
|
||
"bool b = (f() > 0) && (f() > 0);",
|
||
"bool b = (f() > 0) || (f() > 0);",
|
||
"bool b = (f() > 1) || (f() > 1);",
|
||
"bool b = a;",
|
||
"bool b = rightForInterest(newValue, priv);",
|
||
"bool b = true;",
|
||
"bool b;",
|
||
"bool c;",
|
||
"bool confirmed = isConfirmed(transactionId);",
|
||
"bool constant LEN = true;",
|
||
"bool constant b = true;",
|
||
"bool constant c = nc;",
|
||
"bool constant c = this;",
|
||
"bool constant d = true;",
|
||
"bool constant dd = d;",
|
||
"bool d;",
|
||
"bool e;",
|
||
"bool empty;",
|
||
"bool equal = true;",
|
||
"bool equal;",
|
||
"bool executed;",
|
||
"bool exists;",
|
||
"bool f;",
|
||
"bool flag;",
|
||
"bool foundEmptyArrayID = false;",
|
||
"bool interest = false;",
|
||
"bool isForRent;",
|
||
"bool isRightPadded",
|
||
"bool j = true ? true : false;",
|
||
"bool lock;",
|
||
"bool lostEverything;",
|
||
"bool lv_1;",
|
||
"bool m0;",
|
||
"bool nc = false;",
|
||
"bool newCurator,",
|
||
"bool newCurator;",
|
||
"bool ok = false;",
|
||
"bool open;",
|
||
"bool oppositable;",
|
||
"bool payable a;",
|
||
"bool priv;",
|
||
"bool proposalCheck = true;",
|
||
"bool proposalPassed;",
|
||
"bool providerHasClosed = false;",
|
||
"bool public aborted;",
|
||
"bool public campaignCanceled;",
|
||
"bool public changingMilestones;",
|
||
"bool public closed;",
|
||
"bool public flag = false;",
|
||
"bool public isFueled;",
|
||
"bool public isOutcomeSet;",
|
||
"bool public isSet;",
|
||
"bool public payOwnerOnly;",
|
||
"bool public stateBool = true;",
|
||
"bool public success;",
|
||
"bool public test = false;",
|
||
"bool result;",
|
||
"bool schellingEvent;",
|
||
"bool sendRet = addr.send(1);",
|
||
"bool sha3 = true;",
|
||
"bool success;",
|
||
"bool suicide = true;",
|
||
"bool transferEvent;",
|
||
"bool valid;",
|
||
"bool voteResult;",
|
||
"bool voted;",
|
||
"bool x = false;",
|
||
"bool x = true;",
|
||
"bool x;",
|
||
"bool xor_x_y = (x && !y) || (!x && y);",
|
||
"bool y = true;",
|
||
"bool y = x;",
|
||
"bool y;",
|
||
"bool z = x || y;",
|
||
"bool(a == 1);",
|
||
"bool[1][] m1;",
|
||
"bool[2][] flags;",
|
||
"bool[500] memory Aboolas,",
|
||
"bool[500] memory Aboolbs,",
|
||
"bool[500] memory Aboolcs",
|
||
"bool[500] memory Bboolas,",
|
||
"bool[500] memory Bboolbs",
|
||
"bool[500] memory Cboolas,",
|
||
"bool[] x_0;",
|
||
"bool[][1][1][][] memory x_1;",
|
||
"break",
|
||
"break;",
|
||
"brought[beneficiaryAddress].cor = safeAdd(brought[beneficiaryAddress].cor, _reward);",
|
||
"brought[beneficiaryAddress].eth = safeAdd(brought[beneficiaryAddress].eth, _value);",
|
||
"brought[owner].corp = safeAdd(brought[owner].corp, _reward);",
|
||
"bts = new bytes(len);",
|
||
"bug = Buggy(10, 20, 30, \"asdfghjkl\");",
|
||
"but WITHOUT ANY WARRANTY; without even the implied warranty of",
|
||
"byte a = b[3];",
|
||
"byte b = byte(0x01);",
|
||
"byte payable g;",
|
||
"byte s = b[31];",
|
||
"byte s = b[3];",
|
||
"byte y;",
|
||
"byte[0] c;",
|
||
"byte[2] memory a;",
|
||
"byte[2] memory b;",
|
||
"byte[2] memory k = true ? a : b;",
|
||
"bytes a;",
|
||
"bytes arr;",
|
||
"bytes array;",
|
||
"bytes b1 = \"\xa0\x00\";",
|
||
"bytes b3 = hex\"a000\";",
|
||
"bytes b;",
|
||
"bytes constant a = \"\x00\x01\x02\";",
|
||
"bytes constant a = \"\x03\x01\x02\";",
|
||
"bytes constant b = hex\"000102\";",
|
||
"bytes constant b = hex\"030102\";",
|
||
"bytes constant c = hex\"12_3456_789012\";",
|
||
"bytes constant c = type(B).creationCode;",
|
||
"bytes constant r = type(B).runtimeCode;",
|
||
"bytes data;",
|
||
"bytes memory _data;",
|
||
"bytes memory _transactionData",
|
||
"bytes memory _transactionData,",
|
||
"bytes memory a = \"123\";",
|
||
"bytes memory a = abi.encodePacked(S, A, A.X, T, uint, uint[]);",
|
||
"bytes memory a = new bytes(34);",
|
||
"bytes memory a = this.g(s[0]);",
|
||
"bytes memory a = type(D).creationCode;",
|
||
"bytes memory a;",
|
||
"bytes memory a; bytes memory b; bytes memory c;",
|
||
"bytes memory arg = \"abcdefg\";",
|
||
"bytes memory argumentEncoding = abi.encode(sv_0);",
|
||
"bytes memory argumentEncoding = abi.encode(sv_0, lv_1);",
|
||
"bytes memory argumentEncoding,",
|
||
"bytes memory b = this.g(m);",
|
||
"bytes memory b = type(D).runtimeCode;",
|
||
"bytes memory bts = new bytes(len);",
|
||
"bytes memory c = b;",
|
||
"bytes memory c = type(D).creationCode;",
|
||
"bytes memory d = b;",
|
||
"bytes memory e;",
|
||
"bytes memory encoded = abi.encodePacked(\"\\\\\");",
|
||
"bytes memory f;",
|
||
"bytes memory invalidEncoding = new bytes(4 + invalidLength);",
|
||
"bytes memory l = true ? e : f;",
|
||
"bytes memory m = \"tmp\";",
|
||
"bytes memory m = a[0];",
|
||
"bytes memory m1 = bytes(s1);",
|
||
"bytes memory mProposedMilestones = proposedMilestones;",
|
||
"bytes memory memBytes;",
|
||
"bytes memory s = \"abcdefghijklmn\";",
|
||
"bytes memory s = \"abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn\";",
|
||
"bytes memory test = new bytes(3);",
|
||
"bytes memory validEncoding = new bytes(4 + argumentEncoding.length);",
|
||
"bytes memory x = new bytes(200);",
|
||
"bytes memory x = new bytes(3);",
|
||
"bytes memory x = new bytes(35);",
|
||
"bytes memory x = new bytes(4);",
|
||
"bytes memory x = new bytes(5);",
|
||
"bytes memory x;",
|
||
"bytes memory y = \"def\";",
|
||
"bytes memory y = new bytes(4);",
|
||
"bytes memory y = x[1:2];",
|
||
"bytes memory y;",
|
||
"bytes memory z = new bytes(7);",
|
||
"bytes memory z = new bytes(size);",
|
||
"bytes payable h;",
|
||
"bytes public b;",
|
||
"bytes public externalData;",
|
||
"bytes public ipfsHash;",
|
||
"bytes public proposedMilestones;",
|
||
"bytes savedData;",
|
||
"bytes storage c = a;",
|
||
"bytes x;",
|
||
"bytes(x[18726387213:111111111111111111]);",
|
||
"bytes(x[18726387213:]);",
|
||
"bytes(x[:18726387213]);",
|
||
"bytes0 b0 = 1;",
|
||
"bytes1 a = x[cond ? 1 : 2]; a;",
|
||
"bytes1 a;",
|
||
"bytes1 b = bytes1(a); ",
|
||
"bytes1 b1 = 0;",
|
||
"bytes1 b1 = 0x000;",
|
||
"bytes1 b1 = 0x01;",
|
||
"bytes1 b1 = 0x0;",
|
||
"bytes1 b1 = 0x1;",
|
||
"bytes1 b1 = 1;",
|
||
"bytes1 b1 = b;",
|
||
"bytes1 b1 = bytes1(0);",
|
||
"bytes1 b1 = bytes1(0x0);",
|
||
"bytes1 b1 = bytes1(0x000);",
|
||
"bytes1 b1 = bytes1(0x01);",
|
||
"bytes1 b1 = bytes1(0x1);",
|
||
"bytes1 b1 = bytes1(1);",
|
||
"bytes1 b2 = 0x100;",
|
||
"bytes1 b2 = 0xFF;",
|
||
"bytes1 b2 = bytes1(0x100);",
|
||
"bytes1 b2 = bytes1(0xFF);",
|
||
"bytes1 b;",
|
||
"bytes1 c;",
|
||
"bytes1 public aboveChar = 0x31;",
|
||
"bytes1 public belowChar = 0x30;",
|
||
"bytes1 tmp2 = s.b;",
|
||
"bytes1 x;",
|
||
"bytes1 y;",
|
||
"bytes10 b10 = b9;",
|
||
"bytes10 c;",
|
||
"bytes10 e;",
|
||
"bytes10[6] data2;",
|
||
"bytes11 b11 = b10;",
|
||
"bytes12 b12 = b11;",
|
||
"bytes13 b13 = b12;",
|
||
"bytes14 b14 = b13;",
|
||
"bytes15 b15 = b14;",
|
||
"bytes16 b12 = 0x1;",
|
||
"bytes16 b12 = bytes16(0x1);",
|
||
"bytes16 b16 = 0;",
|
||
"bytes16 b16 = 0x0;",
|
||
"bytes16 b16 = b15;",
|
||
"bytes16 b16 = bytes16(0);",
|
||
"bytes16 b16 = bytes16(0x0);",
|
||
"bytes16 b8 = 1;",
|
||
"bytes16 b8 = bytes16(1);",
|
||
"bytes16 memory b2;",
|
||
"bytes16 storage b1;",
|
||
"bytes16 x;",
|
||
"bytes16 z = \"testz\";",
|
||
"bytes16 z;",
|
||
"bytes16[] inner;",
|
||
"bytes16[] public data;",
|
||
"bytes16[][] a;",
|
||
"bytes17 b17 = b16;",
|
||
"bytes18 b18 = b17;",
|
||
"bytes19 b19 = b18;",
|
||
"bytes2 a = \"a\";",
|
||
"bytes2 a = 0x1234;",
|
||
"bytes2 b = \"b\";",
|
||
"bytes2 b2 = 0;",
|
||
"bytes2 b2 = 0x00000;",
|
||
"bytes2 b2 = 0x0;",
|
||
"bytes2 b2 = 1;",
|
||
"bytes2 b2 = b1;",
|
||
"bytes2 b2 = bytes2(0);",
|
||
"bytes2 b2 = bytes2(0x0);",
|
||
"bytes2 b2 = bytes2(0x00000);",
|
||
"bytes2 b2 = bytes2(1);",
|
||
"bytes2 b3 = 0x0100;",
|
||
"bytes2 b3 = 0xFF;",
|
||
"bytes2 b3 = 256;",
|
||
"bytes2 b3 = bytes2(0x0100);",
|
||
"bytes2 b3 = bytes2(0xFF);",
|
||
"bytes2 b3 = bytes2(256);",
|
||
"bytes2 b4 = 0x100;",
|
||
"bytes2 b4 = 0xFFFF;",
|
||
"bytes2 b4 = bytes2(0x100);",
|
||
"bytes2 b4 = bytes2(0xFFFF);",
|
||
"bytes2 b5 = 0x10000;",
|
||
"bytes2 b5 = bytes2(0x10000);",
|
||
"bytes2 c;",
|
||
"bytes2 constant b = 0xabcd;",
|
||
"bytes2 constant bb = b;",
|
||
"bytes2 d;",
|
||
"bytes2 m = true ? c : d;",
|
||
"bytes2 x = \"aa\";",
|
||
"bytes2 x;",
|
||
"bytes2 y = bytes2(x);",
|
||
"bytes20 b20 = b19;",
|
||
"bytes20 x;",
|
||
"bytes20 y;",
|
||
"bytes21 inner;",
|
||
"bytes21 b21 = b20;",
|
||
"bytes21 x = 0x1122334455667788990011223344556677889900ff;",
|
||
"bytes22 b22 = b21;",
|
||
"bytes23 b23 = b22;",
|
||
"bytes24 b24 = b23;",
|
||
"bytes25 b25 = b24;",
|
||
"bytes256 b256 = 1;",
|
||
"bytes26 b26 = b25;",
|
||
"bytes27 b27 = b26;",
|
||
"bytes28 b28 = b27;",
|
||
"bytes29 b29 = b28;",
|
||
"bytes2[2] data1;",
|
||
"bytes2[2] memory x;",
|
||
"bytes2[2] memory y;",
|
||
"bytes3 b3 = 0;",
|
||
"bytes3 b3 = 0x0000000;",
|
||
"bytes3 b3 = 0x0;",
|
||
"bytes3 b3 = b2;",
|
||
"bytes3 b3 = bytes3(0);",
|
||
"bytes3 b3 = bytes3(0x0);",
|
||
"bytes3 b3 = bytes3(0x0000000);",
|
||
"bytes3 b4 = 1;",
|
||
"bytes3 b4 = bytes3(1);",
|
||
"bytes3 b5 = 0x010000;",
|
||
"bytes3 b5 = 65536;",
|
||
"bytes3 b5 = bytes3(0x010000);",
|
||
"bytes3 b5 = bytes3(65536);",
|
||
"bytes3 b6 = 0xFFFF;",
|
||
"bytes3 b6 = 0xFFFFFF;",
|
||
"bytes3 b6 = bytes3(0xFFFF);",
|
||
"bytes3 b6 = bytes3(0xFFFFFF);",
|
||
"bytes3 b7 = 0x10000;",
|
||
"bytes3 b7 = bytes3(0x10000);",
|
||
"bytes3 b8 = 0x1000000;",
|
||
"bytes3 b8 = bytes3(0x1000000);",
|
||
"bytes3 constant c = \"abc\";",
|
||
"bytes3 constant cc = c;",
|
||
"bytes3 constant ccc = cc;",
|
||
"bytes3 constant cccc = ccc;",
|
||
"bytes3 name;",
|
||
"bytes30 b30 = b29;",
|
||
"bytes30 sv_0;",
|
||
"bytes31 b31 = b30;",
|
||
"bytes32 _name = keccak256(bytes(name));",
|
||
"bytes32 a = keccak256(\"abcdefghijklmn\");",
|
||
"bytes32 a = keccak256(\"abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn\");",
|
||
"bytes32 a = sha256(abi.encodePacked(s, t));",
|
||
"bytes32 b13 = 0x1;",
|
||
"bytes32 b13 = bytes32(0x1);",
|
||
"bytes32 b2 = \"\xa0\x00\";",
|
||
"bytes32 b32 = 0;",
|
||
"bytes32 b32 = 0x0;",
|
||
"bytes32 b32 = b31;",
|
||
"bytes32 b32 = bytes32(0);",
|
||
"bytes32 b32 = bytes32(0x0);",
|
||
"bytes32 b9 = 1;",
|
||
"bytes32 b9 = bytes32(1);",
|
||
"bytes32 b;",
|
||
"bytes32 bytes10abc = \"abc\";",
|
||
"bytes32 c = 3.2; c;",
|
||
"bytes32 c = a; c;",
|
||
"bytes32 cent = \"aaa\u00A2aaa\";",
|
||
"bytes32 codeHash;",
|
||
"bytes32 computedHash = leaf;",
|
||
"bytes32 constant a = keccak256(abi.encode(1, 2));",
|
||
"bytes32 constant b = keccak256(abi.encodePacked(uint(1), a));",
|
||
"bytes32 constant c = keccak256(abi.encodeWithSelector(0x12345678, b, 2));",
|
||
"bytes32 constant d = keccak256(abi.encodeWithSignature(\"f()\", 1, 2));",
|
||
"bytes32 constant sc = keccak256(\"abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn\");",
|
||
"bytes32 constant st = \"abc\x00\xff__\";",
|
||
"bytes32 constant x = keccak256(\"abc\");",
|
||
"bytes32 constant y = x;",
|
||
"bytes32 creationHash = keccak256(type(D).creationCode);",
|
||
"bytes32 escapeCharacters = \"This a test",
|
||
"bytes32 escapeCharacters = \"\t\b\n\r\f\'\";",
|
||
"bytes32 escapeCharacters = \"first\" \"second\" \"third\";",
|
||
"bytes32 escapeCharacters = \"foo\" \"bar\" hex\"aa\";",
|
||
"bytes32 escapeCharacters = \"foo\" hex\"aa\" unicode\"😃, 😭, and 😈\" \"!\" hex\"00\";",
|
||
"bytes32 escapeCharacters = \"text \";",
|
||
"bytes32 escapeCharacters = hex\"0000\"",
|
||
"bytes32 escapeCharacters = hex\"aa\" hex\"b\";",
|
||
"bytes32 escapeCharacters = hex\"aa\" hex\"bb\" \"cc\";",
|
||
"bytes32 escapeCharacters = unicode\"foo\" unicode\"😃, 😭, and 😈\" unicode\"!\";",
|
||
"bytes32 eur = \"aaa\u20ACaaa\";",
|
||
"bytes32 eventHash = keccak256(abi.encodePacked(collateralToken, oracle, lowerBound, upperBound));",
|
||
"bytes32 eventHash = keccak256(abi.encodePacked(collateralToken, oracle, outcomeCount));",
|
||
"bytes32 h = keccak256(abi.encodePacked(keccak256, f, this.f{gas: 2}, blockhash));",
|
||
"bytes32 h = keccak256(abi.encodePacked(this.f, arr, sarr));",
|
||
"bytes32 hash, voterStatus status, bool voteResult, uint256 rewards) {",
|
||
"bytes32 hash;",
|
||
"bytes32 invalid = \"\";",
|
||
"bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));",
|
||
"bytes32 name;",
|
||
"bytes32 needledata;",
|
||
"bytes32 otherHash;",
|
||
"bytes32 payable i;",
|
||
"bytes32 proofElement = proof[i];",
|
||
"bytes32 proposalHash;",
|
||
"bytes32 ptrdata;",
|
||
"bytes32 public a_hash;",
|
||
"bytes32 public descriptionHash;",
|
||
"bytes32 public stateBytes = \"\x42\x00\xef\";",
|
||
"bytes32 public x;",
|
||
"bytes32 res = \"\u0024\u00A2\u20AC\";",
|
||
"bytes32 runtimeHash = keccak256(type(D).runtimeCode);",
|
||
"bytes32 should_be_constant = sha256('abc');",
|
||
"bytes32 sig_1;",
|
||
"bytes32 sig_2;",
|
||
"bytes32 slot = keccak256(abi.encode(uint(1), uint(0)));",
|
||
"bytes32 testHash;",
|
||
"bytes32 usdollar = \"aaa\u0024aaa\";",
|
||
"bytes32 x = bytes32(uint256(1));",
|
||
"bytes32 x = keccak256(\"abc\");",
|
||
"bytes32 x = sha3(\"\");",
|
||
"bytes32 x;",
|
||
"bytes32 y = \"test\";",
|
||
"bytes32 y = _x;",
|
||
"bytes32 y = sha256(\"abc\");",
|
||
"bytes32 y;",
|
||
"bytes32 z = _x;",
|
||
"bytes32[0] d;",
|
||
"bytes32[1263941234127518272][500] memory x;",
|
||
"bytes32[2][500] memory bytescs,",
|
||
"bytes32[3][500] memory Abytesas,",
|
||
"bytes32[3][500] memory bytesbs,",
|
||
"bytes32[8**90] ids;",
|
||
"bytes32[8**90][500] ids;",
|
||
"bytes32[][] data;",
|
||
"bytes33 b33 = 1;",
|
||
"bytes4 b = bytes4(a); ",
|
||
"bytes4 b10 = 0x1000000;",
|
||
"bytes4 b10 = bytes4(0x1000000);",
|
||
"bytes4 b11 = 0x100000000;",
|
||
"bytes4 b11 = bytes4(0x100000000);",
|
||
"bytes4 b4 = 0;",
|
||
"bytes4 b4 = 0x000000000;",
|
||
"bytes4 b4 = 0x0;",
|
||
"bytes4 b4 = b3;",
|
||
"bytes4 b4 = bytes4(0);",
|
||
"bytes4 b4 = bytes4(0x0);",
|
||
"bytes4 b4 = bytes4(0x000000000);",
|
||
"bytes4 b6 = 1;",
|
||
"bytes4 b6 = bytes4(1);",
|
||
"bytes4 b7 = 0x01000000;",
|
||
"bytes4 b7 = 16777216;",
|
||
"bytes4 b7 = bytes4(0x01000000);",
|
||
"bytes4 b7 = bytes4(16777216);",
|
||
"bytes4 b8 = 0xFFFFFFFF;",
|
||
"bytes4 b8 = bytes4(0xFFFFFFFF);",
|
||
"bytes4 b9 = 0xFFFFFF;",
|
||
"bytes4 b9 = bytes4(0xFFFFFF);",
|
||
"bytes4 constant s = \"ab\";",
|
||
"bytes4 constant s1 = A.f.selector;",
|
||
"bytes4 constant s1 = h.selector;",
|
||
"bytes4 constant s2 = B.g.selector;",
|
||
"bytes4 constant s3 = this.h.selector;",
|
||
"bytes4 constant s4 = A.f.selector;",
|
||
"bytes4 constant s4 = super.g.selector;",
|
||
"bytes4 funcSelector,",
|
||
"bytes4 public ERC165_interfaceId = type(ERC165).interfaceId;",
|
||
"bytes4 public ghello_world_interfaceId = type(HelloWorld).interfaceId;",
|
||
"bytes4 public hello_world = type(HelloWorld).interfaceId;",
|
||
"bytes4 public hello_world_with_event = type(HelloWorldWithEvent).interfaceId;",
|
||
"bytes4 x = \"abcd\";",
|
||
"bytes4 x = 0xffffffff;",
|
||
"bytes4 x;",
|
||
"bytes5 b5 = b4;",
|
||
"bytes6 b6 = b5;",
|
||
"bytes6 name;",
|
||
"bytes6 public name;",
|
||
"bytes7 b7 = b6;",
|
||
"bytes8 b8 = 0;",
|
||
"bytes8 b8 = 0x00000000000000000;",
|
||
"bytes8 b8 = 0x0;",
|
||
"bytes8 b8 = b7;",
|
||
"bytes8 b8 = bytes8(0);",
|
||
"bytes8 b8 = bytes8(0x0);",
|
||
"bytes8 b8 = bytes8(0x00000000000000000);",
|
||
"bytes8 bytesValue = bytes8(value);",
|
||
"bytes8 x;",
|
||
"bytes9 b9 = b8;",
|
||
"bytes9 d;",
|
||
"bytesM fail = \"now\";",
|
||
"bytes[0] e;",
|
||
"bytes[2] deadly;",
|
||
"bytes[32] memory a;",
|
||
"bytes[][1][1][][] memory x_1;",
|
||
"c += countData(tree.children[i]);",
|
||
"c := 3",
|
||
"c := add(add(1, 2), c)",
|
||
"c := sar(0, a)",
|
||
"c := sar(0x110, a)",
|
||
"c := sar(0xd0, sar(0x40, a))",
|
||
"c := sar(4, sar(12, a))",
|
||
"c := sar(b, a)",
|
||
"c := shl(",
|
||
"c := shl(0, a)",
|
||
"c := shl(0x01, shl(not(0x00), a))",
|
||
"c := shl(0x110, a)",
|
||
"c := shl(0xd0, shl(0x40, a))",
|
||
"c := shl(2, 1)",
|
||
"c := shl(4, shl(12, a))",
|
||
"c := shl(b, a)",
|
||
"c := shr(",
|
||
"c := shr(0, a)",
|
||
"c := shr(0x01, shr(not(0x00), a))",
|
||
"c := shr(0x110, a)",
|
||
"c := shr(0xd0, shr(0x40, a))",
|
||
"c := shr(1, 3)",
|
||
"c := shr(4, shr(12, a))",
|
||
"c := shr(b, a)",
|
||
"c := xyz",
|
||
"c = !a;",
|
||
"c = !b;",
|
||
"c = (((17)));",
|
||
"c = -a;",
|
||
"c = -b;",
|
||
"c = 1;",
|
||
"c = 2;",
|
||
"c = 3 gwei;",
|
||
"c = 3;",
|
||
"c = 5;",
|
||
"c = C(a);",
|
||
"c = C(address(2));",
|
||
"c = L.h.selector;",
|
||
"c = _c;",
|
||
"c = _data[i];",
|
||
"c = a != b;",
|
||
"c = a % b;",
|
||
"c = a & b;",
|
||
"c = a && b;",
|
||
"c = a * b;",
|
||
"c = a * int8(120) * int8(121);",
|
||
"c = a ** b;",
|
||
"c = a + b;",
|
||
"c = a - b;",
|
||
"c = a / b;",
|
||
"c = a < b;",
|
||
"c = a << b;",
|
||
"c = a <= b;",
|
||
"c = a == b;",
|
||
"c = a > b;",
|
||
"c = a >= b;",
|
||
"c = a >> b;",
|
||
"c = a ^ b;",
|
||
"c = a | b;",
|
||
"c = a || b;",
|
||
"c = b;",
|
||
"c = d;",
|
||
"c = data2[3];",
|
||
"c = data[k].c;",
|
||
"c = false;",
|
||
"c = m[1].a;",
|
||
"c = m_c;",
|
||
"c = new C(v);",
|
||
"c = new C{salt: \"abc\"}(v);",
|
||
"c = new function(uint) external returns (uint)[](200);",
|
||
"c = s.c;",
|
||
"c = s2.a;",
|
||
"c = s;",
|
||
"c = s[1].a;",
|
||
"c = st;",
|
||
"c = this.h;",
|
||
"c = x[i][j].length;",
|
||
"c = ~a;",
|
||
"c = ~b;",
|
||
"c ==",
|
||
"c d;",
|
||
"c storage x = d;",
|
||
"c.FailsToLookupToo();",
|
||
"c.a[0] = 0;",
|
||
"c.a[0] = 1;",
|
||
"c.a[0] = 2;",
|
||
"c.a[0][0] = 0;",
|
||
"c.a[0][0] = 1;",
|
||
"c.a[0][0] = 2;",
|
||
"c.a[0][0][0] = 0;",
|
||
"c.a[0][0][0] = 1;",
|
||
"c.a[0][0][0] = 2;",
|
||
"c.b.a.f();",
|
||
"c.balance;",
|
||
"c.call;",
|
||
"c.callcode;",
|
||
"c.delegatecall;",
|
||
"c.f();",
|
||
"c.funcCalled();",
|
||
"c.g(3);",
|
||
"c.g(8);",
|
||
"c.h();",
|
||
"c.send;",
|
||
"c.setOwner();",
|
||
"c.setOwner(address(0));",
|
||
"c.slot := s.slot",
|
||
"c.transfer;",
|
||
"c",
|
||
"c;",
|
||
"c; d;",
|
||
"c[0] = 0;",
|
||
"c[0] = 1;",
|
||
"c[0] = 2;",
|
||
"c[0] = 42;",
|
||
"c[0] |= 1;",
|
||
"c[0].a[0][0] = 0;",
|
||
"c[0].a[0][0] = 1;",
|
||
"c[0].a[0][0] = 2;",
|
||
"c[0][0] = 0;",
|
||
"c[0][0] = 1;",
|
||
"c[0][0] = 2;",
|
||
"c[0][0][0] = 0;",
|
||
"c[0][0][0] = 12;",
|
||
"c[0][0][0] = 1;",
|
||
"c[0][0][0] = 2;",
|
||
"c[10][0] |= 1;",
|
||
"c[2];",
|
||
"c[i] = b[i];",
|
||
"calldatacopy(add(m, 0x20), 0x44, mul(calldataload(4), 0x20))",
|
||
"campaign = new Campaign(eventContract, marketFactory, marketMaker, fee, funding, deadline);",
|
||
"campaignCanceled = true;",
|
||
"campaigns[0].m_value = 2;",
|
||
"case 0 {",
|
||
"case 0 { c.slot := s.slot }",
|
||
"case 0 { f := 1 }",
|
||
"case 0 { revert(0, 0) }",
|
||
"case 1 {",
|
||
"case 1 { c.slot := s.slot }",
|
||
"case 2 {",
|
||
"case hex\"00\" {}",
|
||
"case hex\"1122\" {}",
|
||
"catch (bytes memory x) {",
|
||
"catch (bytes memory) { r = s; }",
|
||
"catch (bytes memory) { r; }",
|
||
"catch (bytes memory) { return r; }",
|
||
"catch (bytes memory) { }",
|
||
"catch Error (string memory) { r = s; }",
|
||
"catch Error(string memory s) { s; }",
|
||
"catch { return true; }",
|
||
"categoricalEvent = eventFactory.createCategoricalEvent(collateralToken, this, outcomeCount);",
|
||
"categoricalEvent.buyAllOutcomes(funding);",
|
||
"categoricalEvent.outcomeTokens(i),",
|
||
"categoricalEvent.redeemWinnings();",
|
||
"categoricalEvents[eventHash] = eventContract;",
|
||
"cc[0][0] = 42;",
|
||
"cc[0][0] = 50;",
|
||
"centralizedOracle = new CentralizedOracle(msg.sender, ipfsHash);",
|
||
"ch = s[2];",
|
||
"challengeAmount = _challengeAmount;",
|
||
"challengeAmount,",
|
||
"challengePeriod = _challengePeriod;",
|
||
"challengePeriod,",
|
||
"changeRequirement(owners.length);",
|
||
"changingMilestones = false;",
|
||
"changingMilestones = true;",
|
||
"check token balances, send tokens, send tokens on behalf of a 3rd party and the",
|
||
"checkFloatingOwnSupply(addr, currentHeight, ! neg, value);",
|
||
"checkFloatingSupply(clients[addr].providerAddress, providers[clients[addr].providerAddress].currentHeight, ! neg, value);",
|
||
"checkFloatingSupply(provider, currHeight, false, bal);",
|
||
"checkFloatingSupply(provider, currHeight, true, bal);",
|
||
"checkPremium(beneficiaryAddress);",
|
||
"choice = ActionChoices(-1);",
|
||
"choice = ActionChoices(x);",
|
||
"choices = ActionChoices.GoStraight;",
|
||
"choices = ActionChoices.RunAroundWavingYourHands;",
|
||
"choices = Sit;",
|
||
"cleanup[x] = 3;",
|
||
"clientReward = getClientReward(_limit);",
|
||
"clientsCount = providers[addr].data[height].clientsCount;",
|
||
"clients[addr].lastSupplyID = currentSchellingRound;",
|
||
"clients[addr].supply[currentSchellingRound] = TEMath(clients[addr].supply[clients[addr].lastSupplyID], value, neg);",
|
||
"clients[addr].supply[currentSchellingRound] = TEMath(clients[addr].supply[currentSchellingRound], value, neg);",
|
||
"clients[msg.sender].lastRate = providers[provider].data[currHeight].currentRate;",
|
||
"clients[msg.sender].lastRate = rate;",
|
||
"clients[msg.sender].lastSupplyID = currentSchellingRound;",
|
||
"clients[msg.sender].paidUpTo = a-1;",
|
||
"clients[msg.sender].paidUpTo = currentSchellingRound;",
|
||
"clients[msg.sender].providerAddress = provider;",
|
||
"clients[msg.sender].providerConnected = block.timestamp;",
|
||
"clients[msg.sender].providerHeight = currHeight;",
|
||
"clients[msg.sender].supply[currentSchellingRound] = bal;",
|
||
"closeProposal(_proposalID);",
|
||
"closed = true;",
|
||
"closingTime = _closingTime;",
|
||
"cnt++;",
|
||
"code {",
|
||
"codeHash := keccak256(mload(0x40), size)",
|
||
"codecopy(mload(0x40), 0, size)",
|
||
"collateralToken = _collateralToken;",
|
||
"collateralToken,",
|
||
"compare(this.enc_bytes(test, i, j), this.enc_bytes_reference(test, i, j));",
|
||
"compare(this.enc_packed_bytes(test, i, j), this.enc_packed_bytes_reference(test, i, j));",
|
||
"compare(this.enc_packed_uint256(test, i, j), this.enc_packed_uint256_reference(test, i, j));",
|
||
"compare(this.enc_uint256(test, i, j), this.enc_uint256_reference(test, i, j));",
|
||
"computedHash = keccak256(abi.encodePacked(computedHash, proofElement));",
|
||
"computedHash = keccak256(abi.encodePacked(proofElement, computedHash));",
|
||
"cond ? a = v : b = v;",
|
||
"confirmTransaction(transactionId);",
|
||
"confirmationsTemp[count] = owners[i];",
|
||
"confirmations[transactionId][msg.sender] = false;",
|
||
"confirmations[transactionId][msg.sender] = true;",
|
||
"confirmed(transactionId, msg.sender)",
|
||
"constructor (",
|
||
"constructor () A(2) { assert(x == 2); }",
|
||
"constructor () {",
|
||
"constructor (uint y) { assert(x == 0); x = y; }",
|
||
"constructor(",
|
||
"constructor()",
|
||
"constructor() A() m1 m2 { }",
|
||
"constructor() A() {",
|
||
"constructor() A(17) { b_a = a; b_b = b; b_c = c; }",
|
||
"constructor() B(y = 3) { }",
|
||
"constructor() Base(2) { }",
|
||
"constructor() C() {}",
|
||
"constructor() C(2) C(2) {}",
|
||
"constructor() C(2) {",
|
||
"constructor() C(5) {}",
|
||
"constructor() F(1) {",
|
||
"constructor() X(5) {}",
|
||
"constructor() external {}",
|
||
"constructor() initX {",
|
||
"constructor() internal {}",
|
||
"constructor() m1 { }",
|
||
"constructor() mod1 {",
|
||
"constructor() override {}",
|
||
"constructor() payable",
|
||
"constructor() payable public {}",
|
||
"constructor() payable {",
|
||
"constructor() payable { }",
|
||
"constructor() payable {}",
|
||
"constructor() public payable {",
|
||
"constructor() public {",
|
||
"constructor() public { a = 5; }",
|
||
"constructor() public { }",
|
||
"constructor() public {}",
|
||
"constructor() pure {}",
|
||
"constructor() readX {",
|
||
"constructor() readX(x = 3) { }",
|
||
"constructor() returns (uint a) { }",
|
||
"constructor() view {}",
|
||
"constructor() virtual {}",
|
||
"constructor() x;",
|
||
"constructor() {",
|
||
"constructor() { assembly {} }",
|
||
"constructor() { d = new D(); }",
|
||
"constructor() { new Y(); }",
|
||
"constructor() { s.a = 42; }",
|
||
"constructor() { while (s.length < 42) s.push(0); }",
|
||
"constructor() { x = 2; }",
|
||
"constructor() { x = 3; }",
|
||
"constructor() { x = 42; }",
|
||
"constructor() { x = f; }",
|
||
"constructor() { x.push(42); }",
|
||
"constructor() { y.push(42); }",
|
||
"constructor() { }",
|
||
"constructor() {}",
|
||
"constructor();",
|
||
"constructor(){",
|
||
"constructor(ActionChoices param) {}",
|
||
"constructor(C other_c) {",
|
||
"constructor(C) {",
|
||
"constructor(C1 x) {",
|
||
"constructor(EventFactory _eventFactory)",
|
||
"constructor(Oracle[] memory _oracles)",
|
||
"constructor(S) {}",
|
||
"constructor(Token _collateralToken, Oracle _oracle, uint8 outcomeCount)",
|
||
"constructor(address _address) {}",
|
||
"constructor(address _creator, Event _eventContract, MarketMaker _marketMaker, uint24 _fee)",
|
||
"constructor(address _owner, bool _payOwnerOnly) public {",
|
||
"constructor(address _owner, bool _payOwnerOnly) {",
|
||
"constructor(address _owner, bytes memory _ipfsHash)",
|
||
"constructor(address payable _moduleHandler) public {",
|
||
"constructor(address payable _moduleHandler) {",
|
||
"constructor(address payable _moduleHandler, address _db, bool _forReplace) {",
|
||
"constructor(address payable foundation, address priceSet, uint256 exchangeRate, uint256 startBlockNum, address[] memory genesisAddr, uint256[] memory genesisValue) {",
|
||
"constructor(address payable moduleHandler) {",
|
||
"constructor(address) internal {}",
|
||
"constructor(address) {}",
|
||
"constructor(address[3] memory s, uint256 x) {",
|
||
"constructor(address[] memory _owners, uint _required)",
|
||
"constructor(address[] memory _owners, uint _required, uint _dailyLimit)",
|
||
"constructor(address[] memory newOwners) multiOwner(newOwners) {}",
|
||
"constructor(address[] memory newOwners) {",
|
||
"constructor(bool forReplace, address payable moduleHandler, address dbAddr, address payable icoContractAddr, address payable exchangeContractAddress, address payable[] memory genesisAddr, uint256[] memory genesisValue) payable {",
|
||
"constructor(bool forReplace, address payable moduleHandler, address dbAddress, address icoContractAddr, address[] memory genesisAddr, uint256[] memory genesisValue) {",
|
||
"constructor(bytes3 x, bool f) payable {",
|
||
"constructor(bytes3 x, bool f) public payable {",
|
||
"constructor(bytes3 x, bool f) {",
|
||
"constructor(bytes32 _arg) {",
|
||
"constructor(bytes32 _descriptionHash, uint8 v, bytes32 r, bytes32 s)",
|
||
"constructor(function() internal returns(uint) fp) {",
|
||
"constructor(function() internal) {}",
|
||
"constructor(mapping(uint => uint) memory a) {}",
|
||
"constructor(uint _a) {",
|
||
"constructor(uint _blockNumber)",
|
||
"constructor(uint _state) payable {",
|
||
"constructor(uint _x) payable {",
|
||
"constructor(uint _x) {",
|
||
"constructor(uint a, uint b) {",
|
||
"constructor(uint i) Base(i) {}",
|
||
"constructor(uint k) { S[k]; }",
|
||
"constructor(uint newI) {",
|
||
"constructor(uint newI, uint newK) A(newI, newK) {}",
|
||
"constructor(uint newI, uint newK) B(newI) C(newI, newK + 1) {}",
|
||
"constructor(uint newI, uint newK) C(newI, newK + 1) {}",
|
||
"constructor(uint newI, uint newK) {",
|
||
"constructor(uint newJ) {",
|
||
"constructor(uint param1, test param2, bool param3) payable {}",
|
||
"constructor(uint param1, test param2, bool param3) {}",
|
||
"constructor(uint v) {",
|
||
"constructor(uint x) B() {",
|
||
"constructor(uint x) B(x) C(x + 2) {",
|
||
"constructor(uint x) B(x) {",
|
||
"constructor(uint x) B1(x) B2(x) {",
|
||
"constructor(uint x) B2(x) B1(x) {",
|
||
"constructor(uint x) C(x + 2) B(x + 1) {",
|
||
"constructor(uint x) C(x + 2) {",
|
||
"constructor(uint x) F(x + 1) {",
|
||
"constructor(uint x) n {",
|
||
"constructor(uint x) {",
|
||
"constructor(uint y) {",
|
||
"constructor(uint) { revert(\"test message.\"); }",
|
||
"constructor(uint) { }",
|
||
"constructor(uint) {}",
|
||
"constructor(uint, uint) {}",
|
||
"constructor(uint256 _a, uint256[3] memory _b) {",
|
||
"constructor(uint256 a) {",
|
||
"constructor(uint256 i) Base(i) Base1(7) {}",
|
||
"constructor(uint256 i) Base(i) {}",
|
||
"constructor(uint256 i) Base1(i) {}",
|
||
"constructor(uint256 i) {",
|
||
"constructor(uint256 j) {",
|
||
"constructor(uint256 k) Base(k) {}",
|
||
"constructor(uint256 k) {}",
|
||
"constructor(uint256 x) {",
|
||
"constructor(uint256[LEN] memory _a) {",
|
||
"constructor(uint8) {}",
|
||
"constructor(uint[] calldata) public {}",
|
||
"constructor(uint[] storage a) {}",
|
||
"constructor(uint[][][] memory t) {}",
|
||
"continue",
|
||
"continue;",
|
||
"contract (e.g. TokenCreation.sol).",
|
||
"contract A",
|
||
"contract A is B {",
|
||
"contract A is B { }",
|
||
"contract A is B {}",
|
||
"contract A is B, B2 {",
|
||
"contract A is B2, B1 {",
|
||
"contract A is Base {",
|
||
"contract A is C {",
|
||
"contract A is C { constructor() C(2) { assert(a == 2); } }",
|
||
"contract A is C { constructor() C(2) {} }",
|
||
"contract A is C(2) {}",
|
||
"contract A is ERC20 {",
|
||
"contract A is I",
|
||
"contract A is I {",
|
||
"contract A is I {}",
|
||
"contract A is IJ",
|
||
"contract A {",
|
||
"contract A { constructor() { } }",
|
||
"contract A { constructor() {} }",
|
||
"contract A { constructor(string memory) { } }",
|
||
"contract A { constructor(uint a) { } }",
|
||
"contract A { constructor(uint) { } }",
|
||
"contract A { event X(uint); }",
|
||
"contract A { event e(uint a, string b); }",
|
||
"contract A { function A() public {} }",
|
||
"contract A { function f() public pure virtual {} }",
|
||
"contract A { function f() public virtual { uint8 x = C(0).g(); } }",
|
||
"contract A { function f() public { new B(); } }",
|
||
"contract A { function f() public {} }",
|
||
"contract A { function f(uint a) public {} }",
|
||
"contract A { function mod(uint a) public { } }",
|
||
"contract A { modifier mod(uint a) virtual { _; } }",
|
||
"contract A { modifier mod(uint a) { _; } }",
|
||
"contract A { }",
|
||
"contract A {modifier m virtual;}",
|
||
"contract A {}",
|
||
"contract A {} contract B {} contract C { struct S { uint a; } }",
|
||
"contract A1 { constructor() {} }",
|
||
"contract A1 {}",
|
||
"contract A2 { constructor() payable {} }",
|
||
"contract A2 { constructor() {} }",
|
||
"contract AddrString {",
|
||
"contract Apple {",
|
||
"contract Arraysum {",
|
||
"contract A{",
|
||
"contract B",
|
||
"contract B is A {",
|
||
"contract B is A { constructor() A { } }",
|
||
"contract B is A { constructor() A() { } }",
|
||
"contract B is A { function f() public pure virtual override {} }",
|
||
"contract B is A { function mod(uint a) public { } }",
|
||
"contract B is A { modifier mod(uint a) override { _; } }",
|
||
"contract B is A { modifier mod(uint a) { _; } }",
|
||
"contract B is A { modifier mod(uint8 a) { _; } }",
|
||
"contract B is A { uint public mod; }",
|
||
"contract B is A { }",
|
||
"contract B is A {}",
|
||
"contract B is A(2) { constructor() A(3) { } }",
|
||
"contract B is A(2) { constructor() { } }",
|
||
"contract B is Base {",
|
||
"contract B is C {",
|
||
"contract B is C { constructor() C(2) {} }",
|
||
"contract B is C { constructor() C(3) { assert(a == 3); } }",
|
||
"contract B is C {}",
|
||
"contract B is C(2) {}",
|
||
"contract B is I",
|
||
"contract B is I {",
|
||
"contract B is I {}",
|
||
"contract B is IJ",
|
||
"contract B is S",
|
||
"contract B {",
|
||
"contract B { function f() payable virtual public {} }",
|
||
"contract B { function f() public pure {} }",
|
||
"contract B { function f() public virtual {} function g() public returns (uint8) {} }",
|
||
"contract B { function f() public { new C(); } }",
|
||
"contract B { function f() public {} }",
|
||
"contract B { function f() virtual internal {} }",
|
||
"contract B { function f() virtual public view {} }",
|
||
"contract B { function f() virtual public {} }",
|
||
"contract B { }",
|
||
"contract B {}",
|
||
"contract B1 is A1 { constructor() payable {} }",
|
||
"contract B1 is A1 {}",
|
||
"contract B2 is A2 { constructor() payable {} }",
|
||
"contract B2 is A2 {}",
|
||
"contract B2 is C {",
|
||
"contract B3 { constructor() payable {} }",
|
||
"contract B3 {}",
|
||
"contract B4 { constructor() {} }",
|
||
"contract Base is BaseBase {",
|
||
"contract Base is BaseBase(7) {",
|
||
"contract Base is BaseBase(BaseBase.g()) {}",
|
||
"contract Base {",
|
||
"contract Base1 is Base {",
|
||
"contract Base1 is Base(3) {}",
|
||
"contract Base1 {",
|
||
"contract Base2 is Base1 {",
|
||
"contract BaseBase {",
|
||
"contract Base{",
|
||
"contract Bike is Vehicle {",
|
||
"contract BinarySearch {",
|
||
"contract B{",
|
||
"contract C",
|
||
"contract C is A {",
|
||
"contract C is A {}",
|
||
"contract C is A, B",
|
||
"contract C is A, B {",
|
||
"contract C is A, B { function f() public override (A, B) { A.f(); } }",
|
||
"contract C is A, B { }",
|
||
"contract C is A, B {}",
|
||
"contract C is B {",
|
||
"contract C is B { constructor() A(3) { } }",
|
||
"contract C is B { function f() override public view {} }",
|
||
"contract C is B { function f() payable public {} }",
|
||
"contract C is B { function f() public {} }",
|
||
"contract C is B { function f(uint i) public {} }",
|
||
"contract C is B { }",
|
||
"contract C is B {}",
|
||
"contract C is B(C.f) {",
|
||
"contract C is B(C.y = 3) {",
|
||
"contract C is B(C.y) {",
|
||
"contract C is B, A {",
|
||
"contract C is Base {",
|
||
"contract C is Base2 {",
|
||
"contract C is C1 {",
|
||
"contract C is D {",
|
||
"contract C is D {}",
|
||
"contract C is ERC20 {",
|
||
"contract C is ERC20 { uint public override x; }",
|
||
"contract C is I {",
|
||
"contract C is I(2) {}",
|
||
"contract C is SubA, SubB {",
|
||
"contract C is V",
|
||
"contract C is X {",
|
||
"contract C {",
|
||
"contract C { D d; }",
|
||
"contract C { constructor(uint a) {} }",
|
||
"contract C { constructor(uint) {} }",
|
||
"contract C { enum E { A, B } }",
|
||
"contract C { event E(); }",
|
||
"contract C { function f() public { new A(); } }",
|
||
"contract C { function f() public { string memory x = \"Hello World\"; } }",
|
||
"contract C { function f() public { string memory x = hex\"ff\"; } }",
|
||
"contract C { function f() public { string memory x = unicode\"Hello 😃\"; } }",
|
||
"contract C { function f() { uint x = 2; x++; } }",
|
||
"contract C { function f(function() external payable returns (uint) x) returns (function() external view returns (uint)) {} }",
|
||
"contract C { mapping(L => bool) i; }",
|
||
"contract C { modifier M { _; } }",
|
||
"contract C { modifier M(uint i) { _; } function F() M(1) public {} }",
|
||
"contract C { uint a; constructor(uint x) { a = x; } }",
|
||
"contract C { uint[] i; }",
|
||
"contract C { }",
|
||
"contract C {}",
|
||
"contract C1 is D {",
|
||
"contract C1 {",
|
||
"contract C1 {} contract C2 is C1 {}",
|
||
"contract C2 is D {",
|
||
"contract C2 {}",
|
||
"contract CalldataTest {",
|
||
"contract Campaign {",
|
||
"contract CampaignFactory {",
|
||
"contract CategoricalEvent is Event {",
|
||
"contract CentralizedOracle is Oracle {",
|
||
"contract CentralizedOracleFactory {",
|
||
"contract Child is Base {",
|
||
"contract Child is Parent {",
|
||
"contract Child is Parent2 {",
|
||
"contract ContractWithFunctionCalled {",
|
||
"contract ContractWithFunctionCalledSuper is ContractWithFunctionCalled {",
|
||
"contract ContractWithFunctionNotCalled {",
|
||
"contract ContractWithFunctionNotCalled2 is ContractWithFunctionCalledSuper {",
|
||
"contract CopyTest {",
|
||
"contract CrashContract {",
|
||
"contract Creator {",
|
||
"contract Crypto {",
|
||
"contract C{",
|
||
"contract D",
|
||
"contract D is A {",
|
||
"contract D is A, B { constructor() C(3) {} }",
|
||
"contract D is A, B { function f() public pure override(A, B) {} }",
|
||
"contract D is A, B { }",
|
||
"contract D is A, B {}",
|
||
"contract D is B, C {",
|
||
"contract D is B, C {}",
|
||
"contract D is C {",
|
||
"contract D is C { }",
|
||
"contract D is C {}==== Source: a ====",
|
||
"contract D is C(2, 1) {}",
|
||
"contract D is E {",
|
||
"contract D is E {}",
|
||
"contract D is I {",
|
||
"contract D is b { function f(c.S memory var1, x.C.S memory var2, C.S memory var3) internal {} }==== Source: A.sol ====",
|
||
"contract D {",
|
||
"contract D { constructor() payable {} }",
|
||
"contract D { function f() pure public {} }",
|
||
"contract D { }",
|
||
"contract D {}",
|
||
"contract DAO is DAOInterface, Token, TokenCreation {",
|
||
"contract DAO_Creator {",
|
||
"contract Data {",
|
||
"contract Derived is Base {",
|
||
"contract Derived is Base {}",
|
||
"contract Derived is Base(2) { }",
|
||
"contract Derived is Base(300) { }",
|
||
"contract Derived is Base, B, A {}",
|
||
"contract Derived is Base, Base1 {",
|
||
"contract Derived is Base{",
|
||
"contract Derived2 is Base {",
|
||
"contract Derived2 is Base(), Derived() { }",
|
||
"contract Derived2 is Base, Derived {}",
|
||
"contract DifficultyOracle is Oracle {",
|
||
"contract DifficultyOracleFactory {",
|
||
"contract D{",
|
||
"contract E is A {",
|
||
"contract E is C, B {",
|
||
"contract E is D {",
|
||
"contract E is D { }",
|
||
"contract E is F {}",
|
||
"contract E is I {}",
|
||
"contract E { }",
|
||
"contract E {}",
|
||
"contract ERC20 {",
|
||
"contract Error1 {",
|
||
"contract Error2 {",
|
||
"contract Error3 {",
|
||
"contract Error4 {",
|
||
"contract Errort6 {",
|
||
"contract EtherToken is StandardToken {",
|
||
"contract EventFactory {",
|
||
"contract F is C, B {",
|
||
"contract F {",
|
||
"contract Factory {",
|
||
"contract Final is Derived(4) {}",
|
||
"contract First {",
|
||
"contract Flow {",
|
||
"contract Foo {",
|
||
"contract FutarchyOracle is Oracle {",
|
||
"contract FutarchyOracleFactory {",
|
||
"contract G {",
|
||
"contract H {",
|
||
"contract Helper {",
|
||
"contract Homer is ERC165, Simpson {",
|
||
"contract I {",
|
||
"contract IJ is I, J {",
|
||
"contract Impl is SubA, SubB {",
|
||
"contract Impl {",
|
||
"contract Interface {",
|
||
"contract Intermediate{",
|
||
"contract InternalCall {",
|
||
"contract InvalidTest {",
|
||
"contract J is C { constructor() C(3) { assert(a == 4); } }",
|
||
"contract J {",
|
||
"contract J {}",
|
||
"contract K {",
|
||
"contract LMSRMarketMaker is MarketMaker {",
|
||
"contract Large {",
|
||
"contract Lib {",
|
||
"contract Library {",
|
||
"contract Lisa is ERC165MappingImplementation, Simpson {",
|
||
"contract ListsA is ParentA, Sub {}",
|
||
"contract ListsA is Sub, ParentA {}",
|
||
"contract ListsB is ParentB, Sub {}",
|
||
"contract ListsB is Sub, ParentB {}",
|
||
"contract ListsBoth is ParentA, ParentB, Sub {}",
|
||
"contract ListsBoth is Sub, ParentA, ParentB {}",
|
||
"contract LoopFor2 {",
|
||
"contract Lotto {",
|
||
"contract Main {",
|
||
"contract MajorityOracle is Oracle {",
|
||
"contract MajorityOracleFactory {",
|
||
"contract ManagedAccount is ManagedAccountInterface{",
|
||
"contract Medium {",
|
||
"contract Migrations {",
|
||
"contract MilestoneTracker {",
|
||
"contract Min {",
|
||
"contract MultiSigWallet {",
|
||
"contract MultiSigWalletFactory is Factory {",
|
||
"contract MultiSigWalletWithDailyLimit is MultiSigWallet {",
|
||
"contract MultiSigWalletWithDailyLimitFactory is Factory {",
|
||
"contract MyConc{",
|
||
"contract Observable {",
|
||
"contract Other {",
|
||
"contract OutcomeToken is StandardToken {",
|
||
"contract Ownable {",
|
||
"contract Parent {",
|
||
"contract Parent1 {",
|
||
"contract Parent2 is Parent1 {",
|
||
"contract PropagateThroughArguments {",
|
||
"contract PropagateThroughReturnValue {",
|
||
"contract Receiver {",
|
||
"contract Reference{",
|
||
"contract Reverts {",
|
||
"contract S",
|
||
"contract S {}",
|
||
"contract Sample {",
|
||
"contract ScalarEvent is Event {",
|
||
"contract Scope {",
|
||
"contract Second {",
|
||
"contract SendCoin {",
|
||
"contract SignedMessageOracle is Oracle {",
|
||
"contract SignedMessageOracleFactory {",
|
||
"contract Simp {",
|
||
"contract Simple {",
|
||
"contract Simple{",
|
||
"contract Small {",
|
||
"contract SolidityVar{",
|
||
"contract SomeContract {",
|
||
"contract Source is Updateable, Upgradable {",
|
||
"contract StandardMarket is Market {",
|
||
"contract StandardMarketFactory is MarketFactory {",
|
||
"contract StandardToken is Token {",
|
||
"contract State {",
|
||
"contract Storage {",
|
||
"contract Store is BinarySearch {",
|
||
"contract SubImpl is Sub {",
|
||
"contract Succeeds {",
|
||
"contract T {",
|
||
"contract Test",
|
||
"contract Test is Base {",
|
||
"contract Test is Lib {}",
|
||
"contract Test {",
|
||
"contract Test {}",
|
||
"contract TestContract",
|
||
"contract TestIt {",
|
||
"contract TestToken {",
|
||
"contract Token is TokenInterface {",
|
||
"contract TokenCreation is TokenCreationInterface, Token {",
|
||
"contract TransferTest {",
|
||
"contract Tsra {",
|
||
"contract UltimateOracle is Oracle {",
|
||
"contract UltimateOracleFactory {",
|
||
"contract Updateable {",
|
||
"contract Upgradable {",
|
||
"contract Vehicle {",
|
||
"contract VolatileStorage is Storage {",
|
||
"contract VolatileStorage is Storage, Observable {",
|
||
"contract Voting is Ownable {",
|
||
"contract X is A",
|
||
"contract X is A {",
|
||
"contract X is A, B {",
|
||
"contract X is A, B, C, D {",
|
||
"contract X is B, C {",
|
||
"contract X is C {",
|
||
"contract X is D {",
|
||
"contract X {",
|
||
"contract X {}",
|
||
"contract Y is X {",
|
||
"contract Y is X, T {",
|
||
"contract Y {",
|
||
"contract a { event b(uint[(1 / 1)]); }",
|
||
"contract a { function func() public {} }",
|
||
"contract abstractModule {",
|
||
"contract abstractModuleHandler {",
|
||
"contract announcementTypes {",
|
||
"contract attr_func is attribute, func {",
|
||
"contract attribute {",
|
||
"contract b is a {",
|
||
"contract b {",
|
||
"contract b {}",
|
||
"contract base {",
|
||
"contract base { function foo() public virtual; }",
|
||
"contract base { uint baseMember; struct BaseType { uint element; } }",
|
||
"contract buggystruct {",
|
||
"contract c is a {",
|
||
"contract c is a,b {",
|
||
"contract c is base {",
|
||
"contract c {",
|
||
"contract c { function f() public pure {22237625-86535-0+1;",
|
||
"contract c { function f() public { uint a = 2 + 3; } }",
|
||
"contract c { function f() public { uint[] memory x; } }",
|
||
"contract c { function f() public { uint[][] memory rows; } }",
|
||
"contract c { uint[] a; function f() public { uint[] storage b = a; } }",
|
||
"contract c1 {",
|
||
"contract c2 {",
|
||
"contract c3 {",
|
||
"contract c4 {",
|
||
"contract c5 {",
|
||
"contract c6 {",
|
||
"contract c7 {",
|
||
"contract d {",
|
||
"contract derived is base {",
|
||
"contract derived is base { function foo() public virtual override {} }",
|
||
"contract derived is root, inter2, inter1 {",
|
||
"contract derived {",
|
||
"contract from {",
|
||
"contract func {",
|
||
"contract helper {",
|
||
"contract ico is safeMath {",
|
||
"contract inter1 is root { function f() public virtual {} }",
|
||
"contract inter2 is root { function f() public virtual {} }",
|
||
"contract module {",
|
||
"contract moduleHandler is multiOwner, announcementTypes {",
|
||
"contract msg {",
|
||
"contract msg {} contract block{}",
|
||
"contract multiOwner is safeMath {",
|
||
"contract n",
|
||
"contract ownedDB {",
|
||
"contract premium is module, safeMath {",
|
||
"contract provider is module, safeMath, announcementTypes {",
|
||
"contract ptokenDB is tokenDB {}",
|
||
"contract publisher is announcementTypes, module, safeMath {",
|
||
"contract receiver { function nopay() public {} }",
|
||
"contract receiver { function pay() payable public {} }",
|
||
"contract root { function rootFunction() public {} }",
|
||
"contract safeMath {",
|
||
"contract schelling is module, announcementTypes, schellingVars {",
|
||
"contract schellingDB is safeMath, schellingVars {",
|
||
"contract schellingVars {",
|
||
"contract test",
|
||
"contract test is base {",
|
||
"contract test {",
|
||
"contract test { bytes a; bytes b; fallback() external { a == b; } }",
|
||
"contract test { fallback() external { uint x = 1; !x; } }",
|
||
"contract test { fallback() external { uint x = 1; uint y = 2; x && y; } }",
|
||
"contract test { fallback() external { uint x = 1; uint y = 2; x || y; } }",
|
||
"contract test { fallback() external { uint x = 3; int y = -4; x ** y; } }",
|
||
"contract test { }",
|
||
"contract test1 {",
|
||
"contract test2 {",
|
||
"contract thirdPartyContractAbstract {",
|
||
"contract thirdPartyPContractAbstract {",
|
||
"contract token is safeMath, module, announcementTypes {",
|
||
"contract tokenDB is safeMath, ownedDB {",
|
||
"contract type { }",
|
||
"contract wrong is derived { function foo() public virtual override; }",
|
||
"contributions[msg.sender] = 0;",
|
||
"contributions[msg.sender] = contributions[msg.sender].add(amount);",
|
||
"convertedWinningOutcome = 0;",
|
||
"convertedWinningOutcome = OUTCOME_RANGE;",
|
||
"convertedWinningOutcome = uint24(OUTCOME_RANGE * (outcome - lowerBound) / (upperBound - lowerBound));",
|
||
"copyFromTree(memoryTree, result, 0);",
|
||
"correct = (m[0] == 0x01) && (r == 0x01);",
|
||
"correct = (m[0] == 0x02) && (r == 0x02);",
|
||
"correct = (m[0] == 0xdeadbeef15dead) && (r == (((2 ** 224 - 1) << 32) | 0xef15dead));",
|
||
"correct = (r == 0xef15dead) && (m[0] == 0xdeadbeef15dead);",
|
||
"correct = (s[0] == 0x01) && (r == 0x01);",
|
||
"correct = r == (0x64 << 248);",
|
||
"correct = r == (0x66 << 248);",
|
||
"correct = r == 0x01;",
|
||
"correct = r == 0x7fff;",
|
||
"correct = r == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80;",
|
||
"corresponding approval process. Tokens need to be created by a derived",
|
||
"cost /= ONE;",
|
||
"cost = cost / ONE + 1;",
|
||
"cost = outcomeTokenCost.add(fees);",
|
||
"cost = outcomeTokenCount - profit;",
|
||
"cost = outcomeTokenCount;",
|
||
"cost = uint(costLevelAfter - costLevelBefore);",
|
||
"costLevel = (costLevel.mul(int(ONE)) / logN).mul(int(funding));",
|
||
"costLevel = Math.ln(sum);",
|
||
"costLevel = costLevel.add(offset);",
|
||
"count += 1;",
|
||
"country = providers[addr].data[height].country;",
|
||
"create = providers[addr].data[height].create;",
|
||
"createTokenProxy(msg.sender);",
|
||
"createdAtBlock = block.number;",
|
||
"creator = _creator;",
|
||
"curator = _curator;",
|
||
"currentSchellingRound = 1;",
|
||
"currentSchellingRound = _id;",
|
||
"currentSchellingRound = roundID;",
|
||
"currentSchellingRound++;",
|
||
"d := add(d, 3)",
|
||
"d := create(0, add(c, 0x20), mload(c))",
|
||
"d = 1;",
|
||
"d = 4;",
|
||
"d = 6;",
|
||
"d = D.Left;",
|
||
"d = D.Right;",
|
||
"d = L.h.selector;",
|
||
"d = _d;",
|
||
"d = bytes(c);",
|
||
"d = data2[4];",
|
||
"d = false;",
|
||
"d = g;",
|
||
"d = keccak256(\"foo\");",
|
||
"d = keccak256(abi.encodePacked(a, b, c));",
|
||
"d = keccak256(abi.encodePacked(a, b, uint8(145)));",
|
||
"d = keccak256(abi.encodePacked(a, b, uint8(145), \"foo\"));",
|
||
"d = m[1].b;",
|
||
"d = s3.a;",
|
||
"d = s[1].b;",
|
||
"d = string(c);",
|
||
"d = true;",
|
||
"d = uint256(choice);",
|
||
"d = uint256(choices);",
|
||
"d = uint[](c);",
|
||
"d = x[i][j][k];",
|
||
"d.a[0] = 5;",
|
||
"d.a[1] = 6;",
|
||
"d.d();",
|
||
"d.f();",
|
||
"d.g();",
|
||
"d.g(y);",
|
||
"d.g{gas: 200}();",
|
||
"d.s.x = 2;",
|
||
"d.s.y = 3;",
|
||
"d.s.z = 4;",
|
||
"d.x = 1;",
|
||
"d1; d2; d3; d4; d5; d6;",
|
||
"d[0] = 42;",
|
||
"d[5] = 7;",
|
||
"dailyLimit = _dailyLimit;",
|
||
"daoCreator = _daoCreator;",
|
||
"data += 1;",
|
||
"data := div(mload(rStartPos), exp(256, 12))",
|
||
"data := div(mload(rStartPos), exp(256, sub(32, len)))",
|
||
"data = 8;",
|
||
"data = [x[0], x[1], x[2]];",
|
||
"data = _data;",
|
||
"data = a;",
|
||
"data = abi.encode(s);",
|
||
"data = i;",
|
||
"data = msg.data;",
|
||
"data = new bytes(100);",
|
||
"data = super.f() | 8;",
|
||
"data = x;",
|
||
"data |= 0x1;",
|
||
"data |= 0x20;",
|
||
"data |= 0x300;",
|
||
"data |= 0x4000;",
|
||
"data |= 1;",
|
||
"data |= 2;",
|
||
"data |= 4;",
|
||
"data().a = x;",
|
||
"data.a = 0x02;",
|
||
"data.a = 2;",
|
||
"data.a = 8;",
|
||
"data.a = small.B;",
|
||
"data.a = small.C;",
|
||
"data.a == 0x02 &&",
|
||
"data.b = 0x05;",
|
||
"data.b = 0xabcd;",
|
||
"data.b = 0xdcab;",
|
||
"data.b = small.C;",
|
||
"data.b = small.D;",
|
||
"data.b == 0x05 &&",
|
||
"data.c = 0x1234567890;",
|
||
"data.c = 0x9876543210;",
|
||
"data.c = bytes1(0x06);",
|
||
"data.c = larger.B;",
|
||
"data.c = larger.D;",
|
||
"data.c == bytes1(0x06) &&",
|
||
"data.inner.a = 0x03;",
|
||
"data.inner.a == 0x03 &&",
|
||
"data.inner.b = 0x04;",
|
||
"data.inner.b == 0x04 &&",
|
||
"data.inner.c = \"1234567890\";",
|
||
"data.inner.c == \"1234567890\" &&",
|
||
"data.inner.d = \"123456789\";",
|
||
"data.inner.d == \"123456789\" &&",
|
||
"data.inner.e = \"abcdefghij\";",
|
||
"data.inner.e == \"abcdefghij\" &&",
|
||
"data.map = a;",
|
||
"data.pop();",
|
||
"data.pop(5);",
|
||
"data.pop;",
|
||
"data.push(\"f\");",
|
||
"data.push(\"o\");",
|
||
"data.push(\"x\");",
|
||
"data.push(\"y\");",
|
||
"data.push(\"z\");",
|
||
"data.push(0);",
|
||
"data.push(0x02);",
|
||
"data.push(0x03);",
|
||
"data.push(0x04);",
|
||
"data.push(0x05);",
|
||
"data.push(0x07);",
|
||
"data.push(123);",
|
||
"data.push(234);",
|
||
"data.push(3);",
|
||
"data.push(4);",
|
||
"data.push(5);",
|
||
"data.push(7);",
|
||
"data.push(bytes1(i));",
|
||
"data.push(inner);",
|
||
"data.push(s);",
|
||
"data.push(x);",
|
||
"data.recursive[0].recursive[0].z == 1;",
|
||
"data.recursive[0].recursive[1].z == 0 &&",
|
||
"data.recursive[0].s1data.y = false;",
|
||
"data.recursive[0].s1data.y == false &&",
|
||
"data.recursive[0].z == 3 &&",
|
||
"data.recursive[3].recursive[4].z = 5;",
|
||
"data.recursive[3].recursive[4].z == 5 &&",
|
||
"data.recursive[4].recursive[3].z = 6;",
|
||
"data.recursive[4].recursive[3].z == 6 &&",
|
||
"data.recursive[4].z = 9;",
|
||
"data.recursive[4].z == 9;",
|
||
"data.s1data.x = 2;",
|
||
"data.s1data.y = true;",
|
||
"data.s1data.y == true &&",
|
||
"data.z = 1;",
|
||
"data.z = 2;",
|
||
"data1 = cond ? x : y;",
|
||
"data1 = data2;",
|
||
"data1 = new bytes8[](9);",
|
||
"data1.a = 1;",
|
||
"data1.b = 2;",
|
||
"data1.m_value = 2;",
|
||
"data1[0] = \"cc\";",
|
||
"data1[0] = bytes8(uint64(1));",
|
||
"data1[1] = bytes8(uint64(2));",
|
||
"data1[2] = 7;",
|
||
"data1[2] = bytes8(uint64(3));",
|
||
"data1[30] = 4;",
|
||
"data1[3] = 9;",
|
||
"data1[3] = bytes8(uint64(4));",
|
||
"data1[8] = 4;",
|
||
"data2 = data1;",
|
||
"data2 = x;",
|
||
"data2[3] = 8;",
|
||
"data2[8] = data2[9] = bytes8(uint64(2));",
|
||
"data2[i] = bytes10(uint80(0xffff00 | (1 + i)));",
|
||
"data: data,",
|
||
"dataArray[5] = 2;",
|
||
"dataBase = base;",
|
||
"dataDerived = derived;",
|
||
"dataRef = x;",
|
||
"data[\"abc\"] = 2;",
|
||
"data[0] = \"12345\";",
|
||
"data[0] = 234;",
|
||
"data[0] = 8;",
|
||
"data[1] = 123;",
|
||
"data[2].a[1] = 4;",
|
||
"data[2].x = 1;",
|
||
"data[2].y = 2;",
|
||
"data[2].z = 3;",
|
||
"data[2][2] = 8;",
|
||
"data[7].a = 1;",
|
||
"data[7].b = 2;",
|
||
"data[7].c[0] = 3;",
|
||
"data[7].d = true;",
|
||
"data[94] == 0 &&",
|
||
"data[96] == 0 &&",
|
||
"data[data.length - 1] = v;",
|
||
"data[i] = i;",
|
||
"data[index] = value;",
|
||
"data[index].x = x;",
|
||
"data[index].y = y;",
|
||
"data[k].a = 1;",
|
||
"data[k].c = 2;",
|
||
"data[k].nested.x = 3;",
|
||
"data[k].nested.y = 4;",
|
||
"data[offset++] = tree.data;",
|
||
"data[to] = data[from];",
|
||
"datacopy(0, dataoffset(\"Runtime\"), datasize(\"Runtime\"))",
|
||
"db = ptokenDB(dbAddress);",
|
||
"db = schellingDB(_db);",
|
||
"db = tokenDB(dbAddr);",
|
||
"dd[0][0] = 10;",
|
||
"dd[0][0] = 42;",
|
||
"deadline",
|
||
"deadline = _deadline;",
|
||
"decimals",
|
||
"decimals = _decimalPlaces;",
|
||
"default {",
|
||
"default { c.slot := s.slot }",
|
||
"default { f := 2 }",
|
||
"default { return(0,0) }",
|
||
"delete a;",
|
||
"delete a[2];",
|
||
"delete b;",
|
||
"delete b[x];",
|
||
"delete b[y];",
|
||
"delete b[z];",
|
||
"delete brought[msg.sender];",
|
||
"delete c;",
|
||
"delete campaigns[0];",
|
||
"delete clients[msg.sender].lastRate;",
|
||
"delete clients[msg.sender].lastSupplyID;",
|
||
"delete clients[msg.sender].paidUpTo;",
|
||
"delete clients[msg.sender].providerAddress;",
|
||
"delete clients[msg.sender].providerConnected;",
|
||
"delete clients[msg.sender].providerHeight;",
|
||
"delete data;",
|
||
"delete data[94];",
|
||
"delete data[96];",
|
||
"delete data[98];",
|
||
"delete doDB[doHash];",
|
||
"delete f;",
|
||
"delete func;",
|
||
"delete funds;",
|
||
"delete g;",
|
||
"delete interestDB[msg.sender][r];",
|
||
"delete invalid;",
|
||
"delete modules[_id];",
|
||
"delete opponents[msg.sender][a];",
|
||
"delete owners[addr];",
|
||
"delete proposedMilestones;",
|
||
"delete providers[msg.sender].data[currHeight].supply[currentSchellingRound];",
|
||
"delete providers[provider].data[currHeight].allowedUsers[addr[a]];",
|
||
"delete s.x;",
|
||
"delete s;",
|
||
"delete sstorage;",
|
||
"delete str;",
|
||
"delete this.f;",
|
||
"delete toDelete;",
|
||
"delete v;",
|
||
"delete voter.hash;",
|
||
"delete voter.rewards;",
|
||
"delete voter.roundID;",
|
||
"delete voter.status;",
|
||
"delete x.m_value;",
|
||
"delete x;",
|
||
"delete y;",
|
||
"derived = dataDerived;",
|
||
"descriptionHash = _descriptionHash;",
|
||
"dest += 32;",
|
||
"destination = source;",
|
||
"destination = source_intermediate;",
|
||
"destination = source_taint;",
|
||
"destination.val = source.val;",
|
||
"destination.val = source_taint;",
|
||
"destination: destination,",
|
||
"diff = internal1 != internal2;",
|
||
"diff = internal1 == internal2;",
|
||
"difficulty = block.difficulty;",
|
||
"difficultyOracle = new DifficultyOracle(blockNumber);",
|
||
"divisor = divisor / 256;",
|
||
"do",
|
||
"do {",
|
||
"do { c = s; } while(false);",
|
||
"do {} while((c = s).f);",
|
||
"do {} while(false);",
|
||
"doDB[doHash].push(msg.sender);",
|
||
"donor = _donor;",
|
||
"donor = _newDonor;",
|
||
"dropModule,",
|
||
"dummy;",
|
||
"dup0()",
|
||
"dup1()",
|
||
"dup10()",
|
||
"dup11()",
|
||
"dup12()",
|
||
"dup13()",
|
||
"dup14()",
|
||
"dup15()",
|
||
"dup16()",
|
||
"dup2()",
|
||
"dup3()",
|
||
"dup32()",
|
||
"dup4()",
|
||
"dup5()",
|
||
"dup6()",
|
||
"dup7()",
|
||
"dup8()",
|
||
"dup9()",
|
||
"dynamicData.push();",
|
||
"dynamicData.push(8);",
|
||
"dynamicData[2].push();",
|
||
"dynamicData[2][2] = 8;",
|
||
"e = _data[a][b];",
|
||
"e = abi.decode(msg.data[4 : 4 + 32], (uint256));",
|
||
"e = data2[5];",
|
||
"e = data2[9];",
|
||
"e = false;",
|
||
"e = s3.b;",
|
||
"e();",
|
||
"e;",
|
||
"ecrecover.gas();",
|
||
"ecrecover.value();",
|
||
"eee[0][0][0] = 42;",
|
||
"eee[0][0][0] = 50;",
|
||
"else",
|
||
"else _;",
|
||
"else c = s;",
|
||
"else f(b2, c);",
|
||
"else if ( a == announcementType.providerGasProtect ) { gasProtectMaxRounds = b; }",
|
||
"else if ( a == announcementType.providerInterestMinFunds ) { interestMinFunds = b; }",
|
||
"else if ( a == announcementType.providerPrivateClientLimit ) { privateProviderLimit = b; }",
|
||
"else if ( a == announcementType.providerPrivateFunds ) { minFundsForPrivate = b; }",
|
||
"else if ( a == announcementType.providerPrivateMaxRate ) { privateMaxRate = uint8(b); }",
|
||
"else if ( a == announcementType.providerPrivateMinRate ) { privateMinRate = uint8(b); }",
|
||
"else if ( a == announcementType.providerPublicMaxRate ) { publicMaxRate = uint8(b); }",
|
||
"else if ( a == announcementType.providerPublicMinRate ) { publicMinRate = uint8(b); }",
|
||
"else if ( a == announcementType.providerRentRate ) { rentRate = b; }",
|
||
"else if ( a == announcementType.schellingCheckAboves ) { interestCheckAboves = uint8(b); }",
|
||
"else if ( a == announcementType.schellingCheckRounds ) { interestCheckRounds = uint8(b); }",
|
||
"else if ( a == announcementType.schellingRate ) { interestRate = b; }",
|
||
"else if ( aType == announcementType.transactionFeeBurn ) { transactionFeeBurn = value; }",
|
||
"else if ( aType == announcementType.transactionFeeMax ) { transactionFeeMax = value; }",
|
||
"else if ( aType == announcementType.transactionFeeMin ) { transactionFeeMin = value; }",
|
||
"else if ( fee < transactionFeeMin ) { fee = transactionFeeMin; }",
|
||
"else if (_value > v)",
|
||
"else if (b0 < DATA_LONG_START)",
|
||
"else if (b0 < DATA_LONG_START) {",
|
||
"else if (b0 < LIST_LONG_START)",
|
||
"else if (b0 < LIST_SHORT_START) {",
|
||
"else if (outcome > upperBound)",
|
||
"else if (validations[j] == 0) {",
|
||
"else if (which == 1) return s.s.x;",
|
||
"else if (which == 1) return s.y;",
|
||
"else if (which == 2) return s.s.y;",
|
||
"else if (x == 1) x = 2;",
|
||
"else if (x == 2) x = 0;",
|
||
"else if (x > 2)",
|
||
"else return 0;",
|
||
"else return _begin + halfLen;",
|
||
"else return f(3, 7);",
|
||
"else return s.s.z;",
|
||
"else return s.z;",
|
||
"else return value2;",
|
||
"else revert();",
|
||
"else s.f = true;",
|
||
"else value2 = value;",
|
||
"else {",
|
||
"else { c = s; }",
|
||
"else { disabledUntil = block.number + 5760; }",
|
||
"else { return (true, rounds[_id].totalAboveWeight, rounds[_id].totalBelowWeight, rounds[_id].reward, rounds[_id].blockHeight, rounds[_id].voted); }",
|
||
"else { return a+b; }",
|
||
"else { return false; }",
|
||
"emit A.e(2, \"abc\");",
|
||
"emit A.e({b: \"abc\", a: 8});",
|
||
"emit A;",
|
||
"emit AllowanceUsed(msg.sender, from, amount);",
|
||
"emit AllowedRecipientChanged(_recipient, _allowed);",
|
||
"emit Approval(msg.sender, _spender, _amount);",
|
||
"emit Approval(msg.sender, _spender, _value);",
|
||
"emit Approval(msg.sender, spender, amount);",
|
||
"emit Approval(msg.sender, spender, value);",
|
||
"emit Approval(owner, spender, value);",
|
||
"emit Burn(owner, value);",
|
||
"emit CampaignCanceled();",
|
||
"emit CampaignCreation(msg.sender, campaign, eventContract, marketFactory, marketMaker, fee, funding, deadline);",
|
||
"emit CampaignFunding(msg.sender, amount);",
|
||
"emit CampaignRefund(msg.sender, refundAmount);",
|
||
"emit CategoricalEventCreation(msg.sender, eventContract, collateralToken, oracle, outcomeCount);",
|
||
"emit CentralizedOracleCreation(msg.sender, centralizedOracle, ipfsHash);",
|
||
"emit Confirmation(msg.sender, transactionId);",
|
||
"emit ContractInstantiation(msg.sender, instantiation);",
|
||
"emit CreatedToken(_tokenHolder, token);",
|
||
"emit DailyLimitChange(_dailyLimit);",
|
||
"emit Deposit(msg.sender, msg.value);",
|
||
"emit DifficultyOracleCreation(msg.sender, difficultyOracle, blockNumber);",
|
||
"emit EClientLost(msg.sender, provider, currHeight, bal);",
|
||
"emit EICO(beneficiaryAddress, _reward, affilateAddress, extra);",
|
||
"emit EInvalidateAnnouncement(id);",
|
||
"emit ENewAnnouncement(announcementsLength, Type);",
|
||
"emit ENewClient(msg.sender, provider, currHeight, bal);",
|
||
"emit EOppositeAnnouncement(id, msg.sender, _balance);",
|
||
"emit EProviderClose(msg.sender, currHeight);",
|
||
"emit EProviderDetailsChanged(addr, currHeight, website, country, info, rate, admin);",
|
||
"emit EProviderOpen(msg.sender, currHeight);",
|
||
"emit EReward(msg.sender, provider, clientReward, providerReward);",
|
||
"emit Execution(transactionId);",
|
||
"emit ExecutionFailure(transactionId);",
|
||
"emit FeeWithdrawal(fees);",
|
||
"emit FeeWithdrawal(msg.sender, fees);",
|
||
"emit ForwardedOracleOutcomeAssignment(forwardedOutcome);",
|
||
"emit FuelingToDate(totalSupply);",
|
||
"emit FutarchyClosing();",
|
||
"emit FutarchyFunding(funding);",
|
||
"emit FutarchyOracleCreation(",
|
||
"emit Issuance(_for, outcomeTokenCount);",
|
||
"emit MajorityOracleCreation(msg.sender, majorityOracle, oracles);",
|
||
"emit MarketClosing();",
|
||
"emit MarketCreation(market);",
|
||
"emit MarketCreation(msg.sender, market, eventContract, marketMaker, fee);",
|
||
"emit MarketFunding(funding);",
|
||
"emit Mint(genesisAddr[a], genesisValue[a]);",
|
||
"emit Mint(owner, value);",
|
||
"emit NewCurator(_newCurator);",
|
||
"emit NewMilestoneListAccepted();",
|
||
"emit NewMilestoneListProposed();",
|
||
"emit NewMilestoneListUnproposed();",
|
||
"emit OutcomeAssignment(_outcome);",
|
||
"emit OutcomeAssignment(difficulty);",
|
||
"emit OutcomeAssignment(outcome);",
|
||
"emit OutcomeAssignment(winningMarketIndex);",
|
||
"emit OutcomeChallenge(msg.sender, _outcome);",
|
||
"emit OutcomeTokenCreation(outcomeToken, i);",
|
||
"emit OutcomeTokenPurchase(msg.sender, outcomeTokenIndex, outcomeTokenCount, cost);",
|
||
"emit OutcomeTokenSale(msg.sender, outcomeTokenIndex, outcomeTokenCount, profit);",
|
||
"emit OutcomeTokenSetIssuance(msg.sender, collateralTokenCount);",
|
||
"emit OutcomeTokenSetRevocation(msg.sender, outcomeTokenCount);",
|
||
"emit OutcomeTokenShortSale(msg.sender, outcomeTokenIndex, outcomeTokenCount, cost);",
|
||
"emit OutcomeVote(msg.sender, _outcome, amount);",
|
||
"emit OwnerAddition(newOwner);",
|
||
"emit OwnerAddition(owner);",
|
||
"emit OwnerRemoval(owner);",
|
||
"emit OwnerReplacement(newOwner);",
|
||
"emit PayOut(_recipient, _amount);",
|
||
"emit ProposalAdded(",
|
||
"emit ProposalStatusChanged(_idMilestone, milestone.status);",
|
||
"emit ProposalTallied(_proposalID, _success, quorum);",
|
||
"emit Refund(msg.sender, weiGiven[msg.sender]);",
|
||
"emit RequirementChange(_required);",
|
||
"emit Revocation(_for, outcomeTokenCount);",
|
||
"emit Revocation(msg.sender, transactionId);",
|
||
"emit ScalarEventCreation(msg.sender, eventContract, collateralToken, oracle, lowerBound, upperBound);",
|
||
"emit SignedMessageOracleCreation(msg.sender, signedMessageOracle, oracle);",
|
||
"emit SignerReplacement(newSigner);",
|
||
"emit Submission(transactionId);",
|
||
"emit Test();",
|
||
"emit Transfer(_from, _to, _amount);",
|
||
"emit Transfer(_from, _to, _value);",
|
||
"emit Transfer(account, address(0), value);",
|
||
"emit Transfer(address(0), account, value);",
|
||
"emit Transfer(from, to, amount, _data);",
|
||
"emit Transfer(from, to, value);",
|
||
"emit Transfer(msg.sender, 0x0000000000000000000000000000000000000000, balances[msg.sender]);",
|
||
"emit Transfer(msg.sender, _to, _amount);",
|
||
"emit Transfer(msg.sender, _to, _value);",
|
||
"emit Transfer(msg.sender, receiver, amount);",
|
||
"emit Transfer(msg.sender, to, amount, _data);",
|
||
"emit Transfer(msg.sender, to, amount, extraData);",
|
||
"emit Transfer(msg.sender, to, value);",
|
||
"emit Transfer(owner, _schellingAddr, _forSchelling, _data);",
|
||
"emit UltimateOracleCreation(",
|
||
"emit Verified(\"Transaction successfully verified.\");",
|
||
"emit Voted(_proposalID, _supportsProposal, msg.sender);",
|
||
"emit WinningsRedemption(msg.sender, winnings);",
|
||
"emit Withdrawal(msg.sender, amount);",
|
||
"emit Withdrawal(msg.sender, value);",
|
||
"emit e();",
|
||
"emit e(2, \"abc\");",
|
||
"emit e({b: \"abc\", a: 8});",
|
||
"emit;",
|
||
"enum A { B, C }",
|
||
"enum A { X, Y }",
|
||
"enum ActionChoices { GoLeft, GoRight, GoLeft, Sit }",
|
||
"enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }",
|
||
"enum ActionChoices {GoLeft, GoRight, GoStraight, Sit}",
|
||
"enum ActionChoices {GoLeft, GoRight, GoStraight}",
|
||
"enum Choice {A, B, C}",
|
||
"enum D { Left, Right }",
|
||
"enum Direction { Left, Right }",
|
||
"enum E { A }",
|
||
"enum E { A, B }",
|
||
"enum E { A, B, C }",
|
||
"enum E { Left, Right }",
|
||
"enum E { V }",
|
||
"enum E {X, Y}",
|
||
"enum ENUM { F,G,H }",
|
||
"enum Foo {",
|
||
"enum Foo {Things, Stuff}",
|
||
"enum Ground { North, South, West, East }",
|
||
"enum MilestoneStatus {",
|
||
"enum MyEnum { One, Two }",
|
||
"enum Paper { Up, Down, Left, Right }",
|
||
"enum Stages {",
|
||
"enum Truth {False, True}",
|
||
"enum X {A, B}",
|
||
"enum a { X }",
|
||
"enum announcementType {",
|
||
"enum big { A, B, C, D }",
|
||
"enum foo { WARNING,}",
|
||
"enum foo { }",
|
||
"enum larger {A, B, C, D, E}",
|
||
"enum small { A, B, C, D }",
|
||
"enum small {A, B, C, D}",
|
||
"enum status {",
|
||
"enum validEnum { Value1, Value2, Value3, Value4 }",
|
||
"enum voterStatus {",
|
||
"enum_x = true ? enum_x : enum_y;",
|
||
"equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))",
|
||
"ev = eval;",
|
||
"event A();",
|
||
"event A(bytes);",
|
||
"event A(uint i) anonymous;",
|
||
"event A(uint i);",
|
||
"event A(uint indexed i);",
|
||
"event A(uint);",
|
||
"event A(uint, uint);",
|
||
"event AllowanceUsed(address indexed spender, address indexed owner, uint256 indexed value);",
|
||
"event AllowedRecipientChanged(address indexed _recipient, bool _allowed);",
|
||
"event Approval(",
|
||
"event Approval(address indexed _owner, address indexed _spender, uint256 _value);",
|
||
"event Approval(address indexed owner, address indexed spender, uint value);",
|
||
"event Approval(address indexed owner, address indexed spender, uint256 value);",
|
||
"event Burn(address indexed addr, uint256 indexed value);",
|
||
"event CampaignCanceled();",
|
||
"event CampaignCreation(address indexed creator, Campaign campaign, Event eventContract, MarketFactory marketFactory, MarketMaker marketMaker, uint24 fee, uint funding, uint deadline);",
|
||
"event CampaignFunding(address indexed sender, uint funding);",
|
||
"event CampaignRefund(address indexed sender, uint refund);",
|
||
"event CategoricalEventCreation(address indexed creator, CategoricalEvent categoricalEvent, Token collateralToken, Oracle oracle, uint8 outcomeCount);",
|
||
"event CentralizedOracleCreation(address indexed creator, CentralizedOracle centralizedOracle, bytes ipfsHash);",
|
||
"event Confirmation(address indexed sender, uint indexed transactionId);",
|
||
"event ContractInstantiation(address sender, address instantiation);",
|
||
"event CreatedToken(address indexed to, uint amount);",
|
||
"event DailyLimitChange(uint dailyLimit);",
|
||
"event Deposit(address indexed sender, uint value);",
|
||
"event DifficultyOracleCreation(address indexed creator, DifficultyOracle difficultyOracle, uint blockNumber);",
|
||
"event E();",
|
||
"event E(S indexed);",
|
||
"event E(S);",
|
||
"event E(T t, S s);",
|
||
"event E(address a);",
|
||
"event E(uint[2][]);",
|
||
"event E(uint[] indexed);",
|
||
"event E(uint[]);",
|
||
"event E(uint[][] indexed);",
|
||
"event E(uint[][]);",
|
||
"event EClientLost(address indexed client, address indexed provider, uint256 height, uint256 indexed value);",
|
||
"event ECloseAnnouncement(uint256 id);",
|
||
"event EICO(address indexed Address, uint256 indexed value, address Affiliate, uint256 AffilateValue);",
|
||
"event EInvalidateAnnouncement(uint256 id);",
|
||
"event ENewAnnouncement(uint256 id, announcementType typ);",
|
||
"event ENewClient(address indexed client, address indexed provider, uint256 height, uint256 indexed value);",
|
||
"event EOppositeAnnouncement(uint256 id, address addr, uint256 value);",
|
||
"event EProviderClose(address indexed addr, uint256 height);",
|
||
"event EProviderDetailsChanged(address indexed addr, uint256 height, string website, string country, string info, uint8 rate, address admin);",
|
||
"event EProviderOpen(address addr, uint256 height);",
|
||
"event EReward(address indexed client, address indexed provider, uint256 clientreward, uint256 providerReward);",
|
||
"event Event();",
|
||
"event Execution(uint indexed transactionId);",
|
||
"event ExecutionFailure(uint indexed transactionId);",
|
||
"event FeeWithdrawal(address indexed receiver, uint fees);",
|
||
"event FeeWithdrawal(uint fees);",
|
||
"event ForwardedOracleOutcomeAssignment(int outcome);",
|
||
"event FuelingToDate(uint value);",
|
||
"event FutarchyClosing();",
|
||
"event FutarchyFunding(uint funding);",
|
||
"event FutarchyOracleCreation(",
|
||
"event Issuance(address indexed owner, uint amount);",
|
||
"event MajorityOracleCreation(address indexed creator, MajorityOracle majorityOracle, Oracle[] oracles);",
|
||
"event MarketClosing();",
|
||
"event MarketCreation(Market indexed market);",
|
||
"event MarketCreation(address indexed creator, Market market, Event eventContract, MarketMaker marketMaker, uint24 fee);",
|
||
"event MarketFunding(uint funding);",
|
||
"event Mint(address indexed addr, uint256 indexed value);",
|
||
"event NewCurator(address indexed _newCurator);",
|
||
"event NewMilestoneListAccepted();",
|
||
"event NewMilestoneListProposed();",
|
||
"event NewMilestoneListUnproposed();",
|
||
"event OutcomeAssignment(int outcome);",
|
||
"event OutcomeAssignment(uint difficulty);",
|
||
"event OutcomeAssignment(uint winningMarketIndex);",
|
||
"event OutcomeChallenge(address indexed sender, int outcome);",
|
||
"event OutcomeTokenCreation(OutcomeToken outcomeToken, uint8 index);",
|
||
"event OutcomeTokenPurchase(address indexed buyer, uint8 outcomeTokenIndex, uint outcomeTokenCount, uint cost);",
|
||
"event OutcomeTokenSale(address indexed seller, uint8 outcomeTokenIndex, uint outcomeTokenCount, uint profit);",
|
||
"event OutcomeTokenSetIssuance(address indexed buyer, uint collateralTokenCount);",
|
||
"event OutcomeTokenSetRevocation(address indexed seller, uint outcomeTokenCount);",
|
||
"event OutcomeTokenShortSale(address indexed buyer, uint8 outcomeTokenIndex, uint outcomeTokenCount, uint cost);",
|
||
"event OutcomeVote(address indexed sender, int outcome, uint amount);",
|
||
"event OwnerAddition(address indexed owner);",
|
||
"event OwnerRemoval(address indexed owner);",
|
||
"event OwnerReplacement(address indexed newOwner);",
|
||
"event PayOut(address indexed _recipient, uint _amount);",
|
||
"event ProposalAdded(",
|
||
"event ProposalStatusChanged(uint idProposal, MilestoneStatus newProposal);",
|
||
"event ProposalTallied(uint indexed proposalID, bool result, uint quorum);",
|
||
"event Refund(address indexed to, uint value);",
|
||
"event RequirementChange(uint required);",
|
||
"event Revocation(address indexed owner, uint amount);",
|
||
"event Revocation(address indexed sender, uint indexed transactionId);",
|
||
"event ScalarEventCreation(address indexed creator, ScalarEvent scalarEvent, Token collateralToken, Oracle oracle, int lowerBound, int upperBound);",
|
||
"event SignedMessageOracleCreation(address indexed creator, SignedMessageOracle signedMessageOracle, address oracle);",
|
||
"event SignerReplacement(address indexed newSigner);",
|
||
"event SomeEvent();",
|
||
"event Submission(uint indexed transactionId);",
|
||
"event Test(uint a, uint b,);",
|
||
"event Test(uint a,);",
|
||
"event Transfer();",
|
||
"event Transfer(address indexed _from, address indexed _to, uint256 _amount);",
|
||
"event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _extraData);",
|
||
"event Transfer(address indexed _from, address indexed _to, uint256 indexed _value, bytes _extraData);",
|
||
"event Transfer(address indexed from, address indexed to, uint amount);",
|
||
"event Transfer(address indexed from, address indexed to, uint value);",
|
||
"event Transfer(address indexed from, address indexed to, uint256 value);",
|
||
"event UltimateOracleCreation(",
|
||
"event Verified(string);",
|
||
"event Voted(uint indexed proposalID, bool position, address indexed voter);",
|
||
"event WinningsRedemption(address indexed receiver, uint winnings);",
|
||
"event Withdrawal(address indexed receiver, uint value);",
|
||
"event Withdrawal(address indexed sender, uint amount);",
|
||
"event X() anonymous;",
|
||
"event X();",
|
||
"event X(uint indexed);",
|
||
"event X(uint);",
|
||
"event X(uint, uint indexed);",
|
||
"event X(uint, uint);",
|
||
"event baseEvent(bytes32 indexed evtArgBase);",
|
||
"event derivedEvent(uint indexed evtArgDerived);",
|
||
"event dup();",
|
||
"event e() anonymous;",
|
||
"event e();",
|
||
"event e(uint a, bytes3 indexed s, bool indexed b);",
|
||
"event e(uint a, bytes32 indexed s, bool indexed b);",
|
||
"event e(uint a, bytes32 s);",
|
||
"event e(uint a, string b);",
|
||
"event e(uint indexed a, bytes3 indexed b, bool indexed c, uint indexed d) anonymous;",
|
||
"event e(uint indexed a, bytes3 indexed b, bool indexed c, uint indexed d);",
|
||
"event e(uint indexed a, bytes3 indexed b, bool indexed c, uint indexed d, uint indexed e) anonymous;",
|
||
"event e(uint indexed a, bytes3 indexed s, bool indexed b);",
|
||
"event e(uint indexed a, mapping(uint => uint) indexed b, bool indexed c, uint indexed d, uint indexed e) anonymous;",
|
||
"event e(uint[10] a, bytes7[8] indexed b, c[3] x);",
|
||
"event e(uint[]);",
|
||
"event e1(uint a, uint e1, uint e2);",
|
||
"event e1(uint b, address indexed c);",
|
||
"event e2();",
|
||
"event e2(uint a);",
|
||
"event e2(uint a, uint e1, uint e2);",
|
||
"event e3() anonymous;",
|
||
"event e;",
|
||
"event keccak256();",
|
||
"eventContract = _eventContract;",
|
||
"eventContract = msg.sender;",
|
||
"eventContract = new CategoricalEvent(",
|
||
"eventContract = new ScalarEvent(",
|
||
"eventContract.buyAllOutcomes(_funding);",
|
||
"eventContract.buyAllOutcomes(outcomeTokenCost);",
|
||
"eventContract.buyAllOutcomes(outcomeTokenCount);",
|
||
"eventContract.outcomeTokens(outcomeTokenIndex).approve(address(this), outcomeTokenCount);",
|
||
"eventContract.redeemWinnings();",
|
||
"eventContract.sellAllOutcomes(outcomeTokenProfit);",
|
||
"eventFactory = _eventFactory;",
|
||
"eventFactory,",
|
||
"exchangeAddress = exchangeContractAddress;",
|
||
"executeTransaction(transactionId);",
|
||
"executed: false",
|
||
"expansion = getTotalSupply() * interestRate / interestRateM / 100;",
|
||
"explict_sum.Y == scalar_prod.Y);",
|
||
"extcodecopy(d, mload(0x40), 0, size)",
|
||
"external",
|
||
"externalData = msg.data;",
|
||
"extra = affiliate[affilateAddress].weight;",
|
||
"extra = safeSub(extra * rate / 100, affiliate[affilateAddress].paid);",
|
||
"extraBalance = new ManagedAccount(address(this), true);",
|
||
"extraBalance.payOut(address(this), extraBalance.accumulatedInput());",
|
||
"f := 1",
|
||
"f = abi.decode(msg.data[4 + 32 : 4 + 32 + 32], (uint256));",
|
||
"f = false;",
|
||
"f()",
|
||
"f().x = 2;",
|
||
"f().x;",
|
||
"f();",
|
||
"f()[2] = 21;",
|
||
"f(,1)",
|
||
"f(0);",
|
||
"f(1)",
|
||
"f(1);",
|
||
"f(1, 2)",
|
||
"f(1, 2);",
|
||
"f(1,)",
|
||
"f(1,,1)",
|
||
"f(42);",
|
||
"f(a);",
|
||
"f(a, b);",
|
||
"f(array2d[a], array2d[b], array4d[c][c], tinyArray3d[d], array4d[e]);",
|
||
"f(array2d[x], array2d[y]);",
|
||
"f(array2d[x], array2d[y], c);",
|
||
"f(array2d[x], c);",
|
||
"f(m_g);",
|
||
"f(notfound);",
|
||
"f(severalMaps3d[x][0]);",
|
||
"f(severalMaps[x]);",
|
||
"f(this.callback);",
|
||
"f(x);",
|
||
"f(x, a, b);",
|
||
"f({x: 1, y: 2, z: 3});",
|
||
"f({x: 1, y: 2});",
|
||
"f({x: 1});",
|
||
"f({x:1, y: 2, z: 3});",
|
||
"f({x:1, y: 2});",
|
||
"f({x:1, z: 3});",
|
||
"f({y: 2, x: 1});",
|
||
"f({y: 2, z: 3, x: 1});",
|
||
"f({y: 2});",
|
||
"f({y:2, v: 10, z: 3});",
|
||
"f({z: 3, x: 1, y: 2});",
|
||
"f1();",
|
||
"f1; f2;",
|
||
"f2();",
|
||
"f2(f1);",
|
||
"f2(user_input, 4);",
|
||
"f3();",
|
||
"f4();",
|
||
"f[0];",
|
||
"f[];",
|
||
"fallback () external override {",
|
||
"fallback () external payable {",
|
||
"fallback () external payable {}",
|
||
"fallback () external virtual {",
|
||
"fallback () external {",
|
||
"fallback () external { x = 2; }",
|
||
"fallback () external { }",
|
||
"fallback () internal { }",
|
||
"fallback () payable external { ++x; }",
|
||
"fallback () private { }",
|
||
"fallback () public { }",
|
||
"fallback() external",
|
||
"fallback() external payable {",
|
||
"fallback() external payable { }",
|
||
"fallback() external pure { x = 2; }",
|
||
"fallback() external returns (bytes memory) {}",
|
||
"fallback() external returns (bytes memory, bytes memory) {}",
|
||
"fallback() external returns (uint) { }",
|
||
"fallback() external returns (uint256) {}",
|
||
"fallback() external view { x = 2; }",
|
||
"fallback() external {",
|
||
"fallback() external { data = 1; }",
|
||
"fallback() external { uint x = 3; int y = -4; y ** x; }",
|
||
"fallback() external { x = 2; }",
|
||
"fallback() external { x = 3; }",
|
||
"fallback() external { }",
|
||
"fallback() external {}",
|
||
"fallback() external;",
|
||
"fallback() override external { x = 2; }",
|
||
"fallback() override external {}",
|
||
"fallback() virtual external { x = 1; }",
|
||
"fallback() virtual external {}",
|
||
"fallback() {}",
|
||
"fallback(){}",
|
||
"fallback(uint a) external { x = 2; }",
|
||
"fallback(uint256) external {}",
|
||
"false",
|
||
"false && (c = s).f;",
|
||
"fee = _fee;",
|
||
"fee = value * transactionFeeRate / transactionFeeRateM / 100;",
|
||
"fee) virtual public returns (Market);",
|
||
"fee,",
|
||
"fees = eventContract.collateralToken().balanceOf(address(this));",
|
||
"fees = finalBalance.mul(contributions[msg.sender]) / funding;",
|
||
"finalBalance = eventContract.collateralToken().balanceOf(address(this));",
|
||
"fixed F1 = 3.1415_;",
|
||
"fixed F2 = 3__1.4__15;",
|
||
"fixed F3 = 1_.2;",
|
||
"fixed F4 = 1._2;",
|
||
"fixed F5 = 1.2e_12;",
|
||
"fixed F6 = 1._;",
|
||
"fixed a = 0.42578125 % -0.4271087646484375;",
|
||
"fixed a = 1.0x2;",
|
||
"fixed a = 3.25;",
|
||
"fixed a = 4.5;",
|
||
"fixed a1 = 0.1 % -0.4271087646484375;",
|
||
"fixed a2 = 0.1 % 0.4271087646484375;",
|
||
"fixed a3 = 0 / 0.123;",
|
||
"fixed a4 = 0 / -0.123;",
|
||
"fixed b = .5 % a;",
|
||
"fixed b;",
|
||
"fixed c = 3;",
|
||
"fixed c = a % b;",
|
||
"fixed c = b;",
|
||
"fixed constant L = 10.5;",
|
||
"fixed f1 = 3.14_15;",
|
||
"fixed f2 = 3_1.4_15;",
|
||
"fixed g = 2 ** -2.2;",
|
||
"fixed g = 2 ** -2;",
|
||
"fixed payable j;",
|
||
"fixed(1.5) | 3;",
|
||
"fixed(1.75) & 3;",
|
||
"fixed(1.75) ^ 3;",
|
||
"fixed0x7 a = .3;",
|
||
"fixed16x2 a = 0; a;",
|
||
"fixed16x2 b = -3.25;",
|
||
"fixed16x2 c = -0.5;",
|
||
"fixed256x1 d = -123456781234567979695948382928485849359686494864095409282048094275023098123.5;",
|
||
"fixed256x52 d = -0.0000000000000006661338147750939242541790008544921875;",
|
||
"fixed256x76 e = -0.93322335481643744342575580035176794825198893968114429702091846411734101080123;",
|
||
"fixed256x79 g = -0.0001178860664374434257558003517679482519889396811442970209184641173410108012309;",
|
||
"fixed40x40 pi = 3.14.15;",
|
||
"fixed40x40 pi = 3.14;",
|
||
"fixed40x40 storeMe;",
|
||
"fixed7x8 c = 3.12345678;",
|
||
"fixed80x80 payable k;",
|
||
"fixed8x1 a = 0.1;",
|
||
"fixed8x1 b = 12.7;",
|
||
"fixed8x1 c = -12.8;",
|
||
"fixed8x80 a = -1e-100;",
|
||
"fixed8x888888888888888888888888888888888888888888888888888 b;",
|
||
"fixed99999999999999999999999999999999999999x7 b = 9.5;",
|
||
"fixedString[0.5] = \"Half\";",
|
||
"fixed[3] memory a = [fixed(3.5), fixed(-4.25), fixed(967.125)];",
|
||
"fixed[] b;",
|
||
"flag = f;",
|
||
"flag = true;",
|
||
"flag = x;",
|
||
"flag ? (c = s).f : (c = s).f;",
|
||
"flag ? (c = s).f : false;",
|
||
"flag ? c = s : (c = s);",
|
||
"flag ? c = s : c = s;",
|
||
"flag ? false : (c = s).f;",
|
||
"flagAfter = h.getFlag();",
|
||
"foo g;",
|
||
"foo{gas: 5};",
|
||
"for ( a = (clients[msg.sender].paidUpTo + 1) ; a <= currentSchellingRound ; a++ ) {",
|
||
"for ( a = (providers[addr].data[currHeight].paidUpTo + 1) ; a <= currentSchellingRound ; a++ ) {",
|
||
"for ( a=0 ; a<opponents[from].length ; a++ ) {",
|
||
"for ( a=0 ; a<opponents[to].length ; a++ ) {",
|
||
"for ( uint256 a=0 ; a<addr.length ; a++ ) {",
|
||
"for ( uint256 a=0 ; a<doDB[doHash].length ; a++ ) {",
|
||
"for ( uint256 a=0 ; a<genesisAddr.length ; a++ ) {",
|
||
"for ( uint256 a=0 ; a<modules.length ; a++ ) {",
|
||
"for ( uint256 a=0 ; a<newOwners.length ; a++ ) {",
|
||
"for ( uint256 a=0 ; a<opponents[msg.sender].length ; a++ ) {",
|
||
"for ( uint256 a=currentRound ; a>=currentRound-interestCheckRounds ; a-- ) {",
|
||
"for ( uint256 r=0 ; r < _to ; r++ ) {",
|
||
"for ( uint8 a=0 ; a<icoLevels.length ; a++ ) {",
|
||
"for (; a < 10; a = a + 1) {",
|
||
"for (; x < 10; ) {",
|
||
"for (; x < 10; ++x) {",
|
||
"for (; x == 2; ) {",
|
||
"for (; x == 2;) {",
|
||
"for (; x == 2;) {}",
|
||
"for (; x > 2;) {}",
|
||
"for (;; y++){",
|
||
"for (;;) {",
|
||
"for (;;) {break;}",
|
||
"for (;;) {}",
|
||
"for (i = 0; i < 10; i++)",
|
||
"for (i = 0; i < 10; i++) {",
|
||
"for (i = 0; i < count; ++i) _;",
|
||
"for (i = 0; i < oracles.length; i++)",
|
||
"for (i=0; i<count; i++)",
|
||
"for (i=0; i<milestones.length; i++) {",
|
||
"for (i=0; i<owners.length; i++)",
|
||
"for (i=0; i<transactionCount; i++)",
|
||
"for (i=from; i<to; i++)",
|
||
"for (idx = 0; idx <= selflen - needlelen; idx++) {",
|
||
"for (l = 0; ptr < end; l++) {",
|
||
"for (uint a = 0; a < 10; a = a + 1) {",
|
||
"for (uint a = 0; a < 1; a++) {",
|
||
"for (uint i = 0; i < 23; i++)",
|
||
"for (uint i = 0; i < 2; ++i)",
|
||
"for (uint i = 0; i < 2; i++)",
|
||
"for (uint i = 0; i < 3; i++)",
|
||
"for (uint i = 0; i < 42; i++)",
|
||
"for (uint i = 0; i < 4; i++)",
|
||
"for (uint i = 0; i < _oracles.length; i++)",
|
||
"for (uint i = 0; i < a.length; i++)",
|
||
"for (uint i = 0; i < argumentEncoding.length; i++)",
|
||
"for (uint i = 0; i < data.length; ++i)",
|
||
"for (uint i = 0; i < elements; i++)",
|
||
"for (uint i = 0; i < input.length; i++)",
|
||
"for (uint i = 0; i < invalidLength; i++)",
|
||
"for (uint i = 0; i < l; ++i) {",
|
||
"for (uint i = 0; i < len; i++)",
|
||
"for (uint i = 0; i < n; ++i)",
|
||
"for (uint i = 0; i < n; i += 1) {",
|
||
"for (uint i = 0; i < nums.length; i++)",
|
||
"for (uint i = 0; i < test.length; i++)",
|
||
"for (uint i = 0; i < tree.children.length; i++) {",
|
||
"for (uint i = 0; i < x.length; ++i)",
|
||
"for (uint i = 0; i < x; ++i)",
|
||
"for (uint i = 0; i <= index; ++i)",
|
||
"for (uint i = 1; i < length; i++) {",
|
||
"for (uint i = 3; i < len; i++)",
|
||
"for (uint i=0; i<_owners.length; i++) {",
|
||
"for (uint i=0; i<owners.length - 1; i++)",
|
||
"for (uint i=0; i<owners.length; i++)",
|
||
"for (uint i=0; i<owners.length; i++) {",
|
||
"for (uint i=0; i<transactionCount; i++)",
|
||
"for (uint idx = 0; idx < shortest; idx += 32) {",
|
||
"for (uint j = 0; j < 3; ++j)",
|
||
"for (uint j = 0; j <= i; j++)",
|
||
"for (uint j = i; j <= test.length; j++)",
|
||
"for (uint x = 0; true; x++)",
|
||
"for (uint x = 0; x < 10; true)",
|
||
"for (uint x = 0; x < 10; x ++)",
|
||
"for (uint x = 0; x < 10; x ++){",
|
||
"for (uint y = 2; x < 10; ) {",
|
||
"for (uint y = 2; x < 10; y = 3) {",
|
||
"for (uint256 i = 0; i < 10; i++) {",
|
||
"for (uint256 i = 0; i < 33; i++) data.push(0x03);",
|
||
"for (uint256 i = 0; i < 34; i++) data.push(0x03);",
|
||
"for (uint256 i = 0; i < array.length; i++)",
|
||
"for (uint256 i = 0; i < array.length; i++) {",
|
||
"for (uint256 i = 0; i < data.length; i++) data[i] = bytes1(uint8(i));",
|
||
"for (uint256 i = 0; i < data1.length; ++i) data1[i] = bytes8(uint64(i));",
|
||
"for (uint256 i = 0; i < data2.length; ++i)",
|
||
"for (uint256 i = 0; i < len; i++)",
|
||
"for (uint256 i = 0; i < proof.length; i++) {",
|
||
"for (uint256 i = 0; i < x.length; ++i) x[i] = bytes1(uint8(i + 1));",
|
||
"for (uint256 i = 0; i < x.length; i++) x[i] = this.h;",
|
||
"for (uint256 i = 1; i < 10; i++) {",
|
||
"for (uint256 i = 1; i <= n; i++) {",
|
||
"for (uint256 j = 0; j < 4; j++) data.pop();",
|
||
"for (uint256 j = 1; j < i - 1; j++)",
|
||
"for (uint256 x = 0; x < 10; ++x)",
|
||
"for (uint8 i = 0; i < 15; i++) {",
|
||
"for (uint8 i = 0; i < 32; i++) {",
|
||
"for (uint8 i = 0; i < 33; i++) {",
|
||
"for (uint8 i = 0; i < categoricalEvent.getOutcomeCount(); i++) {",
|
||
"for (uint8 i = 0; i < data.length; i++)",
|
||
"for (uint8 i = 0; i < markets.length; i++) {",
|
||
"for (uint8 i = 0; i < netOutcomeTokensSold.length; i++) {",
|
||
"for (uint8 i = 0; i < outcomeCount; i++)",
|
||
"for (uint8 i = 0; i < outcomeCount; i++) {",
|
||
"for (uint8 i = 0; i < outcomeTokenDistribution.length; i++)",
|
||
"for (uint8 i = 0; i < outcomeTokens.length; i++)",
|
||
"for (uint8 i = 0; i < quantities.length; i++)",
|
||
"for (uint8 i = 1; i < 40; i++)",
|
||
"for (uint8 i = 1; i < 40; i++) {",
|
||
"for (uint8 i = 1; i < markets.length; i++) {",
|
||
"for (x = 0; x < 10; ++x)",
|
||
"for (x = 0; x < 10; ++x) {}",
|
||
"for (x = 10; y < x; ++y)",
|
||
"for (y = 0; y < x; ++y) {}",
|
||
"for (y = 2; x < 10; ) {",
|
||
"for the infos of the provider.",
|
||
"for {",
|
||
"for { c.slot := s.slot } iszero(0) {} {}",
|
||
"for { c.slot := s.slot } iszero(1) {} {}",
|
||
"for { let a := 0} lt(a,1) { a := add(a, 1) } {",
|
||
"for { let i := 0 } not(eq(i, words)) { i := add(i, 1) }",
|
||
"for { } lt(x, 10) { x := add(x, 1) } {",
|
||
"for { } sload(4) { } {",
|
||
"for { } sload(5) { } {",
|
||
"for {let i := 0} lt(i, 10) { i := add(i, 1) }",
|
||
"for {} eq(0,0) { c.slot := s.slot } {}",
|
||
"for {} eq(0,0) {} { c.slot := s.slot }",
|
||
"for {} eq(0,1) { c.slot := s.slot } {}",
|
||
"for {} eq(0,1) {} { c.slot := s.slot }",
|
||
"for {} lt(i, 10) { i := add(i, 1) }",
|
||
"for {} lt(x, 3) { i := 17 x := 9 } {",
|
||
"for(; (c = s).f;) {",
|
||
"for(; len >= 32; len -= 32) {",
|
||
"for(;; c = s) {",
|
||
"for(;;) {",
|
||
"for(c = s;;) {",
|
||
"for(int i = 0; i < 3; i++) { f(); }",
|
||
"for(uint i = 0; i < 10; ++i) {",
|
||
"for(uint i = 0; i < parts.length; i++)",
|
||
"for(uint i = 0; i < parts.length; i++) {",
|
||
"for(uint i = 0; i < values.length; i++)",
|
||
"for(uint256 i = 0; i < l; ++i)",
|
||
"forwardedOracle = _forwardedOracle;",
|
||
"forwardedOutcome = forwardedOracle.getOutcome();",
|
||
"forwardedOutcomeSetTimestamp = block.timestamp;",
|
||
"foundEmptyArrayID = true;",
|
||
"foundationAddress = foundation;",
|
||
"frontRunner = _outcome;",
|
||
"frontRunnerPeriod",
|
||
"frontRunnerPeriod = _frontRunnerPeriod;",
|
||
"frontRunnerSetTimestamp = block.timestamp;",
|
||
"fs = B.f.selector;",
|
||
"ftring a;",
|
||
"funcSelector,",
|
||
"funcTakesExternalMutable(this.externalMutableFunc);",
|
||
"funcTakesExternalMutable(this.externalPayableFunc);",
|
||
"funcTakesExternalMutable(this.externalPureFunc);",
|
||
"funcTakesExternalMutable(this.externalViewFunc);",
|
||
"funcTakesExternalPayable(this.externalPayableFunc);",
|
||
"funcTakesExternalPure(this.externalPureFunc);",
|
||
"funcTakesExternalView(this.externalPureFunc);",
|
||
"funcTakesExternalView(this.externalViewFunc);",
|
||
"funcTakesInternalMutable(internalMutableFunc);",
|
||
"funcTakesInternalMutable(internalPureFunc);",
|
||
"funcTakesInternalMutable(internalViewFunc);",
|
||
"funcTakesInternalPure(internalPureFunc);",
|
||
"funcTakesInternalView(internalPureFunc);",
|
||
"funcTakesInternalView(internalViewFunc);",
|
||
"function ( ) internal returns ( bytes [ ] storage , mapping ( bytes => mapping ( bytes => mapping ( uint => mapping ( bytes => mapping ( string => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( string => mapping ( string => mapping ( uint => mapping ( bytes => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( bytes => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( uint => mapping ( string => mapping ( uint => string ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) [ ] storage ) constant c = c ;",
|
||
"function ( uint ) external returns ( a [ ] calldata ) public a = ( 1 / 2 ) ;",
|
||
"function () external g = this.h;",
|
||
"function () external g_nonpayable = this.h_nonpayable; g_nonpayable;",
|
||
"function () external nonpayFun;",
|
||
"function () external pure pureFun;",
|
||
"function () external view viewFun;",
|
||
"function () g;",
|
||
"function () internal returns (uint) x;",
|
||
"function () payable external g = this.h;",
|
||
"function () payable external g_payable = this.h_payable; g_payable;",
|
||
"function () pure external g = this.h;",
|
||
"function () pure external g_pure = this.h_pure; g_pure;",
|
||
"function () pure external returns (bytes4) fun = this.f;",
|
||
"function () pure returns (uint) x;",
|
||
"function () r = true ? fun_x : fun_y;",
|
||
"function () returns (uint) z = cond ? x : y;",
|
||
"function () view external g = this.h;",
|
||
"function () view external g_view = this.h_view; g_view;",
|
||
"function (D.s storage, uint) returns (uint) g = x.mul;",
|
||
"function (a, b) {}",
|
||
"function (address payable) payable external returns (address payable) h; h;",
|
||
"function (address payable) view internal returns (address payable) f;",
|
||
"function (bytes6 _name) internal setter = setName;",
|
||
"function (function (uint) external returns (uint)) internal returns (uint) ev;",
|
||
"function (string memory) internal pure returns (string memory) var_string_to_string = string_to_string;",
|
||
"function (string memory) internal pure returns (string memory) var_string_to_string = var_uint256_to_string;",
|
||
"function (string memory) internal pure returns (uint256) var_string_to_uint256 = string_to_uint256;",
|
||
"function (string memory) internal pure returns (uint256) var_string_to_uint256 = uint256_to_string;",
|
||
"function (string memory, string memory) internal pure returns (string memory) var_string_string_to_string = string_string_to_string;",
|
||
"function (string memory, string memory) internal pure returns (string memory) var_string_string_to_string = string_to_string;",
|
||
"function (string memory, uint256) internal pure returns (string memory) var_string_uint256_to_string = string_to_string;",
|
||
"function (string memory, uint256) internal pure returns (string memory) var_string_uint256_to_string = string_uint256_to_string;",
|
||
"function (uint x, uint y) internal returns (uint) f;",
|
||
"function (uint) external payable returns (uint) x;",
|
||
"function (uint) external public x;",
|
||
"function (uint) external returns (uint) x;",
|
||
"function (uint) internal payable returns (uint) x;",
|
||
"function (uint) internal returns (uint) x;",
|
||
"function (uint, uint) external returns (uint) g;",
|
||
"function (uint, uint) internal returns (uint) f1 = f;",
|
||
"function (uint, uint) internal returns (uint) f1;",
|
||
"function (uint, uint) modifier1() returns (uint) f1;",
|
||
"function (uint256) internal pure returns (string memory) var_uint256_to_string = uint256_to_string;",
|
||
"function (uint256) internal pure returns (string memory) var_uint256_to_string = uint256_to_string_storage;",
|
||
"function (uint256) internal pure returns (uint256) var_uint256_to_uint256 = uint256_to_string;",
|
||
"function (uint256) internal pure returns (uint256) var_uint256_to_uint256 = uint256_to_uint256;",
|
||
"function (uint256, string memory) internal pure returns (string memory) var_uint256_string_to_string = uint256_string_to_string;",
|
||
"function (uint256, uint256) internal pure returns (string memory) var_uint256_uint256_to_string = uint256_uint256_to_string;",
|
||
"function (uint256, uint256) internal pure returns (uint256) var_uint256_uint256_to_uint256 = uint256_to_uint256;",
|
||
"function (uint256, uint256) internal pure returns (uint256) var_uint256_uint256_to_uint256 = uint256_uint256_to_uint256;",
|
||
"function A() public pure returns (uint8) {}",
|
||
"function Announcements(uint256 id) public view returns (uint256 Type, uint256 Start, uint256 End, bool Closed, string memory Announcement, string memory Link, bool Opposited, string memory _str, uint256 _uint, address _addr) {",
|
||
"function C() {}",
|
||
"function ICObonus() public view returns(uint256 bonus) {",
|
||
"function P1() internal returns (G1Point memory) {",
|
||
"function P2() internal returns (G2Point memory) {",
|
||
"function Source() public {}",
|
||
"function Storage() public {}",
|
||
"function Storage() {}",
|
||
"function TEMath(uint256 a, uint256 b, bool neg) internal returns (uint256) {",
|
||
"function UintToBytes(uint16 h) public returns (bytes8 s) {",
|
||
"function UintToBytes(uint8 h) public returns (bytes1 s) {",
|
||
"function _addOwner(address addr) private {",
|
||
"function _approve(address owner, address spender, uint256 value) internal {",
|
||
"function _approve(address spender, uint256 amount, uint256 nonce) internal {",
|
||
"function _approve(address spender, uint256 amount, uint256 nonce) isReady internal {",
|
||
"function _burn(address account, uint256 value) internal {",
|
||
"function _burn(address owner, uint256 value) internal {",
|
||
"function _burnFrom(address account, uint256 value) internal {",
|
||
"function _connectModule() internal {",
|
||
"function _copyToBytes(uint btsPtr, bytes memory tgt, uint btsLen) private {",
|
||
"function _decode(RLPItem memory self) private view returns (uint memPtr, uint len) {",
|
||
"function _delOwner(address addr) private {",
|
||
"function _disableModule(bool forever) internal {",
|
||
"function _disconnectModule() internal {",
|
||
"function _itemLength(uint memPtr) private view returns (uint len) {",
|
||
"function _mint(address account, uint256 value) internal {",
|
||
"function _mint(address owner, uint256 value) internal {",
|
||
"function _mint(address owner, uint256 value) isReady internal {",
|
||
"function _payloadOffset(RLPItem memory self) private view returns (uint) {",
|
||
"function _processTransactionFee(address owner, uint256 value) internal {",
|
||
"function _replaceModule(address payable newModuleAddress) internal {",
|
||
"function _replaceModuleHandler(address payable newModuleHandlerAddress) internal {",
|
||
"function _transfer(address from, address to, uint256 amount) isReady internal {",
|
||
"function _transfer(address from, address to, uint256 amount, bool fee) internal {",
|
||
"function _transfer(address from, address to, uint256 value) internal {",
|
||
"function _transferToContract(address from, address to, uint256 amount, bytes memory extraData) internal {",
|
||
"function _validate(RLPItem memory self) private view returns (bool ret) {",
|
||
"function a() internal view override returns (uint256) { return 42;}",
|
||
"function a() internal view virtual returns(uint256);",
|
||
"function a() public pure returns (bool payable) {}",
|
||
"function a() public pure returns(int[0][500] memory) {}",
|
||
"function a() public pure {",
|
||
"function a() public pure {}",
|
||
"function a() public returns (uint256 x) {",
|
||
"function a() public returns (uint256) {",
|
||
"function a() public returns(uint n) { return 0; }",
|
||
"function a() public virtual;",
|
||
"function a() public {",
|
||
"function a(bool payable) public pure {}",
|
||
"function a(bytes32 h, uint8 v, bytes32 r, bytes32 s) public returns (address addr) {",
|
||
"function a(function(Nested) external) external pure {}",
|
||
"function a(function(Nested)) external pure {}",
|
||
"function a(function(function(function(Nested)))) external pure {}",
|
||
"function a(uint a, uint b) public returns (uint r) {",
|
||
"function a(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; }",
|
||
"function a(uint a, uint b, uint c) returns (uint r) { r = a * 100 + b * 10 + c * 1; }",
|
||
"function a(uint i) public returns (uint) {",
|
||
"function a(uint i, uint j) public returns (uint) {",
|
||
"function a(uint index) public view returns (bytes1) {",
|
||
"function a(uint index) public view returns (uint) {",
|
||
"function a(uint256 x) public returns (uint256) {",
|
||
"function a(uint256) public returns (uint) { return 1; }",
|
||
"function a(uint8) public returns (uint) { return 1; }",
|
||
"function abortICO() external {",
|
||
"function acceptProposedMilestones(bytes32 _hashProposals",
|
||
"function accessIndex(uint256 len, int256 idx) public returns (uint256)",
|
||
"function actualBalance() public view returns (uint _actualBalance) {",
|
||
"function add() public pure returns (uint8, uint8) {",
|
||
"function add(G1Point memory p1, G1Point memory p2) internal returns (G1Point memory r) {",
|
||
"function add(bytes2 a, bytes2 b) internal pure returns (bytes2) {",
|
||
"function add(int a, int b)",
|
||
"function add(uint a, uint b)",
|
||
"function add(uint a, uint b) pure returns (uint) {",
|
||
"function add(uint x, uint y) internal pure returns (uint) {",
|
||
"function add(uint x, uint y) public pure returns (uint) {",
|
||
"function add(uint256 a, uint256 b) internal pure returns (uint256) {",
|
||
"function add(uint256 v) public {",
|
||
"function addFunds(uint256 amount) isReady noContract external {",
|
||
"function addModule(modules_s memory input, bool call) internal {",
|
||
"function addOwner(address owner)",
|
||
"function addTestStruct(TestStruct memory) public pure {}",
|
||
"function addTransaction(address destination, uint value, bytes memory data)",
|
||
"function addTwo(uint256 x) public returns (uint256) {",
|
||
"function addr() public view returns (bool) {",
|
||
"function allowUsers(address provider, address[] calldata addr) isReady external {",
|
||
"function allowance(",
|
||
"function allowance(address _owner, address _spender)",
|
||
"function allowance(address _owner, address _spender) public override view returns (uint256 remaining) {",
|
||
"function allowance(address owner, address spender)",
|
||
"function allowance(address owner, address spender) public view returns (uint256 remaining, uint256 nonce) {",
|
||
"function allowance(address owner, address spender) public view returns (uint256) {",
|
||
"function allowance(address owner, address spender) virtual public view returns (uint);",
|
||
"function and(uint x) public returns (bool t, uint y) {",
|
||
"function answer() public returns (Choice _ret) {",
|
||
"function answer() public returns (base.Choice _ret) {",
|
||
"function answer() public returns (test.Choice _ret) {",
|
||
"function applyShift(function (bytes6 _value, uint _shift) internal returns (bytes6) _shiftOperator, uint _bytes) internal {",
|
||
"function approve(address _spender, uint256 _amount) public override returns (bool success) {",
|
||
"function approve(address _spender, uint256 _amount) public virtual returns (bool success);",
|
||
"function approve(address _spender, uint256 _value)",
|
||
"function approve(address spender, uint value)",
|
||
"function approve(address spender, uint value) virtual public returns (bool);",
|
||
"function approve(address spender, uint256 amount, uint256 nonce) isReady external returns (bool success) {",
|
||
"function approve(address spender, uint256 value) public returns (bool) {",
|
||
"function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)",
|
||
"function approveAndCall(address spender, uint256 amount, uint256 nonce, bytes calldata extraData) isReady external returns (bool success) {",
|
||
"function approveCompletedMilestone(uint _idMilestone)",
|
||
"function approvedCorionPremiumToken(address, uint256, bytes calldata) external returns (bool) {}",
|
||
"function approvedCorionToken(address, uint256, bytes calldata) external returns (bool) {}",
|
||
"function arbitrateApproveMilestone(uint _idMilestone",
|
||
"function arbitrateCancelCampaign() public onlyArbitrator campaignNotCanceled {",
|
||
"function asmfun(a, b, c) -> x, y, z {",
|
||
"function assert0() external view {",
|
||
"function assert0_delegated() external returns (bool) {",
|
||
"function assert0_delegated() external returns (bool, bytes memory) {",
|
||
"function assign()",
|
||
"function assignment() public {",
|
||
"function associated() public returns (uint) {",
|
||
"function at(mapping(uint => uint) storage a, uint i) internal view returns (uint) {",
|
||
"function at(string memory a, uint i) internal pure returns (uint8) {",
|
||
"function at(uint[2] memory a, uint i) internal pure returns (uint) {",
|
||
"function at(uint[] memory a, uint i) internal pure returns (uint) {",
|
||
"function authorizePayment(uint _idMilestone) internal {",
|
||
"function b() public pure returns (string payable) {}",
|
||
"function b() public pure returns (uint) { return c(); }",
|
||
"function b() public pure returns(uint[0][500] memory) {}",
|
||
"function b() public pure { a(); }",
|
||
"function b() public returns (uint r) {",
|
||
"function b() public returns (uint r) { r = a({a: 1, b: 2, c: 3}); }",
|
||
"function b() public returns (uint r) { r = a({c: 3, a: 1, b: 2}); }",
|
||
"function b() public returns (uint) { return c(42); }",
|
||
"function b() public returns(uint n) { return 1; }",
|
||
"function b() public view returns(uint256) { return a(); }",
|
||
"function b() public {}",
|
||
"function b() returns (uint r) { r = a({: 1, : 2, : 3}); }",
|
||
"function b() returns (uint r) { r = a({a: , b: , c: }); }",
|
||
"function b() returns (uint r) { r = a({a: 1, b: 2, c: 3, }); }",
|
||
"function b(C) public returns (A) {",
|
||
"function b(function(Nested calldata) external returns (uint)[] storage) external pure {}",
|
||
"function b(function(Nested memory) external returns (uint)[] storage) internal pure {}",
|
||
"function b(string payable) public pure {}",
|
||
"function b(uint a) public {",
|
||
"function b(uint256 x) public returns (uint256) {",
|
||
"function bInit(uint c) public {",
|
||
"function bInit(uint c, uint d) public {",
|
||
"function balance() public payable returns (uint256) {",
|
||
"function balance() public returns (uint) {",
|
||
"function balance() public returns (uint256) {",
|
||
"function balance(uint number) public {}",
|
||
"function balanceOf() external virtual view returns (uint) {}",
|
||
"function balanceOf(address _owner)",
|
||
"function balanceOf(address _owner) public override view returns (uint256 balance) {",
|
||
"function balanceOf(address _owner) public virtual view returns (uint256 balance);",
|
||
"function balanceOf(address owner)",
|
||
"function balanceOf(address owner) public view returns (bool success, uint256 value) {",
|
||
"function balanceOf(address owner) public view returns (uint256 value) {",
|
||
"function balanceOf(address owner) public view returns (uint256) {",
|
||
"function balanceOf(address owner) virtual public view returns (uint);",
|
||
"function balanceOf(address payable owner) public view returns (bool success, uint256 value) {}",
|
||
"function balanceOf(address) external virtual view returns (uint) {}",
|
||
"function balanceOf(address, uint) external virtual view returns (uint) {}",
|
||
"function balanceOf(uint) external virtual view returns (uint) {}",
|
||
"function bar() internal returns (uint) {",
|
||
"function bar() public only_owner virtual;",
|
||
"function bar(uint256 a, uint16 b) public returns (bytes32 d) {",
|
||
"function bar(uint256 value) public pure returns (uint256) {",
|
||
"function bar(uint256 value) public returns (uint256) {",
|
||
"function baseFunction(uint p) public returns (uint i) { return p; }",
|
||
"function basic() public pure returns(bool) {",
|
||
"function basic() public pure {",
|
||
"function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {",
|
||
"function bignum() public {",
|
||
"function bitnot(int256 a) public pure returns (int256)",
|
||
"function bitnot_s8() public pure returns (int256 ret)",
|
||
"function bitnot_u8(uint8 a) public pure returns (uint256 ret)",
|
||
"function blockhash(uint256 blockNumber) public returns(bytes32) { bytes32 x; return x; }",
|
||
"function boo() public returns (bytes4 value) {",
|
||
"function boo(uint32 a) public pure returns (uint b) { return a * 4; }",
|
||
"function boo(uint32 a) public view returns(uint b) { return a * 4; }",
|
||
"function broadcastSchellingRound(uint256 roundID, uint256 reward) external returns (bool success) {",
|
||
"function broadcastTransfer(address from, address to, uint256 value) external returns (bool success) {",
|
||
"function burn(address from, uint256 value) external returns (bool success) {",
|
||
"function burn(address owner, uint256 value) isReady external returns (bool success) {",
|
||
"function buy(address payable beneficiaryAddress, address affilateAddress) public payable returns (bool success) {",
|
||
"function buy(uint8 outcomeTokenIndex, uint outcomeTokenCount, uint maxCost)",
|
||
"function buy(uint8 outcomeTokenIndex, uint outcomeTokenCount, uint maxCost) virtual public returns (uint);",
|
||
"function buyAllOutcomes(uint collateralTokenCount)",
|
||
"function bytesCompare(bytes memory a, bytes memory b) internal pure returns (bool) {",
|
||
"function bytesNN() public pure returns (bytes3 x) {",
|
||
"function bytesNN_padded() public pure returns (bytes4 x) {",
|
||
"function bytesToBytes(bytes2 input) public returns (bytes4 ret) {",
|
||
"function bytesToBytes(bytes4 input) public returns (bytes2 ret) {",
|
||
"function bytesToBytes(bytes4 input) public returns (bytes4 ret) {",
|
||
"function bytesToUint(bytes1 s) public returns (uint8 h) {",
|
||
"function bytesToUint(bytes32 s) public returns (uint256 h) {",
|
||
"function bytesToUint(bytes4 s) public returns (uint16 h) {",
|
||
"function bytesToUint(bytes4 s) public returns (uint64 h) {",
|
||
"function c() public pure returns (int payable) {}",
|
||
"function c() public pure returns (uint) { return 42; }",
|
||
"function c() public pure returns(byte[0][500] memory) {}",
|
||
"function c() public returns(uint n) { return 2; }",
|
||
"function c(function(Nested memory) external returns (uint)[] memory) public pure {}",
|
||
"function c(function(Nested memory) external returns (uint)[] storage) external pure {}",
|
||
"function c(int payable) public pure {}",
|
||
"function c(uint _y) public returns (uint) {",
|
||
"function c(uint b) public returns (uint e) { return b * 8; }",
|
||
"function c(uint256 a, uint256[] memory b) public {",
|
||
"function c(uint256 x) public returns (uint256) {",
|
||
"function cInit(uint c) public {",
|
||
"function cInit(uint c, uint d) public {",
|
||
"function ca() public returns (uint256) {",
|
||
"function calcCost(Market market, uint8 outcomeTokenIndex, uint outcomeTokenCount)",
|
||
"function calcCost(Market market, uint8 outcomeTokenIndex, uint outcomeTokenCount) virtual public view returns (uint);",
|
||
"function calcCostLevel(int logN, int[] memory netOutcomeTokensSold, uint funding)",
|
||
"function calcDoHash(string memory job, bytes32 data) public pure returns (bytes32 hash) {",
|
||
"function calcMarginalPrice(Market market, uint8 outcomeTokenIndex)",
|
||
"function calcMarginalPrice(Market market, uint8 outcomeTokenIndex) virtual public view returns (uint);",
|
||
"function calcMarketFee(uint outcomeTokenCost)",
|
||
"function calcMarketFee(uint outcomeTokenCost) virtual public view returns (uint);",
|
||
"function calcMaxWithdraw()",
|
||
"function calcProfit(Market market, uint8 outcomeTokenIndex, uint outcomeTokenCount)",
|
||
"function calcProfit(Market market, uint8 outcomeTokenIndex, uint outcomeTokenCount) virtual public view returns (uint);",
|
||
"function call() internal {",
|
||
"function call() public payable returns (uint v, uint x, uint y, uint z) {",
|
||
"function call(uint num) public returns (uint256) {",
|
||
"function callDisableCallback(string calldata moduleName) external returns (bool success) {",
|
||
"function callReplaceCallback(string calldata moduleName, address newModule) external returns (bool success) {",
|
||
"function callWithSuper() public {",
|
||
"function callZ() public view returns (uint) {",
|
||
"function call_deleted_internal_func() public pure returns (bool ret)",
|
||
"function call_internal_func() public pure returns (bool ret)",
|
||
"function callback(bytes calldata) pure external {}",
|
||
"function callcode() pure public {",
|
||
"function cancelDo(bytes32 doHash) external {",
|
||
"function cancelMilestone(uint _idMilestone)",
|
||
"function challengeOutcome(int _outcome)",
|
||
"function changeAllowedRecipients(address _recipient, bool _allowed) external",
|
||
"function changeAllowedRecipients(address _recipient, bool _allowed) virtual external returns (bool _success);",
|
||
"function changeArbitrator(address _newArbitrator) public onlyArbitrator {",
|
||
"function changeDailyLimit(uint _dailyLimit)",
|
||
"function changeDonor(address _newDonor) public onlyDonor {",
|
||
"function changeIt() public { x = 9; }",
|
||
"function changeProposalDeposit(uint _proposalDeposit) external override {",
|
||
"function changeProposalDeposit(uint _proposalDeposit) virtual external;",
|
||
"function changeRecipient(address _newRecipient) public onlyRecipient {",
|
||
"function changeRequirement(uint _required)",
|
||
"function check() public returns (bool ok) {",
|
||
"function check() public returns (bytes memory) {",
|
||
"function checkCorrectRate(bool priv, uint8 rate) internal returns(bool) {",
|
||
"function checkEncodedCall(",
|
||
"function checkFloatingOwnSupply(address providerAddress, uint256 providerHeight, bool neg, uint256 value) internal {",
|
||
"function checkFloatingSupply(address providerAddress, uint256 providerHeight, bool neg, uint256 value) internal {",
|
||
"function checkICO() internal returns (bool isICO) {",
|
||
"function checkInterest(address addr) public view returns(uint256 amount) {",
|
||
"function checkOk() public returns (bool) { return ok(); }",
|
||
"function checkOpposited(uint256 weight, bool oppositable) public view returns (bool success) {",
|
||
"function checkPremium(address owner) internal {",
|
||
"function checkProposalCode(",
|
||
"function checkReward() public view returns (uint256 reward) {",
|
||
"function checkReward(address addr) public returns (uint256 reward) {",
|
||
"function checkState() public returns (bool flagAfter, uint256 myBal) {",
|
||
"function checkState() public returns(bool flagAfter, uint myBal) {",
|
||
"function checkVote() isReady noContract external {",
|
||
"function close()",
|
||
"function close() virtual public;",
|
||
"function closeAnnouncement(uint256 id) onlyOwner external {",
|
||
"function closeICO() external {",
|
||
"function closeIco() external returns (bool success) {",
|
||
"function closeMarket()",
|
||
"function closeProposal(uint _proposalID) internal {",
|
||
"function closeProvider() isReady external {",
|
||
"function coder_calldata_external(S0 calldata p_0, bool p_1) external pure returns (uint) {",
|
||
"function coder_calldata_external(bytes30 p_0) external pure returns (uint) {",
|
||
"function coder_calldata_public(S0 memory p_0, bool p_1) public pure returns (uint) {",
|
||
"function coder_calldata_public(bytes30 p_0) public pure returns (uint) {",
|
||
"function coder_external() external view returns (uint) {",
|
||
"function coder_external(bool[] calldata c_0, bool[][1][1][][] calldata c_1) external view returns (uint) {",
|
||
"function coder_external(string[] calldata c_0, bytes[][1][1][][] calldata c_1) external view returns (uint) {",
|
||
"function coder_public() public view returns (uint) {",
|
||
"function coder_public(bool[] memory c_0, bool[][1][1][][] memory c_1) public view returns (uint) {",
|
||
"function coder_public(string[] memory c_0, bytes[][1][1][][] memory c_1) public view returns (uint) {",
|
||
"function combine(uint8 a, uint8 x, uint16 y, uint256 z)",
|
||
"function combine(uint8 x, uint16 y, uint256 z)",
|
||
"function combined() public pure returns (bytes32) {",
|
||
"function combined() public pure returns (string memory) {",
|
||
"function compare(bytes memory x, bytes memory y) internal {",
|
||
"function compare(slice memory self, slice memory other) internal pure returns (int) {",
|
||
"function concat(slice memory self, slice memory other) internal pure returns (string memory) {",
|
||
"function configure(announcementType a, uint256 b) external returns(bool) {",
|
||
"function configure(announcementType aType, uint256 value) isReady external returns(bool success) {",
|
||
"function configureModule(string calldata moduleName, announcementType aType, uint256 value) external returns (bool success) {",
|
||
"function confirmTransaction(uint transactionId)",
|
||
"function connectModule() external override returns (bool success) {",
|
||
"function connectModule() external returns (bool success) {}",
|
||
"function connectModule() virtual external onlyForModuleHandler returns (bool success) {",
|
||
"function connectTokens(address payable tokenContractAddr, address payable premiumContractAddr) external {",
|
||
"function constructor();",
|
||
"function contains(slice memory self, slice memory needle) internal pure returns (bool) {",
|
||
"function contractMin() public {",
|
||
"function convertParent() public returns (uint256) {",
|
||
"function convertSubA() public returns (uint256, uint256) {",
|
||
"function convertSubB() public returns (uint256, uint256) {",
|
||
"function copy(slice memory self) internal pure returns (slice memory) {",
|
||
"function copy(uint256 from, uint256 to) public returns (bool) {",
|
||
"function copyFromTree(Tree memory tree, uint256[] memory data, uint256 offset) internal returns (uint256) {",
|
||
"function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {",
|
||
"function countData(Tree memory tree) internal returns (uint256 c) {",
|
||
"function create() public {",
|
||
"function create(address[] memory _owners, uint _required)",
|
||
"function create(address[] memory _owners, uint _required, uint _dailyLimit)",
|
||
"function create(uint256 len) public returns (uint256)",
|
||
"function createC() public returns (C) {",
|
||
"function createCampaigns(",
|
||
"function createCategoricalEvent(",
|
||
"function createCentralizedOracle(bytes memory ipfsHash)",
|
||
"function createChild() public {",
|
||
"function createDAO(",
|
||
"function createDifficultyOracle(uint blockNumber)",
|
||
"function createEncoding(",
|
||
"function createFutarchyOracle(",
|
||
"function createMajorityOracle(Oracle[] memory oracles)",
|
||
"function createMarket()",
|
||
"function createMarket(Event eventContract, MarketMaker marketMaker, uint24",
|
||
"function createMarket(Event eventContract, MarketMaker marketMaker, uint24 fee)",
|
||
"function createNewDAO(address payable _newCurator) internal returns (DAO _newDAO) {",
|
||
"function createProvider(bool priv, string calldata name, string calldata website, string calldata country, string calldata info, uint8 rate, bool isForRent, address payable admin) isReady external {",
|
||
"function createScalarEvent(",
|
||
"function createSignedMessageOracle(bytes32 descriptionHash, uint8 v, bytes32 r, bytes32 s)",
|
||
"function createTokenProxy(address payable _tokenHolder) payable public",
|
||
"function createTokenProxy(address payable _tokenHolder) payable virtual public returns (bool success);",
|
||
"function createUltimateOracle(",
|
||
"function createWithValue(bytes memory c, uint256 value) public payable returns (bool) {",
|
||
"function creation() public pure returns (bytes memory) {",
|
||
"function creationBase() public pure returns (bytes memory) {",
|
||
"function creationOther() public pure returns (bytes memory) {",
|
||
"function d() external virtual;",
|
||
"function d() public pure returns (int256 payable) {}",
|
||
"function d() public pure returns(bytes32[0][500] memory) {}",
|
||
"function d() public returns (uint) {",
|
||
"function d() public returns (uint256) {",
|
||
"function d() public {",
|
||
"function d(bytes memory _data) public pure returns (uint8) {",
|
||
"function d(function(Nested memory) external returns (uint)[] calldata) external pure {}",
|
||
"function d(function(Nested storage) external returns (uint)[] storage) external pure {}",
|
||
"function d(int256 payable) public pure {}",
|
||
"function d(uint n) external pure returns (uint[] memory) {",
|
||
"function d(uint256 x) public returns (uint256) {",
|
||
"function data() internal view returns (S storage _data) {",
|
||
"function dec_post() public pure returns (uint8) {",
|
||
"function dec_pre() public pure returns (uint8) {",
|
||
"function decrease(address owner, uint256 value) external returns(bool success) {",
|
||
"function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {",
|
||
"function delLocal() public returns (uint res){",
|
||
"function delLocal() public returns (uint res1, uint res2){",
|
||
"function deleteIt() public returns (uint256) {",
|
||
"function deleteMember() public returns (uint256 ret_value) {",
|
||
"function deposit()",
|
||
"function derivedFunction(bytes32 p) public returns (bytes32 i) { return p; }",
|
||
"function destroy()",
|
||
"function destroy() public view {}",
|
||
"function destroy() public view;",
|
||
"function diff() public pure returns (uint256 remainder) {",
|
||
"function different_salt() public returns (bool) {",
|
||
"function disableModule(bool forever) external onlyForModuleHandler returns (bool success) {",
|
||
"function disableModule(bool forever) external returns (bool success) {}",
|
||
"function disallowUsers(address provider, address[] calldata addr) isReady external {",
|
||
"function disconnectModule() external onlyForModuleHandler returns (bool success) {",
|
||
"function disconnectModule() external returns (bool success) {}",
|
||
"function div() public pure returns (uint8, uint8) {",
|
||
"function div(uint256 a, uint256 b) internal pure returns (uint256) {",
|
||
"function div(uint256 a, uint256 b) public returns (uint256) {",
|
||
"function divisor() public override view returns (uint divisor) {",
|
||
"function divisor() public virtual view returns (uint divisor);",
|
||
"function doSomething() public {",
|
||
"function double(function(uint) external pure returns (uint) f, uint x) internal pure returns (uint) {",
|
||
"function double(function(uint) internal pure returns (uint) f, uint x) internal pure returns (uint) {",
|
||
"function double(uint256 _arg) public returns (uint256 _ret) {",
|
||
"function dropModule(string calldata name, bool callCallback) external returns (bool success) {",
|
||
"function dropOwner(address addr) external {",
|
||
"function dt(uint n) public view returns (uint) {",
|
||
"function dummy() external {}",
|
||
"function dup() public returns (uint) {",
|
||
"function dyn(uint ptr, uint start, uint x) public returns (bytes memory a) {",
|
||
"function e() external pure {}",
|
||
"function e() public payable returns (uint) {",
|
||
"function e() public pure returns (uint payable) {}",
|
||
"function e() public pure returns(bytes[0][500] memory) {}",
|
||
"function e() public pure returns(string[0][500] memory) {}",
|
||
"function e() public pure {",
|
||
"function e() public returns (uint256) {",
|
||
"function e() public view {",
|
||
"function e() pure public {",
|
||
"function e(bytes memory a) public pure returns (uint) { return 7; }",
|
||
"function e(bytes memory b) public pure returns (bytes memory) {",
|
||
"function e(uint payable) public pure {}",
|
||
"function e(uint256 x) public returns (uint256) {",
|
||
"function empty(slice memory self) internal pure returns (bool) {",
|
||
"function enc_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_bytes_reference(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_packed_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_packed_bytes_reference(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_packed_uint256(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_packed_uint256_reference(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_uint256(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function enc_uint256_reference(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {",
|
||
"function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {",
|
||
"function enlarge(uint256 amount) public returns (uint256) {",
|
||
"function eq() public pure returns (bool) {",
|
||
"function eq(uint a, uint b) public pure returns (bool) {",
|
||
"function equal() public pure returns (bool same, bool diff, bool inv) {",
|
||
"function equals(E a, E b) internal pure returns (bool) {",
|
||
"function equals(address a, address b) internal pure returns (bool) {",
|
||
"function equals(slice memory self, slice memory other) internal pure returns (bool) {",
|
||
"function equalsA(uint choice) public returns (bool) {",
|
||
"function eval(function(uint) external returns (uint) x, uint a) public returns (uint) {",
|
||
"function eval(function(uint) external returns (uint) y) public returns (uint) {",
|
||
"function eval(function(uint) internal returns (uint) x, uint a) internal returns (uint) {",
|
||
"function exec() external returns(uint){",
|
||
"function executeProposal(",
|
||
"function executeTransaction(uint transactionId)",
|
||
"function exp(int x)",
|
||
"function exp(uint base, uint exponent) pure returns (uint power) {",
|
||
"function ext() external { }",
|
||
"function ext() external {}",
|
||
"function extendICO() external {",
|
||
"function extern() public returns (uint256) {",
|
||
"function externalCall() public {",
|
||
"function externalMutableFunc(uint256 x) external returns (uint256) { return x; }",
|
||
"function externalMutableFunc(uint256 x) external returns (uint256) { y = x; return x; }",
|
||
"function externalPayableFunc(uint256 x) external payable returns (uint256) { return x + y; }",
|
||
"function externalPayableFunc(uint256 x) external payable returns (uint256) { return x; }",
|
||
"function externalPureFunc(uint256 x) external pure returns (uint256) { return x; }",
|
||
"function externalViewFunc(uint256 x) external view returns (uint256) { return x + y; }",
|
||
"function externalViewFunc(uint256 x) external view returns (uint256) { return x; }",
|
||
"function extract(S memory s, uint256 which) internal returns (uint256 x) {",
|
||
"function extract(X memory s, uint256 which) internal returns (uint256 x) {",
|
||
"function f ( ) public {",
|
||
"function f ( ) public { function ( function ( bytes9 , uint ) external pure returns ( uint ) , uint ) external pure returns ( uint ) [ 3 ] memory s2 ;",
|
||
"function f () public",
|
||
"function f (a, b , c ) - > y,x,z {",
|
||
"function f (a, b , c ) -> y,x,z {",
|
||
"function f (uint256[] calldata x) external pure {",
|
||
"function f(",
|
||
"function f() -> o1 {",
|
||
"function f() -> t {",
|
||
"function f() -> x, y, z {}",
|
||
"function f() costs(1 ether) public payable {}",
|
||
"function f() costs(1 ether) public pure {}",
|
||
"function f() costs(1 ether) public view {}",
|
||
"function f() external m pure returns (uint);",
|
||
"function f() external override (A, B) {}",
|
||
"function f() external override (A, B);",
|
||
"function f() external override (I, J) {}",
|
||
"function f() external override virtual;",
|
||
"function f() external override {}",
|
||
"function f() external override(A, I) {}",
|
||
"function f() external payable returns (uint) { assert(msg.value > 0); return 1; }",
|
||
"function f() external payable {}",
|
||
"function f() external pure returns (mapping(uint=>uint) storage m) {",
|
||
"function f() external pure returns (mapping(uint=>uint)[] storage m) {",
|
||
"function f() external pure returns (uint);",
|
||
"function f() external pure returns (uint256);",
|
||
"function f() external pure returns(int) { return 42; }",
|
||
"function f() external pure virtual override returns (uint) { return 2; }",
|
||
"function f() external pure {",
|
||
"function f() external pure {}",
|
||
"function f() external returns (address) {",
|
||
"function f() external returns (bytes4) {",
|
||
"function f() external returns (uint) {",
|
||
"function f() external returns (uint);",
|
||
"function f() external returns (uint, uint) { return (x, y); }",
|
||
"function f() external returns (uint256) {}",
|
||
"function f() external view returns (uint256);",
|
||
"function f() external view returns(uint) {",
|
||
"function f() external view returns(uint) { return x; }",
|
||
"function f() external view virtual returns (uint) { return 1; }",
|
||
"function f() external view {",
|
||
"function f() external view {}",
|
||
"function f() external virtual override (I, J);",
|
||
"function f() external virtual override returns (uint) { return 2; }",
|
||
"function f() external virtual override returns (uint);",
|
||
"function f() external virtual override {}",
|
||
"function f() external virtual override(A, B);",
|
||
"function f() external virtual override;",
|
||
"function f() external virtual pure {}",
|
||
"function f() external virtual returns (uint);",
|
||
"function f() external virtual returns (uint256) {",
|
||
"function f() external virtual returns (uint256, string memory);",
|
||
"function f() external virtual {}",
|
||
"function f() external virtual;",
|
||
"function f() external {}",
|
||
"function f() external;",
|
||
"function f() internal",
|
||
"function f() internal override returns (uint256) {",
|
||
"function f() internal override(A, B) returns(uint) {",
|
||
"function f() internal pure returns (S storage c) {",
|
||
"function f() internal pure returns (S storage) {",
|
||
"function f() internal pure returns (mapping(uint=>uint) storage r) { }",
|
||
"function f() internal pure returns (mapping(uint=>uint) storage) {}",
|
||
"function f() internal pure returns (uint, bool, uint) {",
|
||
"function f() internal pure returns (uint, uint) {",
|
||
"function f() internal pure returns (uint, uint, uint, S storage, uint, uint) {",
|
||
"function f() internal pure returns (uint, uint, uint, uint) {",
|
||
"function f() internal pure returns(uint _x, uint _y) {",
|
||
"function f() internal pure virtual returns (uint) { return 0; }",
|
||
"function f() internal pure {",
|
||
"function f() internal pure { }",
|
||
"function f() internal pure {}",
|
||
"function f() internal returns (S storage r)",
|
||
"function f() internal returns (mapping(uint8 => uint8) storage r) {",
|
||
"function f() internal returns (string memory, uint, uint, uint) {",
|
||
"function f() internal returns (uint x) {",
|
||
"function f() internal returns (uint) {",
|
||
"function f() internal returns (uint) {}",
|
||
"function f() internal returns (uint256 i) {",
|
||
"function f() internal returns (uint256) {",
|
||
"function f() internal returns (uint[] storage a)",
|
||
"function f() internal returns (uint[] storage ptr1, uint[][] storage ptr2) {",
|
||
"function f() internal returns(uint) { return x + 2; }",
|
||
"function f() internal returns(uint) { return x = 2; }",
|
||
"function f() internal returns(uint) { return x; }",
|
||
"function f() internal view override returns(uint) { return readX(); }",
|
||
"function f() internal view returns (S memory c) {",
|
||
"function f() internal view returns (S storage c) {",
|
||
"function f() internal view returns (S storage, uint) {",
|
||
"function f() internal view returns (mapping(uint=>uint) storage r) { r = m; }",
|
||
"function f() internal view returns (mapping(uint=>uint) storage) {",
|
||
"function f() internal view returns (mapping(uint=>uint) storage) { return m; }",
|
||
"function f() internal view returns (mapping(uint=>uint)[] storage) {",
|
||
"function f() internal view returns (uint[] storage s) {",
|
||
"function f() internal view returns(uint[] storage a)",
|
||
"function f() internal view virtual returns(uint) { return 1; }",
|
||
"function f() internal view {",
|
||
"function f() internal virtual returns (uint256) {",
|
||
"function f() internal virtual returns(uint) { return 3; }",
|
||
"function f() internal virtual returns(uint[] storage);",
|
||
"function f() internal {",
|
||
"function f() internal { b[0] += 1; }",
|
||
"function f() internal {}",
|
||
"function f() internal;",
|
||
"function f() m m public {",
|
||
"function f() m n public {",
|
||
"function f() m public payable {",
|
||
"function f() m public view {",
|
||
"function f() m public {",
|
||
"function f() m(1 ether, msg.value) public pure {}",
|
||
"function f() m(1 ether, msg.value) public view {}",
|
||
"function f() m1(b = s) m2(b) internal view returns (uint[] storage b) {}",
|
||
"function f() m1(b) m2(b = s) internal view returns (uint[] storage b) {}",
|
||
"function f() mod(a) internal returns (uint[] storage a)",
|
||
"function f() mod(x) pure public { uint x = 7; }",
|
||
"function f() mod1(2, true) mod2(\"0123456\") pure public { }",
|
||
"function f() mod1(true) public { }",
|
||
"function f() mod2(\"0123456\") pure public { }",
|
||
"function f() mutex public {",
|
||
"function f() override internal {}",
|
||
"function f() override view external {}",
|
||
"function f() override(inter1, inter2) public {}",
|
||
"function f() payable external {}",
|
||
"function f() payable internal {}",
|
||
"function f() payable payable {}",
|
||
"function f() payable private {}",
|
||
"function f() payable public returns (C) {",
|
||
"function f() payable public {",
|
||
"function f() payable public {}",
|
||
"function f() payable view {}",
|
||
"function f() private external {}",
|
||
"function f() private pure returns(uint[] memory, uint[] storage b) { b = b; }",
|
||
"function f() private pure returns(uint[]) {}",
|
||
"function f() private pure {}",
|
||
"function f() private pure{",
|
||
"function f() private {}",
|
||
"function f() private;",
|
||
"function f() public",
|
||
"function f() public constant returns (uint) {",
|
||
"function f() public m returns (bool) {",
|
||
"function f() public m {",
|
||
"function f() public mod returns (bool r) {",
|
||
"function f() public mod1(7) mod2 { }",
|
||
"function f() public onlyOwner {",
|
||
"function f() public override (B, C) returns (uint256 r) {",
|
||
"function f() public override pure {",
|
||
"function f() public override returns (uint256) {",
|
||
"function f() public override {",
|
||
"function f() public override { super.f(); }",
|
||
"function f() public override {}",
|
||
"function f() public override(A, B) {}",
|
||
"function f() public override(B, C) returns (uint256 r) {",
|
||
"function f() public override(a, b) { super.f(); }",
|
||
"function f() public payable returns (bool) {",
|
||
"function f() public payable returns (uint ret) {",
|
||
"function f() public payable returns (uint) {",
|
||
"function f() public payable returns (uint, uint, uint) {",
|
||
"function f() public payable returns (uint256) {",
|
||
"function f() public payable {",
|
||
"function f() public pure",
|
||
"function f() public pure returns (C c) {",
|
||
"function f() public pure returns (Direction) {",
|
||
"function f() public pure returns (I.Direction) {",
|
||
"function f() public pure returns (L.Direction) {",
|
||
"function f() public pure returns (S memory x) {}",
|
||
"function f() public pure returns (S memory) {",
|
||
"function f() public pure returns (S memory) {}",
|
||
"function f() public pure returns (S memory, bytes memory, uint[][2] memory) {",
|
||
"function f() public pure returns (address payable) {",
|
||
"function f() public pure returns (address r) {",
|
||
"function f() public pure returns (address) {",
|
||
"function f() public pure returns (address, address) {",
|
||
"function f() public pure returns (bool correct) {",
|
||
"function f() public pure returns (bool) {",
|
||
"function f() public pure returns (byte) {",
|
||
"function f() public pure returns (bytes memory) {",
|
||
"function f() public pure returns (bytes memory, bytes memory) {",
|
||
"function f() public pure returns (bytes32 r) {",
|
||
"function f() public pure returns (bytes32 ret) {",
|
||
"function f() public pure returns (bytes32 val) { return gasleft(); }",
|
||
"function f() public pure returns (bytes32) {",
|
||
"function f() public pure returns (bytes4 a, bytes4 b, bytes4 c, bytes4 d) {",
|
||
"function f() public pure returns (bytes4) {",
|
||
"function f() public pure returns (bytes4, bytes4) {",
|
||
"function f() public pure returns (function(uint) pure external returns (uint) g) {",
|
||
"function f() public pure returns (int) {",
|
||
"function f() public pure returns (int, int) {",
|
||
"function f() public pure returns (mapping(uint=>uint) memory m) {",
|
||
"function f() public pure returns (mapping(uint=>uint) storage m) {",
|
||
"function f() public pure returns (mapping(uint=>uint)[] storage m) {",
|
||
"function f() public pure returns (string memory ret) {",
|
||
"function f() public pure returns (string memory) {",
|
||
"function f() public pure returns (string memory, string memory) {",
|
||
"function f() public pure returns (string[][] memory) {}",
|
||
"function f() public pure returns (uint a)",
|
||
"function f() public pure returns (uint a, uint b)",
|
||
"function f() public pure returns (uint a, uint b) {",
|
||
"function f() public pure returns (uint r) { return r.g(); }",
|
||
"function f() public pure returns (uint t) {",
|
||
"function f() public pure returns (uint w) {",
|
||
"function f() public pure returns (uint w, bytes2 x, bytes3 y, bool z, address t) {",
|
||
"function f() public pure returns (uint x) {",
|
||
"function f() public pure returns (uint x, T memory t) {",
|
||
"function f() public pure returns (uint y) {",
|
||
"function f() public pure returns (uint)",
|
||
"function f() public pure returns (uint) {",
|
||
"function f() public pure returns (uint) { return 3 + x; }",
|
||
"function f() public pure returns (uint) { return 3; }",
|
||
"function f() public pure returns (uint) {}",
|
||
"function f() public pure returns (uint, S memory) {",
|
||
"function f() public pure returns (uint, byte, byte) {",
|
||
"function f() public pure returns (uint, bytes32, C) {",
|
||
"function f() public pure returns (uint, uint)",
|
||
"function f() public pure returns (uint, uint) {",
|
||
"function f() public pure returns (uint, uint) {}",
|
||
"function f() public pure returns (uint, uint, bytes32) {",
|
||
"function f() public pure returns (uint, uint, uint) {",
|
||
"function f() public pure returns (uint, uint, uint, uint) {",
|
||
"function f() public pure returns (uint16 x) {",
|
||
"function f() public pure returns (uint256 a, uint256 b){",
|
||
"function f() public pure returns (uint256 payable) {}",
|
||
"function f() public pure returns (uint256) {",
|
||
"function f() public pure returns (uint256, bytes memory) {",
|
||
"function f() public pure returns (uint32 x) {",
|
||
"function f() public pure returns (uint8 x) {",
|
||
"function f() public pure returns (uint8 x, bool a, bool b) {",
|
||
"function f() public pure returns (uint[][2] memory) {}",
|
||
"function f() public pure returns(address payable[] memory m) {",
|
||
"function f() public pure returns(address) {",
|
||
"function f() public pure returns(bool) {",
|
||
"function f() public pure returns(bytes memory) {",
|
||
"function f() public pure returns(bytes1) {",
|
||
"function f() public pure returns(bytes32) {",
|
||
"function f() public pure returns(uint r) {",
|
||
"function f() public pure returns(uint256) {",
|
||
"function f() public pure returns(uint32) {",
|
||
"function f() public pure {",
|
||
"function f() public pure { (int[][]); }",
|
||
"function f() public pure { (int[][][]); }",
|
||
"function f() public pure { int16 x = 3; uint8 y = 4; x ** y; }",
|
||
"function f() public pure { int[][]; }",
|
||
"function f() public pure { int[][][]; }",
|
||
"function f() public pure { uint a = 2; assert(a == 2); }",
|
||
"function f() public pure { x = 42; }",
|
||
"function f() public pure { }",
|
||
"function f() public pure {}",
|
||
"function f() public pure{",
|
||
"function f() public repeat(10) returns (uint256 r) {",
|
||
"function f() public returns (C) { return this; }",
|
||
"function f() public returns (Reverts x, uint, string memory txt) {",
|
||
"function f() public returns (S memory s, C c) {",
|
||
"function f() public returns (S memory) {",
|
||
"function f() public returns (S memory) {}",
|
||
"function f() public returns (address) {",
|
||
"function f() public returns (bool correct) {",
|
||
"function f() public returns (bool r) { return 1 >= 2; }",
|
||
"function f() public returns (bool r1, bool r2) { return 1 >= 2; }",
|
||
"function f() public returns (bool ret) {",
|
||
"function f() public returns (bool) {",
|
||
"function f() public returns (bool) { return g(12, true) == 3; }",
|
||
"function f() public returns (bool) { }",
|
||
"function f() public returns (bool, bool, uint256) {",
|
||
"function f() public returns (byte z) {",
|
||
"function f() public returns (bytes memory x) {",
|
||
"function f() public returns (bytes memory) {",
|
||
"function f() public returns (bytes1) {",
|
||
"function f() public returns (bytes1, uint256, uint256, bytes1) {",
|
||
"function f() public returns (bytes20) {",
|
||
"function f() public returns (bytes32) {",
|
||
"function f() public returns (bytes4) {",
|
||
"function f() public returns (function(uint) internal returns (uint) x) {",
|
||
"function f() public returns (int16[] memory) {",
|
||
"function f() public returns (int8) {",
|
||
"function f() public returns (string memory) {",
|
||
"function f() public returns (string memory, string memory) {",
|
||
"function f() public returns (string memory, uint256) {",
|
||
"function f() public returns (uint a, uint b) {",
|
||
"function f() public returns (uint b) {",
|
||
"function f() public returns (uint d) { return 2 ** 10000000000; }",
|
||
"function f() public returns (uint i) {",
|
||
"function f() public returns (uint id) {",
|
||
"function f() public returns (uint k) {",
|
||
"function f() public returns (uint r) {",
|
||
"function f() public returns (uint ret_k, uint) {",
|
||
"function f() public returns (uint x) {",
|
||
"function f() public returns (uint x, S memory s) {",
|
||
"function f() public returns (uint x, uint y) {",
|
||
"function f() public returns (uint x, uint y, uint z) {",
|
||
"function f() public returns (uint) {",
|
||
"function f() public returns (uint) { return 1; }",
|
||
"function f() public returns (uint, S memory) {",
|
||
"function f() public returns (uint, function() external, uint) {",
|
||
"function f() public returns (uint, uint) {",
|
||
"function f() public returns (uint16 x) {",
|
||
"function f() public returns (uint16[5] memory res, uint16[5] memory res2) {",
|
||
"function f() public returns (uint24[3][4] memory) {",
|
||
"function f() public returns (uint24[3][] memory) {",
|
||
"function f() public returns (uint256 a) {",
|
||
"function f() public returns (uint256 i) {",
|
||
"function f() public returns (uint256 r) {",
|
||
"function f() public returns (uint256 r) { return 1 >= 2; }",
|
||
"function f() public returns (uint256 r, bytes32 r2) {",
|
||
"function f() public returns (uint256 r, uint8) { return ((12, \"\")); }",
|
||
"function f() public returns (uint256 x, uint256 y) {",
|
||
"function f() public returns (uint256) {",
|
||
"function f() public returns (uint256, uint, uint) {",
|
||
"function f() public returns (uint256, uint256) {",
|
||
"function f() public returns (uint256, uint256, uint256, uint256) {",
|
||
"function f() public returns (uint256, uint256[] memory, uint256) {",
|
||
"function f() public returns (uint8 x) {",
|
||
"function f() public returns (uint8, uint) {",
|
||
"function f() public returns (uint8, uint8, uint8, uint8) {",
|
||
"function f() public returns (uint8[5] memory) {",
|
||
"function f() public returns (uint[5] memory) {",
|
||
"function f() public returns (uint[] memory, uint) {",
|
||
"function f() public returns(bytes32) {",
|
||
"function f() public returns(bytes32) { return blockhash(3); }",
|
||
"function f() public returns(int d) { return (-2) ** 3; }",
|
||
"function f() public returns(uint d) {",
|
||
"function f() public returns(uint d) { return 0 ** 0; }",
|
||
"function f() public returns(uint d) { return 2 ** 3; }",
|
||
"function f() public returns(uint n) { return 3; }",
|
||
"function f() public returns(uint) {",
|
||
"function f() public returns(uint256) {",
|
||
"function f() public returns(uint[] storage);",
|
||
"function f() public run {",
|
||
"function f() public setsx returns (uint256) {",
|
||
"function f() public view override {",
|
||
"function f() public view returns (C) { return this; }",
|
||
"function f() public view returns (address payable a, address b) {",
|
||
"function f() public view returns (address payable) {",
|
||
"function f() public view returns (address) {",
|
||
"function f() public view returns (bytes32) {",
|
||
"function f() public view returns (bytes32) { return blockhash(3); }",
|
||
"function f() public view returns (bytes4) {",
|
||
"function f() public view returns (function(uint) external) {",
|
||
"function f() public view returns (uint) {",
|
||
"function f() public view returns (uint) { return a; }",
|
||
"function f() public view returns (uint256 val) { return gasleft(); }",
|
||
"function f() public view returns (uint256 val) { return msg.gas; }",
|
||
"function f() public view returns (uint256) {",
|
||
"function f() public view returns (uint256, uint256) {",
|
||
"function f() public view returns (uint256, uint256, uint, uint) {",
|
||
"function f() public view returns(uint) { return x; }",
|
||
"function f() public view returns(uint256, uint256) {",
|
||
"function f() public view virtual override {",
|
||
"function f() public view {",
|
||
"function f() public view { new D(); }",
|
||
"function f() public view{",
|
||
"function f() public virtual override returns (uint256 r) {",
|
||
"function f() public virtual override { super.f(); }",
|
||
"function f() public virtual returns (uint256 r) {",
|
||
"function f() public virtual view {",
|
||
"function f() public virtual view { x; }",
|
||
"function f() public virtual {}",
|
||
"function f() public virtual;",
|
||
"function f() public {",
|
||
"function f() public { (((((a))))).pop();}",
|
||
"function f() public { (--a); }",
|
||
"function f() public { (a).pop();}",
|
||
"function f() public { (new receiver()).nopay{value: 10}(); }",
|
||
"function f() public { (new receiver()).pay{value: 10}(); }",
|
||
"function f() public { A a = B(1); }",
|
||
"function f() public { B b = A(1); }",
|
||
"function f() public { C c = new C(); c; }",
|
||
"function f() public { Test x = new Test(); }",
|
||
"function f() public { a = 2; }",
|
||
"function f() public { a = b; }",
|
||
"function f() public { b = a; }",
|
||
"function f() public { baseMember = 7; }",
|
||
"function f() public { byte a = arr[0];}",
|
||
"function f() public { bytes1 a = s[2]; }",
|
||
"function f() public { c[10] storage a = 7; uint8[10 * 2] storage x; }",
|
||
"function f() public { emit e(2, \"abc\", true); }",
|
||
"function f() public { gasleft = 42; }",
|
||
"function f() public { int x = 3; int y = 4; x ** y; }",
|
||
"function f() public { int x; }",
|
||
"function f() public { int32(2) == uint64(2); }",
|
||
"function f() public { new D(); }",
|
||
"function f() public { string memory x = \"123456789012345678901234567890123\"; }",
|
||
"function f() public { string storage x = \"abc\"; }",
|
||
"function f() public { true ? 1 : 3;}",
|
||
"function f() public { uint a = s.length; }",
|
||
"function f() public { uint32(2) == int64(2); }",
|
||
"function f() public { }",
|
||
"function f() public {}",
|
||
"function f() public;",
|
||
"function f() public{",
|
||
"function f() pure external returns (bytes4) {",
|
||
"function f() pure external returns (uint id) {",
|
||
"function f() pure external {",
|
||
"function f() pure internal returns (S storage) {",
|
||
"function f() pure payable {}",
|
||
"function f() pure public returns (byte) {",
|
||
"function f() pure public returns (bytes memory r) {",
|
||
"function f() pure public returns (uint a) {",
|
||
"function f() pure public returns (uint require) {",
|
||
"function f() pure public returns (uint) {",
|
||
"function f() pure public returns(uint) {",
|
||
"function f() pure public {",
|
||
"function f() pure public { \"abc\"",
|
||
"function f() pure public { 0.",
|
||
"function f() pure public { 0.x; }",
|
||
"function f() pure public { 1.",
|
||
"function f() pure public { 1.x; }",
|
||
"function f() pure public { abi.decode(\"\", (0)); }",
|
||
"function f() pure public { abi.encode(2**500); }",
|
||
"function f() pure public { abi.encodePacked(0/1); }",
|
||
"function f() pure public { assert; }",
|
||
"function f() pure public { g(); }",
|
||
"function f() pure public { require; }",
|
||
"function f() pure public { selfdestruct; }",
|
||
"function f() pure public { uint32 variable; variable = 2; }",
|
||
"function f() pure public { }",
|
||
"function f() pure public {}",
|
||
"function f() pure pure {}",
|
||
"function f() pure view {}",
|
||
"function f() pure { }",
|
||
"function f() purem(0) pure public {}",
|
||
"function f() readX internal {",
|
||
"function f() readX internal { }",
|
||
"function f() returns (uint) {",
|
||
"function f() returns (uint) { C.S storage t; t.x; }",
|
||
"function f() returns (uint) { S storage t; }",
|
||
"function f() returns (uint, uint) {",
|
||
"function f() view external returns (bytes4) {",
|
||
"function f() view external returns (uint ret) {",
|
||
"function f() view external {",
|
||
"function f() view external;",
|
||
"function f() view internal returns (S storage) {",
|
||
"function f() view internal {",
|
||
"function f() view payable {}",
|
||
"function f() view public returns (uint) {",
|
||
"function f() view public returns (uint) { f(); g(); }",
|
||
"function f() view public returns (uint) { return block.timestamp; }",
|
||
"function f() view public {",
|
||
"function f() view public { x = 2; }",
|
||
"function f() view view {}",
|
||
"function f() viewm(0) pure public {}",
|
||
"function f() virtual internal {}",
|
||
"function f() virtual override internal {}",
|
||
"function f() virtual public { x = 2; }",
|
||
"function f() virtual public;",
|
||
"function f() {",
|
||
"function f() { return(0, 0) }",
|
||
"function f() { revert(0, 0) }",
|
||
"function f() { var memory x; }",
|
||
"function f() { var[] a; }",
|
||
"function f() {}",
|
||
"function f();",
|
||
"function f(B.T memory y, B.A.S memory z) public pure returns (uint, uint) {",
|
||
"function f(C _c) public {",
|
||
"function f(C c) pure public returns (C) {",
|
||
"function f(C c, C d) public pure {",
|
||
"function f(C c, C d, C e) public pure {",
|
||
"function f(C c, address a) public pure {",
|
||
"function f(D _a) public pure {",
|
||
"function f(D _a) public {",
|
||
"function f(D _a, D _b) public view {",
|
||
"function f(D _d) public {",
|
||
"function f(D c, D d) public pure {",
|
||
"function f(D d) public view returns (uint256) {",
|
||
"function f(Data.S memory a) public {}",
|
||
"function f(E _d) public pure {",
|
||
"function f(E v) public view returns (bool, bool) {",
|
||
"function f(E[] calldata arr) external {",
|
||
"function f(I x, J y) public view returns (bool, bool) {",
|
||
"function f(I x, J y, address z) public view returns (bool, bool, bool) {",
|
||
"function f(L.S storage s) public view {}",
|
||
"function f(MyStructName memory _x) public {",
|
||
"function f(MyStructName memory s) public {}",
|
||
"function f(MyStructName storage s) public {}",
|
||
"function f(S calldata b) external {",
|
||
"function f(S calldata s)",
|
||
"function f(S calldata s) external pure returns (uint256 a, bytes32 b) {",
|
||
"function f(S calldata s) external pure returns (uint256 a, uint256 b) {",
|
||
"function f(S calldata s) external pure returns (uint256 a, uint256 b, uint256 c) {",
|
||
"function f(S calldata s) external pure returns (uint256, uint256) {",
|
||
"function f(S calldata s) external pure returns (uint256, uint256, uint256, uint256) {",
|
||
"function f(S calldata s) external pure {",
|
||
"function f(S calldata s) external returns (bytes memory) {",
|
||
"function f(S calldata s) external returns (uint256 a) {",
|
||
"function f(S calldata s) external view {}",
|
||
"function f(S calldata s) external { s = S(2); }",
|
||
"function f(S calldata s) external { s.a = 4; }",
|
||
"function f(S calldata s) internal pure returns (uint, uint) {",
|
||
"function f(S calldata s) public pure returns (bool correct) {",
|
||
"function f(S calldata s, int[3] calldata a) external {",
|
||
"function f(S calldata) external pure;",
|
||
"function f(S calldata) external virtual pure {}",
|
||
"function f(S calldata) external { }",
|
||
"function f(S memory _s) internal returns (uint256[] memory) {",
|
||
"function f(S memory _s) internal {",
|
||
"function f(S memory _s) public returns (S memory,S memory) { }",
|
||
"function f(S memory a) external pure returns (S memory) {}",
|
||
"function f(S memory m) public pure returns (uint, uint[] memory, uint) {",
|
||
"function f(S memory s) public pure {",
|
||
"function f(S memory) public override pure {}",
|
||
"function f(S memory) public pure {",
|
||
"function f(S memory) public {}",
|
||
"function f(S storage g) view returns (uint) { S storage t = g; return t.x; }",
|
||
"function f(S storage s) external returns (uint) { return s.a; }",
|
||
"function f(S storage s) public { }",
|
||
"function f(S storage) internal {}",
|
||
"function f(S1 calldata s1, S2 calldata s2, S1 calldata s3)",
|
||
"function f(S1 memory) public pure {}",
|
||
"function f(S2 calldata s)",
|
||
"function f(S2 memory) public pure {}",
|
||
"function f(S[] calldata s)",
|
||
"function f(S[] calldata s) external pure returns (bytes memory) {",
|
||
"function f(S[] calldata) external { }",
|
||
"function f(S[][] calldata) external { }",
|
||
"function f(Struct storage _x) internal view returns (uint256) {",
|
||
"function f(StructType storage b, uint[] storage c, X d) public returns (uint[] memory e, StructType storage f) { f = f; }",
|
||
"function f(T memory) public pure { }",
|
||
"function f(U memory) public {}",
|
||
"function f(X storage x) external {}",
|
||
"function f(a) public { }",
|
||
"function f(a) {}",
|
||
"function f(a, b) {}",
|
||
"function f(a, b, c) {}",
|
||
"function f(a., x.b) -> t.b, b.. {}",
|
||
"function f(address _a) public pure {",
|
||
"function f(address _from, address _5to, uint256 value) internal {",
|
||
"function f(address a) external view returns (bool success) {",
|
||
"function f(address a) m public pure {",
|
||
"function f(address a) m(a) public pure {",
|
||
"function f(address a) public pure returns (address payable) {",
|
||
"function f(address a) public pure returns (address x) {",
|
||
"function f(address a) public pure returns (bool) {",
|
||
"function f(address a) public pure {",
|
||
"function f(address a) public returns (uint256) {",
|
||
"function f(address a) public view {",
|
||
"function f(address a) public {",
|
||
"function f(address a, address b) public view {",
|
||
"function f(address a, bytes memory data) public {",
|
||
"function f(address a, function(uint) external g) internal pure {",
|
||
"function f(address a, uint x) public view {",
|
||
"function f(address b) public pure returns (address c) {",
|
||
"function f(address c) public view {",
|
||
"function f(address payable a) public pure {",
|
||
"function f(address payable a) public {",
|
||
"function f(address payable a, address payable b) public {",
|
||
"function f(address payable arg) public returns (address payable r) {",
|
||
"function f(address payable b) public pure returns (address payable c) {",
|
||
"function f(address payable) external pure {}",
|
||
"function f(address payable) internal pure {}",
|
||
"function f(address payable) public pure {}",
|
||
"function f(address x) external virtual returns (uint256, string memory);",
|
||
"function f(address) external pure {}",
|
||
"function f(address) internal pure returns (uint) {}",
|
||
"function f(address) internal pure {}",
|
||
"function f(address) public pure returns (address) {}",
|
||
"function f(address) public pure {}",
|
||
"function f(address) pure public {}",
|
||
"function f(bool _b) public returns (uint256) {",
|
||
"function f(bool _value) public pure {",
|
||
"function f(bool a) public mod1 mod2(a) returns (uint256 r) {",
|
||
"function f(bool a) public pure returns (bool x) {",
|
||
"function f(bool a, bool b) public pure {",
|
||
"function f(bool b) public pure returns (uint, string memory) {",
|
||
"function f(bool b) public pure {",
|
||
"function f(bool b) public returns (uint x, uint y, bytes memory txt) {",
|
||
"function f(bool b) public returns (uint x, uint y, string memory txt) {",
|
||
"function f(bool b) public returns (uint256) {",
|
||
"function f(bool b) public {",
|
||
"function f(bool b, uint[] memory c) public {",
|
||
"function f(bool c) public pure {",
|
||
"function f(bool cond) public pure returns (uint, uint) {",
|
||
"function f(bool cond) public pure returns (uint256) {",
|
||
"function f(bool cond) public returns (uint x, uint y, bytes memory txt) {",
|
||
"function f(bool cond) public returns (uint) {",
|
||
"function f(bool cond) public returns (uint, uint) {",
|
||
"function f(bool cond) public {",
|
||
"function f(bool cond, bytes calldata x) external pure {",
|
||
"function f(bool cond, uint v) public returns (uint a, uint b) {",
|
||
"function f(bool cond1, bool cond2) public returns (uint x, uint y, bytes memory txt) {",
|
||
"function f(bool condition) public returns (uint x) {",
|
||
"function f(bool flag) ifFlag(flag) internal view returns(S storage) {",
|
||
"function f(bool flag) internal pure returns (S storage c) {",
|
||
"function f(bool flag) internal pure {",
|
||
"function f(bool flag) internal view returns (S storage c) {",
|
||
"function f(bool flag) internal view {",
|
||
"function f(bool flag) internal {",
|
||
"function f(bool flag) public view returns (uint x) {",
|
||
"function f(bool flag) public view returns (uint x, uint y) {",
|
||
"function f(bool flag) revertIfNoReturn() internal view returns(S storage) {",
|
||
"function f(bool flag) revertIfNoReturn() internal view {",
|
||
"function f(bool twice) public repeat(twice) returns (uint256 r) {",
|
||
"function f(bool x) public pure {",
|
||
"function f(bool x) public pure { for (;x;) {} }",
|
||
"function f(bool x) public pure { require(x); for (;x;) {} }",
|
||
"function f(bool x) public pure { require(x); if (x) {} }",
|
||
"function f(bool x) public pure { require(x); while (x) {} }",
|
||
"function f(bool x) public pure { require(x); }",
|
||
"function f(bool x) public pure { while (x) {} }",
|
||
"function f(bool x) public pure { x = true; require(x); }",
|
||
"function f(bool x) public returns (uint) {",
|
||
"function f(bool x) public view {",
|
||
"function f(bool x) pure public {",
|
||
"function f(bool x, bool y) public pure {",
|
||
"function f(bool x, uint a) public pure {",
|
||
"function f(bytes calldata _x) internal pure returns (byte) {",
|
||
"function f(bytes calldata _x) internal pure returns (bytes calldata) {",
|
||
"function f(bytes calldata _x) public pure returns (byte) {",
|
||
"function f(bytes calldata _x) public pure returns (byte, byte) {",
|
||
"function f(bytes calldata _x) public pure returns (bytes calldata) {",
|
||
"function f(bytes calldata a)",
|
||
"function f(bytes calldata b) internal pure returns (byte) {",
|
||
"function f(bytes calldata b) public returns (bool correct) {",
|
||
"function f(bytes calldata b, uint i) internal pure returns (byte) {",
|
||
"function f(bytes calldata bytesAsCalldata) external {",
|
||
"function f(bytes calldata data)",
|
||
"function f(bytes calldata data) external pure returns (S memory) {",
|
||
"function f(bytes calldata data) external pure returns (uint256[] memory) {",
|
||
"function f(bytes calldata data) external returns (bytes memory) {",
|
||
"function f(bytes calldata data) external returns (bytes32) {",
|
||
"function f(bytes calldata x) external pure {",
|
||
"function f(bytes calldata x) external {",
|
||
"function f(bytes calldata x, uint y) external pure {",
|
||
"function f(bytes calldata) external virtual returns (uint256 r) {r = 1;}",
|
||
"function f(bytes calldata) external {}",
|
||
"function f(bytes calldata) internal pure {}",
|
||
"function f(bytes calldata) internal;",
|
||
"function f(bytes calldata) override external returns (uint256 r) {r = 42;}",
|
||
"function f(bytes calldata) public;",
|
||
"function f(bytes memory _a, bytes calldata _b, bytes memory _c)",
|
||
"function f(bytes memory _data) public returns (uint256, bytes memory) {",
|
||
"function f(bytes memory _x) public pure {",
|
||
"function f(bytes memory a, bytes calldata b, uint[] memory c)",
|
||
"function f(bytes memory b) public pure returns (address payable) {",
|
||
"function f(bytes memory b) public pure returns (bytes memory) {",
|
||
"function f(bytes memory b1, bytes memory b2) public pure {",
|
||
"function f(bytes memory data) public pure returns (uint256) {",
|
||
"function f(bytes memory data) public pure returns (uint256, bytes memory) {",
|
||
"function f(bytes memory data) public pure {",
|
||
"function f(bytes memory s) public returns (uint256) {",
|
||
"function f(bytes memory x) public pure {",
|
||
"function f(bytes memory) external {}",
|
||
"function f(bytes memory) external;",
|
||
"function f(bytes memory) internal pure {}",
|
||
"function f(bytes memory) internal {}",
|
||
"function f(bytes memory) public {}",
|
||
"function f(bytes storage) external {}",
|
||
"function f(bytes storage) external;",
|
||
"function f(bytes storage) internal pure {}",
|
||
"function f(bytes storage) internal {}",
|
||
"function f(bytes storage) public;",
|
||
"function f(bytes10 x) public pure returns (address payable) {",
|
||
"function f(bytes16 b) public view {",
|
||
"function f(bytes2 a, uint16 x) public returns (uint256) {",
|
||
"function f(bytes20 x) public pure returns (address payable) {",
|
||
"function f(bytes32 _x) public pure {",
|
||
"function f(bytes32 _x, uint256 _a) public {",
|
||
"function f(bytes32 b) public pure returns (bytes32 x) {",
|
||
"function f(bytes32 x) public pure returns (address payable) {",
|
||
"function f(bytes32 x) public returns (bytes1) {",
|
||
"function f(bytes32 x) public returns (uint256, uint256, uint256) {",
|
||
"function f(bytes32[1263941234127518272] memory) public pure {}",
|
||
"function f(bytes32[1263941234127518272][500] memory) public pure {}",
|
||
"function f(bytes4 memory) public;",
|
||
"function f(bytes8 y) public view {",
|
||
"function f(bytes[] calldata a)",
|
||
"function f(bytes[] calldata a, uint256 i) external returns (uint) {",
|
||
"function f(function() external returns (function() external returns (uint))[] memory x)",
|
||
"function f(function() external returns (mapping(uint=>uint) storage)) public pure {",
|
||
"function f(function() external returns (uint)[] calldata s) external returns (uint, uint, uint) {",
|
||
"function f(function() internal returns (mapping(uint=>uint) storage)) internal pure {",
|
||
"function f(function(Nested memory) external) external pure {}",
|
||
"function f(function(S memory) external) public {}",
|
||
"function f(function(bytes memory) pure external /*g*/) pure public { }",
|
||
"function f(function(mapping(uint=>uint) storage) external) public pure {",
|
||
"function f(function(mapping(uint=>uint) storage) internal) internal pure {",
|
||
"function f(function(uint) external g) public {",
|
||
"function f(function(uint) external payable g) internal {",
|
||
"function f(function(uint) external returns (uint) g) internal returns (uint a) {",
|
||
"function f(function(uint) external returns (uint) g) public returns (function(uint) external returns (uint)) {",
|
||
"function f(function(uint) external returns (uint) g, function(uint) external returns (uint) h) public {",
|
||
"function f(function(uint) internal g) internal {",
|
||
"function f(function(uint) internal returns (uint) /*x*/) pure internal {",
|
||
"function f(function(uint) internal returns (uint) x) public {",
|
||
"function f(function(uint) internal returns (uint)[] memory x) public { }",
|
||
"function f(function(uint) returns (uint) g, function(uint) returns (uint) h) internal {",
|
||
"function f(function(uint[] storage) internal returns (uint[] storage)) internal pure",
|
||
"function f(int a, int b) public pure returns (int x) {",
|
||
"function f(int x, int y) public pure returns (int) {",
|
||
"function f(int x, int y) public pure {",
|
||
"function f(int x, uint y) public returns (int) {",
|
||
"function f(int16 a, uint16 b) public returns (int16) {",
|
||
"function f(int16 a, uint16 b) public returns (int256) {",
|
||
"function f(int16[] calldata a) external returns (bool correct) {",
|
||
"function f(int256 a, int256 b) public returns (int256) {",
|
||
"function f(int256 a, uint256 b) public returns (int256) {",
|
||
"function f(int32 a, uint32 b) public returns (int256) {",
|
||
"function f(int32 a, uint32 b) public returns (int32) {",
|
||
"function f(int8 a, uint8 b) public returns (int256) {",
|
||
"function f(int8 a, uint8 b) public returns (int8) {",
|
||
"function f(int8 x) public pure returns (int8) {",
|
||
"function f(int8 x) public pure {",
|
||
"function f(int8 x, uint y) public returns (int) {",
|
||
"function f(int[] memory) public virtual;",
|
||
"function f(mapping (uint => uint) storage map) internal {",
|
||
"function f(mapping(uint => uint) storage a, mapping(uint => uint) storage b, bool c) external pure returns(mapping(uint => uint) storage) {",
|
||
"function f(mapping(uint => uint) storage a, mapping(uint => uint) storage b, bool c) internal pure returns(mapping(uint => uint) storage) {",
|
||
"function f(mapping(uint => uint) storage a, mapping(uint => uint) storage b, bool c) private pure returns(mapping(uint => uint) storage) {",
|
||
"function f(mapping(uint => uint) storage a, mapping(uint => uint) storage b, bool c) public pure returns(mapping(uint => uint) storage) {",
|
||
"function f(mapping(uint => uint) storage map, uint index, uint value) internal {",
|
||
"function f(mapping(uint => uint) storage) external pure {",
|
||
"function f(mapping(uint => uint) storage) internal pure {",
|
||
"function f(mapping(uint => uint) storage) private pure {",
|
||
"function f(mapping(uint => uint) storage) public pure {",
|
||
"function f(mapping(uint => uint)[2] memory a) external pure returns (mapping(uint => uint)[2] memory) {}",
|
||
"function f(mapping(uint => uint)[2] memory b) internal {",
|
||
"function f(mapping(uint => uint)[] memory x) public pure {}",
|
||
"function f(mapping(uint => uint)[] storage) external pure {",
|
||
"function f(mapping(uint => uint)[] storage) internal pure {",
|
||
"function f(mapping(uint => uint)[] storage) private pure {",
|
||
"function f(mapping(uint => uint)[] storage) public pure {",
|
||
"function f(mapping(uint=>uint) storage x, mapping(uint=>uint) storage y) external {",
|
||
"function f(string calldata a, bytes calldata b, uint[] calldata c) external {}",
|
||
"function f(string memory _s, uint256 n) public returns (bytes1) {",
|
||
"function f(string memory s) public pure returns (bytes memory t) {",
|
||
"function f(string memory s, uint x) public {",
|
||
"function f(string memory s1, string memory s2) public pure {",
|
||
"function f(string memory) returns (uint) {",
|
||
"function f(string[] calldata a)",
|
||
"function f(ufixed x, fixed32x32 y) public {",
|
||
"function f(uint _value) public payable {",
|
||
"function f(uint _x) public pure returns (uint) {",
|
||
"function f(uint a) external payable {}",
|
||
"function f(uint a) external pure { a = 1; }",
|
||
"function f(uint a) external pure { a++; }",
|
||
"function f(uint a) external returns (bool);",
|
||
"function f(uint a) external { delete a; }",
|
||
"function f(uint a) internal pure {}",
|
||
"function f(uint a) mod(2) public returns (uint r) { }",
|
||
"function f(uint a) public override returns (uint8) { }",
|
||
"function f(uint a) public pure returns (uint x) {",
|
||
"function f(uint a) public pure returns (uint, uint) {",
|
||
"function f(uint a) public pure returns (uint8 x) {",
|
||
"function f(uint a) public pure {",
|
||
"function f(uint a) public pure { assert(a == 2); }",
|
||
"function f(uint a) public pure { require(a < 10); assert(a < 20); }",
|
||
"function f(uint a) public returns (uint d) { return a * 7; }",
|
||
"function f(uint a) public returns (uint) {",
|
||
"function f(uint a) public returns (uint) { return 2 * a; }",
|
||
"function f(uint a) public returns (uint) { return a; }",
|
||
"function f(uint a) public returns (uint, uint, uint) {",
|
||
"function f(uint a) public virtual returns (uint) { }",
|
||
"function f(uint a) public {",
|
||
"function f(uint a) public { uint8[-1] x; }",
|
||
"function f(uint a) public { uint8[a] x; }",
|
||
"function f(uint a) pure external returns (uint b);",
|
||
"function f(uint a) pure public returns (uint b) {",
|
||
"function f(uint a) pure public virtual returns (uint b);",
|
||
"function f(uint a) pure public {",
|
||
"function f(uint a, uint b) public pure returns (uint x) {",
|
||
"function f(uint a, uint b) public pure returns (uint x, uint y) {",
|
||
"function f(uint a, uint b) public pure returns (uint) { return a + b; }",
|
||
"function f(uint a, uint b) public returns (uint d) { return a + b; }",
|
||
"function f(uint a, uint b) public returns (uint) {",
|
||
"function f(uint a, uint b, uint c) public returns (uint) {",
|
||
"function f(uint a, uint b, uint c, uint d, uint e) public returns (uint) {",
|
||
"function f(uint a, uint[] calldata b, uint c) external pure returns (uint) {",
|
||
"function f(uint a1, uint a2) public returns (uint r1, uint r2) {",
|
||
"function f(uint b) public pure returns (uint x) {",
|
||
"function f(uint constant LEN) public {",
|
||
"function f(uint difficulty) public view {",
|
||
"function f(uint finney) public pure returns (uint szabo) {",
|
||
"function f(uint immutable) public pure {}",
|
||
"function f(uint index, uint value) public {",
|
||
"function f(uint k) public returns (uint) {",
|
||
"function f(uint l) public {",
|
||
"function f(uint n) public payable returns (uint, uint) {",
|
||
"function f(uint n) public pure returns (uint) {",
|
||
"function f(uint n) public view returns (uint) {",
|
||
"function f(uint n, uint m) public {",
|
||
"function f(uint ptr, uint start, uint x) public returns (bool) {",
|
||
"function f(uint require) pure public {",
|
||
"function f(uint size) public {",
|
||
"function f(uint storage a) public {",
|
||
"function f(uint storage a) public { }",
|
||
"function f(uint type) public pure {",
|
||
"function f(uint user_input) public {",
|
||
"function f(uint v) public returns (uint one, uint two) {",
|
||
"function f(uint x) external payable returns (uint) { return 1; }",
|
||
"function f(uint x) internal pure returns (uint, bool, uint) {",
|
||
"function f(uint x) internal returns (uint) {",
|
||
"function f(uint x) internal { }",
|
||
"function f(uint x) m public pure {",
|
||
"function f(uint x) m(8) m(1) m(4) m(s) m(4) m(4) m(s) m(4) m(s) public view {",
|
||
"function f(uint x) m(x) m(2) m(s) public view {",
|
||
"function f(uint x) m(x) n(x) public pure {",
|
||
"function f(uint x) m(x) public pure {",
|
||
"function f(uint x) m(x, 0) public pure {",
|
||
"function f(uint x) mod(x) mod(2) public pure { }",
|
||
"function f(uint x) public payable {",
|
||
"function f(uint x) public pure returns (address payable) {",
|
||
"function f(uint x) public pure returns (uint) {",
|
||
"function f(uint x) public pure returns (uint, int) {",
|
||
"function f(uint x) public pure returns (uint, uint) {",
|
||
"function f(uint x) public pure {",
|
||
"function f(uint x) public returns (uint i) {",
|
||
"function f(uint x) public returns (uint y) {",
|
||
"function f(uint x) public returns (uint256) { c = x * 3; return 23; }",
|
||
"function f(uint x) public returns(uint d) {",
|
||
"function f(uint x) public {",
|
||
"function f(uint x) public {}",
|
||
"function f(uint x) pure public {",
|
||
"function f(uint x) pure returns (uint) { return x * 3; }",
|
||
"function f(uint x, address payable a, address payable b) public {",
|
||
"function f(uint x, bool b) public pure {",
|
||
"function f(uint x, bytes32 y) external {",
|
||
"function f(uint x, uint p) public {",
|
||
"function f(uint x, uint y) external payable returns (uint) { return 2; }",
|
||
"function f(uint x, uint y) internal { }",
|
||
"function f(uint x, uint y) public pure returns (uint) {",
|
||
"function f(uint x, uint y) public pure {",
|
||
"function f(uint x, uint y) public returns (uint a) {}",
|
||
"function f(uint x, uint y) public returns (uint) {",
|
||
"function f(uint x, uint y) public view {",
|
||
"function f(uint x, uint y) public {",
|
||
"function f(uint x, uint y, bool b, bool c) public pure {",
|
||
"function f(uint x, uint y, uint v) public {",
|
||
"function f(uint x, uint y, uint z) internal { }",
|
||
"function f(uint x, uint y, uint z, uint t) public view {",
|
||
"function f(uint x, uint y, uint z, uint t, uint w, uint v) public view {",
|
||
"function f(uint x, uint[] calldata input) public returns (uint, uint) {",
|
||
"function f(uint y) internal pure returns (uint) {",
|
||
"function f(uint y) internal view returns (uint) {",
|
||
"function f(uint y) public pure returns (uint) {",
|
||
"function f(uint y) public pure {",
|
||
"function f(uint y) public returns (uint) {",
|
||
"function f(uint y) public view {",
|
||
"function f(uint y) public {",
|
||
"function f(uint y) view public {",
|
||
"function f(uint y, D d) public {",
|
||
"function f(uint y, uint v) public {",
|
||
"function f(uint) public pure returns (uint) {}",
|
||
"function f(uint) public pure {",
|
||
"function f(uint) public pure {}",
|
||
"function f(uint) public returns (uint);",
|
||
"function f(uint) public { }",
|
||
"function f(uint) public {}",
|
||
"function f(uint) pure external {}",
|
||
"function f(uint) pure public {",
|
||
"function f(uint) pure public {}",
|
||
"function f(uint) returns (bytes memory) {}",
|
||
"function f(uint) returns (uint) {",
|
||
"function f(uint, S calldata s, uint) external pure returns (uint, uint) {",
|
||
"function f(uint, bytes calldata _x, uint) internal returns (byte) {",
|
||
"function f(uint, bytes calldata b, uint) external pure returns (byte) {",
|
||
"function f(uint, uint k) public returns (uint ret_k) {",
|
||
"function f(uint, uint k) public returns (uint ret_k, uint ret_g) {",
|
||
"function f(uint, uint) public {}",
|
||
"function f(uint, uint[3][2] calldata s, uint) external pure returns (uint, uint) {",
|
||
"function f(uint, uint[][2] calldata s, uint) external pure returns (uint, uint) {",
|
||
"function f(uint16 a) public returns (uint) {",
|
||
"function f(uint16 input) public pure returns (uint16[5] memory arr) {",
|
||
"function f(uint16 x) public pure {",
|
||
"function f(uint16 x, uint16 y) public pure {",
|
||
"function f(uint256 _5value, uint256 _value, uint256 value) internal {",
|
||
"function f(uint256 a) external view returns (bool) {",
|
||
"function f(uint256 a) external view returns (uint256) {",
|
||
"function f(uint256 a) internal pure returns (S storage c) {",
|
||
"function f(uint256 a) internal pure {",
|
||
"function f(uint256 a) public returns (uint256 b) {",
|
||
"function f(uint256 a) public returns (uint256 b, uint256 c, uint256 d) {",
|
||
"function f(uint256 a) public returns (uint256) {",
|
||
"function f(uint256 a, S calldata s, uint256 b)",
|
||
"function f(uint256 a, bytes32 b) public returns (bytes memory) {",
|
||
"function f(uint256 a, uint256 b) external returns (uint256 c, uint256 d, uint256 e, uint256 f) {",
|
||
"function f(uint256 a, uint256 b) external {",
|
||
"function f(uint256 a, uint256 b) public returns (bytes memory) {",
|
||
"function f(uint256 a, uint256 b) public returns (uint256 d) {",
|
||
"function f(uint256 a, uint256 b) public returns (uint256) {",
|
||
"function f(uint256 a, uint8 b) public returns (uint256) {",
|
||
"function f(uint256 a, uint8 b) public view returns (bool, bool) {",
|
||
"function f(uint256 arg) public {",
|
||
"function f(uint256 d) public pure returns (uint256) {",
|
||
"function f(uint256 i) public returns (string memory) {",
|
||
"function f(uint256 i) public returns (uint256) {",
|
||
"function f(uint256 k) public returns (uint256 d) {",
|
||
"function f(uint256 k) public returns (uint256) {",
|
||
"function f(uint256 l) public {",
|
||
"function f(uint256 n, uint256 k) public returns (uint256) {",
|
||
"function f(uint256 payable) public pure {}",
|
||
"function f(uint256 start, uint256 end, uint256[] calldata arr) external pure {",
|
||
"function f(uint256 v) external pure returns (uint) {",
|
||
"function f(uint256 v) external returns (uint256) { return v*v; }",
|
||
"function f(uint256 v) internal returns (uint256) { return v*v; }",
|
||
"function f(uint256 value) public payable returns (bool) {",
|
||
"function f(uint256 x) external returns (uint) { return x; }",
|
||
"function f(uint256 x) public mod(2) mod(5) mod(x) returns (uint256) {",
|
||
"function f(uint256 x) public pure returns (uint256, uint256) {",
|
||
"function f(uint256 x) public returns (uint256 a) {",
|
||
"function f(uint256 x) public returns (uint256) {",
|
||
"function f(uint256 x) public view returns(uint256) { return x; }",
|
||
"function f(uint256 y) public payable {",
|
||
"function f(uint256 y) public pure returns (uint256 x) {",
|
||
"function f(uint256) external pure {}",
|
||
"function f(uint256) external {}",
|
||
"function f(uint256) internal {}",
|
||
"function f(uint256) private {}",
|
||
"function f(uint256) public returns (uint out) { f(variable); test; out; }",
|
||
"function f(uint256[2] calldata s)",
|
||
"function f(uint256[2] calldata x) external returns (uint256) {",
|
||
"function f(uint256[3] calldata s) external pure returns (bytes memory) {",
|
||
"function f(uint256[3] calldata s1, uint256[2] calldata s2, bool which) external pure returns (bytes memory) {",
|
||
"function f(uint256[42] calldata x) external pure {",
|
||
"function f(uint256[42] memory x) public pure {",
|
||
"function f(uint256[] calldata a) external override returns (uint256) {",
|
||
"function f(uint256[] calldata a) external returns (bytes memory) {",
|
||
"function f(uint256[] calldata a) external returns (uint256);",
|
||
"function f(uint256[] calldata a) external virtual returns (uint256) {",
|
||
"function f(uint256[] calldata s) external pure returns (bytes memory) {",
|
||
"function f(uint256[] calldata s) external { s[0] = 4; }",
|
||
"function f(uint256[] calldata s1, uint256[] calldata s2, bool which) external pure returns (bytes memory) {",
|
||
"function f(uint256[] calldata seq) external pure returns (uint256) {",
|
||
"function f(uint256[] calldata x) external pure {",
|
||
"function f(uint256[] calldata x) external returns (uint256) {",
|
||
"function f(uint256[] calldata x, uint256 i) external returns (uint256) {",
|
||
"function f(uint256[] calldata x, uint256 s, uint256 e) external returns (uint256) {",
|
||
"function f(uint256[] calldata x, uint256 s, uint256 e, uint256 ss, uint256 ee) external returns (uint256) {",
|
||
"function f(uint256[] calldata x, uint256 start, uint256 end) external pure {",
|
||
"function f(uint256[] calldata x, uint256[] calldata y) external pure {",
|
||
"function f(uint256[] memory _data) internal {",
|
||
"function f(uint256[] memory a) public override returns (uint256) {",
|
||
"function f(uint256[] memory a) public returns (uint256) {",
|
||
"function f(uint256[] memory x) public pure {",
|
||
"function f(uint256[] memory x) public returns (uint256) {",
|
||
"function f(uint256[] storage x) public pure returns (uint256) {",
|
||
"function f(uint256[] storage x) public view returns (uint256) {",
|
||
"function f(uint256[][1] calldata s) external view returns (bool) {",
|
||
"function f(uint256[][1][] calldata a) external returns (uint256) {",
|
||
"function f(uint256[][2][] calldata x) external returns (uint256) {",
|
||
"function f(uint256[][2][] calldata x, uint256 i, uint256 j, uint256 k) external returns (uint256 a, uint256 b, uint256 c, uint256 d) {",
|
||
"function f(uint256[][] calldata a)",
|
||
"function f(uint256[][] calldata a) external returns (uint) {",
|
||
"function f(uint256[][] calldata a) external returns (uint256) {",
|
||
"function f(uint256[][] calldata s) external pure returns (bytes memory) {",
|
||
"function f(uint256[][] calldata x) external pure {",
|
||
"function f(uint256[][] calldata x) external returns (uint256 l1, uint256 l2, uint256 l3) {",
|
||
"function f(uint256[][] calldata x) external returns (uint256) {",
|
||
"function f(uint256[][] calldata x) external { x[0]; }",
|
||
"function f(uint256[][] calldata x, uint256 i, uint256 j) external returns (uint256) {",
|
||
"function f(uint32 a, uint32 b) public returns (uint256) {",
|
||
"function f(uint8 a) mod1(a, true) mod2(r) pure public returns (bytes7 r) { }",
|
||
"function f(uint8 a) public returns (uint _x) {",
|
||
"function f(uint8 a) public returns (uint) { return a; }",
|
||
"function f(uint8 a) public { }",
|
||
"function f(uint8 a, uint8 b) public returns (uint256) {",
|
||
"function f(uint8 x) public pure returns (uint) {",
|
||
"function f(uint8 x) public pure returns (uint8) {",
|
||
"function f(uint8 x) public pure {",
|
||
"function f(uint8 x, uint8 y) public returns (uint) {",
|
||
"function f(uint8[1][][1] calldata s) external pure returns (bytes memory) {",
|
||
"function f(uint8[] memory x) private {",
|
||
"function f(uint8[][1][] calldata s) external pure returns (bytes memory) {",
|
||
"function f(uint[1] memory x) public {",
|
||
"function f(uint[1][] memory x) public {",
|
||
"function f(uint[2**16][2**16][] memory) public pure {}",
|
||
"function f(uint[2**30][2**30][] memory) public pure {}",
|
||
"function f(uint[2**30][2**30][][] memory) public pure {}",
|
||
"function f(uint[2**30][] memory) public pure {}",
|
||
"function f(uint[2] memory a, uint[2] memory b, uint[2] memory c) public pure {",
|
||
"function f(uint[2] storage a, uint[2] memory c) internal {",
|
||
"function f(uint[3] calldata) external { }",
|
||
"function f(uint[3][4] calldata) external { }",
|
||
"function f(uint[85678901234] calldata a) pure external {",
|
||
"function f(uint[85678901234] memory a) pure internal {",
|
||
"function f(uint[85678901234] memory a) pure public {",
|
||
"function f(uint[] calldata _c) public pure {",
|
||
"function f(uint[] calldata x) external pure {",
|
||
"function f(uint[] calldata x) external {",
|
||
"function f(uint[] calldata) external override pure {}",
|
||
"function f(uint[] calldata) external pure {}",
|
||
"function f(uint[] calldata) external pure;",
|
||
"function f(uint[] calldata) external virtual pure {}",
|
||
"function f(uint[] calldata) external { }",
|
||
"function f(uint[] memory a) external {}",
|
||
"function f(uint[] memory a) public pure returns (uint) { return 7; }",
|
||
"function f(uint[] memory a, uint[] memory b) public {",
|
||
"function f(uint[] memory arr) public pure {",
|
||
"function f(uint[] memory array, uint x, uint y) public pure {",
|
||
"function f(uint[] memory constant a) public { }",
|
||
"function f(uint[] memory marr) public {",
|
||
"function f(uint[] memory x) public {",
|
||
"function f(uint[] memory x) returns (bytes memory) { return f(x[0]); }",
|
||
"function f(uint[] memory x, uint y) public {",
|
||
"function f(uint[] memory) internal pure {}",
|
||
"function f(uint[] memory) public override pure {}",
|
||
"function f(uint[] memory) public virtual;",
|
||
"function f(uint[] memory, uint[] storage) private pure {}",
|
||
"function f(uint[] memory, uint[] storage, S storage) private pure",
|
||
"function f(uint[] storage a) external {}",
|
||
"function f(uint[] storage a, uint[] memory c) internal {",
|
||
"function f(uint[] storage a, uint[] storage b) internal {",
|
||
"function f(uint[] storage a, uint[] storage b, uint[] memory c) internal {",
|
||
"function f(uint[] storage constant x, uint[] memory y) internal { }",
|
||
"function f(uint[] storage memory constant x, uint[] memory calldata y) internal { }",
|
||
"function f(uint[] storage x) private {",
|
||
"function f(uint[]) private pure {}",
|
||
"function f(uint[][] calldata) external { }",
|
||
"function f(uint[][] memory arr) public pure {",
|
||
"function f(uint[][] memory arr2) public {",
|
||
"function f.() {}",
|
||
"function f0() public pure returns (bytes memory) {",
|
||
"function f0() public returns (bytes memory) {",
|
||
"function f0() public returns (uint) {",
|
||
"function f0() public returns(int, bool) {",
|
||
"function f0() public {",
|
||
"function f0() public { (()) = 2; }",
|
||
"function f0(uint x) public pure returns (uint) { require(x > 10); }",
|
||
"function f1() external pure returns (string memory) { return \"abcabc\"; }",
|
||
"function f1() internal returns (function() internal returns (uint)) {",
|
||
"function f1() public m1() {",
|
||
"function f1() public mod2 {",
|
||
"function f1() public pure returns (bool) {",
|
||
"function f1() public pure returns (bytes memory) {",
|
||
"function f1() public pure returns (bytes32 val) { return g(); }",
|
||
"function f1() public pure {",
|
||
"function f1() public pure { (()) = (); }",
|
||
"function f1() public returns (bool) {",
|
||
"function f1() public returns (bytes memory) {",
|
||
"function f1() public returns (uint x) {",
|
||
"function f1() public returns(int) {",
|
||
"function f1() view public returns (bytes memory) {",
|
||
"function f1() {",
|
||
"function f1(bytes32 _msg) public {",
|
||
"function f1(bytes32 a) external view returns (bytes32) {",
|
||
"function f1(bytes[1] calldata a)",
|
||
"function f1(function(uint) internal g1) internal {",
|
||
"function f1(mapping(uint => uint) calldata) pure external returns (mapping(uint => uint) memory) {}",
|
||
"function f1(mapping(uint => uint)[] calldata) pure external {}",
|
||
"function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }",
|
||
"function f1(uint) public pure returns (uint) { }",
|
||
"function f1(uint[] memory c, X d) public pure returns (uint[] memory e) { }",
|
||
"function f128(int256 a) external view returns (int256) {",
|
||
"function f128(uint256 a) external view returns (uint256) {",
|
||
"function f16(bytes32 a) external view returns (bytes32) {",
|
||
"function f16(int256 a) external view returns (int256) {",
|
||
"function f16(uint256 a) external view returns (uint256) {",
|
||
"function f1a() public returns (uint x) {",
|
||
"function f1b() public returns (uint x) {",
|
||
"function f1c() public returns (uint x) {",
|
||
"function f2() external pure returns (string memory) { return \"abcabc`~12345677890- _=+!@#$%^&*()[{]}|;:',<.>?\"; }",
|
||
"function f2() internal pure returns (uint, uint) { return () = f2(); }",
|
||
"function f2() internal returns (function() internal returns (function () internal returns (uint))) {",
|
||
"function f2() public m1() {",
|
||
"function f2() public pure returns (bool) {",
|
||
"function f2() public pure returns (bytes memory) {",
|
||
"function f2() public pure returns (bytes32 val, bytes3 val2) { return h(); }",
|
||
"function f2() public pure returns(int) {",
|
||
"function f2() public returns (bool) {",
|
||
"function f2() public returns (bytes memory) {",
|
||
"function f2() public returns (uint x) {",
|
||
"function f2() public returns(int) {",
|
||
"function f2() public {",
|
||
"function f2() public{",
|
||
"function f2() view public returns (bytes memory) {",
|
||
"function f2() { }",
|
||
"function f2(bool a) public pure returns (bool x) {",
|
||
"function f2(bytes32 a) external view returns (bytes32) {",
|
||
"function f2(bytes[1] calldata a, bytes[1] calldata b)",
|
||
"function f2(function(function(uint) internal) internal g2) internal {",
|
||
"function f2(uint n, uint m, uint a, uint b) public {",
|
||
"function f2(uint x) public returns (uint) { b[uint8(msg.data[1])] = x; }",
|
||
"function f2(uint x, uint y) internal pure returns (uint) {",
|
||
"function f2(uint x, uint y) internal {",
|
||
"function f2(uint256 x) public returns (uint256) {",
|
||
"function f2(uint256[2][][2] calldata s) external pure returns (bytes memory) {",
|
||
"function f2(uint256[][2][] calldata s) external pure returns (bytes memory) {",
|
||
"function f2(uint[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}",
|
||
"function f2a() public returns (uint x) {",
|
||
"function f2b() public returns (uint x) {",
|
||
"function f2c() public returns (uint x) {",
|
||
"function f3() internal returns (function() internal returns (function () internal returns (function () internal returns (uint)))) {",
|
||
"function f3() public override {",
|
||
"function f3() public pure returns (bool) {",
|
||
"function f3() public pure returns (byte) {",
|
||
"function f3() public pure returns (bytes memory r) {",
|
||
"function f3() public pure {",
|
||
"function f3() public returns (bytes memory r) {",
|
||
"function f3() public returns (uint x) {",
|
||
"function f3() public returns(int) {",
|
||
"function f3() public virtual {}",
|
||
"function f3() public {",
|
||
"function f3() view public returns (bytes memory) {",
|
||
"function f3()public{return()=();}",
|
||
"function f3(bool a) public pure returns (bool x) {",
|
||
"function f3(mapping(uint => uint) memory) view public {}",
|
||
"function f3(uint x) public returns (uint) { b[uint8(msg.data[2])] = x; }",
|
||
"function f3(uint16[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}",
|
||
"function f32(int256 a) external view returns (int256) {",
|
||
"function f32(uint256 a) external view returns (uint256) {",
|
||
"function f3a() public returns (uint x) {",
|
||
"function f3b() public returns (uint x) {",
|
||
"function f3c() public returns (uint x) {",
|
||
"function f4 ( bytes32 hash , uint8 v , bytes32 r , bytes32 s , uint blockExpired , bytes32 salt ) public returns ( address ) {",
|
||
"function f4() public pure returns (bool) {",
|
||
"function f4() public returns (bytes memory r) {",
|
||
"function f4() public returns (bytes memory) {",
|
||
"function f4() public returns (uint x) {",
|
||
"function f4() public returns(int) {",
|
||
"function f4() public {",
|
||
"function f4() view public returns (bytes memory) {",
|
||
"function f4(bool a) public pure returns (bool x) {",
|
||
"function f4(bytes32 a) external view returns (bytes32) {",
|
||
"function f4(mapping(uint => uint) storage) pure internal {}",
|
||
"function f4(uint x) public returns (uint) { b[uint8(msg.data[3])] = x; }",
|
||
"function f4(uint32[] memory, string[12] memory, bytes[2][] memory, address) public returns (uint[] memory, uint16[] memory) {}",
|
||
"function f4a() public returns (uint x) {",
|
||
"function f4b() public returns (uint x) {",
|
||
"function f4c() public returns (uint x) {",
|
||
"function f5() public pure returns (bool) {",
|
||
"function f5(address[] memory, string[] memory, bytes memory, address) public returns (uint[] memory, uint16[] memory) {}",
|
||
"function f5(mapping(uint => uint) memory) pure internal {}",
|
||
"function f5(uint x) public returns (uint) { b[uint8(msg.data[4])] = x; }",
|
||
"function f6() public pure returns (bool) {",
|
||
"function f6(uint x) public returns (uint) { b[uint8(msg.data[5])] = x; }",
|
||
"function f6(uint[30] memory, string[] memory, uint16, address) public returns (uint16[200] memory, uint16[] memory) {}",
|
||
"function f64(int256 a) external view returns (int256) {",
|
||
"function f64(uint256 a) external view returns (uint256) {",
|
||
"function f7(uint x) public returns (uint) { b[uint8(msg.data[6])] = x; }",
|
||
"function f7(uint[31] memory, string[20] memory, C, address) public returns (bytes[] memory, uint16[] memory) {}",
|
||
"function f8(bytes32 a) external view returns (bytes32) {",
|
||
"function f8(int256 a) external view returns (int256) {",
|
||
"function f8(uint x) public returns (uint) { b[uint8(msg.data[7])] = x; }",
|
||
"function f8(uint256 a) external view returns (uint256) {",
|
||
"function f8(uint[32] memory, string[] memory, uint32, address) public returns (uint[] memory, uint16[] memory) {}",
|
||
"function f9(uint x) public returns (uint) { b[uint8(msg.data[8])] = x; }",
|
||
"function f_e_only(uint256[] calldata x, uint256 e) external returns (uint256) {",
|
||
"function f_internal() internal {}",
|
||
"function f_priv() private {}",
|
||
"function f_reenc(function() external returns (uint)[] calldata s) external returns (uint, uint, uint) {",
|
||
"function f_s_only(uint256[] calldata x, uint256 s) external returns (uint256) {",
|
||
"function fa(bytes memory) public { }",
|
||
"function fa(uint) public {}",
|
||
"function faa() public override {}",
|
||
"function faa() public override(A, B) {}",
|
||
"function faa() public {}",
|
||
"function fac(n) -> nf {",
|
||
"function fail() public pure returns (bool x) {",
|
||
"function fallback() external pure {}",
|
||
"function fb(uint) internal {}",
|
||
"function fc(uint) internal {}",
|
||
"function fd(uint) external {}",
|
||
"function fe(uint) external {}",
|
||
"function fetch(uint256 a) public view returns (uint256) {",
|
||
"function ff(uint) internal {}",
|
||
"function ffff(uint256 a) external view returns (uint256, uint256) {",
|
||
"function ffffffffffffffffffffff(announcementTypeTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Ty, string A) onlyOwner external {",
|
||
"function fffffffffffffffffffffff(announcementTypeTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Typ, string A) onlyOwner external {",
|
||
"function ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff(announcementType Type,",
|
||
"function ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff(announcementType Type, string Announcement, string Link, bool Oppositable, string _str, uint256 _uint, address _addr) onlyOwner external {",
|
||
"function fg(uint) internal pure {}",
|
||
"function fh(uint) pure internal {}",
|
||
"function fii() public",
|
||
"function find(",
|
||
"function find(slice memory self, slice memory needle) internal pure returns (slice memory) {",
|
||
"function find(uint256 v) public returns (uint256) {",
|
||
"function find(uint256[] storage _data, uint256 _value)",
|
||
"function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {",
|
||
"function five() public pure returns (uint, uint, uint, uint, uint) {}",
|
||
"function five() public view returns(uint) {",
|
||
"function fixedBytes() public returns(bytes32 ret) {",
|
||
"function fixedBytesHex() public returns(bytes32 ret) {",
|
||
"function floorLog2(uint x)",
|
||
"function fn() public pure {",
|
||
"function foo() external override returns (uint) { return 3; }",
|
||
"function foo() external override(B, C) virtual returns (uint256) {}",
|
||
"function foo() external payable override(B, C) virtual returns (uint256) {}",
|
||
"function foo() external pure override virtual returns (uint256) {}",
|
||
"function foo() external pure override(B, C) virtual returns (uint256) {}",
|
||
"function foo() external pure virtual returns (uint);",
|
||
"function foo() external pure virtual returns (uint256) {}",
|
||
"function foo() external returns (uint) {",
|
||
"function foo() external returns (uint);",
|
||
"function foo() external view override virtual returns (uint256) {}",
|
||
"function foo() external virtual override returns (uint) { return 2; }",
|
||
"function foo() external virtual override returns (uint);",
|
||
"function foo() external virtual override view returns(uint) { return 5; }",
|
||
"function foo() external virtual returns (uint) { return 1; }",
|
||
"function foo() external virtual view returns(A) { }",
|
||
"function foo() external virtual view returns(uint) { return 4; }",
|
||
"function foo() external virtual view returns(uint) { return 5; }",
|
||
"function foo() internal override returns (uint256) {}",
|
||
"function foo() internal override virtual returns (uint256);",
|
||
"function foo() internal override(A, B) virtual returns (uint256);",
|
||
"function foo() internal override(A, B) {}",
|
||
"function foo() internal override(A, B, C, D) returns (uint256) {}",
|
||
"function foo() internal override(A, C) virtual returns (uint256);",
|
||
"function foo() internal override(A, C, B, B, B, D ,D) virtual returns (uint256);",
|
||
"function foo() internal override(MyStruct, ENUM, A, B, C, D) virtual returns (uint256);",
|
||
"function foo() internal override(N, Z) returns (uint256);",
|
||
"function foo() internal override(X, address) returns (uint256);",
|
||
"function foo() internal pure override virtual returns (uint256) {}",
|
||
"function foo() internal pure override(B, C) virtual returns (uint256) {}",
|
||
"function foo() internal returns (uint) {",
|
||
"function foo() internal returns (uint256);",
|
||
"function foo() internal view override virtual returns (uint256) {}",
|
||
"function foo() internal view virtual returns (uint256) {}",
|
||
"function foo() internal virtual returns (uint256) {}",
|
||
"function foo() internal virtual returns (uint256);",
|
||
"function foo() internal virtual returns (uint8);",
|
||
"function foo() internal virtual view returns(uint) { return 5; }",
|
||
"function foo() internal {",
|
||
"function foo() internal {}",
|
||
"function foo() only_owner public virtual;",
|
||
"function foo() public override virtual returns (uint256) {}",
|
||
"function foo() public override { }",
|
||
"function foo() public override {}",
|
||
"function foo() public payable override virtual returns (uint256) {}",
|
||
"function foo() public payable virtual returns (uint256) {}",
|
||
"function foo() public pure override virtual returns (uint256) {}",
|
||
"function foo() public returns (bool) {",
|
||
"function foo() public returns (bytes32 d) {",
|
||
"function foo() public returns (bytes32) {",
|
||
"function foo() public returns (int) { return o = 3; }",
|
||
"function foo() public returns (uint256) { return Child.m_aMember2; }",
|
||
"function foo() public returns (uint256) { return Parent.m_aMember; }",
|
||
"function foo() public returns (uint256) { return Parent2.m_aMember1; }",
|
||
"function foo() public view override virtual returns (uint256) {}",
|
||
"function foo() public view virtual returns (uint256) {}",
|
||
"function foo() public view {",
|
||
"function foo() public virtual returns (uint256) {}",
|
||
"function foo() public virtual {}",
|
||
"function foo() public virtual;",
|
||
"function foo() public {",
|
||
"function foo() public { b = new base(); }",
|
||
"function foo() public {}",
|
||
"function foo() public;",
|
||
"function foo() pure internal {",
|
||
"function foo() virtual external;",
|
||
"function foo() virtual internal {}",
|
||
"function foo() virtual public virtual {}",
|
||
"function foo(E e) internal pure returns (uint) {",
|
||
"function foo(I i) internal pure returns (uint) {",
|
||
"function foo(X param) private view",
|
||
"function foo(address a, address b) public returns (bool) {",
|
||
"function foo(bool a, bool b) public returns (bool) {",
|
||
"function foo(int a) external {",
|
||
"function foo(int a) payable external {",
|
||
"function foo(int a) pure external {",
|
||
"function foo(int a) pure internal {",
|
||
"function foo(uint ) external virtual view returns(uint) { return 4; }",
|
||
"function foo(uint , uint ) external view virtual returns(A) { }",
|
||
"function foo(uint a, uint b) public returns (uint d) { return a + b; }",
|
||
"function foo(uint x) override public returns(uint) {return x;}",
|
||
"function foo(uint x) virtual public returns(uint);",
|
||
"function foo(uint) internal virtual pure returns(uint) { return 5; }",
|
||
"function foo(uint256 a) public returns (bytes4 value) {",
|
||
"function foo(uint256 a, uint16 b) public returns (bytes32 d) {",
|
||
"function foo(uint256 a, uint256 b) public returns (uint256) {",
|
||
"function foo(uint256 a, uint256 b, uint256 c) public returns (bytes32 d) {",
|
||
"function foo(uint256 value) internal pure returns (uint256) {",
|
||
"function foo(uint256 value) internal returns (uint256) {",
|
||
"function foo2() virtual public {}",
|
||
"function four() public pure returns (uint, uint, uint, uint) {}",
|
||
"function fow() public { x = 3; }",
|
||
"function fpure() public returns (uint256) {",
|
||
"function freezing(bool forever) external {",
|
||
"function fu() pure returns (uint, uint) {",
|
||
"function fun() -> a3, b3, c3, d3, e3, f3, g3, h3, i3, j3, k3, l3, m3, n3, o3, p3",
|
||
"function fun() C.someModifier {",
|
||
"function fun() override {",
|
||
"function fun() payable {",
|
||
"function fun() public pure {",
|
||
"function fun() public pure {}",
|
||
"function fun() public returns (bool ret) {",
|
||
"function fun() public returns (bool) {",
|
||
"function fun() public returns (uint r) {",
|
||
"function fun() public view {",
|
||
"function fun() public {",
|
||
"function fun() public { }",
|
||
"function fun() someModifier {",
|
||
"function fun() virtual {",
|
||
"function fun() {",
|
||
"function fun(S storage) {",
|
||
"function fun(uint a) public returns(uint r) { return a; }",
|
||
"function fun(uint a, uint b) public returns(uint r) { return a + b; }",
|
||
"function fun(uint, bool, uint) public returns (uint) {",
|
||
"function fun(uint256 a) public returns (uint) {",
|
||
"function fun(uint256 a) public returns (uint8 b) {",
|
||
"function fun(uint256 a) public {",
|
||
"function fun(uint256 arg1) public { uint256 y; y = arg1; }",
|
||
"function fun(uint256, uint[] calldata _x, uint[] storage _y) view returns (uint, uint[] calldata) {",
|
||
"function fun(uint[] calldata _x, uint[] storage _y) view returns (uint, uint[] calldata) {",
|
||
"function fun1() public { }",
|
||
"function fun2() internal { }",
|
||
"function fun_() public {}",
|
||
"function fun_x() public {}",
|
||
"function fun_y() public {}",
|
||
"function func ( ) private pure {",
|
||
"function func() private pure {",
|
||
"function func() public pure {",
|
||
"function func() public {}",
|
||
"function funcCalled() external {",
|
||
"function funcNotCalled() public {",
|
||
"function funcNotCalled2() public {",
|
||
"function funcNotCalled3() public {",
|
||
"function funcTakesExternalMutable(function(uint256) external returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesExternalPayable(function(uint256) external payable returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesExternalPure(function(uint256) external pure returns(uint256) a) internal pure returns (uint256) { return a(4); }",
|
||
"function funcTakesExternalPure(function(uint256) external pure returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesExternalView(function(uint256) external view returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesExternalView(function(uint256) external view returns(uint256) a) internal view returns (uint256) { return a(4); }",
|
||
"function funcTakesInternalMutable(function(uint256) internal returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesInternalPure(function(uint256) internal pure returns(uint256) a) internal pure returns (uint256) { return a(4); }",
|
||
"function funcTakesInternalPure(function(uint256) internal pure returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesInternalView(function(uint256) internal view returns(uint256) a) internal returns (uint256) { return a(4); }",
|
||
"function funcTakesInternalView(function(uint256) internal view returns(uint256) a) internal view returns (uint256) { return a(4); }",
|
||
"function functionName() public {}",
|
||
"function functionName(bytes20 arg1, address addr) public view returns (int id) { }",
|
||
"function functionName(bytes32 input) public returns (bytes32 out) {}",
|
||
"function functionName(bytes32 input) public virtual returns (bytes32 out);",
|
||
"function functionName1(bytes32 input) public returns (bytes32 out) {}",
|
||
"function functionName2(bytes32 input) public returns (bytes32 out) {}",
|
||
"function functionName3(bytes32 input) public returns (bytes32 out) {}",
|
||
"function functionName4(bytes32 input) public returns (bytes32 out) {}",
|
||
"function fund(uint _funding)",
|
||
"function fund(uint _funding) virtual public;",
|
||
"function fund(uint amount)",
|
||
"function fund(uint funding)",
|
||
"function fview() public returns (uint256) {",
|
||
"function g (C c) external {}",
|
||
"function g (C c) public {}",
|
||
"function g (S calldata) external view {}",
|
||
"function g() -> a,b, c {}",
|
||
"function g() -> x { x := a }",
|
||
"function g() -> x { x := a.offset }",
|
||
"function g() -> x { x := a.slot }",
|
||
"function g() external override virtual;",
|
||
"function g() external override {}",
|
||
"function g() external payable returns (uint) { assert(msg.value > 0); return 2; }",
|
||
"function g() external pure returns (bytes32) { return \"abcabc\"; }",
|
||
"function g() external pure returns (uint[2]) {}",
|
||
"function g() external pure returns(bytes4) {",
|
||
"function g() external pure {}",
|
||
"function g() external returns (address ret) {",
|
||
"function g() external returns (bool) {",
|
||
"function g() external returns (byte) {",
|
||
"function g() external returns (bytes memory) {",
|
||
"function g() external virtual;",
|
||
"function g() external {",
|
||
"function g() external {}",
|
||
"function g() external;",
|
||
"function g() internal",
|
||
"function g() internal override returns (uint256 i) {",
|
||
"function g() internal pure returns (I.Direction) {",
|
||
"function g() internal pure returns (S storage c) {",
|
||
"function g() internal pure returns (bytes calldata) {",
|
||
"function g() internal pure returns (bytes32, bytes16) {",
|
||
"function g() internal pure returns (uint) { return 1; }",
|
||
"function g() internal pure returns (uint, S memory) {",
|
||
"function g() internal pure returns (uint, uint, uint, D.S[20] storage x, uint) { x = x; }",
|
||
"function g() internal pure returns (uint[2]) {}",
|
||
"function g() internal pure returns (uint[] memory) {",
|
||
"function g() internal pure returns(uint[] memory, uint[] storage b) { b = b; }",
|
||
"function g() internal pure returns(uint[]) {}",
|
||
"function g() internal pure {",
|
||
"function g() internal returns (S storage r)",
|
||
"function g() internal returns (function(uint8) internal returns(uint))",
|
||
"function g() internal returns (uint256 a, uint256 b, uint256[] storage c) {",
|
||
"function g() internal returns (uint256, S storage, uint256) {",
|
||
"function g() internal view returns (S memory) {",
|
||
"function g() internal view returns (S storage c) {",
|
||
"function g() internal view returns (S storage) { return s; }",
|
||
"function g() internal view returns (bytes16[] storage) {",
|
||
"function g() internal view {",
|
||
"function g() internal view { s; }",
|
||
"function g() internal virtual returns (uint256 i) {",
|
||
"function g() internal virtual returns(uint[] storage s);",
|
||
"function g() internal {",
|
||
"function g() internal {}",
|
||
"function g() nonpayablem(0) view public {}",
|
||
"function g() private pure returns (uint[2]) {}",
|
||
"function g() private view returns (mapping(uint=>uint) storage) {",
|
||
"function g() private view returns (mapping(uint=>uint)[] storage) {",
|
||
"function g() public pure returns (uint, uint) {",
|
||
"function g() public onlyOwner {",
|
||
"function g() public override returns (uint x) {",
|
||
"function g() public override returns (uint256 i) {",
|
||
"function g() public override returns (uint256 r) {",
|
||
"function g() public override {}",
|
||
"function g() public payable {}",
|
||
"function g() public pure returns (",
|
||
"function g() public pure returns (address payable r) {",
|
||
"function g() public pure returns (address) {",
|
||
"function g() public pure returns (bool) {",
|
||
"function g() public pure returns (byte payable) {}",
|
||
"function g() public pure returns (bytes32 val) { return \"abc\"; }",
|
||
"function g() public pure returns (bytes32 x) {",
|
||
"function g() public pure returns (string memory) {",
|
||
"function g() public pure returns (string memory, uint, string memory) {",
|
||
"function g() public pure returns (uint a)",
|
||
"function g() public pure returns (uint a, uint b)",
|
||
"function g() public pure returns (uint a, uint b, uint c) {",
|
||
"function g() public pure returns (uint x) {",
|
||
"function g() public pure returns (uint x, uint y, uint z) {",
|
||
"function g() public pure returns (uint)",
|
||
"function g() public pure returns (uint) {",
|
||
"function g() public pure returns (uint) {}",
|
||
"function g() public pure returns (uint, uint)",
|
||
"function g() public pure returns (uint, uint) {",
|
||
"function g() public pure returns (uint128) {",
|
||
"function g() public pure returns (uint256) {",
|
||
"function g() public pure {",
|
||
"function g() public pure { f(true); }",
|
||
"function g() public pure { int16 x = 3; uint16 y = 4; x ** y; }",
|
||
"function g() public returns (Succeeds x, uint, string memory txt) {",
|
||
"function g() public returns (T memory) {",
|
||
"function g() public returns (bool ret) {",
|
||
"function g() public returns (bool) {",
|
||
"function g() public returns (bool, bool, uint256) {",
|
||
"function g() public returns (bool, uint256) {",
|
||
"function g() public returns (byte) {",
|
||
"function g() public returns (bytes memory) {",
|
||
"function g() public returns (bytes4) {",
|
||
"function g() public returns (int16[2] memory) {",
|
||
"function g() public returns (string memory, string memory) {",
|
||
"function g() public returns (uint a, function() external h, uint b) {",
|
||
"function g() public returns (uint a, uint b, uint c) {",
|
||
"function g() public returns (uint x) {",
|
||
"function g() public returns (uint) {",
|
||
"function g() public returns (uint) { function (uint) returns (uint) x = f; return x(7); }",
|
||
"function g() public returns (uint) { return f().balance(); }",
|
||
"function g() public returns (uint) { return f(1); }",
|
||
"function g() public returns (uint) { return f(3, 5); }",
|
||
"function g() public returns (uint) { return x; }",
|
||
"function g() public returns (uint) {}",
|
||
"function g() public returns (uint, byte, byte, byte) {",
|
||
"function g() public returns (uint, byte, uint, byte, uint, uint) {",
|
||
"function g() public returns (uint, uint) {",
|
||
"function g() public returns (uint256 a, uint256 b, uint256 c) {",
|
||
"function g() public returns (uint256 d) {",
|
||
"function g() public returns (uint256 r) {",
|
||
"function g() public returns (uint256) {",
|
||
"function g() public returns (uint256, uint256) {",
|
||
"function g() public returns (uint8, uint8, uint8, uint8, uint8, uint8) {",
|
||
"function g() public returns (uint[5] memory) {",
|
||
"function g() public returns(bytes32) {",
|
||
"function g() public returns(uint) {",
|
||
"function g() public returns(uint[] storage s);",
|
||
"function g() public view returns (bytes32) {",
|
||
"function g() public view returns (function (uint) external returns (uint)) {",
|
||
"function g() public view returns (uint) {",
|
||
"function g() public view {",
|
||
"function g() public virtual override returns (uint256 r) {",
|
||
"function g() public virtual override view {}",
|
||
"function g() public virtual pure {}",
|
||
"function g() public virtual returns (uint x) {",
|
||
"function g() public virtual returns (uint256 i) {",
|
||
"function g() public virtual returns (uint256 r) {",
|
||
"function g() public virtual;",
|
||
"function g() public {",
|
||
"function g() public { (new receiver()).nopay.value(10)(); }",
|
||
"function g() public { L.f(1, 2, 3); }",
|
||
"function g() public { base.f(); }",
|
||
"function g() public { c(0).a(); }",
|
||
"function g() public { c(0).f(); }",
|
||
"function g() public { f(); rootFunction(); }",
|
||
"function g() public { f(); }",
|
||
"function g() public { f(1, 2, 3); }",
|
||
"function g() public { fun(); }",
|
||
"function g() public { int x; }",
|
||
"function g() public { revert(\"fail\"); }",
|
||
"function g() public { revert(); }",
|
||
"function g() public { this.f.value(); }",
|
||
"function g() public { x; }",
|
||
"function g() public {}",
|
||
"function g() pure internal {",
|
||
"function g() pure public returns (bytes4) {",
|
||
"function g() pure public returns (uint x) {",
|
||
"function g() pure public returns (uint, uint, uint) {}",
|
||
"function g() pure public {",
|
||
"function g() pure public { g(); }",
|
||
"function g() pure public {}",
|
||
"function g() view external returns (uint ret) {",
|
||
"function g() view external returns (uint sb) {",
|
||
"function g() view public {",
|
||
"function g() view public { x; }",
|
||
"function g() view public { }",
|
||
"function g() viewm(0) view public {}",
|
||
"function g() {}",
|
||
"function g(B calldata b) external pure returns(uint256) {",
|
||
"function g(C) public view returns (C) {",
|
||
"function g(L.S memory s) public view {}",
|
||
"function g(S calldata c) external pure returns (uint, uint, uint, uint, uint, uint) {",
|
||
"function g(S calldata s) external returns (bytes memory) {",
|
||
"function g(S calldata s) external { S memory m; s = m; }",
|
||
"function g(S calldata) external view;",
|
||
"function g(S calldata) external virtual view { dummy; }",
|
||
"function g(S memory m) public returns (uint) { return m.a; }",
|
||
"function g(S memory s) public view {}",
|
||
"function g(S memory) public override view { dummy; }",
|
||
"function g(S storage s, uint y) internal {",
|
||
"function g(S[] calldata s) external view returns (bytes memory) {",
|
||
"function g(address a) external pure {",
|
||
"function g(address payable _p) internal pure returns (uint) {",
|
||
"function g(address payable a) public returns (uint256) {",
|
||
"function g(address payable) public pure returns (address payable) {}",
|
||
"function g(address view) public pure {}",
|
||
"function g(address x) external pure returns (uint256 r) {",
|
||
"function g(bool _b) internal returns (bool) {",
|
||
"function g(bool _in) public returns (bool _out) {",
|
||
"function g(bool _value) public pure {",
|
||
"function g(bool a) public returns (bool) {",
|
||
"function g(bool b) public pure returns (uint x) {",
|
||
"function g(bool b) public pure returns (uint x, uint y) {",
|
||
"function g(bool b) public pure returns (uint, uint) {",
|
||
"function g(bool b) public returns (uint, string memory) {",
|
||
"function g(bool b) public {",
|
||
"function g(bool condition) public returns (uint x) {",
|
||
"function g(bool flag) ifFlag(flag) revertIfNoReturn() internal view returns(S storage) {",
|
||
"function g(bool flag) internal pure returns (S storage c) {",
|
||
"function g(bool flag) internal pure {",
|
||
"function g(bool flag) internal returns (S storage c) {",
|
||
"function g(bool flag) internal view returns (S storage c) {",
|
||
"function g(bool flag) internal view {",
|
||
"function g(bool flag) internal {",
|
||
"function g(bool flag) public returns (uint256 d) {",
|
||
"function g(bool flag) revertIfNoReturn() ifFlag(flag) internal view returns(S storage) {",
|
||
"function g(bool flag) revertIfNoReturn() ifFlag(flag) internal view {",
|
||
"function g(bool reenc) external returns (uint, uint, uint) {",
|
||
"function g(bool val) public returns (bool) {",
|
||
"function g(bool x) external pure {",
|
||
"function g(bool x) public pure {",
|
||
"function g(bool x, uint[2] memory c) public {",
|
||
"function g(byte payable) public pure {}",
|
||
"function g(bytes calldata _x) internal pure returns (bytes memory) {",
|
||
"function g(bytes calldata _x) public pure returns (bytes memory) {",
|
||
"function g(bytes memory _x) internal pure returns (byte) {",
|
||
"function g(bytes memory _x) public pure returns (byte) {",
|
||
"function g(bytes memory revertMsg) public pure returns (uint, uint) {",
|
||
"function g(bytes32 x) public returns (uint256) {",
|
||
"function g(bytes32) pure internal {}",
|
||
"function g(bytes7 a) pure public {",
|
||
"function g(function (address payable) payable external returns (address payable)) public payable returns (function (address payable) payable external returns (address payable)) {",
|
||
"function g(function() external cb) public returns (address) {",
|
||
"function g(function() external pure x) external view {",
|
||
"function g(function() internal pure x) internal view {",
|
||
"function g(function() internal returns (uint) _t) internal returns (uint) { return _t(); }",
|
||
"function g(function(S memory) external) public {}",
|
||
"function g(function(test) external returns (test[] memory) x) public {}",
|
||
"function g(function(uint) external returns (uint) x) public {}",
|
||
"function g(function(uint) internal returns (uint)[] storage x) public { }",
|
||
"function g(int x, int y) public pure returns (int) { return x - y; }",
|
||
"function g(int256 a, int256 b) public returns (int256) {",
|
||
"function g(int256 a, uint256 b) public returns (int256) {",
|
||
"function g(int256 x, uint y) public returns (int) {",
|
||
"function g(int8 a, int8 b) public pure returns (int8 x) {",
|
||
"function g(int8 a, uint8 b) public returns (int256) {",
|
||
"function g(r) - > s {",
|
||
"function g(uint _x) public {",
|
||
"function g(uint _y) public view {",
|
||
"function g(uint a) external {}",
|
||
"function g(uint a) internal pure {}",
|
||
"function g(uint a) public returns (uint, uint, uint) {",
|
||
"function g(uint a, uint b) m(a, b) internal pure returns (bool) {",
|
||
"function g(uint a, uint b) notZero(a) internal pure returns (bool) {",
|
||
"function g(uint a, uint b) public {",
|
||
"function g(uint a, uint b, uint c, uint d, uint e) public {",
|
||
"function g(uint b) public returns (uint e) { return b * 8; }",
|
||
"function g(uint base, uint exponent) public pure returns (uint) {",
|
||
"function g(uint n) external payable returns (uint, uint) {",
|
||
"function g(uint n) external pure returns (uint) {",
|
||
"function g(uint n, uint m) public {",
|
||
"function g(uint x) public virtual;",
|
||
"function g(uint x) public {",
|
||
"function g(uint x) pure returns (uint) { return A.f(x) * 3; }",
|
||
"function g(uint x, uint y) public returns (uint) {",
|
||
"function g(uint x, uint y) public {",
|
||
"function g(uint x, uint y, uint v) public {",
|
||
"function g(uint x, uint y, uint[] memory c) public {",
|
||
"function g(uint x, uint[] memory c) public {",
|
||
"function g(uint y) public {",
|
||
"function g(uint) public pure returns (uint) { return 2; }",
|
||
"function g(uint) public {",
|
||
"function g(uint16) {}",
|
||
"function g(uint256 a) internal pure returns (S storage c) {",
|
||
"function g(uint256 a) internal pure {",
|
||
"function g(uint256 a) public returns (uint256) {",
|
||
"function g(uint256 a, uint256 b) public returns (bool) {",
|
||
"function g(uint256 d) public pure returns (uint256) {",
|
||
"function g(uint256 v) external returns (uint) {",
|
||
"function g(uint256 v) external returns (uint256) {",
|
||
"function g(uint256 v) public view returns (uint256) {",
|
||
"function g(uint256 value) public payable returns (bool) {",
|
||
"function g(uint256 x) public pure returns (uint256) {",
|
||
"function g(uint256 x) public returns (uint256 a) {",
|
||
"function g(uint256 x) public returns (uint256) {",
|
||
"function g(uint256 x) public view returns(uint256) { return x + 1; }",
|
||
"function g(uint256 x) public view returns(uint256) { return x; }",
|
||
"function g(uint256 y) external {",
|
||
"function g(uint256 y) public pure returns (uint256 x) {",
|
||
"function g(uint256) external returns (uint256) {}",
|
||
"function g(uint256) external view {}",
|
||
"function g(uint256) external {}",
|
||
"function g(uint256) public returns (uint256) {",
|
||
"function g(uint256, bool) public returns (uint256) { }",
|
||
"function g(uint256[3] calldata s) external view returns (bytes memory) {",
|
||
"function g(uint256[3] calldata s1, uint256[2] calldata s2, bool which) external view returns (bytes memory) {",
|
||
"function g(uint256[3][2] calldata s, uint256 which) external view returns (bytes memory) {",
|
||
"function g(uint256[] calldata s) external view returns (bytes memory) {",
|
||
"function g(uint256[] calldata s1, uint256[] calldata s2, bool which) external view returns (bytes memory) {",
|
||
"function g(uint256[] calldata x, uint256 s, uint256 e, uint256 idx) external returns (uint256) {",
|
||
"function g(uint256[] calldata x, uint256 start, uint256 end, uint256 index) external pure returns (uint256, uint256, uint256) {",
|
||
"function g(uint256[] calldata) external pure returns (bytes memory) {",
|
||
"function g(uint256[] memory _data) private {",
|
||
"function g(uint256[] storage s) external returns (uint) { return s.length; }",
|
||
"function g(uint256[] storage) external {}",
|
||
"function g(uint256[][1][] calldata a) external returns (uint256) {",
|
||
"function g(uint256[][2] calldata s, uint256 which) external view returns (bytes memory) {",
|
||
"function g(uint256[][2][] calldata x) external returns (uint256) {",
|
||
"function g(uint256[][] calldata a) external returns (uint256) {",
|
||
"function g(uint256[][] calldata s) external view returns (bytes memory) {",
|
||
"function g(uint8 a, uint8 b) public pure returns (uint8 x) {",
|
||
"function g(uint8) {}",
|
||
"function g(uint[2]) external pure {}",
|
||
"function g(uint[3][2] calldata s) internal pure returns (uint, uint[3] calldata) {",
|
||
"function g(uint[] calldata) external override view { dummy; }",
|
||
"function g(uint[] calldata) external view;",
|
||
"function g(uint[] calldata) external virtual view { dummy; }",
|
||
"function g(uint[] memory x) public {",
|
||
"function g(uint[] memory) public override view { dummy; }",
|
||
"function g(uint[] memory, uint[] storage) internal pure",
|
||
"function g(uint[] memory, uint[] storage) internal pure {}",
|
||
"function g(uint[] storage x) pure { x[0] = 1; }",
|
||
"function g(uint[]) internal pure {}",
|
||
"function g(uint[][1] calldata) external { }",
|
||
"function g(uint[][2] calldata s) internal pure returns (uint, uint[] calldata) {",
|
||
"function g.f() {}",
|
||
"function g0(uint x) public payable returns (uint) { require(x > 10); }",
|
||
"function g1() public pure returns (bool) {",
|
||
"function g1() public returns (bytes memory) {",
|
||
"function g1(bytes[2] calldata a)",
|
||
"function g1(uint x) public payable returns (uint) { a = x; b[uint8(msg.data[0])] = x; }",
|
||
"function g128(int128 x) external pure returns (int256) {",
|
||
"function g128(uint128 x) external pure returns (uint256) {",
|
||
"function g16(bytes16 x) external pure returns (bytes32) {",
|
||
"function g2() public pure returns (bool) {",
|
||
"function g2() public returns (bytes memory) {",
|
||
"function g2(S calldata c1, S calldata c2) external pure returns (uint, uint, uint, uint, uint, uint) {",
|
||
"function g2(bytes[] calldata a) external returns (uint256[8] memory) {",
|
||
"function g2(uint n, uint m, uint a, uint b) public {",
|
||
"function g2(uint x) public payable returns (uint) { b[uint8(msg.data[1])] = x; }",
|
||
"function g3() public pure returns (bool) {",
|
||
"function g3() public returns (bytes memory) {",
|
||
"function g3(uint x) public payable returns (uint) { b[uint8(msg.data[2])] = x; }",
|
||
"function g4() public pure returns (bool) {",
|
||
"function g4() public returns (bytes memory) {",
|
||
"function g4(uint x) public payable returns (uint) { b[uint8(msg.data[3])] = x; }",
|
||
"function g5() public pure returns (bool) {",
|
||
"function g5(uint x) public payable returns (uint) { b[uint8(msg.data[4])] = x; }",
|
||
"function g6() public pure returns (bool) {",
|
||
"function g6(uint x) public payable returns (uint) { b[uint8(msg.data[5])] = x; }",
|
||
"function g7(uint x) public payable returns (uint) { b[uint8(msg.data[6])] = x; }",
|
||
"function g8(uint x) public payable returns (uint) { b[uint8(msg.data[7])] = x; }",
|
||
"function g9(uint x) public payable returns (uint) { b[uint8(msg.data[8])] = x; }",
|
||
"function gNonPayable() public returns (uint) { x = 4; return 0; }",
|
||
"function gView() public view returns (uint) { return x; }",
|
||
"function gasleft() public pure returns (bytes32 val) { return \"abc\"; }",
|
||
"function gasleft() public returns (uint256) {",
|
||
"function geq() public pure returns (bool) {",
|
||
"function get()",
|
||
"function get() external view returns (uint256) {",
|
||
"function get() public returns (uint24[3][] memory) {",
|
||
"function get() public returns (uint256 a, uint256 b, uint256 c) {",
|
||
"function get() public view returns (uint) {",
|
||
"function get(A k) public returns (uint8 v) {",
|
||
"function get(A k) public returns (uint8) {",
|
||
"function get(E k) public returns (uint8 v) {",
|
||
"function get(E k) public returns (uint8) {",
|
||
"function get(mapping(A => uint8) storage table, A k) external returns (uint8) {",
|
||
"function get(mapping(E => uint8) storage table, E k) external returns (uint8) {",
|
||
"function get(uint256 index) public returns (uint256) {",
|
||
"function get(uint8 k) public returns (uint8 v) {",
|
||
"function get(uint8 key) public returns (uint8, uint8) {",
|
||
"function get(uint8 key) public returns (uint8, uint8, uint8, uint8) {",
|
||
"function get(uint8 which) public returns (uint256 value) {",
|
||
"function getA() public returns (uint256 r) {",
|
||
"function getAllowance(address owner, address spender) public view returns(bool success, uint256 remaining, uint256 nonce) {",
|
||
"function getBMember() public returns (uint256 i) {",
|
||
"function getBalance() payable public returns(uint256 myBalance) {",
|
||
"function getBalance() public payable returns (uint256 myBalance) {",
|
||
"function getBalance() public returns (uint256 balance) {",
|
||
"function getBalance() public view returns (uint) {",
|
||
"function getBalances() public returns (uint256 me, uint256 them) {",
|
||
"function getChoice() public returns (uint256 d) {",
|
||
"function getChoiceExp(uint256 x) public returns (uint256 d) {",
|
||
"function getChoiceFromNegativeLiteral() public returns (uint256 d) {",
|
||
"function getChoiceFromSigned(int256 x) public returns (uint256 d) {",
|
||
"function getClientReward(uint256 limit) internal returns (uint256 reward) {",
|
||
"function getConfirmationCount(uint transactionId)",
|
||
"function getConfirmations(uint transactionId)",
|
||
"function getCurrentRound() internal returns (uint256) {",
|
||
"function getCurrentRound() public view returns(bool, uint256) {",
|
||
"function getCurrentSchellingRound() internal view returns(uint256) {",
|
||
"function getCurrentSchellingRound() public view returns(bool, uint256) {",
|
||
"function getCurrentSchellingRoundID() public view returns (bool success, uint256 round) {",
|
||
"function getCurrentSchellingRoundID() public view returns (uint256) {",
|
||
"function getDMember() public returns (uint256 i) {",
|
||
"function getData() public returns (uint r) { return data; }",
|
||
"function getData() public returns (uint256 r) {",
|
||
"function getData(uint256 index) public returns (uint256 x, uint256 y) {",
|
||
"function getElement(uint256 i) public returns (uint256) {",
|
||
"function getEventHash()",
|
||
"function getEventHash() virtual public view returns (bytes32);",
|
||
"function getFirst() public returns (uint256) {",
|
||
"function getFlag() public returns (bool fl) {",
|
||
"function getFlag() public returns (bool ret) {",
|
||
"function getFlag() public returns(bool fl) {",
|
||
"function getFunds() isReady noContract external {",
|
||
"function getFunds(address _owner) public view returns(bool, uint256) {",
|
||
"function getFunds(address addr) internal returns (uint256) {",
|
||
"function getID(uint256 index) public returns (uint256) {",
|
||
"function getIcoReward(uint256 value) public view returns (uint256 reward) {",
|
||
"function getInstantiationCount(address creator)",
|
||
"function getInterest(address beneficiary) external {",
|
||
"function getLast() public returns (string memory) {",
|
||
"function getLength() public returns (uint256) {",
|
||
"function getLength() public view returns (uint256) {",
|
||
"function getLengths() public returns (uint256 l1, uint256 l2) {",
|
||
"function getModuleAddressByName(string memory name) public view returns( bool success, bool found, address addr ) {",
|
||
"function getModuleIDByAddress(address addr) public view returns( bool success, bool found, uint256 id ) {",
|
||
"function getModuleIDByHash(bytes32 hashOfName) public view returns( bool success, bool found, uint256 id ) {",
|
||
"function getModuleIDByName(string memory name) public view returns( bool success, bool found, uint256 id ) {",
|
||
"function getMyReward() public override returns (bool _success) {",
|
||
"function getMyReward() public virtual returns (bool _success);",
|
||
"function getName() public returns (bytes3 ret) {",
|
||
"function getName() public returns (bytes6 ret) {",
|
||
"function getNestedMapping(uint index) public returns(bool ret) {",
|
||
"function getNestedValue() public returns(uint nestedValue){",
|
||
"function getNetOutcomeTokensSold(Market market)",
|
||
"function getNewDAOAddress(uint _proposalID) public override view returns (address _newDAO) {",
|
||
"function getNewDAOAddress(uint _proposalID) public virtual view returns (address _newDAO);",
|
||
"function getNumber() public returns(uint){",
|
||
"function getOne() public payable nonFree returns (uint256 r) {",
|
||
"function getOutcome()",
|
||
"function getOutcome() virtual public view returns (int);",
|
||
"function getOutcomeCount()",
|
||
"function getOutcomeTokenDistribution(address owner)",
|
||
"function getOutcomeTokens()",
|
||
"function getOwners()",
|
||
"function getProviderCurrentSupply(address addr) internal view returns (uint256) {",
|
||
"function getProviderDetails(address payable addr, uint256 height) public view returns (uint8 rate, bool isForRent, uint256 clientsCount, bool priv, bool getInterest, bool valid) {",
|
||
"function getProviderInfo(address addr, uint256 height) public view returns (string memory name, string memory website, string memory country, string memory info, uint256 create) {",
|
||
"function getProviderReward(address addr, uint256 limit) internal returns (uint256 providerReward, uint256 adminReward) {",
|
||
"function getReward(address beneficiary, uint256 limit, address provider) isReady external returns (uint256 reward) {",
|
||
"function getRewards(address beneficiary) isReady noContract external {",
|
||
"function getRound(uint256 _id) public view returns(bool, uint256, uint256, uint256, uint256, bool) {",
|
||
"function getRound(uint256 id) internal returns (_rounds memory) {",
|
||
"function getRoundWeight(uint256 aboveW, uint256 belowW) internal returns (uint256) {",
|
||
"function getSchellingExpansion(uint256 _id) public view returns(bool, uint256) {",
|
||
"function getSchellingExpansion(uint256 id) internal view returns(uint256) {",
|
||
"function getSchellingRound(uint256 id) public view returns (uint256 expansion) {",
|
||
"function getSecond() public returns (uint256) {",
|
||
"function getStateVar() public view returns (uint256 stateVar) {",
|
||
"function getStateVar() view public returns (uint stateVar) {",
|
||
"function getStatusAndOutcome()",
|
||
"function getThird() public returns (uint256) {",
|
||
"function getToDelete() public returns (uint res){",
|
||
"function getTokenBalance(address addr) internal returns (uint256 balance) {",
|
||
"function getTopMapping(uint index) public returns(uint ret) {",
|
||
"function getTopValue() public returns(uint topValue){",
|
||
"function getTotalSupply() internal returns (uint256 amount) {",
|
||
"function getTransactionCount(bool pending, bool executed)",
|
||
"function getTransactionFee(uint256 value) public view returns (bool success, uint256 fee) {",
|
||
"function getTransactionIds(uint from, uint to, bool pending, bool executed)",
|
||
"function getUserDetails(address payable addr, uint256 schellingRound) public view returns (address ProviderAddress, uint256 ProviderHeight, uint256 ConnectedOn, uint256 value) {",
|
||
"function getViaB() public returns (uint256 i) {",
|
||
"function getViaBase() public returns (uint256 i) {",
|
||
"function getViaDerived() public returns (uint256 base, uint256 derived) {",
|
||
"function getVoter(address _owner) public view returns(bool success, uint256 roundID,",
|
||
"function getVoter(address addr) internal view returns (_voter memory) {",
|
||
"function getX() public returns (uint256 r) {",
|
||
"function get_delegated() external returns (bool) {",
|
||
"function get_delegated() external returns (bool, bytes memory) {",
|
||
"function get_ptr(function() internal returns (uint) ptr) internal returns(function() internal returns (uint)) {",
|
||
"function getter1() external returns (uint) {",
|
||
"function getter2() external returns (uint) {",
|
||
"function getter3() external returns (uint) {",
|
||
"function gg(S calldata s) external pure returns (bytes memory) {",
|
||
"function gg(uint256[] calldata x, uint256 s, uint256 e, uint256 idx) external returns (uint256) {",
|
||
"function gg1(bytes1 x) external pure returns (bytes32) {",
|
||
"function gg16(int16 x) external pure returns (int256) {",
|
||
"function gg16(uint16 x) external pure returns (uint256) {",
|
||
"function gg2(bytes2 x) external pure returns (bytes32) {",
|
||
"function gg32(int32 x) external pure returns (int256) {",
|
||
"function gg32(uint32 x) external pure returns (uint256) {",
|
||
"function gg4(bytes4 x) external pure returns (bytes32) {",
|
||
"function gg64(int64 x) external pure returns (int256) {",
|
||
"function gg64(uint64 x) external pure returns (uint256) {",
|
||
"function gg8(bytes8 x) external pure returns (bytes32) {",
|
||
"function gg_e_only(uint256[] calldata x, uint256 e, uint256 idx) external returns (uint256) {",
|
||
"function gg_s_only(uint256[] calldata x, uint256 s, uint256 idx) external returns (uint256) {",
|
||
"function ggg(function() external x) external pure returns (uint256 r) {",
|
||
"function ggg(uint8[] calldata s) external pure returns (bytes memory) {",
|
||
"function ggg8(int8 x) external pure returns (int256) {",
|
||
"function ggg8(uint8 x) external pure returns (uint256) {",
|
||
"function gggg(bool x) external pure returns (bool) {",
|
||
"function gggggggg(uint8[2] calldata s) external pure returns (bytes memory) {",
|
||
"function goo() external returns (uint);",
|
||
"function goo() external virtual override returns (uint);",
|
||
"function goo() external virtual override(A, B) returns (uint) {}",
|
||
"function gp(uint[2]) internal pure {}",
|
||
"function gp(uint[2]) private pure {}",
|
||
"function gsf() public { }",
|
||
"function gt() public pure returns (bool) {",
|
||
"function gt(uint a, uint b) public pure returns (bool) {",
|
||
"function gte(uint a, uint b) public pure returns (bool) {",
|
||
"function h ( bool flag ) public returns ( bool c ) {",
|
||
"function h() external payable {}",
|
||
"function h() external pure returns (bytes4) { return 0xcafecafe; }",
|
||
"function h() external pure returns (uint[]) {}",
|
||
"function h() external returns (bytes memory) {",
|
||
"function h() external returns (uint256 a, uint256 b) {",
|
||
"function h() external view returns (uint, uint, uint, uint, uint, uint) {",
|
||
"function h() external view {",
|
||
"function h() external {",
|
||
"function h() external {}",
|
||
"function h() internal",
|
||
"function h() internal pure returns (S memory) {",
|
||
"function h() internal pure returns (S storage c) {",
|
||
"function h() internal pure returns (bytes memory, string storage s) { s = s; }",
|
||
"function h() internal pure returns (uint, uint) { return (1, 2); }",
|
||
"function h() internal pure returns (uint[]) {}",
|
||
"function h() internal pure {",
|
||
"function h() internal returns (S storage r)",
|
||
"function h() internal view returns (S storage c) {",
|
||
"function h() internal view returns (S storage c) { return s; }",
|
||
"function h() internal view returns (S storage, S storage) {",
|
||
"function h() internal view returns (bytes16) {",
|
||
"function h() internal view returns (mapping(uint=>uint) storage r) {",
|
||
"function h() internal view returns (mapping(uint=>uint)[] storage r) {",
|
||
"function h() internal view {",
|
||
"function h() internal {",
|
||
"function h() nonpayablem(0) public {}",
|
||
"function h() payable external {",
|
||
"function h() private pure returns (uint[]) {}",
|
||
"function h() public onlyOwner {",
|
||
"function h() public payable returns (uint) {",
|
||
"function h() public pure returns (address) {",
|
||
"function h() public pure returns (bytes payable) {}",
|
||
"function h() public pure returns (bytes32 val, bytes3 val2) { return (\"abc\", \"def\"); }",
|
||
"function h() public pure returns (string memory) {",
|
||
"function h() public pure returns (uint a) {",
|
||
"function h() public pure returns (uint a, uint b)",
|
||
"function h() public pure returns (uint) {",
|
||
"function h() public pure returns (uint, uint)",
|
||
"function h() public pure returns (uint256) {",
|
||
"function h() public pure returns (uint64) {",
|
||
"function h() public pure returns(uint[] memory) {}",
|
||
"function h() public pure returns(uint[]) {}",
|
||
"function h() public pure {",
|
||
"function h() public pure {}",
|
||
"function h() public returns (bool, bool, uint256) {",
|
||
"function h() public returns (bool, uint256) {",
|
||
"function h() public returns (bytes memory) {",
|
||
"function h() public returns (bytes4 fs, bytes4 gs) {",
|
||
"function h() public returns (bytes4) {",
|
||
"function h() public returns (function() external returns (uint)) {",
|
||
"function h() public returns (string memory) {",
|
||
"function h() public returns (uint a, uint b, uint c) {",
|
||
"function h() public returns (uint x) {",
|
||
"function h() public returns (uint256 a, uint256 b, uint256 c, uint256 d) {",
|
||
"function h() public returns (uint256 i) {",
|
||
"function h() public returns (uint256) {",
|
||
"function h() public returns (uint8, uint8, uint8, uint8, uint8, uint8) {",
|
||
"function h() public returns(bytes32) {",
|
||
"function h() public returns(uint) {",
|
||
"function h() public view {",
|
||
"function h() public {",
|
||
"function h() public { assert(false); }",
|
||
"function h() public { h(); g(); f(); }",
|
||
"function h() public { r.pay{value: 10}(); }",
|
||
"function h() public { uint8 x = 3; int16 y = 4; x ** y; }",
|
||
"function h() public { x = 2; }",
|
||
"function h() pure external {",
|
||
"function h() pure internal { f; }",
|
||
"function h() pure public returns (uint x, uint a, uint b) {",
|
||
"function h() view external {",
|
||
"function h() view public returns (bytes4) {",
|
||
"function h() view public {",
|
||
"function h() view public { i(); }",
|
||
"function h(S calldata x) external pure returns (uint256 r) {",
|
||
"function h(S calldata) external virtual { dummy = 42; }",
|
||
"function h(S calldata) external;",
|
||
"function h(S memory) public override { dummy = 42; }",
|
||
"function h(Struct storage _s) internal view returns (uint) {",
|
||
"function h(address pure) public pure {}",
|
||
"function h(bool b) public {",
|
||
"function h(bool condition) public returns (uint x) {",
|
||
"function h(bool flag) internal view returns (S storage c) {",
|
||
"function h(bool flag) internal view {",
|
||
"function h(bool val) public returns (bool) {",
|
||
"function h(bytes calldata b) external returns (byte) {",
|
||
"function h(bytes payable) public pure {}",
|
||
"function h(function() external a) public returns (address) {",
|
||
"function h(function() external a) public returns (bytes4) {",
|
||
"function h(int y, int x) public pure returns (int) { return y - x; }",
|
||
"function h(int8 t) public returns (int16) {",
|
||
"function h(string calldata _s) pure external { bytes(_s).length; }",
|
||
"function h(uint x) public pure returns (uint) {",
|
||
"function h(uint x) public returns (uint) {",
|
||
"function h(uint x, uint y) public pure returns (uint) {",
|
||
"function h(uint x, uint y, uint v) public {",
|
||
"function h(uint y) public {",
|
||
"function h(uint256 a) internal pure returns (S storage c) {",
|
||
"function h(uint256 a) internal pure {",
|
||
"function h(uint256 a, uint256 b) public pure returns (uint256 x) {",
|
||
"function h(uint256 v) public returns (uint256) {",
|
||
"function h(uint256 value) public payable returns (bool) {",
|
||
"function h(uint256[2][] calldata s) external returns (bytes memory) {",
|
||
"function h(uint256[] memory m) public returns (uint) { return m.length; }",
|
||
"function h(uint256[] memory) public {}",
|
||
"function h(uint256[][1][] calldata a) external returns (uint256) {",
|
||
"function h(uint8[3] calldata s) external pure returns (bytes memory) {",
|
||
"function h(uint8[] calldata s) external pure returns (bytes memory) {",
|
||
"function h(uint8[][] calldata s) external pure returns (bytes memory) {",
|
||
"function h(uint[4] memory n) public pure returns (uint) {",
|
||
"function h(uint[] calldata _c) internal pure {",
|
||
"function h(uint[] calldata) external override { dummy = 42; }",
|
||
"function h(uint[] calldata) external virtual { dummy = 42; }",
|
||
"function h(uint[] calldata) external;",
|
||
"function h(uint[] memory) public override { dummy = 42; }",
|
||
"function h(uint[] memory) public pure {}",
|
||
"function h(uint[] memory, uint[] storage) public pure returns (S storage x) { return x; }",
|
||
"function h(uint[]) external pure {}",
|
||
"function h(uint[]) public pure {}",
|
||
"function h1() internal returns (function() internal returns (uint) _h) {}",
|
||
"function h2() public {",
|
||
"function h_nonpayable() external { dummy = 1; }",
|
||
"function h_payable() payable external {}",
|
||
"function h_pure() pure external {}",
|
||
"function h_view() view external { dummy; }",
|
||
"function halveMinQuorum() public override returns (bool _success) {",
|
||
"function halveMinQuorum() public virtual returns (bool _success);",
|
||
"function hasNext(Iterator memory self) internal view returns (bool) {",
|
||
"function hash(bytes32) external pure returns (bytes32) {",
|
||
"function hash(bytes32) external pure virtual returns (bytes32);",
|
||
"function hello() external pure;",
|
||
"function hello() public pure returns (bytes4 data){",
|
||
"function hello_world() public pure returns (bytes4 data){",
|
||
"function hello_world_derived_interfaceId() public pure returns (bytes4 data){",
|
||
"function hello_world_interfaceId() public pure returns (bytes4 data){",
|
||
"function hp(uint[]) internal pure {}",
|
||
"function hp(uint[]) private pure {}",
|
||
"function htwo() public returns (function() external returns (uint)) {",
|
||
"function i() external pure returns (S) {}",
|
||
"function i() external pure returns(uint[] memory) {}",
|
||
"function i() external pure returns(uint[]) {}",
|
||
"function i() external returns (bytes memory) {",
|
||
"function i() external view {",
|
||
"function i() external {",
|
||
"function i() internal",
|
||
"function i() internal pure returns (S storage c) {",
|
||
"function i() internal pure returns (S) {}",
|
||
"function i() internal pure {",
|
||
"function i() internal pure {}",
|
||
"function i() internal returns (S storage r)",
|
||
"function i() internal view returns (S storage c) {",
|
||
"function i() internal view returns (S storage c) { c = s; }",
|
||
"function i() internal view {",
|
||
"function i() payable public { i(); h(); g(); f(); }",
|
||
"function i() payable public { x = 2; }",
|
||
"function i() private pure returns (S) {}",
|
||
"function i() private view returns (mapping(uint=>uint) storage r) {",
|
||
"function i() private view returns (mapping(uint=>uint)[] storage r) {",
|
||
"function i() public pure returns (address view) {}",
|
||
"function i() public pure returns (bytes32 payable) {}",
|
||
"function i() public pure returns (bytes4) {",
|
||
"function i() public pure returns (uint d) {",
|
||
"function i() public pure returns (uint, uint) {",
|
||
"function i() public pure returns (uint32) {",
|
||
"function i() public returns (uint a, uint b, uint c, uint d) {",
|
||
"function i() public returns (uint x) {",
|
||
"function i() public returns(int) {",
|
||
"function i() public view {",
|
||
"function i() public {",
|
||
"function i() public { x = 2; }",
|
||
"function i() pure internal { f; }",
|
||
"function i() pure public returns (uint x, uint a) {",
|
||
"function i() purem(x) view public {}",
|
||
"function i() view public {",
|
||
"function i(S calldata) external payable;",
|
||
"function i(S calldata) external virtual payable {}",
|
||
"function i(S memory) public override payable {}",
|
||
"function i(S) external pure {}",
|
||
"function i(bool b) public pure returns (bool) {",
|
||
"function i(bool condition) public returns (uint x) {",
|
||
"function i(bool flag) internal view returns (S memory c) {",
|
||
"function i(bytes32 b) public returns (bytes32) {",
|
||
"function i(bytes32 payable) public pure {}",
|
||
"function i(string memory _s) pure internal { bytes(_s).length; }",
|
||
"function i(uint x, uint y, uint v) public {",
|
||
"function i(uint256 v) public returns (uint256) {",
|
||
"function i(uint256 value) public payable returns (bool) {",
|
||
"function i(uint256[2][2] calldata s) external returns (bytes memory) {",
|
||
"function i(uint8[3] calldata s) external view returns (bytes memory) {",
|
||
"function i(uint8[3][2] calldata s, uint256 which) external view returns (bytes memory) {",
|
||
"function i(uint8[] calldata s) external view returns (bytes memory) {",
|
||
"function i(uint8[][2] calldata s, uint256 which) external view returns (bytes memory) {",
|
||
"function i(uint8[][] calldata s) external view returns (bytes memory) {",
|
||
"function i(uint[4] memory n) public view returns (uint) {",
|
||
"function i(uint[] calldata _c) internal pure {",
|
||
"function i(uint[] calldata) external override payable {}",
|
||
"function i(uint[] calldata) external payable;",
|
||
"function i(uint[] calldata) external pure {}",
|
||
"function i(uint[] calldata) external virtual payable {}",
|
||
"function i(uint[] calldata, uint[] storage) external pure returns (S storage x) {return x; }",
|
||
"function i(uint[] memory) public override payable {}",
|
||
"function i(uint[][2] calldata s) external { tmp_i = s; }",
|
||
"function i(uint[][] calldata s) external { tmp_i = s; }",
|
||
"function iHaveAuthor() public pure {}",
|
||
"function identity(uint x) external pure returns (uint) {",
|
||
"function identity(uint x) internal pure returns (uint) {",
|
||
"function idle() {}",
|
||
"function idle();",
|
||
"function inc() public {",
|
||
"function inc1() public {",
|
||
"function inc2() public {",
|
||
"function inc_post() public pure returns (uint8) {",
|
||
"function inc_pre() public pure returns (uint8) {",
|
||
"function increase(address owner, uint256 value) external returns(bool success) {",
|
||
"function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {",
|
||
"function index(uint256 len) public returns (bool)",
|
||
"function init()",
|
||
"function init() public { array.length = 3; }",
|
||
"function init() public;",
|
||
"function init(uint a) public override {",
|
||
"function init(uint a) public virtual {",
|
||
"function init(uint a) public {",
|
||
"function init(uint a, uint b) public override {",
|
||
"function init(uint a, uint b) public virtual {",
|
||
"function init(uint a, uint b) public {",
|
||
"function init(uint phaseLength) internal pure {",
|
||
"function initX() internal {",
|
||
"function insert(Data storage self, uint value)",
|
||
"function insertAndCheckDo(bytes32 doHash) internal returns (bool success) {",
|
||
"function insertOwner(address addr) external {",
|
||
"function intMaxA() public pure returns (bool) {",
|
||
"function intMaxB() public pure returns(bool) {",
|
||
"function intMaxC() public pure returns (bool) {",
|
||
"function intMaxD() public pure returns(bool) {",
|
||
"function intMinA() public pure returns (bool) {",
|
||
"function intMinB() public pure returns(bool) {",
|
||
"function intMinC() public pure returns (bool) {",
|
||
"function intMinD() public pure returns(bool) {",
|
||
"function intName() public {",
|
||
"function integer(uint t, bool b) public pure returns (uint) {",
|
||
"function inter() internal pure returns (uint) {",
|
||
"function intern() public returns (uint256) {",
|
||
"function internal1() internal pure returns (bool) {",
|
||
"function internal2() internal pure returns (bool) {",
|
||
"function internalCall() public {",
|
||
"function internalMutableFunc(uint256 x) internal returns (uint256) { return x; }",
|
||
"function internalMutableFunc(uint256 x) internal returns (uint256) { y = x; return x; }",
|
||
"function internalPureFunc(uint256 x) internal pure returns (uint256) { return x; }",
|
||
"function internalStateDecimal() public returns (uint256) {",
|
||
"function internalViewFunc(uint256 x) internal view returns (uint256) { return x + y; }",
|
||
"function internalViewFunc(uint256 x) internal view returns (uint256) { return x; }",
|
||
"function internal_func() internal pure returns (int8)",
|
||
"function inv() public view {",
|
||
"function invalidLiteral() public pure returns (bytes32) {",
|
||
"function invalidateAnnouncement(uint256 id) onlyOwner external {",
|
||
"function ip(S) internal pure {}",
|
||
"function ip(S) private pure {}",
|
||
"function is2D() external override returns (bool) {",
|
||
"function is2D() external returns (bool);",
|
||
"function isActive() public view returns (bool success) {}",
|
||
"function isActive() public view returns (bool success, bool active) {",
|
||
"function isBlocked(address _account) internal override returns (bool) {",
|
||
"function isBlocked(address _account) internal virtual returns (bool);",
|
||
"function isChallengePeriodOver()",
|
||
"function isChallenged()",
|
||
"function isConfirmed(uint transactionId)",
|
||
"function isContract(address addr) internal returns (bool success) {",
|
||
"function isData(RLPItem memory self) internal view returns (bool ret) {",
|
||
"function isEmpty(RLPItem memory self) internal view returns (bool ret) {",
|
||
"function isFrontRunnerPeriodOver()",
|
||
"function isICO() public view returns (bool success) {",
|
||
"function isICO() public view returns (bool success, bool ico) {",
|
||
"function isList(RLPItem memory self) internal view returns (bool ret) {",
|
||
"function isModuleHandler(address payable addr) internal returns (bool ret) {",
|
||
"function isNull(RLPItem memory self) internal view returns (bool ret) {",
|
||
"function isOutcomeSet()",
|
||
"function isOutcomeSet() virtual public view returns (bool);",
|
||
"function isOwner() internal returns(bool) {",
|
||
"function isRecipientAllowed(address _recipient) internal returns (bool _isAllowed) {",
|
||
"function isUnderLimit(uint amount)",
|
||
"function isWinner(_rounds memory round, bool aboveVote) internal returns (bool) {",
|
||
"function is_not_solved() view public {",
|
||
"function issue(address _for, uint outcomeTokenCount)",
|
||
"function issueTokens(address _to, uint256 _value)",
|
||
"function items(RLPItem memory self) internal view returns (uint) {",
|
||
"function iterator(RLPItem memory self) internal view returns (Iterator memory it) {",
|
||
"function j() external pure returns (mapping(uint => uint)) {}",
|
||
"function j() external returns (bytes memory) {",
|
||
"function j() internal pure returns (mapping(uint => uint)) {}",
|
||
"function j() internal view returns (S storage c) {",
|
||
"function j() internal view returns (S storage c) { (c) = s; }",
|
||
"function j() internal view {",
|
||
"function j() private pure returns (mapping(uint => uint)) {}",
|
||
"function j() public pure returns (address pure) {}",
|
||
"function j() public pure returns (fixed payable) {}",
|
||
"function j() public pure returns (uint a, uint b) {",
|
||
"function j() public pure returns (uint16) {",
|
||
"function j() public returns(int) {",
|
||
"function j() public {",
|
||
"function j() view internal { bytes(s).length; }",
|
||
"function j() view public {",
|
||
"function j() viewm(x) view public {}",
|
||
"function j(bool b) public returns (bool) {",
|
||
"function j(bool flag) internal view returns (S memory) {",
|
||
"function j(bytes calldata s) external pure returns (bytes memory) {",
|
||
"function j(bytes32 b) public pure returns (bytes32, bytes32) {",
|
||
"function j(bytes[] calldata s) external pure returns (bytes memory) {",
|
||
"function j(fixed payable) public pure {}",
|
||
"function j(mapping(uint => uint)) external pure {}",
|
||
"function j(uint a, uint b) public returns (uint x, uint y) {",
|
||
"function j(uint x, uint y, uint z, uint v) public {",
|
||
"function j(uint256 v) public returns (uint256) {",
|
||
"function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {",
|
||
"function joinProvider(address provider) isReady external {",
|
||
"function jp(mapping(uint => uint)) internal pure {}",
|
||
"function jp(mapping(uint => uint)) private pure {}",
|
||
"function jp(mapping(uint => uint)) private pure {}}",
|
||
"function k() internal view returns (S storage c) {",
|
||
"function k() internal view {",
|
||
"function k() nonpayablem(x) public {}",
|
||
"function k() public pure returns (fixed80x80 payable) {}",
|
||
"function k() public pure returns (uint) {",
|
||
"function k() public pure returns (uint8) {",
|
||
"function k() public returns(int) {",
|
||
"function k() public {",
|
||
"function k() pure public returns (bytes memory) {",
|
||
"function k() pure public returns (uint) {",
|
||
"function k() {}",
|
||
"function k(bytes calldata _b) pure external { string(_b); }",
|
||
"function k(bytes calldata s) external view returns (bytes memory) {",
|
||
"function k(bytes32 b) public returns (bytes32) {",
|
||
"function k(bytes[2] calldata s, uint256 which) external view returns (bytes memory) {",
|
||
"function k(bytes[] calldata s) external view returns (bytes memory) {",
|
||
"function k(fixed80x80 payable) public pure {}",
|
||
"function k(uint a, uint b) public returns (uint x, uint y) {",
|
||
"function k(uint x) public pure returns (uint) {",
|
||
"function k(uint256 v) public returns (uint256) {",
|
||
"function k1() internal returns (function() external returns (uint) _k) {}",
|
||
"function k2() public {",
|
||
"function keccak(slice memory self) internal pure returns (bytes32 ret) {",
|
||
"function keccak1() public pure returns (bytes32) {",
|
||
"function keccak2() public pure returns (bytes32) {",
|
||
"function keccak256() pure public {}",
|
||
"function killer(bytes[2] calldata weapon) pure external {",
|
||
"function killer(uint256[][2] calldata weapon) pure external {",
|
||
"function killer(uint256[][] calldata weapon) pure external {",
|
||
"function l() public pure returns (ufixed payable) {}",
|
||
"function l() public returns (uint) {",
|
||
"function l() public returns (uint256) {",
|
||
"function l() public view returns (uint) {",
|
||
"function l() public {",
|
||
"function l() pure public returns (bytes memory) {",
|
||
"function l() purem(x = 2) public {}",
|
||
"function l(bytes memory _b) pure internal { string(_b); }",
|
||
"function l(ufixed payable) public pure {}",
|
||
"function l(uint a) public pure returns (uint d) {",
|
||
"function leftByteShift(bytes6 _value, uint _shift) public returns (bytes6) {",
|
||
"function leftS(int8 x, uint8 y) public returns (int8) {",
|
||
"function leftU(uint8 x, uint8 y) public returns (uint8) {",
|
||
"function len() public returns (uint ret) {",
|
||
"function len(bytes32 self) internal pure returns (uint) {",
|
||
"function len(slice memory self) internal pure returns (uint l) {",
|
||
"function length() public returns (uint256) {",
|
||
"function leq() public pure returns (bool) {",
|
||
"function libFun(S storage s) internal mod(s) {",
|
||
"function linkersymbol(a) {}",
|
||
"function literalToFixed() public pure {",
|
||
"function literalToUFixed() public pure {",
|
||
"function ll(uint index) public returns (uint) {",
|
||
"function ln(uint x)",
|
||
"function load()",
|
||
"function load(address payable foundation, bool forReplace, address payable Token, address payable Premium, address payable Publisher, address payable Schelling, address payable Provider) public {",
|
||
"function localConst() returns (uint ret)",
|
||
"function long() public pure returns (bool, bool) {",
|
||
"function long_bytes_dyn() public pure returns (bytes memory x) {",
|
||
"function long_dyn() public pure returns (string memory x) {",
|
||
"function lt() public pure returns (bool) {",
|
||
"function lt(uint a, uint b) public pure returns (bool) {",
|
||
"function lte(uint a, uint b) public pure returns (bool) {",
|
||
"function lv(uint value) public {",
|
||
"function lv(uint y) public {",
|
||
"function m(",
|
||
"function m() public pure returns (ufixed80x80 payable) {}",
|
||
"function m() public {",
|
||
"function m() view internal { string(b); }",
|
||
"function m() viewm(x = 2) public {}",
|
||
"function m(ufixed80x80 payable) public pure {}",
|
||
"function map(uint key) public view returns (uint) {",
|
||
"function mapValue(uint a) public returns (uint) {",
|
||
"function markMilestoneComplete(uint _idMilestone)",
|
||
"function max(int[] memory nums)",
|
||
"function memcpy(uint dest, uint src, uint len) private pure {",
|
||
"function min(uint, uint) public returns (uint);",
|
||
"function minQuorum(uint _value) internal view returns (uint _minQuorum) {",
|
||
"function mint(address owner, uint256 value) external returns (bool success) {",
|
||
"function mint(address owner, uint256 value) isReady external returns (bool success) {",
|
||
"function mint(address to, uint256 value) external returns (bool success) {",
|
||
"function mod() public pure returns (uint8, uint8) {",
|
||
"function mod(uint256 a, uint256 b) public returns (uint256) {",
|
||
"function mul() public pure returns (uint8, uint8) {",
|
||
"function mul(G1Point memory p, uint s) internal returns (G1Point memory r) {",
|
||
"function mul(int a, int b)",
|
||
"function mul(s storage self, uint x) public returns (uint) { return self.a *= x; }",
|
||
"function mul(s storage, bytes32) public returns (bytes32) { }",
|
||
"function mul(uint a, uint b)",
|
||
"function mul(uint256 a, uint256 b) internal pure returns (uint256) {",
|
||
"function myAwesomeFunction(param) -> returnMe {",
|
||
"function my_func() internal returns(bool){",
|
||
"function n() nonpayablem(x = 2) public {}",
|
||
"function n1(uint key, uint value) public {",
|
||
"function n2() public {",
|
||
"function neg() public pure returns (int8) {",
|
||
"function negate(G1Point memory p) internal returns (G1Point memory) {",
|
||
"function negate(int256 a) public pure returns (int256)",
|
||
"function negate_s16(int16 a) public pure returns (int16)",
|
||
"function negate_s8(int8 a) public pure returns (int8)",
|
||
"function neq() public pure returns (bool) {",
|
||
"function neq(uint a, uint b) public pure returns (bool) {",
|
||
"function newAnnouncement(announcementType Type, string calldata Announcement, string calldata Link, bool Oppositable, string calldata _str, uint256 _uint, address payable _addr) onlyOwner external {",
|
||
"function newContract(address payable _newContract) public override {",
|
||
"function newContract(address payable _newContract) virtual public;",
|
||
"function newModule(string calldata name, address payable addr, bool schellingEvent, bool transferEvent) external returns (bool success) {",
|
||
"function newProposal(",
|
||
"function newSchellingRoundEvent(uint256 roundID, uint256 reward) external override returns (bool success) {",
|
||
"function newSchellingRoundEvent(uint256 roundID, uint256 reward) external returns (bool success) {}",
|
||
"function newSchellingRoundEvent(uint256 roundID, uint256 reward) virtual external onlyForModuleHandler returns (bool success) {",
|
||
"function next(Iterator memory self) internal view returns (RLPItem memory subItem) {",
|
||
"function next(Iterator memory self, bool strict) internal view returns (RLPItem memory subItem) {",
|
||
"function nextRound() internal returns (bool) {",
|
||
"function nextRune(slice memory self) internal pure returns (slice memory ret) {",
|
||
"function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {",
|
||
"function not(bool a) public pure returns (bool)",
|
||
"function nredit(uint256 startindex)",
|
||
"function numberOfMilestones() public view returns (uint) {",
|
||
"function numberOfProposals() public view override returns (uint _numberOfProposals) {",
|
||
"function numberOfProposals() public virtual view returns (uint _numberOfProposals);",
|
||
"function o(byte) public pure {}",
|
||
"function o(uint a) external returns(uint) { return a+1; }",
|
||
"function ok() public returns (bool) { return true; }",
|
||
"function one() public pure returns (uint) {}",
|
||
"function one() public returns (uint256) {",
|
||
"function oneByteUTF8() public pure returns (bytes32) {",
|
||
"function oneByteUTF8() public pure returns (string memory) {",
|
||
"function oppositeAnnouncement(uint256 id) external {",
|
||
"function or(uint x) public returns (bool t, uint y) {",
|
||
"function ord(slice memory self) internal pure returns (uint ret) {",
|
||
"function other() external pure;",
|
||
"function other() public pure returns (bytes4 data){",
|
||
"function outOfGas() public returns (bool ret) {",
|
||
"function outOfGas() public returns(bool ret) {",
|
||
"function overridden() public override returns (uint256 r) {",
|
||
"function overridden() public virtual returns (uint256 r) {",
|
||
"function ownersForChange() public view returns (uint256 owners) {",
|
||
"function p() public {",
|
||
"function pair() public returns (bool) {",
|
||
"function pairing(G1Point[] memory p1, G2Point[] memory p2) internal returns (bool) {",
|
||
"function pairingProd2(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2) internal returns (bool) {",
|
||
"function pairingProd3(",
|
||
"function pairingProd4(",
|
||
"function parentFun() external returns (uint256);",
|
||
"function parentFun() override external returns (uint256) { return 1; }",
|
||
"function partProvider() isReady external {",
|
||
"function payOut(address payable _recipient, uint _amount) public override returns (bool) {",
|
||
"function payOut(address payable _recipient, uint _amount) public virtual returns (bool);",
|
||
"function pipeThrough(bytes2 small, bool one) public returns(bytes16 large, bool oneRet) {",
|
||
"function pop(uint[2] memory a) internal {}",
|
||
"function popEmpty() public {",
|
||
"function postdecr(uint a) public pure returns (uint) {",
|
||
"function postdecr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {",
|
||
"function postdecr_u8(uint8 a) public pure returns (uint8) {",
|
||
"function postincr(uint a) public pure returns (uint) {",
|
||
"function postincr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {",
|
||
"function postincr_u8(uint8 a) public pure returns (uint8) {",
|
||
"function predecr(uint a) public pure returns (uint) {",
|
||
"function predecr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {",
|
||
"function predecr_u8(uint8 a) public pure returns (uint8) {",
|
||
"function preincr(uint a) public pure returns (uint) {",
|
||
"function preincr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {",
|
||
"function preincr_u8(uint8 a) public pure returns (uint8) {",
|
||
"function prepareVote(bytes32 votehash, uint256 roundID) isReady noContract external {",
|
||
"function press_A() public {",
|
||
"function press_B() public {",
|
||
"function press_C() public {",
|
||
"function press_D() public {",
|
||
"function press_E() public {",
|
||
"function press_F() public {",
|
||
"function processTransactionFee(address from, uint256 value) external returns (bool success) {",
|
||
"function processTransactionFee(address owner, uint256 value) isReady external returns (bool success) {",
|
||
"function proposeMilestones(bytes memory _newMilestones",
|
||
"function pub() public pure returns (uint) {",
|
||
"function push(uint[2] memory a) internal {}",
|
||
"function pushEmpty(uint256 len) public {",
|
||
"function pushRound(_rounds memory round) internal returns (uint256) {",
|
||
"function pushRound(uint256 _totalAboveWeight, uint256 _totalBelowWeight, uint256 _reward, uint256 _blockHeight, bool _voted) isOwner external returns(bool, uint256) {",
|
||
"function r() internal view returns (function(uint)) {",
|
||
"function r() public returns (bool[3] memory) {",
|
||
"function r() public {",
|
||
"function readX() external view returns(uint) { return x; }",
|
||
"function readX() internal override returns(uint) {",
|
||
"function readX() internal view override returns(uint) {",
|
||
"function readX() internal view returns(uint) {",
|
||
"function readX() internal view returns(uint) { return x; }",
|
||
"function readX() internal view virtual returns(uint) {",
|
||
"function readX() internal virtual returns(uint) {",
|
||
"function readX() public view returns(function() external view returns(uint) _f) {",
|
||
"function receive() external pure {}",
|
||
"function receiveApproval(address _from, uint256 _value, address _token, bytes memory _extraData) public virtual;",
|
||
"function receiveCorionPremiumToken(address, uint256, bytes calldata) external returns (bool, uint256) {}",
|
||
"function receiveCorionToken(address, uint256, bytes calldata) external returns (bool, uint256) {}",
|
||
"function receiveEther() public override returns (bool) {",
|
||
"function receiveEther() public virtual returns (bool);",
|
||
"function receiveFunds() external {",
|
||
"function receiver(uint[] memory array, uint idx) public returns (uint256)",
|
||
"function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s, uint blockExpired, bytes32 salt)",
|
||
"function redeemWinnings()",
|
||
"function redeemWinnings() virtual public returns (uint);",
|
||
"function reduce(",
|
||
"function reenc_f(uint8[1][][1] calldata s) external view returns (bytes memory) {",
|
||
"function reenc_f(uint8[][1][] calldata s) external view returns (bytes memory) {",
|
||
"function reenc_f2(uint256[2][][2] calldata s) external view returns (bytes memory) {",
|
||
"function reenc_f2(uint256[][2][] calldata s) external view returns (bytes memory) {",
|
||
"function refund()",
|
||
"function refund() public override {",
|
||
"function refund() virtual public;",
|
||
"function register(address instantiation)",
|
||
"function registerModuleHandler(address payable _moduleHandlerAddress) internal {",
|
||
"function rejectMilestone(uint _idMilestone)",
|
||
"function removeOwner(address owner)",
|
||
"function renounceOwnership() public onlyOwner { }",
|
||
"function replaceModule(address addr) external returns (bool success) {}",
|
||
"function replaceModule(address payable addr) external override returns (bool success) {",
|
||
"function replaceModule(address payable addr) external override returns (bool) {",
|
||
"function replaceModule(address payable newModuleAddress) virtual external onlyForModuleHandler returns (bool success) {",
|
||
"function replaceModule(string calldata name, address payable addr, bool callCallback) external returns (bool success) {",
|
||
"function replaceModuleHandler(address newHandler) external returns (bool success) {",
|
||
"function replaceModuleHandler(address newHandler) external returns (bool success) {}",
|
||
"function replaceModuleHandler(address payable newModuleHandlerAddress) external onlyForModuleHandler returns (bool success) {",
|
||
"function replaceOwner(address newOwner)",
|
||
"function replaceOwner(address newOwner) external returns(bool) {",
|
||
"function replaceOwner(address owner, address newOwner)",
|
||
"function replaceSigner(address newSigner, uint _nonce, uint8 v, bytes32 r, bytes32 s)",
|
||
"function requestMilestonePayment(uint _idMilestone",
|
||
"function reset() internal {",
|
||
"function ret() public returns (ActionChoices) {",
|
||
"function retrieve(uint256 k)",
|
||
"function retrieveDAOReward(bool _toMembers) external override returns (bool _success) {",
|
||
"function retrieveDAOReward(bool _toMembers) virtual external returns (bool _success);",
|
||
"function return500InvoicesByDates(",
|
||
"function return500PaymentsByDates(",
|
||
"function returnsArray() public returns (uint256[] memory) {",
|
||
"function revoke(address _for, uint outcomeTokenCount)",
|
||
"function revokeConfirmation(uint transactionId)",
|
||
"function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {",
|
||
"function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {",
|
||
"function rightForInterest(uint256 value, bool priv) internal view returns (bool) {",
|
||
"function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {",
|
||
"function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {",
|
||
"function run()",
|
||
"function run() public returns (uint256, uint256, uint256) {",
|
||
"function run() public returns (uint256[] memory) {",
|
||
"function run() public returns(int8 y) {",
|
||
"function run() public view returns (bool);",
|
||
"function run() public {",
|
||
"function run(bool a, uint32 b, uint64 c) public returns(uint256 y) {",
|
||
"function run(bool x1, uint x2) public returns(uint y1, bool y2, uint y3) {",
|
||
"function runtime() public pure returns (bytes memory) {",
|
||
"function runtime(uint256 _arg) public returns (uint256) {",
|
||
"function runtimeBase() public pure returns (bytes memory) {",
|
||
"function runtimeOther() public pure returns (bytes memory) {",
|
||
"function s() internal returns (int[] storage) {",
|
||
"function s() public returns (S memory) {",
|
||
"function s() public returns (bool) {",
|
||
"function s() public returns (uint256[] memory) {",
|
||
"function s() public returns (uint[2] memory, uint) {",
|
||
"function s() public returns(S memory)",
|
||
"function s() public s {",
|
||
"function s(uint a, uint b) internal returns (uint) {",
|
||
"function safeAdd(uint256 a, uint256 b) internal returns(uint256) {",
|
||
"function safeSub(uint256 a, uint256 b) internal returns(uint256) {",
|
||
"function safeToAdd(int a, int b)",
|
||
"function safeToAdd(uint a, uint b)",
|
||
"function safeToMul(int a, int b)",
|
||
"function safeToMul(uint a, uint b)",
|
||
"function safeToSub(int a, int b)",
|
||
"function safeToSub(uint a, uint b)",
|
||
"function same_salt() public returns (bool) {",
|
||
"function sar(uint256 a, uint256 b) public returns (uint256 c) {",
|
||
"function sar_combined(uint256 a) public returns (uint256 c) {",
|
||
"function sar_combined_large(uint256 a) public returns (uint256 c) {",
|
||
"function sar_large(uint256 a) public returns (uint256 c) {",
|
||
"function sar_zero(uint256 a) public returns (uint256 c) {",
|
||
"function save() public returns (uint256 r) {",
|
||
"function secondChar() public returns (uint8) {",
|
||
"function secondItem() public returns (uint) {",
|
||
"function selector() external view returns(uint) { return x; }",
|
||
"function selector() public returns(uint) { ",
|
||
"function selector(function(uint) internal pure returns (uint) f, uint x) internal pure returns (uint) {",
|
||
"function sell(uint8 outcomeTokenIndex, uint outcomeTokenCount, uint minProfit)",
|
||
"function sell(uint8 outcomeTokenIndex, uint outcomeTokenCount, uint minProfit) virtual public returns (uint);",
|
||
"function sellAllOutcomes(uint outcomeTokenCount)",
|
||
"function send(address a) internal {}",
|
||
"function sendAmount(uint amount) public payable returns(uint256 bal) {",
|
||
"function sendAmount(uint256 amount) public payable returns (uint256 bal) {",
|
||
"function sendAmount(uint256 amount) public returns (uint256 bal) {",
|
||
"function sendCoin(address receiver, uint amount) public returns(bool sufficient) {",
|
||
"function sendVote(string calldata vote) isReady noContract external {",
|
||
"function set() public override(A, B) { super.set(); }",
|
||
"function set() public returns (bool) {",
|
||
"function set() public returns (uint256) {",
|
||
"function set() public virtual override { a = 1; super.set(); a = 2; }",
|
||
"function set() public virtual override { b = 1; super.set(); b = 2; }",
|
||
"function set() public virtual {}",
|
||
"function set() public {",
|
||
"function set() public { test = 2; }",
|
||
"function set() public { test.v = 2; test.s = \"statevar\"; }",
|
||
"function set() public { test[42].v = 2; test[42].s = \"statevar\"; }",
|
||
"function set(A k, uint8 v) public {",
|
||
"function set(E k, uint8 v) public {",
|
||
"function set(S storage a, uint v) { a.x = v; }",
|
||
"function set(address source_taint) public{",
|
||
"function set(bytes memory _data, uint256 i)",
|
||
"function set(mapping(A => uint8) storage table, A k, uint8 v) external {",
|
||
"function set(mapping(E => uint8) storage table, E k, uint8 v) external {",
|
||
"function set(string memory s) public returns (uint) {",
|
||
"function set(string memory s) public returns (uint[3] memory x, uint[2] memory y, uint[] memory z, uint t) {",
|
||
"function set(string memory s) public {",
|
||
"function set(string memory s, uint n, uint a) public returns (uint) {",
|
||
"function set(string memory s, uint n, uint m) public returns (uint) {",
|
||
"function set(string memory s, uint n, uint m, uint a, uint b) public returns (uint) {",
|
||
"function set(uint _x) mutex public {",
|
||
"function set(uint source_taint) public{",
|
||
"function set(uint x) public {",
|
||
"function set(uint24[3][4] memory x) public {",
|
||
"function set(uint24[3][] memory _data) public returns (uint256) {",
|
||
"function set(uint24[3][] memory _data, uint256 a, uint256 b)",
|
||
"function set(uint24[3][][4] memory x)",
|
||
"function set(uint256 _value) external {",
|
||
"function set(uint256 index, uint256 value) public returns (bool) {",
|
||
"function set(uint256 k) public returns (bool) {",
|
||
"function set(uint256 k, uint256 v) public {",
|
||
"function set(uint256 k1, uint256 k2, uint256 v) public {",
|
||
"function set(uint256 v) public returns (uint256) { x = v; return v; }",
|
||
"function set(uint8 k, uint8 v) public {",
|
||
"function set(uint8 key, uint8 value_a, uint8 value_b) public returns (uint8 old_a, uint8 old_b) {",
|
||
"function set(uint8 key, uint8 value_a1, uint8 value_a2, uint8 value_b1, uint8 value_b2) public returns (uint8 old_a1, uint8 old_a2, uint8 old_b1, uint8 old_b2) {",
|
||
"function set(uint8 which, uint256 value) public {",
|
||
"function set2() public{",
|
||
"function set3(uint source_taint) public{",
|
||
"function set5th() public returns (bool) {",
|
||
"function setA(uint x, uint y) public {",
|
||
"function setAllowance(address owner, address spender, uint256 amount, uint256 nonce) external returns(bool success) {",
|
||
"function setB(uint x, uint y, uint z) public {",
|
||
"function setCompleted(uint completed) public restricted {",
|
||
"function setCurrentSchellingRound(uint256 _id) isOwner external returns(bool) {",
|
||
"function setCurrentSchellingRound(uint256 id) internal {",
|
||
"function setData(uint256 base, uint256 derived) public returns (bool r) {",
|
||
"function setData(uint256 i) public {",
|
||
"function setData(uint256 index, uint256 x, uint256 y) public {",
|
||
"function setFlag() public {",
|
||
"function setForwardedOutcome()",
|
||
"function setFunds(address _owner, uint256 _amount) isOwner external returns(bool) {",
|
||
"function setFunds(address addr, uint256 amount) internal {",
|
||
"function setICOEthPrice(uint256 value) external {",
|
||
"function setID(uint256 index, uint256 id) public {",
|
||
"function setIDStatic(uint256 id) public {",
|
||
"function setInterestDB(address addr, uint256 balance) external returns(bool success) {",
|
||
"function setLengths(uint256 l1, uint256 l2) public {",
|
||
"function setName(bytes3 _name) private {",
|
||
"function setName(bytes6 _name) private {",
|
||
"function setOutcome()",
|
||
"function setOutcome(int _outcome)",
|
||
"function setOutcome(int _outcome, uint8 v, bytes32 r, bytes32 s)",
|
||
"function setOwner() public {",
|
||
"function setOwner(address _owner) public {",
|
||
"function setProviderDetails(address payable addr, string calldata website, string calldata country, string calldata info, uint8 rate, address payable admin) isReady external {",
|
||
"function setRightForInterest(uint256 oldValue, uint256 newValue, bool priv) internal {",
|
||
"function setRound(uint256 _id, uint256 _totalAboveWeight, uint256 _totalBelowWeight, uint256 _reward, uint256 _blockHeight, bool _voted) isOwner external returns(bool) {",
|
||
"function setRound(uint256 id, _rounds memory round) internal {",
|
||
"function setSchellingExpansion(uint256 _id, uint256 _expansion) isOwner external returns(bool) {",
|
||
"function setSchellingExpansion(uint256 id, uint256 amount) internal {",
|
||
"function setUsed() public {",
|
||
"function setUsed(uint a) public {",
|
||
"function setViaA(uint256 i) public {",
|
||
"function setVoter(address _owner, uint256 _roundID, bytes32 _hash, voterStatus _status, bool _voteResult, uint256 _rewards) isOwner external returns(bool) {",
|
||
"function setVoter(address owner, _voter memory voter) internal {",
|
||
"function setX(uint a) public returns (uint _x) {",
|
||
"function setY(uint a) public returns (uint _y) {",
|
||
"function set_get_length(uint256 len) public returns (uint256)",
|
||
"function set_get_length(uint256 len) public returns (uint256) {",
|
||
"function set_internal(mapping(uint8 => uint8) storage m, uint8 key, uint8 value) internal returns (uint8) {",
|
||
"function set_internal(mapping(uint8 => uint8)[2] storage m, uint8 key, uint8 value1, uint8 value2) internal returns (uint8, uint8) {",
|
||
"function set_test1() external{",
|
||
"function set_test2() external{",
|
||
"function sgt(int a, int b) public pure returns (bool) {",
|
||
"function sgte(int a, int b) public pure returns (bool) {",
|
||
"function sha3() public pure returns (bool) {",
|
||
"function shl(uint256 a, uint256 b) public returns (uint256 c) {",
|
||
"function shl_1() public returns (bool) {",
|
||
"function shl_2() public returns (bool) {",
|
||
"function shl_3() public returns (bool) {",
|
||
"function shl_combined(uint256 a) public returns (uint256 c) {",
|
||
"function shl_combined_large(uint256 a) public returns (uint256 c) {",
|
||
"function shl_combined_overflow(uint256 a) public returns (uint256 c) {",
|
||
"function shl_large(uint256 a) public returns (uint256 c) {",
|
||
"function shl_zero(uint256 a) public returns (uint256 c) {",
|
||
"function short() public pure returns (bool) {",
|
||
"function shortSell(uint8 outcomeTokenIndex, uint outcomeTokenCount, uint minProfit)",
|
||
"function shortSell(uint8 outcomeTokenIndex, uint outcomeTokenCount, uint minProfit) virtual public returns (uint);",
|
||
"function short_bytes_dyn() public pure returns (bytes memory x) {",
|
||
"function short_dyn() public pure returns (string memory x) {",
|
||
"function shr(uint256 a, uint256 b) public returns (uint256 c) {",
|
||
"function shr_1() public returns (bool) {",
|
||
"function shr_2() public returns (bool) {",
|
||
"function shr_3() public returns (bool) {",
|
||
"function shr_combined(uint256 a) public returns (uint256 c) {",
|
||
"function shr_combined_large(uint256 a) public returns (uint256 c) {",
|
||
"function shr_combined_overflow(uint256 a) public returns (uint256 c) {",
|
||
"function shr_large(uint256 a) public returns (uint256 c) {",
|
||
"function shr_zero(uint256 a) public returns (uint256 c) {",
|
||
"function sideeffect(r) -> x {",
|
||
"function skinColor() external override returns (string memory) {",
|
||
"function skinColor() external returns (string memory);",
|
||
"function slt(int a, int b) public pure returns (bool) {",
|
||
"function slte(int a, int b) public pure returns (bool) {",
|
||
"function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {",
|
||
"function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {",
|
||
"function splitDAO(",
|
||
"function stage0() internal {",
|
||
"function stage1() internal {",
|
||
"function stage2() internal {",
|
||
"function start() {}",
|
||
"function start();",
|
||
"function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {",
|
||
"function state() public view returns (bool) {}",
|
||
"function state() public view returns (bool);",
|
||
"function stop() public;",
|
||
"function stop() {}",
|
||
"function store()",
|
||
"function store(function(uint) external returns (uint) y) public {",
|
||
"function string_string_to_string(string memory x, string memory y) internal pure returns (string memory) { return bytes(x).length == 0 ? y : x; }",
|
||
"function string_to_string(string memory x) internal pure returns (string memory) { return x; }",
|
||
"function string_to_uint256(string memory x) internal pure returns (uint256) { return bytes(x).length; }",
|
||
"function string_uint256_to_string(string memory x, uint256 y) internal pure returns (string memory) { return y == 0 ? \"a\" : x; }",
|
||
"function stru(S storage t, bool b) public view returns (uint) {",
|
||
"function sub() public pure returns (uint8, uint8) {",
|
||
"function sub(int a, int b)",
|
||
"function sub(uint a, uint b)",
|
||
"function sub(uint256 a, uint256 b) internal pure returns (uint256) {",
|
||
"function subAFun() external returns (uint256);",
|
||
"function subAFun() override external returns (uint256) { return 2; }",
|
||
"function subBFun() external returns (uint256);",
|
||
"function subBFun() override external returns (uint256) { return 3; }",
|
||
"function submitTransaction(address destination, uint value, bytes memory data)",
|
||
"function succeed() public pure returns (bool x) {",
|
||
"function suicide() public pure returns (bool) {",
|
||
"function sum(bytes2 a, bytes2 b) public returns (bytes2) {",
|
||
"function sum(uint256 a, uint256 b) internal returns (uint256) {",
|
||
"function sumArray() public view returns(uint) {",
|
||
"function sumExpOffset(int logN, int[] memory netOutcomeTokensSold, uint funding, uint8 outcomeIndex)",
|
||
"function supportsInterface(bytes4 interfaceID) external view override returns (bool) {",
|
||
"function supportsInterface(bytes4 interfaceID) external view returns (bool);",
|
||
"function swap() public {",
|
||
"function t() external view returns (",
|
||
"function t() public pure returns (uint) { return 7; }",
|
||
"function t() public returns (T memory) {",
|
||
"function t() public returns (uint256) {",
|
||
"function t() public {",
|
||
"function t() {",
|
||
"function t(uint) public pure {",
|
||
"function t(uint) public pure {}",
|
||
"function t1() public returns (uint256) {",
|
||
"function t1(C1 a) public returns (C1) {",
|
||
"function t2() public returns (C1) {",
|
||
"function t2() public returns (uint256) {",
|
||
"function t3() public returns (uint256) {",
|
||
"function t4() public returns (uint256) {",
|
||
"function test()",
|
||
"function test() external override pure returns (uint256) { return 42; }",
|
||
"function test() external override returns (uint256) {}",
|
||
"function test() external override(A, B) returns (uint256) {}",
|
||
"function test() external pure override returns (uint256);",
|
||
"function test() external pure override(SubA, SubB) returns (uint256) { return 42; }",
|
||
"function test() external pure returns (uint256);",
|
||
"function test() external returns (uint) {",
|
||
"function test() external returns (uint256) {}",
|
||
"function test() external returns (uint256);",
|
||
"function test() external virtual returns (uint256 v, string memory s)",
|
||
"function test() external virtual returns (uint256)",
|
||
"function test() external virtual returns (uint256);",
|
||
"function test() internal override override returns (uint256);",
|
||
"function test() internal override returns (uint256) {}",
|
||
"function test() internal override virtual returns (uint256);",
|
||
"function test() internal override() returns (uint256);",
|
||
"function test() internal override(,) returns (uint256);",
|
||
"function test() internal override(B, D, C) virtual returns (uint256);",
|
||
"function test() internal override(B, D, D) virtual returns (uint256);",
|
||
"function test() internal pure {",
|
||
"function test() internal returns (uint256);",
|
||
"function test() internal virtual returns (uint256);",
|
||
"function test() private override returns (uint256) {}",
|
||
"function test() private virtual returns (uint256);",
|
||
"function test() public pure returns(bytes memory) {",
|
||
"function test() public returns (C1 x, C1 y) {",
|
||
"function test() public returns (Interface.MyEnum) {",
|
||
"function test() public returns (bool x) {",
|
||
"function test() public returns (bool) {",
|
||
"function test() public returns (bytes memory) {",
|
||
"function test() public returns (bytes10 r1, bytes10 r2, bytes10 r3) {",
|
||
"function test() public returns (int16[] memory) {",
|
||
"function test() public returns (uint ret) { return uint(address(Test(address(0x11223344556677889900112233445566778899001122)))); }",
|
||
"function test() public returns (uint x, uint y, uint z) {",
|
||
"function test() public returns (uint) {",
|
||
"function test() public returns (uint16, uint16, uint16, uint16) {",
|
||
"function test() public returns (uint256 x) {",
|
||
"function test() public returns (uint256 x, uint256 l) {",
|
||
"function test() public returns (uint256 x, uint256 y) {",
|
||
"function test() public returns (uint256 x, uint256 y, uint256 l) {",
|
||
"function test() public returns (uint256 x, uint256 y, uint256 z) {",
|
||
"function test() public returns (uint256) {",
|
||
"function test() public returns (uint256, uint256) {",
|
||
"function test() public returns (uint256, uint256, uint256) {",
|
||
"function test() public returns (uint8, uint8, uint8, uint8, uint8) {",
|
||
"function test() public returns (uint80, uint80, uint80, uint80) {",
|
||
"function test() public view returns (bool) {",
|
||
"function test() public view returns (bytes10 r2) {",
|
||
"function test() public {",
|
||
"function test() returns (bool) {",
|
||
"function test() returns (uint) {",
|
||
"function test(address _ext) external {",
|
||
"function test(address a) external view returns (bool status) {",
|
||
"function test(bytes calldata x) public returns (bytes calldata) {",
|
||
"function test(bytes memory buf) public view returns (bool same, bool inplaceDecoded) {",
|
||
"function test(uint a) external {}",
|
||
"function test(uint a) public returns (uint b) { }",
|
||
"function test(uint value) public returns (uint) {",
|
||
"function test(uint256 a, uint256 b)",
|
||
"function test(uint256 len, uint idx) public returns (uint256)",
|
||
"function test(uint256 v) public {",
|
||
"function test(uint256 x) external virtual returns (uint256 v, string memory s)",
|
||
"function test(uint256 x, uint256 i) public returns (uint256) {",
|
||
"function test(uint256[2][] calldata d) external returns (uint256) {",
|
||
"function test(uint8 _a) internal virtual returns (uint256) {}",
|
||
"function test(uint8 _a) internal virtual returns (uint256);",
|
||
"function test(uint8 _a) virtual internal returns (uint256);",
|
||
"function test1() external returns (bool) {",
|
||
"function test1() external returns (uint256);",
|
||
"function test1() external returns(bytes4, bytes4, bytes4, bytes4) {",
|
||
"function test1() public returns(uint){",
|
||
"function test2() external override returns (uint256);",
|
||
"function test2() external override(A) returns (uint256) {}",
|
||
"function test2() external override(B, A) returns (uint256) {}",
|
||
"function test2() external returns (uint256) {}",
|
||
"function test2() external returns (uint256);",
|
||
"function test2() external returns(bytes4, bytes4, bytes4, bytes4) {",
|
||
"function test2() internal override(A) returns (uint256) {}",
|
||
"function test2() internal virtual returns (uint256);",
|
||
"function test2() public returns(uint){",
|
||
"function test3() external override(Super) returns (uint256);",
|
||
"function test3() external override(SuperA) returns (uint256);",
|
||
"function test3() external returns (uint256);",
|
||
"function test3() public returns(uint){",
|
||
"function test4() external override(SuperB) returns (uint256);",
|
||
"function test4() external returns (uint256);",
|
||
"function test5() external override(SuperA, SuperB) returns (uint256);",
|
||
"function test5() external returns (uint256);",
|
||
"function testA() external override returns (uint256) { return 12; }",
|
||
"function testA() external pure override returns (uint256) { return 12; }",
|
||
"function testA() external pure returns (uint256);",
|
||
"function testA() external returns (int128);",
|
||
"function testA() external returns (uint256);",
|
||
"function testAssign()",
|
||
"function testB() external pure override(ParentB) returns (uint256) { return 42; }",
|
||
"function testB() external pure returns (uint256);",
|
||
"function testB() external returns (int256);",
|
||
"function testB() external returns (uint256);",
|
||
"function testCopyRead()",
|
||
"function testCreation() public returns (bool) {",
|
||
"function testInit()",
|
||
"function testIt() public returns (bool) {",
|
||
"function testIt() public {",
|
||
"function testMul() public returns (bool) {",
|
||
"function testRuntime() public returns (bool) {",
|
||
"function testSub() external override returns (uint256) { return 99; }",
|
||
"function testSub() external pure override returns (uint256) { return 99; }",
|
||
"function testSub() external pure returns (uint256);",
|
||
"function testSub() external returns (uint256);",
|
||
"function testUnboundedForLoop(uint n) public {",
|
||
"function testUnboundedForLoop(uint n, uint[] memory b, uint[] memory c) public pure {",
|
||
"function testUnboundedForLoop(uint n, uint[] memory b, uint[] memory c) public {",
|
||
"function test_assignment() public returns (X _ret) {",
|
||
"function test_boundary_check(uint256 len, uint256 access) public returns (uint256)",
|
||
"function test_bytes() public {",
|
||
"function test_calldata_coding() internal returns (uint) {",
|
||
"function test_cleanup() public returns (bool) {",
|
||
"function test_eq() public returns (bool) {",
|
||
"function test_eq_ok() public returns (bool) {",
|
||
"function test_indices(uint256 len) public",
|
||
"function test_inline_assignment() public returns (X _ret) {",
|
||
"function test_long() public returns (uint256 r) {",
|
||
"function test_neq() public returns (bool) {",
|
||
"function test_pop() public returns (uint256 r) {",
|
||
"function test_return() public returns (X) {",
|
||
"function test_short() public returns (uint256 r) {",
|
||
"function test_simple(uint _off) public returns (uint _a, uint _b, uint _c) {",
|
||
"function test_store() public returns (uint256) {",
|
||
"function test_store_ok() public returns (uint256) {",
|
||
"function test_str() public returns (bool) {",
|
||
"function test_twodim() public returns (uint a, uint b) {",
|
||
"function test_uint256() public {",
|
||
"function test_zeroed_indicies(uint256 len) public",
|
||
"function tested(X x) public returns (uint256) {",
|
||
"function tester(bytes calldata x) public returns (byte) {",
|
||
"function tests() internal",
|
||
"function tests() internal pure",
|
||
"function tgeo() public { }",
|
||
"function three() public pure returns (uint, uint, uint) {}",
|
||
"function threeBytesUTF8() public pure returns (bytes32) {",
|
||
"function threeBytesUTF8() public pure returns (string memory) {",
|
||
"function toAddress(RLPItem memory self) internal view returns (address data) {",
|
||
"function toAscii(RLPItem memory self) internal returns (string memory str) {",
|
||
"function toBool(RLPItem memory self) internal view returns (bool data) {",
|
||
"function toByte(RLPItem memory self) internal view returns (byte data) {",
|
||
"function toBytes(RLPItem memory self) internal returns (bytes memory bts) {",
|
||
"function toBytes32(RLPItem memory self) internal view returns (bytes32 data) {",
|
||
"function toData(RLPItem memory self) internal returns (bytes memory bts) {",
|
||
"function toInt(RLPItem memory self) internal view returns (int data) {",
|
||
"function toList(RLPItem memory self) internal view returns (RLPItem[] memory list) {",
|
||
"function toRLPItem(bytes memory self) internal view returns (RLPItem memory) {",
|
||
"function toRLPItem(bytes memory self, bool strict) internal view returns (RLPItem memory) {",
|
||
"function toSlice(string memory self) internal pure returns (slice memory) {",
|
||
"function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {",
|
||
"function toString(slice memory self) internal pure returns (string memory) {",
|
||
"function toUint(RLPItem memory self) internal view returns (uint data) {",
|
||
"function to_little_endian_64(uint64 value) public pure returns (bytes memory ret) {",
|
||
"function totalSupply()",
|
||
"function totalSupply() public view returns (bool success, uint256 value) {",
|
||
"function totalSupply() public view returns (uint256 value) {",
|
||
"function totalSupply() public view returns (uint256) {",
|
||
"function totalSupply() virtual public view returns (uint);",
|
||
"function transfer() pure public {}",
|
||
"function transfer(address _to, uint256 _amount) public virtual override returns (bool success) {",
|
||
"function transfer(address _to, uint256 _amount) public virtual returns (bool success);",
|
||
"function transfer(address _to, uint256 _value)",
|
||
"function transfer(address _to, uint256 _value) public override returns (bool success) {",
|
||
"function transfer(address a) internal {}",
|
||
"function transfer(address from, address to, uint256 value, bool fee) external returns (bool success) {",
|
||
"function transfer(address payable from, address payable to, uint256 value, bool fee) external returns (bool success) {}",
|
||
"function transfer(address to, uint value)",
|
||
"function transfer(address to, uint value) virtual public returns (bool);",
|
||
"function transfer(address to, uint256 amount) isReady external returns (bool success) {",
|
||
"function transfer(address to, uint256 amount, bytes calldata extraData) isReady external returns (bool success) {",
|
||
"function transfer(address to, uint256 value) public returns (bool) {",
|
||
"function transfer(address,uint256) external returns(bool);",
|
||
"function transfer(uint amount) public {",
|
||
"function transfer(uint) public virtual;",
|
||
"function transfer(uint256 amount) public returns (uint256) {",
|
||
"function transferEvent(address from, address to, uint256 value) external returns (bool success) {}",
|
||
"function transferEvent(address payable from, address payable to, uint256",
|
||
"function transferEvent(address payable from, address payable to, uint256 value) external override returns (bool success) {",
|
||
"function transferEvent(address payable from, address payable to, uint256 value) external override returns (bool) {",
|
||
"function transferEvent_(address addr, uint256 value, bool neg) internal {",
|
||
"function transferFrom(",
|
||
"function transferFrom(address _from, address _to, uint256 _amount) public",
|
||
"function transferFrom(address _from, address _to, uint256 _value)",
|
||
"function transferFrom(address _from, address _to, uint256 _value) public",
|
||
"function transferFrom(address from, address to, uint value)",
|
||
"function transferFrom(address from, address to, uint value) virtual public returns (bool);",
|
||
"function transferFrom(address from, address to, uint256 amount) isReady external returns (bool success) {",
|
||
"function transferFrom(address from, address to, uint256 value) public returns (bool) {",
|
||
"function transferFromByModule(address from, address to, uint256 amount, bool fee) isReady external returns (bool success) {",
|
||
"function transferFromWithoutReward(",
|
||
"function transferPaidOut(",
|
||
"function transferToContract(address from, address to, uint256 amount, bytes memory extraData) internal {",
|
||
"function transferWithoutReward(address _to, uint256 _amount) public virtual returns (bool success);",
|
||
"function transferWithoutReward(address _to, uint256 _value) public override returns (bool success) {",
|
||
"function two() public pure returns (uint, uint) {}",
|
||
"function two() public returns (uint256) {",
|
||
"function twoBytesUTF8() public pure returns (bytes32) {",
|
||
"function twoBytesUTF8() public pure returns (string memory) {",
|
||
"function type() public pure {",
|
||
"function u() public returns (T[2] memory) {",
|
||
"function uint256_string_to_string(uint256 x, string memory y) internal pure returns (string memory) { return x == 0 ? \"a\" : y; }",
|
||
"function uint256_to_string(uint256 x) internal pure returns (string memory) { return x == 0 ? \"a\" : \"b\"; }",
|
||
"function uint256_to_string_storage(uint256) internal pure returns (string storage) {}",
|
||
"function uint256_to_uint256(uint256 x) internal pure returns (uint256) { return x; }",
|
||
"function uint256_uint256_to_string(uint256 x, uint256 y) internal pure returns (string memory) { return x == y ? \"a\" : \"b\"; }",
|
||
"function uint256_uint256_to_uint256(uint256 x, uint256 y) internal pure returns (uint256) { return x + y; }",
|
||
"function uintMaxA() public pure returns (bool) {",
|
||
"function uintMaxB() public pure returns (bool) {",
|
||
"function uintMaxC() public pure returns (bool) {",
|
||
"function uintMaxD() public pure returns(bool) {",
|
||
"function uintMinA() public pure returns(bool) {",
|
||
"function uintMinB() public pure returns(bool) {",
|
||
"function uintMinC() public pure returns(bool) {",
|
||
"function uintMinD() public pure returns(bool) {",
|
||
"function uintToBytes(uint256 h) public returns (bytes32 s) {",
|
||
"function uintToBytes(uint32 h) public returns (bytes2 s) {",
|
||
"function unassociated() public returns (uint) {",
|
||
"function unblockMe() public override returns (bool) {",
|
||
"function unblockMe() public virtual returns (bool);",
|
||
"function unequal() public pure returns (bool same, bool diff, bool inv) {",
|
||
"function unproposeMilestones() public onlyRecipient campaignNotCanceled {",
|
||
"function until(slice memory self, slice memory needle) internal pure returns (slice memory) {",
|
||
"function unused() internal returns (uint256) {",
|
||
"function unvote(uint id) public virtual returns (uint value);",
|
||
"function update() public;",
|
||
"function update() {}",
|
||
"function update(bool _bool, uint256 _decimal, bytes32 _bytes) public returns (bool, uint256, bytes32) {",
|
||
"function update(uint _state) public {",
|
||
"function upgrade() {}",
|
||
"function upgrade();",
|
||
"function upgrade(address new_address) public restricted {",
|
||
"function use(uint256 _arg) public returns (uint256) {",
|
||
"function useSend(address a) public {",
|
||
"function useTransfer(address a) public {",
|
||
"function utterance() external returns (bytes32);",
|
||
"function utterance() public returns (bytes32) { return \"miaow\"; }",
|
||
"function v() public returns (bool[2][] memory) {",
|
||
"function val() public returns (uint ret) {",
|
||
"function validDoHash(bytes32 doHash) public view returns (bool valid) {",
|
||
"function value(function()internal a, uint256 b) internal {}",
|
||
"function value(uint256) public returns (uint) { return 1; }",
|
||
"function value(uint8) public returns (uint) { return 1; }",
|
||
"function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {",
|
||
"function verify(uint[] memory input, Proof memory proof) internal returns (uint) {",
|
||
"function verifyTx() public returns (bool) {",
|
||
"function verifyingKey() internal returns (VerifyingKey memory vk) {",
|
||
"function viewAssignment() public view {",
|
||
"function vote(",
|
||
"function vote() public virtual returns (uint value);",
|
||
"function vote(uint id) public virtual returns (uint value);",
|
||
"function vote(uint id) public {",
|
||
"function vote(uint id) public {}",
|
||
"function voteForOutcome(int _outcome, uint amount)",
|
||
"function w1() public returns (string[1] memory) {",
|
||
"function w2() public returns (string[2] memory) {",
|
||
"function w3() public returns (string[3] memory) {",
|
||
"function withMod(uint self) mod() internal view { require(self > 0); }",
|
||
"function withdraw()",
|
||
"function withdraw(uint value)",
|
||
"function withdrawFees()",
|
||
"function withdrawFees() virtual public returns (uint);",
|
||
"function withdrawRewardFor(address payable _account) internal virtual returns (bool _success);",
|
||
"function withdrawRewardFor(address payable _account) noEther internal",
|
||
"function world() public pure returns (bytes4 data){",
|
||
"function world(int) external pure;",
|
||
"function x() external {}",
|
||
"function x() internal returns (uint256) {",
|
||
"function x() public returns (string[2] memory, string[3] memory) {",
|
||
"function x() public returns (uint) { return 1; }",
|
||
"function x() public returns (uint) {}",
|
||
"function x() public {}",
|
||
"function x() pure internal {}",
|
||
"function x(bool) public {}",
|
||
"function xInit() internal override returns(uint) {",
|
||
"function xInit() internal virtual returns(uint) {",
|
||
"function xor(bool a, bool b) internal pure returns (bool) {",
|
||
"function y() public returns (uint) { return 2; }",
|
||
"function y() public {}",
|
||
"function z() public {",
|
||
"function(",
|
||
"function() Test;",
|
||
"function() external f = A.f;",
|
||
"function() external g;",
|
||
"function() external immutable f;",
|
||
"function() external override fp2;",
|
||
"function() external override virtual fp3;",
|
||
"function() external payable x = this.f{value: 7};",
|
||
"function() external payable {}",
|
||
"function() external public f;",
|
||
"function() external public g;",
|
||
"function() external public h;",
|
||
"function() external pure g = A.g;",
|
||
"function() external returns (S memory) sub;",
|
||
"function() external returns (function () internal) x;",
|
||
"function() external returns (function() external returns (uint))[] memory x =",
|
||
"function() external returns (uint)",
|
||
"function() external returns (uint) _g;",
|
||
"function() external returns (uint) a,",
|
||
"function() external returns (uint) b",
|
||
"function() external returns (uint) b;",
|
||
"function() external returns (uint) c;",
|
||
"function() external returns (uint),",
|
||
"function() external returns (uint)[3] memory y = (new D()).f(x);",
|
||
"function() external returns (uint)[] memory a = new function() external returns (uint)[](3);",
|
||
"function() external returns (uint)[] memory arr = new function() external returns (uint)[](n);",
|
||
"function() external returns (uint)[][] memory arr = new function() external returns (uint)[][](n);",
|
||
"function() external two_stack_slots;",
|
||
"function() external virtual fp;",
|
||
"function() external {}",
|
||
"function() external[] d;",
|
||
"function() internal c = f;",
|
||
"function() internal invalid;",
|
||
"function() internal pure returns (bool) invalid;",
|
||
"function() internal pure returns(int8) func = internal_func;",
|
||
"function() internal returns (uint) _f;",
|
||
"function() internal returns (uint) a;",
|
||
"function() internal returns (uint) d;",
|
||
"function() internal returns (uint)[200] memory x;",
|
||
"function() internal returns (uint)[20] memory xmem;",
|
||
"function() internal returns (uint)[20] x;",
|
||
"function() internal returns (uint)[] memory arr = new function() internal returns (uint)[](n);",
|
||
"function() internal returns (uint)[] x;",
|
||
"function() internal returns (uint)[] y;",
|
||
"function() internal returns (uint)[][] memory arr = new function() internal returns (uint)[][](n);",
|
||
"function() internal returns (uint256) ptr = A.f;",
|
||
"function() internal returns (uint256) ptr = g;",
|
||
"function() internal returns(function() internal returns(function() internal returns(function() internal returns(uint)))) x;",
|
||
"function() internal returns(uint) ptr;",
|
||
"function() internal storedFn;",
|
||
"function() internal view returns(uint256) immutable z;",
|
||
"function() internal x = f0;",
|
||
"function() internal x;",
|
||
"function() internal y;",
|
||
"function() pure x;",
|
||
"function() r = true ? fun_x : f;",
|
||
"function() returns (uint a, uint b,) {}",
|
||
"function() returns (uint a,) {}",
|
||
"function() returns (uint256) internal x;",
|
||
"function() returns (uint256) internal y;",
|
||
"function() returns (uint256) y = a;",
|
||
"function() returns (x) constant x = x;",
|
||
"function() returns(function() returns(function() returns(function() returns(uint)))) x;",
|
||
"function() returns(uint) ptr;",
|
||
"function() x;",
|
||
"function() y = x;",
|
||
"function()internal x;",
|
||
"function(bytes calldata) returns (byte) x;",
|
||
"function(bytes memory) a1;",
|
||
"function(bytes memory) external c1;",
|
||
"function(bytes memory) external internal a = fa;",
|
||
"function(bytes memory) external internal c2;",
|
||
"function(bytes memory) external public c3;",
|
||
"function(bytes memory) internal b1;",
|
||
"function(bytes memory) internal internal b2;",
|
||
"function(bytes memory) internal public a;",
|
||
"function(bytes memory) public a;",
|
||
"function(function () internal) external x;",
|
||
"function(function() internal pure) internal view y;",
|
||
"function(uint a) f;",
|
||
"function(uint a) returns (uint) x;",
|
||
"function(uint a) {}",
|
||
"function(uint a, uint b,) {}",
|
||
"function(uint a,) {}",
|
||
"function(uint) a = fa;",
|
||
"function(uint) external d = this.fd;",
|
||
"function(uint) external internal e = this.fe;",
|
||
"function(uint) external returns (uint) a,",
|
||
"function(uint) external returns (uint) x;",
|
||
"function(uint) external returns (uint)[] memory c;",
|
||
"function(uint) external returns (uint)[] public x;",
|
||
"function(uint) external view returns (uint) b) {",
|
||
"function(uint) internal f = ff;",
|
||
"function(uint) internal internal c = fc;",
|
||
"function(uint) internal pure g = fg;",
|
||
"function(uint) internal returns (uint) a = y;",
|
||
"function(uint) internal returns (uint) g;",
|
||
"function(uint) internal returns (uint) y;",
|
||
"function(uint) internal returns (uint)[10] y;",
|
||
"function(uint) internal returns (uint)[] memory arr =",
|
||
"function(uint) internal returns (uint)[] x;",
|
||
"function(uint) m_g;",
|
||
"function(uint) private returns (uint) x;",
|
||
"function(uint) public returns (uint) x;",
|
||
"function(uint) pure internal h = fh;",
|
||
"function(uint) returns (bool ret) f;",
|
||
"function(uint) returns (uint) a;",
|
||
"function(uint) returns (uint) b;",
|
||
"function(uint) returns (uint) x;",
|
||
"function(uint) returns (uint)[10] memory a;",
|
||
"function(uint) returns (uint)[10] storage b = y;",
|
||
"function(uint, bytes32) external y;",
|
||
"function(uint, uint) internal returns (uint) f,",
|
||
"function(uint, uint) internal returns (uint) single_slot_function = s;",
|
||
"function(uint256) returns (uint256) internal x;",
|
||
"funding = _funding;",
|
||
"funds += amount;",
|
||
"funds = getFunds(msg.sender);",
|
||
"funds[_owner] = _amount;",
|
||
"fun{gas: 1}();",
|
||
"fun{value: 1}();",
|
||
"futarchyOracle = new FutarchyOracle(",
|
||
"futarchyOracle,",
|
||
"g = f;",
|
||
"g(\"0123456\");",
|
||
"g();",
|
||
"g()[3][4];",
|
||
"g(2);",
|
||
"g(_data);",
|
||
"g(a);",
|
||
"g(array.push(), y);",
|
||
"g(keccak256(uint(2)));",
|
||
"g(ripemd160(uint(2)));",
|
||
"g(s, y);",
|
||
"g(sha256(uint(2)));",
|
||
"g(this).f();",
|
||
"g(x);",
|
||
"g(x, a);",
|
||
"g.selector;",
|
||
"g1(2);",
|
||
"g1points[0] = Pairing.P1().mul(5);",
|
||
"g1points[0] = Pairing.P1();",
|
||
"g1points[1] = Pairing.P1().negate();",
|
||
"g1points[1] = Pairing.P1();",
|
||
"g1points[1].Y = p - g1points[1].Y;",
|
||
"g2(m_g);",
|
||
"g2(r());",
|
||
"g2points[0] = Pairing.P2();",
|
||
"g2points[1] = Pairing.P2();",
|
||
"g2points[1] = fiveTimesP2;",
|
||
"garbled := 5",
|
||
"gas memory x;",
|
||
"gas: 2",
|
||
"genesis[genesisAddr[a]] = true;",
|
||
"getInterest = rightForInterest(getProviderCurrentSupply(addr), providers[addr].data[height].priv );",
|
||
"getProviderCurrentSupply(providerAddress) + value,",
|
||
"getProviderCurrentSupply(providerAddress) - value,",
|
||
"getProviderCurrentSupply(providerAddress),",
|
||
"globalFunds[currentSchellingRound].supply += newValue;",
|
||
"globalFunds[currentSchellingRound].supply -= oldValue;",
|
||
"globalFunds[currentSchellingRound].supply = globalFunds[currentSchellingRound].supply - oldValue + newValue;",
|
||
"globalFunds[roundID].reward = reward;",
|
||
"globalFunds[roundID].supply = globalFunds[roundID-1].supply;",
|
||
"gs = B.g.selector;",
|
||
"g{gas: 2, value: 3}(4);",
|
||
"h = (new Helper){value: 10}(\"abc\", true);",
|
||
"h = new Helper(\"abc\", true);",
|
||
"h = new helper();",
|
||
"h = this.fun;",
|
||
"h();",
|
||
"h()[5];",
|
||
"h.setFlag {",
|
||
"h1()();",
|
||
"h;",
|
||
"halflnz += termpow / 11;",
|
||
"halflnz += termpow / 13;",
|
||
"halflnz += termpow / 15;",
|
||
"halflnz += termpow / 17;",
|
||
"halflnz += termpow / 19;",
|
||
"halflnz += termpow / 21;",
|
||
"halflnz += termpow / 23;",
|
||
"halflnz += termpow / 25;",
|
||
"halflnz += termpow / 3;",
|
||
"halflnz += termpow / 5;",
|
||
"halflnz += termpow / 7;",
|
||
"halflnz += termpow / 9;",
|
||
"hash = voter[_owner].hash;",
|
||
"height = providers[addr].currentHeight;",
|
||
"helper h;",
|
||
"hex\"1234_\";",
|
||
"hex\"12__34\";",
|
||
"hex\"1_234\";",
|
||
"hex\"_1234\";",
|
||
"hex\"deaf\"",
|
||
"hex\"feed\";",
|
||
"hi = mid;",
|
||
"highestIndex = i;",
|
||
"highestMarginalPrice = marginalPrice;",
|
||
"https:",
|
||
"https:",
|
||
"i := 0",
|
||
"i := add(i, 1)",
|
||
"i := sub(i, 1)",
|
||
"i = 2;",
|
||
"i = i + i;",
|
||
"i = n;",
|
||
"i = newI;",
|
||
"i++;",
|
||
"i.f(new uint[](1));",
|
||
"icoAddr = icoContractAddr;",
|
||
"icoDelay += oneSegment;",
|
||
"icoDelay = startBlock + oneSegment * 3;",
|
||
"icoEtcPriceAddr = priceSet;",
|
||
"icoExchangeRate = exchangeRate;",
|
||
"icoExchangeRate = value;",
|
||
"icoExchangeRateSetBlock = block.number + exchangeRateDelay;",
|
||
"icoLevels.push(icoLevels_s(startBlock + oneSegment * 1, 3));",
|
||
"icoLevels.push(icoLevels_s(startBlock + oneSegment / 7, 5));",
|
||
"icoLevels.push(icoLevels_s(startBlock, 10));",
|
||
"icoLevels_s[] public icoLevels;",
|
||
"id := chainid()",
|
||
"id = modules.length;",
|
||
"ids[2] = id;",
|
||
"ids[index] = id;",
|
||
"idx++;",
|
||
"if ( a == announcementType.providerPublicFunds ) { minFundsForPublic = b; }",
|
||
"if ( a == announcementType.schellingRoundBlockDelay ) { roundBlockDelay = b; }",
|
||
"if ( aType == announcementType.transactionFeeRate ) { transactionFeeRate = value; }",
|
||
"if ((milestone.status != MilestoneStatus.AcceptedAndInProgress) &&",
|
||
"if ((milestone.status != MilestoneStatus.Completed) ||",
|
||
"if (",
|
||
"if ( !balances[from].safeToSub(value)",
|
||
"if ( !balances[msg.sender].safeToSub(value)",
|
||
"if ( ownerCount > MAX_OWNER_COUNT",
|
||
"if ( pending && !transactions[i].executed",
|
||
"if ( (msg.sender != milestone.milestoneLeadLink)",
|
||
"if ( ! ( _found && modules[_id].name == keccak256('Publisher') )) {",
|
||
"if ( ! _forReplace ) {",
|
||
"if ( ! announcements[opponents[msg.sender][a]].open) {",
|
||
"if ( ! checkOpposited(announcements[id].oppositionWeight, announcements[id].oppositable) ) {",
|
||
"if ( ! forReplace ) {",
|
||
"if ( ! found ) {",
|
||
"if ( ! foundEmptyArrayID ) {",
|
||
"if ( ! genesisAddr[a].send(0.2 ether) ) {}",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"callDisableCallback\", keccak256(bytes(moduleName)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"callReplaceCallback\", keccak256(abi.encodePacked(moduleName, newModule)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"configureModule\", keccak256(abi.encodePacked(moduleName, aType, value)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"freezing\", keccak256(abi.encodePacked(forever)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"newModule\", keccak256(abi.encodePacked(name, addr, schellingEvent, transferEvent)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"replaceModule\", keccak256(abi.encodePacked(name, addr, callCallback)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"replaceModule\", keccak256(abi.encodePacked(name, callCallback)))) ) {",
|
||
"if ( ! insertAndCheckDo(calcDoHash(\"replaceModuleHandler\", keccak256(abi.encodePacked(newHandler)))) ) {",
|
||
"if ( ! oppositable ) { return false; }",
|
||
"if ( ! owners[addr] ) { return; }",
|
||
"if ( ! providerHasClosed ) {",
|
||
"if ( ! round.voted ) {",
|
||
"if ( ( a > LTSID && rightForInterest(providers[addr].data[currHeight].supply[LTSID], providers[addr].data[currHeight].priv) ||",
|
||
"if ( LTSID < a ) {",
|
||
"if ( _addr == address(0x00) ) { _addr = msg.sender; }",
|
||
"if ( _back > 0 ) {",
|
||
"if ( _balance > 0 ) {",
|
||
"if ( _beneficiary == address(0x00) ) { _beneficiary = msg.sender; }",
|
||
"if ( _empty ) {",
|
||
"if ( _idb.amount > 0 ) {",
|
||
"if ( _idb.empty ) {",
|
||
"if ( _limit == 0 ) { _limit = gasProtectMaxRounds; }",
|
||
"if ( _provider == address(0x00) ) { _provider = msg.sender; }",
|
||
"if ( _reward > 0 ) {",
|
||
"if ( _schellingAddr != address(0x00) && _found) {",
|
||
"if ( _success && _found ) { return (true, true, modules[_id].addr); }",
|
||
"if ( _to == 0 || aborted ) { return 0; }",
|
||
"if ( a && b ) {",
|
||
"if ( a > providers[provAddr].data[provHeight].lastSupplyID ) {",
|
||
"if ( above >= interestCheckAboves ) {",
|
||
"if ( aboveW == belowW ) {",
|
||
"if ( address(this).balance > 0 ) {",
|
||
"if ( admin != address(0x00) ) {",
|
||
"if ( admin == address(0x00) ) {",
|
||
"if ( affilateAddress != address(0x00) && ( brought[affilateAddress].eth > 0 || interestDB[affilateAddress][0].amount > 0 ) ) {",
|
||
"if ( announcements[announcementID].end < block.number && announcements[announcementID].open ) {",
|
||
"if ( announcements[id].Type == announcementType.newModule ) {",
|
||
"if ( b > 0 ) {",
|
||
"if ( balance == 0 ) {",
|
||
"if ( beneficiaryAddress == address(0x00)) { beneficiaryAddress = msg.sender; }",
|
||
"if ( beneficiaryAddress == affilateAddress ) {",
|
||
"if ( beneficiaryAddress.balance < 0.2 ether ) {",
|
||
"if ( block.number > icoLevels[a].block ) {",
|
||
"if ( bytes(vote)[0] == aboveChar ) {",
|
||
"if ( call ) { require( abstractModule(input.addr).connectModule() ); }",
|
||
"if ( callCallback ) {",
|
||
"if ( checkICO() ) {",
|
||
"if ( checkOpposited(announcements[id].oppositionWeight, announcements[id].oppositable) ) {",
|
||
"if ( clientReward > 0 ) {",
|
||
"if ( clients[addr].providerAddress != address(0x00) ) {",
|
||
"if ( currentSchellingRound != LSID ) {",
|
||
"if ( doDB[doHash].length+1 >= ownersForChange() ) {",
|
||
"if ( fee ) { _processTransactionFee(from, amount); }",
|
||
"if ( fee > transactionFeeMax ) { fee = transactionFeeMax; }",
|
||
"if ( forever ) {",
|
||
"if ( forever ) { moduleStatus = status.Disabled; }",
|
||
"if ( foundEmptyArrayID ) {",
|
||
"if ( from != msg.sender ) {",
|
||
"if ( globalFunds[a].supply > 0) {",
|
||
"if ( height == 0 ) {",
|
||
"if ( insertAndCheckDo(calcDoHash(\"cancelDo\", doHash)) ) {",
|
||
"if ( insertAndCheckDo(calcDoHash(\"dropOwner\", keccak256(abi.encodePacked(addr)))) ) {",
|
||
"if ( insertAndCheckDo(calcDoHash(\"insertOwner\", keccak256(abi.encodePacked(addr)))) ) {",
|
||
"if ( interest ) {",
|
||
"if ( isContract(to) ) {",
|
||
"if ( isICO ) {",
|
||
"if ( isICO ) { return (true, 0); }",
|
||
"if ( isICO ) { return; }",
|
||
"if ( isWinner(round, voter.voteResult) && voter.status == voterStatus.afterSendVoteOk ) {",
|
||
"if ( keccak256(bytes(vote)) == voter.hash ) {",
|
||
"if ( limit > 0 && steps > limit ) {",
|
||
"if ( lostEverything ) {",
|
||
"if ( moduleHandlerAddress == address(0x00) ) { return true; }",
|
||
"if ( moduleStatus != status.Connected ) { return false; }",
|
||
"if ( modules[a].addr == addr ) {",
|
||
"if ( modules[a].name == _name ) {",
|
||
"if ( modules[a].name == hashOfName ) {",
|
||
"if ( modules[a].schellingEvent && abstractModule(modules[a].addr).isActive() ) {",
|
||
"if ( modules[a].transferEvent && abstractModule(modules[a].addr).isActive() ) {",
|
||
"if ( neg ) {",
|
||
"if ( neg ) { return a-b; }",
|
||
"if ( owner == address(0x00) ) {",
|
||
"if ( owners[addr] ) { return; }",
|
||
"if ( prevRound.totalAboveWeight > prevRound.totalBelowWeight ) { above++; }",
|
||
"if ( priv ) {",
|
||
"if ( providerReward > 0 ) {",
|
||
"if ( providers[_provider].data[providers[_provider].currentHeight].valid ) {",
|
||
"if ( providers[addr].data[currHeight].isForRent ) {",
|
||
"if ( providers[addr].data[currHeight].priv ) {",
|
||
"if ( providers[addr].data[currHeight].priv ) { providerReward += ownReward; }",
|
||
"if ( providers[addr].data[currHeight].rateHistory[a].valid ) {",
|
||
"if ( providers[addr].data[currentHeight].priv ) {",
|
||
"if ( providers[addr].data[providers[addr].currentHeight].valid ) {",
|
||
"if ( providers[provAddr].data[provHeight].rateHistory[a].valid ) {",
|
||
"if ( providers[provider].data[currHeight].close > 0 ) {",
|
||
"if ( providers[provider].data[currHeight].priv ) {",
|
||
"if ( r*interestBlockDelay+startBlock >= icoDelay ) { break; }",
|
||
"if ( rate > 0 ) {",
|
||
"if ( reward < 5e6) { return 0; }",
|
||
"if ( round.blockHeight+roundBlockDelay > block.number) { return false; }",
|
||
"if ( round.blockHeight+roundBlockDelay/2 <= block.number ) {",
|
||
"if ( round.totalAboveWeight == round.totalBelowWeight ||",
|
||
"if ( rounds.length <= _id ) { return (false, 0, 0, 0, 0, false); }",
|
||
"if ( schellingRound == 0 ) {",
|
||
"if ( startBlockNum > 0 ) {",
|
||
"if ( to == address(this) ) {",
|
||
"if (!DAOrewardAccount.payOut(address(dao), reward))",
|
||
"if (!DAOrewardAccount.payOut(address(dao.rewardAccount()), reward))",
|
||
"if (!Pairing.pairing(g1points, g2points))",
|
||
"if (!Pairing.pairingProd2(proof.A, vk.A, Pairing.negate(proof.A_p), Pairing.P2())) return 1;",
|
||
"if (!Pairing.pairingProd2(proof.C, vk.C, Pairing.negate(proof.C_p), Pairing.P2())) return 3;",
|
||
"if (!Pairing.pairingProd2(vk.B, proof.B, Pairing.negate(proof.B_p), Pairing.P2())) return 2;",
|
||
"if (!Pairing.pairingProd3(",
|
||
"if (!b)",
|
||
"if (!changingMilestones) revert();",
|
||
"if (!confirmations[transactionId][owner])",
|
||
"if (!confirmed)",
|
||
"if (!flag) c = s;",
|
||
"if (!flag) {",
|
||
"if (!getMyReward())",
|
||
"if (!isFueled",
|
||
"if (!isList(self))",
|
||
"if (!isOwner[owner])",
|
||
"if (!isRecipientAllowed(p.recipient)) {",
|
||
"if (!itmProposal.isList()) revert();",
|
||
"if (!itmProposals.isList()) revert();",
|
||
"if (!p.creator.send(p.proposalDeposit))",
|
||
"if (!rewardAccount.payOut(_account, reward))",
|
||
"if (!success)",
|
||
"if (!success) {",
|
||
"if (!withdrawRewardFor(_from))",
|
||
"if ((2**255 + 2**255) % 7 != addmod(2**255, 2**255, 7)) return 1;",
|
||
"if ((2**255 + 2**255) % 7 != addmod(2**255, 2**255, 7)) return 2;",
|
||
"if ((b = false) && (b = true)) {}",
|
||
"if ((b = false) && (b == true)) {}",
|
||
"if ((b = false) || b) {}",
|
||
"if ((b = true) && b) {}",
|
||
"if ((b = true) || (b = false)) {}",
|
||
"if ((b = true) || (b == false)) {}",
|
||
"if ((b == false) && (b = true)) {}",
|
||
"if ((b == false) && (b == true)) {}",
|
||
"if ((b == false) && g(true)) {}",
|
||
"if ((b == true) || (b = false)) {}",
|
||
"if ((b == true) || (b == false)) {}",
|
||
"if ((b == true) || g(false)) {}",
|
||
"if ((balanceOf(_account) * rewardAccount.accumulatedInput()) / totalSupply < paidOut[_account])",
|
||
"if ((c = s).f && !(c = s).f) {",
|
||
"if ((c = s).f) {",
|
||
"if ((lastTimeMinQuorumMet < (block.timestamp - quorumHalvingPeriod) || msg.sender == curator)",
|
||
"if ((msg.sender != milestone.reviewer) ||",
|
||
"if ((rewardToken[msg.sender] * DAOrewardAccount.accumulatedInput()) /",
|
||
"if (0==0)",
|
||
"if (0==1)",
|
||
"if (1 == x) {}",
|
||
"if (DAOpaidOut[address(this)] < paidOutToBeMoved)",
|
||
"if (First(2).fun() == true) return 1;",
|
||
"if (_address == address(0))",
|
||
"if (_b) return 1;",
|
||
"if (_c[2] > 10)",
|
||
"if (_debatingPeriod > 8 weeks)",
|
||
"if (_idMilestone >= milestones.length) revert();",
|
||
"if (_len == 0 || (_len == 1 && _data[_begin] != _value))",
|
||
"if (_newCurator && (",
|
||
"if (_newCurator)",
|
||
"if (_outcome != frontRunner && totalOutcomeAmounts[_outcome] > totalOutcomeAmounts[frontRunner])",
|
||
"if (_outcome == outcomes[j]) {",
|
||
"if (_supportsProposal) {",
|
||
"if (_transactionData.length >= 4 && _transactionData[0] == 0x68",
|
||
"if (_value < v) return find(_data, _begin, halfLen, _value);",
|
||
"if (a != \"ab\") return 1;",
|
||
"if (a != 0) {",
|
||
"if (a != 0x1234567890123456789012345678901234567890) return 1;",
|
||
"if (a != 1 || b != 2 || c[0] != 3) return 2;",
|
||
"if (a != 2 || b != 1) return 3;",
|
||
"if (a != 2) return false;",
|
||
"if (a != 2) revert();",
|
||
"if (a != 5 || b != 6) return 1;",
|
||
"if (a != 8 || b != 10) return 4;",
|
||
"if (a != b)",
|
||
"if (a != b) {",
|
||
"if (a + b < 10)",
|
||
"if (a < 0) b = 0x67; else if (a == 0) b = 0x12; else b = 0x78;",
|
||
"if (a == 0) {",
|
||
"if (a == 0) { break; }",
|
||
"if (a == b)",
|
||
"if (a > 0)",
|
||
"if (a > 100)",
|
||
"if (a >= 8) { return 2; } else { uint b = 7; }",
|
||
"if (a) return;",
|
||
"if (a) y = 1;",
|
||
"if (a) {",
|
||
"if (a1 != 1 || a3 != 3) return false;",
|
||
"if (a[i] != b[i])",
|
||
"if (address(DAOrewardAccount) == 0x0000000000000000000000000000000000000000)",
|
||
"if (address(extraBalance).balance >= extraBalance.accumulatedInput())",
|
||
"if (address(p.splitData[0].newDAO) == 0x0000000000000000000000000000000000000000)",
|
||
"if (address(p.splitData[0].newDAO) == 0x0000000000000000000000000000000000000000) {",
|
||
"if (address(rewardAccount) == 0x0000000000000000000000000000000000000000)",
|
||
"if (address(this).balance < sumOfProposalDeposits)",
|
||
"if (allowedRecipients[_recipient]",
|
||
"if (amount == maxAmount)",
|
||
"if (amount > maxAmount)",
|
||
"if (arrayData[3] != 2) return 8;",
|
||
"if (b != 1) return false;",
|
||
"if (b & 0xC0 != 0x80) {",
|
||
"if (b < 0x80) {",
|
||
"if (b)",
|
||
"if (b) {",
|
||
"if (b0 < DATA_SHORT_START)",
|
||
"if (b0 < DATA_SHORT_START) {",
|
||
"if (b1 != 1 || b2 != 2) return false;",
|
||
"if (balanceOf(msg.sender) == 0) revert();",
|
||
"if (balances[_from] < _value || allowed[_from][msg.sender] < _value) {",
|
||
"if (balances[_from] >= _amount",
|
||
"if (balances[msg.sender] < _value) {",
|
||
"if (balances[msg.sender] < amount) return false;",
|
||
"if (balances[msg.sender] >= _amount && _amount > 0) {",
|
||
"if (beneficiary != address(0x00)) { _beneficiary = beneficiary; }",
|
||
"if (block.timestamp < closingTime && msg.value > 0",
|
||
"if (block.timestamp < closingTime + creationGracePeriod && msg.sender != address(extraBalance))",
|
||
"if (block.timestamp < milestone.minCompletionDate) revert();",
|
||
"if (block.timestamp > closingTime && !isFueled) {",
|
||
"if (block.timestamp > lastDay + 24 hours)",
|
||
"if (block.timestamp > lastDay + 24 hours) {",
|
||
"if (block.timestamp > milestone.maxCompletionDate) revert();",
|
||
"if (block.timestamp > p.votingDeadline) {",
|
||
"if (blocked[_account] == 0)",
|
||
"if (blocked[msg.sender] == 0) {",
|
||
"if (bytes3(uint24(x)) != 0x000102) return 3;",
|
||
"if (c != 3) return false;",
|
||
"if (c)",
|
||
"if (c) {",
|
||
"if (c2 != 2 || c3 != 3) return false;",
|
||
"if (c_0.length != 1) return 1;",
|
||
"if (c_0[0] != \"b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6\") return 2;",
|
||
"if (c_0[0] != true) return 2;",
|
||
"if (c_1.length != 2) return 3;",
|
||
"if (c_1[0].length != 1) return 4;",
|
||
"if (c_1[0][0].length != 1) return 5;",
|
||
"if (c_1[0][0][0].length != 1) return 6;",
|
||
"if (c_1[0][0][0][0].length != 1) return 7;",
|
||
"if (c_1[0][0][0][0][0] != \"036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db0\") return 8;",
|
||
"if (c_1[0][0][0][0][0] != true) return 8;",
|
||
"if (c_1[1].length != 2) return 9;",
|
||
"if (c_1[1][0].length != 1) return 10;",
|
||
"if (c_1[1][0][0].length != 1) return 11;",
|
||
"if (c_1[1][0][0][0].length != 2) return 12;",
|
||
"if (c_1[1][0][0][0][0] != \"f3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3\") return 13;",
|
||
"if (c_1[1][0][0][0][0] != false) return 13;",
|
||
"if (c_1[1][0][0][0][1] != \"6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af\") return 14;",
|
||
"if (c_1[1][0][0][0][1] != true) return 14;",
|
||
"if (c_1[1][1].length != 1) return 15;",
|
||
"if (c_1[1][1][0].length != 1) return 16;",
|
||
"if (c_1[1][1][0][0].length != 1) return 17;",
|
||
"if (c_1[1][1][0][0][0] != \"0175b7a638427703f0dbe7bb9bbf987a2551717b34e79f33b5b1008d1fa01db9\") return 18;",
|
||
"if (c_1[1][1][0][0][0] != true) return 18;",
|
||
"if (clients[addr].lastSupplyID != currentSchellingRound) {",
|
||
"if (clients[msg.sender].lastSupplyID < a) {",
|
||
"if (closingTime - 2 weeks > block.timestamp) {",
|
||
"if (computedHash < proofElement) {",
|
||
"if (cond)",
|
||
"if (condition)",
|
||
"if (confirmations[transactionId][owner])",
|
||
"if (confirmations[transactionId][owners[i]])",
|
||
"if (confirmations[transactionId][owners[i]]) {",
|
||
"if (confirmed || tx.data.length == 0 && isUnderLimit(tx.value)) {",
|
||
"if (cost / ONE * ONE == cost)",
|
||
"if (cost > outcomeTokenCount)",
|
||
"if (count == required)",
|
||
"if (d3 != 3 || d4 != 4) return false;",
|
||
"if (dailyLimit < spentToday)",
|
||
"if (data.a != 2) return 2;",
|
||
"if (data.a != 2) return 5;",
|
||
"if (data.a != 8) return 6;",
|
||
"if (data.a != small.B) return 2;",
|
||
"if (data.a != small.B) return 5;",
|
||
"if (data.a != small.C) return 6;",
|
||
"if (data.b != 0xabcd) return 3;",
|
||
"if (data.b != 0xabcd) return 7;",
|
||
"if (data.b != 0xdcab) return 8;",
|
||
"if (data.b != small.C) return 3;",
|
||
"if (data.b != small.C) return 7;",
|
||
"if (data.b != small.D) return 8;",
|
||
"if (data.c != 0x1234567890) return 4;",
|
||
"if (data.c != 0x1234567890) return 9;",
|
||
"if (data.c != 0x9876543210) return 10;",
|
||
"if (data.c != larger.B) return 10;",
|
||
"if (data.c != larger.D) return 4;",
|
||
"if (data.c != larger.D) return 9;",
|
||
"if (data.length != 1) return true;",
|
||
"if (data.length != i) return 0x1000 + i;",
|
||
"if (data.length != s.length) return 6;",
|
||
"if (data1[0] == \"aa\")",
|
||
"if (data1[0] == \"bb\")",
|
||
"if (data[0] != 0x05) return true;",
|
||
"if (data[1] != 0x04) return true;",
|
||
"if (data[2] != 0x03) return true;",
|
||
"if (data[3] != s[3]) return 7;",
|
||
"if (data[data.length - 1] != bytes1(i)) return i;",
|
||
"if (data[i - 1] != bytes1(i)) return 0x1000000 + i;",
|
||
"if (data[i] != bytes1(i)) return i;",
|
||
"if (diff != 0)",
|
||
"if (doDB[doHash].length >= ownersForChange()) {",
|
||
"if (e1 != 1 || e3 != 3 || e4 != 4) return false;",
|
||
"if (equal) {",
|
||
"if (exponent & 1 == 1)",
|
||
"if (exponent == 0)",
|
||
"if (extra >= 1e12) {",
|
||
"if (false)",
|
||
"if (false) _;",
|
||
"if (false) {",
|
||
"if (flag)",
|
||
"if (flag) c = s;",
|
||
"if (flag) return 2;",
|
||
"if (flag) return f(3);",
|
||
"if (flag) return s;",
|
||
"if (flag) s;",
|
||
"if (g(false) && (b == true)) {}",
|
||
"if (g(false) && g(true)) {}",
|
||
"if (g(false) || b) {}",
|
||
"if (g(true) && b) {}",
|
||
"if (g(true) || (b == false)) {}",
|
||
"if (g(true) || g(false)) {}",
|
||
"if (globalFunds[a].reward > 0 && globalFunds[a].supply > 0) {",
|
||
"if (hash == testHash)",
|
||
"if (i != outcomeTokenIndex)",
|
||
"if (i % 2 == 1) continue;",
|
||
"if (i < parts.length - 1) {",
|
||
"if (i == 5) return;",
|
||
"if (i == outcomeIndex)",
|
||
"if (i > 0) return 0;",
|
||
"if (idx >= 10) break;",
|
||
"if (ilog2 < 0)",
|
||
"if (isConfirmed(transactionId)) {",
|
||
"if (isFrontRunnerPeriodOver())",
|
||
"if (isFueled",
|
||
"if (isOwner[_owners[i]] || _owners[i] == address(0))",
|
||
"if (isOwner[owner])",
|
||
"if (isRightPadded)",
|
||
"if (keccak256(proposedMilestones) != _hashProposals) revert();",
|
||
"if (l != 0x03) return true;",
|
||
"if (l > self._len) {",
|
||
"if (l1 > 0) l2 = x[0].length;",
|
||
"if (l1 > 1) l3 = x[1].length;",
|
||
"if (len != 0)",
|
||
"if (len != 1)",
|
||
"if (len != 20)",
|
||
"if (len == 0) {",
|
||
"if (len > 3)",
|
||
"if (len > 32 || len == 0)",
|
||
"if (length > self._len) {",
|
||
"if (loc != 3) return 9;",
|
||
"if (loc != 8) return 1;",
|
||
"if (marginalPrice > highestMarginalPrice) {",
|
||
"if (maxAmount < amount)",
|
||
"if (memArray.length != arrayData.length) return 10;",
|
||
"if (mid < 0 && x << uint(-mid) < ONE || mid >= 0 && x >> uint(mid) < ONE)",
|
||
"if (milestone.status != MilestoneStatus.AcceptedAndInProgress) revert();",
|
||
"if (milestone.status == MilestoneStatus.AuthorizedForPayment) revert();",
|
||
"if (milestones[i].status != MilestoneStatus.AuthorizedForPayment) {",
|
||
"if (msg.sender != address(this) || !allowedRecipients[_newContract]) return;",
|
||
"if (msg.sender != address(this) || _proposalDeposit > (actualBalance() + rewardToken[address(this)])",
|
||
"if (msg.sender != address(this))",
|
||
"if (msg.sender != curator)",
|
||
"if (msg.sender != owner || (payOwnerOnly && _recipient != owner))",
|
||
"if (msg.sender == MY_ADDRESS) {",
|
||
"if (msg.sender == address(this))",
|
||
"if (msg.sender == owner) _;",
|
||
"if (msg.sender == owner) {",
|
||
"if (msg.value > 0)",
|
||
"if (msg.value > 0) _;",
|
||
"if (mutex > 0) return 7;",
|
||
"if (mutex > 0) {",
|
||
"if (needlelen <= 32) {",
|
||
"if (needlelen <= selflen) {",
|
||
"if (num == 0)",
|
||
"if (num == 1)",
|
||
"if (num == 2)",
|
||
"if (num == 3)",
|
||
"if (nums[i] > max)",
|
||
"if (oracles[i].isOutcomeSet()) {",
|
||
"if (other._len < self._len)",
|
||
"if (outcome < lowerBound)",
|
||
"if (outcomeValidations * 2 > oracles.length) {",
|
||
"if (owners[i] == owner) {",
|
||
"if (p.X == 0 && p.Y == 0)",
|
||
"if (p.amount > actualBalance())",
|
||
"if (p.open && block.timestamp > p.votingDeadline + waitPeriod) {",
|
||
"if (p.open)",
|
||
"if (p.recipient != address(this) && p.recipient != address(rewardAccount)",
|
||
"if (p.splitData[0].newDAO.createTokenProxy{value: fundsToBeMoved}(msg.sender) == false)",
|
||
"if (p.votedYes[msg.sender]",
|
||
"if (p_0 != hex\"ecd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563\") return 1;",
|
||
"if (p_0.m0 != false) return 1;",
|
||
"if (p_0.m1.length != 1) return 2;",
|
||
"if (p_0.m1[0].length != 1) return 3;",
|
||
"if (p_0.m1[0][0] != false) return 4;",
|
||
"if (p_1 != true) return 5;",
|
||
"if (parts.length == 0)",
|
||
"if (ptr <= selfptr)",
|
||
"if (ptr == self._ptr + self._len) {",
|
||
"if (ptr == self._ptr) {",
|
||
"if (ptr >= end)",
|
||
"if (quorum > totalSupply / 5)",
|
||
"if (quorum >= minQuorum(p.amount) && p.yea > p.nay && proposalCheck) {",
|
||
"if (quorum >= minQuorum(p.amount)) {",
|
||
"if (required > owners.length)",
|
||
"if (result >> uint(256 - shift) > 0)",
|
||
"if (returnVal != 0)",
|
||
"if (rewardToken[address(this)] < rewardTokenToBeMoved)",
|
||
"if (round.blockHeight+roundBlockDelay/2 >= block.number) {",
|
||
"if (s.f) {",
|
||
"if (self == 0)",
|
||
"if (self._len < needle._len) {",
|
||
"if (self._len == 0) {",
|
||
"if (self._ptr != needle._ptr) {",
|
||
"if (self._ptr == needle._ptr) {",
|
||
"if (self._unsafe_length == 0)",
|
||
"if (self.flags[value])",
|
||
"if (selfptr != needle._ptr) {",
|
||
"if (selfptr == needle._ptr) {",
|
||
"if (shift >= 0) {",
|
||
"if (spentToday + amount > dailyLimit || spentToday + amount < spentToday)",
|
||
"if (stage == Stages.AuctionStarted && deadline < block.timestamp)",
|
||
"if (success == false || returnCode != 0)",
|
||
"if (success == true)",
|
||
"if (success) {",
|
||
"if (sum >= 500) return sum;",
|
||
"if (temp > 1)",
|
||
"if (totalSupply >= minTokensToCreate && !isFueled) {",
|
||
"if (transactions[transactionId].destination == address(0))",
|
||
"if (transactions[transactionId].executed)",
|
||
"if (transferPaidOut > paidOut[_from])",
|
||
"if (true)",
|
||
"if (true) {",
|
||
"if (true) { revert(); }",
|
||
"if (true) { uint256 x; x = 2; }",
|
||
"if (twice) _;",
|
||
"if (tx.executed)",
|
||
"if (type(int).min == 2**256 - 1) {",
|
||
"if (uint256(self) & 0xff == 0) {",
|
||
"if (uint256(self) & 0xffff == 0) {",
|
||
"if (uint256(self) & 0xffffffff == 0) {",
|
||
"if (uint256(self) & 0xffffffffffffffff == 0) {",
|
||
"if (uint256(self) & 0xffffffffffffffffffffffffffffffff == 0) {",
|
||
"if (validations[i] > outcomeValidations) {",
|
||
"if (verify(input, proof) == 0) {",
|
||
"if (which == 0) return s.x;",
|
||
"if (which == 0) return value1;",
|
||
"if (which == 0) value1 = value;",
|
||
"if (which)",
|
||
"if (x != 0x0102) return 2;",
|
||
"if (x != 1 || y != 2 || z != 3) return false;",
|
||
"if (x != 4) return 2;",
|
||
"if (x != 456 || memBytes.length != s.length || y[2] != 789) return 11;",
|
||
"if (x != bytes32(0)) return false;",
|
||
"if (x != ~bytes32(uint256(1))) return false;",
|
||
"if (x < -818323753292969962227)",
|
||
"if (x < 10)",
|
||
"if (x < 2)",
|
||
"if (x == 0)",
|
||
"if (x == 0) x = 1;",
|
||
"if (x == 1)",
|
||
"if (x == 1) {}",
|
||
"if (x == 10)",
|
||
"if (x == 2)",
|
||
"if (x == 7)",
|
||
"if (x > 0)",
|
||
"if (x > 0) g();",
|
||
"if (x > 10)",
|
||
"if (x > 10) return x + 10;",
|
||
"if (x > 10) {",
|
||
"if (x > 7)",
|
||
"if (x >= 0) {",
|
||
"if (x >= 0) { revert(); }",
|
||
"if (x >= 10) { if (x < 10) { revert(); } }",
|
||
"if (x >= 1000) {",
|
||
"if (x) f(b1, c);",
|
||
"if (x) {",
|
||
"if (x1 != 1 || y1.x != 7 || z1 != 2) return false;",
|
||
"if (x2 != 1) return false;",
|
||
"if (x[0] == \"bb\")",
|
||
"if (x[0] == \"cc\")",
|
||
"if (y != 1)",
|
||
"if (y == 1)",
|
||
"if (y > 0)",
|
||
"if (y > 1) {",
|
||
"if (y > x) f();",
|
||
"if (y) {",
|
||
"if (y.length != 9) return 3;",
|
||
"if (y2.x != 7) return false;",
|
||
"if (y[2] != 5) return 4;",
|
||
"if (y[7] != 4) return 5;",
|
||
"if (z2 != 2) return false;",
|
||
"if eq(i, 6) { break }",
|
||
"if eq(mod(i, 2), 0) { continue }",
|
||
"if eq(x, 0) { i := 2 break }",
|
||
"if eq(x, 1) { continue }",
|
||
"if eq(x, 2) { break }",
|
||
"if eq(x, 4) { continue }",
|
||
"if eq(x, 4) { i := 90 }",
|
||
"if flag { c.slot := s.slot }",
|
||
"if gt(a, 1) {",
|
||
"if iszero(eq(sload(pos), 0)) {",
|
||
"if( callCallback ) {",
|
||
"if( fee ) {",
|
||
"if(!_validate(item))",
|
||
"if(!isData(self))",
|
||
"if(!isList(self))",
|
||
"if(_itemLength(item._unsafe_memPtr) != len)",
|
||
"if(_payloadOffset(item) > len)",
|
||
"if(_toMembers) {",
|
||
"if(a) { c = true; } else { reset(); }",
|
||
"if(a.length != b.length)",
|
||
"if(b) { f = true; } else { reset(); }",
|
||
"if(b0 < DATA_LONG_START || (b0 >= LIST_SHORT_START && b0 < LIST_LONG_START))",
|
||
"if(b0 < DATA_SHORT_START)",
|
||
"if(b0 < LIST_SHORT_START)",
|
||
"if(b0 == DATA_SHORT_START + 1 && b1 < DATA_SHORT_START)",
|
||
"if(c) { b = true; } else { reset(); }",
|
||
"if(d) { e = true; } else { reset(); }",
|
||
"if(e) { a = true; } else { reset(); }",
|
||
"if(hasNext(self)) {",
|
||
"if(isNull(self))",
|
||
"if(self._unsafe_length == 0)",
|
||
"if(shortest < 32) {",
|
||
"if(strict && !_validate(subItem))",
|
||
"if(strict) {",
|
||
"if(true){",
|
||
"if(x == 0) x = 0; ",
|
||
"if(x)",
|
||
"if(x) {",
|
||
"import \"\";",
|
||
"import \"../../.././a\" as x; contract B is x.A { fallback() external { x.A r = x.A(20); r; } }",
|
||
"import \"../../.././a\"; contract B is A {}",
|
||
"import \"../Events/CategoricalEvent.sol\";",
|
||
"import \"../Events/Event.sol\";",
|
||
"import \"../Events/EventFactory.sol\";",
|
||
"import \"../Events/ScalarEvent.sol\";",
|
||
"import \"../MarketMakers/MarketMaker.sol\";",
|
||
"import \"../Markets/Campaign.sol\";",
|
||
"import \"../Markets/Market.sol\";",
|
||
"import \"../Markets/MarketFactory.sol\";",
|
||
"import \"../Markets/StandardMarket.sol\";",
|
||
"import \"../Markets/StandardMarketFactory.sol\";",
|
||
"import \"../Oracles/CentralizedOracle.sol\";",
|
||
"import \"../Oracles/DifficultyOracle.sol\";",
|
||
"import \"../Oracles/FutarchyOracle.sol\";",
|
||
"import \"../Oracles/MajorityOracle.sol\";",
|
||
"import \"../Oracles/Oracle.sol\";",
|
||
"import \"../Oracles/SignedMessageOracle.sol\";",
|
||
"import \"../Oracles/UltimateOracle.sol\";",
|
||
"import \"../Tokens/OutcomeToken.sol\";",
|
||
"import \"../Tokens/StandardToken.sol\";",
|
||
"import \"../Tokens/Token.sol\";",
|
||
"import \"../Utils/Math.sol\";",
|
||
"import \"../a\"; contract C is A {}==== Source: a ====",
|
||
"import \"./A.sol\";",
|
||
"import \"./B.sol\";",
|
||
"import \"./ManagedAccount.sol\";",
|
||
"import \"./Token.sol\";",
|
||
"import \"./TokenCreation.sol\";",
|
||
"import \"./announcementTypes.sol\";",
|
||
"import \"./dir/b\"; contract A is B {}",
|
||
"import \"./ico.sol\";",
|
||
"import \"./module.sol\";",
|
||
"import \"./moduleHandler.sol\";",
|
||
"import \"./multiOwner.sol\";",
|
||
"import \"./owned.sol\";",
|
||
"import \"./premium.sol\";",
|
||
"import \"./provider.sol\";",
|
||
"import \"./publisher.sol\";",
|
||
"import \"./safeMath.sol\";",
|
||
"import \"./schelling.sol\";",
|
||
"import \"./token.sol\";",
|
||
"import \"./tokenDB.sol\";",
|
||
"import \".b.sol\"; contract A is B {}",
|
||
"import \"A\" as A;",
|
||
"import \"A\";",
|
||
"import \"Factory.sol\";",
|
||
"import \"MultiSigWallet.sol\";",
|
||
"import \"MultiSigWalletWithDailyLimit.sol\";",
|
||
"import \"RLP.sol\";",
|
||
"import \"a\" as A;",
|
||
"import \"a\" as A; contract A {}",
|
||
"import \"a\" as x; import {B as b, C as c, C} from \"a\";",
|
||
"import \"a\";",
|
||
"import \"a\"; contract A {}",
|
||
"import \"a\"; contract D is C {}",
|
||
"import \"a\"; contract D is C {}==== Source: a ====",
|
||
"import \"a\"; contract D { C c; }",
|
||
"import \"a.sol\";",
|
||
"import \"b\" as B;",
|
||
"import \"b\";",
|
||
"import \"b\"; contract C { D d; }",
|
||
"import \"hello\";",
|
||
"import \"i0.sol\" as I0;",
|
||
"import \"i0.sol\";",
|
||
"import \"i1.sol\" as I1;",
|
||
"import * as msg from \"B.sol\";",
|
||
"import function;",
|
||
"import {A as b} from \"a\";",
|
||
"import {A as b} from \"a\"; contract b {}",
|
||
"import {A} from \"./a\"; import {A} from \"./b\";",
|
||
"import {A} from \"a\";",
|
||
"import {A} from \"a\"; contract A {}",
|
||
"import {A} from \"a\"; contract B {}",
|
||
"import {C as msg} from \"B.sol\";",
|
||
"import {C} from \"a\";",
|
||
"import {hello, world} from \"hello\";",
|
||
"import {hello, world} from function;",
|
||
"import {hello, world};",
|
||
"import {msg, block} from \"B.sol\";",
|
||
"info = providers[addr].data[height].info;",
|
||
"init = f(array[i], init);",
|
||
"initX();",
|
||
"initial = double(2);",
|
||
"inner.recursive[0].z = inner.recursive[1].z + 1;",
|
||
"inner.z = 3;",
|
||
"inplaceDecoded := eq(arr1, add(buf, 0x60))",
|
||
"input.pop();",
|
||
"input.push();",
|
||
"input[0] = 0x11;",
|
||
"input[0] = 13986731495506593864492662381614386532349950841221768152838255933892789078521;",
|
||
"input[0] = p.X;",
|
||
"input[0] = p1.X;",
|
||
"input[1] = 0x22;",
|
||
"input[1] = 622860516154313070522697309645122400675542217310916019527100517240519630053;",
|
||
"input[1] = p.Y;",
|
||
"input[1] = p1.Y;",
|
||
"input[2] = 11094488463398718754251685950409355128550342438297986977413505294941943071569;",
|
||
"input[2] = p2.X;",
|
||
"input[2] = s;",
|
||
"input[3] = 6627643779954497813586310325594578844876646808666478625705401786271515864467;",
|
||
"input[3] = p2.Y;",
|
||
"input[4] = 2957286918163151606545409668133310005545945782087581890025685458369200827463;",
|
||
"input[5] = 1384290496819542862903939282897996566903332587607290986044945365745128311081;",
|
||
"input[6] = 5613571677741714971687805233468747950848449704454346829971683826953541367271;",
|
||
"input[7] = 9643208548031422463313148630985736896287522941726746581856185889848792022807;",
|
||
"input[8] = 18066496933330839731877828156604;",
|
||
"input[i * 6 + 0] = p1[i].X;",
|
||
"input[i * 6 + 1] = p1[i].Y;",
|
||
"input[i * 6 + 2] = p2[i].X[0];",
|
||
"input[i * 6 + 3] = p2[i].X[1];",
|
||
"input[i * 6 + 4] = p2[i].Y[0];",
|
||
"input[i * 6 + 5] = p2[i].Y[1];",
|
||
"instantiations[msg.sender].push(instantiation);",
|
||
"int YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY = YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY;",
|
||
"int YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY = YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY;",
|
||
"int _lowerBound,",
|
||
"int _outcome = oracles[i].getOutcome();",
|
||
"int _upperBound",
|
||
"int a = 3;",
|
||
"int a;",
|
||
"int b = -2 ** x;",
|
||
"int b = a;",
|
||
"int b;",
|
||
"int constant EXP_LIMIT = 2352680790717288641401;",
|
||
"int constant c = 0 + 1;",
|
||
"int constant c = 1;",
|
||
"int costLevelAfter = calcCostLevel(logN, netOutcomeTokensSold, funding);",
|
||
"int costLevelBefore = calcCostLevel(logN, netOutcomeTokensSold, funding);",
|
||
"int dummy;",
|
||
"int halflnz = term;",
|
||
"int hi = 193;",
|
||
"int ilog2 = floorLog2(x);",
|
||
"int immutable a;",
|
||
"int int10abc = 4;",
|
||
"int intMax = type(int).max;",
|
||
"int intMin = type(int).min;",
|
||
"int int_max = type(int).max;",
|
||
"int int_min = type(int).min;",
|
||
"int logN = Math.ln(netOutcomeTokensSold.length * ONE);",
|
||
"int lowerBound,",
|
||
"int max = type(int).max;",
|
||
"int maxQuantity = Math.max(netOutcomeTokensSold);",
|
||
"int mid = (hi + lo) >> 1;",
|
||
"int min = type(int).min;",
|
||
"int o;",
|
||
"int override f;",
|
||
"int payable c;",
|
||
"int public forwardedOutcome;",
|
||
"int public frontRunner;",
|
||
"int public lowerBound;",
|
||
"int public outcome;",
|
||
"int public override override testvar;",
|
||
"int public override testvar;",
|
||
"int public override() testvar;",
|
||
"int public override(A,) testvar;",
|
||
"int public testvar;",
|
||
"int public upperBound;",
|
||
"int shift;",
|
||
"int term = (z - int(ONE)) * int(ONE) / (z + int(ONE));",
|
||
"int termpow = term * term / int(ONE) * term / int(ONE);",
|
||
"int upperBound",
|
||
"int upperBound,",
|
||
"int x = +(0, 0);",
|
||
"int x = --(,);",
|
||
"int x = delete (,0);",
|
||
"int x = ~(0,);",
|
||
"int x;",
|
||
"int y = -(0, 0);",
|
||
"int y;",
|
||
"int z1 = x % y;",
|
||
"int z2 = x % -y;",
|
||
"int z;",
|
||
"int(x);",
|
||
"int, uint, bytes14) {",
|
||
"int104 int104_max = type(int104).max;",
|
||
"int104 int104_min = type(int104).min;",
|
||
"int112 int112_max = type(int112).max;",
|
||
"int112 int112_min = type(int112).min;",
|
||
"int120 int120_max = type(int120).max;",
|
||
"int120 int120_min = type(int120).min;",
|
||
"int128 int128_max = type(int128).max;",
|
||
"int128 int128_min = type(int128).min;",
|
||
"int128 x = 0;",
|
||
"int136 int136_max = type(int136).max;",
|
||
"int136 int136_min = type(int136).min;",
|
||
"int144 int144_max = type(int144).max;",
|
||
"int144 int144_min = type(int144).min;",
|
||
"int152 int152_max = type(int152).max;",
|
||
"int152 int152_min = type(int152).min;",
|
||
"int16 int16_max = type(int16).max;",
|
||
"int16 int16_min = type(int16).min;",
|
||
"int16 public q = 250;",
|
||
"int16 x = 0;",
|
||
"int16 z;",
|
||
"int160 int160_max = type(int160).max;",
|
||
"int160 int160_min = type(int160).min;",
|
||
"int168 int168_max = type(int168).max;",
|
||
"int168 int168_min = type(int168).min;",
|
||
"int16[2] public y = [-5, -6];",
|
||
"int16[] inner;",
|
||
"int16[] public x = [-1, -2];",
|
||
"int16[] x;",
|
||
"int176 int176_max = type(int176).max;",
|
||
"int176 int176_min = type(int176).min;",
|
||
"int184 int184_max = type(int184).max;",
|
||
"int184 int184_min = type(int184).min;",
|
||
"int192 int192_max = type(int192).max;",
|
||
"int192 int192_min = type(int192).min;",
|
||
"int200 int200_max = type(int200).max;",
|
||
"int200 int200_min = type(int200).min;",
|
||
"int208 int208_max = type(int208).max;",
|
||
"int208 int208_min = type(int208).min;",
|
||
"int216 int216_max = type(int216).max;",
|
||
"int216 int216_min = type(int216).min;",
|
||
"int224 int224_max = type(int224).max;",
|
||
"int224 int224_min = type(int224).min;",
|
||
"int232 int232_max = type(int232).max;",
|
||
"int232 int232_min = type(int232).min;",
|
||
"int24 int24_max = type(int24).max;",
|
||
"int24 int24_min = type(int24).min;",
|
||
"int240 int240_max = type(int240).max;",
|
||
"int240 int240_min = type(int240).min;",
|
||
"int248 int248_max = type(int248).max;",
|
||
"int248 int248_min = type(int248).min;",
|
||
"int256 Stuff;",
|
||
"int256 Things;",
|
||
"int256 int256_max = type(int256).max;",
|
||
"int256 int256_min = type(int256).min;",
|
||
"int256 mutex;",
|
||
"int256 payable d;",
|
||
"int256 public a = -0x42 << 8;",
|
||
"int256 public a = -0x4200 >> 8;",
|
||
"int256 x = -2**255;",
|
||
"int256 x = -7;",
|
||
"int32 int32_max = type(int32).max;",
|
||
"int32 int32_min = type(int32).min;",
|
||
"int32 x = -3;",
|
||
"int32 x = 0;",
|
||
"int32 x = int32(m[0]);",
|
||
"int40 int40_max = type(int40).max;",
|
||
"int40 int40_min = type(int40).min;",
|
||
"int48 int48_max = type(int48).max;",
|
||
"int48 int48_min = type(int48).min;",
|
||
"int56 int56_max = type(int56).max;",
|
||
"int56 int56_min = type(int56).min;",
|
||
"int64 b = 4;",
|
||
"int64 int64_max = type(int64).max;",
|
||
"int64 int64_min = type(int64).min;",
|
||
"int64 x = 0;",
|
||
"int72 int72_max = type(int72).max;",
|
||
"int72 int72_min = type(int72).min;",
|
||
"int8 a;",
|
||
"int8 c;",
|
||
"int8 int8_max = type(int8).max;",
|
||
"int8 int8_min = type(int8).min;",
|
||
"int8 public i = -128;",
|
||
"int8 public i = -129;",
|
||
"int8 public j = 127;",
|
||
"int8 public j = 128;",
|
||
"int8 public x = 2;",
|
||
"int8 public y = 127;",
|
||
"int8 x = 0;",
|
||
"int8 x = 1;",
|
||
"int8 x = int8(s.m[0]);",
|
||
"int8 x;",
|
||
"int8 y = 0;",
|
||
"int8 y = 1;",
|
||
"int8 y = x * 2;",
|
||
"int8 y = x + 1;",
|
||
"int8 y = x - 127;",
|
||
"int8 z = x & y;",
|
||
"int80 int80_max = type(int80).max;",
|
||
"int80 int80_min = type(int80).min;",
|
||
"int88 int88_max = type(int88).max;",
|
||
"int88 int88_min = type(int88).min;",
|
||
"int8[2] memory t = [-3, -4];",
|
||
"int8[5] memory foo3 = [int8(1), -1, 0, 0, 0];",
|
||
"int8[] memory t = new int8[](2);",
|
||
"int96 int96_max = type(int96).max;",
|
||
"int96 int96_min = type(int96).min;",
|
||
"intM should = 4;",
|
||
"intM; bytesM;",
|
||
"intMax;",
|
||
"intMin;",
|
||
"int[0] a;",
|
||
"int[10] x;",
|
||
"int[1] c;",
|
||
"int[1][20] c;",
|
||
"int[3*1] x;",
|
||
"int[3] d;",
|
||
"int[] a;",
|
||
"int[] b;",
|
||
"int[] memory b;",
|
||
"int[] memory netOutcomeTokensSold = getNetOutcomeTokensSold(market);",
|
||
"int[] memory outcomes = new int[](oracles.length);",
|
||
"int[] public netOutcomeTokensSold;",
|
||
"int[] storage a = x;",
|
||
"int[] x;",
|
||
"int[] y;",
|
||
"int[](x);",
|
||
"int[][] array2d;",
|
||
"int[][] data;",
|
||
"int[][][] array2d;",
|
||
"interest = rightForInterest(providers[provAddr].data[provHeight].supply[a], providers[provAddr].data[provHeight].priv);",
|
||
"interest = rightForInterest(providers[provAddr].data[provHeight].supply[providers[provAddr].data[provHeight].lastSupplyID], providers[provAddr].data[provHeight].priv);",
|
||
"interestDB[addr][_num].amount = balance;",
|
||
"interestDB[addr][_num].empty = true;",
|
||
"interestDB[genesisAddr[a]][0].amount = genesisValue[a];",
|
||
"interest_s memory _idb;",
|
||
"interface A {",
|
||
"interface A {}",
|
||
"interface B {",
|
||
"interface B { }",
|
||
"interface B {}",
|
||
"interface Banana {",
|
||
"interface CPure {",
|
||
"interface CView {",
|
||
"interface D {",
|
||
"interface ERC165 {",
|
||
"interface ERC20 { function x() external returns (uint); }",
|
||
"interface HelloWorld {",
|
||
"interface HelloWorldDerived is HelloWorld {",
|
||
"interface HelloWorldWithEvent {",
|
||
"interface I is A {",
|
||
"interface I is C {}",
|
||
"interface I {",
|
||
"interface I {}",
|
||
"interface Interface {",
|
||
"interface J {",
|
||
"interface Parent {",
|
||
"interface ParentA {",
|
||
"interface ParentA {}",
|
||
"interface ParentB {",
|
||
"interface ParentB {}",
|
||
"interface Simpson {",
|
||
"interface Sub is ParentA, ParentB {",
|
||
"interface Sub is ParentA, ParentB {}",
|
||
"interface Sub is Super {",
|
||
"interface Sub is Super {}",
|
||
"interface Sub is SuperA, SuperB {",
|
||
"interface SubA is Parent {",
|
||
"interface SubA is Parent {}",
|
||
"interface SubB is Parent {",
|
||
"interface SubB is Parent {}",
|
||
"interface Super {",
|
||
"interface SuperA {",
|
||
"interface SuperB {",
|
||
"interface X { function test() external returns (uint256); }",
|
||
"interfaceID == type(ERC165).interfaceId ||",
|
||
"interfaceID == type(Simpson).interfaceId;",
|
||
"internal",
|
||
"inv = internal1 != invalid;",
|
||
"inv = internal1 == invalid;",
|
||
"invalid()",
|
||
"invalid();",
|
||
"invalidEncoding[i+4] = argumentEncoding[i];",
|
||
"invalidLength = invalidLengthFuzz % (argumentEncoding.length - 31);",
|
||
"invalidLength = invalidLengthFuzz % argumentEncoding.length;",
|
||
"invalidLengthFuzz,",
|
||
"ipfsHash = _ipfsHash;",
|
||
"isCreator",
|
||
"isEventContract",
|
||
"isForRent = providers[addr].data[height].isForRent;",
|
||
"isFueled = true;",
|
||
"isICO = ! forReplace;",
|
||
"isICO = false;",
|
||
"isICO = true;",
|
||
"isInstantiation[instantiation] = true;",
|
||
"isOutcomeSet = true;",
|
||
"isOwner",
|
||
"isOwner[_owners[i]] = true;",
|
||
"isOwner[newOwner] = true;",
|
||
"isOwner[owner] = false;",
|
||
"isOwner[owner] = true;",
|
||
"isRightPadded",
|
||
"isSet = true;",
|
||
"isSigner",
|
||
"it under the terms of the GNU General Public License as published by",
|
||
"it under the terms of the GNU lesser General Public License as published by",
|
||
"it._unsafe_item = self;",
|
||
"it._unsafe_nextPtr = ptr;",
|
||
"itms++;",
|
||
"j = newJ;",
|
||
"jump(2)",
|
||
"jumpdest()",
|
||
"jumpi(2, 1)",
|
||
"k",
|
||
"k := add(k, 1)",
|
||
"k = k - i;",
|
||
"k = newK;",
|
||
"k()",
|
||
"k1()();",
|
||
"keccak256.gas();",
|
||
"keccak256.value();",
|
||
"l = 1;",
|
||
"l = 2;",
|
||
"l = 3;",
|
||
"l = 4;",
|
||
"l = _data.length;",
|
||
"l = data.length;",
|
||
"l = m.length;",
|
||
"l = s.length;",
|
||
"l1 = data.length;",
|
||
"l1 = x.length;",
|
||
"l2 = ids.length;",
|
||
"label:",
|
||
"large = small;",
|
||
"larger c;",
|
||
"larger d;",
|
||
"lastDay = block.timestamp;",
|
||
"lastTimeMinQuorumMet = block.timestamp;",
|
||
"last_completed_migration = completed;",
|
||
"leave",
|
||
"len = 1;",
|
||
"len = b0 - DATA_SHORT_START + 1;",
|
||
"len = b0 - LIST_SHORT_START + 1;",
|
||
"len = self._unsafe_length - 1 - bLen;",
|
||
"len = self._unsafe_length - 1;",
|
||
"length += parts[i]._len;",
|
||
"length = 1;",
|
||
"length = 2;",
|
||
"length = 3;",
|
||
"length = 4;",
|
||
"let A := 1",
|
||
"let C := 1",
|
||
"let D.a := 1",
|
||
"let a := 1",
|
||
"let a := x",
|
||
"let a, .a, aa.b := f()",
|
||
"let a, sub, mov := g()",
|
||
"let a. := 2",
|
||
"let a., aa.b := f()",
|
||
"let a.. := 2",
|
||
"let a..b := 2",
|
||
"let a.b := 2",
|
||
"let a1, b1, c1",
|
||
"let a1, b1, c1 := asmfun(1, 2, 3)",
|
||
"let a1, b1, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1, n1, o1, p1 := fun()",
|
||
"let a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2 := fun()",
|
||
"let abc := sub(10, a)",
|
||
"let b := 1",
|
||
"let b := 3",
|
||
"let b := 42",
|
||
"let b.a := 4",
|
||
"let c1 := x",
|
||
"let c2 := b",
|
||
"let c3 := s",
|
||
"let d := 0x10",
|
||
"let d:= 0x10",
|
||
"let destpart := and(mload(dest), mask)",
|
||
"let f := 0",
|
||
"let f := 1",
|
||
"let freeMem := mload(0x40)",
|
||
"let i := a",
|
||
"let i := n",
|
||
"let length := mload(needle)",
|
||
"let localVar := 10",
|
||
"let mod := 2",
|
||
"let needleptr := mload(add(needle, 0x20))",
|
||
"let offset := mul(i, 0x20)",
|
||
"let pos := add(keccak256(0, 0x20), i)",
|
||
"let ptr := mload(0x40)",
|
||
"let r := x.offset",
|
||
"let rOffset := btsPtr",
|
||
"let s := returndatasize()",
|
||
"let selfptr := mload(add(self, 0x20))",
|
||
"let size := codesize()",
|
||
"let srcpart := and(mload(src), not(mask))",
|
||
"let t := c",
|
||
"let wOffset := add(tgt, 0x20)",
|
||
"let words := div(add(btsLen, 31), 32)",
|
||
"let x",
|
||
"let x : = mload(0)",
|
||
"let x := two_stack_slots",
|
||
"let x := .offset",
|
||
"let x := .slot",
|
||
"let x := 0100",
|
||
"let x := 1",
|
||
"let x := C",
|
||
"let x := L",
|
||
"let x := b",
|
||
"let x := bytesAsCalldata",
|
||
"let x := calldataload(0)",
|
||
"let x := f",
|
||
"let x := f.slot",
|
||
"let x := hex\"0011\"",
|
||
"let x := mload(0)",
|
||
"let x := msize()",
|
||
"let x := super",
|
||
"let x, y ,z : = g()",
|
||
"let x,y,z",
|
||
"let x.offset := 1",
|
||
"let x.slot := 1",
|
||
"let xyz := 20",
|
||
"let y := x",
|
||
"let y, z",
|
||
"let z3 := 1",
|
||
"library A {",
|
||
"library A {}",
|
||
"library Arst {",
|
||
"library B {",
|
||
"library C {",
|
||
"library D {",
|
||
"library D { function double(bytes32 self) public returns (uint) { return 2; } }",
|
||
"library D { function double(uint self) internal pure returns (uint) { return 2*self; } }",
|
||
"library D { function double(uint self) public pure returns (uint) { return 2*self; } }",
|
||
"library D { function double(uint self) public returns (uint) { return 2*self; } }",
|
||
"library D { function double(uint self) public returns (uint) { return 2; } }",
|
||
"library D { function f(bytes calldata) internal pure {} }",
|
||
"library D { struct s { uint a; } function mul(s storage self, uint x) public returns (uint) { return self.a *= x; } }",
|
||
"library D { }",
|
||
"library L",
|
||
"library L {",
|
||
"library L { function l() public {} }",
|
||
"library L {}",
|
||
"library L {} contract C { using L for uint; }",
|
||
"library L1 {",
|
||
"library L2 {",
|
||
"library Lib is Test {}",
|
||
"library Lib {",
|
||
"library Lib { uint constant x = 9; }",
|
||
"library Lib { uint x; }",
|
||
"library Lib {}",
|
||
"library L{ constructor() { L.x; } }",
|
||
"library Math {",
|
||
"library MerkleProof {",
|
||
"library Pairing {",
|
||
"library RLP {",
|
||
"library Set {",
|
||
"library Test {",
|
||
"library Utils {",
|
||
"library VoteTiming {",
|
||
"library WithModifier {",
|
||
"library X { }",
|
||
"library c {",
|
||
"library l1 {",
|
||
"library strings {",
|
||
"library test {",
|
||
"linkersymbol(\"contract/library.sol:L\")",
|
||
"list = new RLPItem[](numItems);",
|
||
"list[idx] = next(it);",
|
||
"lo = -64;",
|
||
"lo = mid;",
|
||
"loadimmutable(\"abc\")",
|
||
"lock = false;",
|
||
"lock = true;",
|
||
"long; short;",
|
||
"lowerBound = _lowerBound;",
|
||
"lowerBound,",
|
||
"lv_1 = true;",
|
||
"m &= m;",
|
||
"m = m2;",
|
||
"m = new address payable[](10);",
|
||
"m(1) = 2;",
|
||
"m.a = \"hello\";",
|
||
"m.b = \"world\";",
|
||
"m.push();",
|
||
"m.x = 0xbbbb;",
|
||
"m.y = 0xcccc;",
|
||
"m1[k] = v;",
|
||
"m2[k1][k2] = v;",
|
||
"m[0] = 42;",
|
||
"m[0][0] = new uint256[](1);",
|
||
"m[0][0] = new uint8[](1);",
|
||
"m[0][0][0] = 0x00042;",
|
||
"m[0][0][0] = 42;",
|
||
"m[0][0][1] = 0x00142;",
|
||
"m[0][1] = new uint256[](1);",
|
||
"m[0][1][0] = 42;",
|
||
"m[0][key] = value1;",
|
||
"m[1] = 23;",
|
||
"m[1] = 42;",
|
||
"m[1].push().a = 1;",
|
||
"m[1].push().a = 3;",
|
||
"m[1][0].a = 1;",
|
||
"m[1][0].b = 2;",
|
||
"m[1][0][0] = 0x10042;",
|
||
"m[1][0][1] = 0x10142;",
|
||
"m[1][1].a = 3;",
|
||
"m[1][1].b = 4;",
|
||
"m[1][key] = value2;",
|
||
"m[2] = 17;",
|
||
"m[2] = 21;",
|
||
"m[2] = v;",
|
||
"m[] = 3;",
|
||
"m[_a] = 7;",
|
||
"m[c] = address(0);",
|
||
"m[key] = value;",
|
||
"m_a *= m_a;",
|
||
"m_a = a;",
|
||
"m_b = 6;",
|
||
"m_b = new B(this);",
|
||
"m_b.b(this).a();",
|
||
"m_c = 8;",
|
||
"m_c = other_c;",
|
||
"m_c.f();",
|
||
"m_i = i;",
|
||
"m_i = j;",
|
||
"m_x = d;",
|
||
"m_x.a[0] = 5;",
|
||
"m_x.a[1] = 6;",
|
||
"m_x.s.x = 2;",
|
||
"m_x.s.y = 3;",
|
||
"m_x.s.z = 4;",
|
||
"m_x.x = 1;",
|
||
"majorityOracle = new MajorityOracle(oracles);",
|
||
"map = a;",
|
||
"map[0] = 0;",
|
||
"map[0] = 2;",
|
||
"map[0] = 42;",
|
||
"map[0].length = 4;",
|
||
"map[13][14] = 42;",
|
||
"map[13][14][15] = 42;",
|
||
"map[1] = 111;",
|
||
"map[1] = 112;",
|
||
"map[2] = 3;",
|
||
"map[2] = x;",
|
||
"map[42] = 0x24;",
|
||
"map[66] = 0x66;",
|
||
"map[index] = value;",
|
||
"map[p] *= map[p] + x;",
|
||
"map[p] += map[p] + x;",
|
||
"map[p] -= map[p] - x;",
|
||
"map[p] /= map[p] / x;",
|
||
"map[p] = 100;",
|
||
"map[p] = 10;",
|
||
"map[p] = 200;",
|
||
"map[s] = 0;",
|
||
"map[s] = x;",
|
||
"map[s];",
|
||
"map[x] = 2;",
|
||
"map[x] = 5;",
|
||
"map[x] = x;",
|
||
"mapping ( string => uint24 ) [ 1 ] memory val ;",
|
||
"mapping ( uint => address payable ) c ;",
|
||
"mapping ( uint => address payable [ ] ) d ;",
|
||
"mapping (address => affiliate_s) public affiliate;",
|
||
"mapping (address => bool) public allowedRecipients;",
|
||
"mapping (address => bool) public isOwner;",
|
||
"mapping (address => bool) public never_used;",
|
||
"mapping (address => bool) votedNo;",
|
||
"mapping (address => bool) votedYes;",
|
||
"mapping (address => brought_s) public brought;",
|
||
"mapping (address => function() external) b;",
|
||
"mapping (address => function() external[]) c;",
|
||
"mapping (address => function() internal returns (uint)) a;",
|
||
"mapping (address => mapping (address => uint)) allowances;",
|
||
"mapping (address => mapping (address => uint256)) allowed;",
|
||
"mapping (address => mapping (address => uint256)) private _allowances;",
|
||
"mapping (address => mapping (int => uint)) public outcomeAmounts;",
|
||
"mapping (address => mapping(uint256 => interest_s)) public interestDB;",
|
||
"mapping (address => uint balances; ",
|
||
"mapping (address => uint) balances;",
|
||
"mapping (address => uint) map;",
|
||
"mapping (address => uint) public DAOpaidOut;",
|
||
"mapping (address => uint) public blocked;",
|
||
"mapping (address => uint) public contributions;",
|
||
"mapping (address => uint) public paidOut;",
|
||
"mapping (address => uint) public rewardToken;",
|
||
"mapping (address => uint256) balances;",
|
||
"mapping (address => uint256) private _balances;",
|
||
"mapping (address => uint256) public balanceOf;",
|
||
"mapping (address => uint256) weiGiven;",
|
||
"mapping (address => uint256[]) public opponents;",
|
||
"mapping (bool => bool) map;",
|
||
"mapping (bytes32 => CategoricalEvent) public categoricalEvents;",
|
||
"mapping (bytes32 => ScalarEvent) public scalarEvents;",
|
||
"mapping (int => uint) public totalOutcomeAmounts;",
|
||
"mapping (string => uint) map;",
|
||
"mapping (uint => S) map;",
|
||
"mapping (uint => S) smap;",
|
||
"mapping (uint => Transaction) public transactions;",
|
||
"mapping (uint => address payable [ ]) public a = a ;",
|
||
"mapping (uint => bool) map;",
|
||
"mapping (uint => bool) nestedMapping;",
|
||
"mapping (uint => int) storage c = a;",
|
||
"mapping (uint => mapping (address => bool)) public confirmations;",
|
||
"mapping (uint => mapping (uint => mapping (uint => uint))) map;",
|
||
"mapping (uint => mapping (uint => uint)) map;",
|
||
"mapping (uint => uint) a;",
|
||
"mapping (uint => uint) b = a;",
|
||
"mapping (uint => uint) b = x;",
|
||
"mapping (uint => uint) b;",
|
||
"mapping (uint => uint) k;",
|
||
"mapping (uint => uint) m;",
|
||
"mapping (uint => uint) map;",
|
||
"mapping (uint => uint) s;",
|
||
"mapping (uint => uint) singleMap;",
|
||
"mapping (uint => uint) storage c = a;",
|
||
"mapping (uint => uint) storage c = b;",
|
||
"mapping (uint => uint) storage localMap = map;",
|
||
"mapping (uint => uint) storage map = storageMap;",
|
||
"mapping (uint => uint) storageMap;",
|
||
"mapping (uint => uint) topMapping;",
|
||
"mapping (uint => uint)[2] severalMaps;",
|
||
"mapping (uint => uint)[2][2] severalMaps3d;",
|
||
"mapping (uint => uint)[] a;",
|
||
"mapping (uint => uint)[] severalMaps;",
|
||
"mapping (uint => uint)[] storage b = a[a.length - 1];",
|
||
"mapping (uint => uint)[][] a;",
|
||
"mapping (uint => uint)[][] severalMaps3d;",
|
||
"mapping (uint => uint8)[2] severalMaps8;",
|
||
"mapping (uint => uint8)[] severalMaps8;",
|
||
"mapping (uint => uint[]) map;",
|
||
"mapping (uint => uint[][]) map;",
|
||
"mapping (uint64 => mapping (bytes32 => uint)) complex_mapping;",
|
||
"mapping(A => uint8) public table;",
|
||
"mapping(A => uint8) table;",
|
||
"mapping(C => bool) a;",
|
||
"mapping(E => bool) c;",
|
||
"mapping(E => bool) e;",
|
||
"mapping(E => uint8) public table;",
|
||
"mapping(E => uint8) table;",
|
||
"mapping(I => bool) i;",
|
||
"mapping(J => bool) j;",
|
||
"mapping(S => uint) a;",
|
||
"mapping(S => uint) data;",
|
||
"mapping(address => S) public override f;",
|
||
"mapping(address => _client) private clients;",
|
||
"mapping(address => _providers) private providers;",
|
||
"mapping(address => _voter) private voter;",
|
||
"mapping(address => address payable) public m;",
|
||
"mapping(address => address[]) public instantiations;",
|
||
"mapping(address => bool) allowedUsers;",
|
||
"mapping(address => bool) b;",
|
||
"mapping(address => bool) public genesis;",
|
||
"mapping(address => bool) public isInstantiation;",
|
||
"mapping(address => bool) public owners;",
|
||
"mapping(address => bytes32) names;",
|
||
"mapping(address => function() internal) stages;",
|
||
"mapping(address => mapping(address => allowance_s)) public allowance;",
|
||
"mapping(address => uint) public override balanceOf;",
|
||
"mapping(address => uint256) private funds;",
|
||
"mapping(address payable => uint) m;",
|
||
"mapping(bytes32 => address[]) public doDB;",
|
||
"mapping(bytes32 => test_struct) self_reference;",
|
||
"mapping(bytes4 => bool) internal supportedInterfaces;",
|
||
"mapping(int => int) a;",
|
||
"mapping(string => uint) data;",
|
||
"mapping(string => uint) public data;",
|
||
"mapping(string => uint) str;",
|
||
"mapping(string => uint256) data;",
|
||
"mapping(string => uint8[3]) public x;",
|
||
"mapping(string[] => uint) data;",
|
||
"mapping(ufixed8x1 => string) fixedString;",
|
||
"mapping(uint => Data) public data;",
|
||
"mapping(uint => MyStructName1) x;",
|
||
"mapping(uint => P[103]) x;",
|
||
"mapping(uint => P[103]) y;",
|
||
"mapping(uint => P[104]) z;",
|
||
"mapping(uint => S) public mappingAccess;",
|
||
"mapping(uint => S2) t;",
|
||
"mapping(uint => address payable) c;",
|
||
"mapping(uint => address payable) e;",
|
||
"mapping(uint => address payable) m;",
|
||
"mapping(uint => address payable) storage c = m;",
|
||
"mapping(uint => address payable[]) d;",
|
||
"mapping(uint => address payable[]) f;",
|
||
"mapping(uint => address payable[]) n;",
|
||
"mapping(uint => address payable[]) storage d = n;",
|
||
"mapping(uint => address view) m_d;",
|
||
"mapping(uint => mapping(uint => S)) public x;",
|
||
"mapping(uint => mapping(uint => int8)[8][][9])[] x;",
|
||
"mapping(uint => mapping(uint => uint)) public x;",
|
||
"mapping(uint => mapping(uint => uint)) twodim;",
|
||
"mapping(uint => uint) a;",
|
||
"mapping(uint => uint) c;",
|
||
"mapping(uint => uint) calldata x = y;",
|
||
"mapping(uint => uint) constant x;",
|
||
"mapping(uint => uint) m;",
|
||
"mapping(uint => uint) map;",
|
||
"mapping(uint => uint) memory x = y;",
|
||
"mapping(uint => uint) public m;",
|
||
"mapping(uint => uint) simple;",
|
||
"mapping(uint => uint) storage a = cond ? x : y;",
|
||
"mapping(uint => uint) storage x = new mapping(uint => uint)[](4);",
|
||
"mapping(uint => uint) storage x;",
|
||
"mapping(uint => uint) storage y = x;",
|
||
"mapping(uint => uint) x = y;",
|
||
"mapping(uint => uint) x;",
|
||
"mapping(uint => uint) y;",
|
||
"mapping(uint => uint)[] storage x;",
|
||
"mapping(uint => uint[2**100]) x;",
|
||
"mapping(uint => uint[8]) public data;",
|
||
"mapping(uint => uint[]) map;",
|
||
"mapping(uint => uint[]) public dynamicData;",
|
||
"mapping(uint16 => uint) cleanup;",
|
||
"mapping(uint256 => Invoice) public invoices;",
|
||
"mapping(uint256 => S) public override test;",
|
||
"mapping(uint256 => Struct) data;",
|
||
"mapping(uint256 => X) public m;",
|
||
"mapping(uint256 => Y) public m;",
|
||
"mapping(uint256 => Y)[3] public n;",
|
||
"mapping(uint256 => Y)[] public m;",
|
||
"mapping(uint256 => Y[3]) public n;",
|
||
"mapping(uint256 => Y[]) public m;",
|
||
"mapping(uint256 => __providers) data;",
|
||
"mapping(uint256 => _globalFunds) private globalFunds;",
|
||
"mapping(uint256 => _rate) rateHistory;",
|
||
"mapping(uint256 => announcements_s) public announcements;",
|
||
"mapping(uint256 => bool) public to_bool_map;",
|
||
"mapping(uint256 => bytes4) public to_string_map;",
|
||
"mapping(uint256 => mapping(uint256 => st[5])) public multiple_map;",
|
||
"mapping(uint256 => mapping(uint256 => uint256)) public m2;",
|
||
"mapping(uint256 => mapping(uint256 => uint256)) public to_multiple_map;",
|
||
"mapping(uint256 => testStruct) campaigns;",
|
||
"mapping(uint256 => uint256) b;",
|
||
"mapping(uint256 => uint256) map;",
|
||
"mapping(uint256 => uint256) ownSupply;",
|
||
"mapping(uint256 => uint256) private schellingExpansion;",
|
||
"mapping(uint256 => uint256) public m1;",
|
||
"mapping(uint256 => uint256) public to_uint_map;",
|
||
"mapping(uint256 => uint256) supply;",
|
||
"mapping(uint32 => uint8) table2;",
|
||
"mapping(uint8 => s2) recursive;",
|
||
"mapping(uint8 => s2) storage map = data.recursive;",
|
||
"mapping(uint8 => uint8) a;",
|
||
"mapping(uint8 => uint8) b;",
|
||
"mapping(uint8 => uint8) m1;",
|
||
"mapping(uint8 => uint8) m2;",
|
||
"mapping(uint8 => uint8) storage m = f();",
|
||
"mapping(uint8 => uint8) storage m = m1;",
|
||
"mapping(uint8 => uint8) storage p = true ? table1 : table2;",
|
||
"mapping(uint8 => uint8) table1;",
|
||
"mapping(uint8 => uint8) table2;",
|
||
"mapping(uint8 => uint8) table;",
|
||
"mapping(uint8 => uint8)[2] a;",
|
||
"mapping(uint8 => uint8)[2] b;",
|
||
"mapping(uint=>uint) m;",
|
||
"mapping(uint=>uint) map;",
|
||
"mapping(uint=>uint) storage a = data.map;",
|
||
"mapping(uint=>uint) storage a = map;",
|
||
"mapping(uint=>uint) storage b = map;",
|
||
"mapping(uint=>uint)[] m;",
|
||
"mapping(uint=>uint)[] memory x;",
|
||
"mapping(uint[] => uint) data;",
|
||
"mapping(var=>bytes32) d;",
|
||
"market = marketFactory.createMarket(eventContract, marketMaker, fee);",
|
||
"market = new StandardMarket(msg.sender, eventContract, marketMaker, fee);",
|
||
"market.close();",
|
||
"market.eventContract().redeemWinnings();",
|
||
"market.fund(funding);",
|
||
"market.withdrawFees();",
|
||
"marketFactory = _marketFactory;",
|
||
"marketFactory,",
|
||
"marketMaker = _marketMaker;",
|
||
"marketMaker,",
|
||
"markets.push(marketFactory.createMarket(scalarEvent, marketMaker, fee));",
|
||
"mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);",
|
||
"max = -2**255;",
|
||
"max = nums[i];",
|
||
"max;",
|
||
"me = address(this).balance;",
|
||
"memPtr := add(self, 0x20)",
|
||
"memPtr = start + 1;",
|
||
"memPtr = start + bLen + 1;",
|
||
"memPtr = start;",
|
||
"memcpy(retptr + self._len, other._ptr, other._len);",
|
||
"memcpy(retptr, parts[i]._ptr, parts[i]._len);",
|
||
"memcpy(retptr, self._ptr, self._len);",
|
||
"memoryTree = storageTree;",
|
||
"message = \"fancy message!\";",
|
||
"mid = (hi + lo) >> 1;",
|
||
"milestone.description = itrProposal.next().toAscii();",
|
||
"milestone.doneTime = block.timestamp;",
|
||
"milestone.maxCompletionDate = itrProposal.next().toUint();",
|
||
"milestone.milestoneLeadLink = itrProposal.next().toAddress();",
|
||
"milestone.minCompletionDate = itrProposal.next().toUint();",
|
||
"milestone.payData = itrProposal.next().toData();",
|
||
"milestone.paymentSource = itrProposal.next().toAddress();",
|
||
"milestone.reviewTime = itrProposal.next().toUint();",
|
||
"milestone.reviewer = itrProposal.next().toAddress();",
|
||
"milestone.status = MilestoneStatus.AcceptedAndInProgress;",
|
||
"milestone.status = MilestoneStatus.AuthorizedForPayment;",
|
||
"milestone.status = MilestoneStatus.Canceled;",
|
||
"milestone.status = MilestoneStatus.Completed;",
|
||
"milestone.url = itrProposal.next().toAscii();",
|
||
"milestones[i].status = MilestoneStatus.Canceled;",
|
||
"min;",
|
||
"minAnnouncementDelay = announcements[id]._uint;",
|
||
"minQuorumDivisor *= 2;",
|
||
"minQuorumDivisor = 5;",
|
||
"minTokensToCreate = _minTokensToCreate;",
|
||
"mload(0)",
|
||
"mod ;",
|
||
"mod g;",
|
||
"modifier atStage(Stages _stage) {",
|
||
"modifier campaignNotCanceled { if (campaignCanceled) revert(); _; }",
|
||
"modifier confirmed(uint transactionId, address owner) {",
|
||
"modifier costs(uint _amount) { require(msg.value >= _amount); _; }",
|
||
"modifier f() override override {}",
|
||
"modifier f() override { _; }",
|
||
"modifier f() override(A,B) { _; }",
|
||
"modifier f() virtual override (I, J) { _; }",
|
||
"modifier f() virtual override(A, B) { _; }",
|
||
"modifier f() virtual { _; }",
|
||
"modifier f(uint a) virtual { _; }",
|
||
"modifier ifFlag(bool flag) {",
|
||
"modifier initX() {",
|
||
"modifier isCreator () {",
|
||
"modifier isEventContract () {",
|
||
"modifier isOwner () {",
|
||
"modifier isOwner { require( msg.sender == owner ); _; }",
|
||
"modifier isReady {",
|
||
"modifier isSigner () {",
|
||
"modifier m override {",
|
||
"modifier m virtual;",
|
||
"modifier m {",
|
||
"modifier m { a = 5; _; }",
|
||
"modifier m() { _; }",
|
||
"modifier m() { msg.value; _; }",
|
||
"modifier m() {}",
|
||
"modifier m(S storage x) {",
|
||
"modifier m(address a) {",
|
||
"modifier m(uint _amount, uint _avail) { require(_avail >= _amount); _; }",
|
||
"modifier m(uint a) {",
|
||
"modifier m(uint a, uint b) {",
|
||
"modifier m(uint x) {",
|
||
"modifier m1 {",
|
||
"modifier m1 { _; }",
|
||
"modifier m1(uint[] storage a) { _; }",
|
||
"modifier m2 { _; }",
|
||
"modifier m2(uint[] storage a) { _; }",
|
||
"modifier mod override {",
|
||
"modifier mod virtual {",
|
||
"modifier mod virtual;",
|
||
"modifier mod { if (msg.sender == 0) _ }",
|
||
"modifier mod { if (msg.sender == 0x0000000000000000000000000000000000000000) _; }",
|
||
"modifier mod() override { _; }",
|
||
"modifier mod() override { _;}",
|
||
"modifier mod() virtual;",
|
||
"modifier mod() { _; }",
|
||
"modifier mod() { require(msg.value > 10 ether); _; }",
|
||
"modifier mod(L.S storage) {",
|
||
"modifier mod(S storage s) {",
|
||
"modifier mod(address a) { if (msg.sender == a) _; }",
|
||
"modifier mod(uint a) { _; return 7; }",
|
||
"modifier mod(uint a) { if (a > 0) _; }",
|
||
"modifier mod(uint256 x) {",
|
||
"modifier mod(uint[] storage b) {",
|
||
"modifier mod1 override {",
|
||
"modifier mod1 virtual {",
|
||
"modifier mod1 {",
|
||
"modifier mod1(uint a) { if (a > 0) _; }",
|
||
"modifier mod1(uint a) { if (msg.sender == address(a)) _; }",
|
||
"modifier mod1(uint a, bool b) { if (b) _; }",
|
||
"modifier mod2 {",
|
||
"modifier mod2 { if (msg.sender == address(2)) _; }",
|
||
"modifier mod2(bool a) {",
|
||
"modifier mod2(bytes7 a) {",
|
||
"modifier mod2(bytes7 a) { while (a == \"1234567\") _; }",
|
||
"modifier modTest(uint a, uint b,) { _; }",
|
||
"modifier modTest(uint a,) { _; }",
|
||
"modifier modi() virtual virtual {_;}",
|
||
"modifier modi() virtual {_;}",
|
||
"modifier mutex {",
|
||
"modifier n {",
|
||
"modifier n { _; a = 7; }",
|
||
"modifier n(uint x) {",
|
||
"modifier noContract {",
|
||
"modifier noEther() {if (msg.value > 0) revert(); _; }",
|
||
"modifier nonFree {",
|
||
"modifier nonpayablem(uint) { x = 2; _; }",
|
||
"modifier notChanging { if (changingMilestones) revert(); _; }",
|
||
"modifier notConfirmed(uint transactionId, address owner) {",
|
||
"modifier notExecuted(uint transactionId) {",
|
||
"modifier notNull(address _address) {",
|
||
"modifier notZero(uint x) {",
|
||
"modifier onlyArbitrator { if (msg.sender != arbitrator) revert(); _; }",
|
||
"modifier onlyDonor { if (msg.sender != donor) revert(); _; }",
|
||
"modifier onlyForModuleHandler() {",
|
||
"modifier onlyOwner {",
|
||
"modifier onlyOwner() {",
|
||
"modifier onlyRecipient { if (msg.sender != recipient) revert(); _; }",
|
||
"modifier onlyTokenholders {",
|
||
"modifier onlyWallet() {",
|
||
"modifier only_owner() { _; }",
|
||
"modifier ownerDoesNotExist(address owner) {",
|
||
"modifier ownerExists(address owner) {",
|
||
"modifier purem(uint) { _; }",
|
||
"modifier readX() override {",
|
||
"modifier readX() virtual {",
|
||
"modifier readX() {",
|
||
"modifier readX(uint _x) {",
|
||
"modifier repeat(bool twice) {",
|
||
"modifier repeat(uint256 count) {",
|
||
"modifier restricted() {",
|
||
"modifier revertIfNoReturn() {",
|
||
"modifier run() {",
|
||
"modifier setsx {",
|
||
"modifier someModifier() { _; }",
|
||
"modifier timedTransitions() {",
|
||
"modifier transactionExists(uint transactionId) {",
|
||
"modifier validRequirement(uint ownerCount, uint _required) {",
|
||
"modifier viewm(uint) { uint a = x; _; a; }",
|
||
"module callbacks",
|
||
"moduleHandlerAddress = _moduleHandlerAddress;",
|
||
"moduleHandlerAddress = newModuleHandlerAddress;",
|
||
"moduleStatus = status.Connected;",
|
||
"moduleStatus = status.Disconnected;",
|
||
"modules.push();",
|
||
"modules[_id].addr = addr;",
|
||
"modules[id] = input;",
|
||
"modules_s[] public modules;",
|
||
"ms1 = ms2;",
|
||
"ms1.x = x;",
|
||
"msg := 1",
|
||
"msg.sender,",
|
||
"msg.sender.transfer(value);",
|
||
"msg.value;",
|
||
"msg;",
|
||
"mstore(0, 0)",
|
||
"mstore(0, 7)",
|
||
"mstore(0, b.slot)",
|
||
"mstore(0, s.slot)",
|
||
"mstore(0, sload(0))",
|
||
"mstore(0, start)",
|
||
"mstore(0, storageArray.slot)",
|
||
"mstore(0x00, a1)",
|
||
"mstore(0x20, b1)",
|
||
"mstore(0x40, add(ptr, 0x20))",
|
||
"mstore(0x40, c1)",
|
||
"mstore(0x60, d)",
|
||
"mstore(add(freeMem, 32), 42)",
|
||
"mstore(add(m, 0x20), b)",
|
||
"mstore(add(m, 32), \"deadbeef15dead\")",
|
||
"mstore(add(m, 32), 258)",
|
||
"mstore(add(ret, 0x20), ptr)",
|
||
"mstore(add(s, 0x20), b)",
|
||
"mstore(add(s, 64), 257)",
|
||
"mstore(add(tgt, add(0x20, mload(tgt))), 0)",
|
||
"mstore(add(wOffset, offset), mload(add(rOffset, offset)))",
|
||
"mstore(add(x, 32), \"12345678901234567890123456789012\")",
|
||
"mstore(dest, mload(src))",
|
||
"mstore(dest, or(destpart, srcpart))",
|
||
"mstore(freeMem, 42)",
|
||
"mstore(m, 0xdeadbeef15dead)",
|
||
"mstore(m, 257)",
|
||
"mstore(m, 8)",
|
||
"mstore(m, a)",
|
||
"mstore(mload(0x40), 0xca35b7d915458ef540ade6068dfe2f44e8fa733c)",
|
||
"mstore(ptr, self)",
|
||
"mstore(s, a)",
|
||
"mstore(start, add(start, 1))",
|
||
"mstore(x, z)",
|
||
"mulmod(0, 1, 2);",
|
||
"mulmod(1, 0, 2);",
|
||
"mulmod(1, 2, d);",
|
||
"multiple_map[2][1][2].a = 3;",
|
||
"multiple_map[2][1][2].finalArray.push();",
|
||
"multiple_map[2][1][2].finalArray[3] = 5;",
|
||
"mutex = 1;",
|
||
"myBal = address(this).balance;",
|
||
"myStruct a = myStruct(3.125, 3);",
|
||
"n[1][0].a = 7;",
|
||
"n[1][0].b = 8;",
|
||
"n[1][1].a = 9;",
|
||
"n[1][1].b = 10;",
|
||
"name = providers[addr].data[height].name;",
|
||
"name = \"Celina\";",
|
||
"name = _name;",
|
||
"name = _shiftOperator(name, _bytes);",
|
||
"name = _tokenName;",
|
||
"name = x;",
|
||
"name,",
|
||
"nestedStruct nstr;",
|
||
"nestedValue = str.nstr.nestedValue;",
|
||
"netOutcomeTokensSold = new int[](eventContract.getOutcomeCount());",
|
||
"netOutcomeTokensSold[outcomeTokenIndex] = netOutcomeTokensSold[outcomeTokenIndex].add(int(outcomeTokenCount));",
|
||
"netOutcomeTokensSold[outcomeTokenIndex] = netOutcomeTokensSold[outcomeTokenIndex].sub(int(outcomeTokenCount));",
|
||
"new C((1234));",
|
||
"new B();",
|
||
"new B1{value: 10}();",
|
||
"new B2{value: 10}();",
|
||
"new B3{value: 10}();",
|
||
"new B4{value: 10}();",
|
||
"new C();",
|
||
"new D{gas: 2};",
|
||
"new D{random:5+5};",
|
||
"new D{salt:\"aabbcc\"};",
|
||
"new D{salt:\"abc\", salt:\"efg\"}();",
|
||
"new D{salt:\"abc\", value:3, gas: 4};",
|
||
"new D{salt:\"abc\", value:3};",
|
||
"new D{salt:\"abc\"};",
|
||
"new D{salt:\"abc\"}{salt:\"a\"}();",
|
||
"new D{salt:\"xyz\", salt:\"aaf\"};",
|
||
"new D{slt:5, value:3};",
|
||
"new D{val:5};",
|
||
"new D{value:3, value:4};",
|
||
"new D{value:5+5};",
|
||
"new D{what:2130+5};",
|
||
"new I();",
|
||
"new L();",
|
||
"new S();",
|
||
"new function() external returns (function() external returns (uint))[](10);",
|
||
"new function(uint) internal returns (uint)[](10);",
|
||
"new uint[1];",
|
||
"new uint[](4);",
|
||
"new var;",
|
||
"newArrayID = a;",
|
||
"newModule,",
|
||
"newRound.blockHeight = block.number;",
|
||
"newRound.reward = round.reward;",
|
||
"nextRound();",
|
||
"nextRune(self, ret);",
|
||
"nf := 1",
|
||
"nf := mul(n, fac(sub(n, 1)))",
|
||
"nf := mul(nf, i)",
|
||
"nonce = _nonce;",
|
||
"nonpayFun();",
|
||
"nonpayFun;",
|
||
"notConfirmed(transactionId, msg.sender)",
|
||
"notExecuted(transactionId)",
|
||
"notNull(destination)",
|
||
"notNull(owner)",
|
||
"now;",
|
||
"o = S(super).foo();",
|
||
"o(true ? 99 : 99**99);",
|
||
"o(true ? 99**99 : 99);",
|
||
"o(true ? 99**99 : 99**99);",
|
||
"o.h();",
|
||
"o1 := y.offset",
|
||
"object \"MyContract\" {",
|
||
"object \"Runtime\" {",
|
||
"off := x.offset",
|
||
"off1 := z.offset",
|
||
"off2 := f()",
|
||
"off2 := y.offset",
|
||
"offset = copyFromTree(tree.children[i], data, offset);",
|
||
"offset = maxQuantity.mul(logN) / int(funding);",
|
||
"offset = offset.sub(EXP_LIMIT);",
|
||
"ofg = abc;",
|
||
"old_a = set_internal(a, key, value_a);",
|
||
"old_b = set_internal(b, key, value_b);",
|
||
"one = data.x;",
|
||
"oneRet = one;",
|
||
"onlyWallet",
|
||
"opponents[msg.sender].push(id);",
|
||
"opponents[msg.sender][newArrayID] = id;",
|
||
"oppositeRate = uint8(announcements[id]._uint);",
|
||
"oracle = _oracle;",
|
||
"oracle,",
|
||
"oracles = _oracles;",
|
||
"otherHash := keccak256(mload(0x40), size)",
|
||
"other_c.f();",
|
||
"otherptr += 32;",
|
||
"outcome = _outcome;",
|
||
"outcome = oracle.getOutcome();",
|
||
"outcome = outcomes[outcomeIndex];",
|
||
"outcomeAmounts[msg.sender][_outcome] = challengeAmount;",
|
||
"outcomeAmounts[msg.sender][_outcome] = outcomeAmounts[msg.sender][_outcome].add(amount);",
|
||
"outcomeAmounts[msg.sender][frontRunner] = 0;",
|
||
"outcomeCount",
|
||
"outcomeCount,",
|
||
"outcomeExpTerm = term;",
|
||
"outcomeIndex = i;",
|
||
"outcomeSet = true;",
|
||
"outcomeTokenDistribution = new uint[](outcomeTokens.length);",
|
||
"outcomeTokenDistribution[i] = outcomeTokens[i].balanceOf(owner);",
|
||
"outcomeTokens.push(outcomeToken);",
|
||
"outcomeTokens[LONG].revoke(msg.sender, longOutcomeTokenCount);",
|
||
"outcomeTokens[SHORT].revoke(msg.sender, shortOutcomeTokenCount);",
|
||
"outcomeTokens[i].issue(msg.sender, collateralTokenCount);",
|
||
"outcomeTokens[i].revoke(msg.sender, outcomeTokenCount);",
|
||
"outcomeTokens[uint(outcome)].revoke(msg.sender, winnings);",
|
||
"outcomeValidations = validations[i];",
|
||
"outcomes[j] = _outcome;",
|
||
"override",
|
||
"override returns (bool _success) {",
|
||
"override returns (bool success) {",
|
||
"ownReward += value * globalFunds[a].reward / globalFunds[a].supply;",
|
||
"owner = _owner;",
|
||
"owner = address(0);",
|
||
"owner = g();",
|
||
"owner = msg.sender;",
|
||
"owner = newOwner;",
|
||
"ownerCount = safeAdd(ownerCount, 1);",
|
||
"ownerCount = safeSub(ownerCount, 1);",
|
||
"ownerDoesNotExist(newOwner)",
|
||
"ownerDoesNotExist(owner)",
|
||
"ownerExists(msg.sender)",
|
||
"ownerExists(owner)",
|
||
"owners = _owners;",
|
||
"owners.pop();",
|
||
"owners.push(owner);",
|
||
"owners[addr] = true;",
|
||
"owners[i] = newOwner;",
|
||
"owners[i] = owners[owners.length - 1];",
|
||
"p = Pairing.mul(p, 13986731495506593864492662381614386532349950841221768152838255933892789078521);",
|
||
"p.X = 14125296762497065001182820090155008161146766663259912659363835465243039841726;",
|
||
"p.X == 18256332256630856740336504687838346961237861778318632856900758565550522381207 &&",
|
||
"p.Y = 16229134936871442251132173501211935676986397196799085184804749187146857848057;",
|
||
"p.Y == 6976682127058094634733239494758371323697222088503263230319702770853579280803;",
|
||
"p.amount = _amount;",
|
||
"p.creator = msg.sender;",
|
||
"p.creator.send(p.proposalDeposit);",
|
||
"p.description = _description;",
|
||
"p.nay += balances[msg.sender];",
|
||
"p.newCurator = _newCurator;",
|
||
"p.open = false;",
|
||
"p.open = true;",
|
||
"p.proposalDeposit = msg.value;",
|
||
"p.proposalHash = keccak256(abi.encodePacked(_recipient, _amount, _transactionData));",
|
||
"p.proposalPassed = true;",
|
||
"p.recipient = _recipient;",
|
||
"p.splitData.push();",
|
||
"p.splitData[0].newDAO = createNewDAO(_newCurator);",
|
||
"p.splitData[0].rewardToken = rewardToken[address(this)];",
|
||
"p.splitData[0].splitBalance = actualBalance();",
|
||
"p.splitData[0].totalSupply = totalSupply;",
|
||
"p.splitData[0].totalSupply;",
|
||
"p.votedNo[msg.sender] = true;",
|
||
"p.votedYes[msg.sender] = true;",
|
||
"p.votingDeadline = block.timestamp + _debatingPeriod;",
|
||
"p.yea += balances[msg.sender];",
|
||
"p1.X = 1; p1.Y = 2;",
|
||
"p1[0] = a1;",
|
||
"p1[1] = b1;",
|
||
"p1[2] = c1;",
|
||
"p1[3] = d1;",
|
||
"p2.X = 1; p2.Y = 2;",
|
||
"p2[0] = a2;",
|
||
"p2[1] = b2;",
|
||
"p2[2] = c2;",
|
||
"p2[3] = d2;",
|
||
"p[0] = m;",
|
||
"paidOut[_account] += reward;",
|
||
"paidOut[_from] -= transferPaidOut;",
|
||
"paidOut[_to] += transferPaidOut;",
|
||
"paidOut[msg.sender] = 0;",
|
||
"payOwnerOnly = _payOwnerOnly;",
|
||
"payable",
|
||
"pointer.push();",
|
||
"pointer[index] = value;",
|
||
"pop",
|
||
"pop(add(add(1, 2), c))",
|
||
"pop(hex\"2233\")",
|
||
"pop(linkersymbol(\"contract/library.sol:L\"))",
|
||
"pop(pc())",
|
||
"pop(y)",
|
||
"pop(y.offset)",
|
||
"pop(y.slot)",
|
||
"pop(y_offset)",
|
||
"pop(y_slot)",
|
||
"pos += _itemLength(pos);",
|
||
"power *= base;",
|
||
"power *= power;",
|
||
"power = exp(base, exponent / 2);",
|
||
"pragma 0.5.11;",
|
||
"pragma 0;",
|
||
"pragma ``;",
|
||
"pragma experimental \"\";",
|
||
"pragma experimental \"ABIEncoderV2\";",
|
||
"pragma experimental \"unsupportedName\";",
|
||
"pragma experimental 123;",
|
||
"pragma experimental ABIEncoderV2;",
|
||
"pragma experimental SMTChecker;",
|
||
"pragma experimental SMTChecker;pragma experimental ABIEncoderV2;",
|
||
"pragma experimental __test;",
|
||
"pragma experimental unsupportedName unsupportedName;",
|
||
"pragma experimental unsupportedName;",
|
||
"pragma experimental;",
|
||
"pragma solidity < 142857;",
|
||
"pragma solidity >0.4.23;",
|
||
"pragma solidity >0.4.24;",
|
||
"pragma solidity >= 0.0.0;",
|
||
"pragma solidity >= 0.0;",
|
||
"pragma solidity >= 0.6.0;",
|
||
"pragma solidity >=0.0.0;",
|
||
"pragma solidity >=0.0;",
|
||
}; |