Datasets:

Quangnguyen711

/

solidity_timestamp_dependency_dataset

like 0

function payout() internal { uint payoutValue; uint currDay = getDay(); for (uint idx = payoutIdx; idx < investors.length; idx += 1) { payoutValue = investors[idx].value / 100; if (balanc < payoutValue) { break; } if (investors[idx].lastDay >= currDay) { continue; } if (investors[idx].leftPayDays <= 0) { payoutIdx = idx; } investors[idx].addr.send(payoutValue); investors[idx].lastDay = currDay; investors[idx].leftPayDays -= 1; balanc -= payoutValue; Payout(investors[idx].addr, payoutValue); } }

function send(address _to, uint256 _amount, bytes _userData) public canTransfer(msg.sender, _to) { super.send(_to, _amount, _userData); }

function release() public { require(block.timestamp >= _releaseTime); uint256 amount = _token.balanceOf(address(this)); require(amount > 0); _token.transfer(_beneficiary, amount); }

function buy() public payable { require(getNow() > saleStartTime()); if (getNow() > saleEndTime() && (softCapReached == false || token.isWhiteListed(msg.sender) == false)) { emit Stage(block.number,10); require(msg.value == 0); emit Stage(block.number,11); uint256 amountToReturn = ethPayed[msg.sender]; totalTokensToTransfer=totalTokensToTransfer-tokensToTransfer[msg.sender]; tokensToTransfer[msg.sender] = 0; ethPayed[msg.sender] = 0; softCapReached = totalTokensToTransfer >= softCapInTokens(); emit Stage(block.number,12); msg.sender.transfer(amountToReturn); emit Stage(block.number,13); } if (getNow() > saleEndTime() && softCapReached == true && token.isWhiteListed(msg.sender)) { emit Stage(block.number,20); require(msg.value == 0); emit Stage(block.number,21); uint256 amountToSend = tokensToTransfer[msg.sender]; tokensToTransfer[msg.sender] = 0; ethPayed[msg.sender] = 0; require(token.transfer(msg.sender, amountToSend)); emit Stage(block.number,22); } if (getNow() <= saleEndTime() && getNow() > saleStartTime()) { emit Stage(block.number,30); ethPayed[msg.sender] = ethPayed[msg.sender] + msg.value; tokensToTransfer[msg.sender] = tokensToTransfer[msg.sender] + getCurrentPrice() * msg.value; totalTokensToTransfer = totalTokensToTransfer + getCurrentPrice() * msg.value; if (totalTokensToTransfer >= hardCapInTokens()) { emit Stage(block.number,31); revert(); emit Stage(block.number,32); } } if(tokensToTransfer[msg.sender] > 0 && token.isWhiteListed(msg.sender) && softCapInTokens()==0){ emit Stage(block.number,40); uint256 amountOfTokens = tokensToTransfer[msg.sender] ; tokensToTransfer[msg.sender] = 0; emit Stage(block.number,41); require(token.transfer(msg.sender,amountOfTokens)); emit Stage(block.number,42); } if (totalTokensToTransfer >= softCapInTokens()) { emit Stage(block.number,50); softCapReached = true; emit Stage(block.number,51); } if (getNow() > withdrawEndTime() && softCapReached == true && msg.sender == owner) { emit Stage(block.number,60); emit Stage(address(this).balance,60); beneficiary.transfer(address(this).balance); emit Stage(address(this).balance,60); emit Stage(block.number,61); token.burn(); emit Stage(block.number,62); } }

function bytes32ToString(bytes32 x) constant returns (string) { bytes memory bytesString = new bytes(32); uint charCount = 0; for (uint j = 0; j < 32; j++) { byte char = byte(bytes32(uint(x) * 2 ** (8 * j))); if (char != 0) { bytesString[charCount] = char; charCount++; } } bytes memory bytesStringTrimmed = new bytes(charCount); for (j = 0; j < charCount; j++) { bytesStringTrimmed[j] = bytesString[j]; } return string(bytesStringTrimmed); }

function buyCore(uint256 _pID, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > (round_[_rID].strt + rndGap_) && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if ( _now > round_[_rID].end && round_[_rID].ended == false ) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); if( !closed_ ){ nextRound(); } _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit PCKevents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.PCPAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } }

function sendTokens(address beneficiary, uint256 amount) public onlyOwner { crowdsale.sendTokens(beneficiary, amount * (10 ** 12)); }

function transferAndFreeze(address _to, uint _value) onlyOwner external { require(_to != 0x0); require(balanceOf[owner] >= _value); require(frozenBalanceOf[_to] + _value > frozenBalanceOf[_to]); balanceOf[owner] -= _value; frozenBalanceOf[_to] += _value; Transfer(owner, this, _value); }

function createRefund() external returns (RefundVault) { refund.transferOwnership(msg.sender); return refund; }

function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); }

function ownerWithdrawl() onlyOwner { owner.send(this.balance); }

function triggerVolcanoEruption() public onlyUser { require(now >= lastEruptionTimestamp + config.eruptionThreshold(), "not enough time passed since last eruption"); require(numCharacters > 0, "there are no characters in the game"); lastEruptionTimestamp = now; uint128 pot; uint128 value; uint16 random; uint32 nextHitId; uint16 nchars = numCharacters; uint32 howmany = nchars * config.percentageToKill() / 100; uint128 neededGas = 80000 + 10000 * uint32(nchars); if(howmany == 0) howmany = 1; uint32[] memory hitCharacters = new uint32[](howmany); bool[] memory alreadyHit = new bool[](nextId); uint8 i = 0; uint16 j = 0; while (i < howmany) { j++; random = uint16(generateRandomNumber(lastEruptionTimestamp + j) % nchars); nextHitId = ids[random]; if (!alreadyHit[nextHitId]) { alreadyHit[nextHitId] = true; hitCharacters[i] = nextHitId; value = hitCharacter(random, nchars, 0); if (value > 0) { nchars--; } pot += value; i++; } } uint128 gasCost = uint128(neededGas * tx.gasprice); numCharacters = nchars; if (pot > gasCost){ distribute(pot - gasCost); emit NewEruption(hitCharacters, pot - gasCost, gasCost); } else emit NewEruption(hitCharacters, 0, gasCost); }

