Upload 491 files

output.csv

@@ -0,0 +1,779 @@
+,file,contract,ground truth,error_type
+0,15,NXX,1,timestamp dependency
+1,124,TTPresale,1,timestamp dependency
+2,176,IcoRocketFuel,1,timestamp dependency
+3,188,Duang8,1,timestamp dependency
+4,237,braggerContract,1,timestamp dependency
+5,292,CrowdsaleExt,1,timestamp dependency
+6,295,CrowdsaleExt,1,timestamp dependency
+7,347,CrowdsaleWPTByRounds,1,timestamp dependency
+8,361,FreezableToken,1,timestamp dependency
+9,361,FreezableMintableToken,1,timestamp dependency
+10,399,Saturn,1,timestamp dependency
+11,419,SnooKarma,1,timestamp dependency
+12,428,F3DPLUS,1,timestamp dependency
+13,496,TokenSale,1,timestamp dependency
+14,518,SCardLong,1,timestamp dependency
+15,578,ERC20Like,1,timestamp dependency
+16,613,SnooKarma,1,timestamp dependency
+17,649,DVPlock,1,timestamp dependency
+18,665,TwoYearDreamTokensVesting,1,timestamp dependency
+19,738,Token,1,timestamp dependency
+20,739,Crowdsale,1,timestamp dependency
+21,837,Controller,1,timestamp dependency
+22,883,RakuRakuEth,1,timestamp dependency
+23,1051,LimitCollectCoin,1,timestamp dependency
+24,1182,BitSongCrowdsale,1,timestamp dependency
+25,1256,Betting,1,timestamp dependency
+26,1318,WorkIt,1,timestamp dependency
+27,1667,JobsBounty,1,timestamp dependency
+28,1671,TokenSale,1,timestamp dependency
+29,1704,ExternalView,1,timestamp dependency
+30,1704,WinnerWinner,1,timestamp dependency
+31,1826,JobsBounty,1,timestamp dependency
+32,2315,ETHERlemon,1,timestamp dependency
+33,2389,ERC20Like,1,timestamp dependency
+34,2391,FsTKColdWallet,1,timestamp dependency
+35,2641,CrowdsaleExt,1,timestamp dependency
+36,2641,UpgradeableToken,1,timestamp dependency
+37,2646,CrowdsaleExt,1,timestamp dependency
+38,2688,F3d,1,timestamp dependency
+39,2711,ExhibationLinkingCoin,1,timestamp dependency
+40,2736,DisbursementHandler,1,timestamp dependency
+41,2736,TimedStateMachine,1,timestamp dependency
+42,2797,TimedCrowdsale,1,timestamp dependency
+43,2814,TokenSale,1,timestamp dependency
+44,2861,TokenVesting,1,timestamp dependency
+45,2948,BGAudit,1,timestamp dependency
+46,3100,CardsRaffle,1,timestamp dependency
+47,3125,NekoToken,1,timestamp dependency
+48,3185,StarmidFreezeTokens,1,timestamp dependency
+49,3240,TokenTimelock,1,timestamp dependency
+50,3240,TokenVesting,1,timestamp dependency
+51,3271,hodlEthereum,1,timestamp dependency
+52,6053,TimedCrowdsale,1,timestamp dependency
+53,6054,TimedCrowdsale,1,timestamp dependency
+54,6059,TimedCrowdsale,1,timestamp dependency
+55,6065,TokenTimelock,1,timestamp dependency
+56,6065,TokenVesting,1,timestamp dependency
+57,6149,JadeCoin,1,timestamp dependency
+58,6272,JadeCoin,1,timestamp dependency
+59,6297,TimedCrowdsale,1,timestamp dependency
+60,6297,JcnxxxCrowdsale,1,timestamp dependency
+61,6322,TokenTimelock,1,timestamp dependency
+62,6348,DutchAuction,1,timestamp dependency
+63,6369,LemoCoin,1,timestamp dependency
+64,6370,AMTTimelockedToken,1,timestamp dependency
+65,6396,SparksterToken,1,timestamp dependency
+66,6403,CrowdsaleExt,1,timestamp dependency
+67,6404,CrowdsaleExt,1,timestamp dependency
+68,6472,SparksterToken,1,timestamp dependency
+69,6534,XTVToken,1,timestamp dependency
+70,6578,CryptualProjectToken,1,timestamp dependency
+71,6586,TokenTimelockController,1,timestamp dependency
+72,6592,SparksterToken,1,timestamp dependency
+73,6596,FreezableToken,1,timestamp dependency
+74,6604,TimedCrowdsale,1,timestamp dependency
+75,6604,VreoTokenSale,1,timestamp dependency
+76,6663,TokenTimelockController,1,timestamp dependency
+77,6747,CrowdsaleBase,1,timestamp dependency
+78,6753,CrowdsaleBase,1,timestamp dependency
+79,6798,CrowdsaleBase,1,timestamp dependency
+80,6806,CrowdsaleBase,1,timestamp dependency
+81,6811,XTVToken,1,timestamp dependency
+82,6822,Lockable,1,timestamp dependency
+83,6833,MOEToken,1,timestamp dependency
+84,6844,XTVToken,1,timestamp dependency
+85,6846,FoMo3Dlong,1,timestamp dependency
+86,6915,TimedCrowdsale,1,timestamp dependency
+87,6933,AnythingAppTokenPreSale,1,timestamp dependency
+88,7012,TokenVesting,1,timestamp dependency
+89,7044,BaseICO,1,timestamp dependency
+90,7044,IonChainICO,1,timestamp dependency
+91,7046,Crowdsale,1,timestamp dependency
+92,7046,TokenVesting,1,timestamp dependency
+93,7046,GambioVesting,1,timestamp dependency
+94,7046,GambioCrowdsale,1,timestamp dependency
+95,7086,TokenTimelockController,1,timestamp dependency
+96,7134,FENIX,1,timestamp dependency
+97,7334,TimedCrowdsale,1,timestamp dependency
+98,7338,EtheremonRankBattle,1,timestamp dependency
+99,7419,SponsoredItemGooRaffle,1,timestamp dependency
+100,7440,FreezableToken,1,timestamp dependency
+101,7441,Crowdsale,1,timestamp dependency
+102,7441,MainCrowdsale,1,timestamp dependency
+103,7441,TemplateCrowdsale,1,timestamp dependency
+104,7464,TimedCrowdsale,1,timestamp dependency
+105,7464,GrapevineCrowdsale,1,timestamp dependency
+106,7466,TokenTimelockController,1,timestamp dependency
+107,7511,R1Exchange,1,timestamp dependency
+108,7512,CrowdsaleExt,1,timestamp dependency
+109,7515,CrowdsaleExt,1,timestamp dependency
+110,7519,BSPMintable,1,timestamp dependency
+111,7521,BSPVesting,1,timestamp dependency
+112,7570,GStarCrowdsale,1,timestamp dependency
+113,7627,NanoLoanEngine,1,timestamp dependency
+114,7724,CTCLock,1,timestamp dependency
+115,7736,CTCVesting,1,timestamp dependency
+116,7753,BVesting,1,timestamp dependency
+117,7775,TokenVesting,1,timestamp dependency
+118,7803,TimedCrowdsale,1,timestamp dependency
+119,7803,CareerChainPrivateSale,1,timestamp dependency
+120,8025,ESSENTIA_PE,1,timestamp dependency
+121,8099,tipbot,1,timestamp dependency
+122,8233,CrowdsaleExt,1,timestamp dependency
+123,8254,StakeDice,1,timestamp dependency
+124,8305,GigToken,1,timestamp dependency
+125,8305,CrowdSale,1,timestamp dependency
+126,8306,CrowdSale,1,timestamp dependency
+127,8314,Vault,1,timestamp dependency
+128,8320,ESSENTIA_PE,1,timestamp dependency
+129,8436,ESSENTIA_PE,1,timestamp dependency
+130,8470,StakeDice,1,timestamp dependency
+131,8505,TokenVesting,1,timestamp dependency
+132,8555,FreezableToken,1,timestamp dependency
+133,8555,FreezableMintableToken,1,timestamp dependency
+134,8555,MainToken,1,timestamp dependency
+135,8556,Crowdsale,1,timestamp dependency
+136,8556,FreezableToken,1,timestamp dependency
+137,8556,TemplateCrowdsale,1,timestamp dependency
+138,8596,CrowdsaleExt,1,timestamp dependency
+139,8606,YunMint,1,timestamp dependency
+140,8612,TokenVesting,1,timestamp dependency
+141,8614,CoinSparrow,1,timestamp dependency
+142,8615,TokenVesting,1,timestamp dependency
+143,8636,TokenVesting,1,timestamp dependency
+144,8636,VariableRateTokenVesting,1,timestamp dependency
+145,8647,StreamityEscrow,1,timestamp dependency
+146,8750,LemurTokenSale,1,timestamp dependency
+147,8766,ESSENTIA_PE,1,timestamp dependency
+148,8826,TokenOffering,1,timestamp dependency
+149,8851,mameCoin,1,timestamp dependency
+150,8926,DreamTeamToken,1,timestamp dependency
+151,8939,StreamityEscrow,1,timestamp dependency
+152,9208,Crowdsale,1,timestamp dependency
+153,9210,Crowdsale,1,timestamp dependency
+154,9221,EtherBet,1,timestamp dependency
+155,9224,TokenTimelock,1,timestamp dependency
+156,9230,Tokenlock,1,timestamp dependency
+157,9242,EthTeamContract,1,timestamp dependency
+158,9300,TimedCrowdsale,1,timestamp dependency
+159,9300,EoptCrowdsale,1,timestamp dependency
+160,9309,CrowdsaleExt,1,timestamp dependency
+161,9310,CrowdsaleExt,1,timestamp dependency
+162,9322,Cryphos,1,timestamp dependency
+163,9329,FreezableToken,1,timestamp dependency
+164,9333,CrowdsaleExt,1,timestamp dependency
+165,9334,CrowdsaleExt,1,timestamp dependency
+166,9358,SecurityController,1,timestamp dependency
+167,9359,SecurityController,1,timestamp dependency
+168,9378,PGOMonthlyPresaleVault,1,timestamp dependency
+169,9379,PGOVault,1,timestamp dependency
+170,9379,PGOMonthlyInternalVault,1,timestamp dependency
+171,9379,PGOMonthlyPresaleVault,1,timestamp dependency
+172,9379,GotCrowdSale,1,timestamp dependency
+173,9474,WaltonTokenLocker,1,timestamp dependency
+174,9476,WaltonTokenLocker,1,timestamp dependency
+175,9499,WaltonTokenLocker,1,timestamp dependency
+176,9500,WaltonTokenLocker,1,timestamp dependency
+177,9502,FreezableToken,1,timestamp dependency
+178,9505,WaltonTokenLocker,1,timestamp dependency
+179,9521,WaltonTokenLocker,1,timestamp dependency
+180,9531,CryptualProjectToken,1,timestamp dependency
+181,9560,dappVolumeAd,1,timestamp dependency
+182,9654,SimpleBet,1,timestamp dependency
+183,9759,FreezableToken,1,timestamp dependency
+184,9779,CrowdsaleExt,1,timestamp dependency
+185,9780,CrowdsaleExt,1,timestamp dependency
+186,9802,CrowdsaleExt,1,timestamp dependency
+187,9803,CrowdsaleExt,1,timestamp dependency
+188,9805,CrowdsaleExt,1,timestamp dependency
+189,9806,CrowdsaleExt,1,timestamp dependency
+190,9820,CrowdsaleRC,1,timestamp dependency
+191,9830,SpaceWar,1,timestamp dependency
+192,9843,Frozenable,1,timestamp dependency
+193,9843,Releaseable,1,timestamp dependency
+194,9850,PLCRVoting,1,timestamp dependency
+195,9850,Parameterizer,1,timestamp dependency
+196,9851,PLCRVoting,1,timestamp dependency
+197,9851,Parameterizer,1,timestamp dependency
+198,9858,CrowdsaleExt,1,timestamp dependency
+199,9859,CrowdsaleExt,1,timestamp dependency
+200,9889,SecurityController,1,timestamp dependency
+201,9890,CrowdsaleExt,1,timestamp dependency
+202,9892,CrowdsaleExt,1,timestamp dependency
+203,9918,GENEOSSale,1,timestamp dependency
+204,9978,EthTeamContract,1,timestamp dependency
+205,9987,DQCoin,1,timestamp dependency
+206,9994,BaseGameLogic,1,timestamp dependency
+207,9998,EthTeamContract,1,timestamp dependency
+208,10022,CrowdsaleExt,1,timestamp dependency
+209,10023,CrowdsaleExt,1,timestamp dependency
+210,10024,CrowdsaleExt,1,timestamp dependency
+211,10025,CrowdsaleExt,1,timestamp dependency
+212,10129,CrowdsaleBase,1,timestamp dependency
+213,10129,KYCPresale,1,timestamp dependency
+214,10131,ICO,1,timestamp dependency
+215,10131,Tokens,1,timestamp dependency
+216,10133,Tokens,1,timestamp dependency
+217,10146,KOIOSTokenSale,1,timestamp dependency
+218,10146,KOIOSTokenPreSale,1,timestamp dependency
+219,10159,XPAAssets,1,timestamp dependency
+220,10186,FreezableToken,1,timestamp dependency
+221,10189,TokenTimelock,1,timestamp dependency
+222,10189,TokenVesting,1,timestamp dependency
+223,10250,CrowdsaleExt,1,timestamp dependency
+224,10253,CrowdsaleExt,1,timestamp dependency
+225,10369,MuskTokenVault,1,timestamp dependency
+226,10431,EthTeamContract,1,timestamp dependency
+227,10547,ATTRToken,1,timestamp dependency
+228,10551,CrowdsaleExt,1,timestamp dependency
+229,10552,CrowdsaleExt,1,timestamp dependency
+230,10559,Crowdsale,1,timestamp dependency
+231,10559,TokenTimelock,1,timestamp dependency
+232,10560,Crowdsale,1,timestamp dependency
+233,10560,TokenTimelock,1,timestamp dependency
+234,10736,LescovexERC20,1,timestamp dependency
+235,10755,Crowdsale,1,timestamp dependency
+236,10755,FreezableToken,1,timestamp dependency
+237,10758,FreezableToken,1,timestamp dependency
+238,10763,Frozenable,1,timestamp dependency
+239,10798,TokenTimelock,1,timestamp dependency
+240,10803,AnythingAppTokenPreSale,1,timestamp dependency
+241,10807,CrowdsaleExt,1,timestamp dependency
+242,10808,CrowdsaleExt,1,timestamp dependency
+243,10826,AnythingAppTokenPreSale,1,timestamp dependency
+244,10833,AnythingAppTokenPreSale,1,timestamp dependency
+245,10855,TokenLock,1,timestamp dependency
+246,10915,DiceRoll,1,timestamp dependency
+247,10931,CrowdsaleBase,1,timestamp dependency
+248,11021,PAIStandardToken,1,timestamp dependency
+249,11063,TimedCrowdsale,1,timestamp dependency
+250,11064,ANSAToken,1,timestamp dependency
+251,11069,Deposit,1,timestamp dependency
+252,11069,Redeem,1,timestamp dependency
+253,11182,CrowdsaleExt,1,timestamp dependency
+254,11183,FractionalERC20Ext,1,timestamp dependency
+255,11190,TimedCrowdsale,1,timestamp dependency
+256,11191,DiceForSlice,1,timestamp dependency
+257,11205,TimedCrowdsale,1,timestamp dependency
+258,11207,ANDToken,1,timestamp dependency
+259,11223,MCoinDistribution,1,timestamp dependency
+260,11236,EDiamondToken,1,timestamp dependency
+261,11237,TimedCrowdsale,1,timestamp dependency
+262,11237,T2TCrowdsale,1,timestamp dependency
+263,11243,EmontFrenzy,1,timestamp dependency
+264,11257,TTGOracle,1,timestamp dependency
+265,11323,TUINETWORK,1,timestamp dependency
+266,11328,BWService,1,timestamp dependency
+267,11328,BW,1,timestamp dependency
+268,11329,BWService,1,timestamp dependency
+269,11330,BWService,1,timestamp dependency
+270,11339,CrowdsaleExt,1,timestamp dependency
+271,11340,CrowdsaleExt,1,timestamp dependency
+272,11373,TimedCrowdsale,1,timestamp dependency
+273,11374,DAVToken,1,timestamp dependency
+274,11407,Validation,1,timestamp dependency
+275,11415,CrowdsaleExt,1,timestamp dependency
+276,11416,CrowdsaleExt,1,timestamp dependency
+277,11418,CrowdsaleExt,1,timestamp dependency
+278,11419,CrowdsaleExt,1,timestamp dependency
+279,11447,TimedCrowdsale,1,timestamp dependency
+280,11448,SuperCountriesEth,1,timestamp dependency
+281,11457,BCVTokenVault,1,timestamp dependency
+282,11526,Escrow,1,timestamp dependency
+283,11566,Variation,1,timestamp dependency
+284,11568,SetLottery,1,timestamp dependency
+285,11569,CrowdsaleTokenExt,1,timestamp dependency
+286,11640,CrowdsaleExt,1,timestamp dependency
+287,11642,CrowdsaleExt,1,timestamp dependency
+288,11684,CrowdsaleExt,1,timestamp dependency
+289,11685,CrowdsaleExt,1,timestamp dependency
+290,11711,Escrow,1,timestamp dependency
+291,11716,TimedCrowdsale,1,timestamp dependency
+292,11727,FreezableToken,1,timestamp dependency
+293,11751,TokenVesting,1,timestamp dependency
+294,11765,FreezableToken,1,timestamp dependency
+295,11766,FreezableToken,1,timestamp dependency
+296,11775,CrowdsaleBase,1,timestamp dependency
+297,11776,CrowdsaleBase,1,timestamp dependency
+298,11777,AllocatedCappedCrowdsale,1,timestamp dependency
+299,11778,LockToken,1,timestamp dependency
+300,11779,CrowdsaleBase,1,timestamp dependency
+301,11780,CrowdsaleBase,1,timestamp dependency
+302,11786,TokenVesting,1,timestamp dependency
+303,11798,CopaDelCrypto,1,timestamp dependency
+304,11804,TokenVesting,1,timestamp dependency
+305,0,BREBuy,1,block number dependency
+306,42,PoP,1,block number dependency
+307,57,ForeignBridgeErcToErc,1,block number dependency
+308,58,MiniMeToken,1,block number dependency
+309,58,AywakeToken,1,block number dependency
+310,103,EBLLToken,1,block number dependency
+311,106,SPMTToken,1,block number dependency
+312,112,ZeroGoldPOWMining,1,block number dependency
+313,129,DelayedClaimable,1,block number dependency
+314,135,HorseyToken,1,block number dependency
+315,136,HorseyToken,1,block number dependency
+316,137,HorseyToken,1,block number dependency
+317,138,DelayedClaimable,1,block number dependency
+318,164,BREBuy,1,block number dependency
+319,173,EBBToken,1,block number dependency
+320,196,DelayedClaimable,1,block number dependency
+321,215,HorseyToken,1,block number dependency
+322,216,HorseyToken,1,block number dependency
+323,217,HorseyToken,1,block number dependency
+324,220,DelayedClaimable,1,block number dependency
+325,238,DEJToken,1,block number dependency
+326,246,Pinakion,1,block number dependency
+327,246,BlockHashRNGFallback,1,block number dependency
+328,277,Random,1,block number dependency
+329,313,Ethnamed,1,block number dependency
+330,399,Saturn,1,block number dependency
+331,413,StandardToken,1,block number dependency
+332,413,CryptoCongress,1,block number dependency
+333,415,Pinakion,1,block number dependency
+334,415,BlockHashRNGFallback,1,block number dependency
+335,436,DelayedClaimable,1,block number dependency
+336,441,QCOToken,1,block number dependency
+337,584,ULCToken,1,block number dependency
+338,639,HorseyToken,1,block number dependency
+339,642,DelayedClaimable,1,block number dependency
+340,652,LighthouseLib,1,block number dependency
+341,652,RobotLiabilityLib,1,block number dependency
+342,654,HorseyToken,1,block number dependency
+343,655,HorseyToken,1,block number dependency
+344,661,DelayedClaimable,1,block number dependency
+345,672,Game,1,block number dependency
+346,677,BREBuy_ERC20,1,block number dependency
+347,681,ULChain,1,block number dependency
+348,705,DelayedClaimable,1,block number dependency
+349,710,HorseyToken,1,block number dependency
+350,712,HorseyToken,1,block number dependency
+351,713,HorseyToken,1,block number dependency
+352,749,Lockable,1,block number dependency
+353,753,LighthouseLib,1,block number dependency
+354,753,RobotLiabilityLib,1,block number dependency
+355,759,DelayedClaimable,1,block number dependency
+356,762,Crowdsale,1,block number dependency
+357,765,TravelHelperToken,1,block number dependency
+358,810,DelayedClaimable,1,block number dependency
+359,931,DelayedClaimable,1,block number dependency
+360,970,OATToken,1,block number dependency
+361,980,HKHCToken,1,block number dependency
+362,1017,Zlots,1,block number dependency
+363,1034,PoCGame,1,block number dependency
+364,1044,PoCGame,1,block number dependency
+365,1052,Zlots,1,block number dependency
+366,1056,Zlots,1,block number dependency
+367,1096,Zlots,1,block number dependency
+368,1101,Zlots,1,block number dependency
+369,1121,DelayedClaimable,1,block number dependency
+370,1149,Zethroll,1,block number dependency
+371,1165,DelayedClaimable,1,block number dependency
+372,1297,BREBuy,1,block number dependency
+373,1345,Zethroll,1,block number dependency
+374,1376,Win20ETH,1,block number dependency
+375,1406,EVTCTLToken,1,block number dependency
+376,1472,Zlots,1,block number dependency
+377,1482,DelayedClaimable,1,block number dependency
+378,1546,Zlots,1,block number dependency
+379,1567,GuessEth,1,block number dependency
+380,1673,Zlots,1,block number dependency
+381,1678,DelayedClaimable,1,block number dependency
+382,1698,EVTCToken,1,block number dependency
+383,1714,Zethroll,1,block number dependency
+384,1761,Zlots,1,block number dependency
+385,1791,DelayedClaimable,1,block number dependency
+386,1986,PoP,1,block number dependency
+387,2003,Zlots,1,block number dependency
+388,2110,GuessEth,1,block number dependency
+389,2295,WrapperLock,1,block number dependency
+390,2296,WrapperLockEth,1,block number dependency
+391,2584,Zethroll,1,block number dependency
+392,2587,Zethroll,1,block number dependency
+393,2589,Zethroll,1,block number dependency
+394,2593,Zethroll,1,block number dependency
+395,2619,UnityToken,1,block number dependency
+396,2632,AntiFakeLabelToken,1,block number dependency
+397,2633,Zethroll,1,block number dependency
+398,2638,Zethroll,1,block number dependency
+399,2644,POOHMO,1,block number dependency
+400,2658,Zethroll,1,block number dependency
+401,2670,TwentyDollars,1,block number dependency
+402,2734,DivMultisigHackable,1,block number dependency
+403,2805,AZExchange,1,block number dependency
+404,2825,KickTheCoin,1,block number dependency
+405,2963,IMDEXDexchange,1,block number dependency
+406,2977,LedToken,1,block number dependency
+407,2978,LedToken,1,block number dependency
+408,2990,MerkleMine,1,block number dependency
+409,2990,MultiMerkleMine,1,block number dependency
+410,2991,PlayCoinKey,1,block number dependency
+411,3060,TokenLock,1,block number dependency
+412,3062,TokenLock,1,block number dependency
+413,3105,ShintakuToken,1,block number dependency
+414,3123,IcoLib,1,block number dependency
+415,3132,PresalePool,1,block number dependency
+416,3201,AuctionPack,1,block number dependency
+417,3240,NokuCustomERC20,1,block number dependency
+418,3284,MiniMeToken,1,block number dependency
+419,3290,MiniMeToken,1,block number dependency
+420,3291,MiniMeToken,1,block number dependency
+421,3311,nDEX,1,block number dependency
+422,3337,PolarisDEX,1,block number dependency
+423,3386,ContractForDifference,1,block number dependency
+424,3574,BitDex,1,block number dependency
+425,3689,EthertoteToken,1,block number dependency
+426,3704,KickTheCoin,1,block number dependency
+427,3708,WithdrawFromKickTheCoin,1,block number dependency
+428,3711,KickTheCoin,1,block number dependency
+429,3828,LavaWallet,1,block number dependency
+430,3955,DelayedClaimable,1,block number dependency
+431,3970,XinXianToken,1,block number dependency
+432,3971,IcoLib,1,block number dependency
+433,510,AbstractStorage,1,dangerous delegatecall
+434,2004,Proxy,1,dangerous delegatecall
+435,3721,Proxy,1,dangerous delegatecall
+436,3721,DutchExchangeProxy,1,dangerous delegatecall
+437,5321,Proxy,1,dangerous delegatecall
+438,5321,DutchExchangeProxy,1,dangerous delegatecall
+439,5349,Proxy,1,dangerous delegatecall
+440,5349,DutchExchangeProxy,1,dangerous delegatecall
+441,5901,Proxy,1,dangerous delegatecall
+442,5901,DutchExchangeProxy,1,dangerous delegatecall
+443,6043,VersionedToken,1,dangerous delegatecall
+444,6043,SPFCToken,1,dangerous delegatecall
+445,7129,Proxy,1,dangerous delegatecall
+446,7129,DutchExchangeProxy,1,dangerous delegatecall
+447,7493,Proxy,1,dangerous delegatecall
+448,7494,Proxy,1,dangerous delegatecall
+449,7494,DutchExchangeProxy,1,dangerous delegatecall
+450,7628,Registry,1,dangerous delegatecall
+451,11089,Proxy,1,dangerous delegatecall
+452,11089,DutchExchangeProxy,1,dangerous delegatecall
+453,12692,main,1,dangerous delegatecall
+454,13000,EllipseMarketMaker,1,dangerous delegatecall
+455,20625,VersionedToken,1,dangerous delegatecall
+456,20625,ELTToken,1,dangerous delegatecall
+457,20740,Proxy,1,dangerous delegatecall
+458,20740,KnowledgeProxy,1,dangerous delegatecall
+459,21312,Proxy,1,dangerous delegatecall
+460,21312,DutchExchangeProxy,1,dangerous delegatecall
+461,21313,Proxy,1,dangerous delegatecall
+462,21313,DutchExchangeProxy,1,dangerous delegatecall
+463,21314,Proxy,1,dangerous delegatecall
+464,21314,DutchExchangeProxy,1,dangerous delegatecall
+465,22229,MultiSigStub,1,dangerous delegatecall
+466,22344,Proxy,1,dangerous delegatecall
+467,22344,DutchExchangeProxy,1,dangerous delegatecall
+468,22345,Proxy,1,dangerous delegatecall
+469,22345,DutchExchangeProxy,1,dangerous delegatecall
+470,22943,Ohni,1,dangerous delegatecall
+471,23604,token,1,dangerous delegatecall
+472,25217,Standard223Receiver,1,dangerous delegatecall
+473,25217,EllipseMarketMaker,1,dangerous delegatecall
+474,25219,Standard223Receiver,1,dangerous delegatecall
+475,26431,Proxy,1,dangerous delegatecall
+476,26431,DutchExchangeProxy,1,dangerous delegatecall
+477,27767,RiskSharingToken,1,dangerous delegatecall
+478,29219,SimpleDispatcher,1,dangerous delegatecall
+479,29219,PersonalCrowdsaleProxyDispatcher,1,dangerous delegatecall
+480,29717,UserWallet,1,dangerous delegatecall
+481,29999,Proxy,1,dangerous delegatecall
+482,29999,DutchExchangeProxy,1,dangerous delegatecall
+483,30357,testBank,1,dangerous delegatecall
+484,30358,debugContract,1,dangerous delegatecall
+485,30679,MultiSigStub,1,dangerous delegatecall
+486,30692,firstTest,1,dangerous delegatecall
+487,33425,AdminInterface,1,dangerous delegatecall
+488,33567,Proxy,1,dangerous delegatecall
+489,33567,DutchExchangeProxy,1,dangerous delegatecall
+490,33727,Dispatcher,1,dangerous delegatecall
+491,33741,EDProxy,1,dangerous delegatecall
+492,33799,caller,1,dangerous delegatecall
+493,34410,Router,1,dangerous delegatecall
+494,34483,Conductor,1,dangerous delegatecall
+495,38293,Proxy,1,dangerous delegatecall
+496,38293,DutchExchangeProxy,1,dangerous delegatecall
+497,38370,Proxy,1,dangerous delegatecall
+498,38370,DutchExchangeProxy,1,dangerous delegatecall
+499,43210,Proxy,1,dangerous delegatecall
+500,43210,DutchExchangeProxy,1,dangerous delegatecall
+501,44311,DelegateCaller,1,dangerous delegatecall
+502,44417,InstaAccount,1,dangerous delegatecall
+503,44418,InstaAccountV2,1,dangerous delegatecall
+504,47235,Proxy,1,dangerous delegatecall
+505,47235,DutchExchangeProxy,1,dangerous delegatecall
+506,47236,Proxy,1,dangerous delegatecall
+507,47236,DutchExchangeProxy,1,dangerous delegatecall
+508,20189,Withdrawals,1,unchecked external call
+509,22074,SIMPLE_PIGGY_BANK,1,unchecked external call
+510,22675,Withdrawable,1,unchecked external call
+511,31497,MultiplicatorX4,1,unchecked external call
+512,33447,OrganizeFunds,1,unchecked external call
+513,33464,Vault,1,unchecked external call
+514,33512,MultiplicatorX3,1,unchecked external call
+515,35078,minter,1,unchecked external call
+516,35421,DSBaseActor,1,unchecked external call
+517,35904,Withdrawals,1,unchecked external call
+518,35970,EnjinBuyer,1,unchecked external call
+519,36334,RequestSale,1,unchecked external call
+520,37707,BountyHunt,1,unchecked external call
+521,39268,TownCrier,1,unchecked external call
+522,40120,Withdrawals,1,unchecked external call
+523,40123,Withdrawals,1,unchecked external call
+524,40124,Withdrawals,1,unchecked external call
+525,40127,Withdrawals,1,unchecked external call
+526,40129,Withdrawals,1,unchecked external call
+527,40250,Withdrawals,1,unchecked external call
+528,40256,Withdrawals,1,unchecked external call
+529,40259,Withdrawals,1,unchecked external call
+530,40267,Withdrawals,1,unchecked external call
+531,40290,Withdrawals,1,unchecked external call
+532,40301,Withdrawals,1,unchecked external call
+533,40304,Withdrawals,1,unchecked external call
+534,40307,Withdrawals,1,unchecked external call
+535,40310,Withdrawals,1,unchecked external call
+536,40315,Withdrawals,1,unchecked external call
+537,40345,Withdrawals,1,unchecked external call
+538,40346,Withdrawals,1,unchecked external call
+539,40347,Withdrawals,1,unchecked external call
+540,40348,Withdrawals,1,unchecked external call
+541,40349,Withdrawals,1,unchecked external call
+542,40368,Withdrawals,1,unchecked external call
+543,40370,Withdrawals,1,unchecked external call
+544,40372,Withdrawals,1,unchecked external call
+545,40374,Withdrawals,1,unchecked external call
+546,40375,Withdrawals,1,unchecked external call
+547,40406,Dice,1,unchecked external call
+548,40407,Dice,1,unchecked external call
+549,40408,Dice,1,unchecked external call
+550,40432,Withdrawals,1,unchecked external call
+551,40435,Withdrawals,1,unchecked external call
+552,40437,Withdrawals,1,unchecked external call
+553,40452,Withdrawals,1,unchecked external call
+554,40454,Withdrawals,1,unchecked external call
+555,40458,Dice,1,unchecked external call
+556,40459,Dice,1,unchecked external call
+557,40460,Dice,1,unchecked external call
+558,40461,Dice,1,unchecked external call
+559,40462,Dice,1,unchecked external call
+560,40481,KissBTC,1,unchecked external call
+561,40500,MICRODAO,1,unchecked external call
+562,40511,Withdrawals,1,unchecked external call
+563,40513,Withdrawals,1,unchecked external call
+564,40521,Withdrawals,1,unchecked external call
+565,40524,Withdrawals,1,unchecked external call
+566,40527,Withdrawals,1,unchecked external call
+567,40623,Withdrawals,1,unchecked external call
+568,40634,Withdrawals,1,unchecked external call
+569,40640,Withdrawals,1,unchecked external call
+570,40654,Withdrawals,1,unchecked external call
+571,40655,Withdrawals,1,unchecked external call
+572,40733,Attack,1,unchecked external call
+573,43091,Withdrawals,1,unchecked external call
+574,43100,Withdrawals,1,unchecked external call
+575,43101,Withdrawals,1,unchecked external call
+576,43121,Withdrawals,1,unchecked external call
+577,43123,Withdrawals,1,unchecked external call
+578,43330,Withdrawals,1,unchecked external call
+579,43334,Withdrawals,1,unchecked external call
+580,43369,Withdrawals,1,unchecked external call
+581,43379,Withdrawals,1,unchecked external call
+582,43387,Withdrawals,1,unchecked external call
+583,43590,Withdrawals,1,unchecked external call
+584,43593,Withdrawals,1,unchecked external call
+585,43595,Withdrawals,1,unchecked external call
+586,43747,Withdrawals,1,unchecked external call
+587,43750,Withdrawals,1,unchecked external call
+588,43752,Withdrawals,1,unchecked external call
+589,43757,Withdrawals,1,unchecked external call
+590,43769,Withdrawals,1,unchecked external call
+591,44156,LoanTokenSettings,1,unchecked external call
+592,44340,Withdrawals,1,unchecked external call
+593,44341,Withdrawals,1,unchecked external call
+594,44342,Withdrawals,1,unchecked external call
+595,44343,Withdrawals,1,unchecked external call
+596,44344,Withdrawals,1,unchecked external call
+597,44432,HeadTail,1,unchecked external call
+598,44548,Withdrawals,1,unchecked external call
+599,44555,Withdrawals,1,unchecked external call
+600,44576,Withdrawals,1,unchecked external call
+601,44577,Withdrawals,1,unchecked external call
+602,44579,Withdrawals,1,unchecked external call
+603,44810,Withdrawals,1,unchecked external call
+604,44812,Withdrawals,1,unchecked external call
+605,44813,Withdrawals,1,unchecked external call
+606,44815,Withdrawals,1,unchecked external call
+607,44821,Withdrawals,1,unchecked external call
+608,44850,DAO,1,unchecked external call
+609,44994,BaseWallet,1,unchecked external call
+610,44998,Withdrawals,1,unchecked external call
+611,45000,Withdrawals,1,unchecked external call
+612,45011,Withdrawals,1,unchecked external call
+613,45013,Withdrawals,1,unchecked external call
+614,45020,Withdrawals,1,unchecked external call
+615,45030,FakeWallet,1,unchecked external call
+616,45052,KyberNetworkTest,1,unchecked external call
+617,60,MultiBuyer,1,reentrancy
+618,80,MultiBuyer,1,reentrancy
+619,81,MultiBuyer,1,reentrancy
+620,92,MultiBuyer,1,reentrancy
+621,95,MultiBuyer,1,reentrancy
+622,165,MultiBuyer,1,reentrancy
+623,168,MultiBuyer,1,reentrancy
+624,180,MultiBuyer,1,reentrancy
+625,187,MultiBuyer,1,reentrancy
+626,241,MultiBuyer,1,reentrancy
+627,245,MultiBuyer,1,reentrancy
+628,268,MultiBuyer,1,reentrancy
+629,332,MultiBuyer,1,reentrancy
+630,336,MultiBuyer,1,reentrancy
+631,420,MultiBuyer,1,reentrancy
+632,425,MultiBuyer,1,reentrancy
+633,470,MultiBuyer,1,reentrancy
+634,475,MultiBuyer,1,reentrancy
+635,520,MultiBuyer,1,reentrancy
+636,523,MultiBuyer,1,reentrancy
+637,601,MultiBuyer,1,reentrancy
+638,609,MultiBuyer,1,reentrancy
+639,668,MultiBuyer,1,reentrancy
+640,670,MultiBuyer,1,reentrancy
+641,678,MultiBuyer,1,reentrancy
+642,717,MultiBuyer,1,reentrancy
+643,721,MultiBuyer,1,reentrancy
+644,754,MultiBuyer,1,reentrancy
+645,760,MultiBuyer,1,reentrancy
+646,798,MultiBuyer,1,reentrancy
+647,801,MultiBuyer,1,reentrancy
+648,870,MultiBuyer,1,reentrancy
+649,871,MultiBuyer,1,reentrancy
+650,930,MultiBuyer,1,reentrancy
+651,934,MultiBuyer,1,reentrancy
+652,989,MultiBuyer,1,reentrancy
+653,990,MultiBuyer,1,reentrancy
+654,1011,MultiBuyer,1,reentrancy
+655,1021,MultiBuyer,1,reentrancy
+656,1023,MultiBuyer,1,reentrancy
+657,1030,MultiBuyer,1,reentrancy
+658,1076,MultiBuyer,1,reentrancy
+659,1078,MultiBuyer,1,reentrancy
+660,1155,ZethrBankroll,1,reentrancy
+661,1421,MultiBuyer,1,reentrancy
+662,1423,MultiBuyer,1,reentrancy
+663,1427,MultiBuyer,1,reentrancy
+664,1489,MultiBuyer,1,reentrancy
+665,1491,MultiBuyer,1,reentrancy
+666,1498,MultiBuyer,1,reentrancy
+667,1600,MultiBuyer,1,reentrancy
+668,1611,MultiBuyer,1,reentrancy
+669,1620,MultiBuyer,1,reentrancy
+670,1634,MultiBuyer,1,reentrancy
+671,20780,MultiBuyer,1,reentrancy
+672,20810,MultiBuyer,1,reentrancy
+673,20815,MultiBuyer,1,reentrancy
+674,20821,MultiBuyer,1,reentrancy
+675,21071,MultiBuyer,1,reentrancy
+676,21080,MultiBuyer,1,reentrancy
+677,21082,MultiBuyer,1,reentrancy
+678,21084,MultiBuyer,1,reentrancy
+679,21390,Accrual_account,1,reentrancy
+680,21391,MultiSigWallet,1,reentrancy
+681,21391,MultiSigWalletWithDailyLimit,1,reentrancy
+682,21700,MultiBuyer,1,reentrancy
+683,21703,MultiBuyer,1,reentrancy
+684,21741,MultiBuyer,1,reentrancy
+685,21750,MultiBuyer,1,reentrancy
+686,21755,COIN_BOX,1,reentrancy
+687,22074,SIMPLE_PIGGY_BANK,1,reentrancy
+688,22478,MultiBuyer,1,reentrancy
+689,22480,MultiBuyer,1,reentrancy
+690,22485,MultiBuyer,1,reentrancy
+691,22500,MultiBuyer,1,reentrancy
+692,22810,MultiBuyer,1,reentrancy
+693,22813,MultiBuyer,1,reentrancy
+694,22823,MultiBuyer,1,reentrancy
+695,22854,MultiBuyer,1,reentrancy
+696,24456,ETH_VAULT,1,reentrancy
+697,24501,MultiBuyer,1,reentrancy
+698,24507,MultiBuyer,1,reentrancy
+699,24517,MultiBuyer,1,reentrancy
+700,24520,MultiBuyer,1,reentrancy
+701,31620,MultiBuyer,1,reentrancy
+702,31624,MultiBuyer,1,reentrancy
+703,31627,MultiBuyer,1,reentrancy
+704,31632,MultiBuyer,1,reentrancy
+705,31890,MultiBuyer,1,reentrancy
+706,31893,MultiBuyer,1,reentrancy
+707,31895,MultiBuyer,1,reentrancy
+708,31900,MultiBuyer,1,reentrancy
+709,32090,MultiBuyer,1,reentrancy
+710,32091,MultiBuyer,1,reentrancy
+711,32095,MultiBuyer,1,reentrancy
+712,32100,MultiBuyer,1,reentrancy
+713,32470,MultiBuyer,1,reentrancy
+714,32474,MultiBuyer,1,reentrancy
+715,32480,MultiBuyer,1,reentrancy
+716,32481,MultiBuyer,1,reentrancy
+717,32700,MultiBuyer,1,reentrancy
+718,32701,MultiBuyer,1,reentrancy
+719,32710,MultiBuyer,1,reentrancy
+720,32715,MultiBuyer,1,reentrancy
+721,33907,MultiBuyer,1,reentrancy
+722,33910,MultiBuyer,1,reentrancy
+723,33912,MultiBuyer,1,reentrancy
+724,33991,MultiBuyer,1,reentrancy
+725,33995,MultiBuyer,1,reentrancy
+726,33998,MultiBuyer,1,reentrancy
+727,34000,MultiBuyer,1,reentrancy
+728,34090,MultiBuyer,1,reentrancy
+729,34092,MultiBuyer,1,reentrancy
+730,34095,MultiBuyer,1,reentrancy
+731,34098,MultiBuyer,1,reentrancy
+732,34328,MultiBuyer,1,reentrancy
+733,34330,MultiBuyer,1,reentrancy
+734,34331,MultiBuyer,1,reentrancy
+735,34334,MultiBuyer,1,reentrancy
+736,9,WWW,1,integer overflow
+737,33,AbcdEfg,1,integer overflow
+738,34,GlobalGoldCashToken,1,integer overflow
+739,35,BEECASHBACKHOME,1,integer overflow
+740,117,ExShellToken,1,integer overflow
+741,118,ExShellToken,1,integer overflow
+742,126,TestCoin,1,integer overflow
+743,130,ExShellToken,1,integer overflow
+744,143,ExShellToken,1,integer overflow
+745,169,ExShellToken,1,integer overflow
+746,241,ExShellToken,1,integer overflow
+747,258,CRYPTOHEDGECoin,1,integer overflow
+748,339,ExShellToken,1,integer overflow
+749,364,ATM,1,integer overflow
+750,370,Purox,1,integer overflow
+751,372,MntToken,1,integer overflow
+752,375,ExShellToken,1,integer overflow
+753,385,HelpingBlocksContract,1,integer overflow
+754,394,ExShellToken,1,integer overflow
+755,465,ExShellToken,1,integer overflow
+756,520,HeavenlyHoundCoin,1,integer overflow
+757,544,HNContract,1,integer overflow
+758,566,CYFToken,1,integer overflow
+759,607,ExShellToken,1,integer overflow
+760,633,StandardToken,1,integer overflow
+761,633,NABC,1,integer overflow
+762,640,ExShellToken,1,integer overflow
+763,655,ExShellToken,1,integer overflow
+764,688,QPay,1,integer overflow
+765,847,ExShellToken,1,integer overflow
+766,944,VXR,1,integer overflow
+767,977,WBET,1,integer overflow
+768,980,ExShellToken,1,integer overflow
+769,1675,ExShellToken,1,integer overflow
+770,1690,ExShellToken,1,integer overflow
+771,1711,ExShellToken,1,integer overflow
+772,1720,ExShellToken,1,integer overflow
+773,1735,ExShellToken,1,integer overflow
+774,1808,ZXCToken,1,integer overflow
+775,1822,CoinByInsomnia,1,integer overflow
+776,1896,SAFCOIN,1,integer overflow
+777,1955,BBBToken,1,integer overflow

smart_contract_dataset/block number dependency/0.sol

@@ -0,0 +1,169 @@
+pragma solidity ^0.4.24;
+contract BREBuy {
+    
+    struct ContractParam {
+        uint32  totalSize ; 
+        uint256 singlePrice;
+        uint8  pumpRate;
+        bool hasChange;
+    }
+    
+    address owner = 0x0;
+    uint32  gameIndex = 0;
+    uint256 totalPrice= 0;
+    bool isLock = false;
+    ContractParam public setConfig;
+    ContractParam public curConfig;
+    
+    address[] public addressArray = new address[](0);
+                    
+    event openLockEvent();
+    event addPlayerEvent(uint32 gameIndex,address player);
+    event gameOverEvent(uint32 gameIndex,uint32 totalSize,uint256 singlePrice,uint8 pumpRate,address winAddr,uint overTime);
+    event stopGameEvent(uint totalBalace,uint totalSize,uint price);
+          
+     
+    constructor ( uint32 _totalSize,
+                  uint256 _singlePrice
+    )  public  {
+        owner = msg.sender;
+        setConfig = ContractParam(_totalSize,_singlePrice * 1 finney ,5,false);
+        curConfig = ContractParam(_totalSize,_singlePrice * 1 finney ,5,false);
+        startNewGame();
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner,"only owner can call this function");
+        _;
+    }
+    
+     modifier notLock {
+        require(isLock == false,"contract current is lock status");
+        _;
+    }
+    
+    function isNotContract(address addr) private view returns (bool) {
+        uint size;
+        assembly { size := extcodesize(addr) }
+        return size <= 0;
+    }
+
+    function updateLock(bool b) onlyOwner public {
+        
+        require(isLock != b," updateLock new status == old status");
+       
+        isLock = b;
+       
+        if(isLock) {
+            stopGame();
+        }else{
+            startNewGame();
+            emit openLockEvent();
+        }
+    }
+    
+    function stopGame() onlyOwner private {
+      
+      if(addressArray.length <= 0) {
+          return;
+      }  
+      uint totalBalace = address(this).balance;
+      uint price = totalBalace / addressArray.length;
+      for(uint i = 0; i < addressArray.length; i++) {
+          address curPlayer =  addressArray[i];
+          curPlayer.transfer(price);
+      }
+      emit stopGameEvent(totalBalace,addressArray.length,price);
+      addressArray.length=0;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        if (newOwner != address(0)) {
+            owner = newOwner;
+        }
+    }
+    
+    function changeConfig( uint32 _totalSize,uint256 _singlePrice,uint8 _pumpRate) onlyOwner public payable {
+    
+        curConfig.hasChange = true;
+        if(setConfig.totalSize != _totalSize) {
+            setConfig.totalSize = _totalSize;
+        }
+        if(setConfig.pumpRate  != _pumpRate){
+            setConfig.pumpRate  = _pumpRate;
+        }
+        if(setConfig.singlePrice != _singlePrice * 1 finney){
+            setConfig.singlePrice = _singlePrice * 1 finney;
+        }
+    }
+    
+    function startNewGame() private {
+        
+        gameIndex++;
+        if(curConfig.hasChange) {
+            if(curConfig.totalSize   != setConfig.totalSize) {
+                curConfig.totalSize   = setConfig.totalSize;
+            }
+            if(curConfig.singlePrice != setConfig.singlePrice){
+               curConfig.singlePrice = setConfig.singlePrice; 
+            }
+            if( curConfig.pumpRate    != setConfig.pumpRate) {
+                curConfig.pumpRate    = setConfig.pumpRate;
+            }
+            curConfig.hasChange = false;
+        }
+        addressArray.length=0;
+    }
+    
+    function getGameInfo() public view returns  (uint256,uint32,uint256,uint8,address[],uint256,bool)  {
+        return (gameIndex,
+                curConfig.totalSize,
+                curConfig.singlePrice,
+                curConfig.pumpRate,
+                addressArray,
+                totalPrice,
+                isLock);
+    }
+    
+    function gameResult() private {
+            
+      uint index  = getRamdon();
+      address lastAddress = addressArray[index];
+      uint totalBalace = address(this).balance;
+      uint giveToOwn   = totalBalace * curConfig.pumpRate / 100;
+      uint giveToActor = totalBalace - giveToOwn;
+      owner.transfer(giveToOwn);
+      lastAddress.transfer(giveToActor);
+      emit gameOverEvent(
+                    gameIndex,
+                    curConfig.totalSize,
+                    curConfig.singlePrice,
+                    curConfig.pumpRate,
+                    lastAddress,
+                    now);
+    }
+    
+    function getRamdon() private view returns (uint) {
+      bytes32 ramdon = keccak256(abi.encodePacked(ramdon,now,blockhash(block.number-1)));
+      for(uint i = 0; i < addressArray.length; i++) {
+            ramdon = keccak256(abi.encodePacked(ramdon,now, addressArray[i]));
+      }
+      uint index  = uint(ramdon) % addressArray.length;
+      return index;
+    }
+    
+    function() notLock payable public{
+        
+        require(msg.sender == tx.origin, "msg.sender must equipt tx.origin");
+        require(isNotContract(msg.sender),"msg.sender not is Contract");
+        require(msg.value == curConfig.singlePrice,"msg.value error");
+        totalPrice = totalPrice + msg.value;
+        addressArray.push(msg.sender);
+       
+        emit addPlayerEvent(gameIndex,msg.sender);
+        if(addressArray.length >= curConfig.totalSize) {
+            gameResult();
+            startNewGame();
+        }
+    }
+}

smart_contract_dataset/block number dependency/1017.sol

@@ -0,0 +1,625 @@
+pragma solidity ^0.4.24;
+
+ 
+
+ 
+contract ZethrTokenBankroll{
+     
+    function gameRequestTokens(address target, uint tokens) public;
+    function gameTokenAmount(address what) public returns (uint);
+}
+
+ 
+contract ZethrMainBankroll{
+    function gameGetTokenBankrollList() public view returns (address[7]);
+}
+
+ 
+contract ZethrInterface{
+    function withdraw() public;
+}
+
+ 
+library ZethrTierLibrary{
+
+    function getTier(uint divRate) internal pure returns (uint){
+         
+         
+        
+         
+         
+        uint actualDiv = divRate; 
+        if (actualDiv >= 30){
+            return 6;
+        } else if (actualDiv >= 25){
+            return 5;
+        } else if (actualDiv >= 20){
+            return 4;
+        } else if (actualDiv >= 15){
+            return 3;
+        } else if (actualDiv >= 10){
+            return 2; 
+        } else if (actualDiv >= 5){
+            return 1;
+        } else if (actualDiv >= 2){
+            return 0;
+        } else{
+             
+            revert(); 
+        }
+    }
+}
+
+ 
+contract ZlotsJackpotHoldingContract {
+  function payOutWinner(address winner) public; 
+  function getJackpot() public view returns (uint);
+}
+ 
+ 
+contract ZethrBankrollBridge {
+     
+    ZethrInterface Zethr;
+   
+     
+     
+     
+     
+    address[7] UsedBankrollAddresses; 
+
+     
+    mapping(address => bool) ValidBankrollAddress;
+    
+     
+    function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
+
+         
+        Zethr = ZethrInterface(0xD48B633045af65fF636F3c6edd744748351E020D);
+
+         
+        UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
+        for(uint i=0; i<7; i++){
+            ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
+        }
+    }
+    
+     
+    modifier fromBankroll(){
+        require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
+        _;
+    }
+    
+     
+     
+    function RequestBankrollPayment(address to, uint tokens, uint tier) internal {
+        address tokenBankrollAddress = UsedBankrollAddresses[tier];
+        ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
+    }
+    
+    function getZethrTokenBankroll(uint divRate) public constant returns (ZethrTokenBankroll){
+        return ZethrTokenBankroll(UsedBankrollAddresses[ZethrTierLibrary.getTier(divRate)]);
+    }
+}
+
+ 
+contract ZethrShell is ZethrBankrollBridge {
+
+     
+    function WithdrawToBankroll() public {
+        address(UsedBankrollAddresses[0]).transfer(address(this).balance);
+    }
+
+     
+    function WithdrawAndTransferToBankroll() public {
+        Zethr.withdraw();
+        WithdrawToBankroll();
+    }
+}
+
+ 
+ 
+contract Zlots is ZethrShell {
+    using SafeMath for uint;
+
+     
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHPrize(address _wagerer, uint _block);               
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreePurplePyramids(address _wagerer, uint _block);    
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeRockets(address _wagerer, uint _block);           
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoPurplePyramids(address _wagerer, uint _block);      
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoRockets(address _wagerer, uint _block);             
+    event SpinConcluded(address _wagerer, uint _block);          
+
+     
+
+     
+     
+    modifier betIsValid(uint _betSize, uint divRate) {
+      require(_betSize.mul(50) <= getMaxProfit(divRate));
+      _;
+    }
+
+     
+    modifier gameIsActive {
+      require(gamePaused == false);
+      _;
+    }
+
+     
+    modifier onlyOwner {
+      require(msg.sender == owner); 
+      _;
+    }
+
+     
+    modifier onlyBankroll {
+      require(msg.sender == bankroll);
+      _;
+    }
+
+     
+    modifier onlyOwnerOrBankroll {
+      require(msg.sender == owner || msg.sender == bankroll);
+      _;
+    }
+
+     
+
+     
+    uint constant public maxProfitDivisor = 1000000;
+    uint constant public houseEdgeDivisor = 1000;
+    mapping (uint => uint) public maxProfit;
+    uint public maxProfitAsPercentOfHouse;
+    uint public minBet = 1e18;
+    address public zlotsJackpot;
+    address private owner;
+    address private bankroll;
+    bool gamePaused;
+
+     
+    uint  public totalSpins;
+    uint  public totalZTHWagered;
+    mapping (uint => uint) public contractBalance;
+    
+     
+    bool public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+
+     
+
+     
+    constructor(address BankrollAddress) public {
+         
+        setupBankrollInterface(BankrollAddress); 
+
+         
+        owner = msg.sender;
+
+         
+        ownerSetMaxProfitAsPercentOfHouse(50000);
+
+         
+        bankroll      = ZTHBANKROLL;
+        gameActive  = true;
+
+         
+        ownerSetMinBet(1e18);
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function execute(address _from, uint _value, uint divRate, bytes  ) public fromBankroll returns (bool){
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn, divRate);
+            return true;
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+        uint8 tier;
+        uint divRate;
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn, uint divRate) 
+      private 
+      betIsValid(_tkn.value, divRate)
+    {
+
+        require(gameActive);
+        require(block.number <= ((2 ** 48) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+ 
+         
+         
+         
+        addContractBalance(divRate, _wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+        spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
+        spin.divRate = divRate;
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+    }
+
+     
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+        return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+        uint playerDivrate = spin.divRate;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 1000000;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target) + 1;
+        }
+
+        if (result > 506856) {
+             
+
+             
+             
+            RequestBankrollPayment(zlotsJackpot, spin.tokenValue / 100, tier);
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
+
+            emit Loss(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else if (result < 2) {
+             
+      
+             
+            profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
+            category = 1;
+    
+             
+            emit ThreeMoonJackpot(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+
+             
+            uint8 tier = spin.tier;
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
+
+             
+            ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
+        } else {
+            if (result < 299) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 50);
+                category = 2;
+                emit TwoMoonPrize(target, spin.blockn);
+            } else if (result < 3128) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 20);
+                category = 3;
+                emit ZTHPrize(target, spin.blockn);
+            } else if (result < 16961) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 4;
+                emit ThreeZSymbols(target, spin.blockn);
+            } else if (result < 30794) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 5;
+                emit ThreeTSymbols(target, spin.blockn);
+            } else if (result < 44627) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 6;
+                emit ThreeHSymbols(target, spin.blockn);
+            } else if (result < 46627) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 11);
+                category = 7;
+                emit ThreeEtherIcons(target, spin.blockn);
+            } else if (result < 49127) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 8;
+                emit ThreePurplePyramids(target, spin.blockn);
+            } else if (result < 51627) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 9);
+                category = 9;
+                emit ThreeGoldPyramids(target, spin.blockn);
+            } else if (result < 53127) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 13);
+                category = 10;
+                emit ThreeRockets(target, spin.blockn);
+            } else if (result < 82530) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
+                category = 11;
+                emit OneMoonPrize(target, spin.blockn);
+            } else if (result < 150423) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                category = 12;
+                emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else if (result < 203888) {
+                 
+                profit = spin.tokenValue;
+                category = 13;
+                 emit TwoZSymbols(target, spin.blockn);
+            } else if (result < 257353) {
+                 
+                profit = spin.tokenValue;
+                category = 14;
+                emit TwoTSymbols(target, spin.blockn);
+            } else if (result < 310818) {
+                 
+                profit = spin.tokenValue;
+                category = 15;
+                emit TwoHSymbols(target, spin.blockn);
+            } else if (result < 364283) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 16;
+                emit TwoEtherIcons(target, spin.blockn);
+            } else if (result < 417748) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125), 100);
+                category = 17;
+                emit TwoPurplePyramids(target, spin.blockn);
+            } else if (result < 471213) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133), 100);
+                category = 18;
+                emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25), 10);
+                category = 19;
+                emit TwoRockets(target, spin.blockn);
+            }
+
+             
+            subContractBalance(playerDivrate, profit);
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            tier = spin.tier;
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));  
+            RequestBankrollPayment(target, profit, tier);
+          }
+            
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+      return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function setMaxProfit(uint divRate) internal {
+      maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor; 
+    } 
+
+     
+    function getMaxProfit(uint divRate) public view returns (uint) {
+      return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+    }
+
+     
+    function subContractBalance(uint divRate, uint sub) internal {
+      contractBalance[divRate] = contractBalance[divRate].sub(sub);
+    }
+
+     
+    function addContractBalance(uint divRate, uint add) internal {
+      contractBalance[divRate] = contractBalance[divRate].add(add);
+    }
+
+     
+     
+     
+    function bankrollExternalUpdateTokens(uint divRate, uint newBalance) 
+      public 
+      fromBankroll 
+    {
+      contractBalance[divRate] = newBalance;
+      setMaxProfit(divRate);
+    }
+
+     
+     
+    function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+    onlyOwner
+    {
+       
+      require(newMaxProfitAsPercent <= 500000);
+      maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+      setMaxProfit(2);
+      setMaxProfit(5);
+      setMaxProfit(10);
+      setMaxProfit(15); 
+      setMaxProfit(20);
+      setMaxProfit(25);
+      setMaxProfit(33);
+    }
+
+     
+    function ownerSetMinBet(uint newMinimumBet) public
+    onlyOwner
+    {
+      minBet = newMinimumBet;
+    }
+
+     
+    function ownerSetZlotsAddress(address zlotsAddress) public
+    onlyOwner
+    {
+        zlotsJackpot = zlotsAddress;
+    }
+
+     
+    function pauseGame() public onlyOwnerOrBankroll {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwnerOrBankroll {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwnerOrBankroll {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwnerOrBankroll {
+        bankroll = _newBankroll;
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/103.sol

@@ -0,0 +1,247 @@
+pragma solidity ^0.4.24;
+ 
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+ 
+ 
+contract SafeMath {
+ 
+ 
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+ 
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+ 
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+ 
+}
+ 
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+ 
+ 
+ 
+contract StandardToken is Token {
+ 
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+ 
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+ 
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+ 
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+ 
+contract EBLLToken is StandardToken, SafeMath {
+ 
+     
+    string  public constant name = "易宝链";
+    string  public constant symbol = "EBL";
+    uint256 public constant decimals = 18;
+    string  public version = "1.0";
+ 
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+ 
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+ 
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+    uint256 public tokenExchangeRate = 5963;              
+ 
+     
+    event AllocateToken(address indexed _to, uint256 _value);    
+    event IssueToken(address indexed _to, uint256 _value);       
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+    event Migrate(address indexed _to, uint256 _value);
+ 
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+ 
+     
+    function EBLLToken(
+        address _ethFundDeposit,
+        uint256 _currentSupply)
+    {
+        ethFundDeposit = _ethFundDeposit;
+ 
+        isFunding = false;                            
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+ 
+        currentSupply = formatDecimals(_currentSupply);
+        totalSupply = formatDecimals(1600000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+ 
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+ 
+     
+    function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
+        if (_tokenExchangeRate == 0) throw;
+        if (_tokenExchangeRate == tokenExchangeRate) throw;
+ 
+        tokenExchangeRate = _tokenExchangeRate;
+    }
+ 
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+ 
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+ 
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+ 
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+ 
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+ 
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+ 
+     
+    function setMigrateContract(address _newContractAddr) isOwner external {
+        if (_newContractAddr == newContractAddr) throw;
+        newContractAddr = _newContractAddr;
+    }
+ 
+     
+    function changeOwner(address _newFundDeposit) isOwner() external {
+        if (_newFundDeposit == address(0x0)) throw;
+        ethFundDeposit = _newFundDeposit;
+    }
+ 
+     
+    function migrate() external {
+        if(isFunding) throw;
+        if(newContractAddr == address(0x0)) throw;
+ 
+        uint256 tokens = balances[msg.sender];
+        if (tokens == 0) throw;
+ 
+        balances[msg.sender] = 0;
+        tokenMigrated = safeAdd(tokenMigrated, tokens);
+ 
+        IMigrationContract newContract = IMigrationContract(newContractAddr);
+        if (!newContract.migrate(msg.sender, tokens)) throw;
+ 
+        Migrate(msg.sender, tokens);                
+    }
+ 
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+ 
+     
+    function allocateToken (address _addr, uint256 _eth) isOwner external {
+        if (_eth == 0) throw;
+        if (_addr == address(0x0)) throw;
+ 
+        uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[_addr] += tokens;
+ 
+        AllocateToken(_addr, tokens);   
+    }
+ 
+     
+    function () payable {
+        if (!isFunding) throw;
+        if (msg.value == 0) throw;
+ 
+        if (block.number < fundingStartBlock) throw;
+        if (block.number > fundingStopBlock) throw;
+ 
+        uint256 tokens = safeMult(msg.value, tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[msg.sender] += tokens;
+ 
+        IssueToken(msg.sender, tokens);   
+    }
+}

smart_contract_dataset/block number dependency/1034.sol

@@ -0,0 +1,258 @@
+pragma solidity ^0.4.21;
+
+
+
+
+
+
+contract PoCGame
+{
+    
+     
+     
+    modifier onlyOwner()
+    {
+        require(msg.sender == owner);
+        _;
+    }
+    
+   modifier isOpenToPublic()
+    {
+        require(openToPublic);
+        _;
+    }
+
+    modifier onlyRealPeople()
+    {
+          require (msg.sender == tx.origin);
+        _;
+    }
+
+    modifier  onlyPlayers()
+    { 
+        require (wagers[msg.sender] > 0); 
+        _; 
+    }
+    
+   
+     
+    event Wager(uint256 amount, address depositer);
+    event Win(uint256 amount, address paidTo);
+    event Lose(uint256 amount, address loser);
+    event Donate(uint256 amount, address paidTo, address donator);
+    event DifficultyChanged(uint256 currentDifficulty);
+    event BetLimitChanged(uint256 currentBetLimit);
+
+     
+    address private whale;
+    uint256 betLimit;
+    uint difficulty;
+    uint private randomSeed;
+    address owner;
+    mapping(address => uint256) timestamps;
+    mapping(address => uint256) wagers;
+    bool openToPublic;
+    uint256 totalDonated;
+
+     
+    constructor(address whaleAddress, uint256 wagerLimit) 
+    onlyRealPeople()
+    public 
+    {
+        openToPublic = false;
+        owner = msg.sender;
+        whale = whaleAddress;
+        totalDonated = 0;
+        betLimit = wagerLimit;
+        
+    }
+
+
+     
+    function OpenToThePublic() 
+    onlyOwner()
+    public
+    {
+        openToPublic = true;
+    }
+    
+     
+    function AdjustBetAmounts(uint256 amount) 
+    onlyOwner()
+    public
+    {
+        betLimit = amount;
+        
+        emit BetLimitChanged(betLimit);
+    }
+    
+      
+    function AdjustDifficulty(uint256 amount) 
+    onlyOwner()
+    public
+    {
+        difficulty = amount;
+        
+        emit DifficultyChanged(difficulty);
+    }
+    
+    
+    function() public payable { }
+
+     
+    function wager()
+    isOpenToPublic()
+    onlyRealPeople() 
+    payable
+    public 
+    {
+         
+        require(msg.value == betLimit);
+        
+         
+        require(wagers[msg.sender] == 0);
+
+         
+        timestamps[msg.sender] = block.number;
+        wagers[msg.sender] = msg.value;
+        emit Wager(msg.value, msg.sender);
+    }
+    
+     
+    function play()
+    isOpenToPublic()
+    onlyRealPeople()
+    onlyPlayers()
+    public
+    {
+        uint256 blockNumber = timestamps[msg.sender];
+        if(blockNumber < block.number)
+        {
+            timestamps[msg.sender] = 0;
+            wagers[msg.sender] = 0;
+    
+            uint256 winningNumber = uint256(keccak256(abi.encodePacked(blockhash(blockNumber),  msg.sender)))%difficulty +1;
+    
+            if(winningNumber == difficulty / 2)
+            {
+                payout(msg.sender);
+            }
+            else 
+            {
+                 
+                loseWager(betLimit / 2);
+            }    
+        }
+        else
+        {
+            revert();
+        }
+    }
+
+     
+    function donate()
+    isOpenToPublic()
+    public 
+    payable
+    {
+        donateToWhale(msg.value);
+    }
+
+     
+    function payout(address winner) 
+    internal 
+    {
+        uint256 ethToTransfer = address(this).balance / 2;
+        
+        winner.transfer(ethToTransfer);
+        emit Win(ethToTransfer, winner);
+    }
+
+     
+    function donateToWhale(uint256 amount) 
+    internal 
+    {
+        whale.call.value(amount)(bytes4(keccak256("donate()")));
+        totalDonated += amount;
+        emit Donate(amount, whale, msg.sender);
+    }
+
+     
+    function loseWager(uint256 amount) 
+    internal 
+    {
+        whale.call.value(amount)(bytes4(keccak256("donate()")));
+        totalDonated += amount;
+        emit Lose(amount, msg.sender);
+    }
+    
+
+     
+    function ethBalance() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return address(this).balance;
+    }
+    
+    
+     
+    function currentDifficulty() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return difficulty;
+    }
+    
+    
+     
+    function currentBetLimit() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return betLimit;
+    }
+    
+    function hasPlayerWagered(address player)
+    public 
+    view 
+    returns (bool)
+    {
+        if(wagers[player] > 0)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+        
+    }
+
+     
+    function winnersPot() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return address(this).balance / 2;
+    }
+
+     
+    function transferAnyERC20Token(address tokenAddress, address tokenOwner, uint tokens) 
+    public 
+    onlyOwner() 
+    returns (bool success) 
+    {
+        return ERC20Interface(tokenAddress).transfer(tokenOwner, tokens);
+    }
+}
+
+ 
+contract ERC20Interface 
+{
+    function transfer(address to, uint256 tokens) public returns (bool success);
+}

smart_contract_dataset/block number dependency/1044.sol

@@ -0,0 +1,255 @@
+pragma solidity ^0.4.21;
+
+
+
+
+
+
+contract PoCGame
+{
+    
+     
+     
+    modifier onlyOwner()
+    {
+        require(msg.sender == owner);
+        _;
+    }
+    
+   modifier isOpenToPublic()
+    {
+        require(openToPublic);
+        _;
+    }
+
+    modifier onlyRealPeople()
+    {
+          require (msg.sender == tx.origin);
+        _;
+    }
+
+    modifier  onlyPlayers()
+    { 
+        require (wagers[msg.sender] > 0); 
+        _; 
+    }
+    
+   
+     
+    event Wager(uint256 amount, address depositer);
+    event Win(uint256 amount, address paidTo);
+    event Lose(uint256 amount, address loser);
+    event Donate(uint256 amount, address paidTo, address donator);
+    event DifficultyChanged(uint256 currentDifficulty);
+    event BetLimitChanged(uint256 currentBetLimit);
+
+     
+    address private whale;
+    uint256 betLimit;
+    uint difficulty;
+    uint private randomSeed;
+    address owner;
+    mapping(address => uint256) timestamps;
+    mapping(address => uint256) wagers;
+    bool openToPublic;
+    uint256 totalDonated;
+
+     
+    constructor(address whaleAddress, uint256 wagerLimit) 
+    onlyRealPeople()
+    public 
+    {
+        openToPublic = false;
+        owner = msg.sender;
+        whale = whaleAddress;
+        totalDonated = 0;
+        betLimit = wagerLimit;
+        
+    }
+
+
+     
+    function OpenToThePublic() 
+    onlyOwner()
+    public
+    {
+        openToPublic = true;
+    }
+    
+     
+    function AdjustBetAmounts(uint256 amount) 
+    onlyOwner()
+    public
+    {
+        betLimit = amount;
+        
+        emit BetLimitChanged(betLimit);
+    }
+    
+      
+    function AdjustDifficulty(uint256 amount) 
+    onlyOwner()
+    public
+    {
+        difficulty = amount;
+        
+        emit DifficultyChanged(difficulty);
+    }
+    
+    
+    function() public payable { }
+
+     
+    function wager()
+    isOpenToPublic()
+    onlyRealPeople() 
+    payable
+    public 
+    {
+         
+        require(msg.value == betLimit);
+
+         
+        timestamps[msg.sender] = block.number;
+        wagers[msg.sender] = msg.value;
+        emit Wager(msg.value, msg.sender);
+    }
+    
+     
+    function play()
+    isOpenToPublic()
+    onlyRealPeople()
+    onlyPlayers()
+    public
+    {
+        uint256 blockNumber = timestamps[msg.sender];
+        if(blockNumber < block.number)
+        {
+            timestamps[msg.sender] = 0;
+            wagers[msg.sender] = 0;
+    
+            uint256 winningNumber = uint256(keccak256(abi.encodePacked(blockhash(blockNumber),  msg.sender)))%difficulty +1;
+    
+            if(winningNumber == difficulty / 2)
+            {
+                payout(msg.sender);
+            }
+            else 
+            {
+                 
+                loseWager(betLimit / 2);
+            }    
+        }
+        else
+        {
+            revert();
+        }
+    }
+
+     
+    function donate()
+    isOpenToPublic()
+    public 
+    payable
+    {
+        donateToWhale(msg.value);
+    }
+
+     
+    function payout(address winner) 
+    internal 
+    {
+        uint256 ethToTransfer = address(this).balance / 2;
+        
+        winner.transfer(ethToTransfer);
+        emit Win(ethToTransfer, winner);
+    }
+
+     
+    function donateToWhale(uint256 amount) 
+    internal 
+    {
+        whale.call.value(amount)(bytes4(keccak256("donate()")));
+        totalDonated += amount;
+        emit Donate(amount, whale, msg.sender);
+    }
+
+     
+    function loseWager(uint256 amount) 
+    internal 
+    {
+        whale.call.value(amount)(bytes4(keccak256("donate()")));
+        totalDonated += amount;
+        emit Lose(amount, msg.sender);
+    }
+    
+
+     
+    function ethBalance() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return address(this).balance;
+    }
+    
+    
+     
+    function currentDifficulty() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return difficulty;
+    }
+    
+    
+     
+    function currentBetLimit() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return betLimit;
+    }
+    
+    function hasPlayerWagered(address player)
+    public 
+    view 
+    returns (bool)
+    {
+        if(wagers[player] > 0)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+        
+    }
+
+     
+    function winnersPot() 
+    public 
+    view 
+    returns (uint256)
+    {
+        return address(this).balance / 2;
+    }
+
+     
+    function transferAnyERC20Token(address tokenAddress, address tokenOwner, uint tokens) 
+    public 
+    onlyOwner() 
+    returns (bool success) 
+    {
+        return ERC20Interface(tokenAddress).transfer(tokenOwner, tokens);
+    }
+}
+
+ 
+contract ERC20Interface 
+{
+    function transfer(address to, uint256 tokens) public returns (bool success);
+}

smart_contract_dataset/block number dependency/1052.sol

@@ -0,0 +1,625 @@
+pragma solidity ^0.4.24;
+
+ 
+
+ 
+contract ZethrTokenBankroll{
+     
+    function gameRequestTokens(address target, uint tokens) public;
+    function gameTokenAmount(address what) public returns (uint);
+}
+
+ 
+contract ZethrMainBankroll{
+    function gameGetTokenBankrollList() public view returns (address[7]);
+}
+
+ 
+contract ZethrInterface{
+    function withdraw() public;
+}
+
+ 
+library ZethrTierLibrary{
+
+    function getTier(uint divRate) internal pure returns (uint){
+         
+         
+        
+         
+         
+        uint actualDiv = divRate; 
+        if (actualDiv >= 30){
+            return 6;
+        } else if (actualDiv >= 25){
+            return 5;
+        } else if (actualDiv >= 20){
+            return 4;
+        } else if (actualDiv >= 15){
+            return 3;
+        } else if (actualDiv >= 10){
+            return 2; 
+        } else if (actualDiv >= 5){
+            return 1;
+        } else if (actualDiv >= 2){
+            return 0;
+        } else{
+             
+            revert(); 
+        }
+    }
+}
+
+ 
+contract ZlotsJackpotHoldingContract {
+  function payOutWinner(address winner) public; 
+  function getJackpot() public view returns (uint);
+}
+ 
+ 
+contract ZethrBankrollBridge {
+     
+    ZethrInterface Zethr;
+   
+     
+     
+     
+     
+    address[7] UsedBankrollAddresses; 
+
+     
+    mapping(address => bool) ValidBankrollAddress;
+    
+     
+    function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
+
+         
+        Zethr = ZethrInterface(0xD48B633045af65fF636F3c6edd744748351E020D);
+
+         
+        UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
+        for(uint i=0; i<7; i++){
+            ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
+        }
+    }
+    
+     
+    modifier fromBankroll(){
+        require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
+        _;
+    }
+    
+     
+     
+    function RequestBankrollPayment(address to, uint tokens, uint tier) internal {
+        address tokenBankrollAddress = UsedBankrollAddresses[tier];
+        ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
+    }
+    
+    function getZethrTokenBankroll(uint divRate) public constant returns (ZethrTokenBankroll){
+        return ZethrTokenBankroll(UsedBankrollAddresses[ZethrTierLibrary.getTier(divRate)]);
+    }
+}
+
+ 
+contract ZethrShell is ZethrBankrollBridge {
+
+     
+    function WithdrawToBankroll() public {
+        address(UsedBankrollAddresses[0]).transfer(address(this).balance);
+    }
+
+     
+    function WithdrawAndTransferToBankroll() public {
+        Zethr.withdraw();
+        WithdrawToBankroll();
+    }
+}
+
+ 
+ 
+contract Zlots is ZethrShell {
+    using SafeMath for uint;
+
+     
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHPrize(address _wagerer, uint _block);               
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreePurplePyramids(address _wagerer, uint _block);    
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeRockets(address _wagerer, uint _block);           
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoPurplePyramids(address _wagerer, uint _block);      
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoRockets(address _wagerer, uint _block);             
+    event SpinConcluded(address _wagerer, uint _block);          
+
+     
+
+     
+     
+    modifier betIsValid(uint _betSize, uint divRate) {
+      require(_betSize.mul(100) <= getMaxProfit(divRate));
+      _;
+    }
+
+     
+    modifier gameIsActive {
+      require(gamePaused == false);
+      _;
+    }
+
+     
+    modifier onlyOwner {
+      require(msg.sender == owner); 
+      _;
+    }
+
+     
+    modifier onlyBankroll {
+      require(msg.sender == bankroll);
+      _;
+    }
+
+     
+    modifier onlyOwnerOrBankroll {
+      require(msg.sender == owner || msg.sender == bankroll);
+      _;
+    }
+
+     
+
+     
+    uint constant public maxProfitDivisor = 1000000;
+    uint constant public houseEdgeDivisor = 1000;
+    mapping (uint => uint) public maxProfit;
+    uint public maxProfitAsPercentOfHouse;
+    uint public minBet = 1e18;
+    address public zlotsJackpot;
+    address private owner;
+    address private bankroll;
+    bool gamePaused;
+
+     
+    uint  public totalSpins;
+    uint  public totalZTHWagered;
+    mapping (uint => uint) public contractBalance;
+    
+     
+    bool public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+
+     
+
+     
+    constructor(address BankrollAddress) public {
+         
+        setupBankrollInterface(BankrollAddress); 
+
+         
+        owner = msg.sender;
+
+         
+        ownerSetMaxProfitAsPercentOfHouse(50000);
+
+         
+        bankroll      = ZTHBANKROLL;
+        gameActive  = true;
+
+         
+        ownerSetMinBet(1e18);
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function execute(address _from, uint _value, uint divRate, bytes  ) public fromBankroll returns (bool){
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn, divRate);
+            return true;
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+        uint8 tier;
+        uint divRate;
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn, uint divRate) 
+      private 
+      betIsValid(_tkn.value, divRate)
+    {
+
+        require(gameActive);
+        require(block.number < ((2 ** 56) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+ 
+         
+         
+         
+        addContractBalance(divRate, _wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+        spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
+        spin.divRate = divRate;
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+    }
+
+     
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+        return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+        uint playerDivrate = spin.divRate;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 1000000;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target) + 1;
+        }
+
+        if (result > 506856) {
+             
+
+             
+             
+            RequestBankrollPayment(zlotsJackpot, spin.tokenValue / 100, tier);
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
+
+            emit Loss(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else if (result < 2) {
+             
+      
+             
+            profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
+            category = 1;
+    
+             
+            emit ThreeMoonJackpot(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+
+             
+            uint8 tier = spin.tier;
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));
+
+             
+            ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
+        } else {
+            if (result < 299) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 50);
+                category = 2;
+                emit TwoMoonPrize(target, spin.blockn);
+            } else if (result < 3128) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 20);
+                category = 3;
+                emit ZTHPrize(target, spin.blockn);
+            } else if (result < 16961) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 4;
+                emit ThreeZSymbols(target, spin.blockn);
+            } else if (result < 30794) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 5;
+                emit ThreeTSymbols(target, spin.blockn);
+            } else if (result < 44627) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 6;
+                emit ThreeHSymbols(target, spin.blockn);
+            } else if (result < 46627) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 11);
+                category = 7;
+                emit ThreeEtherIcons(target, spin.blockn);
+            } else if (result < 49127) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 8;
+                emit ThreePurplePyramids(target, spin.blockn);
+            } else if (result < 51627) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 9);
+                category = 9;
+                emit ThreeGoldPyramids(target, spin.blockn);
+            } else if (result < 53127) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 13);
+                category = 10;
+                emit ThreeRockets(target, spin.blockn);
+            } else if (result < 82530) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
+                category = 11;
+                emit OneMoonPrize(target, spin.blockn);
+            } else if (result < 150423) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                category = 12;
+                emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else if (result < 203888) {
+                 
+                profit = spin.tokenValue;
+                category = 13;
+                 emit TwoZSymbols(target, spin.blockn);
+            } else if (result < 257353) {
+                 
+                profit = spin.tokenValue;
+                category = 14;
+                emit TwoTSymbols(target, spin.blockn);
+            } else if (result < 310818) {
+                 
+                profit = spin.tokenValue;
+                category = 15;
+                emit TwoHSymbols(target, spin.blockn);
+            } else if (result < 364283) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 16;
+                emit TwoEtherIcons(target, spin.blockn);
+            } else if (result < 417748) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125), 100);
+                category = 17;
+                emit TwoPurplePyramids(target, spin.blockn);
+            } else if (result < 471213) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133), 100);
+                category = 18;
+                emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25), 10);
+                category = 19;
+                emit TwoRockets(target, spin.blockn);
+            }
+
+             
+            subContractBalance(playerDivrate, profit);
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            tier = spin.tier;
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0), uint(0));  
+            RequestBankrollPayment(target, profit, tier);
+          }
+            
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+      return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function setMaxProfit(uint divRate) internal {
+      maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor; 
+    } 
+
+     
+    function getMaxProfit(uint divRate) public view returns (uint) {
+      return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+    }
+
+     
+    function subContractBalance(uint divRate, uint sub) internal {
+      contractBalance[divRate] = contractBalance[divRate].sub(sub);
+    }
+
+     
+    function addContractBalance(uint divRate, uint add) internal {
+      contractBalance[divRate] = contractBalance[divRate].add(add);
+    }
+
+     
+     
+     
+    function bankrollExternalUpdateTokens(uint divRate, uint newBalance) 
+      public 
+      fromBankroll 
+    {
+      contractBalance[divRate] = newBalance;
+      setMaxProfit(divRate);
+    }
+
+     
+     
+    function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+    onlyOwner
+    {
+       
+      require(newMaxProfitAsPercent <= 500000);
+      maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+      setMaxProfit(2);
+      setMaxProfit(5);
+      setMaxProfit(10);
+      setMaxProfit(15); 
+      setMaxProfit(20);
+      setMaxProfit(25);
+      setMaxProfit(33);
+    }
+
+     
+    function ownerSetMinBet(uint newMinimumBet) public
+    onlyOwner
+    {
+      minBet = newMinimumBet;
+    }
+
+     
+    function ownerSetZlotsAddress(address zlotsAddress) public
+    onlyOwner
+    {
+        zlotsJackpot = zlotsAddress;
+    }
+
+     
+    function pauseGame() public onlyOwnerOrBankroll {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwnerOrBankroll {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwnerOrBankroll {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwnerOrBankroll {
+        bankroll = _newBankroll;
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1056.sol

@@ -0,0 +1,619 @@
+pragma solidity ^0.4.24;
+
+ 
+
+ 
+contract ZethrTokenBankroll{
+     
+    function gameRequestTokens(address target, uint tokens) public;
+    function gameTokenAmount(address what) public returns (uint);
+}
+
+ 
+contract ZethrMainBankroll{
+    function gameGetTokenBankrollList() public view returns (address[7]);
+}
+
+ 
+contract ZethrInterface{
+    function withdraw() public;
+}
+
+ 
+library ZethrTierLibrary{
+
+    function getTier(uint divRate) internal pure returns (uint){
+         
+         
+        
+         
+         
+        uint actualDiv = divRate; 
+        if (actualDiv >= 30){
+            return 6;
+        } else if (actualDiv >= 25){
+            return 5;
+        } else if (actualDiv >= 20){
+            return 4;
+        } else if (actualDiv >= 15){
+            return 3;
+        } else if (actualDiv >= 10){
+            return 2; 
+        } else if (actualDiv >= 5){
+            return 1;
+        } else if (actualDiv >= 2){
+            return 0;
+        } else{
+             
+            revert(); 
+        }
+    }
+}
+
+ 
+contract ZlotsJackpotHoldingContract {
+  function payOutWinner(address winner) public; 
+  function getJackpot() public view returns (uint);
+}
+ 
+ 
+contract ZethrBankrollBridge {
+     
+    ZethrInterface Zethr;
+   
+     
+     
+     
+     
+    address[7] UsedBankrollAddresses; 
+
+     
+    mapping(address => bool) ValidBankrollAddress;
+    
+     
+    function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
+
+         
+        Zethr = ZethrInterface(0xD48B633045af65fF636F3c6edd744748351E020D);
+
+         
+        UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
+        for(uint i=0; i<7; i++){
+            ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
+        }
+    }
+    
+     
+    modifier fromBankroll(){
+        require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
+        _;
+    }
+    
+     
+     
+    function RequestBankrollPayment(address to, uint tokens, uint tier) internal {
+        address tokenBankrollAddress = UsedBankrollAddresses[tier];
+        ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
+    }
+    
+    function getZethrTokenBankroll(uint divRate) public constant returns (ZethrTokenBankroll){
+        return ZethrTokenBankroll(UsedBankrollAddresses[ZethrTierLibrary.getTier(divRate)]);
+    }
+}
+
+ 
+contract ZethrShell is ZethrBankrollBridge {
+
+     
+    function WithdrawToBankroll() public {
+        address(UsedBankrollAddresses[0]).transfer(address(this).balance);
+    }
+
+     
+    function WithdrawAndTransferToBankroll() public {
+        Zethr.withdraw();
+        WithdrawToBankroll();
+    }
+}
+
+ 
+ 
+contract Zlots is ZethrShell {
+    using SafeMath for uint;
+
+     
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHPrize(address _wagerer, uint _block);               
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreePurplePyramids(address _wagerer, uint _block);    
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeRockets(address _wagerer, uint _block);           
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoPurplePyramids(address _wagerer, uint _block);      
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoRockets(address _wagerer, uint _block);             
+    event SpinConcluded(address _wagerer, uint _block);          
+
+     
+
+     
+     
+    modifier betIsValid(uint _betSize, uint divRate) {
+      require(_betSize.mul(100) <= getMaxProfit(divRate));
+      _;
+    }
+
+     
+    modifier gameIsActive {
+      require(gamePaused == false);
+      _;
+    }
+
+     
+    modifier onlyOwner {
+      require(msg.sender == owner); 
+      _;
+    }
+
+     
+    modifier onlyBankroll {
+      require(msg.sender == bankroll);
+      _;
+    }
+
+     
+    modifier onlyOwnerOrBankroll {
+      require(msg.sender == owner || msg.sender == bankroll);
+      _;
+    }
+
+     
+
+     
+    uint constant public maxProfitDivisor = 1000000;
+    uint constant public houseEdgeDivisor = 1000;
+    mapping (uint => uint) public maxProfit;
+    uint public maxProfitAsPercentOfHouse;
+    uint public minBet = 1e18;
+    address public zlotsJackpot;
+    address private owner;
+    address private bankroll;
+    bool gamePaused;
+
+     
+    uint  public totalSpins;
+    uint  public totalZTHWagered;
+    mapping (uint => uint) public contractBalance;
+    
+     
+    bool public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+
+     
+
+     
+    constructor(address BankrollAddress) public {
+         
+        setupBankrollInterface(BankrollAddress); 
+
+         
+        owner = msg.sender;
+
+         
+        ownerSetMaxProfitAsPercentOfHouse(50000);
+
+         
+        bankroll      = ZTHBANKROLL;
+        gameActive  = true;
+
+         
+        ownerSetMinBet(1e18);
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function execute(address _from, uint _value, uint divRate, bytes  ) public fromBankroll returns (bool){
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn, divRate);
+            return true;
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+        uint8 tier;
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn, uint divRate) 
+      private 
+      betIsValid(_tkn.value, divRate)
+    {
+
+        require(gameActive);
+        require(block.number < ((2 ** 56) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+ 
+         
+         
+         
+        addContractBalance(divRate, _wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+        spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+    }
+
+     
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+        return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 1000000;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target) + 1;
+        }
+
+        if (result > 506856) {
+             
+
+             
+             
+            RequestBankrollPayment(zlotsJackpot, spin.tokenValue / 100, tier);
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));
+
+            emit Loss(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else if (result < 2) {
+             
+      
+             
+            profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
+            category = 1;
+    
+             
+            emit ThreeMoonJackpot(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+
+             
+            uint8 tier = spin.tier;
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));
+
+             
+            ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
+        } else {
+            if (result < 299) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 50);
+                category = 2;
+                emit TwoMoonPrize(target, spin.blockn);
+            } else if (result < 3128) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 20);
+                category = 3;
+                emit ZTHPrize(target, spin.blockn);
+            } else if (result < 16961) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 4;
+                emit ThreeZSymbols(target, spin.blockn);
+            } else if (result < 30794) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 5;
+                emit ThreeTSymbols(target, spin.blockn);
+            } else if (result < 44627) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 30), 10);
+                category = 6;
+                emit ThreeHSymbols(target, spin.blockn);
+            } else if (result < 46627) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 11);
+                category = 7;
+                emit ThreeEtherIcons(target, spin.blockn);
+            } else if (result < 49127) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 8;
+                emit ThreePurplePyramids(target, spin.blockn);
+            } else if (result < 51627) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 9);
+                category = 9;
+                emit ThreeGoldPyramids(target, spin.blockn);
+            } else if (result < 53127) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 13);
+                category = 10;
+                emit ThreeRockets(target, spin.blockn);
+            } else if (result < 82530) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
+                category = 11;
+                emit OneMoonPrize(target, spin.blockn);
+            } else if (result < 150423) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                category = 12;
+                emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else if (result < 203888) {
+                 
+                profit = spin.tokenValue;
+                category = 13;
+                 emit TwoZSymbols(target, spin.blockn);
+            } else if (result < 257353) {
+                 
+                profit = spin.tokenValue;
+                category = 14;
+                emit TwoTSymbols(target, spin.blockn);
+            } else if (result < 310818) {
+                 
+                profit = spin.tokenValue;
+                category = 15;
+                emit TwoHSymbols(target, spin.blockn);
+            } else if (result < 364283) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 16;
+                emit TwoEtherIcons(target, spin.blockn);
+            } else if (result < 417748) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125), 100);
+                category = 17;
+                emit TwoPurplePyramids(target, spin.blockn);
+            } else if (result < 471213) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133), 100);
+                category = 18;
+                emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25), 10);
+                category = 19;
+                emit TwoRockets(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            tier = spin.tier;
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));  
+            RequestBankrollPayment(target, profit, tier);
+          }
+            
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+      return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function setMaxProfit(uint divRate) internal {
+      maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor; 
+    } 
+
+     
+    function getMaxProfit(uint divRate) public view returns (uint) {
+      return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+    }
+
+     
+    function subContractBalance(uint divRate, uint sub) internal {
+      contractBalance[divRate] = contractBalance[divRate].sub(sub);
+    }
+
+     
+    function addContractBalance(uint divRate, uint add) internal {
+      contractBalance[divRate] = contractBalance[divRate].add(add);
+    }
+
+     
+     
+     
+    function bankrollExternalUpdateTokens(uint divRate, uint newBalance) 
+      public 
+      fromBankroll 
+    {
+      contractBalance[divRate] = newBalance;
+      setMaxProfit(divRate);
+    }
+
+     
+     
+    function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+    onlyOwner
+    {
+       
+      require(newMaxProfitAsPercent <= 500000);
+      maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+      setMaxProfit(2);
+      setMaxProfit(5);
+      setMaxProfit(10);
+      setMaxProfit(15); 
+      setMaxProfit(20);
+      setMaxProfit(25);
+      setMaxProfit(33);
+    }
+
+     
+    function ownerSetMinBet(uint newMinimumBet) public
+    onlyOwner
+    {
+      minBet = newMinimumBet;
+    }
+
+     
+    function ownerSetZlotsAddress(address zlotsAddress) public
+    onlyOwner
+    {
+        zlotsJackpot = zlotsAddress;
+    }
+
+     
+    function pauseGame() public onlyOwnerOrBankroll {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwnerOrBankroll {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwnerOrBankroll {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwnerOrBankroll {
+        bankroll = _newBankroll;
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1096.sol

@@ -0,0 +1,621 @@
+pragma solidity ^0.4.24;
+
+ 
+
+ 
+contract ZethrTokenBankroll{
+     
+    function gameRequestTokens(address target, uint tokens) public;
+    function gameTokenAmount(address what) public returns (uint);
+}
+
+ 
+contract ZethrMainBankroll{
+    function gameGetTokenBankrollList() public view returns (address[7]);
+}
+
+ 
+contract ZethrInterface{
+    function withdraw() public;
+}
+
+ 
+library ZethrTierLibrary{
+
+    function getTier(uint divRate) internal pure returns (uint){
+         
+         
+        
+         
+         
+        uint actualDiv = divRate; 
+        if (actualDiv >= 30){
+            return 6;
+        } else if (actualDiv >= 25){
+            return 5;
+        } else if (actualDiv >= 20){
+            return 4;
+        } else if (actualDiv >= 15){
+            return 3;
+        } else if (actualDiv >= 10){
+            return 2; 
+        } else if (actualDiv >= 5){
+            return 1;
+        } else if (actualDiv >= 2){
+            return 0;
+        } else{
+             
+            revert(); 
+        }
+    }
+}
+
+ 
+contract ZlotsJackpotHoldingContract {
+  function payOutWinner(address winner) public; 
+  function getJackpot() public view returns (uint);
+}
+ 
+ 
+contract ZethrBankrollBridge {
+     
+    ZethrInterface Zethr;
+   
+     
+     
+     
+     
+    address[7] UsedBankrollAddresses; 
+
+     
+    mapping(address => bool) ValidBankrollAddress;
+    
+     
+    function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
+
+         
+        Zethr = ZethrInterface(0xD48B633045af65fF636F3c6edd744748351E020D);
+
+         
+        UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
+        for(uint i=0; i<7; i++){
+            ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
+        }
+    }
+    
+     
+    modifier fromBankroll(){
+        require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
+        _;
+    }
+    
+     
+     
+    function RequestBankrollPayment(address to, uint tokens, uint tier) internal {
+        address tokenBankrollAddress = UsedBankrollAddresses[tier];
+        ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
+    }
+    
+    function getZethrTokenBankroll(uint divRate) public constant returns (ZethrTokenBankroll){
+        return ZethrTokenBankroll(UsedBankrollAddresses[ZethrTierLibrary.getTier(divRate)]);
+    }
+}
+
+ 
+contract ZethrShell is ZethrBankrollBridge {
+
+     
+    function WithdrawToBankroll() public {
+        address(UsedBankrollAddresses[0]).transfer(address(this).balance);
+    }
+
+     
+    function WithdrawAndTransferToBankroll() public {
+        Zethr.withdraw();
+        WithdrawToBankroll();
+    }
+}
+
+ 
+ 
+contract Zlots is ZethrShell {
+    using SafeMath for uint;
+
+     
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHPrize(address _wagerer, uint _block);               
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreePurplePyramids(address _wagerer, uint _block);    
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeRockets(address _wagerer, uint _block);           
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoPurplePyramids(address _wagerer, uint _block);      
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoRockets(address _wagerer, uint _block);             
+    event SpinConcluded(address _wagerer, uint _block);          
+
+     
+
+     
+     
+    modifier betIsValid(uint _betSize, uint divRate) {
+      require(_betSize.mul(100) <= getMaxProfit(divRate));
+      _;
+    }
+
+     
+    modifier gameIsActive {
+      require(gamePaused == false);
+      _;
+    }
+
+     
+    modifier onlyOwner {
+      require(msg.sender == owner); 
+      _;
+    }
+
+     
+    modifier onlyBankroll {
+      require(msg.sender == bankroll);
+      _;
+    }
+
+     
+    modifier onlyOwnerOrBankroll {
+      require(msg.sender == owner || msg.sender == bankroll);
+      _;
+    }
+
+     
+
+     
+    uint constant public maxProfitDivisor = 1000000;
+    uint constant public houseEdgeDivisor = 1000;
+    mapping (uint => uint) public maxProfit;
+    uint public maxProfitAsPercentOfHouse;
+    uint public minBet = 1e18;
+    address public zlotsJackpot;
+    address private owner;
+    address private bankroll;
+    bool gamePaused;
+
+     
+    uint  public totalSpins;
+    uint  public totalZTHWagered;
+    mapping (uint => uint) public contractBalance;
+    
+     
+    bool public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+
+     
+
+     
+    constructor(address BankrollAddress) public {
+         
+        setupBankrollInterface(BankrollAddress); 
+
+         
+        owner = msg.sender;
+
+         
+        ownerSetMaxProfitAsPercentOfHouse(50000);
+
+         
+        bankroll      = ZTHBANKROLL;
+        gameActive  = true;
+
+         
+        ownerSetMinBet(1e18);
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function execute(address _from, uint _value, uint divRate, bytes  ) public fromBankroll returns (bool){
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn, divRate);
+            return true;
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+        uint8 tier;
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn, uint divRate) 
+      private 
+      betIsValid(_tkn.value, divRate)
+    {
+
+        require(gameActive);
+        require(1e18 <= _tkn.value);  
+
+        require(block.number < ((2 ** 56) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+ 
+         
+         
+         
+        addContractBalance(divRate, _wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+        spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+    }
+
+     
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+        return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 1000000;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target) + 1;
+        }
+
+        if (result > 476662) {
+             
+
+             
+             
+            RequestBankrollPayment(zlotsJackpot, profit, tier);
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));
+
+            emit Loss(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else if (result < 2) {
+             
+      
+             
+            profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
+            category = 1;
+    
+             
+            emit ThreeMoonJackpot(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+
+             
+            uint8 tier = spin.tier;
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));
+
+             
+            ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
+        } else {
+            if (result < 299) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 100);
+                category = 2;
+                emit TwoMoonPrize(target, spin.blockn);
+            } else if (result < 3128) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 20);
+                category = 3;
+                emit ZTHPrize(target, spin.blockn);
+            } else if (result < 5957) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 4;
+                emit ThreeZSymbols(target, spin.blockn);
+            } else if (result < 8786) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 5;
+                emit ThreeTSymbols(target, spin.blockn);
+            } else if (result < 11615) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 6;
+                emit ThreeHSymbols(target, spin.blockn);
+            } else if (result < 14444) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 15);
+                category = 7;
+                emit ThreeEtherIcons(target, spin.blockn);
+            } else if (result < 17273) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 10);
+                category = 8;
+                emit ThreePurplePyramids(target, spin.blockn);
+            } else if (result < 20102) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 10);
+                category = 9;
+                emit ThreeGoldPyramids(target, spin.blockn);
+            } else if (result < 22930) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 12);
+                category = 10;
+                emit ThreeRockets(target, spin.blockn);
+            } else if (result < 52333) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
+                category = 11;
+                emit OneMoonPrize(target, spin.blockn);
+            } else if (result < 120226) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                category = 12;
+                emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else if (result < 171147) {
+                 
+                profit = spin.tokenValue;
+                category = 13;
+                 emit TwoZSymbols(target, spin.blockn);
+            } else if (result < 222068) {
+                 
+                profit = spin.tokenValue;
+                category = 14;
+                emit TwoTSymbols(target, spin.blockn);
+            } else if (result < 272989) {
+                 
+                profit = spin.tokenValue;
+                category = 15;
+                emit TwoHSymbols(target, spin.blockn);
+            } else if (result < 323910) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 16;
+                emit TwoEtherIcons(target, spin.blockn);
+            } else if (result < 374831) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133),100);
+                category = 17;
+                emit TwoPurplePyramids(target, spin.blockn);
+            } else if (result < 425752) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133),100);
+                category = 18;
+                emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 19;
+                emit TwoRockets(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            tier = spin.tier;
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));  
+            RequestBankrollPayment(target, profit, tier);
+          }
+            
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+      return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function setMaxProfit(uint divRate) internal {
+      maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor; 
+    } 
+
+     
+    function getMaxProfit(uint divRate) public view returns (uint) {
+      return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+    }
+
+     
+    function subContractBalance(uint divRate, uint sub) internal {
+      contractBalance[divRate] = contractBalance[divRate].sub(sub);
+    }
+
+     
+    function addContractBalance(uint divRate, uint add) internal {
+      contractBalance[divRate] = contractBalance[divRate].add(add);
+    }
+
+     
+     
+     
+    function bankrollExternalUpdateTokens(uint divRate, uint newBalance) 
+      public 
+      fromBankroll 
+    {
+      contractBalance[divRate] = newBalance;
+      setMaxProfit(divRate);
+    }
+
+     
+     
+    function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+    onlyOwner
+    {
+       
+      require(newMaxProfitAsPercent <= 200000);
+      maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+      setMaxProfit(2);
+      setMaxProfit(5);
+      setMaxProfit(10);
+      setMaxProfit(15); 
+      setMaxProfit(20);
+      setMaxProfit(25);
+      setMaxProfit(33);
+    }
+
+     
+    function ownerSetMinBet(uint newMinimumBet) public
+    onlyOwner
+    {
+      minBet = newMinimumBet;
+    }
+
+     
+    function ownerSetZlotsAddress(address zlotsAddress) public
+    onlyOwner
+    {
+        zlotsJackpot = zlotsAddress;
+    }
+
+     
+    function pauseGame() public onlyOwnerOrBankroll {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwnerOrBankroll {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwnerOrBankroll {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwnerOrBankroll {
+        bankroll = _newBankroll;
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1101.sol

@@ -0,0 +1,626 @@
+pragma solidity ^0.4.24;
+
+ 
+
+ 
+contract ZethrTokenBankroll{
+     
+    function gameRequestTokens(address target, uint tokens) public;
+    function gameTokenAmount(address what) public returns (uint);
+}
+
+ 
+contract ZethrMainBankroll{
+    function gameGetTokenBankrollList() public view returns (address[7]);
+}
+
+ 
+contract ZethrInterface{
+    function withdraw() public;
+}
+
+ 
+library ZethrTierLibrary{
+
+    function getTier(uint divRate) internal pure returns (uint){
+         
+         
+        
+         
+         
+        uint actualDiv = divRate; 
+        if (actualDiv >= 30){
+            return 6;
+        } else if (actualDiv >= 25){
+            return 5;
+        } else if (actualDiv >= 20){
+            return 4;
+        } else if (actualDiv >= 15){
+            return 3;
+        } else if (actualDiv >= 10){
+            return 2; 
+        } else if (actualDiv >= 5){
+            return 1;
+        } else if (actualDiv >= 2){
+            return 0;
+        } else{
+             
+            revert(); 
+        }
+    }
+}
+
+ 
+contract ZlotsJackpotHoldingContract {
+  function payOutWinner(address winner) public; 
+  function getJackpot() public view returns (uint);
+}
+ 
+ 
+contract ZethrBankrollBridge {
+     
+    ZethrInterface Zethr;
+   
+     
+     
+     
+     
+    address[7] UsedBankrollAddresses; 
+
+     
+    mapping(address => bool) ValidBankrollAddress;
+    
+     
+    function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
+
+         
+        Zethr = ZethrInterface(0xD48B633045af65fF636F3c6edd744748351E020D);
+
+         
+        UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
+        for(uint i=0; i<7; i++){
+            ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
+        }
+    }
+    
+     
+    modifier fromBankroll(){
+        require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
+        _;
+    }
+    
+     
+     
+    function RequestBankrollPayment(address to, uint tokens, uint tier) internal {
+        address tokenBankrollAddress = UsedBankrollAddresses[tier];
+        ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
+    }
+    
+    function getZethrTokenBankroll(uint divRate) public constant returns (ZethrTokenBankroll){
+        return ZethrTokenBankroll(UsedBankrollAddresses[ZethrTierLibrary.getTier(divRate)]);
+    }
+}
+
+ 
+contract ZethrShell is ZethrBankrollBridge {
+
+     
+    function WithdrawToBankroll() public {
+        address(UsedBankrollAddresses[0]).transfer(address(this).balance);
+    }
+
+     
+    function WithdrawAndTransferToBankroll() public {
+        Zethr.withdraw();
+        WithdrawToBankroll();
+    }
+}
+
+ 
+ 
+contract Zlots is ZethrShell {
+    using SafeMath for uint;
+
+     
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHPrize(address _wagerer, uint _block);               
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreePurplePyramids(address _wagerer, uint _block);    
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeRockets(address _wagerer, uint _block);           
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoPurplePyramids(address _wagerer, uint _block);      
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoRockets(address _wagerer, uint _block);             
+    event SpinConcluded(address _wagerer, uint _block);          
+
+     
+
+     
+     
+    modifier betIsValid(uint _betSize, uint divRate) {
+      require(_betSize.mul(100) <= getMaxProfit(divRate));
+      _;
+    }
+
+     
+    modifier gameIsActive {
+      require(gamePaused == false);
+      _;
+    }
+
+     
+    modifier onlyOwner {
+      require(msg.sender == owner); 
+      _;
+    }
+
+     
+    modifier onlyBankroll {
+      require(msg.sender == bankroll);
+      _;
+    }
+
+     
+    modifier onlyOwnerOrBankroll {
+      require(msg.sender == owner || msg.sender == bankroll);
+      _;
+    }
+
+     
+
+     
+    uint constant public maxProfitDivisor = 1000000;
+    uint constant public houseEdgeDivisor = 1000;
+    mapping (uint => uint) public maxProfit;
+    uint public maxProfitAsPercentOfHouse;
+    uint public minBet = 1e18;
+    address public zlotsJackpot;
+    address private owner;
+    address private bankroll;
+    bool gamePaused;
+
+     
+    uint  public totalSpins;
+    uint  public totalZTHWagered;
+    mapping (uint => uint) public contractBalance;
+
+     
+    mapping(uint => uint) public maxBet;
+    
+     
+    bool public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+
+     
+
+     
+    constructor(address BankrollAddress) public {
+         
+        setupBankrollInterface(BankrollAddress); 
+
+         
+        owner = msg.sender;
+
+         
+        ownerSetMaxProfitAsPercentOfHouse(50000);
+
+         
+        bankroll      = ZTHBANKROLL;
+        gameActive  = true;
+
+         
+        ownerSetMinBet(1e18);
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function execute(address _from, uint _value, uint divRate, bytes  ) public fromBankroll returns (bool){
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn, divRate);
+            return true;
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+        uint8 tier;
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn, uint divRate) 
+      private 
+      betIsValid(_tkn.value, divRate)
+    {
+
+        require(gameActive);
+        require(1e18 <= _tkn.value);  
+        
+        require(_tkn.value < ((2 ** 200) - 1));    
+        require(block.number < ((2 ** 56) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+ 
+         
+         
+         
+        addContractBalance(divRate, _wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+        spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+
+    }
+
+     
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+      return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 1000000;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target) + 1;
+        }
+
+        if (result > 476662) {
+             
+
+             
+             
+            RequestBankrollPayment(zlotsJackpot, profit, tier);
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));
+
+            emit Loss(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else if (result < 2) {
+             
+      
+             
+            profit = ZlotsJackpotHoldingContract(zlotsJackpot).getJackpot();
+            category = 1;
+    
+             
+            emit ThreeMoonJackpot(target, spin.blockn);
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+
+             
+            uint8 tier = spin.tier;
+
+             
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));
+
+             
+            ZlotsJackpotHoldingContract(zlotsJackpot).payOutWinner(target);
+        } else {
+            if (result < 299) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 100);
+                category = 2;
+                emit TwoMoonPrize(target, spin.blockn);
+            } else if (result < 3128) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 20);
+                category = 3;
+                emit ZTHPrize(target, spin.blockn);
+            } else if (result < 5957) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 4;
+                emit ThreeZSymbols(target, spin.blockn);
+            } else if (result < 8786) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 5;
+                emit ThreeTSymbols(target, spin.blockn);
+            } else if (result < 11615) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 75), 10);
+                category = 6;
+                emit ThreeHSymbols(target, spin.blockn);
+            } else if (result < 14444) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 15);
+                category = 7;
+                emit ThreeEtherIcons(target, spin.blockn);
+            } else if (result < 17273) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 10);
+                category = 8;
+                emit ThreePurplePyramids(target, spin.blockn);
+            } else if (result < 20102) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 10);
+                category = 9;
+                emit ThreeGoldPyramids(target, spin.blockn);
+            } else if (result < 22930) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 12);
+                category = 10;
+                emit ThreeRockets(target, spin.blockn);
+            } else if (result < 52333) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25),10);
+                category = 11;
+                emit OneMoonPrize(target, spin.blockn);
+            } else if (result < 120226) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                category = 12;
+                emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else if (result < 171147) {
+                 
+                profit = spin.tokenValue;
+                category = 13;
+                 emit TwoZSymbols(target, spin.blockn);
+            } else if (result < 222068) {
+                 
+                profit = spin.tokenValue;
+                category = 14;
+                emit TwoTSymbols(target, spin.blockn);
+            } else if (result < 272989) {
+                 
+                profit = spin.tokenValue;
+                category = 15;
+                emit TwoHSymbols(target, spin.blockn);
+            } else if (result < 323910) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 16;
+                emit TwoEtherIcons(target, spin.blockn);
+            } else if (result < 374831) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133),100);
+                category = 17;
+                emit TwoPurplePyramids(target, spin.blockn);
+            } else if (result < 425752) {
+                 
+                profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 133),100);
+                category = 18;
+                emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 2);
+                category = 19;
+                emit TwoRockets(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            tier = spin.tier;
+            playerSpins[target] = playerSpin(uint200(0), uint48(0), uint8(0));  
+            RequestBankrollPayment(target, profit, tier);
+          }
+            
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+      return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function setMaxProfit(uint divRate) internal {
+      maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor; 
+    } 
+
+     
+    function getMaxProfit(uint divRate) public view returns (uint) {
+      return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+    }
+
+     
+    function subContractBalance(uint divRate, uint sub) internal {
+      contractBalance[divRate] = contractBalance[divRate].sub(sub);
+    }
+
+     
+    function addContractBalance(uint divRate, uint add) internal {
+      contractBalance[divRate] = contractBalance[divRate].add(add);
+    }
+
+     
+     
+     
+    function bankrollExternalUpdateTokens(uint divRate, uint newBalance) 
+      public 
+      fromBankroll 
+    {
+      contractBalance[divRate] = newBalance;
+      setMaxProfit(divRate);
+    }
+
+     
+     
+    function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+    onlyOwner
+    {
+       
+      require(newMaxProfitAsPercent <= 200000);
+      maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+      setMaxProfit(2);
+      setMaxProfit(5);
+      setMaxProfit(10);
+      setMaxProfit(15); 
+      setMaxProfit(20);
+      setMaxProfit(25);
+      setMaxProfit(33);
+    }
+
+     
+    function ownerSetMinBet(uint newMinimumBet) public
+    onlyOwner
+    {
+      minBet = newMinimumBet;
+    }
+
+     
+    function ownerSetZlotsAddress(address zlotsAddress) public
+    onlyOwner
+    {
+        zlotsJackpot = zlotsAddress;
+    }
+
+     
+    function pauseGame() public onlyOwnerOrBankroll {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwnerOrBankroll {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwnerOrBankroll {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwnerOrBankroll {
+        bankroll = _newBankroll;
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/112.sol

@@ -0,0 +1,253 @@
+pragma solidity ^0.4.24;
+
+ 
+
+
+ 
+library SafeMath {
+    function add(uint a, uint b) internal pure returns (uint c) {
+        c = a + b;
+        require(c >= a);
+    }
+    function sub(uint a, uint b) internal pure returns (uint c) {
+        require(b <= a);
+        c = a - b;
+    }
+    function mul(uint a, uint b) internal pure returns (uint c) {
+        c = a * b;
+        require(a == 0 || c / a == b);
+    }
+    function div(uint a, uint b) internal pure returns (uint c) {
+        require(b > 0);
+        c = a / b;
+    }
+}
+
+
+ 
+contract Owned {
+    address public owner;
+    address public newOwner;
+
+    event OwnershipTransferred(address indexed _from, address indexed _to);
+
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address _newOwner) public onlyOwner {
+        newOwner = _newOwner;
+    }
+
+    function acceptOwnership() public {
+        require(msg.sender == newOwner);
+
+        emit OwnershipTransferred(owner, newOwner);
+
+        owner = newOwner;
+
+        newOwner = address(0);
+    }
+}
+
+
+ 
+contract ERC20Interface {
+    function totalSupply() public constant returns (uint);
+    function balanceOf(address tokenOwner) public constant returns (uint balance);
+    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
+    function transfer(address to, uint tokens) public returns (bool success);
+    function approve(address spender, uint tokens) public returns (bool success);
+    function transferFrom(address from, address to, uint tokens) public returns (bool success);
+
+    event Transfer(address indexed from, address indexed to, uint tokens);
+    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
+}
+
+
+ 
+contract ERC918Interface {
+    function getChallengeNumber() public constant returns (bytes32);
+    function getMiningDifficulty() public constant returns (uint);
+    function getMiningTarget() public constant returns (uint);
+    function getMiningReward() public constant returns (uint);
+
+    function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
+    event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
+
+    address public lastRewardTo;
+    uint public lastRewardAmount;
+    uint public lastRewardEthBlockNumber;
+    bytes32 public challengeNumber;
+}
+
+ 
+contract ZeroGoldPOWMining is Owned {
+    using SafeMath for uint;
+
+     
+    ERC20Interface zeroGold;
+    
+     
+    ERC918Interface public miningLeader;
+    
+     
+    address public mintHelper = 0x0;
+
+    modifier onlyMintHelper {
+        require(msg.sender == mintHelper);
+        _;
+    }
+    
+     
+     
+     
+    uint rewardDivisor = 20;
+
+     
+    uint epochCount = 0;
+    
+     
+    uint public lastRewardAmount = 0;
+
+    mapping(bytes32 => bytes32) solutionForChallenge;
+
+    event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
+
+    constructor(address _miningLeader, address _mintHelper) public  {
+         
+        miningLeader = ERC918Interface(_miningLeader);
+
+         
+        mintHelper = _mintHelper;
+
+         
+         
+        zeroGold = ERC20Interface(0x6ef5bca539A4A01157af842B4823F54F9f7E9968);
+    }
+
+     
+    function merge() external onlyMintHelper returns (bool success) {
+         
+        bytes32 futureChallengeNumber = blockhash(block.number - 1);
+
+         
+        bytes32 challengeNumber = miningLeader.getChallengeNumber();
+
+         
+        if (challengeNumber == futureChallengeNumber) {
+             
+             
+            return false; 
+        }
+
+         
+        if (miningLeader.lastRewardTo() != msg.sender) {
+             
+             
+            return false;
+        }
+            
+         
+        if (miningLeader.lastRewardEthBlockNumber() != block.number) {
+             
+             
+            return false;
+        }
+
+         
+         
+         
+        bytes32 parentChallengeNumber = miningLeader.challengeNumber();
+        bytes32 solution = solutionForChallenge[parentChallengeNumber];
+        if (solution != 0x0) return false;  
+        
+        bytes32 digest = 'merge';
+        solutionForChallenge[parentChallengeNumber] = digest;
+
+         
+         
+        
+         
+        uint rewardAmount = getRewardAmount();
+
+         
+        uint balance = zeroGold.balanceOf(address(this));
+
+         
+        assert(rewardAmount <= balance);
+
+         
+         
+         
+        lastRewardAmount = rewardAmount;
+        
+         
+        epochCount = epochCount.add(1);
+
+         
+        emit Mint(msg.sender, rewardAmount, epochCount, 0);
+
+        return true;
+    }
+
+     
+     
+     
+    function transfer(
+        address _wallet, 
+        uint _reward
+    ) external onlyMintHelper returns (bool) {
+         
+        if (_reward > lastRewardAmount) {
+            return false;
+        }
+            
+         
+        lastRewardAmount = lastRewardAmount.sub(_reward);
+
+         
+        zeroGold.transfer(_wallet, _reward);
+    }
+
+     
+    function getRewardAmount() public constant returns (uint) {
+         
+        uint totalBalance = zeroGold.balanceOf(address(this));
+
+        return totalBalance.div(rewardDivisor);
+    }
+
+     
+    function setMiningLeader(address _miningLeader) external onlyOwner {
+        miningLeader = ERC918Interface(_miningLeader);
+    }
+
+     
+    function setMintHelper(address _mintHelper) external onlyOwner {
+        mintHelper = _mintHelper;
+    }
+
+     
+    function setRewardDivisor(uint _rewardDivisor) external onlyOwner {
+        rewardDivisor = _rewardDivisor;
+    }
+
+     
+    function () public payable {
+         
+        revert('Oops! Direct payments are NOT permitted here.');
+    }
+
+     
+    function transferAnyERC20Token(
+        address tokenAddress, uint tokens
+    ) public onlyOwner returns (bool success) {
+        return ERC20Interface(tokenAddress).transfer(owner, tokens);
+    }
+}

smart_contract_dataset/block number dependency/1121.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/1149.sol

@@ -0,0 +1,403 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+
+contract ZTHInterface {
+  function getFrontEndTokenBalanceOf(address who) public view returns (uint);
+  function transfer(address _to, uint _value) public returns (bool);
+  function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zethroll is ZTHReceivingContract {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber) {
+     require( calculateProfit(_betSize, _playerNumber) < maxProfit
+             && _betSize >= minBet
+             && _playerNumber > minNumber
+             && _playerNumber < maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 99;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+  address public ZethrBankroll;
+  address public ZTHTKNADDR;
+
+  ZTHInterface public ZTHTKN;
+
+  uint public contractBalance;
+  uint public houseEdge;
+  uint public maxProfit;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address zthtknaddr, address zthbankrolladdr) public {
+     
+    owner = msg.sender;
+
+     
+    ZTHTKN = ZTHInterface(zthtknaddr);
+    ZTHTKNADDR = zthtknaddr;
+
+     
+    ZethrBankroll = zthbankrolladdr;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+
+     
+    ZTHTKN.approve(zthbankrolladdr, MAX_INT);
+  }
+
+  function() public payable {}  
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint200 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+  function _playerRollDice(uint _rollUnder, TKN _tkn) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder)
+  {
+    require(_tkn.value < ((2 ** 200) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+
+     
+     
+
+     
+    require(_zthToken(msg.sender));
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(false, _tkn.sender);
+    }
+
+     
+    roll.blockn = uint48(block.number);
+    roll.tokenValue = uint200(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(true, msg.sender);
+  }
+
+   
+  function _finishBet(bool delete_it, address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(99, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+      
+        if (profit > maxProfit){
+            profit = maxProfit;
+        }
+
+       
+      contractBalance = contractBalance.sub(profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit();
+
+
+         
+        playerRolls[target] = playerRoll(uint200(0), uint48(0), uint8(0));
+
+
+       
+      ZTHTKN.transfer(target, profit + roll.tokenValue);
+      
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      contractBalance = contractBalance.add(roll.tokenValue);
+
+        playerRolls[target] = playerRoll(uint200(0), uint48(0), uint8(0));
+       
+       
+
+       
+      setMaxProfit();
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
+    require(msg.sender == ZTHTKNADDR);
+    if (_from == ZethrBankroll) {
+       
+      contractBalance = contractBalance.add(_value);
+
+       
+      uint oldMaxProfit = maxProfit;
+      setMaxProfit();
+
+      emit MaxProfitChanged(oldMaxProfit, maxProfit);
+      return true;
+
+    } else {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn);
+    }
+
+    return true;
+  }
+
+   
+  function setMaxProfit() internal {
+    emit CurrentContractBalance(contractBalance);
+    maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance) public
+  onlyOwner
+  {
+    contractBalance = newContractBalance;
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit();
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerTransferZTH(address sendTo, uint amount) public
+  onlyOwner
+  {
+     
+    contractBalance = contractBalance.sub(amount);
+
+     
+    setMaxProfit();
+    require(ZTHTKN.transfer(sendTo, amount));
+    emit LogOwnerTransfer(sendTo, amount);
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerSetBankroll(address newBankroll) public
+  onlyOwner
+  {
+    ZTHTKN.approve(ZethrBankroll, 0);
+    ZethrBankroll = newBankroll;
+    ZTHTKN.approve(newBankroll, MAX_INT);
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+    ZTHTKN.transfer(owner, contractBalance);
+    selfdestruct(owner);
+  }
+  
+  function dumpdivs() public{
+      ZethrBankroll.transfer(address(this).balance);
+  }
+
+  function _zthToken(address _tokenContract) private view returns (bool) {
+    return _tokenContract == ZTHTKNADDR;
+     
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/1165.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/129.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/1297.sol

@@ -0,0 +1,136 @@
+pragma solidity ^0.4.24;
+contract BREBuy {
+    
+
+    struct ContractParam {
+        uint32  totalSize ; 
+        uint256 singlePrice;   
+        uint8  pumpRate;
+        bool hasChange;
+    }
+    
+    address owner = 0x0;
+    uint32  gameIndex = 0;
+    uint256 totalPrice= 0;
+    ContractParam public setConfig;
+    ContractParam public curConfig;
+    
+    address[] public addressArray = new address[](0);
+    
+    
+   event  addPlayerEvent(uint32,address);
+    event GameOverEvent(uint32,uint32,uint256,uint8,address,uint );
+    
+     
+    constructor ( uint32 _totalSize,
+                  uint256 _singlePrice
+    )  public payable  {
+        owner = msg.sender;
+        setConfig = ContractParam(_totalSize,_singlePrice * 1 finney ,5,false);
+        curConfig = ContractParam(_totalSize,_singlePrice * 1 finney ,5,false);
+        startNewGame();
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        if (newOwner != address(0)) {
+            owner = newOwner;
+        }
+    }
+    
+    function changeConfig( uint32 _totalSize,uint256 _singlePrice,uint8 _pumpRate) onlyOwner public payable {
+    
+        curConfig.hasChange = true;
+        if(setConfig.totalSize != _totalSize) {
+            setConfig.totalSize = _totalSize;
+        }
+        if(setConfig.pumpRate  != _pumpRate){
+            setConfig.pumpRate  = _pumpRate;
+        }
+        if(setConfig.singlePrice != _singlePrice * 1 finney){
+            setConfig.singlePrice = _singlePrice * 1 finney;
+        }
+    }
+    
+    function startNewGame() private {
+        
+        gameIndex++;
+        if(curConfig.hasChange) {
+            if(curConfig.totalSize   != setConfig.totalSize) {
+                curConfig.totalSize   = setConfig.totalSize;
+            }
+            if(curConfig.singlePrice != setConfig.singlePrice){
+               curConfig.singlePrice = setConfig.singlePrice; 
+            }
+            if( curConfig.pumpRate    != setConfig.pumpRate) {
+                curConfig.pumpRate    = setConfig.pumpRate;
+            }
+            curConfig.hasChange = false;
+        }
+        addressArray.length=0;
+    }
+    
+    
+    function addPlayer() public payable {
+      
+        require(msg.value == curConfig.singlePrice);
+        totalPrice = totalPrice + msg.value;
+        addressArray.push(msg.sender);
+       
+        emit addPlayerEvent(gameIndex,msg.sender);
+        if(addressArray.length >= curConfig.totalSize) {
+            gameResult();
+            startNewGame();
+        }
+    }
+    
+    function getGameInfo() public view returns  (uint256,uint32,uint256,uint8,address[],uint256)  {
+        return (gameIndex,
+                curConfig.totalSize,
+                curConfig.singlePrice,
+                curConfig.pumpRate,
+                addressArray,
+                totalPrice);
+    }
+    
+    function getSelfCount() private view returns (uint32) {
+        uint32 count = 0;
+        for(uint i = 0; i < addressArray.length; i++) {
+            if(msg.sender == addressArray[i]) {
+                count++;
+            }
+        }
+        return count;
+    }
+    
+    function gameResult() private {
+            
+      uint index  = getRamdon();
+      address lastAddress = addressArray[index];
+      uint totalBalace = address(this).balance;
+      uint giveToOwn   = totalBalace * curConfig.pumpRate / 100;
+      uint giveToActor = totalBalace - giveToOwn;
+      owner.transfer(giveToOwn);
+      lastAddress.transfer(giveToActor);
+      emit GameOverEvent(
+                    gameIndex,
+                    curConfig.totalSize,
+                    curConfig.singlePrice,
+                    curConfig.pumpRate,
+                    lastAddress,
+                    now);
+    }
+    
+    function getRamdon() private view returns (uint) {
+      bytes32 ramdon = keccak256(abi.encodePacked(ramdon,now,blockhash(block.number-1)));
+      for(uint i = 0; i < addressArray.length; i++) {
+            ramdon = keccak256(abi.encodePacked(ramdon,now, addressArray[i]));
+      }
+      uint index  = uint(ramdon) % addressArray.length;
+      return index;
+    }
+}

smart_contract_dataset/block number dependency/1345.sol

@@ -0,0 +1,458 @@
+pragma solidity ^0.4.24;
+
+ 
+contract ZethrTokenBankroll{
+     
+    function gameRequestTokens(address target, uint tokens) public;
+}
+
+ 
+contract ZethrMainBankroll{
+    function gameGetTokenBankrollList() public view returns (address[7]);
+}
+
+ 
+contract ZethrInterface{
+    function withdraw() public;
+}
+
+ 
+library ZethrTierLibrary{
+    uint constant internal magnitude = 2**64;
+    function getTier(uint divRate) internal pure returns (uint){
+         
+         
+        
+         
+         
+        uint actualDiv = divRate; 
+        if (actualDiv >= 30){
+            return 6;
+        } else if (actualDiv >= 25){
+            return 5;
+        } else if (actualDiv >= 20){
+            return 4;
+        } else if (actualDiv >= 15){
+            return 3;
+        } else if (actualDiv >= 10){
+            return 2; 
+        } else if (actualDiv >= 5){
+            return 1;
+        } else if (actualDiv >= 2){
+            return 0;
+        } else{
+             
+            revert(); 
+        }
+    }
+}
+ 
+ 
+contract ZethrBankrollBridge{
+     
+    ZethrInterface Zethr;
+   
+     
+     
+     
+     
+    address[7] UsedBankrollAddresses; 
+
+     
+    mapping(address => bool) ValidBankrollAddress;
+    
+     
+    function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
+         
+        UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
+        for(uint i=0; i<7; i++){
+            ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
+        }
+    }
+    
+     
+    modifier fromBankroll(){
+        require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
+        _;
+    }
+    
+     
+     
+    function RequestBankrollPayment(address to, uint tokens, uint userDivRate) internal {
+        uint tier = ZethrTierLibrary.getTier(userDivRate);
+        address tokenBankrollAddress = UsedBankrollAddresses[tier];
+        ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
+    }
+}
+
+ 
+contract ZethrShell is ZethrBankrollBridge{
+    
+     
+    function WithdrawToBankroll() public {
+        address(UsedBankrollAddresses[0]).transfer(address(this).balance);
+    }
+    
+     
+    function WithdrawAndTransferToBankroll() public {
+        Zethr.withdraw();
+        WithdrawToBankroll();
+    }
+}
+
+ 
+ 
+contract Zethroll is ZethrShell {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber, uint divRate) {
+     require(  calculateProfit(_betSize, _playerNumber) < getMaxProfit(divRate)
+             && _betSize >= minBet
+             && _playerNumber >= minNumber
+             && _playerNumber <= maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 100;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+
+  mapping (uint => uint) public contractBalance;
+  mapping (uint => uint) public maxProfit;
+  uint public houseEdge;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address ZethrMainBankrollAddress) public {
+    setupBankrollInterface(ZethrMainBankrollAddress);
+
+     
+    owner = msg.sender;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+  }
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) public view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint192 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+    uint8 divRate;       
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+   
+  function _playerRollDice(uint _rollUnder, TKN _tkn, uint userDivRate) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder, userDivRate)
+  {
+    require(_tkn.value < ((2 ** 192) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+    require(userDivRate < (2 ** 8 - 1));  
+     
+     
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(_tkn.sender);
+    }
+
+     
+    roll.blockn = uint48(block.number);
+    roll.tokenValue = uint192(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+    roll.divRate = uint8(userDivRate);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(msg.sender);
+  }
+
+   
+  function _finishBet(address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(100, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+      uint mProfit = getMaxProfit(roll.divRate);
+        if (profit > mProfit){
+            profit = mProfit;
+        }
+
+       
+      subContractBalance(roll.divRate, profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit(roll.divRate);
+
+       
+      playerRolls[target] = playerRoll(uint192(0), uint48(0), uint8(0), uint8(0));
+
+       
+      RequestBankrollPayment(target, profit + roll.tokenValue, roll.divRate);
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      addContractBalance(roll.divRate, roll.tokenValue);
+     
+      playerRolls[target] = playerRoll(uint192(0), uint48(0), uint8(0), uint8(0));
+       
+       
+
+       
+      setMaxProfit(roll.divRate);
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function execute(address _from, uint _value, uint userDivRate, bytes _data) public fromBankroll gameIsActive returns (bool) {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn, userDivRate);
+
+    return true;
+  }
+
+   
+  function setMaxProfit(uint divRate) internal {
+     
+    maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+ 
+   
+  function getMaxProfit(uint divRate) public view returns (uint){
+      return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+ 
+   
+  function subContractBalance(uint divRate, uint sub) internal {
+      contractBalance[divRate] = contractBalance[divRate].sub(sub);
+  }
+ 
+   
+  function addContractBalance(uint divRate, uint add) internal {
+      contractBalance[divRate] = contractBalance[divRate].add(add);
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance, uint divRate) public
+  onlyOwner
+  {
+    contractBalance[divRate] = newContractBalance;
+  }
+  
+   
+   
+   
+  function bankrollExternalUpdateTokens(uint divRate, uint newBalance) public fromBankroll {
+      contractBalance[divRate] = newBalance;
+      setMaxProfit(divRate);
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit(2);
+    setMaxProfit(5);
+    setMaxProfit(10);
+    setMaxProfit(15);
+    setMaxProfit(20);
+    setMaxProfit(25);
+    setMaxProfit(33);
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public 
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+
+    selfdestruct(owner);
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/135.sol

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

smart_contract_dataset/block number dependency/136.sol

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

smart_contract_dataset/block number dependency/137.sol

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

smart_contract_dataset/block number dependency/138.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/1406.sol

@@ -0,0 +1,247 @@
+pragma solidity ^0.4.12;
+ 
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+ 
+ 
+contract SafeMath {
+ 
+ 
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+ 
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+ 
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+ 
+}
+ 
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+ 
+ 
+ 
+contract StandardToken is Token {
+ 
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+ 
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+ 
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+ 
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+ 
+contract EVTCTLToken is StandardToken, SafeMath {
+ 
+     
+    string  public constant name = "EVTC";
+    string  public constant symbol = "EVTC";
+    uint256 public constant decimals = 18;
+    string  public version = "1.0";
+ 
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+ 
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+ 
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+    uint256 public tokenExchangeRate = 2600;              
+ 
+     
+    event AllocateToken(address indexed _to, uint256 _value);    
+    event IssueToken(address indexed _to, uint256 _value);       
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+    event Migrate(address indexed _to, uint256 _value);
+ 
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+ 
+     
+    function EVTCTLToken(
+        address _ethFundDeposit,
+        uint256 _currentSupply)
+    {
+        ethFundDeposit = _ethFundDeposit;
+ 
+        isFunding = false;                            
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+ 
+        currentSupply = formatDecimals(_currentSupply);
+        totalSupply = formatDecimals(100000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+ 
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+ 
+     
+    function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
+        if (_tokenExchangeRate == 0) throw;
+        if (_tokenExchangeRate == tokenExchangeRate) throw;
+ 
+        tokenExchangeRate = _tokenExchangeRate;
+    }
+ 
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+ 
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+ 
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+ 
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+ 
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+ 
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+ 
+     
+    function setMigrateContract(address _newContractAddr) isOwner external {
+        if (_newContractAddr == newContractAddr) throw;
+        newContractAddr = _newContractAddr;
+    }
+ 
+     
+    function changeOwner(address _newFundDeposit) isOwner() external {
+        if (_newFundDeposit == address(0x0)) throw;
+        ethFundDeposit = _newFundDeposit;
+    }
+ 
+     
+    function migrate() external {
+        if(isFunding) throw;
+        if(newContractAddr == address(0x0)) throw;
+ 
+        uint256 tokens = balances[msg.sender];
+        if (tokens == 0) throw;
+ 
+        balances[msg.sender] = 0;
+        tokenMigrated = safeAdd(tokenMigrated, tokens);
+ 
+        IMigrationContract newContract = IMigrationContract(newContractAddr);
+        if (!newContract.migrate(msg.sender, tokens)) throw;
+ 
+        Migrate(msg.sender, tokens);                
+    }
+ 
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+ 
+     
+    function allocateToken (address _addr, uint256 _eth) isOwner external {
+        if (_eth == 0) throw;
+        if (_addr == address(0x0)) throw;
+ 
+        uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[_addr] += tokens;
+ 
+        AllocateToken(_addr, tokens);   
+    }
+ 
+     
+    function () payable {
+        if (!isFunding) throw;
+        if (msg.value == 0) throw;
+ 
+        if (block.number < fundingStartBlock) throw;
+        if (block.number > fundingStopBlock) throw;
+ 
+        uint256 tokens = safeMult(msg.value, tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[msg.sender] += tokens;
+ 
+        IssueToken(msg.sender, tokens);   
+    }
+}

smart_contract_dataset/block number dependency/1472.sol

@@ -0,0 +1,472 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+    function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+contract ZTHInterface {
+    function transfer(address _to, uint _value) public returns (bool);
+    function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zlots is ZTHReceivingContract {
+    using SafeMath for uint;
+
+    address private owner;
+    address private bankroll;
+
+     
+    uint  totalSpins;
+    uint  totalZTHWagered;
+
+     
+    uint contractBalance;
+
+     
+    bool    public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+    ZTHInterface private     ZTHTKN;
+
+    mapping (uint => bool) validTokenBet;
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHJackpot(address _wagerer, uint _block);             
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreeGreenPyramids(address _wagerer, uint _block);     
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeWhitePyramids(address _wagerer, uint _block);     
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoGreenPyramids(address _wagerer, uint _block);       
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoWhitePyramids(address _wagerer, uint _block);       
+    
+    event SpinConcluded(address _wagerer, uint _block);          
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    modifier onlyBankroll {
+        require(msg.sender == bankroll);
+        _;
+    }
+
+    modifier onlyOwnerOrBankroll {
+        require(msg.sender == owner || msg.sender == bankroll);
+        _;
+    }
+
+     
+    modifier gameIsActive {
+        require(gameActive == true);
+        _;
+    }
+
+    constructor(address ZethrAddress, address BankrollAddress) public {
+
+         
+        ZTHTKNADDR = ZethrAddress;
+        ZTHBANKROLL = BankrollAddress;
+
+         
+        owner         = msg.sender;
+        bankroll      = ZTHBANKROLL;
+
+         
+        ZTHTKN = ZTHInterface(ZTHTKNADDR);
+        ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
+        
+         
+        ZTHTKN.approve(owner, 2**256 - 1);
+
+         
+        validTokenBet[1e18]  = true;
+        validTokenBet[5e18]  = true;
+        validTokenBet[10e18] = true;
+        validTokenBet[25e18] = true;
+        validTokenBet[50e18] = true;
+
+        gameActive  = true;
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function tokenFallback(address _from, uint _value, bytes  ) public returns (bool){
+        if (_from == bankroll) {
+           
+          contractBalance = contractBalance.add(_value);    
+          return true;
+        } else {
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn);
+            return true;
+        }
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint56 blockn;       
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn) private {
+
+        require(gameActive);
+        require(_zthToken(msg.sender));
+        require(validTokenBet[_tkn.value]);
+        require(jackpotGuard(_tkn.value));
+
+        require(_tkn.value < ((2 ** 200) - 1));    
+        require(block.number < ((2 ** 56) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+
+        contractBalance = contractBalance.add(_wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint56(block.number);
+        spin.tokenValue = uint200(_wagered);
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+
+    }
+
+      
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+      return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 999999;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target);
+        }
+
+        if (result > 476661) {
+           
+          emit Loss(target, spin.blockn);
+          emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else {
+            if (result < 1) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 500);
+                category = 1;
+                emit ThreeMoonJackpot(target, spin.blockn);
+            } else 
+                if (result < 298) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 232);
+                    category = 2;
+                    emit TwoMoonPrize(target, spin.blockn);
+            } else 
+                if (result < 3127) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
+                    category = 3;
+                    emit ZTHJackpot(target, spin.blockn);
+                    
+            } else 
+                if (result < 5956) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 4;
+                    emit ThreeZSymbols(target, spin.blockn);
+            } else 
+                if (result < 8785) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 5;
+                    emit ThreeTSymbols(target, spin.blockn);
+            } else 
+                if (result < 11614) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 6;
+                    emit ThreeHSymbols(target, spin.blockn);
+            } else 
+                if (result < 14443) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 50);
+                    category = 7;
+                    emit ThreeEtherIcons(target, spin.blockn);
+            } else 
+                if (result < 17272) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 40);
+                    category = 8;
+                    emit ThreeGreenPyramids(target, spin.blockn);
+            } else 
+                if (result < 20101) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 9;
+                    emit ThreeGoldPyramids(target, spin.blockn);
+            } else 
+                if (result < 22929) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 10;
+                    emit ThreeWhitePyramids(target, spin.blockn);
+            } else 
+                if (result < 52332) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
+                    category = 11;
+                    emit OneMoonPrize(target, spin.blockn);
+            } else 
+                if (result < 120225) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                    category = 12;
+                    emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else 
+                if (result < 171146) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 13;
+                    emit TwoZSymbols(target, spin.blockn);
+            } else 
+                if (result < 222067) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 14;
+                    emit TwoTSymbols(target, spin.blockn);
+            } else 
+                if (result < 272988) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 15;
+                    emit TwoHSymbols(target, spin.blockn);
+            } else 
+                if (result < 323909) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
+                    category = 16;
+                    emit TwoEtherIcons(target, spin.blockn);
+            } else 
+                if (result < 374830) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
+                    category = 17;
+                    emit TwoGreenPyramids(target, spin.blockn);
+            } else 
+                if (result < 425751) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
+                    category = 18;
+                    emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 2);
+                    category = 19;
+                    emit TwoWhitePyramids(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            contractBalance = contractBalance.sub(profit);
+            ZTHTKN.transfer(target, profit);
+          }
+            
+         
+        playerSpins[target] = playerSpin(uint200(0), uint56(0));
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+     
+     
+    function jackpotGuard(uint _wager)
+        private
+        view
+        returns (bool)
+    {
+        uint maxProfit = SafeMath.mul(_wager, 500);
+        uint ninetyContractBalance = SafeMath.mul(SafeMath.div(contractBalance, 10), 9);
+        return (maxProfit <= ninetyContractBalance);
+    }
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        address(this),
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function balanceOf() public view returns (uint) {
+        return contractBalance;
+    }
+
+    function addNewBetAmount(uint _tokenAmount)
+        public
+        onlyOwner
+    {
+        validTokenBet[_tokenAmount] = true;
+    }
+
+     
+    function pauseGame() public onlyOwner {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwner {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwner {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwner {
+        bankroll = _newBankroll;
+    }
+
+    function divertDividendsToBankroll()
+        public
+        onlyOwner
+    {
+        bankroll.transfer(address(this).balance);
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1482.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/1546.sol

@@ -0,0 +1,472 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+    function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+contract ZTHInterface {
+    function transfer(address _to, uint _value) public returns (bool);
+    function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zlots is ZTHReceivingContract {
+    using SafeMath for uint;
+
+    address private owner;
+    address private bankroll;
+
+     
+    uint  totalSpins;
+    uint  totalZTHWagered;
+
+     
+    uint contractBalance;
+
+     
+    bool    public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+    ZTHInterface private     ZTHTKN;
+
+    mapping (uint => bool) validTokenBet;
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHJackpot(address _wagerer, uint _block);             
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreeGreenPyramids(address _wagerer, uint _block);     
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeWhitePyramids(address _wagerer, uint _block);     
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoGreenPyramids(address _wagerer, uint _block);       
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoWhitePyramids(address _wagerer, uint _block);       
+    
+    event SpinConcluded(address _wagerer, uint _block);          
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    modifier onlyBankroll {
+        require(msg.sender == bankroll);
+        _;
+    }
+
+    modifier onlyOwnerOrBankroll {
+        require(msg.sender == owner || msg.sender == bankroll);
+        _;
+    }
+
+     
+    modifier gameIsActive {
+        require(gameActive == true);
+        _;
+    }
+
+    constructor(address ZethrAddress, address BankrollAddress) public {
+
+         
+        ZTHTKNADDR = ZethrAddress;
+        ZTHBANKROLL = BankrollAddress;
+
+         
+        owner         = msg.sender;
+        bankroll      = ZTHBANKROLL;
+
+         
+        ZTHTKN = ZTHInterface(ZTHTKNADDR);
+        ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
+        
+         
+        ZTHTKN.approve(owner, 2**256 - 1);
+
+         
+        validTokenBet[5e18]  = true;
+        validTokenBet[10e18] = true;
+        validTokenBet[25e18] = true;
+        validTokenBet[50e18] = true;
+
+        gameActive  = true;
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function tokenFallback(address _from, uint _value, bytes  ) public returns (bool){
+        if (_from == bankroll) {
+           
+          contractBalance = contractBalance.add(_value);    
+          return true;
+        } else {
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn);
+            return true;
+        }
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint56 blockn;       
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn) private {
+
+        require(gameActive);
+        require(_zthToken(msg.sender));
+        require(validTokenBet[_tkn.value]);
+        require(jackpotGuard(_tkn.value));
+
+        require(_tkn.value < ((2 ** 200) - 1));    
+        require(block.number < ((2 ** 56) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+
+         
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint56(block.number);
+        spin.tokenValue = uint200(_wagered);
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+
+    }
+
+      
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+      return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 999999;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target);
+        }
+
+        if (result > 476661) {
+           
+          contractBalance = contractBalance.add(spin.tokenValue);
+          emit Loss(target, spin.blockn);
+          emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else {
+            if (result < 1) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 500);
+                category = 1;
+                emit ThreeMoonJackpot(target, spin.blockn);
+            } else 
+                if (result < 298) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 232);
+                    category = 2;
+                    emit TwoMoonPrize(target, spin.blockn);
+            } else 
+                if (result < 3127) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
+                    category = 3;
+                    emit ZTHJackpot(target, spin.blockn);
+                    
+            } else 
+                if (result < 5956) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 4;
+                    emit ThreeZSymbols(target, spin.blockn);
+            } else 
+                if (result < 8785) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 5;
+                    emit ThreeTSymbols(target, spin.blockn);
+            } else 
+                if (result < 11614) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 6;
+                    emit ThreeHSymbols(target, spin.blockn);
+            } else 
+                if (result < 14443) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 50);
+                    category = 7;
+                    emit ThreeEtherIcons(target, spin.blockn);
+            } else 
+                if (result < 17272) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 40);
+                    category = 8;
+                    emit ThreeGreenPyramids(target, spin.blockn);
+            } else 
+                if (result < 20101) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 9;
+                    emit ThreeGoldPyramids(target, spin.blockn);
+            } else 
+                if (result < 22929) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 10;
+                    emit ThreeWhitePyramids(target, spin.blockn);
+            } else 
+                if (result < 52332) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
+                    category = 11;
+                    emit OneMoonPrize(target, spin.blockn);
+            } else 
+                if (result < 120225) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                    category = 12;
+                    emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else 
+                if (result < 171146) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 13;
+                    emit TwoZSymbols(target, spin.blockn);
+            } else 
+                if (result < 222067) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 14;
+                    emit TwoTSymbols(target, spin.blockn);
+            } else 
+                if (result < 272988) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 15;
+                    emit TwoHSymbols(target, spin.blockn);
+            } else 
+                if (result < 323909) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
+                    category = 16;
+                    emit TwoEtherIcons(target, spin.blockn);
+            } else 
+                if (result < 374830) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
+                    category = 17;
+                    emit TwoGreenPyramids(target, spin.blockn);
+            } else 
+                if (result < 425751) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
+                    category = 18;
+                    emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 2);
+                    category = 19;
+                    emit TwoWhitePyramids(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            contractBalance = contractBalance.sub(profit);
+            ZTHTKN.transfer(target, profit);
+          }
+            
+         
+        playerSpins[target] = playerSpin(uint200(0), uint56(0));
+        emit SpinConcluded(target, spin.blockn);
+        return result;
+    }   
+
+     
+     
+     
+     
+    function jackpotGuard(uint _wager)
+        private
+        view
+        returns (bool)
+    {
+        uint maxProfit = SafeMath.mul(_wager, 500);
+        uint ninetyContractBalance = SafeMath.mul(SafeMath.div(contractBalance, 10), 9);
+        return (maxProfit <= ninetyContractBalance);
+    }
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        address(this),
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function balanceOf() public view returns (uint) {
+        return contractBalance;
+    }
+
+    function addNewBetAmount(uint _tokenAmount)
+        public
+        onlyOwner
+    {
+        validTokenBet[_tokenAmount] = true;
+    }
+
+     
+    function pauseGame() public onlyOwner {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwner {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwner {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwner {
+        bankroll = _newBankroll;
+    }
+
+    function divertDividendsToBankroll()
+        public
+        onlyOwner
+    {
+        bankroll.transfer(address(this).balance);
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1567.sol

@@ -0,0 +1,395 @@
+pragma solidity ^0.4.24;
+
+contract Ownable {
+  address public owner;
+
+     
+    constructor() public {
+        owner = msg.sender;
+    }
+
+
+       
+      modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+      }
+  
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    require(newOwner != address(0));
+    owner = newOwner;
+  }
+
+}
+
+contract GuessEthEvents{
+    event drawLog(uint,uint,uint);
+
+    event guessEvt(
+        address indexed playerAddr,
+        uint[] numbers, uint amount
+        );
+    event winnersEvt(
+        uint blockNumber,
+        address indexed playerAddr,
+        uint amount,
+        uint winAmount
+        );
+    event withdrawEvt(
+        address indexed to,
+        uint256 value
+        );
+    event drawEvt(
+        uint indexed blocknumberr,
+        uint number
+        );
+    
+    event sponseEvt(
+        address indexed addr,
+        uint amount
+        );
+
+    event pauseGameEvt(
+        bool pause
+        );
+    event setOddsEvt(
+        uint odds
+        );
+  
+}
+
+contract GuessEth is Ownable,GuessEthEvents{
+    using SafeMath for uint;
+
+     
+
+    struct bnumber{
+        address addr;
+        uint number;
+        uint value;
+        int8 result;
+        uint prize;
+    }
+    mapping(uint => bnumber[]) public bets;
+    mapping(uint => address) public betNumber;
+    
+     
+    mapping(address => uint[]) private playerBetBNumber;
+    
+     
+    struct winner{
+        bool result;
+        uint prize;
+    }
+    
+    mapping(uint => winner[]) private winners;
+    mapping(uint => uint) private winResult;
+    
+    address private wallet1;
+    address private wallet2;
+    
+    uint private predictBlockInterval=3;
+    uint public odds=45;
+    uint public minBetVal=1 finney;
+    uint public blockInterval=500;
+    uint public curOpenBNumber=0;
+    uint public numberRange=100;
+
+    bool public gamePaused=false;
+    
+
+     
+    mapping(address => uint) Sponsors;
+    uint public balanceOfSPS=0;
+    address[] public SponsorAddresses;
+    
+    uint reservefund=30 ether;
+   
+  
+     
+    modifier isHuman() {
+        address _addr = msg.sender;
+        uint256 _codeLength;
+    
+        assembly {_codeLength := extcodesize(_addr)}
+        require(_codeLength == 0, "sorry humans only");
+        _;
+    }
+    
+    constructor(address _wallet1,address _wallet2) public{
+        wallet1=_wallet1;
+        wallet2=_wallet2;
+        
+        curOpenBNumber=blockInterval*(block.number.div(blockInterval));
+    }
+    
+    function pauseGame(bool _status) public onlyOwner returns(bool){
+            gamePaused=_status;
+            emit pauseGameEvt(_status);
+    }
+    
+    function setOdds(uint _odds) isHuman() public onlyOwner returns(bool){
+            odds = _odds;
+            emit setOddsEvt(_odds);
+    }
+    function setReservefund(uint _reservefund) isHuman() public onlyOwner returns(bool){
+            reservefund = _reservefund * 1 ether;
+    }
+    
+    function getTargetBNumber() view isHuman() public returns(uint){
+        uint n;
+        n=blockInterval*(predictBlockInterval + block.number/blockInterval);
+        return n;
+    }
+    
+    function guess(uint[] _numbers) payable isHuman() public returns(uint){
+        require(msg.value  >= _numbers.length.mul(minBetVal));
+
+        uint n=blockInterval*(predictBlockInterval + block.number/blockInterval);
+        
+        for(uint _i=0;_i < _numbers.length;_i++){
+            bnumber memory b;
+            
+            b.addr=msg.sender;
+            b.number=_numbers[_i];
+            b.value=msg.value/_numbers.length;
+            b.result=-1;
+            
+            bets[n].push(b);
+        }
+        
+        
+        if(utils.inArray(playerBetBNumber[msg.sender],n)==false){
+            playerBetBNumber[msg.sender].push(n);
+        }
+        
+        emit guessEvt(msg.sender,_numbers, msg.value);
+        
+        return _numbers.length;
+    }
+    
+
+    function getPlayerGuessNumbers() view public returns (uint[],uint[],uint256[],int8[],uint[]){
+        uint _c=0;
+        uint _i=0;
+        uint _j=0;
+        uint _bnumber;
+        uint limitRows=100;
+        
+        while(_i < playerBetBNumber[msg.sender].length){
+            _bnumber=playerBetBNumber[msg.sender][_i];
+            for(_j=0 ; _j < bets[_bnumber].length && _c < limitRows ; _j++){
+                if(msg.sender==bets[_bnumber][_j].addr){
+                    _c++;
+                }
+            }
+            _i++;
+        }
+
+        uint[] memory _blockNumbers=new uint[](_c);
+        uint[] memory _numbers=new uint[](_c);
+        uint[] memory _values=new uint[](_c);
+        int8[] memory _result=new int8[](_c);
+        uint[] memory _prize=new uint[](_c);
+        
+        if(_c<=0){
+            return(_blockNumbers,_numbers,_values,_result,_prize);
+        }
+
+         
+
+        uint _count=0;
+        for(_i=0 ; _i < playerBetBNumber[msg.sender].length ; _i++){
+            _bnumber=playerBetBNumber[msg.sender][_i];
+            
+            for(_j=0 ; _j < bets[_bnumber].length && _count < limitRows ; _j++){
+                if(bets[_bnumber][_j].addr == msg.sender){
+                    _blockNumbers[_count] = _bnumber;
+                    _numbers[_count] =  bets[_bnumber][_j].number;
+                    _values[_count] =  bets[_bnumber][_j].value;
+                    _result[_count] =  bets[_bnumber][_j].result;
+                    _prize[_count] =  bets[_bnumber][_j].prize;
+                    
+                    _count++;
+                }
+            }
+        }
+
+
+        return(_blockNumbers,_numbers,_values,_result,_prize);
+    }
+    
+
+    function draw(uint _blockNumber,uint _blockTimestamp) public onlyOwner returns (uint){
+        require(block.number >= curOpenBNumber + blockInterval);
+
+         
+        curOpenBNumber=_blockNumber;
+        uint result=_blockTimestamp % numberRange;
+        winResult[_blockNumber]=result;
+
+        for(uint _i=0;_i < bets[_blockNumber].length;_i++){
+             
+            
+            
+            if(bets[_blockNumber][_i].number==result){
+                bets[_blockNumber][_i].result = 1;
+                bets[_blockNumber][_i].prize = bets[_blockNumber][_i].value * odds;
+                
+                emit winnersEvt(_blockNumber,bets[_blockNumber][_i].addr,bets[_blockNumber][_i].value,bets[_blockNumber][_i].prize);
+
+                withdraw(bets[_blockNumber][_i].addr,bets[_blockNumber][_i].prize);
+
+            }else{
+                bets[_blockNumber][_i].result = 0;
+                bets[_blockNumber][_i].prize = 0;
+            }
+        }
+        
+        emit drawEvt(_blockNumber,curOpenBNumber);
+        
+        return result;
+    }
+    
+    function getWinners(uint _blockNumber) view public returns(address[],uint[]){
+        uint _count=winners[_blockNumber].length;
+        
+        address[] memory _addresses = new address[](_count);
+        uint[] memory _prize = new uint[](_count);
+        
+        uint _i=0;
+        for(_i=0;_i<_count;_i++){
+             
+            _prize[_i] = winners[_blockNumber][_i].prize;
+        }
+
+        return (_addresses,_prize);
+    }
+
+    function getWinResults(uint _blockNumber) view public returns(uint){
+        return winResult[_blockNumber];
+    }
+    
+    function withdraw(address _to,uint amount) public onlyOwner returns(bool){
+        require(address(this).balance.sub(amount) > 0);
+        _to.transfer(amount);
+        
+        emit withdrawEvt(_to,amount);
+        return true;
+    }
+    
+    
+    function invest() isHuman payable public returns(uint){
+        require(msg.value >= 0.1 ether,"Minima amoun:0.1 ether");
+        
+        Sponsors[msg.sender] = Sponsors[msg.sender].add(msg.value);
+        balanceOfSPS = balanceOfSPS.add(msg.value);
+        
+        if(!utils.inArray(SponsorAddresses,msg.sender)){
+            SponsorAddresses.push(msg.sender);
+            emit sponseEvt(msg.sender,msg.value);
+        }
+
+        return Sponsors[msg.sender];
+    }
+    
+    function distribute() public onlyOwner{
+        if(address(this).balance < reservefund){
+            return;
+        }
+        
+        uint availableProfits=address(this).balance.sub(reservefund);
+        uint prft1=availableProfits.mul(3 ether).div(10 ether);
+        uint prft2=availableProfits.sub(prft1);
+        
+        uint _val=0;
+        uint _i=0;
+        
+        for(_i=0;_i<SponsorAddresses.length;_i++){
+            _val = (prft1 * Sponsors[SponsorAddresses[_i]]) / (balanceOfSPS);
+            SponsorAddresses[_i].transfer(_val);
+        }
+        
+        uint w1p=prft2.mul(3 ether).div(10 ether);
+        
+        wallet1.transfer(w1p);
+        wallet2.transfer(prft2.sub(w1p));
+    }
+    
+    function sharesOfSPS() view public returns(uint,uint){
+        return (Sponsors[msg.sender],balanceOfSPS);
+    }
+    
+    function getAllSponsors() view public returns(address[],uint[],uint){
+        uint _i=0;
+        uint _c=0;
+        for(_i=0;_i<SponsorAddresses.length;_i++){
+            _c+=1;
+        }
+        
+        address[] memory addrs=new address[](_c);
+        uint[] memory amounts=new uint[](_c);
+
+        for(_i=0;_i<SponsorAddresses.length;_i++){
+            addrs[_i]=SponsorAddresses[_i];
+            amounts[_i]=Sponsors[SponsorAddresses[_i]];
+        }
+        
+        return(addrs,amounts,balanceOfSPS);
+    }
+
+    function() payable isHuman() public {
+    }
+    
+  
+}
+
+library SafeMath {
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+    uint256 c = a / b;
+     
+    return c;
+  }
+
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+library utils{
+    function inArray(uint[] _arr,uint _val) internal pure returns(bool){
+        for(uint _i=0;_i< _arr.length;_i++){
+            if(_arr[_i]==_val){
+                return true;
+                break;
+            }
+        }
+        return false;
+    }
+    
+    function inArray(address[] _arr,address _val) internal pure returns(bool){
+        for(uint _i=0;_i< _arr.length;_i++){
+            if(_arr[_i]==_val){
+                return true;
+                break;
+            }
+        }
+        return false;
+    }
+}

smart_contract_dataset/block number dependency/164.sol

@@ -0,0 +1,167 @@
+pragma solidity ^0.4.24;
+contract BREBuy {
+    
+    struct ContractParam {
+        uint32  totalSize ; 
+        uint256 singlePrice;
+        uint8  pumpRate;
+        bool hasChange;
+    }
+    
+    address owner = 0x0;
+    uint32  gameIndex = 0;
+    uint256 totalPrice= 0;
+    bool isLock = false;
+    ContractParam public setConfig;
+    ContractParam public curConfig;
+    
+    address[] public addressArray = new address[](0);
+                    
+    event openLockEvent();
+    event addPlayerEvent(uint32 gameIndex,address player);
+    event gameOverEvent(uint32 gameIndex,uint32 totalSize,uint256 singlePrice,uint8 pumpRate,address winAddr,uint overTime);
+    event stopGameEvent(uint totalBalace,uint totalSize,uint price);
+          
+     
+    constructor ( uint32 _totalSize,
+                  uint256 _singlePrice
+    )  public  {
+        owner = msg.sender;
+        setConfig = ContractParam(_totalSize,_singlePrice * 1 finney ,5,false);
+        curConfig = ContractParam(_totalSize,_singlePrice * 1 finney ,5,false);
+        startNewGame();
+    }
+
+    modifier onlyOwner {
+        require(msg.sender == owner,"only owner can call this function");
+        _;
+    }
+    
+     modifier notLock {
+        require(isLock == false,"contract current is lock status");
+        _;
+    }
+    
+    function isNotContract(address addr) private view returns (bool) {
+        uint size;
+        assembly { size := extcodesize(addr) }
+        return size <= 0;
+    }
+
+    function updateLock(bool b) onlyOwner public {
+        
+        require(isLock != b," updateLock new status == old status");
+       
+        isLock = b;
+       
+        if(isLock) {
+            stopGame();
+        }else{
+            startNewGame();
+            emit openLockEvent();
+        }
+    }
+    
+    function stopGame() onlyOwner private {
+      
+      if(addressArray.length <= 0) {
+          return;
+      }  
+      uint totalBalace = address(this).balance;
+      uint price = totalBalace / addressArray.length;
+      for(uint i = 0; i < addressArray.length; i++) {
+          address curPlayer =  addressArray[i];
+          curPlayer.transfer(price);
+      }
+      emit stopGameEvent(totalBalace,addressArray.length,price);
+      addressArray.length=0;
+    }
+
+    function transferOwnership(address newOwner) onlyOwner public {
+        if (newOwner != address(0)) {
+            owner = newOwner;
+        }
+    }
+    
+    function changeConfig( uint32 _totalSize,uint256 _singlePrice,uint8 _pumpRate) onlyOwner public payable {
+    
+        curConfig.hasChange = true;
+        if(setConfig.totalSize != _totalSize) {
+            setConfig.totalSize = _totalSize;
+        }
+        if(setConfig.pumpRate  != _pumpRate){
+            setConfig.pumpRate  = _pumpRate;
+        }
+        if(setConfig.singlePrice != _singlePrice * 1 finney){
+            setConfig.singlePrice = _singlePrice * 1 finney;
+        }
+    }
+    
+    function startNewGame() private {
+        
+        gameIndex++;
+        if(curConfig.hasChange) {
+            if(curConfig.totalSize   != setConfig.totalSize) {
+                curConfig.totalSize   = setConfig.totalSize;
+            }
+            if(curConfig.singlePrice != setConfig.singlePrice){
+               curConfig.singlePrice = setConfig.singlePrice; 
+            }
+            if( curConfig.pumpRate    != setConfig.pumpRate) {
+                curConfig.pumpRate    = setConfig.pumpRate;
+            }
+            curConfig.hasChange = false;
+        }
+        addressArray.length=0;
+    }
+    
+    function getGameInfo() public view returns  (uint256,uint32,uint256,uint8,address[],uint256,bool)  {
+        return (gameIndex,
+                curConfig.totalSize,
+                curConfig.singlePrice,
+                curConfig.pumpRate,
+                addressArray,
+                totalPrice,
+                isLock);
+    }
+    
+    function gameResult() private {
+            
+      uint index  = getRamdon();
+      address lastAddress = addressArray[index];
+      uint totalBalace = address(this).balance;
+      uint giveToOwn   = totalBalace * curConfig.pumpRate / 100;
+      uint giveToActor = totalBalace - giveToOwn;
+      owner.transfer(giveToOwn);
+      lastAddress.transfer(giveToActor);
+      emit gameOverEvent(
+                    gameIndex,
+                    curConfig.totalSize,
+                    curConfig.singlePrice,
+                    curConfig.pumpRate,
+                    lastAddress,
+                    now);
+    }
+    
+    function getRamdon() private view returns (uint) {
+      bytes32 ramdon = keccak256(abi.encodePacked(ramdon,now,blockhash(block.number-1)));
+      for(uint i = 0; i < addressArray.length; i++) {
+            ramdon = keccak256(abi.encodePacked(ramdon,now, addressArray[i]));
+      }
+      uint index  = uint(ramdon) % addressArray.length;
+      return index;
+    }
+    
+    function() notLock payable public{
+        require(isNotContract(msg.sender),"Contract not call addPlayer");
+        require(msg.value == curConfig.singlePrice,"msg.value error");
+        totalPrice = totalPrice + msg.value;
+        addressArray.push(msg.sender);
+       
+        emit addPlayerEvent(gameIndex,msg.sender);
+        if(addressArray.length >= curConfig.totalSize) {
+            gameResult();
+            startNewGame();
+        }
+    }
+}

smart_contract_dataset/block number dependency/1673.sol

@@ -0,0 +1,466 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+    function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+contract ZTHInterface {
+    function transfer(address _to, uint _value) public returns (bool);
+    function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zlots is ZTHReceivingContract {
+    using SafeMath for uint;
+
+    address private owner;
+    address private bankroll;
+
+     
+    uint  totalSpins;
+    uint  totalZTHWagered;
+
+     
+    uint contractBalance;
+
+     
+    bool    public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+    ZTHInterface private     ZTHTKN;
+
+    mapping (uint => bool) validTokenBet;
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHJackpot(address _wagerer, uint _block);             
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreeGreenPyramids(address _wagerer, uint _block);     
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeWhitePyramids(address _wagerer, uint _block);     
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoGreenPyramids(address _wagerer, uint _block);       
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoWhitePyramids(address _wagerer, uint _block);       
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    modifier onlyBankroll {
+        require(msg.sender == bankroll);
+        _;
+    }
+
+    modifier onlyOwnerOrBankroll {
+        require(msg.sender == owner || msg.sender == bankroll);
+        _;
+    }
+
+     
+    modifier gameIsActive {
+        require(gameActive == true);
+        _;
+    }
+
+    constructor(address ZethrAddress, address BankrollAddress) public {
+
+         
+        ZTHTKNADDR = ZethrAddress;
+        ZTHBANKROLL = BankrollAddress;
+
+         
+        owner         = msg.sender;
+        bankroll      = ZTHBANKROLL;
+
+         
+        ZTHTKN = ZTHInterface(ZTHTKNADDR);
+        ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
+        
+         
+        ZTHTKN.approve(owner, 2**256 - 1);
+
+         
+        validTokenBet[5e18]  = true;
+        validTokenBet[10e18] = true;
+        validTokenBet[25e18] = true;
+        validTokenBet[50e18] = true;
+
+        gameActive  = true;
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function tokenFallback(address _from, uint _value, bytes  ) public returns (bool){
+        if (_from == bankroll) {
+           
+          contractBalance = contractBalance.add(_value);    
+          return true;
+        } else {
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn);
+            return true;
+        }
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn) private {
+
+        require(gameActive);
+        require(_zthToken(msg.sender));
+        require(validTokenBet[_tkn.value]);
+        require(jackpotGuard(_tkn.value));
+
+        require(_tkn.value < ((2 ** 200) - 1));    
+        require(block.number < ((2 ** 48) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+
+        contractBalance = contractBalance.add(_wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+
+    }
+
+      
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+      return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 9999;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target);
+        }
+
+        if (result > 476661) {
+           
+          emit Loss(target, spin.blockn);
+          emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else 
+            if (result < 1) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 500);
+                category = 1;
+                emit ThreeMoonJackpot(target, spin.blockn);
+            } else 
+                if (result < 298) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 232);
+                    category = 2;
+                    emit TwoMoonPrize(target, spin.blockn);
+            } else 
+                if (result < 3127) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
+                    category = 3;
+                    emit ZTHJackpot(target, spin.blockn);
+                    
+            } else 
+                if (result < 5956) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 4;
+                    emit ThreeZSymbols(target, spin.blockn);
+            } else 
+                if (result < 8785) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 5;
+                    emit ThreeTSymbols(target, spin.blockn);
+            } else 
+                if (result < 11614) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 6;
+                    emit ThreeHSymbols(target, spin.blockn);
+            } else 
+                if (result < 14443) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 50);
+                    category = 7;
+                    emit ThreeEtherIcons(target, spin.blockn);
+            } else 
+                if (result < 17272) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 40);
+                    category = 8;
+                    emit ThreeGreenPyramids(target, spin.blockn);
+            } else 
+                if (result < 20101) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 9;
+                    emit ThreeGoldPyramids(target, spin.blockn);
+            } else 
+                if (result < 22929) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 10;
+                    emit ThreeWhitePyramids(target, spin.blockn);
+            } else 
+                if (result < 52332) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
+                    category = 11;
+                    emit OneMoonPrize(target, spin.blockn);
+            } else 
+                if (result < 120225) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                    category = 12;
+                    emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else 
+                if (result < 171146) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 13;
+                    emit TwoZSymbols(target, spin.blockn);
+            } else 
+                if (result < 222067) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 14;
+                    emit TwoTSymbols(target, spin.blockn);
+            } else 
+                if (result < 272988) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 15;
+                    emit TwoHSymbols(target, spin.blockn);
+            } else 
+                if (result < 323909) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
+                    category = 16;
+                    emit TwoEtherIcons(target, spin.blockn);
+            } else 
+                if (result < 374830) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
+                    category = 17;
+                    emit TwoGreenPyramids(target, spin.blockn);
+            } else 
+                if (result < 425751) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
+                    category = 18;
+                    emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 2);
+                    category = 19;
+                    emit TwoWhitePyramids(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            contractBalance = contractBalance.sub(profit);
+            ZTHTKN.transfer(target, profit);
+            
+         
+        playerSpins[target] = playerSpin(uint200(0), uint48(0));
+        return result;
+    }   
+
+     
+     
+     
+     
+    function jackpotGuard(uint _wager)
+        private
+        view
+        returns (bool)
+    {
+        uint maxProfit = SafeMath.mul(_wager, 500);
+        uint ninetyContractBalance = SafeMath.mul(SafeMath.div(contractBalance, 10), 9);
+        return (maxProfit <= ninetyContractBalance);
+    }
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function balanceOf() public view returns (uint) {
+        return contractBalance;
+    }
+
+    function addNewBetAmount(uint _tokenAmount)
+        public
+        onlyOwner
+    {
+        validTokenBet[_tokenAmount] = true;
+    }
+
+     
+    function pauseGame() public onlyOwner {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwner {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwner {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwner {
+        bankroll = _newBankroll;
+    }
+
+    function divertDividendsToBankroll()
+        public
+        onlyOwner
+    {
+        bankroll.transfer(address(this).balance);
+    }
+
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1698.sol

@@ -0,0 +1,247 @@
+pragma solidity ^0.4.12;
+ 
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+ 
+ 
+contract SafeMath {
+ 
+ 
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+ 
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+ 
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+ 
+}
+ 
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+ 
+ 
+ 
+contract StandardToken is Token {
+ 
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+ 
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+ 
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+ 
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+ 
+contract EVTCToken is StandardToken, SafeMath {
+ 
+     
+    string  public constant name = "EVTC";
+    string  public constant symbol = "ECoin";
+    uint256 public constant decimals = 18;
+    string  public version = "1.0";
+ 
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+ 
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+ 
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+    uint256 public tokenExchangeRate = 625;              
+ 
+     
+    event AllocateToken(address indexed _to, uint256 _value);    
+    event IssueToken(address indexed _to, uint256 _value);       
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+    event Migrate(address indexed _to, uint256 _value);
+ 
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+ 
+     
+    function EVTCToken(
+        address _ethFundDeposit,
+        uint256 _currentSupply)
+    {
+        ethFundDeposit = _ethFundDeposit;
+ 
+        isFunding = false;                            
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+ 
+        currentSupply = formatDecimals(_currentSupply);
+        totalSupply = formatDecimals(100000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+ 
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+ 
+     
+    function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
+        if (_tokenExchangeRate == 0) throw;
+        if (_tokenExchangeRate == tokenExchangeRate) throw;
+ 
+        tokenExchangeRate = _tokenExchangeRate;
+    }
+ 
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+ 
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+ 
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+ 
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+ 
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+ 
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+ 
+     
+    function setMigrateContract(address _newContractAddr) isOwner external {
+        if (_newContractAddr == newContractAddr) throw;
+        newContractAddr = _newContractAddr;
+    }
+ 
+     
+    function changeOwner(address _newFundDeposit) isOwner() external {
+        if (_newFundDeposit == address(0x0)) throw;
+        ethFundDeposit = _newFundDeposit;
+    }
+ 
+     
+    function migrate() external {
+        if(isFunding) throw;
+        if(newContractAddr == address(0x0)) throw;
+ 
+        uint256 tokens = balances[msg.sender];
+        if (tokens == 0) throw;
+ 
+        balances[msg.sender] = 0;
+        tokenMigrated = safeAdd(tokenMigrated, tokens);
+ 
+        IMigrationContract newContract = IMigrationContract(newContractAddr);
+        if (!newContract.migrate(msg.sender, tokens)) throw;
+ 
+        Migrate(msg.sender, tokens);                
+    }
+ 
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+ 
+     
+    function allocateToken (address _addr, uint256 _eth) isOwner external {
+        if (_eth == 0) throw;
+        if (_addr == address(0x0)) throw;
+ 
+        uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[_addr] += tokens;
+ 
+        AllocateToken(_addr, tokens);   
+    }
+ 
+     
+    function () payable {
+        if (!isFunding) throw;
+        if (msg.value == 0) throw;
+ 
+        if (block.number < fundingStartBlock) throw;
+        if (block.number > fundingStopBlock) throw;
+ 
+        uint256 tokens = safeMult(msg.value, tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[msg.sender] += tokens;
+ 
+        IssueToken(msg.sender, tokens);   
+    }
+}

smart_contract_dataset/block number dependency/1714.sol

@@ -0,0 +1,403 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+
+contract ZTHInterface {
+  function getFrontEndTokenBalanceOf(address who) public view returns (uint);
+  function transfer(address _to, uint _value) public returns (bool);
+  function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zethroll is ZTHReceivingContract {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber) {
+     require( calculateProfit(_betSize, _playerNumber) < maxProfit
+             && _betSize >= minBet
+             && _playerNumber > minNumber
+             && _playerNumber < maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 99;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+  address public ZethrBankroll;
+  address public ZTHTKNADDR;
+
+  ZTHInterface public ZTHTKN;
+
+  uint public contractBalance;
+  uint public houseEdge;
+  uint public maxProfit;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address zthtknaddr, address zthbankrolladdr) public {
+     
+    owner = msg.sender;
+
+     
+    ZTHTKN = ZTHInterface(zthtknaddr);
+    ZTHTKNADDR = zthtknaddr;
+
+     
+    ZethrBankroll = zthbankrolladdr;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+
+     
+    ZTHTKN.approve(zthbankrolladdr, MAX_INT);
+  }
+
+  function() public payable {}  
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint200 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+  function _playerRollDice(uint _rollUnder, TKN _tkn) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder)
+  {
+    require(_tkn.value < ((2 ** 200) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+
+     
+     
+
+     
+    require(_zthToken(msg.sender));
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(false, _tkn.sender);
+    }
+
+     
+    roll.blockn = uint48(block.number);
+    roll.tokenValue = uint200(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(true, msg.sender);
+  }
+
+   
+  function _finishBet(bool delete_it, address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(99, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+      
+        if (profit > maxProfit){
+            profit = maxProfit;
+        }
+
+       
+      contractBalance = contractBalance.sub(profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit();
+
+
+         
+        playerRolls[target] = playerRoll(uint200(0), uint48(0), uint8(0));
+
+
+       
+      ZTHTKN.transfer(target, profit + roll.tokenValue);
+      
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      contractBalance = contractBalance.add(roll.tokenValue);
+
+        playerRolls[target] = playerRoll(uint200(0), uint48(0), uint8(0));
+       
+       
+
+       
+      setMaxProfit();
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
+    require(msg.sender == ZTHTKNADDR);
+    if (_from == ZethrBankroll) {
+       
+      contractBalance = contractBalance.add(_value);
+
+       
+      uint oldMaxProfit = maxProfit;
+      setMaxProfit();
+
+      emit MaxProfitChanged(oldMaxProfit, maxProfit);
+      return true;
+
+    } else {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn);
+    }
+
+    return true;
+  }
+
+   
+  function setMaxProfit() internal {
+    emit CurrentContractBalance(contractBalance);
+    maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance) public
+  onlyOwner
+  {
+    contractBalance = newContractBalance;
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit();
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerTransferZTH(address sendTo, uint amount) public
+  onlyOwner
+  {
+     
+    contractBalance = contractBalance.sub(amount);
+
+     
+    setMaxProfit();
+    require(ZTHTKN.transfer(sendTo, amount));
+    emit LogOwnerTransfer(sendTo, amount);
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerSetBankroll(address newBankroll) public
+  onlyOwner
+  {
+    ZTHTKN.approve(ZethrBankroll, 0);
+    ZethrBankroll = newBankroll;
+    ZTHTKN.approve(newBankroll, MAX_INT);
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+    ZTHTKN.transfer(owner, contractBalance);
+    selfdestruct(owner);
+  }
+  
+  function dumpdivs() public{
+      ZethrBankroll.transfer(address(this).balance);
+  }
+
+  function _zthToken(address _tokenContract) private view returns (bool) {
+    return _tokenContract == ZTHTKNADDR;
+     
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/173.sol

@@ -0,0 +1,247 @@
+pragma solidity ^0.4.24;
+ 
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+ 
+ 
+contract SafeMath {
+ 
+ 
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+ 
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+ 
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+ 
+}
+ 
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+ 
+ 
+ 
+contract StandardToken is Token {
+ 
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+ 
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+ 
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+ 
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+ 
+contract EBBToken is StandardToken, SafeMath {
+ 
+     
+    string  public constant name = "易宝币";
+    string  public constant symbol = "EBB";
+    uint256 public constant decimals = 18;
+    string  public version = "1.0";
+ 
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+ 
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+ 
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+    uint256 public tokenExchangeRate = 5963;              
+ 
+     
+    event AllocateToken(address indexed _to, uint256 _value);    
+    event IssueToken(address indexed _to, uint256 _value);       
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+    event Migrate(address indexed _to, uint256 _value);
+ 
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+ 
+     
+    function EBBToken(
+        address _ethFundDeposit,
+        uint256 _currentSupply)
+    {
+        ethFundDeposit = _ethFundDeposit;
+ 
+        isFunding = false;                            
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+ 
+        currentSupply = formatDecimals(_currentSupply);
+        totalSupply = formatDecimals(1600000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+ 
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+ 
+     
+    function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
+        if (_tokenExchangeRate == 0) throw;
+        if (_tokenExchangeRate == tokenExchangeRate) throw;
+ 
+        tokenExchangeRate = _tokenExchangeRate;
+    }
+ 
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+ 
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+ 
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+ 
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+ 
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+ 
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+ 
+     
+    function setMigrateContract(address _newContractAddr) isOwner external {
+        if (_newContractAddr == newContractAddr) throw;
+        newContractAddr = _newContractAddr;
+    }
+ 
+     
+    function changeOwner(address _newFundDeposit) isOwner() external {
+        if (_newFundDeposit == address(0x0)) throw;
+        ethFundDeposit = _newFundDeposit;
+    }
+ 
+     
+    function migrate() external {
+        if(isFunding) throw;
+        if(newContractAddr == address(0x0)) throw;
+ 
+        uint256 tokens = balances[msg.sender];
+        if (tokens == 0) throw;
+ 
+        balances[msg.sender] = 0;
+        tokenMigrated = safeAdd(tokenMigrated, tokens);
+ 
+        IMigrationContract newContract = IMigrationContract(newContractAddr);
+        if (!newContract.migrate(msg.sender, tokens)) throw;
+ 
+        Migrate(msg.sender, tokens);                
+    }
+ 
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+ 
+     
+    function allocateToken (address _addr, uint256 _eth) isOwner external {
+        if (_eth == 0) throw;
+        if (_addr == address(0x0)) throw;
+ 
+        uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[_addr] += tokens;
+ 
+        AllocateToken(_addr, tokens);   
+    }
+ 
+     
+    function () payable {
+        if (!isFunding) throw;
+        if (msg.value == 0) throw;
+ 
+        if (block.number < fundingStartBlock) throw;
+        if (block.number > fundingStopBlock) throw;
+ 
+        uint256 tokens = safeMult(msg.value, tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[msg.sender] += tokens;
+ 
+        IssueToken(msg.sender, tokens);   
+    }
+}

smart_contract_dataset/block number dependency/1761.sol

@@ -0,0 +1,490 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+    function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+contract ZTHInterface {
+    function transfer(address _to, uint _value) public returns (bool);
+    function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zlots is ZTHReceivingContract {
+    using SafeMath for uint;
+
+    address private owner;
+    address private bankroll;
+
+     
+    uint  totalSpins;
+    uint  totalZTHWagered;
+
+     
+    uint contractBalance;
+
+     
+    bool    public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+    ZTHInterface private     ZTHTKN;
+
+    mapping (uint => bool) validTokenBet;
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        uint _category,
+        bool _win
+    );
+
+     
+    event Loss(address _wagerer, uint _block);                   
+    event ThreeMoonJackpot(address _wagerer, uint _block);       
+    event TwoMoonPrize(address _wagerer, uint _block);           
+    event ZTHJackpot(address _wagerer, uint _block);             
+    event ThreeZSymbols(address _wagerer, uint _block);          
+    event ThreeTSymbols(address _wagerer, uint _block);          
+    event ThreeHSymbols(address _wagerer, uint _block);          
+    event ThreeEtherIcons(address _wagerer, uint _block);        
+    event ThreeGreenPyramids(address _wagerer, uint _block);     
+    event ThreeGoldPyramids(address _wagerer, uint _block);      
+    event ThreeWhitePyramids(address _wagerer, uint _block);     
+    event OneMoonPrize(address _wagerer, uint _block);           
+    event OneOfEachPyramidPrize(address _wagerer, uint _block);  
+    event TwoZSymbols(address _wagerer, uint _block);            
+    event TwoTSymbols(address _wagerer, uint _block);            
+    event TwoHSymbols(address _wagerer, uint _block);            
+    event TwoEtherIcons(address _wagerer, uint _block);          
+    event TwoGreenPyramids(address _wagerer, uint _block);       
+    event TwoGoldPyramids(address _wagerer, uint _block);        
+    event TwoWhitePyramids(address _wagerer, uint _block);       
+
+    event ReturnBet(
+        address _wagerer
+    );
+
+    event TwoAndAHalfXMultiplier(
+        address _wagerer
+    );
+
+    event OneAndAHalfXMultiplier(
+        address _wagerer
+    );
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    modifier onlyBankroll {
+        require(msg.sender == bankroll);
+        _;
+    }
+
+    modifier onlyOwnerOrBankroll {
+        require(msg.sender == owner || msg.sender == bankroll);
+        _;
+    }
+
+     
+    modifier gameIsActive {
+        require(gameActive == true);
+        _;
+    }
+
+    constructor(address ZethrAddress, address BankrollAddress) public {
+
+         
+        ZTHTKNADDR = ZethrAddress;
+        ZTHBANKROLL = BankrollAddress;
+
+         
+        owner         = msg.sender;
+        bankroll      = ZTHBANKROLL;
+
+         
+        ZTHTKN = ZTHInterface(ZTHTKNADDR);
+        ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
+        
+         
+        ZTHTKN.approve(owner, 2**256 - 1);
+
+         
+        validTokenBet[5e18]  = true;
+        validTokenBet[10e18] = true;
+        validTokenBet[25e18] = true;
+        validTokenBet[50e18] = true;
+
+        gameActive  = true;
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function tokenFallback(address _from, uint _value, bytes  ) public returns (bool){
+        if (_from == bankroll) {
+           
+          contractBalance = contractBalance.add(_value);    
+          return true;
+        } else {
+            TKN memory          _tkn;
+            _tkn.sender       = _from;
+            _tkn.value        = _value;
+            _spinTokens(_tkn);
+            return true;
+        }
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn) private {
+
+        require(gameActive);
+        require(_zthToken(msg.sender));
+        require(validTokenBet[_tkn.value]);
+        require(jackpotGuard(_tkn.value));
+
+        require(_tkn.value < ((2 ** 200) - 1));    
+        require(block.number < ((2 ** 48) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+
+        contractBalance = contractBalance.add(_wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+
+    }
+
+      
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+      return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+        uint category = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 9999;  
+        } else {
+
+           
+           
+          result = random(1000000, spin.blockn, target);
+        }
+
+        if (result > 476661) {
+           
+          emit Loss(target, spin.blockn);
+          emit LogResult(target, result, profit, spin.tokenValue, category, false);
+        } else {
+            if (result < 1) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 500);
+                category = 1;
+                emit ThreeMoonJackpot(target, spin.blockn);
+            } else {
+                if (result < 298) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 232);
+                    category = 2;
+                    emit TwoMoonPrize(target, spin.blockn);
+            } else {
+                if (result < 3127) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
+                    category = 3;
+                    emit ZTHJackpot(target, spin.blockn);
+                    
+            } else {
+                if (result < 5956) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 4;
+                    emit ThreeZSymbols(target, spin.blockn);
+            } else {
+                if (result < 8785) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 5;
+                    emit ThreeTSymbols(target, spin.blockn);
+            } else {
+                if (result < 11614) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 25);
+                    category = 6;
+                    emit ThreeHSymbols(target, spin.blockn);
+            } else {
+                if (result < 14443) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 50);
+                    category = 7;
+                    emit ThreeEtherIcons(target, spin.blockn);
+            } else {
+                if (result < 17272) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 40);
+                    category = 8;
+                    emit ThreeGreenPyramids(target, spin.blockn);
+            } else {
+                if (result < 20101) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 9;
+                    emit ThreeGoldPyramids(target, spin.blockn);
+            } else {
+                if (result < 22929) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 20);
+                    category = 10;
+                    emit ThreeWhitePyramids(target, spin.blockn);
+            } else {
+                if (result < 52332) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
+                    category = 11;
+                    emit OneMoonPrize(target, spin.blockn);
+            } else {
+                if (result < 120225) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
+                    category = 12;
+                    emit OneOfEachPyramidPrize(target, spin.blockn);
+            } else {
+                if (result < 171146) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 13;
+                    emit TwoZSymbols(target, spin.blockn);
+            } else {
+                if (result < 222067) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 14;
+                    emit TwoTSymbols(target, spin.blockn);
+            } else {
+                if (result < 272988) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
+                    category = 15;
+                    emit TwoHSymbols(target, spin.blockn);
+            } else {
+                if (result < 323909) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
+                    category = 16;
+                    emit TwoEtherIcons(target, spin.blockn);
+            } else {
+                if (result < 374830) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
+                    category = 17;
+                    emit TwoGreenPyramids(target, spin.blockn);
+            } else {
+                if (result < 425751) {
+                     
+                    profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
+                    category = 18;
+                    emit TwoGoldPyramids(target, spin.blockn);
+            } else {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 2);
+                    category = 19;
+                    emit TwoWhitePyramids(target, spin.blockn);
+            }
+
+            emit LogResult(target, result, profit, spin.tokenValue, category, true);
+            contractBalance = contractBalance.sub(profit);
+            ZTHTKN.transfer(target, profit);
+            
+         
+        }}}}}}}}}}}}}}}}}}
+            
+        playerSpins[target] = playerSpin(uint200(0), uint48(0));
+        return result;
+    }   
+
+     
+     
+     
+     
+    function jackpotGuard(uint _wager)
+        private
+        view
+        returns (bool)
+    {
+        uint maxProfit = SafeMath.mul(_wager, 500);
+        uint ninetyContractBalance = SafeMath.mul(SafeMath.div(contractBalance, 10), 9);
+        return (maxProfit <= ninetyContractBalance);
+    }
+
+     
+     
+    function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function balanceOf() public view returns (uint) {
+        return contractBalance;
+    }
+
+    function addNewBetAmount(uint _tokenAmount)
+        public
+        onlyOwner
+    {
+        validTokenBet[_tokenAmount] = true;
+    }
+
+     
+    function pauseGame() public onlyOwner {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwner {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwner {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwner {
+        bankroll = _newBankroll;
+    }
+
+     
+    function divertDividendsToBankroll()
+        public
+        onlyOwner
+    {
+        bankroll.transfer(address(this).balance);
+    }
+
+    function testingSelfDestruct()
+        public
+        onlyOwner
+    {
+         
+        ZTHTKN.transfer(owner, contractBalance);
+        selfdestruct(owner);
+    }
+    
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/1791.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/1986.sol

@@ -0,0 +1,1250 @@
+pragma solidity ^0.4.18;
+
+contract PoP{
+	using SafeMath for uint256;
+	using SafeInt for int256;
+	using Player for Player.Data;
+	using BettingRecordArray for BettingRecordArray.Data;
+	using WrappedArray for WrappedArray.Data;
+	using FixedPoint for FixedPoint.Data;
+
+	 
+	string public name;
+  	string public symbol;
+  	uint8 public decimals;
+  	address private author;
+	
+  	 
+  	event Bet(address player, uint256 betAmount, uint256 betNumber, uint256 gameNumber);
+	event Withdraw(address player, uint256 amount, uint256 numberOfRecordsProcessed);
+	event EndGame(uint256 currentGameNumber);	
+
+	 
+	event Transfer(address indexed from, address indexed to, uint256 value);
+	event Approval(address indexed owner, address indexed spender, uint256 value);
+	event Burn(address indexed burner, uint256 value);
+	event Mined(address indexed miner, uint256 value);
+
+	 
+	function PoP() public {
+		name = "PopCoin"; 
+    	symbol = "PoP"; 
+    	decimals = 18;
+    	author = msg.sender;
+    	totalSupply_ = 10000000 * 10 ** uint256(decimals);
+    	lastBetBlockNumber = 0;
+    	currentGameNumber = 0;
+    	currentPot = 0;
+    	initialSeed = 0;
+		minimumWager = kBaseMinBetSize.toUInt256Raw();
+    	minimumNumberOfBlocksToEndGame = kLowerBoundBlocksTillGameEnd.add(kUpperBoundBlocksTillGameEnd).toUInt256Raw();
+    	gameHasStarted = false;
+    	currentMiningDifficulty = FixedPoint.fromInt256(kStartingGameMiningDifficulty);
+		unPromisedSupplyAtStartOfCurrentGame_ = totalSupply_;
+		nextGameMaxBlock = kUpperBoundBlocksTillGameEnd;
+		nextGameMinBlock = kLowerBoundBlocksTillGameEnd;
+    	currentGameInitialMinBetSize = kBaseMinBetSize;
+	}
+
+
+	 
+	FixedPoint.Data _2pi = FixedPoint.Data({val: 26986075409});
+	FixedPoint.Data _pi = FixedPoint.Data({val: 13493037704});
+	FixedPoint.Data frontWindowAdjustmentRatio = FixedPoint.fromFraction(14, 10);  
+	FixedPoint.Data backWindowAdjustmentRatio = FixedPoint.fromFraction(175, 100);  
+	FixedPoint.Data kBackPayoutEndPointInitial = FixedPoint.fromFraction(1, 2);
+	FixedPoint.Data kFrontPayoutStartPointInitial = FixedPoint.fromFraction(1, 2);
+	uint256 constant kPercentToTakeAsRake = 3;  
+	uint256 constant kPercentToTakeAsSeed = 9;  
+	uint256 constant kDeveloperMiningPower = 30;  
+	uint256 constant kTotalPercent = 100; 
+	uint8 constant kStartingGameMiningDifficulty = 1;
+	uint8 constant kDifficultyWindow = 10;  
+	FixedPoint.Data kDifficultyDropOffFactor = FixedPoint.fromFraction(8, 10);  
+	uint256 constant kWeiConstant = 10 ** 18;
+	FixedPoint.Data kExpectedFirstGameSize = FixedPoint.fromInt256(Int256(10 * kWeiConstant));
+	FixedPoint.Data kExpectedPopCoinToBePromisedPercent = FixedPoint.fromFraction(1, 1000);  
+	FixedPoint.Data kLowerBoundBlocksTillGameEnd = FixedPoint.fromInt256(6);  
+	FixedPoint.Data kUpperBoundBlocksTillGameEnd = FixedPoint.fromInt256(80);  
+	FixedPoint.Data kBaseMinBetSize = FixedPoint.fromInt256(Int256(kWeiConstant/1000));  
+	FixedPoint.Data kMaxPopMiningPotMultiple = FixedPoint.fromFraction(118709955, 1000000);  
+
+
+	 
+	uint256 public lastBetBlockNumber;
+	uint256 public minimumNumberOfBlocksToEndGame;
+	uint256 public currentPot;
+	uint256 public currentGameNumber;
+	FixedPoint.Data currentMiningDifficulty;
+	uint256 public initialSeed;
+
+
+	 
+	mapping (address => Player.Data) playerCollection;
+	BettingRecordArray.Data currentGameBettingRecords;
+	WrappedArray.Data gameMetaData;
+	mapping (address => uint256) playerInternalWallet;
+	FixedPoint.Data public initialBankrollGrowthAmount;  
+	FixedPoint.Data nextGameInitialMinBetSize;
+	FixedPoint.Data currentGameInitialMinBetSize;
+	FixedPoint.Data nextGameMaxBlock;
+	FixedPoint.Data nextGameMinBlock;
+	uint256 bonusSeed;
+	uint256 minimumWager;
+	uint256 currentBetNumber;
+
+	 
+	mapping(address => uint256) popBalances;
+	mapping (address => mapping (address => uint256)) internal allowed;
+	uint256 totalSupply_;
+	uint256 supplyMined_;
+	uint256 supplyBurned_;
+	uint256 unPromisedSupplyAtStartOfCurrentGame_;
+	bool gameHasStarted;
+
+	function startGame () payable public {
+		require (msg.sender == author);
+		require (msg.value > 0);
+		require (gameHasStarted == false);
+		
+		initialSeed = initialSeed.add(msg.value);
+		currentPot = initialSeed;
+		gameHasStarted = true;
+	}
+
+	function updateNextGameMinAndMaxBlockUntilGameEnd (uint256 maxBlocks, uint256 minBlocks) public {
+		require (msg.sender == author);
+		require (maxBlocks > 0);
+		require (minBlocks > 0);
+		FixedPoint.Data memory nextMaxBlock = FixedPoint.fromInt256(Int256(maxBlocks));
+		FixedPoint.Data memory nextMinBlock = FixedPoint.fromInt256(Int256(minBlocks));
+		require(nextMaxBlock.cmp(kUpperBoundBlocksTillGameEnd.mul(FixedPoint.fromInt256(2))) != 1);
+		require(nextMaxBlock.cmp(kUpperBoundBlocksTillGameEnd.div(FixedPoint.fromInt256(2))) != -1);
+		require(nextMinBlock.cmp(kLowerBoundBlocksTillGameEnd.mul(FixedPoint.fromInt256(2))) != 1);
+		require(nextMaxBlock.cmp(kLowerBoundBlocksTillGameEnd.div(FixedPoint.fromInt256(2))) != -1);
+
+		nextGameMaxBlock = FixedPoint.fromInt256(Int256(maxBlocks));
+		nextGameMinBlock = FixedPoint.fromInt256(Int256(minBlocks));
+	}
+
+	function addToRakePool () public payable{
+		assert (msg.value > 0);
+		playerInternalWallet[this] = playerInternalWallet[this].add(msg.value);
+	}
+
+	 
+	function bet () payable public {
+		 
+		require(msg.value >= minimumWager); 
+		require(gameHasStarted);
+
+		uint256 betAmount = msg.value;
+
+		 
+		betAmount = betAmountAfterRakeHasBeenWithdrawnAndProcessed(betAmount);
+
+		if((block.number.sub(lastBetBlockNumber) >= minimumNumberOfBlocksToEndGame) && (lastBetBlockNumber != 0)) {
+			processEndGame(betAmount);
+		} else if (lastBetBlockNumber == 0) {
+			initialBankrollGrowthAmount = FixedPoint.fromInt256(Int256(betAmount.add(initialSeed)));
+		}
+
+		emit Bet(msg.sender, betAmount, currentBetNumber, currentGameNumber);
+
+		Player.BettingRecord memory newBetRecord = Player.BettingRecord(msg.sender, currentGameNumber, betAmount, currentBetNumber, currentPot.sub(initialSeed), 0, 0, true); 
+
+		Player.Data storage currentPlayer = playerCollection[msg.sender];
+
+		currentPlayer.insertBettingRecord(newBetRecord);
+
+		Player.BettingRecord memory oldGameUnprocessedBettingRecord = currentGameBettingRecords.getNextRecord();
+
+		currentGameBettingRecords.pushRecord(newBetRecord);
+
+		if(oldGameUnprocessedBettingRecord.isActive == true) {
+			processBettingRecord(oldGameUnprocessedBettingRecord);
+		}
+
+		currentPot = currentPot.add(betAmount);
+		currentBetNumber = currentBetNumber.add(1);
+		lastBetBlockNumber = block.number;
+		FixedPoint.Data memory currentGameSize = FixedPoint.fromInt256(Int256(currentPot));
+		FixedPoint.Data memory expectedGameSize = currentMiningDifficulty.mul(kExpectedFirstGameSize);
+		minimumNumberOfBlocksToEndGame = calcNumberOfBlocksUntilGameEnds(currentGameSize, expectedGameSize).toUInt256Raw();
+		minimumWager = calcMinimumBetSize(currentGameSize, expectedGameSize).toUInt256Raw();
+	}
+
+	function getMyBetRecordCount() public view returns(uint256) {
+		Player.Data storage currentPlayer = playerCollection[msg.sender];
+		return currentPlayer.unprocessedBettingRecordCount();
+	}
+	
+	
+	function playerPopMining(uint256 recordIndex, bool onlyCurrentGame) public view returns(uint256) {
+		Player.Data storage currentPlayer = playerCollection[msg.sender];
+		return computeAmountToMineForBettingRecord(currentPlayer.getBettingRecordAtIndex(recordIndex), onlyCurrentGame).mul(kTotalPercent - kDeveloperMiningPower).div(kTotalPercent);
+	}
+
+	function getBetRecord(uint256 recordIndex) public view returns(uint256, uint256, uint256) {
+		Player.Data storage currentPlayer = playerCollection[msg.sender];
+		Player.BettingRecord memory bettingRecord = currentPlayer.getBettingRecordAtIndex(recordIndex);
+		return (bettingRecord.gamePotBeforeBet, bettingRecord.wagerAmount, bettingRecord.gameId);
+	}
+
+	function withdraw (uint256 withdrawCount) public returns(bool res) {
+		Player.Data storage currentPlayer = playerCollection[msg.sender];
+
+		uint256 playerBettingRecordCount = currentPlayer.unprocessedBettingRecordCount();
+		uint256 numberOfIterations = withdrawCount < playerBettingRecordCount ? withdrawCount : playerBettingRecordCount;
+		if(numberOfIterations == 0) {return;}
+
+		numberOfIterations = numberOfIterations.add(1);
+
+		for (uint256 i = 0 ; i < numberOfIterations; i = i.add(1)) {
+			Player.BettingRecord memory unprocessedRecord = currentPlayer.getNextRecord();
+			processBettingRecord(unprocessedRecord);
+		}
+
+		uint256 playerBalance = playerInternalWallet[msg.sender];
+
+		
+		playerInternalWallet[msg.sender] = 0;
+
+		if(playerBalance == 0) {
+			return true;
+		}
+
+		emit Withdraw(msg.sender, playerBalance, numberOfIterations);
+
+		if(!msg.sender.send(playerBalance)) {
+			 
+			playerInternalWallet[msg.sender] = playerBalance;
+			return false;
+		}
+		return true;
+	}
+
+
+	function getCurrentMiningDifficulty() public view returns(uint256){
+		return UInt256(currentMiningDifficulty.toInt256());
+	}
+
+	function getPlayerInternalWallet() public view returns(uint256) {
+		return playerInternalWallet[msg.sender];
+	}
+
+	function getWinningsForRecordId(uint256 recordIndex, bool onlyWithdrawable, bool onlyCurrentGame) public view returns(uint256) {
+		Player.Data storage currentPlayer = playerCollection[msg.sender];
+		Player.BettingRecord memory record = currentPlayer.getBettingRecordAtIndex(recordIndex);
+		if(onlyCurrentGame && record.gameId != currentGameNumber) {
+			return 0;
+		}
+		return getWinningsForRecord(record, onlyWithdrawable);
+	}
+
+	function getWinningsForRecord(Player.BettingRecord record, bool onlyWithdrawable) private view returns(uint256) {
+
+		if(onlyWithdrawable && recordIsTooNewToProcess(record)) {
+			return 0;
+		}
+
+		uint256 payout = getPayoutForPlayer(record).toUInt256Raw();
+		payout = payout.sub(amountToSeedNextRound(payout));
+		return payout.sub(record.withdrawnAmount);
+
+	}
+
+	function totalAmountRaked ()  public constant returns(uint256 res) {
+		return playerInternalWallet[this];
+	}
+
+	function betAmountAfterRakeHasBeenWithdrawnAndProcessed (uint256 betAmount) private returns(uint256 betLessRake){
+		uint256 amountToRake = amountToTakeAsRake(betAmount);
+		playerInternalWallet[this] = playerInternalWallet[this].add(amountToRake);
+		return betAmount.sub(amountToRake);
+	}
+	
+	function amountToSeedNextRound (uint256 value) private pure returns(uint256 res) {
+		return value.mul(kPercentToTakeAsSeed).div(kTotalPercent);
+	}
+
+	function addToBonusSeed () public payable {
+		require (msg.value > 0);
+		bonusSeed = bonusSeed.add(msg.value);
+	}
+	
+
+	function amountToTakeAsRake (uint256 value) private pure returns(uint256 res) {
+		return value.mul(kPercentToTakeAsRake).div(kTotalPercent);
+	}
+
+	function amountOfPopDeveloperShouldMine (uint256 value) private pure returns(uint256 res) {
+		return value.mul(kDeveloperMiningPower).div(kTotalPercent);
+	}
+
+	function processEndGame (uint256 lastBetAmount) private {
+		 
+		 
+		emit EndGame(currentGameNumber);
+		 
+		gameMetaData.push(WrappedArray.GameMetaDataElement(currentPot, initialSeed, initialBankrollGrowthAmount.toUInt256Raw(), unPromisedSupplyAtStartOfCurrentGame_, currentMiningDifficulty, true));
+
+		kUpperBoundBlocksTillGameEnd = nextGameMaxBlock;
+		kLowerBoundBlocksTillGameEnd = nextGameMinBlock;
+
+		unPromisedSupplyAtStartOfCurrentGame_ = unPromisedPop();
+
+		initialSeed = amountToSeedNextRound(currentPot).add(bonusSeed);
+		bonusSeed = 0;
+		currentPot = initialSeed;
+		currentMiningDifficulty = calcDifficulty();
+
+		 
+		initialBankrollGrowthAmount = FixedPoint.fromInt256(Int256(lastBetAmount.add(initialSeed)));
+
+		 
+		currentGameBettingRecords.resetIndex();
+
+		 
+		currentGameNumber = currentGameNumber.add(1);
+	}
+
+	function processBettingRecord (Player.BettingRecord record) private {
+		Player.Data storage currentPlayer = playerCollection[record.playerAddress];
+		if(currentPlayer.containsBettingRecordFromId(record.bettingRecordId) == false) {
+			return;
+		}
+		 
+		Player.BettingRecord memory bettingRecord = currentPlayer.getBettingRecordForId(record.bettingRecordId);
+
+		currentPlayer.deleteBettingRecordForId(bettingRecord.bettingRecordId);
+
+		 
+		uint256 bettingRecordValue = getWinningsForRecord(bettingRecord, true);
+		uint256 amountToMineForBettingRecord = computeAmountToMineForBettingRecord(bettingRecord, false);
+
+		 
+		if(bettingRecord.gameId == currentGameNumber) {
+			bettingRecord.withdrawnAmount = bettingRecord.withdrawnAmount.add(bettingRecordValue);
+			bettingRecord.withdrawnPopAmount = bettingRecord.withdrawnPopAmount.add(amountToMineForBettingRecord);
+			currentPlayer.insertBettingRecord(bettingRecord);
+		}
+		minePoP(bettingRecord.playerAddress, amountToMineForBettingRecord);
+		playerInternalWallet[bettingRecord.playerAddress] = playerInternalWallet[bettingRecord.playerAddress].add(bettingRecordValue);
+	}
+
+	function potAmountForRecord (Player.BettingRecord record) private view returns(uint256 potAmount) {
+		require(record.gameId <= currentGameNumber);
+		if(record.gameId < currentGameNumber) {
+			return gameMetaData.itemAtIndex(record.gameId).totalPotAmount; 
+		} else {
+			return currentPot;
+		} 
+	}
+
+	 
+	function recordIsTooNewToProcess (Player.BettingRecord record) private view returns(bool res) {
+		uint256 potAtBet = record.gamePotBeforeBet.add(record.wagerAmount);
+
+		if(record.gameId == currentGameNumber) {
+			uint256 halfPot = currentPot.sub(initialSeed).div(2);
+			if(potAtBet >= halfPot) {
+				return true;  
+			}
+		}
+		return false;
+	}
+
+	function UInt256 (int256 elem) private pure returns(uint256 res) {
+		assert(elem >= 0);
+		return uint256(elem);
+	}
+	
+	function Int256 (uint256 elem) private pure returns(int256 res) {
+		assert(int256(elem) >= 0);
+		return int256(elem);
+	}
+	
+	function getBankRollGrowthForGameId (uint256 gameId) private view returns(FixedPoint.Data res) {
+		if(gameId == currentGameNumber) {
+			return FixedPoint.fromInt256(Int256(currentPot)).div(initialBankrollGrowthAmount);
+		} else {
+			WrappedArray.GameMetaDataElement memory elem = gameMetaData.itemAtIndex(gameId);
+			return FixedPoint.fromInt256(Int256(elem.totalPotAmount)).div(FixedPoint.fromInt256(Int256(elem.initialBet)));
+		}
+	}
+
+	function getSeedAmountForGameId (uint256 gameId) private view returns(FixedPoint.Data res) {
+		if(gameId == currentGameNumber) {
+			return FixedPoint.fromInt256(Int256(initialSeed));
+		} else {
+			WrappedArray.GameMetaDataElement memory elem = gameMetaData.itemAtIndex(gameId);
+			return FixedPoint.fromInt256(Int256(elem.seedAmount));
+		}
+	}
+
+	function getPayoutForPlayer(Player.BettingRecord playerRecord) internal view returns (FixedPoint.Data) {
+
+		FixedPoint.Data memory frontWindowAdjustment = getWindowAdjustmentForGameIdAndRatio(playerRecord.gameId, frontWindowAdjustmentRatio);
+		FixedPoint.Data memory backWindowAdjustment = getWindowAdjustmentForGameIdAndRatio(playerRecord.gameId, backWindowAdjustmentRatio);
+		FixedPoint.Data memory backPayoutEndPoint = kBackPayoutEndPointInitial.div(backWindowAdjustment);
+		FixedPoint.Data memory frontPayoutSizePercent = kFrontPayoutStartPointInitial.div(frontWindowAdjustment);
+        FixedPoint.Data memory frontPayoutStartPoint = FixedPoint.fromInt256(1).sub(frontPayoutSizePercent);
+
+        FixedPoint.Data memory potAmountData = FixedPoint.fromInt256(Int256(potAmountForRecord(playerRecord)));
+
+		FixedPoint.Data memory frontPercent = FixedPoint.fromInt256(0);
+		if(playerRecord.gamePotBeforeBet != 0) {
+			frontPercent = FixedPoint.fromInt256(Int256(playerRecord.gamePotBeforeBet)).div(potAmountData.sub(getSeedAmountForGameId(playerRecord.gameId)));
+		}
+
+		FixedPoint.Data memory backPercent = FixedPoint.fromInt256(Int256(playerRecord.gamePotBeforeBet)).add(FixedPoint.fromInt256(Int256(playerRecord.wagerAmount))).div(potAmountData.sub(getSeedAmountForGameId(playerRecord.gameId)));
+
+		if(frontPercent.val < backPayoutEndPoint.val) {
+		    if(backPercent.val <= backPayoutEndPoint.val) {
+		    	 
+		        return calcWinnings(frontPercent, backPercent, backPayoutEndPoint, _pi.div(backWindowAdjustment), backWindowAdjustment, FixedPoint.fromInt256(0), potAmountData);
+		    } else if (backPercent.val <= frontPayoutStartPoint.val) {
+		    	 
+		        return calcWinnings(frontPercent, backPayoutEndPoint, backPayoutEndPoint, _pi.div(backWindowAdjustment), backWindowAdjustment, FixedPoint.fromInt256(0), potAmountData);
+		    } else {
+		    	 
+		        return calcWinnings(frontPercent, backPayoutEndPoint, backPayoutEndPoint, _pi.div(backWindowAdjustment), backWindowAdjustment, FixedPoint.fromInt256(0), potAmountData).add(calcWinnings(FixedPoint.fromInt256(0), backPercent.sub(frontPayoutStartPoint), frontPayoutSizePercent, _pi.div(frontWindowAdjustment), frontWindowAdjustment, _pi.div(frontWindowAdjustment), potAmountData));
+		    }
+		} else if (frontPercent.val < frontPayoutStartPoint.val) {
+		    if (backPercent.val <= frontPayoutStartPoint.val) {
+		    	 
+		        return FixedPoint.fromInt256(0);
+		    } else {
+		    	 
+		        return calcWinnings(FixedPoint.fromInt256(0), backPercent.sub(frontPayoutStartPoint), frontPayoutSizePercent, _pi.div(frontWindowAdjustment), frontWindowAdjustment, _pi.div(frontWindowAdjustment), potAmountData);
+		    }
+		} else {
+			 
+		    return calcWinnings(frontPercent.sub(frontPayoutStartPoint), backPercent.sub(frontPayoutStartPoint), frontPayoutSizePercent, _pi.div(frontWindowAdjustment), frontWindowAdjustment, _pi.div(frontWindowAdjustment), potAmountData);
+		}
+	}
+
+	function getWindowAdjustmentForGameIdAndRatio(uint256 gameId, FixedPoint.Data adjustmentRatio) internal view returns (FixedPoint.Data) {
+		FixedPoint.Data memory growth = getBankRollGrowthForGameId(gameId);
+		FixedPoint.Data memory logGrowthRate = growth.ln();
+		return growth.div(adjustmentRatio.pow(logGrowthRate));
+	}
+
+	function integrate(FixedPoint.Data x, FixedPoint.Data a) internal pure returns (FixedPoint.Data) {
+		return a.mul(x).sin().div(a).add(x);
+	}
+
+	function calcWinnings(FixedPoint.Data playerFrontPercent, FixedPoint.Data playerBackPercent, FixedPoint.Data sectionPercentSize, FixedPoint.Data sectionRadiansSize, FixedPoint.Data windowAdjustment, FixedPoint.Data sectionOffset, FixedPoint.Data potSize) internal view returns (FixedPoint.Data) {
+		FixedPoint.Data memory startIntegrationPoint = sectionOffset.add(playerFrontPercent.div(sectionPercentSize).mul(sectionRadiansSize));
+		FixedPoint.Data memory endIntegrationPoint = sectionOffset.add(playerBackPercent.div(sectionPercentSize).mul(sectionRadiansSize));
+		return integrate(endIntegrationPoint, windowAdjustment).sub(integrate(startIntegrationPoint, windowAdjustment)).mul(potSize).mul(windowAdjustment).div(_2pi);
+	}
+
+    function computeAmountToMineForBettingRecord (Player.BettingRecord record, bool onlyCurrentGame) internal view returns(uint256 value) {
+		if(onlyCurrentGame && record.gameId != currentGameNumber){
+			return 0;
+		}
+
+		uint256 payout = getPopPayoutForRecord(record).toUInt256Raw();
+		return payout.sub(record.withdrawnPopAmount);
+    }
+
+    function getPopPayoutForRecord(Player.BettingRecord record) private view returns(FixedPoint.Data value) {
+    	
+    	if(record.isActive == false) {
+    		return FixedPoint.fromInt256(0);
+    	}
+
+    	return totalTokenPayout(getPotAsFixedPointForGameId(record.gameId).sub(getInitialSeedAsFixedPointForGameId(record.gameId)), getDifficultyAsFixedPointForGameId(record.gameId), getPopRemainingAsFixedPointForGameId(record.gameId), record.wagerAmount, record.gamePotBeforeBet); 
+    }
+    
+    function unMinedPop () private view returns(uint256 res) {
+    	return totalSupply_.sub(supplyMined_);
+    }
+
+    function promisedPop () private view returns(uint256) {
+    	FixedPoint.Data memory curPot = getPotAsFixedPointForGameId(currentGameNumber);
+    	FixedPoint.Data memory seed = getInitialSeedAsFixedPointForGameId(currentGameNumber);
+    	FixedPoint.Data memory difficulty = getDifficultyAsFixedPointForGameId(currentGameNumber);
+    	FixedPoint.Data memory unpromised = getPopRemainingAsFixedPointForGameId(currentGameNumber);
+
+    	uint256 promisedPopThisGame = totalTokenPayout(curPot.sub(seed), difficulty, unpromised, currentPot.sub(seed.toUInt256Raw()), 0).toUInt256Raw(); 
+    	return totalSupply_.sub(unPromisedSupplyAtStartOfCurrentGame_).add(promisedPopThisGame);
+    }
+
+    function unPromisedPop () private view returns(uint256 res) {
+    	return totalSupply_.sub(promisedPop());
+    }
+    
+    function potentiallyCirculatingPop () public view returns(uint256 res) {
+    	return promisedPop().sub(supplyBurned_);
+    }
+    
+    function minePoP(address target, uint256 amountToMine) private {
+    	if(supplyMined_ >= totalSupply_) { 
+    		return;
+    	}
+
+    	uint256 remainingPop = unMinedPop();
+    	if(amountToMine == 0 || remainingPop == 0) {
+    		return;
+    	}
+
+    	if(remainingPop < amountToMine) {
+    		amountToMine = remainingPop;
+    	}
+
+    	uint256 developerMined = amountOfPopDeveloperShouldMine(amountToMine);
+    	uint256 playerMined = amountToMine.sub(developerMined);
+
+    	supplyMined_ = supplyMined_.add(amountToMine);
+    	
+        popBalances[target] = popBalances[target].add(playerMined);
+        popBalances[author] = popBalances[author].add(developerMined);
+
+        emit Mined(target, playerMined);
+        emit Transfer(0, target, playerMined);
+        emit Mined(author, developerMined);
+        emit Transfer(0, author, developerMined);
+    }
+
+    function redeemPop (uint256 popToRedeem) public returns(bool res) {
+    	require(popBalances[msg.sender] >= popToRedeem);
+    	require(popToRedeem != 0);
+
+    	uint256 potentiallyAllocatedPop = potentiallyCirculatingPop();
+    	require(popToRedeem <= potentiallyAllocatedPop);
+
+    	FixedPoint.Data memory redeemRatio = FixedPoint.fromFraction(Int256(popToRedeem), Int256(potentiallyAllocatedPop));
+    	FixedPoint.Data memory ethPayoutAmount = redeemRatio.mul(FixedPoint.fromInt256(Int256(totalAmountRaked())));
+    	uint256 payout = ethPayoutAmount.toUInt256Raw();
+    	require(payout<=totalAmountRaked());
+    	require(payout <= address(this).balance);
+    	
+    	burn(popToRedeem);
+    	playerInternalWallet[this] = playerInternalWallet[this].sub(payout);
+    	playerInternalWallet[msg.sender] = playerInternalWallet[msg.sender].add(payout);
+
+    	return true;
+    }
+
+     
+    function totalSupply() public view returns (uint256) {
+	    return promisedPop();
+	}
+
+	function balanceOf(address _owner) public view returns (uint256 balance) {
+		return popBalances[_owner];
+	}
+
+	function transfer(address _to, uint256 _value) public returns (bool) {
+	    require(_to != address(0));
+	    require(_value <= popBalances[msg.sender]);
+
+	     
+	    popBalances[msg.sender] = popBalances[msg.sender].sub(_value);
+	    popBalances[_to] = popBalances[_to].add(_value);
+	    emit Transfer(msg.sender, _to, _value);
+	    return true;
+	}
+
+	function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+	    require(_to != address(0));
+	    require(_value <= popBalances[_from]);
+	    require(_value <= allowed[_from][msg.sender]);
+
+	    popBalances[_from] = popBalances[_from].sub(_value);
+	    popBalances[_to] = popBalances[_to].add(_value);
+	    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+	    emit Transfer(_from, _to, _value);
+	    return true;
+	}
+
+	function approve(address _spender, uint256 _value) public returns (bool) {
+	    allowed[msg.sender][_spender] = _value;
+	    emit Approval(msg.sender, _spender, _value);
+	    return true;
+	}
+
+	function allowance(address _owner, address _spender) public view returns (uint256) {
+	    return allowed[_owner][_spender];
+	}
+
+	function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
+	    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
+	    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+	    return true;
+	}
+
+	function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
+	    uint oldValue = allowed[msg.sender][_spender];
+	    if (_subtractedValue > oldValue) {
+	      allowed[msg.sender][_spender] = 0;
+	    } else {
+	      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+	    }
+	    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+	    return true;
+	}
+
+	function burn(uint256 _value) public {
+	    require (popBalances[msg.sender] >= _value);
+	    
+	    address burner = msg.sender;
+	    supplyBurned_ = supplyBurned_.add(_value);
+	    popBalances[burner] = popBalances[burner].sub(_value);
+	    emit Burn(burner, _value);
+	}
+
+	function getInitialSeedAsFixedPointForGameId (uint256 gameId) private view returns(FixedPoint.Data res) {
+		if(gameId == currentGameNumber) {
+			return FixedPoint.fromInt256(Int256(initialSeed));
+		} else {
+			WrappedArray.GameMetaDataElement memory elem = gameMetaData.itemAtIndex(gameId);
+			return FixedPoint.fromInt256(Int256(elem.seedAmount));
+		}
+	}
+
+	function getPotAsFixedPointForGameId (uint256 gameId) private view returns(FixedPoint.Data res) {
+		if(gameId == currentGameNumber) {
+			return FixedPoint.fromInt256(Int256(currentPot));
+		} else {
+			WrappedArray.GameMetaDataElement memory elem = gameMetaData.itemAtIndex(gameId);
+			return FixedPoint.fromInt256(Int256(elem.totalPotAmount));
+		}
+	}
+
+	function getPopRemainingAsFixedPointForGameId (uint256 gameId) private view returns(FixedPoint.Data res) {
+		if(gameId == currentGameNumber) {
+			return FixedPoint.fromInt256(Int256(unPromisedSupplyAtStartOfCurrentGame_));
+		} else {
+			WrappedArray.GameMetaDataElement memory elem = gameMetaData.itemAtIndex(gameId);
+			return FixedPoint.fromInt256(Int256(elem.coinsRemaining));
+		}
+	}
+	
+	function getDifficultyAsFixedPointForGameId (uint256 gameId) private view returns(FixedPoint.Data res) {
+		if(gameId == currentGameNumber) {
+			return currentMiningDifficulty;
+		} else {
+			WrappedArray.GameMetaDataElement memory elem = gameMetaData.itemAtIndex(gameId);
+			return elem.miningDifficulty;
+		}
+	}
+
+	function calcDifficulty() private view returns (FixedPoint.Data) {
+		FixedPoint.Data memory total = FixedPoint.fromInt256(0);
+		FixedPoint.Data memory count = FixedPoint.fromInt256(0);
+		uint256 j = 0;
+		for(uint256 i=gameMetaData.length().sub(1) ; i>=0 && j<kDifficultyWindow; i = i.sub(1)){
+			WrappedArray.GameMetaDataElement memory thisGame = gameMetaData.itemAtIndex(i);
+			FixedPoint.Data memory thisGamePotSize = FixedPoint.fromInt256(Int256(thisGame.totalPotAmount));
+			FixedPoint.Data memory thisCount = kDifficultyDropOffFactor.pow(FixedPoint.fromInt256(Int256(j)));
+			total = total.add(thisCount.mul(thisGamePotSize));
+			count = count.add(thisCount);
+			j = j.add(1);
+			if(i == 0) {
+				break;
+			}
+		}
+		
+		return total.div(count).div(kExpectedFirstGameSize);
+	}
+
+	function getBrAdj(FixedPoint.Data currentPotValue, FixedPoint.Data expectedGameSize) private pure returns (FixedPoint.Data) {
+		if(currentPotValue.cmp(expectedGameSize) == -1) {
+		    return expectedGameSize.div(currentPotValue).log10().neg();
+		} else {
+		    return currentPotValue.div(expectedGameSize).log10();
+		}
+	}
+
+	function getMiningRateAtPoint(FixedPoint.Data point, FixedPoint.Data difficulty, FixedPoint.Data currentPotValue, FixedPoint.Data coins_tbi) private view returns (FixedPoint.Data) {
+		assert (point.cmp(currentPotValue) != 1);
+        FixedPoint.Data memory expectedGameSize = kExpectedFirstGameSize.mul(difficulty);
+		FixedPoint.Data memory depositRatio = point.div(currentPotValue);
+		FixedPoint.Data memory brAdj = getBrAdj(currentPotValue, expectedGameSize);
+		if(brAdj.cmp(FixedPoint.fromInt256(0)) == -1) {
+			return coins_tbi.mul(FixedPoint.fromInt256(1).div(FixedPoint.fromInt256(2).pow(brAdj.neg()))).mul(FixedPoint.fromInt256(2).sub(depositRatio));
+		} else {
+			return coins_tbi.mul(FixedPoint.fromInt256(2).pow(brAdj)).mul(FixedPoint.fromInt256(2).sub(depositRatio));
+		}
+	}
+
+    function getExpectedGameSize() external view returns (int256) {
+        return kExpectedFirstGameSize.toInt256();
+    }
+
+	function totalTokenPayout(FixedPoint.Data currentPotValue, FixedPoint.Data difficulty, FixedPoint.Data unpromisedPopAtStartOfGame, uint256 wagerAmount, uint256 previousPotSize) private view returns (FixedPoint.Data) {
+		FixedPoint.Data memory maxPotSize = kExpectedFirstGameSize.mul(difficulty).mul(kMaxPopMiningPotMultiple);
+		FixedPoint.Data memory startPoint = FixedPoint.fromInt256(Int256(previousPotSize));
+		if(startPoint.cmp(maxPotSize) != -1){  
+			return FixedPoint.fromInt256(0);
+		}
+		FixedPoint.Data memory endPoint = FixedPoint.fromInt256(Int256(previousPotSize + wagerAmount));
+		if(endPoint.cmp(maxPotSize) != -1){
+			endPoint = maxPotSize;
+			wagerAmount = maxPotSize.sub(startPoint).toUInt256Raw();
+		}
+		if(currentPotValue.cmp(maxPotSize) != -1){
+			currentPotValue = maxPotSize;
+		}
+
+		FixedPoint.Data memory betSizePercent = FixedPoint.fromInt256(Int256(wagerAmount)).div(kExpectedFirstGameSize.mul(difficulty));
+		FixedPoint.Data memory expectedCoinsToBeIssuedTwoThirds = FixedPoint.fromFraction(2, 3).mul(unpromisedPopAtStartOfGame.mul(kExpectedPopCoinToBePromisedPercent));
+		return getMiningRateAtPoint(startPoint.add(endPoint).div(FixedPoint.fromInt256(2)), difficulty, currentPotValue, expectedCoinsToBeIssuedTwoThirds).mul(betSizePercent);
+	}
+
+	function calcNumberOfBlocksUntilGameEnds(FixedPoint.Data currentGameSize, FixedPoint.Data targetGameSize) internal view returns (FixedPoint.Data) {
+		return kLowerBoundBlocksTillGameEnd.add(kUpperBoundBlocksTillGameEnd.mul(FixedPoint.fromInt256(1).div(currentGameSize.div(targetGameSize).exp())));
+	}
+
+	function calcMinimumBetSize(FixedPoint.Data currentGameSize, FixedPoint.Data targetGameSize) internal view returns (FixedPoint.Data) {
+		return currentGameInitialMinBetSize.mul(FixedPoint.fromInt256(2).pow(FixedPoint.fromInt256(1).add(currentGameSize.div(targetGameSize)).log10()));
+	}
+}
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+    uint256 c = a / b;
+    return c;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+library SafeInt {
+
+   
+  function mul(int256 a, int256 b) internal pure returns (int256) {
+    if (a == 0) {
+      return 0;
+    }
+    int256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(int256 a, int256 b) internal pure returns (int256) {
+   	 
+    int256 c = a / b;
+    return c;
+  }
+
+   
+  function sub(int256 a, int256 b) internal pure returns (int256) {
+    int256 c = a - b;
+    if(a>0 && b<0) {
+    	assert (c > a);	
+    } else if(a<0 && b>0) {
+    	assert (c < a);
+    }
+   	return c;
+  }
+
+   
+  function add(int256 a, int256 b) internal pure returns (int256) {
+    int256 c = a + b;
+    if(a>0 && b>0) {
+    	assert(c > a);
+    } else if (a < 0 && b < 0) {
+    	assert(c < a);
+    }
+    return c;
+  }
+}
+
+
+library WrappedArray {
+	using SafeMath for uint256;
+	using FixedPoint for FixedPoint.Data;
+
+	struct GameMetaDataElement {
+		uint256 totalPotAmount;
+		uint256 seedAmount;
+		uint256 initialBet;
+		uint256 coinsRemaining;
+		FixedPoint.Data miningDifficulty;
+		bool isActive;
+	}
+
+	struct Data {
+		GameMetaDataElement[] array;
+	}
+	
+	 
+	function push (Data storage self, GameMetaDataElement element) internal  {
+		self.array.length = self.array.length.add(1);
+		self.array[self.array.length.sub(1)] = element;
+	}
+
+	 
+	function itemAtIndex (Data storage self, uint256 index) internal view returns(GameMetaDataElement elem) {
+		 
+		assert(index < self.array.length); 
+		return self.array[index];
+	}
+	
+	 
+	function length (Data storage self) internal view returns(uint256 len) {
+		return self.array.length;
+	}
+}
+
+
+library CompactArray {
+	using SafeMath for uint256;
+
+	struct Element {
+		uint256 elem;
+	}
+	
+	struct Data {
+		Element[] array;
+		uint256 len;
+		uint256 popNextIndex;
+	}
+
+	 
+	function push (Data storage self, Element element) internal returns(uint256 index)  {
+		if(self.array.length == self.len) {
+			self.array.length = self.array.length.add(1);
+		}
+		self.array[self.len] = element;
+		self.len = self.len.add(1);
+		return self.len.sub(1);
+	}
+
+	 
+	function removeItemAtIndex (Data storage self, uint256 index) internal {
+		 
+		assert(index < self.len);
+
+		 
+		if(index == self.len.sub(1)) {
+			self.len = self.len.sub(1);
+			return;
+		}
+
+		 
+		Element storage temp = self.array[self.len.sub(1)];
+		self.array[index] = temp;
+		self.len = self.len.sub(1);
+	}
+	
+	 
+	function pop (Data storage self) internal returns(Element elem) {
+		assert(self.len > 0);
+
+		 
+		self.len = self.len.sub(1);
+
+		 
+		return self.array[self.len];
+	}
+
+	 
+	function getNext (Data storage self) internal returns(Element elem) {
+		assert(self.len > 0);
+			
+		if(self.popNextIndex >= self.len) {
+			 
+			self.popNextIndex = self.len.sub(1);
+		}
+		Element memory nextElement = itemAtIndex(self, self.popNextIndex);
+		
+		if(self.popNextIndex == 0) {
+			self.popNextIndex = self.len.sub(1);
+		} else {
+			self.popNextIndex = self.popNextIndex.sub(1);
+		}
+		return nextElement;
+	}
+	
+	 
+	function itemAtIndex (Data storage self, uint256 index) internal view returns(Element elem) {
+		 
+		assert(index < self.len);
+			
+		return self.array[index];
+	}
+	
+	 
+	function length (Data storage self) internal view returns(uint256 len) {
+		return self.len;
+	}
+	
+}
+
+
+library UIntSet {
+	using CompactArray for CompactArray.Data;
+
+	struct SetEntry {
+		uint256 index;
+		bool active;  
+	}
+	
+	struct Data {
+		CompactArray.Data compactArray;
+		mapping (uint256 => SetEntry) storedValues;
+	}
+
+	 
+	function contains (Data storage self, uint256 element) internal view returns(bool res) {
+		return self.storedValues[element].active;
+	}
+
+	 
+	function insert (Data storage self, uint256 element) internal {
+		 
+		if(contains(self, element)) {
+			return;
+		}
+		 
+		CompactArray.Element memory newElem = CompactArray.Element(element);
+
+		 
+		uint256 index = self.compactArray.push(newElem);
+
+		 
+		SetEntry memory entry = SetEntry(index, true);
+
+		self.storedValues[element] = entry;
+	}
+	
+	
+	 
+	function removeElement (Data storage self, uint256 element) internal {
+		 
+		if(contains(self, element) == false) {
+			return;
+		}
+
+		 
+		uint256 index = self.storedValues[element].index;
+
+		 
+		self.compactArray.removeItemAtIndex(index);
+
+		 
+		self.storedValues[element].active = false;
+
+		 
+		if(index < self.compactArray.length()) {
+			 
+			CompactArray.Element memory swappedElem = self.compactArray.itemAtIndex(index);
+			
+			 
+			self.storedValues[swappedElem.elem] = SetEntry(index, true);
+			
+		}
+	}
+
+	 
+	function getNext (Data storage self) internal returns(CompactArray.Element) {
+		 
+		return self.compactArray.getNext();
+	}
+
+	 
+	function size (Data storage self) internal view returns(uint256 res) {
+		return self.compactArray.length();
+	}
+
+	function getItemAtIndex (Data storage self, uint256 index) internal view returns(CompactArray.Element) {
+		return self.compactArray.itemAtIndex(index);
+	}
+	
+}
+
+
+
+library Player {
+	using UIntSet for UIntSet.Data;
+	using CompactArray for CompactArray.Data;
+
+	struct BettingRecord {
+		address playerAddress;
+		uint256 gameId;
+		uint256 wagerAmount;
+		uint256 bettingRecordId;
+		uint256 gamePotBeforeBet;
+		uint256 withdrawnAmount;
+		uint256 withdrawnPopAmount;
+		bool isActive;
+	}
+	
+	struct Data {
+		UIntSet.Data bettingRecordIds;
+		mapping (uint256 => BettingRecord) bettingRecordMapping;
+	}
+	
+	 
+	function containsBettingRecordFromId (Data storage self, uint256 bettingRecordId) internal view returns(bool containsBettingRecord) {
+		return self.bettingRecordIds.contains(bettingRecordId);
+	}
+	
+
+	 
+	function getBettingRecordForId (Data storage self, uint256 bettingRecordId) internal view returns(BettingRecord record) {
+		if(containsBettingRecordFromId(self, bettingRecordId) == false) {
+			return ;
+		}
+		return self.bettingRecordMapping[bettingRecordId];
+	}
+	
+
+	 
+	function insertBettingRecord (Data storage self, BettingRecord record) internal {
+		 
+		self.bettingRecordMapping[record.bettingRecordId] = record;
+		self.bettingRecordIds.insert(record.bettingRecordId);
+	}
+	
+	 
+	function getNextRecord (Data storage self) internal returns(BettingRecord record) {
+		if(self.bettingRecordIds.size() == 0) {
+			return ;
+		}
+		CompactArray.Element memory bettingRecordIdEntry = self.bettingRecordIds.getNext();
+		return self.bettingRecordMapping[bettingRecordIdEntry.elem];
+	}
+
+    function getBettingRecordAtIndex (Data storage self, uint256 index) internal view returns(BettingRecord record) {
+    	return self.bettingRecordMapping[self.bettingRecordIds.getItemAtIndex(index).elem];
+    }
+    
+
+	 
+	function deleteBettingRecordForId (Data storage self, uint256 bettingRecordId) internal {
+		self.bettingRecordIds.removeElement(bettingRecordId);
+	}
+
+	 
+	function unprocessedBettingRecordCount (Data storage self) internal view returns(uint256 size) {
+		return self.bettingRecordIds.size();
+	}
+}
+
+library BettingRecordArray {
+	using Player for Player.Data;
+	using SafeMath for uint256;
+
+	struct Data {
+		Player.BettingRecord[] array;
+		uint256 len;
+	}
+
+	function resetIndex (Data storage self) internal {
+		self.len = 0;
+	}
+	
+	function pushRecord (Data storage self, Player.BettingRecord record) internal {
+		if(self.array.length == self.len) {
+			self.array.length = self.array.length.add(1);
+		}
+		self.array[self.len] = record;
+		self.len = self.len.add(1);
+	}
+
+	function getNextRecord (Data storage self) internal view returns(Player.BettingRecord record) {
+		if(self.array.length == self.len) {
+			return;
+		}
+		return self.array[self.len];
+	}	
+}
+
+library FixedPoint {
+	using SafeMath for uint256;
+	using SafeInt for int256;
+
+	int256 constant fracBits = 32;
+	int256 constant scale = 1 << 32;
+	int256 constant halfScale = scale >> 1;
+    int256 constant precision = 1000000;
+	int256 constant e = 11674931554;
+	int256 constant pi = 13493037704;
+	int256 constant _2pi = 26986075409;
+
+	struct Data {
+		int256 val;
+	}
+
+	function fromInt256(int256 n) internal pure returns (Data) {
+		return Data({val: n.mul(scale)});
+	}
+
+	function fromFraction(int256 numerator, int256 denominator) internal pure returns (Data) {
+		return Data ({
+			val: numerator.mul(scale).div(denominator)
+		});
+	}
+
+	function toInt256(Data n) internal pure returns (int256) {
+		return (n.val * precision) >> fracBits;
+	}
+
+	function toUInt256Raw(Data a) internal pure returns (uint256) {
+		return uint256(a.val >> fracBits);
+	}
+
+	function add(Data a, Data b) internal pure returns (Data) {
+		return Data({val: a.val.add(b.val)});
+	}
+
+	function sub(Data a, Data b) internal pure returns (Data) {
+		return Data({val: a.val.sub(b.val)});
+	}
+
+	function mul(Data a, Data b) internal pure returns (Data) {
+		int256 result = a.val.mul(b.val).div(scale);
+		return Data({val: result});
+	}
+
+	function div(Data a, Data b) internal pure returns (Data) {
+		int256 num = a.val.mul(scale);
+		return Data({val: num.div(b.val)});
+	}
+
+    function neg(Data a) internal pure returns (Data) {
+        return Data({val: -a.val});
+    }
+
+	function mod(Data a, Data b) internal pure returns (Data) {
+		return Data({val: a.val % b.val});
+	}
+
+	function expBySquaring(Data x, Data n) internal pure returns (Data) {
+		if(n.val == 0) {  
+			return Data({val: scale});
+		}
+		Data memory extra = Data({val: scale});
+		while(true) {
+			if(n.val == scale) {  
+				return mul(x, extra);
+			} else if (n.val % (2*scale) != 0) {
+				extra = mul(extra, x);
+				n = sub(n, fromInt256(1));
+			}
+			x = mul(x, x);
+			n = div(n, fromInt256(2));
+		}
+	}
+
+	function sin(Data x) internal pure returns (Data) {
+		int256 val = x.val % _2pi;
+
+		if(val < -pi) {
+			val += _2pi;
+		} else if (val > pi) {
+			val -= _2pi;
+		}
+        Data memory result;
+		if(val < 0) {
+			result = add(mul(Data({val: 5468522184}), Data({val: val})), mul(Data({val: 1740684682}), mul(Data({val: val}), Data({val: val}))));
+			if(result.val < 0) {
+				result = add(mul(Data({val: 966367641}), sub(mul(result, neg(result)), result)), result);
+			} else {
+				result = add(mul(Data({val: 966367641}), sub(mul(result, result), result)), result);
+			}
+			return result;
+		} else {
+			result = sub(mul(Data({val: 5468522184}), Data({val: val})), mul(Data({val: 1740684682}), mul(Data({val: val}), Data({val: val})))); 
+			if(result.val < 0) {
+				result = add(mul(Data({val: 966367641}), sub(mul(result, neg(result)), result)), result);
+			} else {
+				result = add(mul(Data({val: 966367641}), sub(mul(result, result), result)), result);
+			}
+			return result;
+		}
+	}
+
+	function cmp(Data a, Data b) internal pure returns (int256) {
+		if(a.val > b.val) {
+			return 1;
+		} else if(a.val < b.val) {
+			return -1;
+		} else {
+			return 0;
+		}
+	}
+
+	function log10(Data a) internal pure returns (Data) {
+	    return div(ln(a), ln(fromInt256(10)));
+	}
+
+	function ln(Data a) internal pure returns (Data) {
+		int256 LOG = 0;
+		int256 prec = 1000000;
+		int256 x = a.val.mul(prec) >> fracBits;
+
+		while(x >= 1500000) {
+			LOG = LOG.add(405465);
+			x = x.mul(2).div(3);
+		}
+		x = x.sub(prec);
+        int256 y = x;
+        int256 i = 1;
+        while (i < 10){
+            LOG = LOG.add(y.div(i));
+            i = i.add(1);
+            y = x.mul(y).div(prec);
+            LOG = LOG.sub(y.div(i));
+            i = i.add(1);
+            y = x.mul(y).div(prec);
+        }
+        LOG = LOG.mul(scale);
+        LOG = LOG.div(prec);
+        return Data({val: LOG});
+	}
+
+	function expRaw(Data a) internal pure returns (Data) {
+		int256 l1 = scale.add(a.val.div(4));
+		int256 l2 = scale.add(a.val.div(3).mul(l1).div(scale));
+		int256 l3 = scale.add(a.val.div(2).mul(l2).div(scale));
+		int256 l4 = scale.add(a.val.mul(l3).div(scale));
+
+		return Data({val: l4});
+	}
+
+	function exp(Data a) internal pure returns (Data) {
+		int256 pwr = a.val >> fracBits;
+		int256 frac = a.val.sub(pwr << fracBits);
+
+		return mul(expRaw(Data({val: frac})), expBySquaring(Data({val: e}), fromInt256(pwr)));
+	}
+
+	function pow(Data base, Data power) internal pure returns (Data) {
+		int256 intpwr = power.val >> 32;
+		int256 frac = power.val.sub(intpwr << fracBits);
+		return mul(expRaw(mul(Data({val:frac}), ln(base))), expBySquaring(base, fromInt256(intpwr)));
+	}
+}

smart_contract_dataset/block number dependency/2003.sol

@@ -0,0 +1,383 @@
+pragma solidity ^0.4.24;
+
+ 
+
+contract ZTHReceivingContract {
+    function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+contract ZTHInterface {
+    function transfer(address _to, uint _value) public returns (bool);
+    function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zlots is ZTHReceivingContract {
+    using SafeMath for uint;
+
+    address private owner;
+    address private bankroll;
+
+     
+    uint  totalSpins;
+    uint  totalZTHWagered;
+
+     
+    uint contractBalance;
+
+     
+    bool    public gameActive;
+
+    address private ZTHTKNADDR;
+    address private ZTHBANKROLL;
+    ZTHInterface private     ZTHTKN;
+
+    mapping (uint => bool) validTokenBet;
+
+     
+    event HouseRetrievedTake(
+        uint timeTaken,
+        uint tokensWithdrawn
+    );
+
+     
+    event TokensWagered(
+        address _wagerer,
+        uint _wagered
+    );
+
+    event LogResult(
+        address _wagerer,
+        uint _result,
+        uint _profit,
+        uint _wagered,
+        bool _win
+    );
+
+    event Loss(
+        address _wagerer
+    );
+
+    event Jackpot(
+        address _wagerer
+    );
+
+    event EightXMultiplier(
+        address _wagerer
+    );
+
+    event ReturnBet(
+        address _wagerer
+    );
+
+    event TwoAndAHalfXMultiplier(
+        address _wagerer
+    );
+
+    event OneAndAHalfXMultiplier(
+        address _wagerer
+    );
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    modifier onlyBankroll {
+        require(msg.sender == bankroll);
+        _;
+    }
+
+    modifier onlyOwnerOrBankroll {
+        require(msg.sender == owner || msg.sender == bankroll);
+        _;
+    }
+
+     
+    modifier gameIsActive {
+        require(gameActive == true);
+        _;
+    }
+
+    constructor(address ZethrAddress, address BankrollAddress) public {
+
+         
+        ZTHTKNADDR = ZethrAddress;
+        ZTHBANKROLL = BankrollAddress;
+
+         
+        owner         = msg.sender;
+        bankroll      = ZTHBANKROLL;
+
+         
+        ZTHTKN = ZTHInterface(ZTHTKNADDR);
+        ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
+        
+         
+        ZTHTKN.approve(owner, 2**256 - 1);
+
+         
+        validTokenBet[5e18]  = true;
+        validTokenBet[10e18] = true;
+        validTokenBet[25e18] = true;
+        validTokenBet[50e18] = true;
+
+        gameActive  = true;
+    }
+
+     
+    function() public payable {  }
+
+     
+    struct TKN { address sender; uint value; }
+    function tokenFallback(address _from, uint _value, bytes  ) public returns (bool){
+        TKN memory          _tkn;
+        _tkn.sender       = _from;
+        _tkn.value        = _value;
+        _spinTokens(_tkn);
+        return true;
+    }
+
+    struct playerSpin {
+        uint200 tokenValue;  
+        uint48 blockn;       
+    }
+
+     
+    mapping(address => playerSpin) public playerSpins;
+
+     
+    function _spinTokens(TKN _tkn) private {
+
+        require(gameActive);
+        require(_zthToken(msg.sender));
+        require(validTokenBet[_tkn.value]);
+        require(jackpotGuard(_tkn.value));
+
+        require(_tkn.value < ((2 ** 200) - 1));    
+        require(block.number < ((2 ** 48) - 1));   
+
+        address _customerAddress = _tkn.sender;
+        uint    _wagered         = _tkn.value;
+
+        playerSpin memory spin = playerSpins[_tkn.sender];
+
+        contractBalance = contractBalance.add(_wagered);
+
+         
+        require(block.number != spin.blockn);
+
+         
+        if (spin.blockn != 0) {
+          _finishSpin(_tkn.sender);
+        }
+
+         
+        spin.blockn = uint48(block.number);
+        spin.tokenValue = uint200(_wagered);
+
+         
+        playerSpins[_tkn.sender] = spin;
+
+         
+        totalSpins += 1;
+
+         
+        totalZTHWagered += _wagered;
+
+        emit TokensWagered(_customerAddress, _wagered);
+
+    }
+
+      
+    function finishSpin() public
+        gameIsActive
+        returns (uint)
+    {
+      return _finishSpin(msg.sender);
+    }
+
+     
+    function _finishSpin(address target)
+        private returns (uint)
+    {
+        playerSpin memory spin = playerSpins[target];
+
+        require(spin.tokenValue > 0);  
+        require(spin.blockn != block.number);
+
+        uint profit = 0;
+
+         
+         
+        uint result;
+        if (block.number - spin.blockn > 255) {
+          result = 9999;  
+        } else {
+
+           
+           
+          result = random(10000, spin.blockn, target);
+        }
+
+        if (result > 4489) {
+           
+          emit Loss(target);
+          emit LogResult(target, result, profit, spin.tokenValue, false);
+        } else {
+            if (result < 29) {
+                 
+                profit = SafeMath.mul(spin.tokenValue, 25);
+                emit Jackpot(target);
+
+            } else {
+                if (result < 233) {
+                     
+                    profit = SafeMath.mul(spin.tokenValue, 8);
+                    emit EightXMultiplier(target);
+                } else {
+
+                    if (result < 641) {
+                         
+                        profit = spin.tokenValue;
+                        emit ReturnBet(target);
+                    } else {
+                        if (result < 1865) {
+                             
+                            profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 25), 10);
+                            emit TwoAndAHalfXMultiplier(target);
+                        } else {
+                             
+                            profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15), 10);
+                            emit OneAndAHalfXMultiplier(target);
+                        }
+                    }
+                }
+            }
+            emit LogResult(target, result, profit, spin.tokenValue, true);
+            contractBalance = contractBalance.sub(profit);
+            ZTHTKN.transfer(target, profit);
+        }
+        playerSpins[target] = playerSpin(uint200(0), uint48(0));
+        return result;
+    }
+
+     
+     
+     
+     
+    function jackpotGuard(uint _wager)
+        public
+        view
+        returns (bool)
+    {
+        uint maxProfit = SafeMath.mul(_wager, 25);
+        uint halfContractBalance = SafeMath.div(contractBalance, 2);
+        return (maxProfit <= halfContractBalance);
+    }
+
+     
+     
+    function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+    }
+
+     
+    function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+    }
+
+     
+    function balanceOf() public view returns (uint) {
+        return contractBalance;
+    }
+
+    function addNewBetAmount(uint _tokenAmount)
+        public
+        onlyOwner
+    {
+        validTokenBet[_tokenAmount] = true;
+    }
+
+     
+    function pauseGame() public onlyOwner {
+        gameActive = false;
+    }
+
+     
+    function resumeGame() public onlyOwner {
+        gameActive = true;
+    }
+
+     
+    function changeOwner(address _newOwner) public onlyOwner {
+        owner = _newOwner;
+    }
+
+     
+    function changeBankroll(address _newBankroll) public onlyOwner {
+        bankroll = _newBankroll;
+    }
+
+     
+    function divertDividendsToBankroll()
+        public
+        onlyOwner
+    {
+        bankroll.transfer(address(this).balance);
+    }
+
+    function testingSelfDestruct()
+        public
+        onlyOwner
+    {
+         
+        ZTHTKN.transfer(owner, contractBalance);
+        selfdestruct(owner);
+    }
+    
+     
+    function _zthToken(address _tokenContract) private view returns (bool) {
+       return _tokenContract == ZTHTKNADDR;
+    }
+}
+
+ 
+
+ 
+library SafeMath {
+
+     
+    function mul(uint a, uint b) internal pure returns (uint) {
+        if (a == 0) {
+            return 0;
+        }
+        uint c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+     
+    function div(uint a, uint b) internal pure returns (uint) {
+         
+        uint c = a / b;
+         
+        return c;
+    }
+
+     
+    function sub(uint a, uint b) internal pure returns (uint) {
+        assert(b <= a);
+        return a - b;
+    }
+
+     
+    function add(uint a, uint b) internal pure returns (uint) {
+        uint c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}

smart_contract_dataset/block number dependency/2110.sol

@@ -0,0 +1,395 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+    uint256 c = a / b;
+     
+    return c;
+  }
+
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+library utils{
+    function inArray(uint[] _arr,uint _val) internal pure returns(bool){
+        for(uint _i=0;_i< _arr.length;_i++){
+            if(_arr[_i]==_val){
+                return true;
+                break;
+            }
+        }
+        return false;
+    }
+    
+    function inArray(address[] _arr,address _val) internal pure returns(bool){
+        for(uint _i=0;_i< _arr.length;_i++){
+            if(_arr[_i]==_val){
+                return true;
+                break;
+            }
+        }
+        return false;
+    }
+}
+
+
+contract Ownable {
+  address public owner;
+
+     
+    constructor() public {
+        owner = msg.sender;
+    }
+
+
+       
+      modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+      }
+  
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    require(newOwner != address(0));
+    owner = newOwner;
+  }
+
+}
+
+contract GuessEthEvents{
+    event drawLog(uint,uint,uint);
+
+    event guessEvt(
+        address indexed playerAddr,
+        uint[] numbers, uint amount
+        );
+    event winnersEvt(
+        uint blockNumber,
+        address indexed playerAddr,
+        uint amount,
+        uint winAmount
+        );
+    event withdrawEvt(
+        address indexed to,
+        uint256 value
+        );
+    event drawEvt(
+        uint indexed blocknumberr,
+        uint number
+        );
+    
+    event sponseEvt(
+        address indexed addr,
+        uint amount
+        );
+
+    event pauseGameEvt(
+        bool pause
+        );
+    event setOddsEvt(
+        uint odds
+        );
+  
+}
+
+contract GuessEth is Ownable,GuessEthEvents{
+    using SafeMath for uint;
+
+     
+
+    struct bnumber{
+        address addr;
+        uint number;
+        uint value;
+        int8 result;
+        uint prize;
+    }
+    mapping(uint => bnumber[]) public bets;
+    mapping(uint => address) public betNumber;
+    
+     
+    mapping(address => uint[]) private playerBetBNumber;
+    
+     
+    struct winner{
+        bool result;
+        uint prize;
+    }
+    
+    mapping(uint => winner[]) private winners;
+    mapping(uint => uint) private winResult;
+    
+    address private wallet1;
+    address private wallet2;
+    
+    uint private predictBlockInterval=3;
+    uint public odds=30;
+    uint public blockInterval=500;
+    uint public curOpenBNumber=0;
+    uint public numberRange=100;
+
+    bool public gamePaused=false;
+    
+
+     
+    mapping(address => uint) Sponsors;
+    uint public balanceOfSPS=0;
+    address[] public SponsorAddresses;
+    
+    uint reservefund=30 ether;
+   
+  
+     
+    modifier isHuman() {
+        address _addr = msg.sender;
+        uint256 _codeLength;
+    
+        assembly {_codeLength := extcodesize(_addr)}
+        require(_codeLength == 0, "sorry humans only");
+        _;
+    }
+    
+    constructor(address _wallet1,address _wallet2) public{
+        wallet1=_wallet1;
+        wallet2=_wallet2;
+        
+        curOpenBNumber=blockInterval*(block.number.div(blockInterval));
+    }
+    
+    function pauseGame(bool _status) public onlyOwner returns(bool){
+            gamePaused=_status;
+            emit pauseGameEvt(_status);
+    }
+    
+    function setOdds(uint _odds) isHuman() public onlyOwner returns(bool){
+            odds = _odds;
+            emit setOddsEvt(_odds);
+    }
+    function setReservefund(uint _reservefund) isHuman() public onlyOwner returns(bool){
+            reservefund = _reservefund * 1 ether;
+    }
+    
+    function getTargetBNumber() view isHuman() public returns(uint){
+        uint n;
+        n=blockInterval*(predictBlockInterval + block.number/blockInterval);
+        return n;
+    }
+    
+    function guess(uint[] _numbers) payable isHuman() public returns(uint){
+        require(msg.value  >= _numbers.length * 0.05 ether);
+
+        uint n=blockInterval*(predictBlockInterval + block.number/blockInterval);
+        
+        for(uint _i=0;_i < _numbers.length;_i++){
+            bnumber memory b;
+            
+            b.addr=msg.sender;
+            b.number=_numbers[_i];
+            b.value=msg.value/_numbers.length;
+            b.result=-1;
+            
+            bets[n].push(b);
+        }
+        
+        
+        if(utils.inArray(playerBetBNumber[msg.sender],n)==false){
+            playerBetBNumber[msg.sender].push(n);
+        }
+        
+        emit guessEvt(msg.sender,_numbers, msg.value);
+        
+        return _numbers.length;
+    }
+    
+
+    function getPlayerGuessNumbers() view public returns (uint[],uint[],uint256[],int8[],uint[]){
+        uint _c=0;
+        uint _i=0;
+        uint _j=0;
+        uint _bnumber;
+        uint limitRows=100;
+        
+        while(_i < playerBetBNumber[msg.sender].length){
+            _bnumber=playerBetBNumber[msg.sender][_i];
+            for(_j=0 ; _j < bets[_bnumber].length && _c < limitRows ; _j++){
+                if(msg.sender==bets[_bnumber][_j].addr){
+                    _c++;
+                }
+            }
+            _i++;
+        }
+
+        uint[] memory _blockNumbers=new uint[](_c);
+        uint[] memory _numbers=new uint[](_c);
+        uint[] memory _values=new uint[](_c);
+        int8[] memory _result=new int8[](_c);
+        uint[] memory _prize=new uint[](_c);
+        
+        if(_c<=0){
+            return(_blockNumbers,_numbers,_values,_result,_prize);
+        }
+
+         
+
+        uint _count=0;
+        for(_i=0 ; _i < playerBetBNumber[msg.sender].length ; _i++){
+            _bnumber=playerBetBNumber[msg.sender][_i];
+            
+            for(_j=0 ; _j < bets[_bnumber].length && _count < limitRows ; _j++){
+                if(bets[_bnumber][_j].addr == msg.sender){
+                    _blockNumbers[_count] = _bnumber;
+                    _numbers[_count] =  bets[_bnumber][_j].number;
+                    _values[_count] =  bets[_bnumber][_j].value;
+                    _result[_count] =  bets[_bnumber][_j].result;
+                    _prize[_count] =  bets[_bnumber][_j].prize;
+                    
+                    _count++;
+                }
+            }
+        }
+
+
+        return(_blockNumbers,_numbers,_values,_result,_prize);
+    }
+    
+
+    function draw(uint _blockNumber,uint _blockTimestamp) public onlyOwner returns (uint){
+        require(block.number >= curOpenBNumber + blockInterval);
+
+         
+        curOpenBNumber=_blockNumber;
+        uint result=_blockTimestamp % numberRange;
+        winResult[_blockNumber]=result;
+
+        for(uint _i=0;_i < bets[_blockNumber].length;_i++){
+             
+            
+            
+            if(bets[_blockNumber][_i].number==result){
+                bets[_blockNumber][_i].result = 1;
+                bets[_blockNumber][_i].prize = bets[_blockNumber][_i].value * odds;
+                
+                emit winnersEvt(_blockNumber,bets[_blockNumber][_i].addr,bets[_blockNumber][_i].value,bets[_blockNumber][_i].prize);
+
+                withdraw(bets[_blockNumber][_i].addr,bets[_blockNumber][_i].prize);
+
+            }else{
+                bets[_blockNumber][_i].result = 0;
+                bets[_blockNumber][_i].prize = 0;
+            }
+        }
+        
+        emit drawEvt(_blockNumber,curOpenBNumber);
+        
+        return result;
+    }
+    
+    function getWinners(uint _blockNumber) view public returns(address[],uint[]){
+        uint _count=winners[_blockNumber].length;
+        
+        address[] memory _addresses = new address[](_count);
+        uint[] memory _prize = new uint[](_count);
+        
+        uint _i=0;
+        for(_i=0;_i<_count;_i++){
+             
+            _prize[_i] = winners[_blockNumber][_i].prize;
+        }
+
+        return (_addresses,_prize);
+    }
+
+    function getWinResults(uint _blockNumber) view public returns(uint){
+        return winResult[_blockNumber];
+    }
+    
+    function withdraw(address _to,uint amount) public onlyOwner returns(bool){
+        require(address(this).balance.sub(amount) > 0);
+        _to.transfer(amount);
+        
+        emit withdrawEvt(_to,amount);
+        return true;
+    }
+    
+    
+    function invest() isHuman payable public returns(uint){
+        require(msg.value >= 1 ether,"Minima amoun:1 ether");
+        
+        Sponsors[msg.sender] = Sponsors[msg.sender].add(msg.value);
+        balanceOfSPS = balanceOfSPS.add(msg.value);
+        
+        if(!utils.inArray(SponsorAddresses,msg.sender)){
+            SponsorAddresses.push(msg.sender);
+            emit sponseEvt(msg.sender,msg.value);
+        }
+
+        return Sponsors[msg.sender];
+    }
+    
+    function distribute() public onlyOwner{
+        if(address(this).balance < reservefund){
+            return;
+        }
+        
+        uint availableProfits=address(this).balance.sub(reservefund);
+        uint prft1=availableProfits.mul(3 ether).div(10 ether);
+        uint prft2=availableProfits.sub(prft1);
+        
+        uint _val=0;
+        uint _i=0;
+        
+        for(_i=0;_i<SponsorAddresses.length;_i++){
+            _val = (prft1 * Sponsors[SponsorAddresses[_i]]) / (balanceOfSPS);
+            SponsorAddresses[_i].transfer(_val);
+        }
+        
+        uint w1p=prft2.mul(3 ether).div(10 ether);
+        
+        wallet1.transfer(w1p);
+        wallet2.transfer(prft2.sub(w1p));
+    }
+    
+    function sharesOfSPS() view public returns(uint,uint){
+        return (Sponsors[msg.sender],balanceOfSPS);
+    }
+    
+    function getAllSponsors() view public returns(address[],uint[],uint){
+        uint _i=0;
+        uint _c=0;
+        for(_i=0;_i<SponsorAddresses.length;_i++){
+            _c+=1;
+        }
+        
+        address[] memory addrs=new address[](_c);
+        uint[] memory amounts=new uint[](_c);
+
+        for(_i=0;_i<SponsorAddresses.length;_i++){
+            addrs[_i]=SponsorAddresses[_i];
+            amounts[_i]=Sponsors[SponsorAddresses[_i]];
+        }
+        
+        return(addrs,amounts,balanceOfSPS);
+    }
+
+    function() payable isHuman() public {
+    }
+    
+  
+}

smart_contract_dataset/block number dependency/215.sol

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

smart_contract_dataset/block number dependency/216.sol

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

smart_contract_dataset/block number dependency/217.sol

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

smart_contract_dataset/block number dependency/220.sol

@@ -0,0 +1,222 @@
+pragma solidity ^0.4.24;
+
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
+     
+     
+     
+    if (a == 0) {
+      return 0;
+    }
+
+    c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+     
+     
+    return a / b;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
+    c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+   
+  constructor() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+   
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+   
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}
+
+contract Claimable is Ownable {
+  address public pendingOwner;
+
+   
+  modifier onlyPendingOwner() {
+    require(msg.sender == pendingOwner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) onlyOwner public {
+    pendingOwner = newOwner;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+  }
+}
+
+contract SimpleFlyDropToken is Claimable {
+    using SafeMath for uint256;
+
+    ERC20 internal erc20tk;
+
+    function setToken(address _token) onlyOwner public {
+        require(_token != address(0));
+        erc20tk = ERC20(_token);
+    }
+
+     
+    function multiSend(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(_destAddrs.length == _values.length);
+
+        uint256 i = 0;
+        for (; i < _destAddrs.length; i = i.add(1)) {
+            if (!erc20tk.transfer(_destAddrs[i], _values[i])) {
+                break;
+            }
+        }
+
+        return (i);
+    }
+}
+
+contract DelayedClaimable is Claimable {
+
+  uint256 public end;
+  uint256 public start;
+
+   
+  function setLimits(uint256 _start, uint256 _end) onlyOwner public {
+    require(_start <= _end);
+    end = _end;
+    start = _start;
+  }
+
+   
+  function claimOwnership() onlyPendingOwner public {
+    require((block.number <= end) && (block.number >= start));
+    emit OwnershipTransferred(owner, pendingOwner);
+    owner = pendingOwner;
+    pendingOwner = address(0);
+    end = 0;
+  }
+
+}
+
+contract FlyDropTokenMgr is DelayedClaimable {
+    using SafeMath for uint256;
+
+    address[] dropTokenAddrs;
+    SimpleFlyDropToken currentDropTokenContract;
+     
+
+     
+    function prepare(uint256 _rand,
+                     address _from,
+                     address _token,
+                     uint256 _value) onlyOwner public returns (bool) {
+        require(_token != address(0));
+        require(_from != address(0));
+        require(_rand > 0);
+
+        if (ERC20(_token).allowance(_from, this) < _value) {
+            return false;
+        }
+
+        if (_rand > dropTokenAddrs.length) {
+            SimpleFlyDropToken dropTokenContract = new SimpleFlyDropToken();
+            dropTokenAddrs.push(address(dropTokenContract));
+            currentDropTokenContract = dropTokenContract;
+        } else {
+            currentDropTokenContract = SimpleFlyDropToken(dropTokenAddrs[_rand.sub(1)]);
+        }
+
+        currentDropTokenContract.setToken(_token);
+        return ERC20(_token).transferFrom(_from, currentDropTokenContract, _value);
+         
+         
+         
+    }
+
+     
+     
+     
+
+     
+     
+
+     
+    function flyDrop(address[] _destAddrs, uint256[] _values) onlyOwner public returns (uint256) {
+        require(address(currentDropTokenContract) != address(0));
+        return currentDropTokenContract.multiSend(_destAddrs, _values);
+    }
+
+}
+
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender)
+    public view returns (uint256);
+
+  function transferFrom(address from, address to, uint256 value)
+    public returns (bool);
+
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(
+    address indexed owner,
+    address indexed spender,
+    uint256 value
+  );
+}

smart_contract_dataset/block number dependency/2295.sol

@@ -0,0 +1,269 @@
+pragma solidity ^0.4.24;
+
+ 
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+ 
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+ 
+contract ERC20OldBasic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public;
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+ 
+contract ERC20Old is ERC20OldBasic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public;
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+    uint256 c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+ 
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+   
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+   
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+     
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+   
+  function balanceOf(address _owner) public view returns (uint256 balance) {
+    return balances[_owner];
+  }
+
+}
+
+ 
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+
+   
+  function Ownable() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) public onlyOwner {
+    require(newOwner != address(0));
+    OwnershipTransferred(owner, newOwner);
+    owner = newOwner;
+  }
+
+}
+
+ 
+
+contract WrapperLock is BasicToken, Ownable {
+    using SafeMath for uint256;
+
+
+    address public TRANSFER_PROXY;
+    mapping (address => bool) public isSigner;
+
+    bool public erc20old;
+    string public name;
+    string public symbol;
+    uint public decimals;
+    address public originalToken;
+
+    mapping (address => uint256) public depositLock;
+    mapping (address => uint256) public balances;
+
+    function WrapperLock(address _originalToken, string _name, string _symbol, uint _decimals, address _transferProxy, bool _erc20old) Ownable() {
+        originalToken = _originalToken;
+        TRANSFER_PROXY = _transferProxy;
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+        isSigner[msg.sender] = true;
+        erc20old = _erc20old;
+    }
+
+    function deposit(uint _value, uint _forTime) public returns (bool success) {
+        require(_forTime >= 1);
+        require(now + _forTime * 1 hours >= depositLock[msg.sender]);
+        if (erc20old) {
+            ERC20Old(originalToken).transferFrom(msg.sender, address(this), _value);
+        } else {
+            require(ERC20(originalToken).transferFrom(msg.sender, address(this), _value));
+        }
+        balances[msg.sender] = balances[msg.sender].add(_value);
+        totalSupply_ = totalSupply_.add(_value);
+        depositLock[msg.sender] = now + _forTime * 1 hours;
+        return true;
+    }
+
+    function withdraw(
+        uint _value,
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint signatureValidUntilBlock
+    )
+        public
+        returns
+        (bool success)
+    {
+        require(balanceOf(msg.sender) >= _value);
+        if (now <= depositLock[msg.sender]) {
+            require(block.number < signatureValidUntilBlock);
+            require(isValidSignature(keccak256(msg.sender, address(this), signatureValidUntilBlock), v, r, s));
+        }
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        totalSupply_ = totalSupply_.sub(_value);
+        depositLock[msg.sender] = 0;
+        if (erc20old) {
+            ERC20Old(originalToken).transfer(msg.sender, _value);
+        } else {
+            require(ERC20(originalToken).transfer(msg.sender, _value));
+        }
+        return true;
+    }
+
+    function withdrawBalanceDifference() public onlyOwner returns (bool success) {
+        require(ERC20(originalToken).balanceOf(address(this)).sub(totalSupply_) > 0);
+        if (erc20old) {
+            ERC20Old(originalToken).transfer(msg.sender, ERC20(originalToken).balanceOf(address(this)).sub(totalSupply_));
+        } else {
+            require(ERC20(originalToken).transfer(msg.sender, ERC20(originalToken).balanceOf(address(this)).sub(totalSupply_)));
+        }
+        return true;
+    }
+
+    function withdrawDifferentToken(address _differentToken, bool _erc20old) public onlyOwner returns (bool) {
+        require(_differentToken != originalToken);
+        require(ERC20(_differentToken).balanceOf(address(this)) > 0);
+        if (_erc20old) {
+            ERC20Old(_differentToken).transfer(msg.sender, ERC20(_differentToken).balanceOf(address(this)));
+        } else {
+            require(ERC20(_differentToken).transfer(msg.sender, ERC20(_differentToken).balanceOf(address(this))));
+        }
+        return true;
+    }
+
+    function transfer(address _to, uint256 _value) public returns (bool) {
+        return false;
+    }
+
+    function transferFrom(address _from, address _to, uint _value) public {
+        require(isSigner[_to] || isSigner[_from]);
+        assert(msg.sender == TRANSFER_PROXY);
+        balances[_to] = balances[_to].add(_value);
+        depositLock[_to] = depositLock[_to] > now ? depositLock[_to] : now + 1 hours;
+        balances[_from] = balances[_from].sub(_value);
+        Transfer(_from, _to, _value);
+    }
+
+    function allowance(address _owner, address _spender) public constant returns (uint) {
+        if (_spender == TRANSFER_PROXY) {
+            return 2**256 - 1;
+        }
+    }
+
+    function balanceOf(address _owner) public constant returns (uint256) {
+        return balances[_owner];
+    }
+
+    function isValidSignature(
+        bytes32 hash,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    )
+        public
+        constant
+        returns (bool)
+    {
+        return isSigner[ecrecover(
+            keccak256("\x19Ethereum Signed Message:\n32", hash),
+            v,
+            r,
+            s
+        )];
+    }
+
+    function addSigner(address _newSigner) public {
+        require(isSigner[msg.sender]);
+        isSigner[_newSigner] = true;
+    }
+
+    function keccak(address _sender, address _wrapper, uint _validTill) public constant returns(bytes32) {
+        return keccak256(_sender, _wrapper, _validTill);
+    }
+
+}

smart_contract_dataset/block number dependency/2296.sol

@@ -0,0 +1,247 @@
+pragma solidity 0.4.24;
+
+ 
+contract ERC20Basic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+ 
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+ 
+contract ERC20OldBasic {
+  function totalSupply() public view returns (uint256);
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public;
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+ 
+contract ERC20Old is ERC20OldBasic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public;
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+     
+    uint256 c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+ 
+contract BasicToken is ERC20Basic {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+
+  uint256 totalSupply_;
+
+   
+  function totalSupply() public view returns (uint256) {
+    return totalSupply_;
+  }
+
+   
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+     
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+   
+  function balanceOf(address _owner) public view returns (uint256 balance) {
+    return balances[_owner];
+  }
+
+}
+
+ 
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+
+   
+  function Ownable() public {
+    owner = msg.sender;
+  }
+
+   
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  function transferOwnership(address newOwner) public onlyOwner {
+    require(newOwner != address(0));
+    OwnershipTransferred(owner, newOwner);
+    owner = newOwner;
+  }
+
+}
+
+ 
+
+contract WrapperLockEth is BasicToken, Ownable {
+    using SafeMath for uint256;
+
+    address public TRANSFER_PROXY;
+    mapping (address => bool) public isSigner;
+
+    string public name;
+    string public symbol;
+    uint public decimals;
+    address public originalToken = 0x00;
+
+    mapping (address => uint) public depositLock;
+    mapping (address => uint256) public balances;
+
+    function WrapperLockEth(string _name, string _symbol, uint _decimals, address _transferProxy) Ownable() {
+        TRANSFER_PROXY = _transferProxy;
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+        isSigner[msg.sender] = true;
+    }
+
+    function deposit(uint _value, uint _forTime) public payable returns (bool success) {
+        require(_forTime >= 1);
+        require(now + _forTime * 1 hours >= depositLock[msg.sender]);
+        balances[msg.sender] = balances[msg.sender].add(msg.value);
+        totalSupply_ = totalSupply_.add(msg.value);
+        depositLock[msg.sender] = now + _forTime * 1 hours;
+        return true;
+    }
+
+    function withdraw(
+        uint _value,
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint signatureValidUntilBlock
+    )
+        public
+        returns
+        (bool)
+    {
+        require(balanceOf(msg.sender) >= _value);
+        if (now > depositLock[msg.sender]) {
+            balances[msg.sender] = balances[msg.sender].sub(_value);
+            totalSupply_ = totalSupply_.sub(msg.value);
+            msg.sender.transfer(_value);
+        } else {
+            require(block.number < signatureValidUntilBlock);
+            require(isValidSignature(keccak256(msg.sender, address(this), signatureValidUntilBlock), v, r, s));
+            balances[msg.sender] = balances[msg.sender].sub(_value);
+            totalSupply_ = totalSupply_.sub(msg.value);
+            depositLock[msg.sender] = 0;
+            msg.sender.transfer(_value);
+        }
+        return true;
+    }
+
+    function withdrawDifferentToken(address _token, bool _erc20old) public onlyOwner returns (bool) {
+        require(ERC20(_token).balanceOf(address(this)) > 0);
+        if (_erc20old) {
+            ERC20Old(_token).transfer(msg.sender, ERC20(_token).balanceOf(address(this)));
+        } else {
+            ERC20(_token).transfer(msg.sender, ERC20(_token).balanceOf(address(this)));
+        }
+        return true;
+    }
+
+    function transfer(address _to, uint256 _value) public returns (bool) {
+        return false;
+    }
+
+    function transferFrom(address _from, address _to, uint _value) public {
+        require(isSigner[_to] || isSigner[_from]);
+        assert(msg.sender == TRANSFER_PROXY);
+        balances[_to] = balances[_to].add(_value);
+        depositLock[_to] = depositLock[_to] > now ? depositLock[_to] : now + 1 hours;
+        balances[_from] = balances[_from].sub(_value);
+        Transfer(_from, _to, _value);
+    }
+
+    function allowance(address _owner, address _spender) public constant returns (uint) {
+        if (_spender == TRANSFER_PROXY) {
+            return 2**256 - 1;
+        }
+    }
+
+    function balanceOf(address _owner) public constant returns (uint256) {
+        return balances[_owner];
+    }
+
+    function isValidSignature(
+        bytes32 hash,
+        uint8 v,
+        bytes32 r,
+        bytes32 s)
+        public
+        constant
+        returns (bool)
+    {
+        return isSigner[ecrecover(
+            keccak256("\x19Ethereum Signed Message:\n32", hash),
+            v,
+            r,
+            s
+        )];
+    }
+
+    function addSigner(address _newSigner) public {
+        require(isSigner[msg.sender]);
+        isSigner[_newSigner] = true;
+    }
+
+    function keccak(address _sender, address _wrapper, uint _validTill) public constant returns(bytes32) {
+        return keccak256(_sender, _wrapper, _validTill);
+    }
+}

smart_contract_dataset/block number dependency/238.sol

@@ -0,0 +1,183 @@
+pragma solidity ^0.4.12;
+
+
+ 
+
+
+
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+ 
+ 
+contract SafeMath {
+ 
+ 
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+ 
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+ 
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+ 
+}
+ 
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+ 
+ 
+ 
+contract StandardToken is Token {
+ 
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+ 
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+ 
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+ 
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+ 
+contract DEJToken is StandardToken, SafeMath {
+ 
+     
+    string  public constant name = "De Home";
+    string  public constant symbol = "DEJ";
+    uint256 public constant decimals = 18;
+    string  public version = "1.0";
+ 
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+ 
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+ 
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+ 
+     
+
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+ 
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+ 
+     
+    function DEJToken()
+    {
+        ethFundDeposit  = 0x697e6C6845212AE294E55E0adB13977de0F0BD37;
+ 
+        isFunding = false;                            
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+ 
+        currentSupply = formatDecimals(1000000000);
+        totalSupply = formatDecimals(1000000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+ 
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+    
+
+ 
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+ 
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+ 
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+ 
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+ 
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+ 
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+ 
+
+ 
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+}

smart_contract_dataset/block number dependency/246.sol

@@ -0,0 +1,1532 @@
+pragma solidity ^0.4.24;
+
+
+ 
+contract PEpsilon {
+  Pinakion public pinakion;
+  Kleros public court;
+
+  uint public balance;
+  uint public disputeID;
+  uint public desiredOutcome;
+  uint public epsilon;
+  bool public settled;
+  uint public maxAppeals;  
+  mapping (address => uint) public withdraw;  
+
+  address public attacker;
+  uint public remainingWithdraw;  
+
+  modifier onlyBy(address _account) {require(msg.sender == _account); _;}
+
+  event AmountShift(uint val, uint epsilon ,address juror);
+  event Log(uint val, address addr, string message);
+
+   
+  constructor(Pinakion _pinakion, Kleros _kleros, uint _disputeID, uint _desiredOutcome, uint _epsilon, uint _maxAppeals) public {
+    pinakion = _pinakion;
+    court = _kleros;
+    disputeID = _disputeID;
+    desiredOutcome = _desiredOutcome;
+    epsilon = _epsilon;
+    attacker = msg.sender;
+    maxAppeals = _maxAppeals;
+  }
+
+   
+  function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
+    require(pinakion.transferFrom(_from, this, _amount));
+
+    balance += _amount;
+  }
+
+   
+  function withdrawJuror() {
+    withdrawSelect(msg.sender);
+  }
+
+   
+  function withdrawSelect(address _juror) {
+    uint amount = withdraw[_juror];
+    withdraw[_juror] = 0;
+
+    balance = sub(balance, amount);  
+    remainingWithdraw = sub(remainingWithdraw, amount);
+
+     
+    require(pinakion.transfer(_juror, amount));
+  }
+
+   
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    assert(_b <= _a);
+    return _a - _b;
+  }
+
+   
+  function withdrawAttacker(){
+    require(settled);
+
+    if (balance > remainingWithdraw) {
+       
+      uint amount = balance - remainingWithdraw;
+      balance = remainingWithdraw;
+
+      require(pinakion.transfer(attacker, amount));
+    }
+  }
+
+   
+  function settle() public {
+    require(court.disputeStatus(disputeID) ==  Arbitrator.DisputeStatus.Solved);  
+    require(!settled);  
+
+    settled = true;  
+
+     
+    var (, , appeals, choices, , , ,) = court.disputes(disputeID);
+
+    if (court.currentRuling(disputeID) != desiredOutcome){
+       
+      uint amountShift = court.getStakePerDraw();
+      uint winningChoice = court.getWinningChoice(disputeID, appeals);
+
+       
+      for (uint i=0; i <= (appeals > maxAppeals ? maxAppeals : appeals); i++){  
+
+         
+         
+        if (winningChoice != 0){
+           
+           
+          uint votesLen = 0;
+          for (uint c = 0; c <= choices; c++) {  
+            votesLen += court.getVoteCount(disputeID, i, c);
+          }
+
+          emit Log(amountShift, 0x0 ,"stakePerDraw");
+          emit Log(votesLen, 0x0, "votesLen");
+
+          uint totalToRedistribute = 0;
+          uint nbCoherent = 0;
+
+           
+          for (uint j=0; j < votesLen; j++){
+            uint voteRuling = court.getVoteRuling(disputeID, i, j);
+            address voteAccount = court.getVoteAccount(disputeID, i, j);
+
+            emit Log(voteRuling, voteAccount, "voted");
+
+            if (voteRuling != winningChoice){
+              totalToRedistribute += amountShift;
+
+              if (voteRuling == desiredOutcome){  
+                 
+                withdraw[voteAccount] += amountShift + epsilon;
+                remainingWithdraw += amountShift + epsilon;
+                emit AmountShift(amountShift, epsilon, voteAccount);
+              }
+            } else {
+              nbCoherent++;
+            }
+          }
+           
+          uint toRedistribute = (totalToRedistribute - amountShift) / (nbCoherent + 1);
+
+           
+          for (j = 0; j < votesLen; j++){
+            voteRuling = court.getVoteRuling(disputeID, i, j);
+            voteAccount = court.getVoteAccount(disputeID, i, j);
+
+            if (voteRuling == desiredOutcome){
+               
+              withdraw[voteAccount] += toRedistribute;
+              remainingWithdraw += toRedistribute;
+              emit AmountShift(toRedistribute, 0, voteAccount);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+ 
+
+pragma solidity ^0.4.24;
+
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
+}
+
+ 
+contract TokenController {
+     
+     
+     
+    function proxyPayment(address _owner) public payable returns(bool);
+
+     
+     
+     
+     
+     
+     
+    function onTransfer(address _from, address _to, uint _amount) public returns(bool);
+
+     
+     
+     
+     
+     
+     
+    function onApprove(address _owner, address _spender, uint _amount) public
+        returns(bool);
+}
+
+contract Controlled {
+     
+     
+    modifier onlyController { require(msg.sender == controller); _; }
+
+    address public controller;
+
+    function Controlled() public { controller = msg.sender;}
+
+     
+     
+    function changeController(address _newController) public onlyController {
+        controller = _newController;
+    }
+}
+
+ 
+ 
+ 
+contract Pinakion is Controlled {
+
+    string public name;                 
+    uint8 public decimals;              
+    string public symbol;               
+    string public version = 'MMT_0.2';  
+
+
+     
+     
+     
+    struct  Checkpoint {
+
+         
+        uint128 fromBlock;
+
+         
+        uint128 value;
+    }
+
+     
+     
+    Pinakion public parentToken;
+
+     
+     
+    uint public parentSnapShotBlock;
+
+     
+    uint public creationBlock;
+
+     
+     
+     
+    mapping (address => Checkpoint[]) balances;
+
+     
+    mapping (address => mapping (address => uint256)) allowed;
+
+     
+    Checkpoint[] totalSupplyHistory;
+
+     
+    bool public transfersEnabled;
+
+     
+    MiniMeTokenFactory public tokenFactory;
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+    function Pinakion(
+        address _tokenFactory,
+        address _parentToken,
+        uint _parentSnapShotBlock,
+        string _tokenName,
+        uint8 _decimalUnits,
+        string _tokenSymbol,
+        bool _transfersEnabled
+    ) public {
+        tokenFactory = MiniMeTokenFactory(_tokenFactory);
+        name = _tokenName;                                  
+        decimals = _decimalUnits;                           
+        symbol = _tokenSymbol;                              
+        parentToken = Pinakion(_parentToken);
+        parentSnapShotBlock = _parentSnapShotBlock;
+        transfersEnabled = _transfersEnabled;
+        creationBlock = block.number;
+    }
+
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+    function transfer(address _to, uint256 _amount) public returns (bool success) {
+        require(transfersEnabled);
+        doTransfer(msg.sender, _to, _amount);
+        return true;
+    }
+
+     
+     
+     
+     
+     
+     
+    function transferFrom(address _from, address _to, uint256 _amount
+    ) public returns (bool success) {
+
+         
+         
+         
+         
+        if (msg.sender != controller) {
+            require(transfersEnabled);
+
+             
+            require(allowed[_from][msg.sender] >= _amount);
+            allowed[_from][msg.sender] -= _amount;
+        }
+        doTransfer(_from, _to, _amount);
+        return true;
+    }
+
+     
+     
+     
+     
+     
+     
+    function doTransfer(address _from, address _to, uint _amount
+    ) internal {
+
+           if (_amount == 0) {
+               Transfer(_from, _to, _amount);     
+               return;
+           }
+
+           require(parentSnapShotBlock < block.number);
+
+            
+           require((_to != 0) && (_to != address(this)));
+
+            
+            
+           var previousBalanceFrom = balanceOfAt(_from, block.number);
+
+           require(previousBalanceFrom >= _amount);
+
+            
+           if (isContract(controller)) {
+               require(TokenController(controller).onTransfer(_from, _to, _amount));
+           }
+
+            
+            
+           updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
+
+            
+            
+           var previousBalanceTo = balanceOfAt(_to, block.number);
+           require(previousBalanceTo + _amount >= previousBalanceTo);  
+           updateValueAtNow(balances[_to], previousBalanceTo + _amount);
+
+            
+           Transfer(_from, _to, _amount);
+
+    }
+
+     
+     
+    function balanceOf(address _owner) public constant returns (uint256 balance) {
+        return balanceOfAt(_owner, block.number);
+    }
+
+     
+     
+     
+     
+     
+    function approve(address _spender, uint256 _amount) public returns (bool success) {
+        require(transfersEnabled);
+
+         
+        if (isContract(controller)) {
+            require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
+        }
+
+        allowed[msg.sender][_spender] = _amount;
+        Approval(msg.sender, _spender, _amount);
+        return true;
+    }
+
+     
+     
+     
+     
+     
+    function allowance(address _owner, address _spender
+    ) public constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+     
+     
+     
+     
+     
+     
+     
+    function approveAndCall(address _spender, uint256 _amount, bytes _extraData
+    ) public returns (bool success) {
+        require(approve(_spender, _amount));
+
+        ApproveAndCallFallBack(_spender).receiveApproval(
+            msg.sender,
+            _amount,
+            this,
+            _extraData
+        );
+
+        return true;
+    }
+
+     
+     
+    function totalSupply() public constant returns (uint) {
+        return totalSupplyAt(block.number);
+    }
+
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+    function balanceOfAt(address _owner, uint _blockNumber) public constant
+        returns (uint) {
+
+         
+         
+         
+         
+         
+        if ((balances[_owner].length == 0)
+            || (balances[_owner][0].fromBlock > _blockNumber)) {
+            if (address(parentToken) != 0) {
+                return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
+            } else {
+                 
+                return 0;
+            }
+
+         
+        } else {
+            return getValueAt(balances[_owner], _blockNumber);
+        }
+    }
+
+     
+     
+     
+    function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
+
+         
+         
+         
+         
+         
+        if ((totalSupplyHistory.length == 0)
+            || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
+            if (address(parentToken) != 0) {
+                return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
+            } else {
+                return 0;
+            }
+
+         
+        } else {
+            return getValueAt(totalSupplyHistory, _blockNumber);
+        }
+    }
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+    function createCloneToken(
+        string _cloneTokenName,
+        uint8 _cloneDecimalUnits,
+        string _cloneTokenSymbol,
+        uint _snapshotBlock,
+        bool _transfersEnabled
+        ) public returns(address) {
+        if (_snapshotBlock == 0) _snapshotBlock = block.number;
+        Pinakion cloneToken = tokenFactory.createCloneToken(
+            this,
+            _snapshotBlock,
+            _cloneTokenName,
+            _cloneDecimalUnits,
+            _cloneTokenSymbol,
+            _transfersEnabled
+            );
+
+        cloneToken.changeController(msg.sender);
+
+         
+        NewCloneToken(address(cloneToken), _snapshotBlock);
+        return address(cloneToken);
+    }
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+    function generateTokens(address _owner, uint _amount
+    ) public onlyController returns (bool) {
+        uint curTotalSupply = totalSupply();
+        require(curTotalSupply + _amount >= curTotalSupply);  
+        uint previousBalanceTo = balanceOf(_owner);
+        require(previousBalanceTo + _amount >= previousBalanceTo);  
+        updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
+        updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
+        Transfer(0, _owner, _amount);
+        return true;
+    }
+
+
+     
+     
+     
+     
+    function destroyTokens(address _owner, uint _amount
+    ) onlyController public returns (bool) {
+        uint curTotalSupply = totalSupply();
+        require(curTotalSupply >= _amount);
+        uint previousBalanceFrom = balanceOf(_owner);
+        require(previousBalanceFrom >= _amount);
+        updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
+        updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
+        Transfer(_owner, 0, _amount);
+        return true;
+    }
+
+ 
+ 
+ 
+
+
+     
+     
+    function enableTransfers(bool _transfersEnabled) public onlyController {
+        transfersEnabled = _transfersEnabled;
+    }
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+    function getValueAt(Checkpoint[] storage checkpoints, uint _block
+    ) constant internal returns (uint) {
+        if (checkpoints.length == 0) return 0;
+
+         
+        if (_block >= checkpoints[checkpoints.length-1].fromBlock)
+            return checkpoints[checkpoints.length-1].value;
+        if (_block < checkpoints[0].fromBlock) return 0;
+
+         
+        uint min = 0;
+        uint max = checkpoints.length-1;
+        while (max > min) {
+            uint mid = (max + min + 1)/ 2;
+            if (checkpoints[mid].fromBlock<=_block) {
+                min = mid;
+            } else {
+                max = mid-1;
+            }
+        }
+        return checkpoints[min].value;
+    }
+
+     
+     
+     
+     
+    function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
+    ) internal  {
+        if ((checkpoints.length == 0)
+        || (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
+               Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
+               newCheckPoint.fromBlock =  uint128(block.number);
+               newCheckPoint.value = uint128(_value);
+           } else {
+               Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
+               oldCheckPoint.value = uint128(_value);
+           }
+    }
+
+     
+     
+     
+    function isContract(address _addr) constant internal returns(bool) {
+        uint size;
+        if (_addr == 0) return false;
+        assembly {
+            size := extcodesize(_addr)
+        }
+        return size>0;
+    }
+
+     
+    function min(uint a, uint b) pure internal returns (uint) {
+        return a < b ? a : b;
+    }
+
+     
+     
+     
+    function () public payable {
+        require(isContract(controller));
+        require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
+    }
+
+ 
+ 
+ 
+
+     
+     
+     
+     
+    function claimTokens(address _token) public onlyController {
+        if (_token == 0x0) {
+            controller.transfer(this.balance);
+            return;
+        }
+
+        Pinakion token = Pinakion(_token);
+        uint balance = token.balanceOf(this);
+        token.transfer(controller, balance);
+        ClaimedTokens(_token, controller, balance);
+    }
+
+ 
+ 
+ 
+    event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
+    event Transfer(address indexed _from, address indexed _to, uint256 _amount);
+    event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
+    event Approval(
+        address indexed _owner,
+        address indexed _spender,
+        uint256 _amount
+        );
+
+}
+
+
+ 
+ 
+ 
+
+ 
+ 
+ 
+contract MiniMeTokenFactory {
+
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+    function createCloneToken(
+        address _parentToken,
+        uint _snapshotBlock,
+        string _tokenName,
+        uint8 _decimalUnits,
+        string _tokenSymbol,
+        bool _transfersEnabled
+    ) public returns (Pinakion) {
+        Pinakion newToken = new Pinakion(
+            this,
+            _parentToken,
+            _snapshotBlock,
+            _tokenName,
+            _decimalUnits,
+            _tokenSymbol,
+            _transfersEnabled
+            );
+
+        newToken.changeController(msg.sender);
+        return newToken;
+    }
+}
+
+contract RNG{
+
+     
+    function contribute(uint _block) public payable;
+
+     
+    function requestRN(uint _block) public payable {
+        contribute(_block);
+    }
+
+     
+    function getRN(uint _block) public returns (uint RN);
+
+     
+    function getUncorrelatedRN(uint _block) public returns (uint RN) {
+        uint baseRN=getRN(_block);
+        if (baseRN==0)
+            return 0;
+        else
+            return uint(keccak256(msg.sender,baseRN));
+    }
+
+ }
+
+ 
+contract BlockHashRNG is RNG {
+
+    mapping (uint => uint) public randomNumber;  
+    mapping (uint => uint) public reward;  
+
+
+
+     
+    function contribute(uint _block) public payable { reward[_block]+=msg.value; }
+
+
+     
+    function getRN(uint _block) public returns (uint RN) {
+        RN=randomNumber[_block];
+        if (RN==0){
+            saveRN(_block);
+            return randomNumber[_block];
+        }
+        else
+            return RN;
+    }
+
+     
+    function saveRN(uint _block) public {
+        if (blockhash(_block) != 0x0)
+            randomNumber[_block] = uint(blockhash(_block));
+        if (randomNumber[_block] != 0) {  
+            uint rewardToSend = reward[_block];
+            reward[_block] = 0;
+            msg.sender.send(rewardToSend);  
+        }
+    }
+
+}
+
+
+ 
+contract BlockHashRNGFallback is BlockHashRNG {
+    
+     
+    function saveRN(uint _block) public {
+        if (_block<block.number && randomNumber[_block]==0) { 
+            if (blockhash(_block)!=0x0)  
+                randomNumber[_block]=uint(blockhash(_block));
+            else  
+                randomNumber[_block]=uint(blockhash(block.number-1));
+        }
+        if (randomNumber[_block] != 0) {  
+            uint rewardToSend=reward[_block];
+            reward[_block]=0;
+            msg.sender.send(rewardToSend);  
+        }
+    }
+    
+}
+
+ 
+contract Arbitrable{
+    Arbitrator public arbitrator;
+    bytes public arbitratorExtraData;  
+
+    modifier onlyArbitrator {require(msg.sender==address(arbitrator)); _;}
+
+     
+    event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
+
+     
+    event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
+
+     
+    event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID);
+
+     
+    event Evidence(Arbitrator indexed _arbitrator, uint indexed _disputeID, address _party, string _evidence);
+
+     
+    constructor(Arbitrator _arbitrator, bytes _arbitratorExtraData) public {
+        arbitrator = _arbitrator;
+        arbitratorExtraData = _arbitratorExtraData;
+    }
+
+     
+    function rule(uint _disputeID, uint _ruling) public onlyArbitrator {
+        emit Ruling(Arbitrator(msg.sender),_disputeID,_ruling);
+
+        executeRuling(_disputeID,_ruling);
+    }
+
+
+     
+    function executeRuling(uint _disputeID, uint _ruling) internal;
+}
+
+ 
+contract Arbitrator{
+
+    enum DisputeStatus {Waiting, Appealable, Solved}
+
+    modifier requireArbitrationFee(bytes _extraData) {require(msg.value>=arbitrationCost(_extraData)); _;}
+    modifier requireAppealFee(uint _disputeID, bytes _extraData) {require(msg.value>=appealCost(_disputeID, _extraData)); _;}
+
+     
+    event AppealPossible(uint _disputeID);
+
+     
+    event DisputeCreation(uint indexed _disputeID, Arbitrable _arbitrable);
+
+     
+    event AppealDecision(uint indexed _disputeID, Arbitrable _arbitrable);
+
+     
+    function createDispute(uint _choices, bytes _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID)  {}
+
+     
+    function arbitrationCost(bytes _extraData) public constant returns(uint fee);
+
+     
+    function appeal(uint _disputeID, bytes _extraData) public requireAppealFee(_disputeID,_extraData) payable {
+        emit AppealDecision(_disputeID, Arbitrable(msg.sender));
+    }
+
+     
+    function appealCost(uint _disputeID, bytes _extraData) public constant returns(uint fee);
+
+     
+    function disputeStatus(uint _disputeID) public constant returns(DisputeStatus status);
+
+     
+    function currentRuling(uint _disputeID) public constant returns(uint ruling);
+
+}
+
+
+
+contract Kleros is Arbitrator, ApproveAndCallFallBack {
+
+     
+     
+     
+
+     
+    Pinakion public pinakion;
+    uint public constant NON_PAYABLE_AMOUNT = (2**256 - 2) / 2;  
+
+     
+     
+    RNG public rng;  
+    uint public arbitrationFeePerJuror = 0.05 ether;  
+    uint16 public defaultNumberJuror = 3;  
+    uint public minActivatedToken = 0.1 * 1e18;  
+    uint[5] public timePerPeriod;  
+    uint public alpha = 2000;  
+    uint constant ALPHA_DIVISOR = 1e4;  
+    uint public maxAppeals = 5;  
+     
+     
+    address public governor;  
+
+     
+    uint public session = 1;       
+    uint public lastPeriodChange;  
+    uint public segmentSize;       
+    uint public rnBlock;           
+    uint public randomNumber;      
+
+    enum Period {
+        Activation,  
+        Draw,        
+        Vote,        
+        Appeal,      
+        Execution    
+    }
+
+    Period public period;
+
+    struct Juror {
+        uint balance;       
+        uint atStake;       
+        uint lastSession;   
+        uint segmentStart;  
+        uint segmentEnd;    
+    }
+
+    mapping (address => Juror) public jurors;
+
+    struct Vote {
+        address account;  
+        uint ruling;      
+    }
+
+    struct VoteCounter {
+        uint winningChoice;  
+        uint winningCount;   
+        mapping (uint => uint) voteCount;  
+    }
+
+    enum DisputeState {
+        Open,        
+        Resolving,   
+        Executable,  
+        Executed     
+    }
+
+    struct Dispute {
+        Arbitrable arbitrated;        
+        uint session;                 
+        uint appeals;                 
+        uint choices;                 
+        uint16 initialNumberJurors;   
+        uint arbitrationFeePerJuror;  
+        DisputeState state;           
+        Vote[][] votes;               
+        VoteCounter[] voteCounter;    
+        mapping (address => uint) lastSessionVote;  
+        uint currentAppealToRepartition;  
+        AppealsRepartitioned[] appealsRepartitioned;  
+    }
+
+    enum RepartitionStage {  
+        Incoherent,
+        Coherent,
+        AtStake,
+        Complete
+    }
+
+    struct AppealsRepartitioned {
+        uint totalToRedistribute;    
+        uint nbCoherent;             
+        uint currentIncoherentVote;  
+        uint currentCoherentVote;    
+        uint currentAtStakeVote;     
+        RepartitionStage stage;      
+    }
+
+    Dispute[] public disputes;
+
+     
+     
+     
+
+     
+    event NewPeriod(Period _period, uint indexed _session);
+
+     
+    event TokenShift(address indexed _account, uint _disputeID, int _amount);
+
+     
+    event ArbitrationReward(address indexed _account, uint _disputeID, uint _amount);
+
+     
+     
+     
+    modifier onlyBy(address _account) {require(msg.sender == _account); _;}
+    modifier onlyDuring(Period _period) {require(period == _period); _;}
+    modifier onlyGovernor() {require(msg.sender == governor); _;}
+
+
+     
+    constructor(Pinakion _pinakion, RNG _rng, uint[5] _timePerPeriod, address _governor) public {
+        pinakion = _pinakion;
+        rng = _rng;
+        lastPeriodChange = now;
+        timePerPeriod = _timePerPeriod;
+        governor = _governor;
+    }
+
+     
+     
+     
+     
+
+     
+    function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
+        require(pinakion.transferFrom(_from, this, _amount));
+
+        jurors[_from].balance += _amount;
+    }
+
+     
+    function withdraw(uint _value) public {
+        Juror storage juror = jurors[msg.sender];
+        require(juror.atStake <= juror.balance);  
+        require(_value <= juror.balance-juror.atStake);
+        require(juror.lastSession != session);
+
+        juror.balance -= _value;
+        require(pinakion.transfer(msg.sender,_value));
+    }
+
+     
+     
+     
+     
+
+     
+    function passPeriod() public {
+        require(now-lastPeriodChange >= timePerPeriod[uint8(period)]);
+
+        if (period == Period.Activation) {
+            rnBlock = block.number + 1;
+            rng.requestRN(rnBlock);
+            period = Period.Draw;
+        } else if (period == Period.Draw) {
+            randomNumber = rng.getUncorrelatedRN(rnBlock);
+            require(randomNumber != 0);
+            period = Period.Vote;
+        } else if (period == Period.Vote) {
+            period = Period.Appeal;
+        } else if (period == Period.Appeal) {
+            period = Period.Execution;
+        } else if (period == Period.Execution) {
+            period = Period.Activation;
+            ++session;
+            segmentSize = 0;
+            rnBlock = 0;
+            randomNumber = 0;
+        }
+
+
+        lastPeriodChange = now;
+        NewPeriod(period, session);
+    }
+
+
+     
+    function activateTokens(uint _value) public onlyDuring(Period.Activation) {
+        Juror storage juror = jurors[msg.sender];
+        require(_value <= juror.balance);
+        require(_value >= minActivatedToken);
+        require(juror.lastSession != session);  
+
+        juror.lastSession = session;
+        juror.segmentStart = segmentSize;
+        segmentSize += _value;
+        juror.segmentEnd = segmentSize;
+
+    }
+
+     
+    function voteRuling(uint _disputeID, uint _ruling, uint[] _draws) public onlyDuring(Period.Vote) {
+        Dispute storage dispute = disputes[_disputeID];
+        Juror storage juror = jurors[msg.sender];
+        VoteCounter storage voteCounter = dispute.voteCounter[dispute.appeals];
+        require(dispute.lastSessionVote[msg.sender] != session);  
+        require(_ruling <= dispute.choices);
+         
+        require(validDraws(msg.sender, _disputeID, _draws));
+
+        dispute.lastSessionVote[msg.sender] = session;
+        voteCounter.voteCount[_ruling] += _draws.length;
+        if (voteCounter.winningCount < voteCounter.voteCount[_ruling]) {
+            voteCounter.winningCount = voteCounter.voteCount[_ruling];
+            voteCounter.winningChoice = _ruling;
+        } else if (voteCounter.winningCount==voteCounter.voteCount[_ruling] && _draws.length!=0) {  
+            voteCounter.winningChoice = 0;  
+        }
+        for (uint i = 0; i < _draws.length; ++i) {
+            dispute.votes[dispute.appeals].push(Vote({
+                account: msg.sender,
+                ruling: _ruling
+            }));
+        }
+
+        juror.atStake += _draws.length * getStakePerDraw();
+        uint feeToPay = _draws.length * dispute.arbitrationFeePerJuror;
+        msg.sender.transfer(feeToPay);
+        ArbitrationReward(msg.sender, _disputeID, feeToPay);
+    }
+
+     
+    function penalizeInactiveJuror(address _jurorAddress, uint _disputeID, uint[] _draws) public {
+        Dispute storage dispute = disputes[_disputeID];
+        Juror storage inactiveJuror = jurors[_jurorAddress];
+        require(period > Period.Vote);
+        require(dispute.lastSessionVote[_jurorAddress] != session);  
+        dispute.lastSessionVote[_jurorAddress] = session;  
+        require(validDraws(_jurorAddress, _disputeID, _draws));
+        uint penality = _draws.length * minActivatedToken * 2 * alpha / ALPHA_DIVISOR;
+        penality = (penality < inactiveJuror.balance) ? penality : inactiveJuror.balance;  
+        inactiveJuror.balance -= penality;
+        TokenShift(_jurorAddress, _disputeID, -int(penality));
+        jurors[msg.sender].balance += penality / 2;  
+        TokenShift(msg.sender, _disputeID, int(penality / 2));
+        jurors[governor].balance += penality / 2;  
+        TokenShift(governor, _disputeID, int(penality / 2));
+        msg.sender.transfer(_draws.length*dispute.arbitrationFeePerJuror);  
+    }
+
+     
+    function oneShotTokenRepartition(uint _disputeID) public onlyDuring(Period.Execution) {
+        Dispute storage dispute = disputes[_disputeID];
+        require(dispute.state == DisputeState.Open);
+        require(dispute.session+dispute.appeals <= session);
+
+        uint winningChoice = dispute.voteCounter[dispute.appeals].winningChoice;
+        uint amountShift = getStakePerDraw();
+        for (uint i = 0; i <= dispute.appeals; ++i) {
+             
+             
+             
+            if (winningChoice!=0 || (dispute.voteCounter[dispute.appeals].voteCount[0] == dispute.voteCounter[dispute.appeals].winningCount)) {
+                uint totalToRedistribute = 0;
+                uint nbCoherent = 0;
+                 
+                for (uint j = 0; j < dispute.votes[i].length; ++j) {
+                    Vote storage vote = dispute.votes[i][j];
+                    if (vote.ruling != winningChoice) {
+                        Juror storage juror = jurors[vote.account];
+                        uint penalty = amountShift<juror.balance ? amountShift : juror.balance;
+                        juror.balance -= penalty;
+                        TokenShift(vote.account, _disputeID, int(-penalty));
+                        totalToRedistribute += penalty;
+                    } else {
+                        ++nbCoherent;
+                    }
+                }
+                if (nbCoherent == 0) {  
+                    jurors[governor].balance += totalToRedistribute;
+                    TokenShift(governor, _disputeID, int(totalToRedistribute));
+                } else {  
+                    uint toRedistribute = totalToRedistribute / nbCoherent;  
+                     
+                    for (j = 0; j < dispute.votes[i].length; ++j) {
+                        vote = dispute.votes[i][j];
+                        if (vote.ruling == winningChoice) {
+                            juror = jurors[vote.account];
+                            juror.balance += toRedistribute;
+                            TokenShift(vote.account, _disputeID, int(toRedistribute));
+                        }
+                    }
+                }
+            }
+             
+            for (j = 0; j < dispute.votes[i].length; ++j) {
+                vote = dispute.votes[i][j];
+                juror = jurors[vote.account];
+                juror.atStake -= amountShift;  
+            }
+        }
+        dispute.state = DisputeState.Executable;  
+    }
+
+     
+    function multipleShotTokenRepartition(uint _disputeID, uint _maxIterations) public onlyDuring(Period.Execution) {
+        Dispute storage dispute = disputes[_disputeID];
+        require(dispute.state <= DisputeState.Resolving);
+        require(dispute.session+dispute.appeals <= session);
+        dispute.state = DisputeState.Resolving;  
+
+        uint winningChoice = dispute.voteCounter[dispute.appeals].winningChoice;
+        uint amountShift = getStakePerDraw();
+        uint currentIterations = 0;  
+        for (uint i = dispute.currentAppealToRepartition; i <= dispute.appeals; ++i) {
+             
+            if (dispute.appealsRepartitioned.length < i+1) {
+                dispute.appealsRepartitioned.length++;
+            }
+
+             
+            if (winningChoice==0 && (dispute.voteCounter[dispute.appeals].voteCount[0] != dispute.voteCounter[dispute.appeals].winningCount)) {
+                 
+                dispute.appealsRepartitioned[i].stage = RepartitionStage.AtStake;
+            }
+
+             
+            if (dispute.appealsRepartitioned[i].stage == RepartitionStage.Incoherent) {
+                for (uint j = dispute.appealsRepartitioned[i].currentIncoherentVote; j < dispute.votes[i].length; ++j) {
+                    if (currentIterations >= _maxIterations) {
+                        return;
+                    }
+                    Vote storage vote = dispute.votes[i][j];
+                    if (vote.ruling != winningChoice) {
+                        Juror storage juror = jurors[vote.account];
+                        uint penalty = amountShift<juror.balance ? amountShift : juror.balance;
+                        juror.balance -= penalty;
+                        TokenShift(vote.account, _disputeID, int(-penalty));
+                        dispute.appealsRepartitioned[i].totalToRedistribute += penalty;
+                    } else {
+                        ++dispute.appealsRepartitioned[i].nbCoherent;
+                    }
+
+                    ++dispute.appealsRepartitioned[i].currentIncoherentVote;
+                    ++currentIterations;
+                }
+
+                dispute.appealsRepartitioned[i].stage = RepartitionStage.Coherent;
+            }
+
+             
+            if (dispute.appealsRepartitioned[i].stage == RepartitionStage.Coherent) {
+                if (dispute.appealsRepartitioned[i].nbCoherent == 0) {  
+                    jurors[governor].balance += dispute.appealsRepartitioned[i].totalToRedistribute;
+                    TokenShift(governor, _disputeID, int(dispute.appealsRepartitioned[i].totalToRedistribute));
+                    dispute.appealsRepartitioned[i].stage = RepartitionStage.AtStake;
+                } else {  
+                    uint toRedistribute = dispute.appealsRepartitioned[i].totalToRedistribute / dispute.appealsRepartitioned[i].nbCoherent;  
+                     
+                    for (j = dispute.appealsRepartitioned[i].currentCoherentVote; j < dispute.votes[i].length; ++j) {
+                        if (currentIterations >= _maxIterations) {
+                            return;
+                        }
+                        vote = dispute.votes[i][j];
+                        if (vote.ruling == winningChoice) {
+                            juror = jurors[vote.account];
+                            juror.balance += toRedistribute;
+                            TokenShift(vote.account, _disputeID, int(toRedistribute));
+                        }
+
+                        ++currentIterations;
+                        ++dispute.appealsRepartitioned[i].currentCoherentVote;
+                    }
+
+                    dispute.appealsRepartitioned[i].stage = RepartitionStage.AtStake;
+                }
+            }
+
+            if (dispute.appealsRepartitioned[i].stage == RepartitionStage.AtStake) {
+                 
+                for (j = dispute.appealsRepartitioned[i].currentAtStakeVote; j < dispute.votes[i].length; ++j) {
+                    if (currentIterations >= _maxIterations) {
+                        return;
+                    }
+                    vote = dispute.votes[i][j];
+                    juror = jurors[vote.account];
+                    juror.atStake -= amountShift;  
+
+                    ++currentIterations;
+                    ++dispute.appealsRepartitioned[i].currentAtStakeVote;
+                }
+
+                dispute.appealsRepartitioned[i].stage = RepartitionStage.Complete;
+            }
+
+            if (dispute.appealsRepartitioned[i].stage == RepartitionStage.Complete) {
+                ++dispute.currentAppealToRepartition;
+            }
+        }
+
+        dispute.state = DisputeState.Executable;
+    }
+
+     
+     
+     
+     
+
+     
+    function amountJurors(uint _disputeID) public view returns (uint nbJurors) {
+        Dispute storage dispute = disputes[_disputeID];
+        return (dispute.initialNumberJurors + 1) * 2**dispute.appeals - 1;
+    }
+
+     
+    function validDraws(address _jurorAddress, uint _disputeID, uint[] _draws) public view returns (bool valid) {
+        uint draw = 0;
+        Juror storage juror = jurors[_jurorAddress];
+        Dispute storage dispute = disputes[_disputeID];
+        uint nbJurors = amountJurors(_disputeID);
+
+        if (juror.lastSession != session) return false;  
+        if (dispute.session+dispute.appeals != session) return false;  
+        if (period <= Period.Draw) return false;  
+        for (uint i = 0; i < _draws.length; ++i) {
+            if (_draws[i] <= draw) return false;  
+            draw = _draws[i];
+            if (draw > nbJurors) return false;
+            uint position = uint(keccak256(randomNumber, _disputeID, draw)) % segmentSize;  
+            require(position >= juror.segmentStart);
+            require(position < juror.segmentEnd);
+        }
+
+        return true;
+    }
+
+     
+     
+     
+     
+
+     
+    function createDispute(uint _choices, bytes _extraData) public payable returns (uint disputeID) {
+        uint16 nbJurors = extraDataToNbJurors(_extraData);
+        require(msg.value >= arbitrationCost(_extraData));
+
+        disputeID = disputes.length++;
+        Dispute storage dispute = disputes[disputeID];
+        dispute.arbitrated = Arbitrable(msg.sender);
+        if (period < Period.Draw)  
+            dispute.session = session;
+        else  
+            dispute.session = session+1;
+        dispute.choices = _choices;
+        dispute.initialNumberJurors = nbJurors;
+        dispute.arbitrationFeePerJuror = arbitrationFeePerJuror;  
+        dispute.votes.length++;
+        dispute.voteCounter.length++;
+
+        DisputeCreation(disputeID, Arbitrable(msg.sender));
+        return disputeID;
+    }
+
+     
+    function appeal(uint _disputeID, bytes _extraData) public payable onlyDuring(Period.Appeal) {
+        super.appeal(_disputeID,_extraData);
+        Dispute storage dispute = disputes[_disputeID];
+        require(msg.value >= appealCost(_disputeID, _extraData));
+        require(dispute.session+dispute.appeals == session);  
+        require(dispute.arbitrated == msg.sender);
+        
+        dispute.appeals++;
+        dispute.votes.length++;
+        dispute.voteCounter.length++;
+    }
+
+     
+    function executeRuling(uint disputeID) public {
+        Dispute storage dispute = disputes[disputeID];
+        require(dispute.state == DisputeState.Executable);
+
+        dispute.state = DisputeState.Executed;
+        dispute.arbitrated.rule(disputeID, dispute.voteCounter[dispute.appeals].winningChoice);
+    }
+
+     
+     
+     
+     
+
+     
+    function arbitrationCost(bytes _extraData) public view returns (uint fee) {
+        return extraDataToNbJurors(_extraData) * arbitrationFeePerJuror;
+    }
+
+     
+    function appealCost(uint _disputeID, bytes _extraData) public view returns (uint fee) {
+        Dispute storage dispute = disputes[_disputeID];
+
+        if(dispute.appeals >= maxAppeals) return NON_PAYABLE_AMOUNT;
+
+        return (2*amountJurors(_disputeID) + 1) * dispute.arbitrationFeePerJuror;
+    }
+
+     
+    function extraDataToNbJurors(bytes _extraData) internal view returns (uint16 nbJurors) {
+        if (_extraData.length < 2)
+            return defaultNumberJuror;
+        else
+            return (uint16(_extraData[0]) << 8) + uint16(_extraData[1]);
+    }
+
+     
+    function getStakePerDraw() public view returns (uint minActivatedTokenInAlpha) {
+        return (alpha * minActivatedToken) / ALPHA_DIVISOR;
+    }
+
+
+     
+     
+     
+
+     
+    function getVoteAccount(uint _disputeID, uint _appeals, uint _voteID) public view returns (address account) {
+        return disputes[_disputeID].votes[_appeals][_voteID].account;
+    }
+
+     
+    function getVoteRuling(uint _disputeID, uint _appeals, uint _voteID) public view returns (uint ruling) {
+        return disputes[_disputeID].votes[_appeals][_voteID].ruling;
+    }
+
+     
+    function getWinningChoice(uint _disputeID, uint _appeals) public view returns (uint winningChoice) {
+        return disputes[_disputeID].voteCounter[_appeals].winningChoice;
+    }
+
+     
+    function getWinningCount(uint _disputeID, uint _appeals) public view returns (uint winningCount) {
+        return disputes[_disputeID].voteCounter[_appeals].winningCount;
+    }
+
+     
+    function getVoteCount(uint _disputeID, uint _appeals, uint _choice) public view returns (uint voteCount) {
+        return disputes[_disputeID].voteCounter[_appeals].voteCount[_choice];
+    }
+
+     
+    function getLastSessionVote(uint _disputeID, address _juror) public view returns (uint lastSessionVote) {
+        return disputes[_disputeID].lastSessionVote[_juror];
+    }
+
+     
+    function isDrawn(uint _disputeID, address _juror, uint _draw) public view returns (bool drawn) {
+        Dispute storage dispute = disputes[_disputeID];
+        Juror storage juror = jurors[_juror];
+        if (juror.lastSession != session
+        || (dispute.session+dispute.appeals != session)
+        || period<=Period.Draw
+        || _draw>amountJurors(_disputeID)
+        || _draw==0
+        || segmentSize==0
+        ) {
+            return false;
+        } else {
+            uint position = uint(keccak256(randomNumber,_disputeID,_draw)) % segmentSize;
+            return (position >= juror.segmentStart) && (position < juror.segmentEnd);
+        }
+
+    }
+
+     
+    function currentRuling(uint _disputeID) public view returns (uint ruling) {
+        Dispute storage dispute = disputes[_disputeID];
+        return dispute.voteCounter[dispute.appeals].winningChoice;
+    }
+
+     
+    function disputeStatus(uint _disputeID) public view returns (DisputeStatus status) {
+        Dispute storage dispute = disputes[_disputeID];
+        if (dispute.session+dispute.appeals < session)  
+            return DisputeStatus.Solved;
+        else if(dispute.session+dispute.appeals == session) {  
+            if (dispute.state == DisputeState.Open) {
+                if (period < Period.Appeal)
+                    return DisputeStatus.Waiting;
+                else if (period == Period.Appeal)
+                    return DisputeStatus.Appealable;
+                else return DisputeStatus.Solved;
+            } else return DisputeStatus.Solved;
+        } else return DisputeStatus.Waiting;  
+    }
+
+     
+     
+     
+
+     
+    function executeOrder(bytes32 _data, uint _value, address _target) public onlyGovernor {
+        _target.call.value(_value)(_data);
+    }
+
+     
+    function setRng(RNG _rng) public onlyGovernor {
+        rng = _rng;
+    }
+
+     
+    function setArbitrationFeePerJuror(uint _arbitrationFeePerJuror) public onlyGovernor {
+        arbitrationFeePerJuror = _arbitrationFeePerJuror;
+    }
+
+     
+    function setDefaultNumberJuror(uint16 _defaultNumberJuror) public onlyGovernor {
+        defaultNumberJuror = _defaultNumberJuror;
+    }
+
+     
+    function setMinActivatedToken(uint _minActivatedToken) public onlyGovernor {
+        minActivatedToken = _minActivatedToken;
+    }
+
+     
+    function setTimePerPeriod(uint[5] _timePerPeriod) public onlyGovernor {
+        timePerPeriod = _timePerPeriod;
+    }
+
+     
+    function setAlpha(uint _alpha) public onlyGovernor {
+        alpha = _alpha;
+    }
+
+     
+    function setMaxAppeals(uint _maxAppeals) public onlyGovernor {
+        maxAppeals = _maxAppeals;
+    }
+
+     
+    function setGovernor(address _governor) public onlyGovernor {
+        governor = _governor;
+    }
+}

smart_contract_dataset/block number dependency/2584.sol

@@ -0,0 +1,402 @@
+pragma solidity ^0.4.23;
+
+ 
+
+contract ZTHReceivingContract {
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+
+contract ZTHInterface {
+  function getFrontEndTokenBalanceOf(address who) public view returns (uint);
+  function transfer(address _to, uint _value) public returns (bool);
+  function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zethroll is ZTHReceivingContract {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber) {
+     require( calculateProfit(_betSize, _playerNumber) < maxProfit
+             && _betSize >= minBet
+             && _playerNumber > minNumber
+             && _playerNumber < maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 99;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+  address public ZethrBankroll;
+  address public ZTHTKNADDR;
+
+  ZTHInterface public ZTHTKN;
+
+  uint public contractBalance;
+  uint public houseEdge;
+  uint public maxProfit;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address zthtknaddr, address zthbankrolladdr) public {
+     
+    owner = msg.sender;
+
+     
+    ZTHTKN = ZTHInterface(zthtknaddr);
+    ZTHTKNADDR = zthtknaddr;
+
+     
+    ZethrBankroll = zthbankrolladdr;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+
+     
+    ZTHTKN.approve(zthbankrolladdr, MAX_INT);
+  }
+
+  function() public payable {}  
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint200 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+  function _playerRollDice(uint _rollUnder, TKN _tkn) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder)
+  {
+    require(_tkn.value < ((2 ** 200) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+
+     
+     
+
+     
+    require(_zthToken(msg.sender));
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(false, _tkn.sender);
+    }
+
+     
+    roll.blockn = uint48(block.number);
+    roll.tokenValue = uint200(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(true, msg.sender);
+  }
+
+   
+  function _finishBet(bool delete_it, address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(99, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+      
+        if (profit > maxProfit){
+            profit = maxProfit;
+        }
+
+       
+      contractBalance = contractBalance.sub(profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit();
+
+
+         
+        delete playerRolls[target];
+
+
+       
+      ZTHTKN.transfer(target, profit + roll.tokenValue);
+      
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      contractBalance = contractBalance.add(roll.tokenValue);
+
+       
+       
+
+       
+      setMaxProfit();
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
+    require(msg.sender == ZTHTKNADDR);
+    if (_from == ZethrBankroll) {
+       
+      contractBalance = contractBalance.add(_value);
+
+       
+      uint oldMaxProfit = maxProfit;
+      setMaxProfit();
+
+      emit MaxProfitChanged(oldMaxProfit, maxProfit);
+      return true;
+
+    } else {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn);
+    }
+
+    return true;
+  }
+
+   
+  function setMaxProfit() internal {
+    emit CurrentContractBalance(contractBalance);
+    maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance) public
+  onlyOwner
+  {
+    contractBalance = newContractBalance;
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit();
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerTransferZTH(address sendTo, uint amount) public
+  onlyOwner
+  {
+     
+    contractBalance = contractBalance.sub(amount);
+
+     
+    setMaxProfit();
+    require(ZTHTKN.transfer(sendTo, amount));
+    emit LogOwnerTransfer(sendTo, amount);
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerSetBankroll(address newBankroll) public
+  onlyOwner
+  {
+    ZTHTKN.approve(ZethrBankroll, 0);
+    ZethrBankroll = newBankroll;
+    ZTHTKN.approve(newBankroll, MAX_INT);
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+    ZTHTKN.transfer(owner, contractBalance);
+    selfdestruct(owner);
+  }
+  
+  function dumpdivs() public{
+      ZethrBankroll.transfer(address(this).balance);
+  }
+
+  function _zthToken(address _tokenContract) private view returns (bool) {
+    return _tokenContract == ZTHTKNADDR;
+     
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/2587.sol

@@ -0,0 +1,402 @@
+pragma solidity ^0.4.23;
+
+ 
+
+contract ZTHReceivingContract {
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+
+contract ZTHInterface {
+  function getFrontEndTokenBalanceOf(address who) public view returns (uint);
+  function transfer(address _to, uint _value) public returns (bool);
+  function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zethroll is ZTHReceivingContract {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber) {
+     require( calculateProfit(_betSize, _playerNumber) < maxProfit
+             && _betSize >= minBet
+             && _playerNumber > minNumber
+             && _playerNumber < maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 99;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+  address public ZethrBankroll;
+  address public ZTHTKNADDR;
+
+  ZTHInterface public ZTHTKN;
+
+  uint public contractBalance;
+  uint public houseEdge;
+  uint public maxProfit;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address zthtknaddr, address zthbankrolladdr) public {
+     
+    owner = msg.sender;
+
+     
+    ZTHTKN = ZTHInterface(zthtknaddr);
+    ZTHTKNADDR = zthtknaddr;
+
+     
+    ZethrBankroll = zthbankrolladdr;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+
+     
+    ZTHTKN.approve(zthbankrolladdr, MAX_INT);
+  }
+
+  function() public payable {}  
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint200 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+  function _playerRollDice(uint _rollUnder, TKN _tkn) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder)
+  {
+    require(_tkn.value < ((2 ** 200) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+
+     
+     
+
+     
+    require(_zthToken(msg.sender));
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(false, _tkn.sender);
+    }
+
+     
+    roll.blockn = uint48(block.number);
+    roll.tokenValue = uint200(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(true, msg.sender);
+  }
+
+   
+  function _finishBet(bool delete_it, address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(99, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+      
+        if (profit > maxProfit){
+            profit = maxProfit;
+        }
+
+       
+      contractBalance = contractBalance.sub(profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit();
+
+      if (delete_it){
+         
+        delete playerRolls[target];
+      }
+
+       
+      ZTHTKN.transfer(target, profit + roll.tokenValue);
+      
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      contractBalance = contractBalance.add(roll.tokenValue);
+
+       
+       
+
+       
+      setMaxProfit();
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
+    require(msg.sender == ZTHTKNADDR);
+    if (_from == ZethrBankroll) {
+       
+      contractBalance = contractBalance.add(_value);
+
+       
+      uint oldMaxProfit = maxProfit;
+      setMaxProfit();
+
+      emit MaxProfitChanged(oldMaxProfit, maxProfit);
+      return true;
+
+    } else {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn);
+    }
+
+    return true;
+  }
+
+   
+  function setMaxProfit() internal {
+    emit CurrentContractBalance(contractBalance);
+    maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance) public
+  onlyOwner
+  {
+    contractBalance = newContractBalance;
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit();
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerTransferZTH(address sendTo, uint amount) public
+  onlyOwner
+  {
+     
+    contractBalance = contractBalance.sub(amount);
+
+     
+    setMaxProfit();
+    require(ZTHTKN.transfer(sendTo, amount));
+    emit LogOwnerTransfer(sendTo, amount);
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerSetBankroll(address newBankroll) public
+  onlyOwner
+  {
+    ZTHTKN.approve(ZethrBankroll, 0);
+    ZethrBankroll = newBankroll;
+    ZTHTKN.approve(newBankroll, MAX_INT);
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+    ZTHTKN.transfer(owner, contractBalance);
+    selfdestruct(owner);
+  }
+  
+  function dumpdivs() public{
+      ZethrBankroll.transfer(address(this).balance);
+  }
+
+  function _zthToken(address _tokenContract) private view returns (bool) {
+    return _tokenContract == ZTHTKNADDR;
+     
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/2589.sol

@@ -0,0 +1,398 @@
+pragma solidity ^0.4.23;
+
+ 
+
+contract ZTHReceivingContract {
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+
+contract ZTHInterface {
+  function getFrontEndTokenBalanceOf(address who) public view returns (uint);
+  function transfer(address _to, uint _value) public returns (bool);
+  function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zethroll is ZTHReceivingContract {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber) {
+     require( calculateProfit(_betSize, _playerNumber) < maxProfit
+             && _betSize >= minBet
+             && _playerNumber > minNumber
+             && _playerNumber < maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 99;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+  address public ZethrBankroll;
+  address public ZTHTKNADDR;
+
+  ZTHInterface public ZTHTKN;
+
+  uint public contractBalance;
+  uint public houseEdge;
+  uint public maxProfit;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address zthtknaddr, address zthbankrolladdr) public {
+     
+    owner = msg.sender;
+
+     
+    ZTHTKN = ZTHInterface(zthtknaddr);
+    ZTHTKNADDR = zthtknaddr;
+
+     
+    ZethrBankroll = zthbankrolladdr;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+
+     
+    ZTHTKN.approve(zthbankrolladdr, MAX_INT);
+  }
+
+  function() public payable {}  
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint200 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+  function _playerRollDice(uint _rollUnder, TKN _tkn) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder)
+  {
+    require(_tkn.value < ((2 ** 200) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+
+     
+     
+
+     
+    require(_zthToken(msg.sender));
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(false, _tkn.sender);
+    }
+
+     
+    roll.blockn = uint40(block.number);
+    roll.tokenValue = uint200(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(true, msg.sender);
+  }
+
+   
+  function _finishBet(bool delete_it, address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(99, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+
+       
+      contractBalance = contractBalance.sub(profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit();
+
+      if (delete_it){
+         
+        delete playerRolls[target];
+      }
+
+       
+      ZTHTKN.transfer(target, profit + roll.tokenValue);
+      
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      contractBalance = contractBalance.add(roll.tokenValue);
+
+       
+       
+
+       
+      setMaxProfit();
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
+    require(msg.sender == ZTHTKNADDR);
+    if (_from == ZethrBankroll) {
+       
+      contractBalance = contractBalance.add(_value);
+
+       
+      uint oldMaxProfit = maxProfit;
+      setMaxProfit();
+
+      emit MaxProfitChanged(oldMaxProfit, maxProfit);
+      return true;
+
+    } else {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn);
+    }
+
+    return true;
+  }
+
+   
+  function setMaxProfit() internal {
+    emit CurrentContractBalance(contractBalance);
+    maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance) public
+  onlyOwner
+  {
+    contractBalance = newContractBalance;
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit();
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerTransferZTH(address sendTo, uint amount) public
+  onlyOwner
+  {
+     
+    contractBalance = contractBalance.sub(amount);
+
+     
+    setMaxProfit();
+    require(ZTHTKN.transfer(sendTo, amount));
+    emit LogOwnerTransfer(sendTo, amount);
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerSetBankroll(address newBankroll) public
+  onlyOwner
+  {
+    ZTHTKN.approve(ZethrBankroll, 0);
+    ZethrBankroll = newBankroll;
+    ZTHTKN.approve(newBankroll, MAX_INT);
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+    ZTHTKN.transfer(owner, contractBalance);
+    selfdestruct(owner);
+  }
+  
+  function dumpdivs() public{
+      ZethrBankroll.transfer(address(this).balance);
+  }
+
+  function _zthToken(address _tokenContract) private view returns (bool) {
+    return _tokenContract == ZTHTKNADDR;
+     
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/2593.sol

@@ -0,0 +1,397 @@
+pragma solidity ^0.4.23;
+
+ 
+
+contract ZTHReceivingContract {
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
+}
+
+
+contract ZTHInterface {
+  function getFrontEndTokenBalanceOf(address who) public view returns (uint);
+  function transfer(address _to, uint _value) public returns (bool);
+  function approve(address spender, uint tokens) public returns (bool);
+}
+
+contract Zethroll is ZTHReceivingContract {
+  using SafeMath for uint;
+
+   
+   
+  modifier betIsValid(uint _betSize, uint _playerNumber) {
+     require( calculateProfit(_betSize, _playerNumber) < maxProfit
+             && _betSize >= minBet
+             && _playerNumber > minNumber
+             && _playerNumber < maxNumber);
+    _;
+  }
+
+   
+  modifier gameIsActive {
+    require(gamePaused == false);
+    _;
+  }
+
+   
+  modifier onlyOwner {
+    require(msg.sender == owner);
+    _;
+  }
+
+   
+  uint constant private MAX_INT = 2 ** 256 - 1;
+  uint constant public maxProfitDivisor = 1000000;
+  uint constant public maxNumber = 99;
+  uint constant public minNumber = 2;
+  uint constant public houseEdgeDivisor = 1000;
+
+   
+  bool public gamePaused;
+
+  address public owner;
+  address public ZethrBankroll;
+  address public ZTHTKNADDR;
+
+  ZTHInterface public ZTHTKN;
+
+  uint public contractBalance;
+  uint public houseEdge;
+  uint public maxProfit;
+  uint public maxProfitAsPercentOfHouse;
+  uint public minBet = 0;
+
+   
+  uint public totalBets;
+  uint public totalZTHWagered;
+
+   
+
+   
+  event LogBet(address sender, uint value, uint rollUnder);
+
+   
+   
+  event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
+
+   
+  event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
+
+   
+  event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
+
+   
+  event CurrentContractBalance(uint _tokens);
+  
+  constructor (address zthtknaddr, address zthbankrolladdr) public {
+     
+    owner = msg.sender;
+
+     
+    ZTHTKN = ZTHInterface(zthtknaddr);
+    ZTHTKNADDR = zthtknaddr;
+
+     
+    ZethrBankroll = zthbankrolladdr;
+
+     
+    houseEdge = 990;
+
+     
+    ownerSetMaxProfitAsPercentOfHouse(10000);
+
+     
+    ownerSetMinBet(1e18);
+
+     
+    ZTHTKN.approve(zthbankrolladdr, MAX_INT);
+  }
+
+  function() public payable {}  
+
+   
+   
+  function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
+    return uint256(keccak256(
+        abi.encodePacked(
+        blockhash(blockn),
+        entropy)
+      ));
+  }
+
+   
+  function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
+    return maxRandom(blockn, entropy) % upper;
+  }
+
+   
+  function calculateProfit(uint _initBet, uint _roll)
+    private
+    view
+    returns (uint)
+  {
+    return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
+  }
+
+   
+  struct playerRoll{
+    uint200 tokenValue;  
+    uint48 blockn;       
+    uint8 rollUnder;     
+  }
+
+   
+  mapping(address => playerRoll) public playerRolls;
+
+  function _playerRollDice(uint _rollUnder, TKN _tkn) private
+    gameIsActive
+    betIsValid(_tkn.value, _rollUnder)
+  {
+    require(_tkn.value < ((2 ** 200) - 1));    
+    require(block.number < ((2 ** 48) - 1));   
+
+     
+     
+
+     
+    require(_zthToken(msg.sender));
+
+    playerRoll memory roll = playerRolls[_tkn.sender];
+
+     
+    require(block.number != roll.blockn);
+
+     
+    if (roll.blockn != 0) {
+      _finishBet(false, _tkn.sender);
+    }
+
+     
+    roll.blockn = uint40(block.number);
+    roll.tokenValue = uint200(_tkn.value);
+    roll.rollUnder = uint8(_rollUnder);
+
+     
+    playerRolls[_tkn.sender] = roll;
+
+     
+    emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
+                 
+     
+    totalBets += 1;
+
+     
+    totalZTHWagered += _tkn.value;
+  }
+
+   
+  function finishBet() public
+    gameIsActive
+    returns (uint)
+  {
+    return _finishBet(true, msg.sender);
+  }
+
+   
+  function _finishBet(bool delete_it, address target) private returns (uint){
+    playerRoll memory roll = playerRolls[target];
+    require(roll.tokenValue > 0);  
+    require(roll.blockn != block.number);
+     
+     
+    uint result;
+    if (block.number - roll.blockn > 255) {
+      result = 1000;  
+    } else {
+       
+      result = random(99, roll.blockn, target) + 1;
+    }
+
+    uint rollUnder = roll.rollUnder;
+
+    if (result < rollUnder) {
+       
+
+       
+      uint profit = calculateProfit(roll.tokenValue, rollUnder);
+
+       
+      contractBalance = contractBalance.sub(profit);
+
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
+
+       
+      setMaxProfit();
+
+      if (delete_it){
+         
+        delete playerRolls[target];
+      }
+
+       
+      ZTHTKN.transfer(target, profit + roll.tokenValue);
+      
+      return result;
+
+    } else {
+       
+      emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
+
+       
+      contractBalance = contractBalance.add(roll.tokenValue);
+
+       
+       
+
+       
+      setMaxProfit();
+      
+      return result;
+    }
+  }
+
+   
+  struct TKN {address sender; uint value;}
+
+   
+  function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
+    if (_from == ZethrBankroll) {
+       
+      contractBalance = contractBalance.add(_value);
+
+       
+      uint oldMaxProfit = maxProfit;
+      setMaxProfit();
+
+      emit MaxProfitChanged(oldMaxProfit, maxProfit);
+      return true;
+
+    } else {
+      TKN memory _tkn;
+      _tkn.sender = _from;
+      _tkn.value = _value;
+      uint8 chosenNumber = uint8(_data[0]);
+      _playerRollDice(chosenNumber, _tkn);
+    }
+
+    return true;
+  }
+
+   
+  function setMaxProfit() internal {
+    emit CurrentContractBalance(contractBalance);
+    maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
+  }
+
+   
+  function ownerUpdateContractBalance(uint newContractBalance) public
+  onlyOwner
+  {
+    contractBalance = newContractBalance;
+  }
+
+   
+  function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
+  onlyOwner
+  {
+     
+    require(newMaxProfitAsPercent <= 200000);
+    maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
+    setMaxProfit();
+  }
+
+   
+  function ownerSetMinBet(uint newMinimumBet) public
+  onlyOwner
+  {
+    minBet = newMinimumBet;
+  }
+
+   
+  function ownerTransferZTH(address sendTo, uint amount) public
+  onlyOwner
+  {
+     
+    contractBalance = contractBalance.sub(amount);
+
+     
+    setMaxProfit();
+    require(ZTHTKN.transfer(sendTo, amount));
+    emit LogOwnerTransfer(sendTo, amount);
+  }
+
+   
+  function ownerPauseGame(bool newStatus) public
+  onlyOwner
+  {
+    gamePaused = newStatus;
+  }
+
+   
+  function ownerSetBankroll(address newBankroll) public
+  onlyOwner
+  {
+    ZTHTKN.approve(ZethrBankroll, 0);
+    ZethrBankroll = newBankroll;
+    ZTHTKN.approve(newBankroll, MAX_INT);
+  }
+
+   
+  function ownerChangeOwner(address newOwner) public
+  onlyOwner
+  {
+    owner = newOwner;
+  }
+
+   
+  function ownerkill() public
+  onlyOwner
+  {
+    ZTHTKN.transfer(owner, contractBalance);
+    selfdestruct(owner);
+  }
+  
+  function dumpdivs() public{
+      ZethrBankroll.transfer(address(this).balance);
+  }
+
+  function _zthToken(address _tokenContract) private view returns (bool) {
+    return _tokenContract == ZTHTKNADDR;
+     
+  }
+}
+
+ 
+library SafeMath {
+
+   
+  function mul(uint a, uint b) internal pure returns (uint) {
+    if (a == 0) {
+      return 0;
+    }
+    uint c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+   
+  function div(uint a, uint b) internal pure returns (uint) {
+     
+    uint c = a / b;
+     
+    return c;
+  }
+
+   
+  function sub(uint a, uint b) internal pure returns (uint) {
+    assert(b <= a);
+    return a - b;
+  }
+
+   
+  function add(uint a, uint b) internal pure returns (uint) {
+    uint c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

smart_contract_dataset/block number dependency/2619.sol

@@ -0,0 +1,250 @@
+pragma solidity ^0.4.12;
+
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+
+ 
+contract SafeMath {
+
+
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+
+}
+
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+
+
+ 
+contract StandardToken is Token {
+   
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+contract UnityToken is StandardToken, SafeMath {
+
+     
+    string  public constant name = "Ping";
+    string  public constant symbol = "PIN";
+    uint256 public constant decimals = 3;
+    string  public version = "1.0";
+
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+    uint256 public tokenExchangeRate = 3;              
+
+     
+    event AllocateToken(address indexed _to, uint256 _value);    
+    event IssueToken(address indexed _to, uint256 _value);       
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+    event Migrate(address indexed _to, uint256 _value);
+
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+
+     
+    function UnityToken(
+        address _ethFundDeposit,
+        uint256 _currentSupply)
+    {
+        ethFundDeposit = _ethFundDeposit;
+
+        isFunding = false;                            
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+
+        currentSupply = formatDecimals(_currentSupply);
+        totalSupply = formatDecimals(10000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+
+     
+    function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
+        if (_tokenExchangeRate == 0) throw;
+        if (_tokenExchangeRate == tokenExchangeRate) throw;
+
+        tokenExchangeRate = _tokenExchangeRate;
+    }
+
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+
+     
+    function setMigrateContract(address _newContractAddr) isOwner external {
+        if (_newContractAddr == newContractAddr) throw;
+        newContractAddr = _newContractAddr;
+    }
+
+     
+    function changeOwner(address _newFundDeposit) isOwner() external {
+        if (_newFundDeposit == address(0x0)) throw;
+        ethFundDeposit = _newFundDeposit;
+    }
+
+     
+    function migrate() external {
+        if(isFunding) throw;
+        if(newContractAddr == address(0x0)) throw;
+
+        uint256 tokens = balances[msg.sender];
+        if (tokens == 0) throw;
+
+        balances[msg.sender] = 0;
+        tokenMigrated = safeAdd(tokenMigrated, tokens);
+
+        IMigrationContract newContract = IMigrationContract(newContractAddr);
+        if (!newContract.migrate(msg.sender, tokens)) throw;
+
+        Migrate(msg.sender, tokens);                
+    }
+
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+
+     
+    function allocateToken (address _addr, uint256 _fin) isOwner public {
+        if (_fin == 0) throw;
+        if (_addr == address(0x0)) throw;
+
+        uint256 tokens = safeMult(formatDecimals(_fin), tokenExchangeRate);
+
+        if (tokens + tokenRaised > currentSupply) throw;
+
+        tokenRaised = safeAdd(tokenRaised, tokens);
+
+        balances[_addr] += tokens;
+         
+        AllocateToken(_addr, tokens);   
+    }
+
+     
+    function () payable {
+        if (!isFunding) throw;
+        if (msg.value == 0) throw;
+
+        if (block.number < fundingStartBlock) throw;
+        if (block.number > fundingStopBlock) throw;
+
+        uint256 tokens = safeMult(msg.value, tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[msg.sender] += tokens;
+
+        IssueToken(msg.sender, tokens);   
+    }
+}

smart_contract_dataset/block number dependency/2632.sol

@@ -0,0 +1,247 @@
+pragma solidity ^0.4.12;
+ 
+contract IMigrationContract {
+    function migrate(address addr, uint256 nas) returns (bool success);
+}
+ 
+
+contract SafeMath {
+ 
+ 
+    function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x + y;
+        assert((z >= x) && (z >= y));
+        return z;
+    }
+ 
+    function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
+        assert(x >= y);
+        uint256 z = x - y;
+        return z;
+    }
+ 
+    function safeMult(uint256 x, uint256 y) internal returns(uint256) {
+        uint256 z = x * y;
+        assert((x == 0)||(z/x == y));
+        return z;
+    }
+ 
+}
+ 
+contract Token {
+    uint256 public totalSupply;
+    function balanceOf(address _owner) constant returns (uint256 balance);
+    function transfer(address _to, uint256 _value) returns (bool success);
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
+    function approve(address _spender, uint256 _value) returns (bool success);
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+ 
+ 
+ 
+contract StandardToken is Token {
+ 
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        if (balances[msg.sender] >= _value && _value > 0) {
+            balances[msg.sender] -= _value;
+            balances[_to] += _value;
+            Transfer(msg.sender, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
+            balances[_to] += _value;
+            balances[_from] -= _value;
+            allowed[_from][msg.sender] -= _value;
+            Transfer(_from, _to, _value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+ 
+    function balanceOf(address _owner) constant returns (uint256 balance) {
+        return balances[_owner];
+    }
+ 
+    function approve(address _spender, uint256 _value) returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+ 
+    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+ 
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+}
+ 
+contract AntiFakeLabelToken is StandardToken, SafeMath {
+ 
+     
+    string  public constant name = "Anti-Fake Label";
+    string  public constant symbol = "AFL";
+    uint256 public constant decimals = 18;
+    string  public version = "1.0";
+ 
+     
+    address public ethFundDeposit;           
+    address public newContractAddr;          
+ 
+     
+    bool    public isFunding;                 
+    uint256 public fundingStartBlock;
+    uint256 public fundingStopBlock;
+ 
+    uint256 public currentSupply;            
+    uint256 public tokenRaised = 0;          
+    uint256 public tokenMigrated = 0;      
+    uint256 public tokenExchangeRate = 3500;              
+ 
+     
+    event AllocateToken(address indexed _to, uint256 _value);    
+    event IssueToken(address indexed _to, uint256 _value);       
+    event IncreaseSupply(uint256 _value);
+    event DecreaseSupply(uint256 _value);
+    event Migrate(address indexed _to, uint256 _value);
+ 
+     
+    function formatDecimals(uint256 _value) internal returns (uint256 ) {
+        return _value * 10 ** decimals;
+    }
+ 
+     
+    function AntiFakeLabelToken(
+        address _ethFundDeposit,
+        uint256 _currentSupply)
+    {
+        ethFundDeposit = _ethFundDeposit;
+ 
+        isFunding = false;                           
+        fundingStartBlock = 0;
+        fundingStopBlock = 0;
+ 
+        currentSupply = formatDecimals(_currentSupply);
+        totalSupply = formatDecimals(5000000000);
+        balances[msg.sender] = totalSupply;
+        if(currentSupply > totalSupply) throw;
+    }
+ 
+    modifier isOwner()  { require(msg.sender == ethFundDeposit); _; }
+ 
+     
+    function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
+        if (_tokenExchangeRate == 0) throw;
+        if (_tokenExchangeRate == tokenExchangeRate) throw;
+ 
+        tokenExchangeRate = _tokenExchangeRate;
+    }
+ 
+     
+    function increaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + currentSupply > totalSupply) throw;
+        currentSupply = safeAdd(currentSupply, value);
+        IncreaseSupply(value);
+    }
+ 
+     
+    function decreaseSupply (uint256 _value) isOwner external {
+        uint256 value = formatDecimals(_value);
+        if (value + tokenRaised > currentSupply) throw;
+ 
+        currentSupply = safeSubtract(currentSupply, value);
+        DecreaseSupply(value);
+    }
+ 
+     
+    function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
+        if (isFunding) throw;
+        if (_fundingStartBlock >= _fundingStopBlock) throw;
+        if (block.number >= _fundingStartBlock) throw;
+ 
+        fundingStartBlock = _fundingStartBlock;
+        fundingStopBlock = _fundingStopBlock;
+        isFunding = true;
+    }
+ 
+     
+    function stopFunding() isOwner external {
+        if (!isFunding) throw;
+        isFunding = false;
+    }
+ 
+     
+    function setMigrateContract(address _newContractAddr) isOwner external {
+        if (_newContractAddr == newContractAddr) throw;
+        newContractAddr = _newContractAddr;
+    }
+ 
+     
+    function changeOwner(address _newFundDeposit) isOwner() external {
+        if (_newFundDeposit == address(0x0)) throw;
+        ethFundDeposit = _newFundDeposit;
+    }
+ 
+     
+    function migrate() external {
+        if(isFunding) throw;
+        if(newContractAddr == address(0x0)) throw;
+ 
+        uint256 tokens = balances[msg.sender];
+        if (tokens == 0) throw;
+ 
+        balances[msg.sender] = 0;
+        tokenMigrated = safeAdd(tokenMigrated, tokens);
+ 
+        IMigrationContract newContract = IMigrationContract(newContractAddr);
+        if (!newContract.migrate(msg.sender, tokens)) throw;
+ 
+        Migrate(msg.sender, tokens);                
+    }
+ 
+     
+    function transferETH() isOwner external {
+        if (this.balance == 0) throw;
+        if (!ethFundDeposit.send(this.balance)) throw;
+    }
+ 
+     
+    function allocateToken (address _addr, uint256 _eth) isOwner external {
+        if (_eth == 0) throw;
+        if (_addr == address(0x0)) throw;
+ 
+        uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[_addr] += tokens;
+ 
+        AllocateToken(_addr, tokens);   
+    }
+ 
+     
+    function () payable {
+        if (!isFunding) throw;
+        if (msg.value == 0) throw;
+ 
+        if (block.number < fundingStartBlock) throw;
+        if (block.number > fundingStopBlock) throw;
+ 
+        uint256 tokens = safeMult(msg.value, tokenExchangeRate);
+        if (tokens + tokenRaised > currentSupply) throw;
+ 
+        tokenRaised = safeAdd(tokenRaised, tokens);
+        balances[msg.sender] += tokens;
+ 
+        IssueToken(msg.sender, tokens);   
+    }
+}