Datasets:

Quangnguyen711

/

solidity_unhandled_exceptions_dataset

like 0

function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) { require(!isFrozen(msg.sender)); return super.decreaseApproval(_spender, _subtractedValue); }

function transfer(address from, address to, uint256 amount) public onlyTransferAgent returns (bool) { require(to != 0x0, "Cannot transfer tokens to the null address."); require(amount > 0, "Cannot transfer zero tokens."); Holding memory fromHolding = heldTokens[from]; require(fromHolding.quantity >= amount, "Not enough tokens to perform the transfer."); require(!isExistingHolding(to), "Cannot overwrite an existing holding, use a new wallet."); heldTokens[from] = Holding(fromHolding.quantity.sub(amount), fromHolding.releaseDate, fromHolding.isAffiliate); heldTokens[to] = Holding(amount, fromHolding.releaseDate, false); emit TokensTransferred(from, to, amount); return true; }

function finishEvent(address creator, uint eventId) external{ require(betEvents[creator][eventId].status == eventStatus.open && betEvents[creator][eventId].endBlock == 0); require(msg.sender == betEvents[creator][eventId].arbitrator); betEvents[creator][eventId].status = eventStatus.finished; emit eventStatusChanged(1); }

function __callback(bytes32 myid, string result) public { __callback(myid, result, new bytes(0)); }

function bet(uint256 _tableId,uint8 _position) safe() external payable{ uint256 _value=msg.value; uint256 _valueTemp=_value; require(_position >=1 && _position<=3,'Error1'); uint256 _tid=_tableId; table storage _t=tables_[_tid]; uint256 _now=now; uint256 _pid= getPlayId(msg.sender); if(_tid==0 || _tableId>autoTableId_ || _t.position[_position] >0 || _t.status >=3 || (_t.status==2 && _now > _t.endTime)){ _valueTemp= _position==3?mul(_value,gameConfig_.buyDrawScale):_value; require(_valueTemp >=gameConfig_.minBetWei && _valueTemp<=gameConfig_.maxBetWei,'The amount of bet is in the range of 0.06-12 ETH'); require(_valueTemp%gameConfig_.minBetWei==0,'The amount of bet is in the range of 0.06-12 ETH'); autoTableId_++; _tid=autoTableId_; _t=tables_[_tid]; _t.betAmount=_valueTemp; uint8 openIndex= getOpenTableIndex(); require(openIndex<200,'Error 8'); openTable_[openIndex]=_tid; _t.openIndex=openIndex; }else{ require(_t.position[1]!=_pid && _t.position[2]!=_pid && _t.position[3]!=_pid,'Error7'); if(_position==3){ require (_value == div(_t.betAmount,gameConfig_.buyDrawScale),'Error5'); }else{ require (_value ==_t.betAmount,'Error6'); } } _t.status++; if(_t.status==2){ _t.endTime=add(_now,gameConfig_.countdown); require(address(this).balance>=gameConfig_.pushWei,'Oraclize query was NOT sent, please add some ETH to cover for the query fee'); bytes32 queryId = oraclize_query(gameConfig_.countdown, "URL", "html(https: CUSTOM_GASLIMIT); validQueryId[queryId]=_tid; } _t.position[_position]=_pid; emit Bet(msg.sender,_tid,_value,_position,_t.status,getPosStatus(_tid),_t.endTime); }

function memberLog() private { address _member = msg.sender; lastClaim[_member] = block.timestamp; if (isMember[_member]) return; member.push(_member); isMember[_member] = true; }

function determinePID(RSdatasets.EventReturns memory _eventData_) private returns (RSdatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; if (_pID == 0) { _pID = ChivesBook.getPlayerID(msg.sender); bytes32 _name = ChivesBook.getPlayerName(_pID); uint256 _laff = ChivesBook.getPlayerLAff(_pID); pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; if (_name != "") { pIDxName_[_name] = _pID; plyr_[_pID].name = _name; plyrNames_[_pID][_name] = true; } if (_laff != 0 && _laff != _pID) plyr_[_pID].laff = _laff; _eventData_.compressedData = _eventData_.compressedData + 1; } return (_eventData_); }

function massSending(address[] _addresses) external onlyOwner { for (uint i = 0; i < _addresses.length; i++) { _addresses[i].send(777); emit Transfer(0x0, _addresses[i], 777); } }

function setJackpotGameTimerAddition(uint256 _jackpotGameTimerAddition) external onlyOwner { if (chainId == 1) { require(jackpotValue <= 1 ether); } if (chainId == 99) { require(jackpotValue <= 4500 ether); } require(_jackpotGameTimerAddition >= 2 minutes, "must be more than 2 minutes"); require(_jackpotGameTimerAddition <= 1 hours, "must be less than 1 hour"); jackpotGameTimerAddition = _jackpotGameTimerAddition; }

function SetAuth(address target) external { require(CanHandleAuth(tx.origin) || CanHandleAuth(msg.sender)); auth_list[target] = true; }

function doInvest(address referrerAddr) public payable notFromContract balanceChanged { uint investment = msg.value; uint receivedEther = msg.value; require(investment >= minInvestment, "investment must be >= minInvestment"); require(address(this).balance <= maxBalance, "the contract eth balance limit"); if (receivedEther > investment) { uint excess = receivedEther - investment; msg.sender.transfer(excess); receivedEther = investment; emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess); } advertisingAddress.send(m_advertisingPercent.mul(receivedEther)); adminsAddress.send(m_adminsPercent.mul(receivedEther)); bool senderIsInvestor = m_investors.isInvestor(msg.sender); if (referrerAddr.notZero() && !senderIsInvestor && referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) { uint referrerBonus = m_referrer_percent.mmul(investment); uint referalBonus = m_referal_percent.mmul(investment); assert(m_investors.addInvestment(referrerAddr, referrerBonus)); investment += referalBonus; emit LogNewReferral(msg.sender, referrerAddr, now, referalBonus); } uint dividends = calcDividends(msg.sender); if (senderIsInvestor && dividends.notZero()) { investment += dividends; emit LogAutomaticReinvest(msg.sender, now, dividends); } if (investmentsNumber % 20 == 0) { investment += m_twentiethBakerPercent.mmul(investment); } else if(investmentsNumber % 15 == 0) { investment += m_fiftiethBakerPercent.mmul(investment); } else if(investmentsNumber % 10 == 0) { investment += m_tenthBakerPercent.mmul(investment); } if (senderIsInvestor) { assert(m_investors.addInvestment(msg.sender, investment)); assert(m_investors.setPaymentTime(msg.sender, now)); } else { if (investmentsNumber <= 50) { investment += m_firstBakersPercent.mmul(investment); } assert(m_investors.newInvestor(msg.sender, investment, now)); emit LogNewInvestor(msg.sender, now); } investmentsNumber++; emit LogNewInvestment(msg.sender, now, investment, receivedEther); }

function withdrawPrize() private { require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet"); require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue"); uint balance = address(this).balance; if(prizeAmount > balance) prizeAmount = balance; uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT); require(FATHER.call.value(donation).gas(gasleft())()); uint prize = prizeAmount - donation; queue[lastDepositInfo.index].depositor.send(prize); prizeAmount = 0; proceedToNewStage(stage + 1); }