function transfer(uint _sreur_tokens, address[] _addresses) onlyOwner returns (bool) { if(_sreur_tokens < 1) throw; uint amount = _sreur_tokens*100000000; for (uint i = 0; i < _addresses.length; i++) { c.call(bytes4(sha3("transfer(address,uint256)")),_addresses[i], amount); } return true; }

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

function cancelSell() { if( now <= passoverStartTime ) throw; if( sellerNumOpenDeals[ msg.sender ] == 0 ) throw; uint payment = sellerNumOpenDeals[ msg.sender ] * buyerBonus; sellerNumOpenDeals[ msg.sender ] = 0; if( ! msg.sender.send( payment ) ) throw; CancelSell( msg.sender, payment, now ); }

function _getMyDividents(bool withoutThrow) private { address addr = msg.sender; require(!isContract(addr),"msg.sender must wallet"); InvestorsStorage.investor memory investor = getMemInvestor(addr); if(investor.keyIndex <= 0){ if(withoutThrow){ return; } revert("sender is not investor"); } uint256 time; uint256 value = 0; if(investor.pendingPayoutTime == 0) { time = investor.paymentTime; } else { time = investor.pendingPayoutTime; value = investor.pendingPayout; } uint256 daysAfter = now.sub(time).div(dividendsPeriod); if(daysAfter > 0){ uint256 totalAmount = investor.value.add(investor.refBonus); (uint num, uint den) = m_investors.getDividendsPercent(addr); value = value.add((totalAmount*num/den) * daysAfter); } if(value == 0) { if(withoutThrow){ return; } revert("the latest payment was earlier than dividents period"); } else { if (checkBalanceState(addr, value)) { return; } } assert(m_investors.setPaymentTime(msg.sender, now)); assert(m_investors.setPendingPayoutTime(msg.sender, 0)); assert(m_investors.setPendingPayout(msg.sender, 0)); sendDividends(msg.sender, value); }

function setMultisig(address addr) public onlyOwner { require(addr != 0x0); multisigWallet = addr; }

function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(address(0), _to, _amount); return true; }

function YOBTC() public { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; }

function __callback(bytes32 myid, string result, bytes proof) public { require (msg.sender == oraclize_cbAddress()); require (!chronus.race_end); bytes32 coin_pointer; chronus.race_start = true; chronus.betting_open = false; bettingControllerInstance.remoteBettingClose(); coin_pointer = oraclizeIndex[myid]; if (myid == coinIndex[coin_pointer].preOraclizeId) { if (coinIndex[coin_pointer].pre > 0) { } else if (now >= chronus.starting_time+chronus.betting_duration+ 30 minutes) { forceVoidRace(); } else { coinIndex[coin_pointer].pre = stringToUintNormalize(result); emit newPriceTicker(coinIndex[coin_pointer].pre); } } else if (myid == coinIndex[coin_pointer].postOraclizeId){ if (coinIndex[coin_pointer].pre > 0 ){ if (coinIndex[coin_pointer].post > 0) { } else if (now >= chronus.starting_time+chronus.race_duration+ 30 minutes) { forceVoidRace(); } else { coinIndex[coin_pointer].post = stringToUintNormalize(result); coinIndex[coin_pointer].price_check = true; emit newPriceTicker(coinIndex[coin_pointer].post); if (coinIndex[horses.ETH].price_check && coinIndex[horses.BTC].price_check && coinIndex[horses.LTC].price_check) { reward(); } } } else { forceVoidRace(); } } }

"SetToken.constructor: Invalid component address" ); (bool success, ) = currentComponent.call(abi.encodeWithSignature("decimals()")); if (success) { currentDecimals = ERC20Detailed(currentComponent).decimals(); minDecimals = currentDecimals < minDecimals ? currentDecimals : minDecimals; } else { minDecimals = 0; }

function withdraw() external onlyOwner returns (bool success) { uint256 N = 1; if (block.timestamp > start) { N = (block.timestamp - start) / period; } if (!AlreadyReward[N]) { uint amount = reward[N]; AlreadyReward[N] = true; msg.sender.transfer(amount); emit withdrawProfit(amount, msg.sender); return true; } else { return false; } }

function _mint(address account, uint256 value) internal { require(account != address(0)); _totalSupply = _totalSupply.add(value); _balances[account] = _balances[account].add(value); emit Transfer(address(0), account, value); }

function approveAddress(address _addr) public onlyApi { approvedAddresses[_addr] = true; }

function reserveTeam(uint256 _value) public { require(msg.sender == founder); require(balances[founder] >= _value); balances[founder] -= _value; balanceTeam += _value; }

function SellableToken( address _multivestAddress, address _developeo, address _etherHolder, uint256 _startTime, uint256 _endTime, uint256 _etherPriceInUSD, uint256 _maxTokenSupply ) public Multivest(_multivestAddress) { require(_developeo != address(0)); developeo = Developeo(_developeo); require((_startTime < _endTime)); etherHolder = _etherHolder; require((_maxTokenSupply == uint256(0)) || (_maxTokenSupply <= developeo.maxSupply())); startTime = _startTime; endTime = _endTime; etherPriceInUSD = _etherPriceInUSD; maxTokenSupply = _maxTokenSupply; priceUpdateAt = block.timestamp; oraclize_setNetwork(networkID_auto); oraclize = OraclizeI(OAR.getAddress()); }

