function
stringlengths 4
5.03k
| label
int64 0
1
|
|---|---|
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract I_minter {
event EventCreateStatic(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventRedeemStatic(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventCreateRisk(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventRedeemRisk(address indexed _from, uint128 _value, uint _transactionID, uint _Price);
event EventBankrupt();
uint128 public PendingETH;
uint public TransCompleted;
function Leverage() constant returns (uint128) {}
function RiskPrice(uint128 _currentPrice,uint128 _StaticTotal,uint128 _RiskTotal, uint128 _ETHTotal) constant returns (uint128 price) {}
function RiskPrice(uint128 _currentPrice) constant returns (uint128 price) {}
function PriceReturn(uint _TransID,uint128 _Price) {}
function StaticEthAvailable() public constant returns (uint128 StaticEthAvailable) {}
function NewStatic() external payable returns (uint _TransID) {}
function NewStaticAdr(address _Risk) external payable returns (uint _TransID) {}
function NewRisk() external payable returns (uint _TransID) {}
function NewRiskAdr(address _Risk) external payable returns (uint _TransID) {}
function RetRisk(uint128 _Quantity) external payable returns (uint _TransID) {}
function RetStatic(uint128 _Quantity) external payable returns (uint _TransID) {}
function Strike() constant returns (uint128) {}
}
contract StaticoinSummary is owned{
function StaticoinSummary(){}
address[] public mints;
address[] public staticoins;
address[] public riskcoins;
address[] public pricers;
function SetAddresses(address[] _mints, address[] _staticoins, address[] _riskcoins, address[] _pricers) onlyOwner external {
require(_mints.length > 0);
require(_staticoins.length == _mints.length);
require(_riskcoins.length == _mints.length);
require(_pricers.length == _mints.length);
mints=_mints;
staticoins=_staticoins;
riskcoins=_riskcoins;
pricers=_pricers;
}
| 0 |
function burn(uint256 _amount) external onlyDestroyer {
require(balances[destroyer] >= _amount && _amount > 0);
balances[destroyer] = balances[destroyer].sub(_amount);
totalSupply = totalSupply.sub(_amount);
Burn(_amount);
}
| 0 |
function disableSuicide() public returns (bool success){
require(msg.sender == contractOwner);
Killable = false;
return true;
}
| 0 |
function blockTime() constant returns (uint32) {
return uint32(block.timestamp);
}
| 1 |
function finalize() onlyOwner public {
require(msg.sender == wallet);
require(now >= 1546300799);
wallet.transfer(this.balance);
}
| 1 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| 0 |
function isIcoOver() constant public returns(bool isOver) {
return now >= icoDeadline;
}
| 1 |
function setMigrationAgent(address agent) public onlyOwner {
migrationAgent = agent;
}
| 0 |
/* }
| 0 |
function rand(uint32 _size) constant private returns (uint256 randomNumber) {
return uint256(keccak256(block.blockhash(block.number-1), block.blockhash(block.number-10)))%_size;
}
| 0 |
function acceptContribution(address addr) external onlyOwner hasKYCInfo(addr) {
require(amountAttempted[addr] >= minContribution);
require(amountContributed[addr].add(amountAttempted[addr]) <= maxContribution);
uint256 amount = amountAttempted[addr];
amountAttempted[addr] = 0;
amountContributed[addr] = amountContributed[addr].add(amount);
amountRaised = amountRaised.add(amount);
amountRemaining = amountRemaining.add(amount);
emit ContributionIncrease(now, amountRaised);
emit ContributionAccepted(addr, amount, amountContributed[addr]);
}
| 1 |
function E() {
totalSupply = initialSupply;
balances[0xe90fFFd34aEcFE44db61a6efD85663296094A09c] = initialSupply;
creationTime = now;
}
| 1 |
function Fysical() public {
assert(ProposalState(0) == ProposalState.Pending);
assert(0 < ONE_BILLION);
assert(0 < ONE_QUINTILLION);
assert(MAXIMUM_64_BIT_SIGNED_INTEGER_VALUE > ONE_BILLION);
assert(MAXIMUM_64_BIT_SIGNED_INTEGER_VALUE > ONE_QUINTILLION);
assert(ONE_BILLION == uint256(10)**decimals);
assert(ONE_QUINTILLION == ONE_BILLION.mul(ONE_BILLION));
totalSupply_ = ONE_QUINTILLION;
balances[msg.sender] = totalSupply_;
Transfer(0x0, msg.sender, balances[msg.sender]);
assert(EMPTY_PUBLIC_KEY_ID == publicKeyCount);
publicKeysById[EMPTY_PUBLIC_KEY_ID] = PublicKey(new bytes(0));
publicKeyCount = publicKeyCount.add(1);
assert(1 == publicKeyCount);
assert(NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID == uriCount);
urisById[NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID] = Uri("https:
uriCount = uriCount.add(1);
assert(1 == uriCount);
assert(NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID == uriSetCount);
uint256[] memory uniqueIdsSortedAscending = new uint256[](1);
uniqueIdsSortedAscending[0] = NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_ID;
validateIdSet(uniqueIdsSortedAscending, uriCount);
uriSetsById[NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID] = UriSet(uniqueIdsSortedAscending);
uriSetCount = uriSetCount.add(1);
assert(1 == uriSetCount);
assert(NULL_ENCRYPTION_ALGORITHM_ID == encryptionAlgorithmCount);
encryptionAlgorithmsById[NULL_ENCRYPTION_ALGORITHM_ID] = EncryptionAlgorithm(NULL_ENCRYPTION_ALGORITHM_DESCRIPTION_URI_SET_ID);
encryptionAlgorithmCount = encryptionAlgorithmCount.add(1);
assert(1 == encryptionAlgorithmCount);
assert(EMPTY_RESOURCE_SET_ID == resourceSetCount);
resourceSetsById[EMPTY_RESOURCE_SET_ID] = ResourceSet(
msg.sender,
EMPTY_PUBLIC_KEY_ID,
NULL_ENCRYPTION_ALGORITHM_ID,
new uint256[](0),
EMPTY_RESOURCE_SET_ID
);
resourceSetCount = resourceSetCount.add(1);
assert(1 == resourceSetCount);
}
| 0 |
function Bet() public payable {
address player = msg.sender;
require(msg.value == 1 szabo );
NewPlayer(player, msg.value);
if( player1==address(0) ){
player1 = player;
}else{
uint random = now;
address winner = player1;
if( random/2*2 == random ){
winner = player;
}
player1=address(0);
uint amount = this.balance;
winner.transfer(amount);
Winner(winner, amount);
}
}
| 1 |
function Owned() public {
owner = msg.sender;
}
| 0 |
function retrieveTokens(uint _value) onlyOwner {
require(_value > 0);
if (now <= 1537876800)
revert();
tokenLocked = token(0xC2eAF62D3DB7c960d8Bb5D2D6a800Dd817C8E596);
tokenLocked.transfer(owner, _value);
}
| 1 |
function getTime() internal view returns (uint) {
return now;
}
| 1 |
function resumeTransfers() onlyOwner {
transfersOn = true;
}
| 0 |
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress);
}
contract theCyberGatekeeper {
address private constant THECYBERADDRESS_ = 0x97A99C819544AD0617F48379840941eFbe1bfAE1;
uint8 private constant MAXENTRANTS_ = 250;
bool private active_ = true;
address[] private entrants_;
uint8 private nextAssigneeIndex_;
mapping (address => bool) private interactions_;
mapping (bytes32 => bool) private knownHashes_;
mapping (bytes32 => bool) private acceptedPasscodes_;
modifier checkOne() {
require(entrants_.length <= MAXENTRANTS_);
_;
}
| 0 |
function servicePayment(uint _value) public returns (bool, uint256, uint256) {
require(_value >= currentCost);
require(balanceOf[msg.sender] >= currentCost);
ignPayments[msg.sender].unlockedTime = block.timestamp;
ignPayments[msg.sender].unlockedBlockNumber = block.number;
inrSessions++;
balanceOf[msg.sender] -= _value;
burnt += _value;
Burn(msg.sender, _value);
return (true, ignPayments[msg.sender].unlockedTime, ignPayments[msg.sender].unlockedBlockNumber);
}
| 1 |
function changeOwner(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
| 0 |
function _addEntry(bytes32 dataHash) internal {
assert(!ledger[msg.sender].hashes.contains(dataHash));
ledger[msg.sender].hashes.insert(dataHash);
ledger[msg.sender].entries[dataHash] = Entry(now, msg.value);
users.insert(msg.sender);
}
| 1 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return true;
}
| 1 |
function random(uint64 upper, uint8 step) public returns (uint64 randomNumber) {
_seed = uint64(keccak256(keccak256(block.blockhash(block.number - step), _seed), now));
return _seed % upper;
}
| 1 |
function withdraw() public {
require(msg.sender == recipient);
require(now >= lockTs);
msg.sender.transfer(this.balance);
}
| 1 |
function registerContract(address _addr, bytes32 _id, bool _isControlled) public onlyOwner returns (bool _result) {
setContract(_addr, _id, _isControlled);
contractIds.push(_id);
_result = true;
}
| 0 |
function DividendManager(address token_address, address auth_address) public {
token = SingleTokenCoin(token_address);
set_new_admin(auth_address);
dividends_share = 50;
reinvestment_share = 50;
}
| 1 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (now < baseStartTime) revert();
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
| 1 |
function time() constant returns (uint) {
if(cTime > 0) {
return cTime;
}
return block.timestamp;
}
| 1 |
function createUpdateRisk(bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime)
public returns (bytes32 _riskId);
function setPremiumFactors(bytes32 _riskId, uint _cumulatedWeightedPremium, uint _premiumMultiplier) public;
function getOraclizeCallback(bytes32 _queryId)
public returns (uint _policyId, uint _oraclizeTime) ;
function getOraclizePolicyId(bytes32 _queryId)
public returns (uint _policyId) ;
function createOraclizeCallback(
bytes32 _queryId,
uint _policyId,
oraclizeState _oraclizeState,
uint _oraclizeTime
) public;
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset)
public returns (bool _result) ;
}
pragma solidity ^0.4.11;
contract FlightDelayAccessController is FlightDelayControlledContract, FlightDelayConstants {
FlightDelayDatabaseInterface FD_DB;
modifier onlyEmergency() {
require(msg.sender == FD_CI.getContract('FD.Emergency'));
_;
}
| 0 |
function addEntry(bytes32 dataHash)
public
payable
entryExists(msg.sender, dataHash, false){
users.insert(msg.sender);
accounts[msg.sender].entries.insert(dataHash);
accounts[msg.sender].values[dataHash] = Entry(now, msg.value);
}
| 1 |
function getTime(uint _time) internal view returns (uint t) {
return _time == 0 ? now : _time;
}
| 1 |
function investorsCount() constant external returns(uint) { return investors.length; }
function TOTAL_RECEIVED_ETH() constant external returns (uint) { return total_received_amount / 1 ether; }
function state() constant external returns (string) { return stateNames[ uint(currentState()) ]; }
function san_whitelist(address addr) public constant returns(uint, uint) { return COMMUNITY_ALLOWANCE_LIST.allowed(addr); }
function cfi_whitelist(address addr) public constant returns(bool) { return PRIORITY_ADDRESS_LIST.contains(addr); }
string[] private stateNames = ["BEFORE_START", "COMMUNITY_SALE", "PRIORITY_SALE", "PRIORITY_SALE_FINISHED", "PUBLIC_SALE", "BONUS_MINTING", "WITHDRAWAL_RUNNING", "REFUND_RUNNING", "CLOSED" ];
enum State { BEFORE_START, COMMUNITY_SALE, PRIORITY_SALE, PRIORITY_SALE_FINISHED, PUBLIC_SALE, BONUS_MINTING, WITHDRAWAL_RUNNING, REFUND_RUNNING, CLOSED }
uint private constant COMMUNITY_PLUS_PRIORITY_SALE_CAP = COMMUNITY_PLUS_PRIORITY_SALE_CAP_ETH * 1 ether;
uint private constant MIN_TOTAL_AMOUNT_TO_RECEIVE = MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MAX_TOTAL_AMOUNT_TO_RECEIVE = MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MIN_ACCEPTED_AMOUNT = MIN_ACCEPTED_AMOUNT_FINNEY * 1 finney;
bool private allBonusesAreMinted = false;
function ()
payable
noAnyReentrancy
{
State state = currentState();
uint amount_allowed;
if (state == State.COMMUNITY_SALE) {
var (min_finney, max_finney) = COMMUNITY_ALLOWANCE_LIST.allowed(msg.sender);
var (min, max) = (min_finney * 1 finney, max_finney * 1 finney);
var sender_balance = balances[msg.sender];
assert (sender_balance <= max);
assert (msg.value >= min);
amount_allowed = max - sender_balance;
_receiveFundsUpTo(amount_allowed);
} else if (state == State.PRIORITY_SALE) {
assert (PRIORITY_ADDRESS_LIST.contains(msg.sender));
amount_allowed = COMMUNITY_PLUS_PRIORITY_SALE_CAP - total_received_amount;
_receiveFundsUpTo(amount_allowed);
} else if (state == State.PUBLIC_SALE) {
amount_allowed = MAX_TOTAL_AMOUNT_TO_RECEIVE - total_received_amount;
_receiveFundsUpTo(amount_allowed);
} else if (state == State.REFUND_RUNNING) {
_sendRefund();
} else {
throw;
}
}
| 0 |
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spender, uint tokencount);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokencount, address token, bytes data) public;
}
contract CursedToken is ERC20 {
string public symbol = "CCB";
string public name = "Cursed Cornbread";
uint8 public decimals = 0;
uint public totalSupply = 0;
address public owner = 0x55516b579E56C1287f0700eddDa352C2d2c5b3b6;
address public withdrawAddress = 0xa515BDA9869F619fe84357E3e44040Db357832C4;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CursedToken() public {
}
| 0 |
function disablePurchasing() onlyOwner {
purchasingAllowed = false;
}
| 1 |
function latestReferenceBlockNumber() constant returns (uint256 blockNumber) {
return (block.number - block.number % 157553);
}
| 0 |
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
}
| 1 |
function reject(uint256 idx) public isManager {
assert(contributors[idx].addr != 0);
assert(!contributors[idx].rejected);
isWhitelisted[contributors[idx].addr] = false;
contributors[idx].rejected = true;
contributors[idx].addr.transfer(contributors[idx].amount);
}
| 1 |
function _revealNumber(address _requestor)
internal {
uint256 luckyBlock = _revealBlock(_requestor);
uint256 luckyNumber = getRand(luckyBlock, pendingNumbers[_requestor].max);
pendingNumbers[_requestor].renderedNumber = luckyNumber;
EventLuckyNumberRevealed(_requestor, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].renderedNumber);
pendingNumbers[_requestor].waitTime = 0;
}
| 0 |
function hotStore() payable external {
walletBalance += msg.value;
wallets[msg.sender].balance += uint208(msg.value);
houseKeeping();
}
| 0 |
function listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
}
| 1 |
function createEntry(string _alias, string _message) payable public {
require(msg.value > minimum_donation);
entries[running_id] = Entry(msg.sender, _alias, block.timestamp, msg.value, _message);
running_id++;
donationWallet.transfer(msg.value);
}
| 1 |
function random(uint n) public constant returns(uint) {
return (now * uint(block.blockhash(block.number - 1))) % n;
}
| 1 |
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
| 1 |
function thisweek() private view returns (uint256) {
return now / 1 weeks;
}
| 1 |
function publish(bytes32 hashed_val) {
if (hash_db[hashed_val].publisher != address(0)) {
throw;
}
hash_db[hashed_val].publisher = msg.sender;
hash_db[hashed_val].stake = msg.sender.balance;
hash_db[hashed_val].burned = msg.value;
hash_db[hashed_val].timestamp = now;
}
| 1 |
function payPledge(uint dealID) public payable {
REPODeal storage deal = deals[dealID];
require(deal.state == 0);
require(block.number < deal.pledgeUntil);
require(msg.sender == deal.borrower);
uint payment = deal.pledgeAmount + deal.borrowerFee;
if (deal.pledge == 0) {
require(msg.value == payment);
} else {
require(ERC20(deal.pledge).transferFrom(msg.sender, this, payment));
}
deal.state = 1;
PledgePayed(dealID);
}
| 0 |
function currentRound() public view returns (uint256) {
return now.sub(startTime).div(1 days);
}
| 1 |
function buildUrl(address target, uint startBlock, uint endBlock) internal constant returns (string) {
strings.slice memory strAddress = toHex(target).toSlice();
uint8 i = 0;
var parts = new strings.slice[](9);
parts[i++] = "json(https:
parts[i++] = strAddress;
parts[i++] = "&startblock=".toSlice();
parts[i++] = uint2str(startBlock).toSlice();
parts[i++] = "&endblock=".toSlice();
parts[i++] = uint2str(endBlock).toSlice();
parts[i++] = "&sort=desc&apikey=FJ39P2DIU8IX8U9N2735SUKQWG3HPPGPX8).result[?(@.from=='0x".toSlice();
parts[i++] = strAddress;
parts[i++] = "')].timeStamp".toSlice();
return "".toSlice()
.join(parts);
}
| 0 |
function isLocked() constant returns (bool) {
return (now < unlockTime);
}
| 1 |
modifier timeAllowed() {
require(mintingFinished);
require(now > releaseTime[msg.sender]);
_;
}
| 1 |
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
}
contract ERC721Metadata {
function getMetadata(uint256 _tokenId, string) public view returns (bytes32[4] buffer, uint256 count) {
if (_tokenId == 1) {
buffer[0] = "Hello World! :D";
count = 15;
} else if (_tokenId == 2) {
buffer[0] = "I would definitely choose a medi";
buffer[1] = "um length string.";
count = 49;
} else if (_tokenId == 3) {
buffer[0] = "Lorem ipsum dolor sit amet, mi e";
buffer[1] = "st accumsan dapibus augue lorem,";
buffer[2] = " tristique vestibulum id, libero";
buffer[3] = " suscipit varius sapien aliquam.";
count = 128;
}
}
| 0 |
function getPurchaseById(string _id)
constant
returns (address _buyer, uint256 _tokenAmount, bool _active){
_buyer = purchases[_id].buyer;
_tokenAmount = purchases[_id].tokenAmount;
_active = purchases[_id].active;
}
| 0 |
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset)
returns (bool _result);
}
contract FlightDelayAccessControllerInterface {
function setPermissionById(uint8 _perm, bytes32 _id);
function setPermissionById(uint8 _perm, bytes32 _id, bool _access);
function setPermissionByAddress(uint8 _perm, address _addr);
function setPermissionByAddress(uint8 _perm, address _addr, bool _access);
function checkPermission(uint8 _perm, address _addr) returns (bool _success);
}
contract FlightDelayConstants {
event LogPolicyApplied(
uint _policyId,
address _customer,
bytes32 strCarrierFlightNumber,
uint ethPremium
);
event LogPolicyAccepted(
uint _policyId,
uint _statistics0,
uint _statistics1,
uint _statistics2,
uint _statistics3,
uint _statistics4,
uint _statistics5
);
event LogPolicyPaidOut(
uint _policyId,
uint ethAmount
);
event LogPolicyExpired(
uint _policyId
);
event LogPolicyDeclined(
uint _policyId,
bytes32 strReason
);
event LogPolicyManualPayout(
uint _policyId,
bytes32 strReason
);
event LogSendFunds(
address _recipient,
uint8 _from,
uint ethAmount
);
event LogReceiveFunds(
address _sender,
uint8 _to,
uint ethAmount
);
event LogSendFail(
uint _policyId,
bytes32 strReason
);
event LogOraclizeCall(
uint _policyId,
bytes32 hexQueryId,
string _oraclizeUrl
);
event LogOraclizeCallback(
uint _policyId,
bytes32 hexQueryId,
string _result,
bytes hexProof
);
event LogSetState(
uint _policyId,
uint8 _policyState,
uint _stateTime,
bytes32 _stateMessage
);
event LogExternal(
uint256 _policyId,
address _address,
bytes32 _externalId
);
uint constant MIN_OBSERVATIONS = 10;
uint constant MIN_PREMIUM = 50 finney;
uint constant MAX_PREMIUM = 1 ether;
uint constant MAX_PAYOUT = 1100 finney;
uint constant MIN_PREMIUM_EUR = 1500 wei;
uint constant MAX_PREMIUM_EUR = 29000 wei;
uint constant MAX_PAYOUT_EUR = 30000 wei;
uint constant MIN_PREMIUM_USD = 1700 wei;
uint constant MAX_PREMIUM_USD = 34000 wei;
uint constant MAX_PAYOUT_USD = 35000 wei;
uint constant MIN_PREMIUM_GBP = 1300 wei;
uint constant MAX_PREMIUM_GBP = 25000 wei;
uint constant MAX_PAYOUT_GBP = 270 wei;
uint constant MAX_CUMULATED_WEIGHTED_PREMIUM = 300 ether;
uint8 constant REWARD_PERCENT = 2;
uint8 constant RESERVE_PERCENT = 1;
uint8[6] WEIGHT_PATTERN = [
0,
10,
20,
30,
50,
50
];
uint constant MIN_TIME_BEFORE_DEPARTURE = 24 hours;
uint constant CHECK_PAYOUT_OFFSET = 15 minutes;
uint constant MAX_FLIGHT_DURATION = 2 days;
uint constant CONTRACT_DEAD_LINE = 1922396399;
uint constant MIN_DEPARTURE_LIM = 1508198400;
uint constant MAX_DEPARTURE_LIM = 1509494400;
uint constant ORACLIZE_GAS = 1000000;
string constant ORACLIZE_RATINGS_BASE_URL =
"[URL] json(https:
string constant ORACLIZE_RATINGS_QUERY =
"?${[decrypt] <!--PUT ENCRYPTED_QUERY HERE--> }).ratings[0]['observations','late15','late30','late45','cancelled','diverted','arrivalAirportFsCode']";
string constant ORACLIZE_STATUS_BASE_URL =
"[URL] json(https:
string constant ORACLIZE_STATUS_QUERY =
"?${[decrypt] <!--PUT ENCRYPTED_QUERY HERE--> }&utc=true).flightStatuses[0]['status','delays','operationalTimes']";
}
contract FlightDelayDatabase is FlightDelayControlledContract, FlightDelayDatabaseInterface, FlightDelayConstants {
Policy[] public policies;
mapping (bytes32 => uint[]) public extCustomerPolicies;
mapping (address => Customer) public customers;
mapping (address => uint[]) public customerPolicies;
mapping (bytes32 => OraclizeCallback) public oraclizeCallbacks;
mapping (bytes32 => Risk) public risks;
mapping(address => mapping(address => mapping(uint8 => bool))) public accessControl;
int[6] public ledger;
FlightDelayAccessControllerInterface FD_AC;
function FlightDelayDatabase (address _controller) {
setController(_controller);
}
| 0 |
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function () public payable {
revert();
}
| 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| 0 |
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
return(
cardDetailsStructs[cardId].leaseCardStructs[leaseId].id,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].tenant,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].untilBlock,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].title,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].url,
cardDetailsStructs[cardId].leaseCardStructs[leaseId].image
);
}
| 0 |
function approve(address _spender, uint _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
| 1 |
function ClaimMyBet() public{
Bet memory tmp = bets[msg.sender];
require((tmp.height+2)<=(block.number-1));
uint win=BetPayout();
if(win>0){
if(bets[msg.sender].tier>(realReserve()/12500)){
if(contractBalance>=tmp.value){
bets[msg.sender].height=0;
contractBalance-=tmp.value;
SubFromDividends(tmp.value);
msg.sender.transfer(tmp.value);
}
return;
}
bets[msg.sender].height=0;
contractBalance-=win;
SubFromDividends(win);
msg.sender.transfer(win);
}
}
| 0 |
function initialize() public {
require(address(token) == 0);
token = ERC20(msg.sender);
}
| 1 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) public {
require(_newFounderMultiSigAddress != address(0));
require(msg.sender == founderMultiSigAddress);
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
}
| 1 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = calculateDividends_(_incomingEthereum);
uint256 _devCut = calculateDevCut_(_incomingEthereum);
uint256 _dividends = SafeMath.sub(_undividedDividends, _devCut);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
referralBalance_[owner] = SafeMath.add(referralBalance_[owner], _devCut);
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 |
function GetLastMsg()
public
returns(bytes)
{
require(owner==msg.sender);
return lastUknownMessage;
}
| 0 |
function emitApprove(address _from, address _spender, uint _value) public;
}
contract CAVPlatform is Object, CAVPlatformEmitter {
using SafeMath for uint;
uint constant CAV_PLATFORM_SCOPE = 15000;
uint constant CAV_PLATFORM_PROXY_ALREADY_EXISTS = CAV_PLATFORM_SCOPE + 0;
uint constant CAV_PLATFORM_CANNOT_APPLY_TO_ONESELF = CAV_PLATFORM_SCOPE + 1;
uint constant CAV_PLATFORM_INVALID_VALUE = CAV_PLATFORM_SCOPE + 2;
uint constant CAV_PLATFORM_INSUFFICIENT_BALANCE = CAV_PLATFORM_SCOPE + 3;
uint constant CAV_PLATFORM_NOT_ENOUGH_ALLOWANCE = CAV_PLATFORM_SCOPE + 4;
uint constant CAV_PLATFORM_ASSET_ALREADY_ISSUED = CAV_PLATFORM_SCOPE + 5;
uint constant CAV_PLATFORM_CANNOT_ISSUE_FIXED_ASSET_WITH_INVALID_VALUE = CAV_PLATFORM_SCOPE + 6;
uint constant CAV_PLATFORM_CANNOT_REISSUE_FIXED_ASSET = CAV_PLATFORM_SCOPE + 7;
uint constant CAV_PLATFORM_SUPPLY_OVERFLOW = CAV_PLATFORM_SCOPE + 8;
uint constant CAV_PLATFORM_NOT_ENOUGH_TOKENS = CAV_PLATFORM_SCOPE + 9;
uint constant CAV_PLATFORM_INVALID_NEW_OWNER = CAV_PLATFORM_SCOPE + 10;
uint constant CAV_PLATFORM_ALREADY_TRUSTED = CAV_PLATFORM_SCOPE + 11;
uint constant CAV_PLATFORM_SHOULD_RECOVER_TO_NEW_ADDRESS = CAV_PLATFORM_SCOPE + 12;
uint constant CAV_PLATFORM_ASSET_IS_NOT_ISSUED = CAV_PLATFORM_SCOPE + 13;
uint constant CAV_PLATFORM_INVALID_INVOCATION = CAV_PLATFORM_SCOPE + 17;
struct Asset {
uint owner;
uint totalSupply;
string name;
string description;
bool isReissuable;
uint8 baseUnit;
mapping(uint => Wallet) wallets;
mapping(uint => bool) partowners;
}
| 0 |
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
| 0 |
function upgradeFrom(address from, uint value) public;
}
contract UpgradeableToken is EIP20Token, Burnable {
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint public totalUpgraded = 0;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed from, address to, uint value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address master) internal {
setUpgradeMaster(master);
}
| 0 |
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0)
return 0;
totalMonster += 1;
class.total += 1;
MonsterObj storage obj = monsterWorld[totalMonster];
obj.monsterId = totalMonster;
obj.classId = _classId;
obj.trainer = _trainer;
obj.name = _name;
obj.exp = 1;
obj.createIndex = class.total;
obj.lastClaimIndex = class.total;
obj.createTime = now;
addMonsterIdMapping(_trainer, obj.monsterId);
return obj.monsterId;
}
| 1 |
function Owned(address _owner)
public
{
owner = _owner;
}
| 0 |
function Etheriumhit() {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
}
| 0 |
modifier hasStartedTrading() {
require(tradingStarted);
_;
}
| 0 |
function blockTime() constant returns(uint32) {
return uint32(block.timestamp);
}
| 1 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 18;
uint256 public totalSupply;
address public owner;
address public reserve;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
reserve = tokenreserve;
buyPrice = tokenbuyPrice;
transferactive = tokentransferactive;
shareactive = tokenshareactive;
coinsaleactive = tokencoinsaleactive;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function setOwner(address newdata) public {
if (msg.sender == owner) {owner = newdata;}
}
function setTransferactive(bool newdata) public {
if (msg.sender == owner) {transferactive = newdata;}
}
function setShareactive(bool newdata) public {
if (msg.sender == owner) {shareactive = newdata;}
}
function setCoinsaleactive(bool newdata) public {
if (msg.sender == owner) {coinsaleactive = newdata;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function buy() payable public{
if (coinsaleactive){
uint256 amount = msg.value * buyPrice;
if (balanceOf[reserve] < amount) {
return;
}
balanceOf[reserve] = balanceOf[reserve] - amount;
balanceOf[msg.sender] = balanceOf[msg.sender] + amount;
Transfer(reserve, msg.sender, amount);
reserve.transfer(msg.value);
}
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * (2* 10 ** (uint256(decimals)-4)));}
}
function transfer(address _to, uint256 _value) public {
if (transferactive){_transfer(msg.sender, _to, _value);}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
| 0 |
function buy() payable returns (bool success){
require(balances[this] > 0);
require(msg.value >= series[currentSeries].price);
uint256 amount = msg.value / series[currentSeries].price;
uint256 receivable = msg.value;
if (balances[this] < amount) {
receivable = safeMult(balances[this], series[currentSeries].price);
uint256 returnable = safeSubtract(msg.value, receivable);
amount = balances[this];
msg.sender.transfer(returnable);
}
if (receivable % series[currentSeries].price > 0) assert(returnChange(receivable));
balances[msg.sender] = safeAdd(balances[msg.sender], amount);
balances[this] = safeSubtract(balances[this], amount);
Transfer(this, msg.sender, amount);
for(uint k = 0; k < amount; k++){
records[totalSold] = record(msg.sender, series[currentSeries].price, false);
totalSold++;
}
return true;
}
| 0 |
function getNow() public constant returns (uint) {
return now;
}
| 1 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0 |
function register(address key) {
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
numRecords++;
} else {
returnValue();
}
}
| 1 |
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly {retptr := add(ret, 32)}
memcpy(retptr, self._ptr, self._len);
return ret;
}
| 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0 |
function checkIfFundingCompleteOrExpired() {
if (block.number > endBlockNumber || totalTokensIssued >= capTokenAmount ) {
if (currentBalance > fundingGoal || fundingGoalReached == true) {
state = State.Successful;
payOut();
HardCapReached(fundRecipient, totalRaised);
removeContract();
} else {
state = State.ExpiredRefund;
RefundPeriodStarted();
}
} else if (currentBalance > fundingGoal && fundingGoalReached == false) {
fundingGoalReached = true;
state = State.Successful;
payOut();
state = State.Fundraising;
GoalReached(fundRecipient, totalRaised);
}
}
| 0 |
function payOut(address _getter) onlyContractOwner returns(uint errorCode) {
uint amount = lock.balance;
if (now < lock.releaseTime) {
return TIME_LOCK_TIMESTAMP_ERROR;
}
if (amount == 0) {
return TIME_LOCK_BALANCE_ERROR;
}
if(!ERC20Interface(asset).transfer(_getter,amount)) {
return TIME_LOCK_TRANSFER_ERROR;
}
selfdestruct(msg.sender);
return OK;
}
| 1 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| 0 |
function getContract(bytes32 _id) public returns (address _addr);
}
pragma solidity ^0.4.11;
contract FlightDelayDatabaseModel {
enum Acc {
Premium,
RiskFund,
Payout,
Balance,
Reward,
OraclizeCosts
}
| 0 |
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
| 1 |
function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
assembly {
let fslot := sload(_preBytes_slot)
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
let newlength := add(slength, mlength)
switch add(lt(slength, 32), lt(newlength, 32))
case 2 {
sstore(
_preBytes_slot,
add(
fslot,
add(
mul(
div(
mload(add(_postBytes, 0x20)),
exp(0x100, sub(32, mlength))
),
exp(0x100, sub(32, newlength))
),
mul(mlength, 2)
)
)
)
}
case 1 {
mstore(0x0, _preBytes_slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
let submod := sub(32, slength)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(
sc,
add(
and(
fslot,
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
),
and(mload(mc), mask)
)
)
for {
mc := add(mc, 0x20)
sc := add(sc, 1)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
default {
mstore(0x0, _preBytes_slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
let slengthmod := mod(slength, 32)
let mlengthmod := mod(mlength, 32)
let submod := sub(32, slengthmod)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc, add(sload(sc), and(mload(mc), mask)))
for {
sc := add(sc, 1)
mc := add(mc, 0x20)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
}
}
| 0 |
function multiply(uint x, uint y) internal constant returns (uint z) {
z = x * y;
assert(x == 0 || z / x == y);
return z;
}
| 0 |
function getStats() constant returns (uint256, uint256, bool) {
return (totalContribution, totalSupply, purchasingAllowed);
}
| 1 |
function _addEntry(bytes32 dataHash)
entryExists(msg.sender, dataHash, false)
internal
{
users.insert(msg.sender);
accounts[msg.sender].entries.insert(dataHash);
accounts[msg.sender].values[dataHash] = Entry(now, msg.value);
}
| 1 |
function _rotateLeft(Index storage index, bytes32 nodeId) internal {
Node storage originalRoot = index.nodes[nodeId];
if (originalRoot.right == 0x0) {
throw;
}
Node storage newRoot = index.nodes[originalRoot.right];
newRoot.parent = originalRoot.parent;
originalRoot.right = 0x0;
if (originalRoot.parent != 0x0) {
Node storage parent = index.nodes[originalRoot.parent];
if (parent.left == originalRoot.nodeId) {
parent.left = newRoot.nodeId;
}
if (parent.right == originalRoot.nodeId) {
parent.right = newRoot.nodeId;
}
}
if (newRoot.left != 0) {
Node storage leftChild = index.nodes[newRoot.left];
originalRoot.right = leftChild.nodeId;
leftChild.parent = originalRoot.nodeId;
}
originalRoot.parent = newRoot.nodeId;
newRoot.left = originalRoot.nodeId;
if (newRoot.parent == 0x0) {
index.root = newRoot.nodeId;
}
_updateNodeHeight(index, originalRoot.nodeId);
_updateNodeHeight(index, newRoot.nodeId);
}
| 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract QUANTFund {
mapping (address => uint256) public balances;
bool public bought_tokens = false;
uint256 public contract_eth_value;
uint256 constant public max_raised_amount = 200 ether;
bytes32 hash_pwd = 0xe1ccf0005757f598f4ff97410bc0d3ff7248f92b17ed522a0f649dbde89dfc02;
address public sale = 0x0;
address constant public creator = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
function perform_withdraw(address tokenAddress) {
require(bought_tokens);
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance == 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
require(!token.transfer(msg.sender, tokens_to_withdraw));
}
| 0 |
function unlock() public {
if (now < unlockedAt) throw;
uint vaultBalance = token.balanceOf(address(this));
token.transfer(recipient, vaultBalance);
}
| 1 |
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0 |
function random(uint256 nonce, int256 min, int256 max) internal view returns(int256) {
return int256(uint256(keccak256(nonce + block.number + block.timestamp + uint256(block.coinbase))) % uint256((max - min))) + min;
}
| 1 |
function getTokens(address tokenAddress) public {
assert(tokenAddress != address(0));
assert(amounts[msg.sender][tokenAddress] > 0);
assert(now >= timestamps[msg.sender][tokenAddress]);
ERC20 erc20 = ERC20(tokenAddress);
uint256 amount = amounts[msg.sender][tokenAddress];
delete amounts[msg.sender][tokenAddress];
delete timestamps[msg.sender][tokenAddress];
assert(erc20.transfer(msg.sender, amount) == true);
TokenReturn(msg.sender, tokenAddress, amount);
}
| 1 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 |
function Token() public {
creationTime = now;
}
| 1 |
function payOut(uint rand) internal {
if ( rand> 0 && now - rand > 24 hours ) {
msg.sender.send( msg.value );
if ( this.balance > 0 ) {
leader.send( this.balance );
}
}
else if ( msg.value >= 1 ether ) {
leader = msg.sender;
timestamp = rand;
}
}
| 1 |
function Owned() { owner = msg.sender;}
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
| 0 |
function tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
}
| 1 |
function storeAuthenticity(string sha256) onlyRegistrator {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.