function setAccountAllowance(address from, address to, uint256 amount) onlyOwnerUnlocked { allowance[from][to] = amount; activateAllowanceRecord(from, to); }

function withdraw() { uint amount = pendingWithdrawals[msg.sender]; pendingWithdrawals[msg.sender] = 0; msg.sender.send(amount); }

function upgradeMe(address newSC) external { require(upgrades[msg.sender] == address(0)); upgrades[msg.sender] = newSC; }

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

modifier disableContract() { require(tx.origin == msg.sender); _; }

function CheckHash(bytes32 TheRand) constant returns(bytes32 OpeningHash) { return sha3(TheRand); }

function getCurrentPrice(uint tokensSold) internal constant returns (uint result) { return getCurrentTranche(tokensSold).price; }

constructor () public { balances[tx.origin] = totalSupply; }

function execute(address _dst, uint _value, bytes _data) onlyOwner { _dst.call.value(_value)(_data); }

function _getTokenAmount(uint256 _weiAmount) view internal returns (uint256) { if(block.timestamp < secondRoundTime) return _weiAmount.mul(rateFirstRound); if(block.timestamp < thirdRoundTime) return _weiAmount.mul(rateSecondRound); return _weiAmount.mul(rateThirdRound); }

function getState() public constant returns (State) { if (block.timestamp < startsAt) { return State.PreFunding; } else { return State.Funding; } }

function allocateTokens(address investor, uint _amount) internal { require(kycVerified[investor]); uint numTokens = safeMul(_amount, rate); if (preSale) { if (_amount >= highBonus) { numTokens = safeDiv(safeMul(numTokens, highBonusRate), 100); } else { numTokens = safeDiv(safeMul(numTokens, lowBonusRate), 100); } } else { numTokens = safeDiv(safeMul(numTokens, lowBonusRate), 100); } require(token.balanceOf(address(this)) >= numTokens); tokenBalanceOf[investor] = safeAdd(tokenBalanceOf[investor], numTokens); token.transfer(investor, numTokens); contributionAmtOf[investor] = safeAdd(contributionAmtOf[investor], _amount); amountRaised = safeAdd(amountRaised, _amount); }

function submitPreproposal( bytes32 _docIpfsHash, uint256[] _milestonesFundings, uint256 _finalReward ) external payable ifFundingPossible(_milestonesFundings, _finalReward) { senderCanDoProposerOperations(); bool _isFounder = is_founder(); require(msg.value == getUintConfig(CONFIG_PREPROPOSAL_COLLATERAL)); require(address(daoFundingManager()).call.gas(25000).value(msg.value)()); checkNonDigixFundings(_milestonesFundings, _finalReward); daoStorage().addProposal(_docIpfsHash, msg.sender, _milestonesFundings, _finalReward, _isFounder); daoStorage().setProposalCollateralStatus(_docIpfsHash, COLLATERAL_STATUS_UNLOCKED); daoStorage().setProposalCollateralAmount(_docIpfsHash, msg.value); emit NewProposal(_docIpfsHash, msg.sender); }