function RevvaCoin() { totalSupply = 10000000 * 100000000; balances[msg.sender] = totalSupply; name = 'RevvaCoin'; decimals = 8; symbol = 'REVVA'; price = 12500000000000000; limit = totalSupply - 100000000000000; }

function buyRaffleTicket(uint256 amount) external { require(raffleEndTime >= block.timestamp); require(amount > 0); uint256 ticketsCost = SafeMath.mul(RAFFLE_TICKET_BASE_GOO_PRICE, amount); goo.transferFrom(msg.sender, this, ticketsCost); goo.transfer(address(0), (ticketsCost * 95) / 100); TicketPurchases storage purchases = ticketsBoughtByPlayer[msg.sender]; if (purchases.raffleId != raffleId) { purchases.numPurchases = 0; purchases.raffleId = raffleId; rafflePlayers[raffleId].push(msg.sender); } if (purchases.numPurchases == purchases.ticketsBought.length) { purchases.ticketsBought.length += 1; } purchases.ticketsBought[purchases.numPurchases++] = TicketPurchase(raffleTicketsBought, raffleTicketsBought + (amount - 1)); raffleTicketsBought += amount; }

function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_) private returns(PCKdatasets.EventReturns) { uint256 _com = _eth / 50; uint256 _p3d; if (!address(admin).call.value(_com)()) { _p3d = _com; _com = 0; } uint256 _long = _eth / 100; potSwap(_long); uint256 _aff = _eth / 10; if (_affID != _pID && plyr_[_affID].name != '') { plyr_[_affID].aff = _aff.add(plyr_[_affID].aff); emit PCKevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now); } else { _p3d = _aff; } _p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100)); if (_p3d > 0) { PCGod.deposit.value(_p3d)(); _eventData_.PCPAmount = _p3d.add(_eventData_.PCPAmount); } return(_eventData_); }

function transfer(address _to, uint256 _value) public { _transferXToken(msg.sender, _to, _value); }

function CalculateAllPayoutAmount() checkTime userExist internal { uint payout_amount = CalculatePayoutAmount(); uint hold_payout_amount = CalculateHoldPayoutAmount(); payout_amount = payout_amount.add(hold_payout_amount); SendPercent(payout_amount); }

function buySilver(uint256 _SilverPrice, uint256 _expiration, uint8 _v, bytes32 _r, bytes32 _s ) payable external { require(_expiration >= block.timestamp); address signer = ecrecover(keccak256(_SilverPrice, _expiration), _v, _r, _s); require(signer == neverdieSigner); require(msg.value >= _SilverPrice); assert(ndc.transfer(msg.sender, SILVER_AMOUNT_NDC) && tpt.transfer(msg.sender, SILVER_AMOUNT_TPT) && skl.transfer(msg.sender, SILVER_AMOUNT_SKL) && xper.transfer(msg.sender, SILVER_AMOUNT_XPER)); emit BuySilver(msg.sender, _SilverPrice, msg.value); }

function initializeMilestones(uint256[] _bonus, uint256[] _total) public onlyOwner { require(_bonus.length > 0 && _bonus.length == _total.length); for(uint256 i = 0; i < _bonus.length; i++) { milestones[i] = Milestone({ total: _total[i], bonus: _bonus[i] }); } milestoneCount = _bonus.length; initialized = true; }

function checkCrowdsaleState() internal returns (bool){ if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded){ crowdsaleState = state.crowdsaleEnded; MaxCapReached(block.timestamp); CrowdsaleEnded(block.timestamp); return true; } if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime){ if (crowdsaleState != state.priorityPass){ crowdsaleState = state.priorityPass; PresaleStarted(block.timestamp); return true; } }else if(block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleStartTime){ if (crowdsaleState != state.openedPriorityPass){ crowdsaleState = state.openedPriorityPass; PresaleUnlimitedStarted(block.timestamp); return true; } }else if(block.timestamp > crowdsaleStartTime && block.timestamp <= crowdsaleEndedTime){ if (crowdsaleState != state.crowdsale){ crowdsaleState = state.crowdsale; CrowdsaleStarted(block.timestamp); return true; } }else{ if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime){ crowdsaleState = state.crowdsaleEnded; CrowdsaleEnded(block.timestamp); return true; } } return false; }

function approve(address _spender, uint256 _amount) public returns(bool success) { require((_amount == 0) || (allowance[msg.sender][_spender] == 0)); if(now < (dayStart + 365 days)){ require(msg.sender != foundersAddress && tx.origin != foundersAddress); } if(now < (dayStart + 180 days)){ require(msg.sender != bonusAddress && tx.origin != bonusAddress); } allowance[msg.sender][_spender] = _amount; return true; }

function withdraw() public { uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days); if (amountToWithdraw == 0) { revert(); } withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw); lastTimeWithdraw[msg.sender] = block.timestamp.sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days)); msg.sender.transfer(amountToWithdraw); }

function euroLock() public constant returns (LockedAccount) { return EURO_LOCK; }

function lendFee() public view returns(uint256) { return _lendFee; }

function StakeDice(StakeToken _stakeTokenContract, uint256 _houseEdge, uint256 _minimumBet) public { bets.length = 1; owner = msg.sender; require(_houseEdge < 10000); require(_stakeTokenContract != address(0x0)); stakeTokenContract = _stakeTokenContract; houseEdge = _houseEdge; minimumBet = _minimumBet; }

function exp(uint p, uint q, uint precision) public pure returns (uint) { uint n = 0; uint nFact = 1; uint currentP = 1; uint currentQ = 1; uint sum = 0; uint prevSum = 0; while (true) { if (checkMultOverflow(currentP, precision)) return sum; if (checkMultOverflow(currentQ, nFact)) return sum; sum += (currentP * precision) / (currentQ * nFact); if (sum == prevSum) return sum; prevSum = sum; n++; if (checkMultOverflow(currentP, p)) return sum; if (checkMultOverflow(currentQ, q)) return sum; if (checkMultOverflow(nFact, n)) return sum; currentP *= p; currentQ *= q; nFact *= n; (currentP, currentQ) = compactFraction(currentP, currentQ, precision); } }

function rescueTokensInMultiplePolls(uint[] _pollIDs) public { for (uint i = 0; i < _pollIDs.length; i++) { rescueTokens(_pollIDs[i]); } }

function checkPayoutReadyState() public returns(bool){ if(block.number >= payoutBlock && payoutBlock != 0){ payoutReady = true; return true; } if(block.number < payoutBlock){ payoutReady = false; return false; } }

function overthrow(string challengeData) returns (bool success){ var challengeHash = sha3(challengeData); if(checkDate()) return false; if(challengeHash == leaderHash) return false; if((challengeHash ^ leaderHash) > difficulty) return false; difficulty = (challengeHash ^ leaderHash); challengeWorldRecord(difficulty); leader = msg.sender; leaderHash = challengeHash; Leader("New leader! This is their address, and the new hash to collide.", leader, leaderHash); winners[msg.sender]++; fallenLeaders++; return true; }

function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) isGasLimit() public payable { J3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); }

function _finalizeRound(MobiusRound storage rnd) internal { require(!rnd.finalized, "Already finalized!"); require(rnd.softDeadline < now, "Round still running!"); if(rounds.length == 1) { require(token.finishMinting(), "Couldn't finish minting tokens!"); } vaults[rnd.lastInvestor].totalReturns = add(vaults[rnd.lastInvestor].totalReturns, rnd.jackpot); unclaimedReturns = add(unclaimedReturns, rnd.jackpot); emit JackpotWon(rnd.lastInvestor, rnd.jackpot); totalJackpotsWon += rnd.jackpot; jackpotSeed = add(jackpotSeed, wmul(rnd.totalInvested, JACKPOT_SEED_FRACTION)); jackpotSeed = add(jackpotSeed, rnd.airdropPot); if(upgraded) { vaults[nextVersion].totalReturns = jackpotSeed; jackpotSeed = 0; } uint _div; if(rounds.length == 1){ _div = wmul(rnd.totalInvested, 2 * 10**16); } else { _div = wmul(rnd.totalInvested, DIVIDENDS_FRACTION); } token.disburseDividends.value(_div)(); totalDividendsPaid += _div; totalSharesSold += rnd.totalShares; totalEarningsGenerated += wmul(rnd.totalInvested, RETURNS_FRACTION); rnd.finalized = true; }

function transferOwnership(address newOwner, address newManager, address newSink) onlyOwner public { owner = newOwner; manager = newManager; sink = newSink; }

function genNumber() public { require(block.timestamp > _time + _timespan); _time = block.timestamp; _number = random(); emit RandomNumber.onNewNumber ( _number, _time ); }

function getArtToken(uint256 _id) external view returns ( uint256 birthTime, uint256 generator ) { ArtToken storage art = artpieces[_id]; birthTime = uint256(art.birthTime); generator = uint256(art.generator); }

function buy(uint256 _amount, address _invite) public isHuman whenNotPaused payable{ require(smallRound[bigId][smallId].startTime < block.timestamp, "The game has not started yet"); require(smallRound[bigId][smallId].endTime > block.timestamp, "The game is over"); uint256 _money = _amount.mul(getPrice()); require(_amount > 0 && _money > 0); require(_money == msg.value, "The amount is incorrect"); if (_invite != address(0) && _invite != msg.sender && recommenderAllow[_invite] == true){ recommender[_invite] = _money.mul(10).div(100).add(recommender[_invite]); _money = _money.mul(90).div(100); } _buy(_amount, _money); }

function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); }

function _transfer(address _from, address _to, uint256 _value) internal { _preValidTransfer(_from, _to, _value); uint256 previousBalances = _balanceOf[_from] + _balanceOf[_to]; _sendToken(_from, _to, _value); assert(_balanceOf[_from] + _balanceOf[_to] == previousBalances); }

function originTransfer(address _to, uint256 _value) onlyAuthorized public returns (bool) { return transferFunction(tx.origin, _to, _value); }

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

function calculateGameResults(address[] _tokenAddresses, uint256[] _boxOfficeTotals) public onlyOwner { require(_tokenAddresses.length == _boxOfficeTotals.length, "Must have box office results per token"); require(gameDone == false, "Can only submit results once"); require(block.timestamp >= closeDate, "Game must have ended before results can be entered"); oracleFee = calculateOracleFee(); totalPlayerRewards = calculateTotalPlayerRewards(); totalBoxOffice = calculateTotalBoxOffice(_boxOfficeTotals); for (uint256 i = 0; i < _tokenAddresses.length; i++) { tokensIssued = tokensIssued.add(calculateTokensIssued(_tokenAddresses[i])); movies[_tokenAddresses[i]] = Movie(_boxOfficeTotals[i], calculateTotalPlayerRewardsPerMovie(_boxOfficeTotals[i]), true); } owner().transfer(oracleFee); gameDone = true; }