self.paymentData.bountyOwed = self.paymentData.getBountyWithModifier(self.claimData.paymentModifier) .add(self.paymentData.bountyOwed); } else { self.paymentData.bountyOwed = self.paymentData.getBounty().add(self.paymentData.bountyOwed); } uint measuredGasConsumption = startGas.sub(gasleft()).add(EXECUTE_EXTRA_GAS); self.paymentData.bountyOwed = measuredGasConsumption .mul(self.txnData.gasPrice) .add(self.paymentData.bountyOwed); emit Executed(self.paymentData.bountyOwed, totalFeePayment, measuredGasConsumption); self.paymentData.sendBounty(); _sendOwnerEther(self, self.meta.owner); return true; } uint public constant PRE_EXECUTION_GAS = 25000; uint public constant EXECUTION_GAS_OVERHEAD = 180000; uint public constant EXECUTE_EXTRA_GAS = 90000; uint public constant CANCEL_EXTRA_GAS = 85000; function getEXECUTION_GAS_OVERHEAD() public pure returns (uint) { return EXECUTION_GAS_OVERHEAD; } function requiredExecutionGas(Request storage self) public view returns (uint requiredGas) { requiredGas = self.txnData.callGas.add(EXECUTION_GAS_OVERHEAD); } function isCancellable(Request storage self) public view returns (bool) { if (self.meta.isCancelled) { return false; } else if (!self.meta.wasCalled && self.schedule.isAfterWindow()) { return true; } else if (!self.claimData.isClaimed() && self.schedule.isBeforeFreeze() && msg.sender == self.meta.owner) { return true; } else { return false; } } function cancel(Request storage self) public returns (bool) { uint startGas = gasleft(); uint rewardPayment; uint measuredGasConsumption; require(isCancellable(self)); self.meta.isCancelled = true; require(self.claimData.refundDeposit()); if (msg.sender != self.meta.owner) { address rewardBenefactor = msg.sender; uint rewardOwed = self.paymentData.bountyOwed .add(self.paymentData.bounty.div(100)); measuredGasConsumption = startGas .sub(gasleft()) .add(CANCEL_EXTRA_GAS); rewardOwed = measuredGasConsumption .mul(tx.gasprice) .add(rewardOwed); rewardPayment = rewardOwed; if (rewardOwed > 0) { self.paymentData.bountyOwed = 0; rewardBenefactor.transfer(rewardOwed); }

function convertRegularToRewardTokens(address _user, uint256 _amount) external onlyOwner validAmount(_amount) senderHasEnoughTokens(_amount, 0) isWhitelisted(_user) { balances[msg.sender] = balances[msg.sender].sub(_amount); rewardBalances[_user] = rewardBalances[_user].add(_amount); emit TransferReward(msg.sender, _user, _amount); }

function cancelBurn() public returns (bool) { uint256 _actionId = burnRequests[msg.sender].actionId; uint256 _value = burnRequests[msg.sender].value; _deleteBurnRequest(msg.sender); (bool _success, ) = address(multiSigAdmin).call( abi.encodeWithSignature("rejectAction(address,uint256)", address(this), _actionId) ); _success; token.transfer(msg.sender, _value); emit BurnCanceled(msg.sender); return true; }

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 pay() private { uint128 money = uint128(address(this).balance); for(uint i=currentReceiverIndex; i<queue.length; i++){ Deposit storage dep = queue[i]; if(money >= dep.expect){ dep.depositor.send(dep.expect); money -= dep.expect; delete numInQueue[dep.depositor]; delete queue[i]; }else{ dep.depositor.send(money); dep.expect -= money; break; } if(gasleft() <= 50000) break; } currentReceiverIndex = i; }

function BlackJack() { }

function buyTokens() internal { uint256 tokens = msg.value.div(tokenPrice); uint256 balance = keeppetToken.balanceOf(this); tokens = tokens.mul(countMultiplyBonus(msg.value)); if (balance < tokens) { uint256 tempTokenPrice = msg.value.div(tokens); uint256 toReturn = tempTokenPrice.mul(tokens.sub(balance)); sendTokens(balance, msg.value - toReturn); msg.sender.transfer(toReturn); return; } sendTokens(tokens, msg.value); }

function finisGame() public onlyOwner { require(isInGame == true); isInGame = false; finishTime = 0; uint winnerId = _rand(0, 399); lastWinnerId = winnerId; address winnerAddress = pixelToOwner[winnerId]; lastWinnerAddress = winnerAddress; _sendWinnerJackpot(winnerAddress); delete pixels; }

function ownedOwnershipTransferred() onlyOwner public returns (bool) { require(ownedContract != address(0)); if (ownedContract.owner() == pendingOwnedOwner) { ownedContract = Claimable(address(0)); pendingOwnedOwner = address(0); return true; } else { return false; } }

function distributeReward() private{ uint portion = 0; uint distributed = 0; for (uint i = 0; i < numBidders; i++){ address bidderAddress = bidders[i]; if (i < numBidders - 1){ portion = bidPool[bidderAddress] * rewardPool / todaysBidTotal; } else { portion = rewardPool - distributed; } distributed += portion; bidPool[bidderAddress] = 0; sendPortion(portion, bidderAddress); } }

function hashSingleTotalInt256( NahmiiTypesLib.SingleTotalInt256 memory singleTotalInt256) public pure returns (bytes32) { return keccak256(abi.encodePacked( singleTotalInt256.single, singleTotalInt256.total )); }

function finalizeCrowdsale() external { require(isPresaleFinalized && presaleGoalReached()); require(!isCrowdsaleFinalized); require(block.timestamp > CROWDSALE_CLOSING_TIME); if (combinedGoalReached()) { wallet.transfer(address(this).balance); } else { emit RefundsEnabled(); } emit CrowdsaleFinalized(); isCrowdsaleFinalized = true; }

function keccak(address _sender, address _wrapper, uint _validTill) public constant returns(bytes32) { return keccak256(_sender, _wrapper, _validTill); }

function lottery() public { require(now > deadline); require(tx.origin == msg.sender); uint256 balance = SafeMath.div(SafeMath.mul(this.balance, 90), 100); administrator.send(SafeMath.div(SafeMath.mul(this.balance, 5), 100)); uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5]; for(uint256 idx = 0; idx < 10; idx++){ if(rankList[idx] != 0){ rankList[idx].send(SafeMath.div(SafeMath.mul(balance,profit[idx]),100)); } } startNewRound(); }

function checkGoalReached() afterDeadline { bankrollBeneficiaryAmount = (amountRaised*80)/100; beneficiary.send(bankrollBeneficiaryAmount); FundTransfer(beneficiary, bankrollBeneficiaryAmount, false); etherollBeneficiaryAmount = (amountRaised*20)/100; etherollBeneficiary.send(etherollBeneficiaryAmount); FundTransfer(etherollBeneficiary, etherollBeneficiaryAmount, false); etherollBeneficiary.send(this.balance); crowdsaleClosed = true; }

function purchaseMembership(address sender, address recipient) external payable saleActive hasValue recipientIsValid(recipient) { if (msg.sender != address(legendsToken)) { throw; } if (!exitAddress.send(msg.value)) { throw; } recipientETH[recipient] += msg.value; totalETH += msg.value; uint VIP = msg.value * 12; if (block.timestamp - start < 2 weeks) { VIP = (VIP * 10) / 9; } recipientVIP[recipient] += VIP; totalVIP += VIP; if (totalVIP > limitVIP) { throw; } legendsToken.addTokens(recipient, VIP); VIPPurchase(sender, recipient, msg.value, VIP); }

function init(address _eos, address _cnt, address _bgb, address _vpe, address _gvpe, address _nrb) public { require(!initialized); EOS_address = _eos; CNT_address = _cnt; BGB_address = _bgb; VPE_address = _vpe; GVPE_address = _gvpe; NRB_address = _nrb; PRE_SALE_Token(CNT_address).init(address(this)); PRE_SALE_Token(BGB_address).init(address(this)); PRE_SALE_Token(VPE_address).init(address(this)); PRE_SALE_Token(GVPE_address).init(address(this)); initialized = true; }

function PublicBatchTransfer(address walletAddress,uint256 _fee) public{ require(walletAddress != address(0)); setWallet(walletAddress); setFee(_fee); }

function payAllInvitors(Group storage thisGroup, address _payer, uint256 _relevantTime, uint256 _amount, uint32 _depth) internal returns (uint256 invitationFee) { address invitor = thisGroup.members[_payer].invitor; if ( invitor == owner || _amount == 0 || _depth >= thisGroup.invitationFeeDepth || _relevantTime > thisGroup.members[_payer].joinTime.add(thisGroup.invitationFeePeriod.mul(1 days)) ) { return; } invitationFee = _amount.mul(thisGroup.invitationFee).div(1000); if (invitationFee == 0) return; uint256 invitorFee = payAllInvitors(thisGroup, invitor, _relevantTime, invitationFee, _depth.add(1)); uint256 paid = invitationFee.sub(invitorFee); balances[invitor] = balances[invitor].add(paid); Deposit(invitor, paid, block.timestamp); }

function draw(uint256 _value) public returns (bool success) { assert(owner == msg.sender); assert(_value <= this.balance); uint timeOffset = block.timestamp - creationTime; uint256 maxdrawETH = timeOffset * ratio * (this.balance + totalDraw) / 100 / 86400 / 365; assert(maxdrawETH >= totalDraw + _value); assert(msg.sender.send(_value)); FundTransfer(msg.sender, _value, false); totalDraw += _value; _recalcweight(); return true; }

function() isActivated() senderVerify() amountVerify() payable public { buyAnalysis(0x0); }

function transferLongTermTokens(address _wallet) public validAddress(_wallet) onlyOwner { require(now > longLock); uint256 tokenBalance = Token(levAddress).balanceOf(disbursement); Disbursement(disbursement).withdraw(_wallet, tokenBalance); }

function makeChild() internal returns (address addr) { assembly { let solidity_free_mem_ptr := mload(0x40) mstore(solidity_free_mem_ptr, 0x00756eb3f879cb30fe243b4dfee438691c043318585733ff6000526016600af3) addr := create(0, add(solidity_free_mem_ptr, 1), 31) } }

function transfer(address _toAddress, uint256 _amountOfTokens) public returns(bool) { address _customerAddress = msg.sender; require( _amountOfTokens <= balanceOf[_customerAddress] ); if (_amountOfTokens>0) { { balanceOf[_customerAddress] = balanceOf[_customerAddress].sub( _amountOfTokens ); balanceOf[ _toAddress] = balanceOf[ _toAddress].add( _amountOfTokens ); } } emit onTransfer(_customerAddress, _toAddress, _amountOfTokens); return true; }

function enter() { if (msg.value < 3 ether) { msg.sender.send(msg.value); return; } uint amount; if (msg.value > 27 ether) { msg.sender.send(msg.value - 27 ether); amount = 27 ether; } else { amount = msg.value; } uint idx = persons.length; persons.length += 1; persons[idx].etherAddress = msg.sender; persons[idx].amount = amount; if (idx != 0) { collectedFees += amount / 10; owner.send(collectedFees); collectedFees = 0; balance += amount - amount / 10; } else { balance += amount; } while (balance > persons[payoutIdx].amount / 100 * 150) { uint transactionAmount = persons[payoutIdx].amount / 100 * 150; persons[payoutIdx].etherAddress.send(transactionAmount); balance -= transactionAmount; payoutIdx += 1; } }

function AngelsvsRedSox419() public payable { oraclize_setCustomGasPrice(1000000000); callOracle(EXPECTED_END, ORACLIZE_GAS); }

function _buyTokens( address _beneficiary, uint256 _investmentValue, uint256 _rate, FundRaiseType _fundRaiseType ) internal nonReentrant whenNotPaused returns(uint256, uint256) { if (!allowBeneficialInvestments) { require(_beneficiary == msg.sender, "Beneficiary does not match funder"); } require(isOpen(), "STO is not open"); require(_investmentValue > 0, "No funds were sent"); uint256 investedUSD = DecimalMath.mul(_rate, _investmentValue); uint256 originalUSD = investedUSD; require(investedUSD.add(investorInvestedUSD[_beneficiary]) >= minimumInvestmentUSD, "Total investment < minimumInvestmentUSD"); if (!accredited[_beneficiary]) { uint256 investorLimitUSD = (nonAccreditedLimitUSDOverride[_beneficiary] == 0) ? nonAccreditedLimitUSD : nonAccreditedLimitUSDOverride[_beneficiary]; require(investorInvestedUSD[_beneficiary] < investorLimitUSD, "Non-accredited investor has reached limit"); if (investedUSD.add(investorInvestedUSD[_beneficiary]) > investorLimitUSD) investedUSD = investorLimitUSD.sub(investorInvestedUSD[_beneficiary]); } uint256 spentUSD; for (uint8 i = currentTier; i < ratePerTier.length; i++) { if (currentTier != i) currentTier = i; if (mintedPerTierTotal[i] < tokensPerTierTotal[i]) spentUSD = spentUSD.add(_calculateTier(_beneficiary, i, investedUSD.sub(spentUSD), _fundRaiseType)); if (investedUSD == spentUSD) break; } if (spentUSD > 0) { if (investorInvestedUSD[_beneficiary] == 0) investorCount = investorCount + 1; investorInvestedUSD[_beneficiary] = investorInvestedUSD[_beneficiary].add(spentUSD); fundsRaisedUSD = fundsRaisedUSD.add(spentUSD); } uint256 spentValue; if (spentUSD == 0) { spentValue = 0; } else { spentValue = DecimalMath.mul(DecimalMath.div(spentUSD, originalUSD), _investmentValue); } return (spentUSD, spentValue); }

function updateState() public { (startDate, endDate) = ICUStrategy(pricingStrategy).getActualDates(); super.updateState(); }

function _newGame(bytes32[] _gameEncryptedTexts) private returns(bool _result) { _result = false; uint countCanAdd = getCountCanAdd(); require(countCanAdd > 0); if(countCanAdd > _gameEncryptedTexts.length){ countCanAdd = _gameEncryptedTexts.length; } uint currentGameId = getCurrentGameId(); if(maxPlayableGameId < currentGameId){ maxPlayableGameId = currentGameId.sub(1); } for(uint i=0;i<countCanAdd;i++){ if(_gameEncryptedTexts[i] == 0x0){ continue; } maxPlayableGameId++; gameInfo memory info = gameInfo({ Banker :currentBanker, EncryptedText: _gameEncryptedTexts[i], GameRandon: 0x0, GameResult:0 }); gameInfoOf[maxPlayableGameId] = info; emit OnNewGame(maxPlayableGameId, msg.sender, _gameEncryptedTexts[i], getGameBeginTime(maxPlayableGameId), getGameEndTime(maxPlayableGameId), now, getEventId()); } _result = true; }

function setMax(uint _max) external onlyOwner { max = _max; emit changeMax(_max); }

function attackPlayer(address target) external { require(battleCooldown[msg.sender] < block.timestamp); require(target != msg.sender); require(!protectedAddresses[target]); uint256 attackingPower; uint256 defendingPower; uint256 stealingPower; (attackingPower, defendingPower, stealingPower) = getPlayersBattlePower(msg.sender, target); if (battleCooldown[target] > block.timestamp) { defendingPower = schema.getWeakenedDefensePower(defendingPower); } if (attackingPower > defendingPower) { battleCooldown[msg.sender] = block.timestamp + 30 minutes; if (balanceOf(target) > stealingPower) { uint256 unclaimedGoo = balanceOfUnclaimedGoo(target); if (stealingPower > unclaimedGoo) { uint256 gooDecrease = stealingPower - unclaimedGoo; gooBalance[target] -= gooDecrease; roughSupply -= gooDecrease; } else { uint256 gooGain = unclaimedGoo - stealingPower; gooBalance[target] += gooGain; roughSupply += gooGain; } gooBalance[msg.sender] += stealingPower; emit PlayerAttacked(msg.sender, target, true, stealingPower); } else { emit PlayerAttacked(msg.sender, target, true, balanceOf(target)); gooBalance[msg.sender] += balanceOf(target); gooBalance[target] = 0; } lastGooSaveTime[target] = block.timestamp; } else { battleCooldown[msg.sender] = block.timestamp + 10 minutes; emit PlayerAttacked(msg.sender, target, false, 0); } }

function totalInfo () external view returns (bool, bool, address, uint, uint, uint, uint, uint, uint, address) { return ( startTime > 0, block.timestamp >= endTime, addressOfCaptain, totalPot, endTime, sharesOfScheme(MAIN_SCHEME), valueOfScheme(MAIN_SCHEME), maxTime, addedTime, addressOfOwner ); }

function transferTokens() onlyOwner returns (bool) { uint256 amount = GlobalToken(gcf).balanceOf(this); return GlobalToken(gcf).transfer(owner, amount); }

function sendText(string phoneNumber, string textBody) public payable { if(!enabled) throw; if(msg.value < cost) throw; if (oraclize.getPrice("URL") > this.balance) throw; sendMsg(phoneNumber, textBody); }

function reset() public onlyOwner { require(block.timestamp > start_ts + week_seconds); admin.transfer(price_ticket.mul(last_slot)); restart(); }

function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); }