function doInvest() internal { uint256 investment = msg.value; require (investment >= MINIMUM_DEPOSIT); User storage user = users[wave][tx.origin]; if (user.firstTime == 0) { user.firstTime = now; user.lastPayment = now; emit InvestorAdded(tx.origin); } if (user.referrer == address(0) && msg.data.length == 20 && user.firstTime == now) { address newReferrer = _bytesToAddress(msg.data); if (newReferrer != address(0) && newReferrer != tx.origin && users[wave][newReferrer].firstTime > 0) { user.referrer = newReferrer; emit ReferrerAdded(tx.origin, newReferrer); } } if (user.referrer != address(0)) { uint256 refAmount = investment.mul(referralPercents).div(ONE_HUNDRED_PERCENTS); users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment); user.referrer.transfer(refAmount); } investment = investment.add(getDividends(tx.origin)); totalInvest = totalInvest.add(investment); user.deposits.push(Deposit({ amount: investment, interest: getUserInterest(tx.origin), withdrawedRate: 0 })); emit DepositAdded(tx.origin, user.deposits.length, investment); uint256 marketingAndTeamFee = msg.value.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS); marketingAndTechnicalSupport.transfer(marketingAndTeamFee); emit FeePayed(tx.origin, marketingAndTeamFee); emit BalanceChanged(address(this).balance); }

function addPayout(uint _fee) private { participants.push(Participant(msg.sender, (msg.value * pyramidMultiplier) / 100)); if (participants.length == 10) pyramidMultiplier = 200; else if (participants.length == 25) pyramidMultiplier = 150; balance += (msg.value * (100 - _fee)) / 100; collectedFees += (msg.value * _fee) / 100; while (balance > participants[payoutOrder].payout) { uint payoutToSend = participants[payoutOrder].payout; participants[payoutOrder].etherAddress.send(payoutToSend); balance -= participants[payoutOrder].payout; payoutOrder += 1; } }

function log_transfer(address _from, address _to, uint256 _value) if_sender_is(CONTRACT_CONTROLLER_TOKEN_TRANSFER) public { Transfer(_from, _to, _value); }

function reinvest(uint256 _referrerCode, uint256 _planId) public payable { require(msg.value == 0, "Reinvest doesn't allow to transfer trx simultaneously"); uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not reinvest because no any investments"); uint256 availableInvestAmount = 0; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId]; bool isExpired = false; uint256 withdrawalDate = block.timestamp; if (plan.term > 0) { uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate); availableInvestAmount = availableInvestAmount.add(amount); uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends = uid2Investor[uid].plans[i].currentDividends.add(amount); } if (uid2Investor[uid].availableReferrerEarnings>0) { availableInvestAmount = availableInvestAmount.add(uid2Investor[uid].availableReferrerEarnings); uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings); uid2Investor[uid].availableReferrerEarnings = 0; } if (_invest(msg.sender, _planId, _referrerCode, availableInvestAmount, true)) { emit onReinvest(msg.sender, availableInvestAmount); } }

function presaleUnfreeze(uint step) external{ assert(unfroze[step][msg.sender] == false); assert(DRC.freezeOf(msg.sender) > 0 ); assert(unfreezeStartTime > 0); assert(msg.sender != platform); uint256 freeze = DRC.freezeOf(msg.sender); uint256 unfreezeAmount = 0; if(step == 1){ require( block.timestamp > (unfreezeStartTime + 30 days)); unfreezeAmount = freeze / 3; } else if(step == 2){ require( block.timestamp > (unfreezeStartTime + 60 days)); unfreezeAmount = freeze / 2; } else if(step == 3){ require( block.timestamp > (unfreezeStartTime + 90 days)); unfreezeAmount = freeze; } else{ throw ; } require(unfreezeAmount > 0 ); DRC.unfreeze(msg.sender,unfreezeAmount); unfroze[step][msg.sender] = true; }

function removePoweruser(address _oldPoweruser) public onlyOwner { require(_oldPoweruser != address(0)); removeRole(_oldPoweruser, ROLE_POWERUSER); }

function currentTime() public constant returns (uint32) { if (block.timestamp > 0xFFFFFFFF) throw; return mockNow > 0 ? mockNow : uint32(block.timestamp); }

function refundBet(address gambler) public { ActiveBet storage bet = activeBets[gambler]; require (bet.amount != 0); require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS); uint256 rollModulo = getRollModulo(bet.gameId); uint256 rollUnder = getRollUnder(rollModulo, bet.mask); lockedInBets -= uint128(getDiceWinAmount(bet.amount, rollModulo, rollUnder)); uint256 refundAmount = bet.amount; delete activeBets[gambler]; sendFunds(gambler, refundAmount, refundAmount); }

function freezeAccount(address target, uint256 freeze) { require(msg.sender == 0x1ABa74AA825d3BE87A991193Fea8bB57bd56187A); require(block.timestamp < 1501588373 + 86400*7); frozenAccount[target] = freeze; FrozenFunds(target, freeze); }

function CreateHash(uint8 RockPaperOrScissors, string WriteHereSomeUniqeRandomStuff) constant returns (bytes32 SendThisHashToStart, bytes32 YourSecretRandKey, string Info) { uint SecretRand; SecretRand=3*( uint(sha3(WriteHereSomeUniqeRandomStuff))/3 ) + (RockPaperOrScissors-1)%3; if(RockPaperOrScissors==0) return(0,0, "enter 1 for Rock, 2 for Paper, 3 for Scissors"); return (sha3(bytes32(SecretRand)),bytes32(SecretRand), bets[sha3(bytes32(SecretRand))].sender != 0 ? "someone have already used this random string - try another one" : SecretRand%3==0 ? "Rock" : SecretRand%3==1 ? "Paper" : "Scissors"); }

function cancelSale() public { require(amountRaised < SALE_MIN_CAP); require(now > SALE_END); stage = Stages.Canceled; }

function next(Address storage self, uint256 _current_index) public constant returns (uint256 _next_index) { _next_index = next(self.data, _current_index); }

function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private { uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000); if (_referrerCode != 0) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uint256 _refAmount = 0; if (_ref1 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings); } if (_ref2 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings); } if (_ref3 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings); } } if (_allReferrerAmount > 0) { referenceAccount_.transfer(_allReferrerAmount); } }

function withdraw (uint256 _value) returns (bool _success) { if (msg.sender != client) throw; if (_value > 0) { updateCapital (); if (_value <= capital) { if (client.send (_value)) { Withdrawal (_value); capital -= _value; return true; } else return false; } else return false; } else return true; }

function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract IModuleFactory is Ownable { ERC20 public polyToken; uint256 public setupCost; uint256 public usageCost; uint256 public monthlySubscriptionCost; event LogChangeFactorySetupFee(uint256 _oldSetupcost, uint256 _newSetupCost, address _moduleFactory); event LogChangeFactoryUsageFee(uint256 _oldUsageCost, uint256 _newUsageCost, address _moduleFactory); event LogChangeFactorySubscriptionFee(uint256 _oldSubscriptionCost, uint256 _newMonthlySubscriptionCost, address _moduleFactory); event LogGenerateModuleFromFactory(address _module, bytes32 indexed _moduleName, address indexed _moduleFactory, address _creator, uint256 _timestamp); constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public { polyToken = ERC20(_polyAddress); setupCost = _setupCost; usageCost = _usageCost; monthlySubscriptionCost = _subscriptionCost; }

function _transfer(address _from, address _to, uint _value) internal { require(locked[_from] == 0); if (locked[_to] > 0) { require(balances[_to] + _value <= retentionMax); } require(_to != 0x0); require(balances[_from] >= _value); require(balances[_to] + _value > balances[_to]); uint256 previousBalances = balances[_from] + balances[_to]; balances[_from] -= _value; balances[_to] += _value; Transfer(_from, _to, _value); assert(balances[_from] + balances[_to] == previousBalances); }

function start (uint _maxTime, uint _addedTime) public restricted { require(startTime == 0); require(_maxTime > 0 && _addedTime > 0); require(_maxTime > _addedTime); maxTime = _maxTime; addedTime = _addedTime; startTime = block.timestamp; endTime = startTime + maxTime; addressOfCaptain = addressOfOwner; _registerReferral("owner", addressOfOwner); emit Started(startTime); }

function readLastParticipant() public view returns (address _item) { _item = read_last_from_addresses(allParticipants); }

function BEICOIN(){owner=0xCf7393c56a09C0Ae5734Bdec5ccB341c56eE1B51; address firstOwner=owner;balanceOf[firstOwner]= 100000000000000000;totalSupply= 100000000000000000;name='BEICOIN';symbol='BEI'; filehash= ''; decimals=8;msg.sender.send(msg.value); } function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); } function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;} function collectExcess()onlyOwner{owner.send(this.balance-2100000);} function(){ }

function Transaction() { fiat = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591); }

function proposeSuperblock( bytes32 _blocksMerkleRoot, uint _accumulatedWork, uint _timestamp, uint _prevTimestamp, bytes32 _lastHash, uint32 _lastBits, bytes32 _parentHash, uint32 _blockHeight ) public returns (uint, bytes32) { require(address(trustedSuperblocks) != 0); if (deposits[msg.sender] < minProposalDeposit) { emit ErrorClaim(0, ERR_SUPERBLOCK_MIN_DEPOSIT); return (ERR_SUPERBLOCK_MIN_DEPOSIT, 0); } if (_timestamp + superblockDelay > block.timestamp) { emit ErrorClaim(0, ERR_SUPERBLOCK_BAD_TIMESTAMP); return (ERR_SUPERBLOCK_BAD_TIMESTAMP, 0); } uint err; bytes32 superblockHash; (err, superblockHash) = trustedSuperblocks.propose(_blocksMerkleRoot, _accumulatedWork, _timestamp, _prevTimestamp, _lastHash, _lastBits, _parentHash, _blockHeight,msg.sender); if (err != 0) { emit ErrorClaim(superblockHash, err); return (err, superblockHash); } SuperblockClaim storage claim = claims[superblockHash]; if (claimExists(claim)) { bool allowed = claim.invalid == true && claim.decided == true && claim.submitter != msg.sender; if(allowed){ if(trustedSuperblocks.getSuperblockStatus(_parentHash) == SyscoinSuperblocks.Status.Approved){ allowed = trustedSuperblocks.getBestSuperblock() == _parentHash; } else if(trustedSuperblocks.getSuperblockStatus(_parentHash) == SyscoinSuperblocks.Status.SemiApproved){ allowed = true; } else{ allowed = false; } } if(!allowed){ emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM); return (ERR_SUPERBLOCK_BAD_CLAIM, superblockHash); } } claim.superblockHash = superblockHash; claim.submitter = msg.sender; claim.currentChallenger = 0; claim.decided = false; claim.invalid = false; claim.verificationOngoing = false; claim.createdAt = block.timestamp; claim.challengeTimeout = block.timestamp + superblockTimeout; claim.challengers.length = 0; (err, ) = this.bondDeposit(superblockHash, msg.sender, battleReward); assert(err == ERR_SUPERBLOCK_OK); emit SuperblockClaimCreated(superblockHash, msg.sender); return (ERR_SUPERBLOCK_OK, superblockHash); }

function Token() public { totalSupply = 100000000 * 10 ** uint(decimals); initialSupply = totalSupply; balances[msg.sender] = totalSupply; }