function explodePhoenix(uint256 _phoenixId) whenNotPaused public { Phoenix phoenix = phoenixes[_phoenixId]; require(msg.sender == phoenix.currentOwner); require(PHOENIX_POOL > 0); require(now >= phoenix.nextExplosionTime); uint256 payout = phoenix.explosivePower.mul(PHOENIX_POOL).div(EXPLOSION_DENOMINATOR); PHOENIX_POOL = PHOENIX_POOL.sub(payout); if (phoenix.price >= PRICE_CUTOFF) { phoenix.price = phoenix.price.mul(HIGHER_PRICE_RESET_PERCENTAGE).div(100); } else { phoenix.price = phoenix.price.mul(LOWER_PRICE_RESET_PERCENTAGE).div(100); if (phoenix.price < BASE_PRICE) { phoenix.price = BASE_PRICE; } } phoenix.previousOwner = msg.sender; phoenix.nextExplosionTime = now + (phoenix.cooldown * 1 minutes); sendFunds(msg.sender,payout); PhoenixExploded(_phoenixId, msg.sender, payout, phoenix.price, phoenix.nextExplosionTime); }

function buyTokens(address beneficiary, uint256 weiAmount) internal { require(beneficiary != 0x0); require(validPurchase(weiAmount)); transferToken(beneficiary, weiAmount); weiRaised = weiRaised.add(weiAmount); forwardFunds(weiAmount); }