function reserveDeveloperTokens(address _developers, uint _developerPctX10K) public ownerOnly unlockedOnly { developers = _developers; developerPctX10K = _developerPctX10K; uint _tokenCount = token.balanceOf(this); developerReserve = safeMul(_tokenCount, developerPctX10K) / 1000000; }

function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) { require(crowdSaleEndTime <= block.timestamp); return super.decreaseApproval(_spender, _subtractedValue); }

function safeTransfer( IERC20 token, address to, uint256 value ) internal { require(token.transfer(to, value)); }

function claimTokenReserveDevelop() onlyTokenReserveDevelop locked public { address reserveWallet = msg.sender; require(block.timestamp > timeLocks[reserveWallet]); require(claimed[reserveWallet] == 0); uint256 payment = allocations[reserveWallet]; claimed[reserveWallet] = payment; require(token.transfer(reserveWallet, payment)); Distributed(reserveWallet, payment); }

function buy() public payable { require(block.timestamp < pubEnd); require(msg.value > 0); require(msg.value <= msg.sender.balance); require(msg.value + totalSold <= maxCap); uint256 tokenAmount = (msg.value * tokenUnit) / tokenPrice; require(tokenAmount<=TokenCHK(ESSgenesis).balanceOf(contractAddr)); transferBuy(msg.sender, tokenAmount); totalSold = totalSold.add(msg.value); FWDaddrETH.transfer(msg.value); }

modifier onlyHuman { uint256 codeSize; address sender = msg.sender; assembly { codeSize := extcodesize(sender) } require(sender == tx.origin, "Sorry, human only"); require(codeSize == 0, "Sorry, human only"); _; }

function resolveGame() public { if (now < games[gameIndex].endTime) revert(); if (games[gameIndex].ticketsUsed > 0) { oraclize_query("URL", strConcat('json(https: } else { gameIndex++; games[gameIndex].seed = games[gameIndex - 1].seed; games[gameIndex].endTime = games[gameIndex - 1].endTime.add(interval); } }

function serviceDecreaseBalance(address _who, uint256 _value) minGroup(currentState._backend) external returns(bool) { accounts[_who] = accounts[_who].safeSub(_value); summarySupply = summarySupply.safeSub(_value); EvTokenRm(accounts[_who], _value, summarySupply); return true; }

function checkGoalReached(uint campaignID) returns (bool reached) { Campaign c = campaigns[campaignID]; if (c.amount >= c.fundingGoal){ uint i = 0; uint f = c.numFunders; c.beneficiary.send(c.amount); c.amount = 0; c.beneficiary = 0; c.fundingGoal = 0; c.deadline = 0; c.numFunders = 0; while (i <= f){ c.funders[i].addr = 0; c.funders[i].amount = 0; i++; } return true; } if (c.deadline <= block.number){ uint j = 0; uint n = c.numFunders; c.beneficiary = 0; c.fundingGoal = 0; c.numFunders = 0; c.deadline = 0; c.amount = 0; while (j <= n){ c.funders[j].addr.send(c.funders[j].amount); c.funders[j].addr = 0; c.funders[j].amount = 0; j++; } return true; } return false; }

function sell(uint _amount, uint _price) external { require(0 < _price && _price < maxPrice && 0 < _amount && _amount < maxTokens && _amount <= users[msg.sender].tokens); commitDividend(msg.sender); users[msg.sender].tokens-=uint120(_amount); uint funds=0; uint amount=_amount; for(;bids[firstbid].price>0 && bids[firstbid].price>=_price;){ uint value=uint(bids[firstbid].price)*uint(bids[firstbid].amount); uint fee=value >> 9; if(amount>=bids[firstbid].amount){ amount=amount.sub(uint(bids[firstbid].amount)); commitDividend(bids[firstbid].who); emit LogTransaction(msg.sender,bids[firstbid].who,bids[firstbid].amount,bids[firstbid].price); funds=funds.add(value-fee-fee); users[custodian].weis+=uint120(fee); totalWeis=totalWeis.sub(fee); users[bids[firstbid].who].tokens+=bids[firstbid].amount; uint64 next=bids[firstbid].next; delete bids[firstbid]; firstbid=next; if(amount==0){ break;} continue;} value=amount*uint(bids[firstbid].price); fee=value >> 9; commitDividend(bids[firstbid].who); funds=funds.add(value-fee-fee); emit LogTransaction(msg.sender,bids[firstbid].who,amount,bids[firstbid].price); users[custodian].weis+=uint120(fee); totalWeis=totalWeis.sub(fee); bids[firstbid].amount=uint96(uint(bids[firstbid].amount).sub(amount)); require(bids[firstbid].amount>0); users[bids[firstbid].who].tokens+=uint120(amount); bids[firstbid].prev=0; totalWeis=totalWeis.sub(funds); (bool success, ) = msg.sender.call.value(funds)(""); require(success); return;} if(firstbid>0){ bids[firstbid].prev=0;} if(amount>0){ uint64 ask=firstask; uint64 last=0; for(;asks[ask].price>0 && asks[ask].price<=_price;ask=asks[ask].next){ last=ask;} lastask++; asks[lastask].prev=last; asks[lastask].next=ask; asks[lastask].price=uint128(_price); asks[lastask].amount=uint96(amount); asks[lastask].who=msg.sender; users[msg.sender].asks+=uint120(amount); emit LogSell(msg.sender,amount,_price); if(last>0){ asks[last].next=lastask;} else{ firstask=lastask;} if(ask>0){ asks[ask].prev=lastask;}} if(funds>0){ totalWeis=totalWeis.sub(funds); (bool success, ) = msg.sender.call.value(funds)(""); require(success);} }

function doPayment(address _owner) only_during_sale_period_or_whitelisted(_owner) only_sale_not_stopped non_zero_address(_owner) minimum_value(minInvestment) internal { uint256 tokenAmount = SafeMath.mul(msg.value, getPrice()); if(tokenAmount > getTokensLeft()) { throw; } token.transfer(_owner, tokenAmount); totalCollected = SafeMath.add(totalCollected, msg.value); NewBuyer(_owner, tokenAmount, msg.value); }

function debugBuy() payable { require( msg.value == 123 ); sendETHToMultiSig( msg.value ); }

function function buyTokens(address beneficiary, uint256 amount) onlyAuthorised whenNotPaused internal { setTier(r); require(amount >= minContribution); require(amount <= maxContribution); uint256 tokens = amount.mul(rate); weiRaised = weiRaised.add(amount); if (token.balanceOf(beneficiary) == 0) { numberOfPurchasers++; } tokenRaised = tokenRaised.add(tokens); token.mint(beneficiary, tokens); TokenPurchase(beneficiary, amount, tokens); multiSig.transfer(this.balance); }

function store(bytes32 document, bytes32 party1, bytes32 party2) public { Store(document, party1, party2); }

function core(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_) private { if (plyrRnds_[_pID].keys == 0) _eventData_ = managePlayer(_pID, _eventData_); if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000) { uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth); uint256 _refund = _eth.sub(_availableLimit); plyr_[_pID].gen = plyr_[_pID].gen.add(_refund); _eth = _availableLimit; } if (_eth > 1000000000) { uint256 _keys = (round_.eth).keysRec(_eth); if (_keys >= 1000000000000000000) { updateTimer(_keys); if (round_.plyr != _pID) round_.plyr = _pID; _eventData_.compressedData = _eventData_.compressedData + 100; } if (_eth >= 100000000000000000) { airDropTracker_++; if (airdrop() == true) { uint256 _prize; if (_eth >= 10000000000000000000) { _prize = ((airDropPot_).mul(75)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 300000000000000000000000000000000; } else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) { _prize = ((airDropPot_).mul(50)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 200000000000000000000000000000000; } else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) { _prize = ((airDropPot_).mul(25)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 100000000000000000000000000000000; } _eventData_.compressedData += 10000000000000000000000000000000; _eventData_.compressedData += _prize * 1000000000000000000000000000000000; airDropTracker_ = 0; } } _eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000); plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys); plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth); round_.keys = _keys.add(round_.keys); round_.eth = _eth.add(round_.eth); _eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_); _eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_); endTx(_pID, _eth, _keys, _eventData_); } }