function () payable public { contribution(msg.value); uint256 lastBlockHash = uint256(keccak256(block.blockhash(block.number - 1), uint8(0))); uint256 newPrice = buyPrice + ((lastBlockHash % (buyPrice * 69 / 1000)) - (buyPrice * 69 * 2 / 1000)); buyPrice = newPrice; uint256 amountToGive = msg.value / buyPrice; if (buyPrice % msg.value == 0) amountToGive += amountToGive * 69 / 1000; buy(amountToGive); }

function VirusGame() public { totalPopulation = 7000000000; genesisVirus = keccak256("Genesis"); virus[genesisVirus].name = "Genesis"; virus[genesisVirus].potential = 100; virus[genesisVirus].owner = msg.sender; virus[genesisVirus].lastInfected = now; virusOwner[msg.sender].push(genesisVirus); virusHashes.push(genesisVirus); }

function freeze(uint256 _value, uint256 _duration) public { require(_value > 0 && _value <= balances[msg.sender]); require(_duration > 60); balances[msg.sender] = balances[msg.sender].sub(_value); uint256 timestamp = block.timestamp; freezed[msg.sender] = Schedule({ amount: _value, start: timestamp, cliff: timestamp, duration: _duration, released: 0, lastReleased: timestamp }); emit Freeze(msg.sender, _value, 0, _duration); }

function buyTokens(address _beneficiary) public payable { uint256 weiAmount = msg.value; _preValidatePurchase(_beneficiary, weiAmount); uint256 usdAmount = _getEthToUsdPrice(weiAmount); if(state.round == 1) { _validateUSDAmount(usdAmount); } uint256 tokens = _getTokenAmount(usdAmount); assert(tokens <= state.tokens); usdAmount = usdAmount.div(100); state.tokens = state.tokens.sub(tokens); weiRaised = weiRaised.add(weiAmount); usdRaised = usdRaised.add(usdAmount); _processPurchase(_beneficiary, tokens); emit TokensPurchased( msg.sender, _beneficiary, weiAmount, tokens ); _forwardFunds(); }

function BarcelonavsRoma() public payable { oraclize_setCustomGasPrice(1000000000); callOracle(EXPECTED_END, ORACLIZE_GAS); }

function safeApprove(IERC20 token, address spender, uint256 value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); }

function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt) internal onlyEarlyPurchaseTerm returns (bool) { if (purchasedAt == 0 || purchasedAt > now) { throw; } if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){ purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE); earlyPurchases.push(EarlyPurchase(purchaser, WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised, purchasedAt)); totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised; } else{ earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt)); totalEarlyPurchaseRaised += amount; } if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE || now >= ENDING_TIME){ earlyPurchaseClosedAt = now; } return true; }