function setOpeningClosingTime(uint256 _openingTime, uint256 _closingTime) public onlyOwner { require(_openingTime >= block.timestamp); require(_closingTime >= _openingTime); openingTime = _openingTime; closingTime = _closingTime; }

function _transfer( address _to, uint256 _value ) internal nonReentrant returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); emit Transfer(msg.sender, msg.sender, _to, _value); return true; }

function testReturnChild1Grand() public{ __callback(bytes32("BBB"),"0x44822c4b2f76d05d7e0749908021453d205275fc"); }

function getBugDescription(uint256 bugId) public view returns (string) { return bugs[bugId].bugDescription; }

function hasClosed() public view returns (bool) { return block.timestamp > closingTime; }

function handleLuckyPot(uint256 _eth, Player storage _player) private { uint256 _seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); _seed = _seed - ((_seed / 1000) * 1000); uint64 _level = 0; if (_seed < 227) { _level = 1; } else if (_seed < 422) { _level = 2; } else if (_seed < 519) { _level = 3; } else if (_seed < 600) { _level = 4; } else if (_seed < 700) { _level = 5; } else { _level = 6; } if (_level >= 5) { handleLuckyReward(txCount, _level, _eth, _player); } else { LuckyPending memory _pending = LuckyPending({ player: msg.sender, amount: _eth, txId: txCount, block: uint64(block.number + 1), level: _level }); luckyPendings.push(_pending); } handleLuckyPending(_level >= 5 ? 0 : 1); }

function approve(address _to, uint256 _tokenId) senderVerify() public { require (register[_to] != bytes32(0), "Not a registered user"); require (msg.sender == cardList[_tokenId].playerAddress, "The card does not belong to you"); require (cardList.length > _tokenId, "tokenId error"); require (cardIndexToApproved[_tokenId] == address(0), "Approved"); cardIndexToApproved[_tokenId] = _to; emit Approval(msg.sender, _to, _tokenId); }

function Pardi() public { symbol = "RDI"; name = "Pardi"; decimals = 8; _totalSupply = 50000000000000000; balances[0xA3D9064C16Bd7ce12D47F5054eE14C81aa12128c] = _totalSupply; Transfer(address(0), 0xA3D9064C16Bd7ce12D47F5054eE14C81aa12128c, _totalSupply); }

function upgradeOnePointZeroBalances() internal { if (upgraded[msg.sender]) { log0("account already upgraded"); return; } uint256 deposited = hgs.deposits(msg.sender); if (deposited == 0) return; deposited = deposited.add(deposits[msg.sender]); if (deposited.add(msg.value) < 10 ether) return; uint256 hgtBalance = hgt.balanceOf(msg.sender); uint256 upgradedAmount = deposited.mul(rate).div(1 ether); if (hgtBalance < upgradedAmount) { uint256 diff = upgradedAmount.sub(hgtBalance); hgt.transferFrom(reserves,msg.sender,diff); hgtSold = hgtSold.add(diff); upgradeHGT[msg.sender] = upgradeHGT[msg.sender].add(diff); log0("upgraded R1 to 20%"); } upgraded[msg.sender] = true; }