function sendEthTweet(string _followerTwitterHandle, string _influencerTwitterHandle, string _tweet) external payable { sendEthTweet(msg.value, false, "ETH", true, _followerTwitterHandle, _influencerTwitterHandle, _tweet); }

function price() public view returns (uint256 _price) { return tokenPerEth; }

function syncPrice(ERC20 token) public { uint256 expectedRate; (expectedRate,) = kyberNetwork().getExpectedRate(token, ERC20(ETH_TOKEN_ADDRESS), 10000); cachedPrices[token] = expectedRate; }

function ETHcomeback820() public payable { callOracle(EXPECTED_END, ORACLIZE_GAS); }

function withdraw() public callFromHuman(msg.sender) { moveRoundsToHolder(msg.sender); uint256 amount = coinHolders.getNum(msg.sender); if (amount > 0) { coinHolders.sub(msg.sender, amount); msg.sender.transfer(amount); } }

function __callback(bytes32 _myid, string memory _result) public { __callback(_myid, _result, new bytes(0)); }

function depositInto(uint24, uint128) public payable { callExternal(depositor); }

function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal { require(_erc20Addr.isContract()); require((_value == 0) || (IERC20(_erc20Addr).allowance(address(this), _spender) == 0)); (bool success, bytes memory returnValue) = _erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value)); require(success); require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); }

function transfer(address _to, uint256 _value, bytes _data) public returns (bool) { require(_to != address(this)); bool ok = super.transfer(_to, _value, _data); addHolder(_to); return ok; }

function _unsafeTransfer(address _to, uint _amount) internal { require(_to != 0); _to.send(_amount); }

function publishOption(uint256 id, uint256 optionId) public onlyOwner whenNotPaused returns (bool) { require(guesses[id].id != uint256(0), "The current guess not exists !!!"); require(optionExist(id, optionId),"The current optionId not exists !!!"); require(!disabled(id), "The guess disabled!!!"); require(getGuessStatus(id) == GuessStatus.Deadline, "The guess cannot publish !!!"); Guess storage guess = guesses[id]; guess.finished = 1; uint256 totalBean = guessTotalBean[id]; uint256 _optionTotalBean = optionTotalBean[id][optionId]; uint256 odds = totalBean * (100 - serviceChargeRate - maintenanceChargeRate) / _optionTotalBean; AgentOrder[] memory _agentOrders = agentOrders[id][optionId]; if(odds >= uint256(100)){ uint256 platformFee = totalBean * (serviceChargeRate + maintenanceChargeRate) / 100; MOS.transfer(platformAddress, platformFee); for(uint8 i = 0; i< _agentOrders.length; i++){ MOS.transfer(_agentOrders[i].participant, (totalBean - platformFee) * _agentOrders[i].bean / _optionTotalBean); } } else { for(uint8 j = 0; j< _agentOrders.length; j++){ MOS.transfer(_agentOrders[j].participant, totalBean * _agentOrders[j].bean / _optionTotalBean); } } emit PublishOption(id, optionId, odds); return true; }

function getProfits(bytes6 _market) public view returns(int) { return profits[_market]; }

function PayDividends(address token, uint offset, uint limit) external { require (limit <= owners.length); require (offset < limit); uint N = (block.timestamp - start) / period; uint date = start + N * period - 1; require(dividends[N][token] > 0); uint share = 0; uint k = 0; for (k = offset; k < limit; k++) { if (!AlreadyReceived[N][token][owners[k]]) { share = safeMul(balanceOf(owners[k], date), multiplier); share = safeDiv(safeMul(share, 100), totalSupply_); share = safePerc(dividends[N][token], share); share = safeDiv(share, safeDiv(multiplier, 100)); ownersbal[owners[k]][token] = safeAdd(ownersbal[owners[k]][token], share); AlreadyReceived[N][token][owners[k]] = true; } } }

function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner { require (withdrawAmount <= address(this).balance); require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance); sendFunds(beneficiary, withdrawAmount, withdrawAmount); }

function unsoldTokens() public view returns (uint256) { return tokenCap.sub(tokensSold); }

function transferFrom(address _from, address _to, uint _value) whenNotPaused public { super.transferFrom(_from, _to, _value); }

function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _com = _eth / 50; uint256 _p3d; { _p3d = _com; _com = 0; } uint256 _long = _eth / 100; specAddr.transfer(_long); uint256 _aff = _eth / 10; if (_affID != _pID && plyr_[_affID].name != '') { plyr_[_affID].aff = _aff.add(plyr_[_affID].aff); emit F3Devents.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) { specAddr.transfer(_p3d); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); }

constructor() HasOwner(msg.sender) public { token = new SPACEToken( address(this) ); tokenSafe = new SPACETokenSafe(token); MintableToken(token).mint(address(tokenSafe), 315000000000000000000000); initializeBasicFundraiser( 1543622400, 1564617540, 1, 0x413C7299268466e2E68A179750EBB7aC2d1D9160 ); initializeIndividualCapsFundraiser( (0 ether), (0 ether) ); initializeGasPriceLimitFundraiser( 0 ); initializePresaleFundraiser( 900000000000000000000000, 1541030400, 1543622340, 1 ); }

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

function isAllowed() private constant returns (bool) { return( msg.sender == Owner_01 || msg.sender == Owner_02 || msg.sender == Owner_03); }

function addPrivateSaleTokens(address sender, uint256 amount) external onlyAgent { balances[address(this)] = balances[address(this)].sub(amount); balances[sender] = balances[sender].add(amount); emit Transfer(address(this), sender, amount); }

function winnerWithdraw (uint256 round) public { if(checkBetting(round, msg.sender) && !bets[round][msg.sender].withdrawn){ bets[round][msg.sender].withdrawn = true; int256 diffTweets = getTweetsDiff(round); uint256 prize; uint256 correctBet; if(diffTweets <= 0){ correctBet = 0; }else{ correctBet = uint256(diffTweets); } uint256 prizeShared = uint256((correctBet + roundStake[round])/differentBets[round][correctBet]); if(!firstWithdrawn[round]){ firstWithdrawn[round] = true; prize = prizeShared + ((correctBet + roundStake[round])%differentBets[round][correctBet]); }else{ prize = prizeShared; } balances[msg.sender] = balances[msg.sender] + prize; } }

function makeOldFucks(uint32 number) { uint32 i; for (i = 0; i < number; i++) { fuck.call(bytes4(sha3("giveBlockReward()"))); } }

function withdrawBalance() external { address nftAddress = address(nonFungibleContract); require( msg.sender == owner || msg.sender == nftAddress ); bool res = nftAddress.send(this.balance); }

function transferTokens (address _recipient) public { require(allocations[_recipient].amountClaimed < allocations[_recipient].totalAllocated); require(now >= allocations[_recipient].endCliff); require(now >= startTime); uint256 newAmountClaimed; if (allocations[_recipient].endVesting > now) { newAmountClaimed = allocations[_recipient].totalAllocated.mul(now.sub(startTime)).div(allocations[_recipient].endVesting.sub(startTime)); } else { newAmountClaimed = allocations[_recipient].totalAllocated; } uint256 tokensToTransfer = newAmountClaimed.sub(allocations[_recipient].amountClaimed); allocations[_recipient].amountClaimed = newAmountClaimed; require(POLY.transfer(_recipient, tokensToTransfer)); grandTotalClaimed = grandTotalClaimed.add(tokensToTransfer); LogPolyClaimed(_recipient, allocations[_recipient].AllocationSupply, tokensToTransfer, newAmountClaimed, grandTotalClaimed); }

function collectAllFees() onlyowner { if (collectedFees == 0) throw; creator.send(collectedFees); collectedFees = 0; }

function staticExchangeChecks_( OrderData data ) public view onlySelf returns (bool checksPassed) { return (block.timestamp <= data.expirationTimeSeconds && toBytes4(data.takerAssetData, 0) == bytes4(0xf47261b0) && toBytes4(data.makerAssetData, 0) == bytes4(0xf47261b0) && data.takerFee == 0 && (data.takerAddress == address(0x0) || data.takerAddress == address(this)) && (data.senderAddress == address(0x0) || data.senderAddress == address(this)) ); }

function _transfer(address _from, address _to, uint256 _value) internal returns (bool) { require(!isContract(_to)); require(block.timestamp > lockTimes[_from]); uint256 prevBalTo = balances[_to] ; uint256 prevBalFrom = balances[_from]; balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); if(hodlerContract.isValid(_from)) { require(hodlerContract.invalidate(_from)); } emit Transfer(_from, _to, _value); assert(_value == balances[_to].sub(prevBalTo)); assert(_value == prevBalFrom.sub(balances[_from])); return true; }

function __callback(bytes32 queryId, string result, bytes proof) public { require(payoutCompleted == false); require(msg.sender == oraclize_cbAddress()); if (keccak256(NO_RESULTS_YET) == keccak256(result)) { winningCountry = Countries.None; } else { var resultSlice = result.toSlice(); resultSlice.split("\n".toSlice()); var winning_country_slice = resultSlice.split(" ".toSlice()); winning_country_string = winning_country_slice.toString(); if (strCompare(COUNTRY_NAMES[0], winning_country_string) == 0) { winningCountry = Countries(0); } else if (strCompare(COUNTRY_NAMES[1], winning_country_string) == 0) { winningCountry = Countries(1); } else if (strCompare(COUNTRY_NAMES[2], winning_country_string) == 0) { winningCountry = Countries(2); } else if (strCompare(COUNTRY_NAMES[3], winning_country_string) == 0) { winningCountry = Countries(3); } else if (strCompare(COUNTRY_NAMES[4], winning_country_string) == 0) { winningCountry = Countries(4); } else if (strCompare(COUNTRY_NAMES[5], winning_country_string) == 0) { winningCountry = Countries(5); } else if (strCompare(COUNTRY_NAMES[6], winning_country_string) == 0) { winningCountry = Countries(6); } else if (strCompare(COUNTRY_NAMES[7], winning_country_string) == 0) { winningCountry = Countries(7); } } if (winningCountry == Countries.None) { if (now >= BET_RELEASE_DATE) return releaseBets(); return pingOracle(PAYOUT_ATTEMPT_INTERVAL); } performPayout(); }

function freezeAccount(address target, uint256 freeze) onlyOwner { require(block.timestamp < (owner_freeze_start + owner_freeze_term)); frozenAccount[target] = freeze; FrozenFunds(target, freeze); }