w8 · tx · EPe···DkE

tx · EPehuPFhgStfmrQBUvLrbvvi4MRHyDE8RryK3iCaKDkE

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.09100000 Waves

2023.08.23 22:21 [2723700] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EPehuPFhgStfmrQBUvLrbvvi4MRHyDE8RryK3iCaKDkE",
    "fee": 9100000,
    "feeAssetId": null,
    "timestamp": 1692818543579,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "4NNumfLGP48gsP4QMUnYmtDCnWapBGBu1cLFjpchYPjgkLrWkMXGWhKi3QBVWHymYuW9uj4frsvYf6cExTEvtyfV"
    ],
    "script": "base64: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",
    "height": 2723700,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8yBi9ULgn4jyeywRT41spXRUyDbgWET2BT9nmWYGjEhZ
Next: EiNWspRUTnBdWA83KEWNiSNjTWE1AVj5MATqwVoJrVMD

Diff: 
Old New Differences
3005 3005  
3006 3006  
3007 3007  @Callable(fo)
3008 - func exitTournaments () = {
3008 + func breakAttempt () = {
3009 3009      let jK = jH(fo)
3010 3010      let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
3011 3011      let lN = bi(s)
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  func a (b) = ("lastArbTimeUser_" + b)
5 5  
6 6  
7 7  let c = 100000000
8 8  
9 9  let d = 3200
10 10  
11 11  let e = 4000
12 12  
13 13  let f = 3
14 14  
15 15  let g = ["Strength", "Accuracy", "Intellect", "Endurance", "Dexterity", "Level", "Health"]
16 16  
17 17  let h = 0
18 18  
19 19  let i = 1
20 20  
21 21  let j = 2
22 22  
23 23  let k = 3
24 24  
25 25  let l = 4
26 26  
27 27  let m = 0
28 28  
29 29  let n = 6
30 30  
31 31  let o = 2
32 32  
33 33  let p = 2
34 34  
35 35  let q = 30
36 36  
37 37  func r (s) = ("duckHealth_" + s)
38 38  
39 39  
40 40  func t (s) = ("duckChars_" + s)
41 41  
42 42  
43 43  func u (s) = ("duckXP_" + s)
44 44  
45 45  
46 46  func v (s) = ("duckLevel_" + s)
47 47  
48 48  
49 49  func w (s) = ("duckFreePoints_" + s)
50 50  
51 51  
52 52  func x (s) = ("duckEquipment_" + s)
53 53  
54 54  
55 55  func y (b) = ("userXP_" + b)
56 56  
57 57  
58 58  func z (b) = ("userLevel_" + b)
59 59  
60 60  
61 61  func A (b) = ("userFreePoints_" + b)
62 62  
63 63  
64 64  func B (s) = ("savedHealth_" + s)
65 65  
66 66  
67 67  func C (s) = ("savedLocation_" + s)
68 68  
69 69  
70 70  func D (s) = ("duckBuffs_" + s)
71 71  
72 72  
73 73  let E = 10000
74 74  
75 75  let F = 10000
76 76  
77 77  let G = 2000
78 78  
79 79  let H = 100000
80 80  
81 81  let I = 1000000
82 82  
83 83  let J = 5000000
84 84  
85 85  let K = 10000
86 86  
87 87  let L = 1000000
88 88  
89 89  let M = 1000000
90 90  
91 91  let N = 10000
92 92  
93 93  func O (P) = fraction(d, pow(P, 4, e, 4, 4, DOWN), c)
94 94  
95 95  
96 96  func Q (R) = (100 + R)
97 97  
98 98  
99 99  func S (T,U) = {
100 100      let V = O(U)
101 101  [V, (f * (V - T))]
102 102      }
103 103  
104 104  
105 105  func W (R) = if (if ((1 > R))
106 106      then true
107 107      else (R > 3))
108 108      then throw(("Invalid ration level: " + toString(R)))
109 109      else {
110 110          let X = [2, 4, 8]
111 111  X[(R - 1)]
112 112          }
113 113  
114 114  
115 115  func Y (Z,s,aa) = {
116 116      let ab = split(valueOrElse(getString(Z, t(s)), "0_0_0_0_0"), "_")
117 117      let ac = valueOrElse(getInteger(Z, v(s)), 0)
118 118      let ad = valueOrElse(getInteger(Z, r(s)), Q(ac))
119 119      let X = split(valueOrElse(getString(Z, D(s)), "0_0_0_0_0"), "_")
120 120  [parseIntValue(ab[h]), parseIntValue(ab[i]), parseIntValue(ab[j]), parseIntValue(ab[k]), parseIntValue(ab[l]), ac, ad, if ((aa > 0))
121 121          then W(aa)
122 122          else parseIntValue(X[h]), if ((aa > 0))
123 123          then W(aa)
124 124          else parseIntValue(X[i]), if ((aa > 0))
125 125          then W(aa)
126 126          else parseIntValue(X[j]), if ((aa > 0))
127 127          then W(aa)
128 128          else parseIntValue(X[k]), if ((aa > 0))
129 129          then W(aa)
130 130          else parseIntValue(X[l])]
131 131      }
132 132  
133 133  
134 134  let ae = "LAND"
135 135  
136 136  let af = "DUCK"
137 137  
138 138  let ag = "PRESALE"
139 139  
140 140  let ah = 6
141 141  
142 142  let ai = 25
143 143  
144 144  let aj = 3456000
145 145  
146 146  let ak = 86400000
147 147  
148 148  let al = 10000000000
149 149  
150 150  let am = "Africa_F_Africa"
151 151  
152 152  let an = 39637
153 153  
154 154  let ao = 10
155 155  
156 156  let ap = ["First Aid Kit L1", "First Aid Kit L2", "First Aid Kit L3", "Backpack L1", "Backpack L2", "Backpack L3", "Food Ration L1", "Food Ration L2", "Food Ration L3", "Jet Pack L1", "Jet Pack L2", "Jet Pack L3", "Shield L1", "Shield L2", "Shield L3", "Mine L1", "Mine L2", "Mine L3", "Trap L1", "Trap L2", "Trap L3"]
157 157  
158 158  let aq = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
159 159  
160 160  let ar = 10000000
161 161  
162 162  let as = [15, 16, 17, 18, 19, 20]
163 163  
164 164  let at = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_30_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_50_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_70_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_"]
165 165  
166 166  let au = 6
167 167  
168 168  let av = 9
169 169  
170 170  let aw = 10
171 171  
172 172  let ax = 10
173 173  
174 174  let ay = 0
175 175  
176 176  let az = 1
177 177  
178 178  let aA = 2
179 179  
180 180  let aB = 3
181 181  
182 182  let aC = 4
183 183  
184 184  let aD = 0
185 185  
186 186  let aE = 1
187 187  
188 188  let aF = 2
189 189  
190 190  let aG = 3
191 191  
192 192  let aH = 0
193 193  
194 194  let aI = 1
195 195  
196 196  let aJ = 2
197 197  
198 198  let aK = 3
199 199  
200 200  func aL (b) = ("lastTxIdByUser_" + b)
201 201  
202 202  
203 203  func aM (aN) = ("nftOwner_" + aN)
204 204  
205 205  
206 206  func aO (aN) = ("landCustomNameByAssetId_" + aN)
207 207  
208 208  
209 209  func aP (aN) = ("stakedTime_" + aN)
210 210  
211 211  
212 212  func aQ (aN) = ("infraLevel_" + aN)
213 213  
214 214  
215 215  func aR (aS,aN) = makeString(["landArtStatus", aS, aN], "_")
216 216  
217 217  
218 218  func aT (aU,aN,aV) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aU) + "_") + aN) + "_") + aV)
219 219  
220 220  
221 221  func aW (aX) = ("wareHouse_" + aX)
222 222  
223 223  
224 224  func aY (aX) = ("fortifications_" + aX)
225 225  
226 226  
227 227  func aZ (aN) = ("duckCustomNameByAssetId_" + aN)
228 228  
229 229  
230 230  func ba (b) = ("accountCustomNameByAddr_" + b)
231 231  
232 232  
233 233  func bb (b) = ("accRefBy_" + b)
234 234  
235 235  
236 236  func bc (s) = ("onboardArtActivatedOnDuck_" + s)
237 237  
238 238  
239 239  func bd (b) = ("onboardArtActivatedDuckBy_" + b)
240 240  
241 241  
242 242  func be (b) = ("accReferrals_" + b)
243 243  
244 244  
245 245  func bf (aN) = ("duckOwner_" + aN)
246 246  
247 247  
248 248  func bg (aV) = ("stakedDuckByOwner_" + aV)
249 249  
250 250  
251 251  func bh (s) = ("backPack_" + s)
252 252  
253 253  
254 254  func bi (s) = ("duckLocation_" + s)
255 255  
256 256  
257 257  func bj () = "contractsBlocked"
258 258  
259 259  
260 260  func bk (bl) = ("%s%s__userGwlReleaseTime__" + bl)
261 261  
262 262  
263 263  func bm () = "emergencyWarehouseProducts"
264 264  
265 265  
266 266  let bn = "%s__lastTourId"
267 267  
268 268  func bo (bp) = ("%s%d__tourStaticData__" + toString(bp))
269 269  
270 270  
271 271  func bq (bp) = ("%s%d__tourDynamicData__" + toString(bp))
272 272  
273 273  
274 274  let br = 0
275 275  
276 276  let bs = 1
277 277  
278 278  func bt (bu,bp) = {
279 279      let bv = split(valueOrErrorMessage(getString(bu, bo(bp)), (("Error reading tournament " + toString(bp)) + " data")), "__")
280 280      let bw = split(valueOrErrorMessage(getString(bu, bq(bp)), (("Error reading tournament " + toString(bp)) + " data")), "__")
281 281  [bv, bw]
282 282      }
283 283  
284 284  
285 285  let bx = 6
286 286  
287 287  let by = 1
288 288  
289 289  let bz = 3
290 290  
291 291  let bA = 0
292 292  
293 293  let bB = 1
294 294  
295 295  let bC = 2
296 296  
297 297  func bD (bE) = (parseIntValue(bE[au]) * ar)
298 298  
299 299  
300 300  let bF = true
301 301  
302 302  let bG = false
303 303  
304 304  let bH = false
305 305  
306 306  let bI = take(drop(this.bytes, 1), 1)
307 307  
308 308  let bJ = {
309 309      let bK = bI
310 310      if ((base58'2W' == bK))
311 311          then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
312 312          else if ((base58'2T' == bK))
313 313              then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
314 314              else throw("Unknown chain")
315 315      }
316 316  
317 317  let bL = {
318 318      let bK = bI
319 319      if ((base58'2W' == bK))
320 320          then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
321 321          else if ((base58'2T' == bK))
322 322              then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
323 323              else throw("Unknown chain")
324 324      }
325 325  
326 326  let bM = {
327 327      let bK = bI
328 328      if ((base58'2W' == bK))
329 329          then 10000000000
330 330          else if ((base58'2T' == bK))
331 331              then 100000000
332 332              else throw("Unknown chain")
333 333      }
334 334  
335 335  let bN = {
336 336      let bK = bI
337 337      if ((base58'2W' == bK))
338 338          then 86400000
339 339          else if ((base58'2T' == bK))
340 340              then 60000
341 341              else throw("Unknown chain")
342 342      }
343 343  
344 344  let bO = "__"
345 345  
346 346  let bP = 1000000
347 347  
348 348  let bQ = 100000000
349 349  
350 350  let bR = 25
351 351  
352 352  let bS = 100
353 353  
354 354  let bT = 225
355 355  
356 356  let bU = 400
357 357  
358 358  let bV = 625
359 359  
360 360  let bW = [0, 1, 2, 3, 4, 5]
361 361  
362 362  func bX (bY,bZ) = valueOrErrorMessage(getString(bY, bZ), makeString(["mandatory ", toString(bY), ".", bZ, " is not defined"], ""))
363 363  
364 364  
365 365  let ca = 1
366 366  
367 367  let cb = 2
368 368  
369 369  let cc = 3
370 370  
371 371  let cd = 4
372 372  
373 373  let ce = 7
374 374  
375 375  func cf () = "%s__restConfig"
376 376  
377 377  
378 378  func cg () = "%s__restAddr"
379 379  
380 380  
381 381  func ch (ci) = split_4C(bX(ci, cf()), bO)
382 382  
383 383  
384 384  func cj (ck,cl) = valueOrErrorMessage(addressFromString(ck[cl]), ("Rest cfg doesn't contain address at index " + toString(cl)))
385 385  
386 386  
387 387  let cm = addressFromStringValue(valueOrElse(getString(this, cg()), bL))
388 388  
389 389  let ck = ch(cm)
390 390  
391 391  let Z = cj(ck, ca)
392 392  
393 393  let cn = cj(ck, cb)
394 394  
395 395  let co = cj(ck, cc)
396 396  
397 397  let cp = cj(ck, cd)
398 398  
399 399  let cq = cj(ck, ce)
400 400  
401 401  let cr = 0
402 402  
403 403  let cs = 1
404 404  
405 405  let ct = 2
406 406  
407 407  let cu = 3
408 408  
409 409  let cv = 2
410 410  
411 411  func cw (bY) = ("finishBlockForAddr_" + bY)
412 412  
413 413  
414 414  func cx () = "resTypesProportions"
415 415  
416 416  
417 417  func cy (cz) = ("resTypesByContinent_" + cz)
418 418  
419 419  
420 420  func cA (aV) = ("stakedLandsByOwner_" + aV)
421 421  
422 422  
423 423  func cB (aV) = ("stakedPiecesByOwner_" + aV)
424 424  
425 425  
426 426  func cC (cD) = {
427 427      let bK = cD
428 428      if ($isInstanceOf(bK, "String"))
429 429          then {
430 430              let cE = bK
431 431              cE
432 432              }
433 433          else throw("fail to cast into String")
434 434      }
435 435  
436 436  
437 437  func cF (cD) = {
438 438      let bK = cD
439 439      if ($isInstanceOf(bK, "Int"))
440 440          then {
441 441              let cG = bK
442 442              cG
443 443              }
444 444          else throw("fail to cast into Int")
445 445      }
446 446  
447 447  
448 448  func cH (cI) = {
449 449      let bK = cI
450 450      if (("S" == bK))
451 451          then bR
452 452          else if (("M" == bK))
453 453              then bS
454 454              else if (("L" == bK))
455 455                  then bT
456 456                  else if (("XL" == bK))
457 457                      then bU
458 458                      else if (("XXL" == bK))
459 459                          then bV
460 460                          else throw("Unknown land size")
461 461      }
462 462  
463 463  
464 464  func cJ (cE) = isDefined(parseInt(cE))
465 465  
466 466  
467 467  let cK = {
468 468      let bK = bI
469 469      if ((base58'2W' == bK))
470 470          then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
471 471          else if ((base58'2T' == bK))
472 472              then this
473 473              else throw("Unknown chain")
474 474      }
475 475  
476 476  let cL = {
477 477      let bK = bI
478 478      if ((base58'2W' == bK))
479 479          then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
480 480          else if ((base58'2T' == bK))
481 481              then this
482 482              else throw("Unknown chain")
483 483      }
484 484  
485 485  let cM = {
486 486      let bK = bI
487 487      if ((base58'2W' == bK))
488 488          then if (bG)
489 489              then base58'CWsMtTZC5BjjoL4Q1ayW4Wwb1ehGACQB6DrKyPgotKfm'
490 490              else base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
491 491          else if ((base58'2T' == bK))
492 492              then base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
493 493              else throw("Unknown chain")
494 494      }
495 495  
496 496  let cN = [30, 60, 120]
497 497  
498 498  let cO = 300000
499 499  
500 500  let cP = 5000000
501 501  
502 502  let cQ = 50
503 503  
504 504  let cR = 10000000
505 505  
506 506  let cS = {
507 507      let bK = bI
508 508      if ((base58'2W' == bK))
509 509          then 252289527462
510 510          else if ((base58'2T' == bK))
511 511              then 2522895274
512 512              else throw("Unknown chain")
513 513      }
514 514  
515 515  let cT = {
516 516      let bK = bI
517 517      if ((base58'2W' == bK))
518 518          then 250000000
519 519          else if ((base58'2T' == bK))
520 520              then 250000000
521 521              else throw("Unknown chain")
522 522      }
523 523  
524 524  let cU = toBigInt(5)
525 525  
526 526  let cV = toBigInt(20)
527 527  
528 528  let cW = toBigInt((20 * 20))
529 529  
530 530  let cX = toBigInt(((20 * 20) * 20))
531 531  
532 532  let cY = toBigInt((((20 * 20) * 20) * 20))
533 533  
534 534  let cZ = toBigInt(((((20 * 20) * 20) * 20) * 20))
535 535  
536 536  let da = 500
537 537  
538 538  func db () = "nextLandNum"
539 539  
540 540  
541 541  func dc (dd) = ("landToAsset_" + dd)
542 542  
543 543  
544 544  func de (df) = ("landByCustomName_" + df)
545 545  
546 546  
547 547  func dg (aN,aV) = ((("infraLevelByAssetIdAndOwner_" + aN) + "_") + aV)
548 548  
549 549  
550 550  func dh (dd) = ("landOwner_" + dd)
551 551  
552 552  
553 553  func di (df) = ("duckByCustomName_" + df)
554 554  
555 555  
556 556  func dj (df) = ("accountByCustomName_" + df)
557 557  
558 558  
559 559  func dk () = "oldiesList"
560 560  
561 561  
562 562  let dl = 0
563 563  
564 564  let dm = 1
565 565  
566 566  let dn = 2
567 567  
568 568  let do = 0
569 569  
570 570  let dp = 5
571 571  
572 572  let dq = 6
573 573  
574 574  let dr = 7
575 575  
576 576  func ds (dd,cI) = ((ae + dd) + cI)
577 577  
578 578  
579 579  func dt (du,dv) = {
580 580      let dw = if ((du >= 0))
581 581          then (((du + dv) - 1) / dv)
582 582          else -((((-(du) + dv) - 1) / dv))
583 583      (dw * bQ)
584 584      }
585 585  
586 586  
587 587  func dx (dy,dz) = {
588 588      let dA = (((((dz[0] + dz[1]) + dz[2]) + dz[3]) + dz[4]) + dz[5])
589 589      if ((0 >= dA))
590 590          then throw("Zero weights sum")
591 591          else {
592 592              let dB = fraction(dy, bP, dA)
593 593              func dC (dD,dE) =             (dD :+ fraction(dE, dB, bP))
594 594  
595 595              let dF = dz
596 596              let dG = size(dF)
597 597              let dH = nil
598 598              func dI (dJ,dK) =             if ((dK >= dG))
599 599                  then dJ
600 600                  else dC(dJ, dF[dK])
601 601  
602 602              func dL (dJ,dK) =             if ((dK >= dG))
603 603                  then dJ
604 604                  else throw("List size exceeds 6")
605 605  
606 606              dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
607 607              }
608 608      }
609 609  
610 610  
611 611  func dM (dy) = {
612 612      let dN = split(value(getString(cx())), "_")
613 613      if ((size(dN) != ah))
614 614          then throw("Wrong proportions data")
615 615          else {
616 616              let dO = [parseIntValue(dN[0]), parseIntValue(dN[1]), parseIntValue(dN[2]), parseIntValue(dN[3]), parseIntValue(dN[4]), parseIntValue(dN[5])]
617 617              dx(dy, dO)
618 618              }
619 619      }
620 620  
621 621  
622 622  func dP (dQ,dR,dS) = {
623 623      let dT = dM(dS)
624 624      func dU (dD,cl) =     {
625 625          let dV = (parseIntValue(dR[cl]) - dT[cl])
626 626          if ((0 > dV))
627 627              then throw(((((("Not enough material idx=" + toString(cl)) + ", you have ") + dR[cl]) + ", but need ") + toString(dT[cl])))
628 628              else (dD :+ toString(dV))
629 629          }
630 630  
631 631      if (dQ)
632 632          then {
633 633              let dF = bW
634 634              let dG = size(dF)
635 635              let dH = nil
636 636              func dI (dJ,dK) =             if ((dK >= dG))
637 637                  then dJ
638 638                  else dU(dJ, dF[dK])
639 639  
640 640              func dL (dJ,dK) =             if ((dK >= dG))
641 641                  then dJ
642 642                  else throw("List size exceeds 6")
643 643  
644 644              dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
645 645              }
646 646          else dR
647 647      }
648 648  
649 649  
650 650  func dW (dX,dY) = if ((dY == ""))
651 651      then dX
652 652      else {
653 653          func dZ (dD,ea) =         {
654 654              let eb = split(ea, ",")
655 655              if ((size(eb) != 2))
656 656                  then throw("Incorrect format, should be index,amount")
657 657                  else {
658 658                      let cl = parseIntValue(eb[0])
659 659                      if (if ((0 > cl))
660 660                          then true
661 661                          else (cl >= size(at)))
662 662                          then throw("Unknown product idx")
663 663                          else {
664 664                              let ec = parseIntValue(eb[1])
665 665                              let ed = split(dD, (eb[0] + ":"))
666 666                              if ((size(ed) != 2))
667 667                                  then throw((("You don't have " + ap[cl]) + " equipped"))
668 668                                  else {
669 669                                      let ee = ed[1]
670 670                                      let ef = if (cJ(take(drop(ee, 1), 1)))
671 671                                          then 2
672 672                                          else 1
673 673                                      let eg = parseIntValue(take(ee, ef))
674 674                                      let eh = drop(ee, ef)
675 675                                      let ei = if ((eg >= ec))
676 676                                          then (eg - ec)
677 677                                          else throw(((((("You equipped " + toString(eg)) + " of ") + ap[cl]) + ", but tried to use ") + toString(ec)))
678 678                                      ((((ed[0] + eb[0]) + ":") + toString(ei)) + eh)
679 679                                      }
680 680                              }
681 681                      }
682 682              }
683 683  
684 684          let dF = split(dY, "_")
685 685          let dG = size(dF)
686 686          let dH = dX
687 687          func dI (dJ,dK) =         if ((dK >= dG))
688 688              then dJ
689 689              else dZ(dJ, dF[dK])
690 690  
691 691          func dL (dJ,dK) =         if ((dK >= dG))
692 692              then dJ
693 693              else throw("List size exceeds 10")
694 694  
695 695          dL(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
696 696          }
697 697  
698 698  
699 699  func ej (ek) = {
700 700      let el = if ((ek == ""))
701 701          then nil
702 702          else split_4C(ek, "_")
703 703      func em (dD,bE) =     {
704 704          let en = (size(dD) / 8)
705 705          let eg = if ((size(el) > en))
706 706              then parseIntValue(el[en])
707 707              else 0
708 708          (dD + toBytes(eg))
709 709          }
710 710  
711 711      let dF = at
712 712      let dG = size(dF)
713 713      let dH = base58''
714 714      func dI (dJ,dK) =     if ((dK >= dG))
715 715          then dJ
716 716          else em(dJ, dF[dK])
717 717  
718 718      func dL (dJ,dK) =     if ((dK >= dG))
719 719          then dJ
720 720          else throw("List size exceeds 50")
721 721  
722 722      dL(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
723 723      }
724 724  
725 725  
726 726  func eo (ep) = {
727 727      func eq (dD,bE) =     {
728 728          let en = size(dD)
729 729          let er = take(drop(ep, (8 * en)), 8)
730 730          (dD :+ toString(toInt(er)))
731 731          }
732 732  
733 733      makeString_2C({
734 734          let dF = at
735 735          let dG = size(dF)
736 736          let dH = nil
737 737          func dI (dJ,dK) =         if ((dK >= dG))
738 738              then dJ
739 739              else eq(dJ, dF[dK])
740 740  
741 741          func dL (dJ,dK) =         if ((dK >= dG))
742 742              then dJ
743 743              else throw("List size exceeds 50")
744 744  
745 745          dL(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
746 746          }, "_")
747 747      }
748 748  
749 749  
750 750  func es (et,eu) = {
751 751      func ev (dD,en) =     {
752 752          let ew = if ((size(et) > (7 + en)))
753 753              then et[(7 + en)]
754 754              else 0
755 755          if ((parseIntValue(eu[en]) > (et[en] + ew)))
756 756              then throw(("Requirement not satisfied: " + g[en]))
757 757              else true
758 758          }
759 759  
760 760      let dF = [0, 1, 2, 3, 4, 5, 6]
761 761      let dG = size(dF)
762 762      let dH = false
763 763      func dI (dJ,dK) =     if ((dK >= dG))
764 764          then dJ
765 765          else ev(dJ, dF[dK])
766 766  
767 767      func dL (dJ,dK) =     if ((dK >= dG))
768 768          then dJ
769 769          else throw("List size exceeds 7")
770 770  
771 771      dL(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7)
772 772      }
773 773  
774 774  
775 775  func ex (ey,el,ez,et,eA,eB) = {
776 776      let eb = split(ey, ":")
777 777      if ((size(eb) != 2))
778 778          then throw("Incorrect format, should be index:amount")
779 779          else if (if (!(ez))
780 780              then (size(eb[0]) != 2)
781 781              else false)
782 782              then throw("Product idx should be 2 digits, zero padded")
783 783              else {
784 784                  let eC = parseIntValue(eb[0])
785 785                  let eD = parseIntValue(eb[1])
786 786                  if (!(containsElement(as, eC)))
787 787                      then throw((("Product '" + ap[eC]) + "' cannot be used for land defense"))
788 788                      else if ((0 > eD))
789 789                          then throw("Count can't be negative")
790 790                          else if ((eD > q))
791 791                              then throw(((("Can't put more than " + toString(q)) + " of ") + ap[eC]))
792 792                              else if ((eD == 0))
793 793                                  then $Tuple3(el, eA, eB)
794 794                                  else {
795 795                                      let eE = take(el, (8 * eC))
796 796                                      let eg = toInt(take(drop(el, (8 * eC)), 8))
797 797                                      let eh = drop(el, (8 * (eC + 1)))
798 798                                      let bE = split(at[eC], "_")
799 799                                      if (if (!(ez))
800 800                                          then (eD > eg)
801 801                                          else false)
802 802                                          then throw(((((("You have " + toString(eg)) + " of ") + ap[eC]) + ", but tried to use ") + toString(eD)))
803 803                                          else {
804 804                                              let ei = if (if (!(ez))
805 805                                                  then es(et, split(bE[av], ","))
806 806                                                  else false)
807 807                                                  then (eg - eD)
808 808                                                  else (eg + eD)
809 809                                              let eF = (dt(ei, ax) - dt(eg, ax))
810 810                                              $Tuple3(((eE + toBytes(ei)) + eh), (eA + eF), (eB - eF))
811 811                                              }
812 812                                      }
813 813                  }
814 814      }
815 815  
816 816  
817 817  func eG (ey,el,ez,eH,eI,eJ,et) = {
818 818      let eb = split(ey, ":")
819 819      if ((size(eb) != 2))
820 820          then throw("Incorrect format, should be index:amount")
821 821          else if (if (!(ez))
822 822              then (size(eb[0]) != 2)
823 823              else false)
824 824              then throw("Product idx should be 2 digits, zero padded")
825 825              else {
826 826                  let eC = parseIntValue(eb[0])
827 827                  let eD = parseIntValue(eb[1])
828 828                  if (if ((0 > eC))
829 829                      then true
830 830                      else (eC >= size(at)))
831 831                      then throw("Unknown product idx")
832 832                      else if ((0 > eD))
833 833                          then throw("Count can't be negative")
834 834                          else if ((eD > q))
835 835                              then throw(((("Can't put more than " + toString(q)) + " of ") + ap[eC]))
836 836                              else if ((eD == 0))
837 837                                  then $Tuple2(el, false)
838 838                                  else {
839 839                                      let eE = take(el, (8 * eC))
840 840                                      let eg = toInt(take(drop(el, (8 * eC)), 8))
841 841                                      let eh = drop(el, (8 * (eC + 1)))
842 842                                      let bE = split(at[eC], "_")
843 843                                      if (if (!(ez))
844 844                                          then (eD > eg)
845 845                                          else false)
846 846                                          then throw(((((("You have " + toString(eg)) + " of ") + ap[eC]) + ", but tried to use ") + toString(eD)))
847 847                                          else {
848 848                                              let eK = if (if (!(ez))
849 849                                                  then es(et, split(bE[av], ","))
850 850                                                  else false)
851 851                                                  then {
852 852                                                      let eL = bE[aw]
853 853                                                      if ((eL == ""))
854 854                                                          then throw("Item cannot be equipped")
855 855                                                          else {
856 856                                                              let eM = parseIntValue(eL)
857 857                                                              let eN = (eM / 100)
858 858                                                              if ((eH != eN))
859 859                                                                  then throw("Segment incompatible")
860 860                                                                  else {
861 861                                                                      let eO = ((eM % 100) / 10)
862 862                                                                      if ((eI != eO))
863 863                                                                          then throw("Slot incompatible")
864 864                                                                          else {
865 865                                                                              let eP = (eM % 10)
866 866                                                                              if (if ((eJ != 0))
867 867                                                                                  then (eP > 1)
868 868                                                                                  else false)
869 869                                                                                  then throw("Big items should occupy slot 0")
870 870                                                                                  else (eP > 1)
871 871                                                                              }
872 872                                                                      }
873 873                                                              }
874 874                                                      }
875 875                                                  else false
876 876                                              $Tuple2(((eE + toBytes((eg + (if (ez)
877 877                                                  then eD
878 878                                                  else -(eD))))) + eh), eK)
879 879                                              }
880 880                                      }
881 881                  }
882 882      }
883 883  
884 884  
885 885  func eQ (eR,eS,ez,eH,eI,eT) = if ((eR != ""))
886 886      then {
887 887          let eU = split(eR, ",")
888 888          if ((size(eU) > p))
889 889              then throw("Wrong slots format")
890 890              else {
891 891                  let eV = eU[0]
892 892                  let eW = if ((size(eU) > 1))
893 893                      then eU[1]
894 894                      else ""
895 895                  if (if ((eV == ""))
896 896                      then (eW == "")
897 897                      else false)
898 898                      then eS
899 899                      else {
900 900                          let eX = if ((eV != ""))
901 901                              then eG(eV, eS, ez, eH, eI, 0, eT)
902 902                              else $Tuple2(eS, false)
903 903                          if ((eW != ""))
904 904                              then if (eX._2)
905 905                                  then throw("Big item already occupies slot")
906 906                                  else eG(eW, eX._1, ez, eH, eI, 1, eT)._1
907 907                              else eX._1
908 908                          }
909 909                  }
910 910          }
911 911      else eS
912 912  
913 913  
914 914  func eY (eZ,fa,ez,eT) = {
915 915      func eH (dD,fb) =     {
916 916          let en = dD._1
917 917          let eI = split(fb, ";")
918 918          if ((size(eI) != o))
919 919              then throw("Wrong segment format")
920 920              else {
921 921                  let fc = eI[0]
922 922                  let fd = eI[1]
923 923                  if (if ((fc == ""))
924 924                      then (fd == "")
925 925                      else false)
926 926                      then $Tuple2((en + 1), dD._2)
927 927                      else {
928 928                          let fe = eQ(fc, dD._2, ez, en, 0, eT)
929 929                          $Tuple2((en + 1), eQ(fd, fe, ez, en, 1, eT))
930 930                          }
931 931                  }
932 932          }
933 933  
934 934  (    let dF = eZ
935 935      let dG = size(dF)
936 936      let dH = $Tuple2(0, fa)
937 937      func dI (dJ,dK) =     if ((dK >= dG))
938 938          then dJ
939 939          else eH(dJ, dF[dK])
940 940  
941 941      func dL (dJ,dK) =     if ((dK >= dG))
942 942          then dJ
943 943          else throw("List size exceeds 6")
944 944  
945 945      dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6))._2
946 946      }
947 947  
948 948  
949 949  func ff (eZ,fa,eA,eB,ez,et) = if ((3 > size(eZ)))
950 950      then throw("At least duck, mines and traps parts are required")
951 951      else {
952 952          func eH (dD,fb) =         {
953 953              let en = dD._1
954 954              if ((en == 0))
955 955                  then $Tuple4((en + 1), dD._2, dD._3, dD._4)
956 956                  else {
957 957                      let fg = ex(fb, dD._2, ez, et, dD._3, dD._4)
958 958                      $Tuple4((en + 1), fg._1, fg._2, fg._3)
959 959                      }
960 960              }
961 961  
962 962          let fh = {
963 963              let dF = eZ
964 964              let dG = size(dF)
965 965              let dH = $Tuple4(0, fa, eA, eB)
966 966              func dI (dJ,dK) =             if ((dK >= dG))
967 967                  then dJ
968 968                  else eH(dJ, dF[dK])
969 969  
970 970              func dL (dJ,dK) =             if ((dK >= dG))
971 971                  then dJ
972 972                  else throw("List size exceeds 10")
973 973  
974 974              dL(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
975 975              }
976 976          $Tuple3(fh._2, fh._3, fh._4)
977 977          }
978 978  
979 979  
980 980  func fi (fj,fk,fl,fm) = if ((size(fj) != ah))
981 981      then throw("Wrong proportions data")
982 982      else {
983 983          func fn (dD,fo) =         {
984 984              let dV = (parseIntValue(fj[fo]) + ((fm * fk[fo]) * fl))
985 985              if ((0 > dV))
986 986                  then throw(((((((("Panic! Pieces of type=" + toString(fo)) + ", sign=") + toString(fm)) + ", terrainCounts[i]=") + toString(fk[fo])) + ", landSizeIndex=") + toString(fl)))
987 987                  else (dD :+ toString(dV))
988 988              }
989 989  
990 990          let dF = bW
991 991          let dG = size(dF)
992 992          let dH = nil
993 993          func dI (dJ,dK) =         if ((dK >= dG))
994 994              then dJ
995 995              else fn(dJ, dF[dK])
996 996  
997 997          func dL (dJ,dK) =         if ((dK >= dG))
998 998              then dJ
999 999              else throw("List size exceeds 6")
1000 1000  
1001 1001          dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1002 1002          }
1003 1003  
1004 1004  
1005 1005  func fp (fk,fl,fm) = {
1006 1006      let fj = split(valueOrElse(getString(cx()), "0_0_0_0_0_0"), "_")
1007 1007      makeString(fi(fj, fk, fl, fm), "_")
1008 1008      }
1009 1009  
1010 1010  
1011 1011  func fq (fr) = [(size(split(fr, "A")) - 1), (size(split(fr, "B")) - 1), (size(split(fr, "C")) - 1), (size(split(fr, "D")) - 1), (size(split(fr, "E")) - 1), (size(split(fr, "F")) - 1)]
1012 1012  
1013 1013  
1014 1014  func fs (ft,fk,fu,fl,fv) = {
1015 1015      func fw (dD,fo) =     {
1016 1016          let fx = ((fraction(fu, fv, ak) * fk[fo]) * fl)
1017 1017          (dD :+ toString((parseIntValue(ft[fo]) + fx)))
1018 1018          }
1019 1019  
1020 1020      let dO = {
1021 1021          let dF = bW
1022 1022          let dG = size(dF)
1023 1023          let dH = nil
1024 1024          func dI (dJ,dK) =         if ((dK >= dG))
1025 1025              then dJ
1026 1026              else fw(dJ, dF[dK])
1027 1027  
1028 1028          func dL (dJ,dK) =         if ((dK >= dG))
1029 1029              then dJ
1030 1030              else throw("List size exceeds 6")
1031 1031  
1032 1032          dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1033 1033          }
1034 1034      makeString(dO, "_")
1035 1035      }
1036 1036  
1037 1037  
1038 1038  func fy (fk,fu,fl,fv) = {
1039 1039      func fw (dD,fo) =     {
1040 1040          let fx = ((fraction(fu, fv, ak) * fk[fo]) * fl)
1041 1041          $Tuple2((dD._1 :+ fx), (dD._2 + fx))
1042 1042          }
1043 1043  
1044 1044      let dF = bW
1045 1045      let dG = size(dF)
1046 1046      let dH = $Tuple2(nil, 0)
1047 1047      func dI (dJ,dK) =     if ((dK >= dG))
1048 1048          then dJ
1049 1049          else fw(dJ, dF[dK])
1050 1050  
1051 1051      func dL (dJ,dK) =     if ((dK >= dG))
1052 1052          then dJ
1053 1053          else throw("List size exceeds 6")
1054 1054  
1055 1055      dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1056 1056      }
1057 1057  
1058 1058  
1059 1059  func fz (fA,fB,fC,fD) = {
1060 1060      let fE = fC._1
1061 1061      let fF = fC._2
1062 1062      if ((fF == 0))
1063 1063          then $Tuple2(makeString(fA, "_"), makeString(fB, "_"))
1064 1064          else if ((fD >= fF))
1065 1065              then {
1066 1066                  func fG (dD,fo) =                 (dD :+ toString((parseIntValue(fA[fo]) + fE[fo])))
1067 1067  
1068 1068                  let dO = {
1069 1069                      let dF = bW
1070 1070                      let dG = size(dF)
1071 1071                      let dH = nil
1072 1072                      func dI (dJ,dK) =                     if ((dK >= dG))
1073 1073                          then dJ
1074 1074                          else fG(dJ, dF[dK])
1075 1075  
1076 1076                      func dL (dJ,dK) =                     if ((dK >= dG))
1077 1077                          then dJ
1078 1078                          else throw("List size exceeds 6")
1079 1079  
1080 1080                      dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1081 1081                      }
1082 1082                  $Tuple2(makeString(dO, "_"), makeString(fB, "_"))
1083 1083                  }
1084 1084              else {
1085 1085                  func fH (dD,fo) =                 {
1086 1086                      let fI = fraction(fE[fo], fD, fF)
1087 1087                      $Tuple2((dD._1 :+ toString((parseIntValue(fA[fo]) + fI))), (dD._2 :+ toString(((parseIntValue(fB[fo]) + fE[fo]) - fI))))
1088 1088                      }
1089 1089  
1090 1090                  let dO = {
1091 1091                      let dF = bW
1092 1092                      let dG = size(dF)
1093 1093                      let dH = $Tuple2(nil, nil)
1094 1094                      func dI (dJ,dK) =                     if ((dK >= dG))
1095 1095                          then dJ
1096 1096                          else fH(dJ, dF[dK])
1097 1097  
1098 1098                      func dL (dJ,dK) =                     if ((dK >= dG))
1099 1099                          then dJ
1100 1100                          else throw("List size exceeds 6")
1101 1101  
1102 1102                      dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1103 1103                      }
1104 1104                  $Tuple2(makeString(dO._1, "_"), makeString(dO._2, "_"))
1105 1105                  }
1106 1106      }
1107 1107  
1108 1108  
1109 1109  func fJ (fK) = if ((fK >= toBigInt(0)))
1110 1110      then fK
1111 1111      else -(fK)
1112 1112  
1113 1113  
1114 1114  let fL = [[6, 9, 14, 15, 16], [5, 8, 13, 14, 15], [1, 4, 9, 10, 15], [1, 6, 7, 15, 19], [4, 7, 8, 13, 18]]
1115 1115  
1116 1116  func fM (cG,fN) = {
1117 1117      let fO = toInt((cG % cV))
1118 1118      let fP = if ((fN[0] > fO))
1119 1119          then "A"
1120 1120          else if ((fN[1] > fO))
1121 1121              then "B"
1122 1122              else if ((fN[2] > fO))
1123 1123                  then "C"
1124 1124                  else if ((fN[3] > fO))
1125 1125                      then "D"
1126 1126                      else if ((fN[4] > fO))
1127 1127                          then "E"
1128 1128                          else "F"
1129 1129      fP
1130 1130      }
1131 1131  
1132 1132  
1133 1133  func fQ (fR,fS) = {
1134 1134      let fT = fL[fS]
1135 1135      func fU (dD,dE) =     $Tuple2((((((dD._1 + fM(dD._2, fT)) + fM((dD._2 / cV), fT)) + fM((dD._2 / cW), fT)) + fM((dD._2 / cX), fT)) + fM((dD._2 / cY), fT)), (dD._2 / cZ))
1136 1136  
1137 1137      let fh = {
1138 1138          let dF = [1, 2, 3, 4, 5]
1139 1139          let dG = size(dF)
1140 1140          let dH = $Tuple2("", (fR / cU))
1141 1141          func dI (dJ,dK) =         if ((dK >= dG))
1142 1142              then dJ
1143 1143              else fU(dJ, dF[dK])
1144 1144  
1145 1145          func dL (dJ,dK) =         if ((dK >= dG))
1146 1146              then dJ
1147 1147              else throw("List size exceeds 5")
1148 1148  
1149 1149          dL(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5)
1150 1150          }
1151 1151      fh._1
1152 1152      }
1153 1153  
1154 1154  
1155 1155  let fV = [7, 2, 15, 19, 8, 24, 1, 21, 16, 5, 0, 22, 20, 23, 11, 4, 18, 12, 6, 10, 3, 17, 13, 9, 14]
1156 1156  
1157 1157  let fW = ["A", "B", "C", "D", "E", "F"]
1158 1158  
1159 1159  func fX (fY,fl) = {
1160 1160      func fZ (dD,cE) =     {
1161 1161          let en = dD._2
1162 1162          let ga = parseIntValue(cE)
1163 1163          let fK = if ((ga == 0))
1164 1164              then 0
1165 1165              else if ((ga >= (4 * fl)))
1166 1166                  then (ga / fl)
1167 1167                  else if ((ga > (3 * fl)))
1168 1168                      then 3
1169 1169                      else (((ga - 1) / fl) + 1)
1170 1170          $Tuple3((dD._1 :+ fK), (dD._2 + 1), (dD._3 + fK))
1171 1171          }
1172 1172  
1173 1173      let fh = {
1174 1174          let dF = fY
1175 1175          let dG = size(dF)
1176 1176          let dH = $Tuple3(nil, 0, 0)
1177 1177          func dI (dJ,dK) =         if ((dK >= dG))
1178 1178              then dJ
1179 1179              else fZ(dJ, dF[dK])
1180 1180  
1181 1181          func dL (dJ,dK) =         if ((dK >= dG))
1182 1182              then dJ
1183 1183              else throw("List size exceeds 6")
1184 1184  
1185 1185          dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1186 1186          }
1187 1187      let gb = fh._1
1188 1188      let gc = value(indexOf(gb, max(gb)))
1189 1189      let gd = (fh._3 - 25)
1190 1190      func ge (dD,cl) =     {
1191 1191          let gf = if ((cl == gc))
1192 1192              then (gb[cl] - gd)
1193 1193              else gb[cl]
1194 1194          let gg = if ((gf == 0))
1195 1195              then nil
1196 1196              else split(drop(toString(pow(10, 0, gf, 0, 0, DOWN)), 1), "")
1197 1197          let eM = fW[cl]
1198 1198          func gh (gi,gj) =         (gi :+ eM)
1199 1199  
1200 1200          let gk = {
1201 1201              let dF = gg
1202 1202              let dG = size(dF)
1203 1203              let dH = nil
1204 1204              func gl (dJ,dK) =             if ((dK >= dG))
1205 1205                  then dJ
1206 1206                  else gh(dJ, dF[dK])
1207 1207  
1208 1208              func gm (dJ,dK) =             if ((dK >= dG))
1209 1209                  then dJ
1210 1210                  else throw("List size exceeds 25")
1211 1211  
1212 1212              gm(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25)
1213 1213              }
1214 1214          (dD ++ gk)
1215 1215          }
1216 1216  
1217 1217      let dO = {
1218 1218          let dF = bW
1219 1219          let dG = size(dF)
1220 1220          let dH = nil
1221 1221          func gl (dJ,dK) =         if ((dK >= dG))
1222 1222              then dJ
1223 1223              else ge(dJ, dF[dK])
1224 1224  
1225 1225          func gm (dJ,dK) =         if ((dK >= dG))
1226 1226              then dJ
1227 1227              else throw("List size exceeds 6")
1228 1228  
1229 1229          gm(gl(gl(gl(gl(gl(gl(dH, 0), 1), 2), 3), 4), 5), 6)
1230 1230          }
1231 1231      func gn (dD,en) =     (dD + dO[en])
1232 1232  
1233 1233      let dF = fV
1234 1234      let dG = size(dF)
1235 1235      let dH = ""
1236 1236      func go (dJ,dK) =     if ((dK >= dG))
1237 1237          then dJ
1238 1238          else gn(dJ, dF[dK])
1239 1239  
1240 1240      func gp (dJ,dK) =     if ((dK >= dG))
1241 1241          then dJ
1242 1242          else throw("List size exceeds 25")
1243 1243  
1244 1244      gp(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25)
1245 1245      }
1246 1246  
1247 1247  
1248 1248  func gq (gr) = {
1249 1249      let fg = split(valueOrElse(getString(gr), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
1250 1250  [toString(valueOrElse(parseInt(fg[aH]), 0)), if ((size(split(fg[aI], "_")) == ah))
1251 1251          then fg[aI]
1252 1252          else "0_0_0_0_0_0", if ((size(split(fg[aJ], "_")) == ah))
1253 1253          then fg[aJ]
1254 1254          else "0_0_0_0_0_0", fg[aK]]
1255 1255      }
1256 1256  
1257 1257  
1258 1258  func gs (gt) = {
1259 1259      let eb = split(gt, "_")
1260 1260      ((al * (parseIntValue(eb[1]) + 1)) * parseIntValue(eb[0]))
1261 1261      }
1262 1262  
1263 1263  
1264 1264  func gu (gv) = {
1265 1265      let gw = gv[aB]
1266 1266      func gx (dD,gy) =     (dD + parseIntValue(gy))
1267 1267  
1268 1268      func gz (dD,gy) =     {
1269 1269          let cl = dD._1
1270 1270          let dw = (((parseIntValue(gy) + ax) - 1) / ax)
1271 1271          $Tuple2((cl + 1), (dD._2 + (dw * bQ)))
1272 1272          }
1273 1273  
1274 1274      let gA = {
1275 1275          let dF = split(gv[az], "_")
1276 1276          let dG = size(dF)
1277 1277          let dH = 0
1278 1278          func dI (dJ,dK) =         if ((dK >= dG))
1279 1279              then dJ
1280 1280              else gx(dJ, dF[dK])
1281 1281  
1282 1282          func dL (dJ,dK) =         if ((dK >= dG))
1283 1283              then dJ
1284 1284              else throw("List size exceeds 6")
1285 1285  
1286 1286          dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1287 1287          }
1288 1288      let gB = {
1289 1289          let dF = split(gv[aA], "_")
1290 1290          let dG = size(dF)
1291 1291          let dH = 0
1292 1292          func gl (dJ,dK) =         if ((dK >= dG))
1293 1293              then dJ
1294 1294              else gx(dJ, dF[dK])
1295 1295  
1296 1296          func gm (dJ,dK) =         if ((dK >= dG))
1297 1297              then dJ
1298 1298              else throw("List size exceeds 6")
1299 1299  
1300 1300          gm(gl(gl(gl(gl(gl(gl(dH, 0), 1), 2), 3), 4), 5), 6)
1301 1301          }
1302 1302      let gC = if ((gw == ""))
1303 1303          then 0
1304 1304          else (        let dF = split_4C(gw, "_")
1305 1305          let dG = size(dF)
1306 1306          let dH = $Tuple2(0, 0)
1307 1307          func go (dJ,dK) =         if ((dK >= dG))
1308 1308              then dJ
1309 1309              else gz(dJ, dF[dK])
1310 1310  
1311 1311          func gp (dJ,dK) =         if ((dK >= dG))
1312 1312              then dJ
1313 1313              else throw("List size exceeds 50")
1314 1314  
1315 1315          gp(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50))._2
1316 1316      ((gA + gB) + gC)
1317 1317      }
1318 1318  
1319 1319  
1320 1320  func gD (gE,gF,gG) = {
1321 1321      let gt = ((toString(gF) + "_") + toString(gG))
1322 1322      let gH = gs(gt)
1323 1323      let gI = valueOrElse(getString(gE), (gt + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
1324 1324      let gJ = split_4C(gI, ":")
1325 1325      let gK = gu(gJ)
1326 1326      let gL = if ((5 > size(gJ)))
1327 1327          then makeString(["0", toString(gK), toString((gH - gK)), toString(gH)], "_")
1328 1328          else {
1329 1329              let gM = split(gJ[aC], "_")
1330 1330              let gN = parseIntValue(gM[aD])
1331 1331              let gO = if ((size(gM) > 1))
1332 1332                  then parseIntValue(gM[aE])
1333 1333                  else gK
1334 1334              makeString([toString(gN), toString(gO), toString(((gH - gN) - gO)), toString(gH)], "_")
1335 1335              }
1336 1336  [gJ[ay], if ((size(split(gJ[az], "_")) == ah))
1337 1337          then gJ[az]
1338 1338          else "0_0_0_0_0_0", if ((size(split(gJ[aA], "_")) == ah))
1339 1339          then gJ[aA]
1340 1340          else "0_0_0_0_0_0", gJ[aB], gL]
1341 1341      }
1342 1342  
1343 1343  
1344 1344  func gP (gv) = {
1345 1345      let gQ = gu(gv)
1346 1346      let gR = parseIntValue(split(gv[aC], "_")[aD])
1347 1347      ((gs(gv[ay]) - gQ) - gR)
1348 1348      }
1349 1349  
1350 1350  
1351 1351  func gS (gT,gv,gU) = if ((size(gT) != 3))
1352 1352      then throw("cargoListStr should contain exactly 2 ':' separators")
1353 1353      else {
1354 1354          let gV = split(gT[0], "_")
1355 1355          let gW = split(gT[1], "_")
1356 1356          let gX = if ((gT[2] == ""))
1357 1357              then nil
1358 1358              else split_4C(gT[2], "_")
1359 1359          if ((size(gV) != ah))
1360 1360              then throw("All 6 resources should be passed")
1361 1361              else if ((size(gW) != ah))
1362 1362                  then throw("All 6 materials should be passed")
1363 1363                  else {
1364 1364                      let fD = gP(gv)
1365 1365                      let gY = split(gv[az], "_")
1366 1366                      let gZ = split(gv[aA], "_")
1367 1367                      let ha = if ((gv[aB] == ""))
1368 1368                          then nil
1369 1369                          else split_4C(gv[aB], "_")
1370 1370                      let fB = split(gU[aI], "_")
1371 1371                      let hb = split(gU[aJ], "_")
1372 1372                      let hc = if ((gU[aK] == ""))
1373 1373                          then nil
1374 1374                          else split_4C(gU[aK], "_")
1375 1375                      func hd (dD,gy) =                     {
1376 1376                          let fo = dD._1
1377 1377                          let he = parseIntValue(gy)
1378 1378                          let hf = parseIntValue(gY[fo])
1379 1379                          let hg = parseIntValue(fB[fo])
1380 1380                          if ((he == 0))
1381 1381                              then $Tuple4((fo + 1), (dD._2 :+ gY[fo]), (dD._3 :+ fB[fo]), dD._4)
1382 1382                              else if ((he > 0))
1383 1383                                  then if ((he > hg))
1384 1384                                      then throw((((("Attempt to take " + gy) + " from backpack, but only ") + toString(hg)) + " available"))
1385 1385                                      else $Tuple4((fo + 1), (dD._2 :+ toString((hf + he))), (dD._3 :+ toString((hg - he))), (dD._4 + he))
1386 1386                                  else if ((-(he) > hf))
1387 1387                                      then throw((((("Attempt to take " + toString(-(he))) + " from warehouse, but only ") + toString(hf)) + " available"))
1388 1388                                      else $Tuple4((fo + 1), (dD._2 :+ toString((hf + he))), (dD._3 :+ toString((hg - he))), (dD._4 + he))
1389 1389                          }
1390 1390  
1391 1391                      let dO = {
1392 1392                          let dF = gV
1393 1393                          let dG = size(dF)
1394 1394                          let dH = $Tuple4(0, nil, nil, 0)
1395 1395                          func dI (dJ,dK) =                         if ((dK >= dG))
1396 1396                              then dJ
1397 1397                              else hd(dJ, dF[dK])
1398 1398  
1399 1399                          func dL (dJ,dK) =                         if ((dK >= dG))
1400 1400                              then dJ
1401 1401                              else throw("List size exceeds 6")
1402 1402  
1403 1403                          dL(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6)
1404 1404                          }
1405 1405                      func hh (dD,gy) =                     {
1406 1406                          let fo = dD._1
1407 1407                          let he = parseIntValue(gy)
1408 1408                          let hi = parseIntValue(gZ[fo])
1409 1409                          let hj = parseIntValue(hb[fo])
1410 1410                          if ((he == 0))
1411 1411                              then $Tuple4((fo + 1), (dD._2 :+ gZ[fo]), (dD._3 :+ hb[fo]), dD._4)
1412 1412                              else if ((he > 0))
1413 1413                                  then if ((he > hj))
1414 1414                                      then throw((((("Attempt to take " + gy) + " from backpack, but only ") + toString(hj)) + " available"))
1415 1415                                      else $Tuple4((fo + 1), (dD._2 :+ toString((hi + he))), (dD._3 :+ toString((hj - he))), (dD._4 + he))
1416 1416                                  else if ((-(he) > hi))
1417 1417                                      then throw((((("Attempt to take " + toString(-(he))) + " from warehouse, but only ") + toString(hi)) + " available"))
1418 1418                                      else $Tuple4((fo + 1), (dD._2 :+ toString((hi + he))), (dD._3 :+ toString((hj - he))), (dD._4 + he))
1419 1419                          }
1420 1420  
1421 1421                      let fc = {
1422 1422                          let dF = gW
1423 1423                          let dG = size(dF)
1424 1424                          let dH = $Tuple4(0, nil, nil, dO._4)
1425 1425                          func gl (dJ,dK) =                         if ((dK >= dG))
1426 1426                              then dJ
1427 1427                              else hh(dJ, dF[dK])
1428 1428  
1429 1429                          func gm (dJ,dK) =                         if ((dK >= dG))
1430 1430                              then dJ
1431 1431                              else throw("List size exceeds 6")
1432 1432  
1433 1433                          gm(gl(gl(gl(gl(gl(gl(dH, 0), 1), 2), 3), 4), 5), 6)
1434 1434                          }
1435 1435                      func hk (dD,gy) =                     {
1436 1436                          let fo = dD._1
1437 1437                          let he = parseIntValue(gy)
1438 1438                          let hl = if ((size(ha) > fo))
1439 1439                              then parseIntValue(ha[fo])
1440 1440                              else 0
1441 1441                          let hm = if ((size(hc) > fo))
1442 1442                              then parseIntValue(hc[fo])
1443 1443                              else 0
1444 1444                          if ((he == 0))
1445 1445                              then $Tuple4((fo + 1), (dD._2 :+ toString(hl)), (dD._3 :+ toString(hm)), dD._4)
1446 1446                              else if ((he > 0))
1447 1447                                  then if ((he > hm))
1448 1448                                      then throw((((("Attempt to take " + gy) + " from backpack, but only ") + toString(hm)) + " available"))
1449 1449                                      else {
1450 1450                                          let eF = (dt((hl + he), ax) - dt(hl, ax))
1451 1451                                          $Tuple4((fo + 1), (dD._2 :+ toString((hl + he))), (dD._3 :+ toString((hm - he))), (dD._4 + eF))
1452 1452                                          }
1453 1453                                  else if ((-(he) > hl))
1454 1454                                      then throw((((("Attempt to take " + toString(-(he))) + " from warehouse, but only ") + toString(hl)) + " available"))
1455 1455                                      else {
1456 1456                                          let eF = (dt((hl + he), ax) - dt(hl, ax))
1457 1457                                          $Tuple4((fo + 1), (dD._2 :+ toString((hl + he))), (dD._3 :+ toString((hm - he))), (dD._4 + eF))
1458 1458                                          }
1459 1459                          }
1460 1460  
1461 1461                      let fg = if ((size(gX) != 0))
1462 1462                          then {
1463 1463                              let dF = gX
1464 1464                              let dG = size(dF)
1465 1465                              let dH = $Tuple4(0, nil, nil, fc._4)
1466 1466                              func go (dJ,dK) =                             if ((dK >= dG))
1467 1467                                  then dJ
1468 1468                                  else hk(dJ, dF[dK])
1469 1469  
1470 1470                              func gp (dJ,dK) =                             if ((dK >= dG))
1471 1471                                  then dJ
1472 1472                                  else throw("List size exceeds 50")
1473 1473  
1474 1474                              gp(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(go(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
1475 1475                              }
1476 1476                          else $Tuple4(0, ha, hc, fc._4)
1477 1477                      let hn = fg._4
1478 1478                      if ((hn > fD))
1479 1479                          then throw((((("Attempt to put total " + toString(hn)) + " stuff, but only ") + toString(fD)) + " warehouse space left"))
1480 1480                          else $Tuple7(makeString(dO._2, "_"), makeString(fc._2, "_"), makeString_2C(fg._2, "_"), makeString(dO._3, "_"), makeString(fc._3, "_"), makeString_2C(fg._3, "_"), hn)
1481 1481                      }
1482 1482          }
1483 1483  
1484 1484  
1485 1485  func ho (hp,hq) = {
1486 1486      let bl = toString(hp)
1487 1487      let hr = fJ(toBigInt(hq))
1488 1488      let hs = valueOrElse(getInteger(db()), (da + 1))
1489 1489      let dd = toString(hs)
1490 1490      let fS = toInt((hr % cU))
1491 1491      let fr = fQ(hr, fS)
1492 1492      let cz = aq[fS]
1493 1493      let ht = Issue(ds(dd, "S"), makeString([dd, "S", fr, cz], "_"), 1, 0, false)
1494 1494      let aN = calculateAssetId(ht)
1495 1495      let hu = toBase58String(aN)
1496 1496      $Tuple2([IntegerEntry(db(), (hs + 1)), ht, StringEntry(dc(dd), hu), StringEntry(aM(hu), bl), StringEntry(dh(dd), bl), IntegerEntry(aQ(hu), 0), IntegerEntry(dg(hu, bl), 0), ScriptTransfer(hp, 1, aN)], $Tuple2(hu, cz))
1497 1497      }
1498 1498  
1499 1499  
1500 1500  func hv (bl,hw,hx) = if (!(sigVerify_8Kb(hw, hx, cM)))
1501 1501      then throw("signature does not match")
1502 1502      else {
1503 1503          let eb = split(toUtf8String(hw), ";")
1504 1504          let hy = split(eb[0], "|")
1505 1505          let hz = split(hy[do], "_")
1506 1506          let hA = parseIntValue(hz[0])
1507 1507          let hB = parseIntValue(hz[1])
1508 1508          let hC = split(eb[1], ":")
1509 1509          let hD = hC[0]
1510 1510          let hE = parseIntValue(hy[dp])
1511 1511          if (if ((hE > (lastBlock.timestamp + cO)))
1512 1512              then true
1513 1513              else ((lastBlock.timestamp - cO) > hE))
1514 1514              then throw(((("signature outdated: logTime=" + toString(hE)) + ", bcTime=") + toString(lastBlock.timestamp)))
1515 1515              else {
1516 1516                  let hF = hC[1]
1517 1517                  let hG = valueOrElse(getString(aL(bl)), "")
1518 1518                  if ((hG != hF))
1519 1519                      then throw(((("Tx ids don't match! In state: " + hG) + ", in msg: ") + hF))
1520 1520                      else {
1521 1521                          let s = valueOrErrorMessage(getString(bg(bl)), "You don't have a duck staked")
1522 1522                          let hH = r(s)
1523 1523                          let hI = Q(valueOrElse(getInteger(v(s)), 0))
1524 1524                          let hJ = valueOrElse(getInteger(hH), hI)
1525 1525                          if ((hJ != hA))
1526 1526                              then throw(((("oldHealth=" + toString(hJ)) + " from state does not match one from flight log=") + toString(hA)))
1527 1527                              else if ((0 >= hA))
1528 1528                                  then throw("You can't fly with zero health")
1529 1529                                  else {
1530 1530                                      let hK = if ((size(hy) > dq))
1531 1531                                          then hy[dq]
1532 1532                                          else ""
1533 1533                                      let hL = if ((size(hy) > dr))
1534 1534                                          then hy[dr]
1535 1535                                          else ""
1536 1536                                      let hM = if (if ((hB > 0))
1537 1537                                          then (hK == "$")
1538 1538                                          else false)
1539 1539                                          then cF(invoke(cm, "sendUsdtPrize", [bl], nil))
1540 1540                                          else 0
1541 1541                                      $Tuple5(hB, s, hM, hD, hL)
1542 1542                                      }
1543 1543                          }
1544 1544                  }
1545 1545          }
1546 1546  
1547 1547  
1548 1548  func hN (hp,hq,hw,hx) = {
1549 1549      let bl = toString(hp)
1550 1550      let fT = hv(bl, hw, hx)
1551 1551      let s = fT._2
1552 1552      let hH = r(s)
1553 1553      let gr = bh(s)
1554 1554      let gU = gq(gr)
1555 1555      let hO = split(gU[aJ], "_")
1556 1556      let hP = makeString(dP(true, hO, cS), "_")
1557 1557      let hQ = x(s)
1558 1558      let hR = valueOrElse(getString(hQ), ",;,_,;,_,;,_,;,_,;,_,;,")
1559 1559      let hS = dW(hR, fT._5)
1560 1560      if ((0 >= fT._1))
1561 1561          then $Tuple3([IntegerEntry(hH, 0), StringEntry(hQ, hS)], "", 0)
1562 1562          else {
1563 1563              let hT = ho(hp, hq)
1564 1564              let hu = hT._2._1
1565 1565              $Tuple3(((((hT._1 :+ StringEntry(bi(s), makeString([hT._2._2, "L", hu], "_"))) :+ IntegerEntry(hH, fT._1)) :+ StringEntry(hQ, hS)) :+ StringEntry(gr, makeString([gU[aH], gU[aI], hP, gU[aK]], ":"))), hu, fT._3)
1566 1566              }
1567 1567      }
1568 1568  
1569 1569  
1570 1570  func hU (aX,hV) = {
1571 1571      let gG = valueOrElse(getInteger(aQ(aX)), 0)
1572 1572      let hW = valueOrElse(getInteger(aR(ag, aX)), 0)
1573 1573      let hX = (gG / 6)
1574 1574      let hY = (gG / 7)
1575 1575      ((aj + fraction(aj, ((gG + hX) + (2 * hY)), 5)) + fraction(aj, hW, (hV * 5)))
1576 1576      }
1577 1577  
1578 1578  
1579 1579  func hZ (b,ia,ib) = {
1580 1580      let ic = if ((ia == dl))
1581 1581          then $Tuple2(ib, valueOrElse(getString(bg(b)), ""))
1582 1582          else {
1583 1583              let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
1584 1584              let id = valueOrElse(getString(bi(s)), am)
1585 1585              let ie = split(value(id), "_")
1586 1586              if ((ie[bB] != "L"))
1587 1587                  then throw((("Duck location type is " + ie[bB]) + ", but should be L"))
1588 1588                  else $Tuple2(ie[bC], s)
1589 1589              }
1590 1590      let aX = ic._1
1591 1591      let if = ic._2
1592 1592      let ig = value(assetInfo(fromBase58String(aX)))
1593 1593      let ih = aP(aX)
1594 1594      let ii = valueOrErrorMessage(getInteger(ih), (("Land " + ig.name) + " is not staked"))
1595 1595      let ij = valueOrErrorMessage(getString(aM(aX)), (("NFT " + ig.name) + " is orphaned"))
1596 1596      if ((ij != b))
1597 1597          then throw((ae + " is not yours"))
1598 1598          else {
1599 1599              let ik = split(ig.description, "_")
1600 1600              $Tuple4(if, aX, ik, ii)
1601 1601              }
1602 1602      }
1603 1603  
1604 1604  
1605 1605  func il (b,du,ia,ib) = if ((0 > du))
1606 1606      then throw("Negative amount")
1607 1607      else {
1608 1608          let eM = hZ(b, ia, ib)
1609 1609          let cI = eM._3[cs]
1610 1610          let fk = fq(eM._3[ct])
1611 1611          let fu = (lastBlock.timestamp - eM._4)
1612 1612          if ((0 > fu))
1613 1613              then throw(((("Saved timestamp is in future, saved = " + toString(eM._4)) + ", current = ") + toString(lastBlock.timestamp)))
1614 1614              else {
1615 1615                  let hV = cH(cI)
1616 1616                  let im = hU(eM._2, hV)
1617 1617                  let in = fraction(fu, (im * hV), ak)
1618 1618                  if ((du > in))
1619 1619                      then throw(((("Not enough resources, available = " + toString(in)) + ", requested = ") + toString(du)))
1620 1620                      else {
1621 1621                          let io = fraction((in - du), ak, (im * hV))
1622 1622                          let ip = (lastBlock.timestamp - io)
1623 1623                          let gF = (hV / bR)
1624 1624                          let fC = fy(fk, (fu - io), gF, im)
1625 1625                          let gE = aW(eM._2)
1626 1626                          let gG = valueOrElse(getInteger(aQ(eM._2)), 0)
1627 1627                          let gv = gD(gE, gF, gG)
1628 1628                          let gM = split(gv[aC], "_")
1629 1629                          let fD = parseIntValue(gM[aF])
1630 1630                          if (if ((ia == dl))
1631 1631                              then (du > fD)
1632 1632                              else false)
1633 1633                              then throw((("Only " + toString(fD)) + " space left in warehouse"))
1634 1634                              else {
1635 1635                                  let gr = bh(eM._1)
1636 1636                                  let gU = gq(gr)
1637 1637                                  let fB = split(gU[aI], "_")
1638 1638                                  let fA = split(gv[az], "_")
1639 1639                                  let iq = if ((ia == dl))
1640 1640                                      then $Tuple4(fs(fA, fk, (fu - io), gF, im), gU[aI], (parseIntValue(gM[aE]) + fC._2), (parseIntValue(gM[aF]) - fC._2))
1641 1641                                      else if ((ia == dm))
1642 1642                                          then $Tuple4(gv[az], fs(fB, fk, (fu - io), gF, im), parseIntValue(gM[aE]), parseIntValue(gM[aF]))
1643 1643                                          else {
1644 1644                                              let ir = fz(fA, fB, fC, fD)
1645 1645                                              let is = min([parseIntValue(gM[aF]), fC._2])
1646 1646                                              $Tuple4(ir._1, ir._2, (parseIntValue(gM[aE]) + is), (parseIntValue(gM[aF]) - is))
1647 1647                                              }
1648 1648                                  let it = iq._1
1649 1649                                  let iu = iq._2
1650 1650                                  let iv = iq._3
1651 1651                                  let iw = iq._4
1652 1652                                  $Tuple5([IntegerEntry(aP(eM._2), ip), IntegerEntry(aT(ae, eM._2, b), ip)], gr, [gU[aH], iu, gU[aJ], gU[aK]], gE, [gv[ay], it, gv[aA], gv[aB], makeString([gM[aD], toString(iv), toString(iw), gM[aG]], "_")])
1653 1653                                  }
1654 1654                          }
1655 1655                  }
1656 1656          }
1657 1657  
1658 1658  
1659 1659  func ix (b,aX,hV,ia) = {
1660 1660      let ih = aP(aX)
1661 1661      let ii = value(getInteger(ih))
1662 1662      let in = (fraction((lastBlock.timestamp - ii), hU(aX, hV), ak) * hV)
1663 1663      il(b, in, ia, aX)
1664 1664      }
1665 1665  
1666 1666  
1667 1667  func iy (dQ,hp,iz,aX) = {
1668 1668      let b = toString(hp)
1669 1669      let eM = hZ(b, dn, aX)
1670 1670      let hV = cH(eM._3[cs])
1671 1671      let iA = aQ(eM._2)
1672 1672      let iB = valueOrElse(getInteger(iA), 0)
1673 1673      if (if (!(bH))
1674 1674          then (iB >= 3)
1675 1675          else false)
1676 1676          then throw("Currently max infrastructure level = 3")
1677 1677          else {
1678 1678              let iC = ((sqrt(hV, 0, 0, DOWN) / 5) + 2)
1679 1679              let V = (iB + 1)
1680 1680              if (if (bH)
1681 1681                  then (V > iC)
1682 1682                  else false)
1683 1683                  then throw(("Currently max infrastructure level = " + toString(iC)))
1684 1684                  else {
1685 1685                      let iD = fraction(cR, (hV * V), bR)
1686 1686                      if (if (!(dQ))
1687 1687                          then (iz != iD)
1688 1688                          else false)
1689 1689                          then throw(("Payment attached should be " + toString(iD)))
1690 1690                          else {
1691 1691                              let gr = bh(eM._1)
1692 1692                              let gU = gq(gr)
1693 1693                              let hO = split(gU[aJ], "_")
1694 1694                              let iE = fraction(bM, (hV * V), bR)
1695 1695                              let hP = makeString(dP(dQ, hO, iE), "_")
1696 1696                              let iF = ix(b, eM._2, hV, dn)
1697 1697                              let iG = iF._5
1698 1698                              let iH = gs(iG[ay])
1699 1699                              let iI = makeString([split(iG[ay], "_")[0], toString(V)], "_")
1700 1700                              let iJ = gs(iI)
1701 1701                              let gM = split(iG[aC], "_")
1702 1702                              let iK = makeString([gM[aD], gM[aE], toString(((parseIntValue(gM[aF]) + iJ) - iH)), toString(iJ)], "_")
1703 1703                              $Tuple3(([IntegerEntry(iA, V), IntegerEntry(dg(eM._2, b), V), StringEntry(gr, makeString([gU[aH], iF._3[aI], hP, gU[aK]], ":")), StringEntry(iF._4, makeString([iI, iG[az], iG[aA], iG[aB], iK], ":"))] ++ iF._1), V, iE)
1704 1704                              }
1705 1705                      }
1706 1706              }
1707 1707      }
1708 1708  
1709 1709  
1710 1710  func iL (s,iM) = if (!(bF))
1711 1711      then $Tuple2(nil, 0)
1712 1712      else {
1713 1713          let iN = v(s)
1714 1714          let iO = u(s)
1715 1715          let P = valueOrElse(getInteger(Z, iO), 0)
1716 1716          let U = (P + iM)
1717 1717          let iP = S(valueOrElse(getInteger(Z, iN), 0), U)
1718 1718          let iQ = w(s)
1719 1719          $Tuple2([IntegerEntry(iN, iP[0]), IntegerEntry(iO, U), IntegerEntry(iQ, (valueOrElse(getInteger(iQ), 0) + iP[1]))], U)
1720 1720          }
1721 1721  
1722 1722  
1723 1723  func iR (b,iM) = if (!(bF))
1724 1724      then $Tuple2(nil, 0)
1725 1725      else {
1726 1726          let iN = z(b)
1727 1727          let iO = y(b)
1728 1728          let P = valueOrElse(getInteger(Z, iO), 0)
1729 1729          let U = (P + iM)
1730 1730          let iP = S(valueOrElse(getInteger(Z, iN), 0), U)
1731 1731          let iQ = A(b)
1732 1732          $Tuple2([IntegerEntry(iN, iP[0]), IntegerEntry(iO, U), IntegerEntry(iQ, (valueOrElse(getInteger(iQ), 0) + iP[1]))], U)
1733 1733          }
1734 1734  
1735 1735  
1736 1736  func iS (b) = {
1737 1737      let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
1738 1738      let iT = bb(b)
1739 1739      let iU = getString(iT)
1740 1740      if (!(isDefined(iU)))
1741 1741          then throw("You are not eligible for ONBOARD artifact")
1742 1742          else {
1743 1743              let iV = bd(b)
1744 1744              let iW = getString(iV)
1745 1745              if (isDefined(iW))
1746 1746                  then throw(("You already used your ONBOARD artifact on duck " + value(iW)))
1747 1747                  else {
1748 1748                      let iX = bc(s)
1749 1749                      let iY = getString(iX)
1750 1750                      if (isDefined(iY))
1751 1751                          then throw(((("The duck " + s) + " already got points from ONBOARD artifact from user ") + value(iY)))
1752 1752                          else ([StringEntry(iV, s), StringEntry(iX, b)] ++ iL(s, M)._1)
1753 1753                      }
1754 1754              }
1755 1755      }
1756 1756  
1757 1757  
1758 1758  func iZ (b,ib) = {
1759 1759      let eM = hZ(b, dn, ib)
1760 1760      let aX = eM._2
1761 1761      let hV = cH(eM._3[cs])
1762 1762      let ja = aR(ag, aX)
1763 1763      if ((valueOrElse(getInteger(ja), 0) > 0))
1764 1764          then throw("Presale artifact is already activated")
1765 1765          else if ((parseIntValue(eM._3[cr]) > da))
1766 1766              then throw((((ae + " ") + aX) + " is not eligible for presale artifact"))
1767 1767              else {
1768 1768                  let iF = ix(b, aX, hV, dn)
1769 1769                  (((iF._1 :+ IntegerEntry(ja, hV)) :+ StringEntry(iF._2, makeString(iF._3, ":"))) :+ StringEntry(iF._4, makeString(iF._5, ":")))
1770 1770                  }
1771 1771      }
1772 1772  
1773 1773  
1774 1774  func jb (s) = {
1775 1775      let jc = valueOrElse(getInteger(cq, bn), 0)
1776 1776      let id = split(valueOrElse(getString(bi(s)), am), "_")
1777 1777      let jd = lastBlock.timestamp
1778 1778      let je = bt(cq, jc)
1779 1779      let bv = je[br]
1780 1780      let bw = je[bs]
1781 1781      if ((id[bB] != "T"))
1782 1782          then false
1783 1783          else {
1784 1784              let dV = if (if (if ((parseIntValue(id[bA]) == jc))
1785 1785                  then (bw[by] == "INPROGRESS")
1786 1786                  else false)
1787 1787                  then (parseIntValue(bv[bx]) > jd)
1788 1788                  else false)
1789 1789                  then throw("Your duck is taking part in the tournament")
1790 1790                  else invoke(this, "exitTournamentInternal", [s], nil)
1791 1791              if ((dV == dV))
1792 1792                  then false
1793 1793                  else throw("Strict value is not equal to itself.")
1794 1794              }
1795 1795      }
1796 1796  
1797 1797  
1798 1798  func jf (jg,V,jh,b,ji,jj) = {
1799 1799      let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
1800 1800      if (jb(s))
1801 1801          then throw("mergeInternal_checkTournament")
1802 1802          else {
1803 1803              func jk (dD,aX) =             {
1804 1804                  let ig = value(assetInfo(fromBase58String(aX)))
1805 1805                  let ih = aP(aX)
1806 1806                  let ii = valueOrErrorMessage(getInteger(ih), (("NFT " + ig.name) + " is not staked"))
1807 1807                  let ij = valueOrErrorMessage(getString(aM(aX)), (("NFT " + ig.name) + " is orphaned"))
1808 1808                  if ((ij != b))
1809 1809                      then throw((ae + " is not yours"))
1810 1810                      else {
1811 1811                          let ik = split(ig.description, "_")
1812 1812                          let cz = ik[cu]
1813 1813                          if (if ((dD._3 != ""))
1814 1814                              then (dD._3 != cz)
1815 1815                              else false)
1816 1816                              then throw("Lands should be on the same continent to merge")
1817 1817                              else {
1818 1818                                  let cI = ik[cs]
1819 1819                                  let jl = dD._1
1820 1820                                  let fo = valueOrErrorMessage(indexOf(jl, cI), "You haven't passed all the lands needed")
1821 1821                                  let jm = (take(jl, fo) + drop(jl, (fo + 1)))
1822 1822                                  let hV = cH(cI)
1823 1823                                  let jn = (dD._2 + valueOrElse(getInteger(aR(ag, aX)), 0))
1824 1824                                  let gG = valueOrElse(getInteger(aQ(aX)), 0)
1825 1825                                  let jo = {
1826 1826                                      let bK = cI
1827 1827                                      if (("S" == bK))
1828 1828                                          then 3
1829 1829                                          else if (("M" == bK))
1830 1830                                              then 4
1831 1831                                              else if (("L" == bK))
1832 1832                                                  then 5
1833 1833                                                  else if (("XL" == bK))
1834 1834                                                      then 6
1835 1835                                                      else throw("Only S, M, L, XL can merge")
1836 1836                                      }
1837 1837                                  if ((gG != jo))
1838 1838                                      then throw("All lands should be maxed to merge")
1839 1839                                      else {
1840 1840                                          let dd = ik[cr]
1841 1841                                          let fk = fq(ik[ct])
1842 1842                                          let fu = (lastBlock.timestamp - ii)
1843 1843                                          if ((0 > fu))
1844 1844                                              then throw(((("Saved timestamp is in future, saved = " + toString(ii)) + ", current = ") + toString(lastBlock.timestamp)))
1845 1845                                              else {
1846 1846                                                  let im = hU(aX, hV)
1847 1847                                                  let gF = (hV / bR)
1848 1848                                                  let iu = fs(split(dD._4, "_"), fk, fu, gF, im)
1849 1849                                                  let dN = fi(dD._6, fk, gF, -1)
1850 1850                                                  let jp = fi(dD._10, fk, gF, -1)
1851 1851                                                  let fY = fi(dD._9, fk, gF, 1)
1852 1852                                                  let jq = dD._7
1853 1853                                                  let cl = indexOf(jq, aX)
1854 1854                                                  if (!(isDefined(cl)))
1855 1855                                                      then throw(("Your staked lands don't contain " + aX))
1856 1856                                                      else {
1857 1857                                                          let jr = aO(aX)
1858 1858                                                          let js = valueOrElse(getString(jr), "")
1859 1859                                                          $Tuple10(jm, jn, cz, iu, ((((((((((((dD._5 :+ DeleteEntry(aP(aX))) :+ DeleteEntry(aT(ae, aX, b))) :+ DeleteEntry(dc(dd))) :+ DeleteEntry(aM(aX))) :+ DeleteEntry(aQ(aX))) :+ DeleteEntry(dg(aX, b))) :+ DeleteEntry(aR(ag, aX))) :+ DeleteEntry(dh(dd))) :+ DeleteEntry(aW(aX))) :+ DeleteEntry(jr)) :+ Burn(fromBase58String(aX), 1)) ++ (if ((js != ""))
1860 1860                                                              then [DeleteEntry(de(js))]
1861 1861                                                              else nil)), dN, removeByIndex(jq, value(cl)), (dD._8 + hV), fY, jp)
1862 1862                                                          }
1863 1863                                                  }
1864 1864                                          }
1865 1865                                  }
1866 1866                          }
1867 1867                  }
1868 1868  
1869 1869              let gr = bh(s)
1870 1870              let gU = gq(gr)
1871 1871              let fj = split(valueOrElse(getString(cx()), "0_0_0_0_0_0"), "_")
1872 1872              let jt = cA(b)
1873 1873              let ju = getString(jt)
1874 1874              let jv = if (isDefined(ju))
1875 1875                  then split_51C(value(ju), "_")
1876 1876                  else nil
1877 1877              let jw = split(value(assetInfo(fromBase58String(ji[0]))).description, "_")[cu]
1878 1878              let jx = split(valueOrElse(getString(cy(jw)), "0_0_0_0_0_0"), "_")
1879 1879              let dO = {
1880 1880                  let dF = ji
1881 1881                  let dG = size(dF)
1882 1882                  let dH = $Tuple10(jh, 0, "", gU[aI], nil, fj, jv, 0, split("0_0_0_0_0_0", "_"), jx)
1883 1883                  func dI (dJ,dK) =                 if ((dK >= dG))
1884 1884                      then dJ
1885 1885                      else jk(dJ, dF[dK])
1886 1886  
1887 1887                  func dL (dJ,dK) =                 if ((dK >= dG))
1888 1888                      then dJ
1889 1889                      else throw("List size exceeds 5")
1890 1890  
1891 1891                  dL(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5)
1892 1892                  }
1893 1893              let cz = dO._3
1894 1894              let fS = valueOrErrorMessage(indexOf(aq, cz), ("Unknown continent: " + cz))
1895 1895              let fr = fX(dO._9, (cH(jg) / bR))
1896 1896              let hs = valueOrElse(getInteger(db()), (da + 1))
1897 1897              let jy = toString(hs)
1898 1898              let ht = Issue(ds(jy, jg), makeString([jy, jg, fr, cz], "_"), 1, 0, false)
1899 1899              let aN = calculateAssetId(ht)
1900 1900              let jz = toBase58String(aN)
1901 1901              let hP = makeString(dP((jj > 0), split(gU[aJ], "_"), jj), "_")
1902 1902              let jA = cB(b)
1903 1903              let jB = valueOrElse(getInteger(jA), 0)
1904 1904              $Tuple2((((((((((((((((dO._5 :+ (if ((size(dO._7) > 0))
1905 1905                  then StringEntry(jt, makeString_11C(dO._7, "_"))
1906 1906                  else DeleteEntry(jt))) :+ IntegerEntry(jA, if ((dO._8 > jB))
1907 1907                  then 0
1908 1908                  else (jB - dO._8))) :+ IntegerEntry(db(), (hs + 1))) :+ ht) :+ StringEntry(dc(jy), jz)) :+ StringEntry(aM(jz), b)) :+ StringEntry(dh(jy), b)) :+ IntegerEntry(aR(ag, jz), dO._2)) :+ IntegerEntry(aQ(jz), V)) :+ IntegerEntry(dg(jz, b), V)) :+ StringEntry(gr, makeString([gU[aH], dO._4, hP, gU[aK]], ":"))) :+ StringEntry(cx(), makeString(dO._6, "_"))) :+ StringEntry(cy(cz), makeString(dO._10, "_"))) :+ StringEntry(bi(s), makeString([cz, "L", jz], "_"))) :+ ScriptTransfer(addressFromStringValue(b), 1, aN)), jz)
1909 1909              }
1910 1910      }
1911 1911  
1912 1912  
1913 1913  func jC (b,ji) = jf("M", 3, "SSSS", b, ji, 0)
1914 1914  
1915 1915  
1916 1916  func jD (b,ji) = jf("L", 4, "SMM", b, ji, (bM * 4))
1917 1917  
1918 1918  
1919 1919  func jE (b,ji) = jf("XL", 5, "SSSML", b, ji, (bM * 47))
1920 1920  
1921 1921  
1922 1922  func jF (b,ji) = jf("XXL", 6, "LXL", b, ji, (bM * 54))
1923 1923  
1924 1924  
1925 1925  func jG (b,ji) = {
1926 1926      let bK = size(ji)
1927 1927      if ((4 == bK))
1928 1928          then jC(b, ji)
1929 1929          else if ((3 == bK))
1930 1930              then jD(b, ji)
1931 1931              else if ((5 == bK))
1932 1932                  then jE(b, ji)
1933 1933                  else if ((2 == bK))
1934 1934                      then jF(b, ji)
1935 1935                      else throw("Unknown merge")
1936 1936      }
1937 1937  
1938 1938  
1939 1939  func jH (fo) = if (if ((fo.originCaller != cm))
1940 1940      then valueOrElse(getBoolean(bj()), false)
1941 1941      else false)
1942 1942      then throw("Contracts are under maintenance")
1943 1943      else StringEntry(aL(toString(fo.originCaller)), toBase58String(fo.transactionId))
1944 1944  
1945 1945  
1946 1946  @Callable(fo)
1947 1947  func constructorV1 (jI) = if ((fo.caller != this))
1948 1948      then throw("Permission denied")
1949 1949      else [StringEntry(cg(), jI)]
1950 1950  
1951 1951  
1952 1952  
1953 1953  @Callable(fo)
1954 1954  func setBlocked (jJ) = if ((fo.caller != this))
1955 1955      then throw("permission denied")
1956 1956      else [BooleanEntry(bj(), jJ)]
1957 1957  
1958 1958  
1959 1959  
1960 1960  @Callable(fo)
1961 1961  func stakeLand () = {
1962 1962      let jK = jH(fo)
1963 1963      if ((size(fo.payments) != 1))
1964 1964          then throw("Exactly one payment required")
1965 1965          else {
1966 1966              let jL = value(fo.payments[0])
1967 1967              let aN = value(jL.assetId)
1968 1968              let bY = toString(fo.caller)
1969 1969              if ((jL.amount != 1))
1970 1970                  then throw((("NFT " + ae) + " token should be attached as payment"))
1971 1971                  else {
1972 1972                      let ig = value(assetInfo(aN))
1973 1973                      if ((ig.issuer != this))
1974 1974                          then throw("Unknown issuer of token")
1975 1975                          else if (!(contains(ig.name, ae)))
1976 1976                              then throw((("Only NFT " + ae) + " tokens are accepted"))
1977 1977                              else {
1978 1978                                  let jM = drop(ig.name, 4)
1979 1979                                  let dd = if (contains(jM, "XXL"))
1980 1980                                      then dropRight(jM, 3)
1981 1981                                      else if (contains(jM, "XL"))
1982 1982                                          then dropRight(jM, 2)
1983 1983                                          else dropRight(jM, 1)
1984 1984                                  if (!(isDefined(parseInt(dd))))
1985 1985                                      then throw(("Cannot parse land number from " + ig.name))
1986 1986                                      else {
1987 1987                                          let aX = toBase58String(aN)
1988 1988                                          let ih = aP(aX)
1989 1989                                          if (isDefined(getInteger(ih)))
1990 1990                                              then throw((("NFT " + ig.name) + " is already staked"))
1991 1991                                              else {
1992 1992                                                  let ik = split(ig.description, "_")
1993 1993                                                  let fk = fq(ik[ct])
1994 1994                                                  let hV = cH(ik[cs])
1995 1995                                                  let gF = (hV / bR)
1996 1996                                                  let dN = fp(fk, gF, 1)
1997 1997                                                  let jN = cy(ik[cu])
1998 1998                                                  let jx = split(valueOrElse(getString(jN), "0_0_0_0_0_0"), "_")
1999 1999                                                  let jO = makeString(fi(jx, fk, gF, 1), "_")
2000 2000                                                  let jt = cA(bY)
2001 2001                                                  let ju = getString(jt)
2002 2002                                                  let jq = if (isDefined(ju))
2003 2003                                                      then split_51C(value(ju), "_")
2004 2004                                                      else nil
2005 2005                                                  if (containsElement(jq, aX))
2006 2006                                                      then throw(("Your staked lands already contain " + aX))
2007 2007                                                      else if ((size(jq) >= ai))
2008 2008                                                          then throw((("Your already staked max (" + toString(ai)) + ") lands"))
2009 2009                                                          else {
2010 2010                                                              let gG = valueOrElse(getInteger(aQ(aX)), 0)
2011 2011                                                              let jA = cB(bY)
2012 2012                                                              let jP = valueOrElse(getInteger(jA), 0)
2013 2013                                                              let jQ = cF(invoke(cp, "onStakeUnstakeLand", [bY], nil))
2014 2014                                                              $Tuple2([IntegerEntry(ih, lastBlock.timestamp), IntegerEntry(aT(ae, aX, bY), lastBlock.timestamp), StringEntry(jt, makeString_11C((jq :+ aX), "_")), IntegerEntry(jA, (jP + hV)), StringEntry(aM(aX), bY), StringEntry(dh(dd), bY), IntegerEntry(dg(aX, bY), gG), StringEntry(cx(), dN), StringEntry(jN, jO), jK], jQ)
2015 2015                                                              }
2016 2016                                                  }
2017 2017                                          }
2018 2018                                  }
2019 2019                      }
2020 2020              }
2021 2021      }
2022 2022  
2023 2023  
2024 2024  
2025 2025  @Callable(fo)
2026 2026  func unstakeLand (ib) = {
2027 2027      let jK = jH(fo)
2028 2028      if ((size(fo.payments) != 0))
2029 2029          then throw("No payments required")
2030 2030          else {
2031 2031              let b = toString(fo.caller)
2032 2032              let eM = hZ(b, dm, ib)
2033 2033              let aX = eM._2
2034 2034              let ik = eM._3
2035 2035              let jt = cA(b)
2036 2036              let fk = fq(ik[ct])
2037 2037              let hV = cH(ik[cs])
2038 2038              let gF = (hV / bR)
2039 2039              let dN = fp(fk, gF, -1)
2040 2040              let jN = cy(ik[cu])
2041 2041              let jx = split(valueOrElse(getString(jN), "0_0_0_0_0_0"), "_")
2042 2042              let jO = makeString(fi(jx, fk, gF, -1), "_")
2043 2043              let iF = ix(b, aX, hV, dm)
2044 2044              let jq = split_51C(valueOrElse(getString(jt), ""), "_")
2045 2045              let cl = indexOf(jq, aX)
2046 2046              if (!(isDefined(cl)))
2047 2047                  then throw(("Your staked lands don't contain " + aX))
2048 2048                  else {
2049 2049                      let jd = lastBlock.timestamp
2050 2050                      let jR = valueOrElse(getInteger(co, bk(b)), 0)
2051 2051                      if ((jR >= jd))
2052 2052                          then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(jR)))
2053 2053                          else {
2054 2054                              let jS = (valueOrElse(getInteger(cp, a(b)), 0) + bN)
2055 2055                              if ((jS > jd))
2056 2056                                  then throw(("Your staked lands took part in arbitrage, cannot unstake until " + toString(jS)))
2057 2057                                  else {
2058 2058                                      let jA = cB(b)
2059 2059                                      let jB = valueOrElse(getInteger(jA), 0)
2060 2060                                      let jT = if ((hV > jB))
2061 2061                                          then 0
2062 2062                                          else (jB - hV)
2063 2063                                      let jQ = cF(invoke(cp, "onStakeUnstakeLand", [b], nil))
2064 2064                                      $Tuple2([ScriptTransfer(fo.caller, 1, fromBase58String(aX)), DeleteEntry(aP(aX)), DeleteEntry(aT(ae, aX, b)), StringEntry(cx(), dN), StringEntry(jN, jO), StringEntry(iF._2, makeString(iF._3, ":")), if ((size(jq) > 1))
2065 2065                                          then StringEntry(jt, makeString_11C(removeByIndex(jq, value(cl)), "_"))
2066 2066                                          else DeleteEntry(jt), IntegerEntry(jA, jT), jK], jQ)
2067 2067                                      }
2068 2068                              }
2069 2069                      }
2070 2070              }
2071 2071      }
2072 2072  
2073 2073  
2074 2074  
2075 2075  @Callable(fo)
2076 2076  func stakeDuck () = {
2077 2077      let jK = jH(fo)
2078 2078      if ((size(fo.payments) != 1))
2079 2079          then throw("Exactly one payment required")
2080 2080          else {
2081 2081              let jL = value(fo.payments[0])
2082 2082              let aN = value(jL.assetId)
2083 2083              let bY = toString(fo.caller)
2084 2084              if ((jL.amount != 1))
2085 2085                  then throw((("NFT " + af) + " token should be attached as payment"))
2086 2086                  else {
2087 2087                      let ig = value(assetInfo(aN))
2088 2088                      if (if ((ig.issuer != cK))
2089 2089                          then (ig.issuer != cL)
2090 2090                          else false)
2091 2091                          then throw((("Unknown issuer of " + af) + " token"))
2092 2092                          else if (!(contains(ig.name, af)))
2093 2093                              then throw((("Only NFT " + af) + " tokens are accepted"))
2094 2094                              else {
2095 2095                                  let jU = toBase58String(aN)
2096 2096                                  let ih = aP(jU)
2097 2097                                  if (isDefined(getInteger(ih)))
2098 2098                                      then throw((("NFT " + ig.name) + " is already staked"))
2099 2099                                      else if (isDefined(getString(bg(bY))))
2100 2100                                          then throw(("You already staked one duck: " + ig.name))
2101 2101                                          else if (jb(jU))
2102 2102                                              then throw("stakeDuck_checkTournament")
2103 2103                                              else {
2104 2104                                                  let jV = bi(jU)
2105 2105                                                  let jW = getString(jV)
2106 2106                                                  let gr = bh(jU)
2107 2107                                                  let jX = getString(gr)
2108 2108                                                  let hH = r(jU)
2109 2109                                                  let hI = Q(valueOrElse(getInteger(v(jU)), 0))
2110 2110                                                  let jY = valueOrElse(getInteger(hH), hI)
2111 2111                                                  ([IntegerEntry(ih, lastBlock.timestamp), IntegerEntry(aT(af, toBase58String(aN), bY), lastBlock.timestamp), StringEntry(bf(jU), bY), StringEntry(bg(bY), jU)] ++ (if (isDefined(jW))
2112 2112                                                      then nil
2113 2113                                                      else ([StringEntry(jV, am)] ++ (if (isDefined(jX))
2114 2114                                                          then nil
2115 2115                                                          else (([StringEntry(gr, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(hH, jY)) :+ jK)))))
2116 2116                                                  }
2117 2117                                  }
2118 2118                      }
2119 2119              }
2120 2120      }
2121 2121  
2122 2122  
2123 2123  
2124 2124  @Callable(fo)
2125 2125  func unstakeDuck (jU) = {
2126 2126      let jK = jH(fo)
2127 2127      if ((size(fo.payments) != 0))
2128 2128          then throw("No payments required")
2129 2129          else {
2130 2130              let aN = fromBase58String(jU)
2131 2131              let bY = toString(fo.caller)
2132 2132              let ig = value(assetInfo(aN))
2133 2133              let ih = aP(jU)
2134 2134              if (!(isDefined(getInteger(ih))))
2135 2135                  then throw((("NFT " + ig.name) + " is not staked"))
2136 2136                  else if (!(isDefined(getString(bg(bY)))))
2137 2137                      then throw((("The duck " + ig.name) + " is not staked"))
2138 2138                      else {
2139 2139                          let ij = valueOrErrorMessage(getString(bf(jU)), (("NFT " + ig.name) + " is orphaned"))
2140 2140                          if ((ij != bY))
2141 2141                              then throw("Staked NFT is not yours")
2142 2142                              else if (jb(jU))
2143 2143                                  then throw("unstakeDuck_checkTournament")
2144 2144                                  else {
2145 2145                                      let hH = r(jU)
2146 2146                                      let hI = Q(valueOrElse(getInteger(v(jU)), 0))
2147 2147                                      let ad = valueOrElse(getInteger(hH), hI)
2148 2148                                      if ((hI > ad))
2149 2149                                          then throw((("Please heal your duck to " + toString(hI)) + "hp before unstaking"))
2150 2150                                          else [ScriptTransfer(fo.caller, 1, aN), DeleteEntry(ih), DeleteEntry(hH), DeleteEntry(bi(jU)), DeleteEntry(bf(jU)), DeleteEntry(aT(af, jU, bY)), DeleteEntry(bg(bY)), jK]
2151 2151                                      }
2152 2152                          }
2153 2153              }
2154 2154      }
2155 2155  
2156 2156  
2157 2157  
2158 2158  @Callable(fo)
2159 2159  func claimRes (du,jZ) = {
2160 2160      let jK = jH(fo)
2161 2161      if ((size(fo.payments) != 0))
2162 2162          then throw("No payments required")
2163 2163          else {
2164 2164              let b = toString(fo.originCaller)
2165 2165              let dV = il(b, du, dm, jZ)
2166 2166              let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
2167 2167              $Tuple2(((((dV._1 ++ iL(s, fraction(E, du, bQ))._1) :+ StringEntry(dV._2, makeString(dV._3, ":"))) :+ StringEntry(dV._4, makeString(dV._5, ":"))) :+ jK), dV._3[aI])
2168 2168              }
2169 2169      }
2170 2170  
2171 2171  
2172 2172  
2173 2173  @Callable(fo)
2174 2174  func claimResToWH (du,jZ) = {
2175 2175      let jK = jH(fo)
2176 2176      if ((size(fo.payments) != 0))
2177 2177          then throw("No payments required")
2178 2178          else {
2179 2179              let b = toString(fo.originCaller)
2180 2180              let dV = il(b, du, dl, jZ)
2181 2181              $Tuple2(((((dV._1 ++ iR(b, fraction(E, du, bQ))._1) :+ StringEntry(dV._2, makeString(dV._3, ":"))) :+ StringEntry(dV._4, makeString(dV._5, ":"))) :+ jK), dV._5[az])
2182 2182              }
2183 2183      }
2184 2184  
2185 2185  
2186 2186  
2187 2187  @Callable(fo)
2188 2188  func flight (hw,hx) = {
2189 2189      let jK = jH(fo)
2190 2190      if ((size(fo.payments) != 0))
2191 2191          then throw("No payments required")
2192 2192          else {
2193 2193              let bl = toString(fo.caller)
2194 2194              let fT = hv(bl, hw, hx)
2195 2195              let s = fT._2
2196 2196              let hD = fT._4
2197 2197              let ka = split(hD, "_")
2198 2198              let kb = (ka[bB] == "T")
2199 2199              if (if (!(kb))
2200 2200                  then jb(s)
2201 2201                  else false)
2202 2202                  then throw("flight_checkTournament")
2203 2203                  else {
2204 2204                      let kc = if (kb)
2205 2205                          then {
2206 2206                              let jc = valueOrElse(getInteger(cq, bn), 0)
2207 2207                              let jd = lastBlock.timestamp
2208 2208                              let je = bt(cq, jc)
2209 2209                              let bv = je[br]
2210 2210                              let bw = je[bs]
2211 2211                              if (if (if ((parseIntValue(ka[bA]) != jc))
2212 2212                                  then true
2213 2213                                  else (bw[by] != "INPROGRESS"))
2214 2214                                  then true
2215 2215                                  else (jd > parseIntValue(bv[bx])))
2216 2216                                  then unit
2217 2217                                  else {
2218 2218                                      let kd = parseIntValue(ka[bC])
2219 2219                                      let ke = parseIntValue(bw[bz])
2220 2220                                      if ((ke >= kd))
2221 2221                                          then unit
2222 2222                                          else invoke(cq, "updateDynamicData", [s, kd], nil)
2223 2223                                      }
2224 2224                              }
2225 2225                          else unit
2226 2226                      if ((kc == kc))
2227 2227                          then {
2228 2228                              let jV = bi(s)
2229 2229                              let id = valueOrElse(getString(jV), am)
2230 2230                              if ((hD == id))
2231 2231                                  then throw("You can't fly to the same location")
2232 2232                                  else {
2233 2233                                      let hQ = x(s)
2234 2234                                      let hR = valueOrElse(getString(hQ), ",;,_,;,_,;,_,;,_,;,_,;,")
2235 2235                                      let hS = dW(hR, fT._5)
2236 2236                                      $Tuple2(([StringEntry(jV, if ((fT._1 > 0))
2237 2237                                          then hD
2238 2238                                          else id), StringEntry(hQ, hS), IntegerEntry(r(s), fT._1), jK] ++ iL(s, if ((fT._1 > 0))
2239 2239                                          then F
2240 2240                                          else G)._1), fT._3)
2241 2241                                      }
2242 2242                              }
2243 2243                          else throw("Strict value is not equal to itself.")
2244 2244                      }
2245 2245              }
2246 2246      }
2247 2247  
2248 2248  
2249 2249  
2250 2250  @Callable(fo)
2251 2251  func heal (kf,kg,kh) = {
2252 2252      let jK = jH(fo)
2253 2253      if (if (if ((0 > kf))
2254 2254          then true
2255 2255          else (0 > kg))
2256 2256          then true
2257 2257          else (0 > kh))
2258 2258          then throw("Quantity cannot be negative")
2259 2259          else {
2260 2260              let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
2261 2261              if (jb(s))
2262 2262                  then throw("heal_checkTournament")
2263 2263                  else {
2264 2264                      let ki = [kf, kg, kh]
2265 2265                      let hH = r(s)
2266 2266                      let hI = Q(valueOrElse(getInteger(v(s)), 0))
2267 2267                      let kj = valueOrElse(getInteger(hH), hI)
2268 2268                      if ((kj >= hI))
2269 2269                          then throw((("HP should be < " + toString(hI)) + " to heal"))
2270 2270                          else {
2271 2271                              let gr = bh(s)
2272 2272                              let gU = gq(gr)
2273 2273                              let kk = if ((gU[aK] == ""))
2274 2274                                  then nil
2275 2275                                  else split_4C(gU[aK], "_")
2276 2276                              func kl (dD,km) =                             {
2277 2277                                  let cG = dD._2
2278 2278                                  let fK = if ((size(kk) > cG))
2279 2279                                      then parseIntValue(kk[cG])
2280 2280                                      else 0
2281 2281                                  if ((3 > cG))
2282 2282                                      then {
2283 2283                                          let kn = ki[cG]
2284 2284                                          if ((kn > fK))
2285 2285                                              then throw(((("You have only " + toString(fK)) + " of ") + ap[cG]))
2286 2286                                              else $Tuple3((dD._1 :+ toString((fK - kn))), (cG + 1), (dD._3 + (cN[cG] * kn)))
2287 2287                                          }
2288 2288                                      else $Tuple3((dD._1 :+ toString(fK)), (cG + 1), dD._3)
2289 2289                                  }
2290 2290  
2291 2291                              let dV = {
2292 2292                                  let dF = at
2293 2293                                  let dG = size(dF)
2294 2294                                  let dH = $Tuple3(nil, 0, 0)
2295 2295                                  func dI (dJ,dK) =                                 if ((dK >= dG))
2296 2296                                      then dJ
2297 2297                                      else kl(dJ, dF[dK])
2298 2298  
2299 2299                                  func dL (dJ,dK) =                                 if ((dK >= dG))
2300 2300                                      then dJ
2301 2301                                      else throw("List size exceeds 50")
2302 2302  
2303 2303                                  dL(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
2304 2304                                  }
2305 2305                              let ko = min([hI, (kj + dV._3)])
2306 2306                              $Tuple2(([IntegerEntry(hH, ko), StringEntry(gr, makeString_2C([gU[aH], gU[aI], gU[aJ], makeString(dV._1, "_")], ":")), jK] ++ iL(s, (N * ((kf + kg) + kh)))._1), ko)
2307 2307                              }
2308 2308                      }
2309 2309              }
2310 2310      }
2311 2311  
2312 2312  
2313 2313  
2314 2314  @Callable(fo)
2315 2315  func healES () = {
2316 2316      let jK = jH(fo)
2317 2317      if ((size(fo.payments) != 1))
2318 2318          then throw("Exactly one payment required")
2319 2319          else {
2320 2320              let jL = value(fo.payments[0])
2321 2321              if ((jL.assetId != bJ))
2322 2322                  then throw("Allowed USDT payment only!")
2323 2323                  else {
2324 2324                      let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
2325 2325                      if (jb(s))
2326 2326                          then throw("healES_checkTournament")
2327 2327                          else {
2328 2328                              let hH = r(s)
2329 2329                              let hI = Q(valueOrElse(getInteger(v(s)), 0))
2330 2330                              let kj = valueOrElse(getInteger(hH), hI)
2331 2331                              if ((kj > 0))
2332 2332                                  then throw("HP should be 0 to call Emergency Service")
2333 2333                                  else {
2334 2334                                      let gr = bh(s)
2335 2335                                      let gU = gq(gr)
2336 2336                                      let kk = if ((gU[aK] == ""))
2337 2337                                          then nil
2338 2338                                          else split_4C(gU[aK], "_")
2339 2339                                      let kp = if ((size(kk) > 0))
2340 2340                                          then parseIntValue(kk[0])
2341 2341                                          else 0
2342 2342                                      let kq = if ((size(kk) > 1))
2343 2343                                          then parseIntValue(kk[1])
2344 2344                                          else 0
2345 2345                                      let kr = if ((size(kk) > 2))
2346 2346                                          then parseIntValue(kk[2])
2347 2347                                          else 0
2348 2348                                      if (if (if ((kp > 0))
2349 2349                                          then true
2350 2350                                          else (kq > 0))
2351 2351                                          then true
2352 2352                                          else (kr > 0))
2353 2353                                          then throw("You have to use own Medical Kit")
2354 2354                                          else {
2355 2355                                              let ks = getString(cn, bm())
2356 2356                                              let kt = if (isDefined(ks))
2357 2357                                                  then split_4C(value(ks), "_")
2358 2358                                                  else nil
2359 2359                                              let ku = if ((size(kt) > 0))
2360 2360                                                  then parseIntValue(kt[0])
2361 2361                                                  else 0
2362 2362                                              if ((0 >= ku))
2363 2363                                                  then throw("There are no Medical Kits L1 at Emergency Service storage")
2364 2364                                                  else {
2365 2365                                                      let ko = (kj + cN[0])
2366 2366                                                      let kv = makeString([toString((ku - 1)), removeByIndex(kt, 0)], "_")
2367 2367                                                      let bE = split(at[0], "_")
2368 2368                                                      let kw = bD(bE)
2369 2369                                                      let kx = fraction((kw * ao), an, (bQ * ax))
2370 2370                                                      if ((jL.amount != kx))
2371 2371                                                          then throw(("Payment attached should be " + toString(kx)))
2372 2372                                                          else {
2373 2373                                                              let dV = cC(invoke(cn, "updateEsStorage", [kv], [AttachedPayment(bJ, kx)]))
2374 2374                                                              $Tuple2(([IntegerEntry(hH, ko), jK] ++ iL(s, H)._1), dV)
2375 2375                                                              }
2376 2376                                                      }
2377 2377                                              }
2378 2378                                      }
2379 2379                              }
2380 2380                      }
2381 2381              }
2382 2382      }
2383 2383  
2384 2384  
2385 2385  
2386 2386  @Callable(fo)
2387 2387  func updateBackpack (s,ky) = if ((fo.caller != cn))
2388 2388      then throw("permission denied")
2389 2389      else $Tuple2([StringEntry(bh(s), ky)], ky)
2390 2390  
2391 2391  
2392 2392  
2393 2393  @Callable(fo)
2394 2394  func commitForRandom () = {
2395 2395      let jK = jH(fo)
2396 2396      let kz = (height + cv)
2397 2397      let b = toString(fo.caller)
2398 2398      $Tuple2(([IntegerEntry(cw(b), kz)] :+ jK), kz)
2399 2399      }
2400 2400  
2401 2401  
2402 2402  
2403 2403  @Callable(fo)
2404 2404  func buySLand () = {
2405 2405      let jK = jH(fo)
2406 2406      if ((size(fo.payments) != 1))
2407 2407          then throw("Exactly one payment required")
2408 2408          else {
2409 2409              let jL = value(fo.payments[0])
2410 2410              if ((jL.assetId != bJ))
2411 2411                  then throw("Allowed USDT payment only!")
2412 2412                  else if ((jL.amount != cT))
2413 2413                      then throw(("Payment attached should be " + toString(cT)))
2414 2414                      else {
2415 2415                          let dV = ho(fo.caller, fo.transactionId)
2416 2416                          $Tuple2((((dV._1 :+ ScriptTransfer(cn, jL.amount, bJ)) ++ iR(toString(fo.caller), J)._1) :+ jK), dV._2._1)
2417 2417                          }
2418 2418              }
2419 2419      }
2420 2420  
2421 2421  
2422 2422  
2423 2423  @Callable(fo)
2424 2424  func expedition (hw,hx) = {
2425 2425      let jK = jH(fo)
2426 2426      if ((size(fo.payments) != 0))
2427 2427          then throw("No payments required")
2428 2428          else {
2429 2429              let dV = hN(fo.caller, fo.transactionId, hw, hx)
2430 2430              let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
2431 2431              if (jb(s))
2432 2432                  then throw("expedition_checkTournament")
2433 2433                  else $Tuple2(((dV._1 ++ iL(s, J)._1) :+ jK), $Tuple2(dV._2, dV._3))
2434 2434              }
2435 2435      }
2436 2436  
2437 2437  
2438 2438  
2439 2439  @Callable(fo)
2440 2440  func upgradeInfra (aX) = {
2441 2441      let jK = jH(fo)
2442 2442      if ((size(fo.payments) != 0))
2443 2443          then throw("No payments required")
2444 2444          else {
2445 2445              let dV = iy(true, fo.caller, 0, aX)
2446 2446              let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
2447 2447              $Tuple2(((dV._1 :+ jK) ++ iL(s, fraction(K, dV._3, bQ))._1), dV._2)
2448 2448              }
2449 2449      }
2450 2450  
2451 2451  
2452 2452  
2453 2453  @Callable(fo)
2454 2454  func activateArtifact (kA,kB) = {
2455 2455      let jK = jH(fo)
2456 2456      if ((size(fo.payments) != 0))
2457 2457          then throw("No payments required")
2458 2458          else {
2459 2459              let b = toString(fo.caller)
2460 2460              let dV = {
2461 2461                  let bK = kA
2462 2462                  if (("PRESALE" == bK))
2463 2463                      then iZ(b, kB)
2464 2464                      else if (("ONBOARD" == bK))
2465 2465                          then iS(b)
2466 2466                          else throw("Unknown artifact")
2467 2467                  }
2468 2468              (dV :+ jK)
2469 2469              }
2470 2470      }
2471 2471  
2472 2472  
2473 2473  
2474 2474  @Callable(fo)
2475 2475  func mergeLands (ji) = {
2476 2476      let jK = jH(fo)
2477 2477      if ((size(fo.payments) != 0))
2478 2478          then throw("No payments required")
2479 2479          else {
2480 2480              let dV = jG(toString(fo.caller), ji)
2481 2481              $Tuple2(((dV._1 :+ jK) ++ iR(toString(fo.caller), L)._1), dV._2)
2482 2482              }
2483 2483      }
2484 2484  
2485 2485  
2486 2486  
2487 2487  @Callable(fo)
2488 2488  func cargoExchange (kC,aX) = {
2489 2489      let jK = jH(fo)
2490 2490      if ((size(fo.payments) != 0))
2491 2491          then throw("No payments required")
2492 2492          else {
2493 2493              let gT = split_4C(kC, ":")
2494 2494              let b = toString(fo.originCaller)
2495 2495              let ig = value(assetInfo(fromBase58String(aX)))
2496 2496              let ih = aP(aX)
2497 2497              if (!(isDefined(getInteger(ih))))
2498 2498                  then throw((ig.name + " is not staked"))
2499 2499                  else {
2500 2500                      let ij = valueOrErrorMessage(getString(aM(aX)), (("NFT " + ig.name) + " is orphaned"))
2501 2501                      if ((ij != b))
2502 2502                          then throw((ae + " is not yours"))
2503 2503                          else {
2504 2504                              let gF = (cH(split(ig.description, "_")[cs]) / bR)
2505 2505                              let gG = valueOrElse(getInteger(aQ(aX)), 0)
2506 2506                              let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
2507 2507                              let id = valueOrElse(getString(bi(s)), am)
2508 2508                              let ie = split(value(id), "_")
2509 2509                              if ((ie[bB] != "L"))
2510 2510                                  then throw((("Duck location type is " + ie[bB]) + ", but should be L"))
2511 2511                                  else if ((ie[bC] != aX))
2512 2512                                      then throw(("Duck should be on the land " + aX))
2513 2513                                      else {
2514 2514                                          let gE = aW(aX)
2515 2515                                          let gv = gD(gE, gF, gG)
2516 2516                                          let gr = bh(s)
2517 2517                                          let gU = gq(gr)
2518 2518                                          let dV = gS(gT, gv, gU)
2519 2519                                          let gM = split(gv[aC], "_")
2520 2520                                          let iv = (parseIntValue(gM[aE]) + dV._7)
2521 2521                                          let iw = (parseIntValue(gM[aF]) - dV._7)
2522 2522  [StringEntry(gr, makeString_2C([gU[aH], dV._4, dV._5, dV._6], ":")), StringEntry(gE, makeString_2C([gv[ay], dV._1, dV._2, dV._3, makeString([gM[aD], toString(iv), toString(iw), gM[aG]], "_")], ":")), jK]
2523 2523                                          }
2524 2524                              }
2525 2525                      }
2526 2526              }
2527 2527      }
2528 2528  
2529 2529  
2530 2530  
2531 2531  @Callable(fo)
2532 2532  func saveWarehouse (gI,aX) = if ((fo.caller != cn))
2533 2533      then throw("Access denied")
2534 2534      else {
2535 2535          let gE = aW(aX)
2536 2536          let gJ = split_4C(gI, ":")
2537 2537          if ((size(gJ) != 5))
2538 2538              then throw("warehouse string should contain 4 ':' separators")
2539 2539              else {
2540 2540                  let kD = split(gJ[aC], "_")[aD]
2541 2541                  let iv = gu(gJ)
2542 2542                  let kE = gs(gJ[ay])
2543 2543                  let iw = ((kE - parseIntValue(kD)) - iv)
2544 2544                  let kF = makeString_2C([gJ[ay], gJ[az], gJ[aA], gJ[aB], makeString([kD, toString(iv), toString(iw), toString(kE)], "_")], ":")
2545 2545                  $Tuple2([StringEntry(gE, kF)], kF)
2546 2546                  }
2547 2547          }
2548 2548  
2549 2549  
2550 2550  
2551 2551  @Callable(fo)
2552 2552  func fixWarehouseFormat (aX) = if ((fo.caller != cm))
2553 2553      then throw("Access denied")
2554 2554      else {
2555 2555          let gE = aW(aX)
2556 2556          let ig = value(assetInfo(fromBase58String(aX)))
2557 2557          let gF = (cH(split(ig.description, "_")[cs]) / bR)
2558 2558          let gG = valueOrElse(getInteger(aQ(aX)), 0)
2559 2559          let gJ = gD(gE, gF, gG)
2560 2560          let kD = cF(invoke(cn, "recalcLockedVolumeREADONLY", [aX, gJ], nil))
2561 2561          let iv = gu(gJ)
2562 2562          let kE = gs(gJ[ay])
2563 2563          let iw = ((kE - kD) - iv)
2564 2564          let kF = makeString_2C([gJ[ay], gJ[az], gJ[aA], gJ[aB], makeString([toString(kD), toString(iv), toString(iw), toString(kE)], "_")], ":")
2565 2565          $Tuple2([StringEntry(gE, kF)], kF)
2566 2566          }
2567 2567  
2568 2568  
2569 2569  
2570 2570  @Callable(fo)
2571 2571  func fixContinentProportions (ji) = if ((fo.caller != cm))
2572 2572      then throw("Access denied")
2573 2573      else {
2574 2574          func kG (dD,kH) =         (dD :+ valueOrElse(getString(cy(kH)), "0_0_0_0_0_0"))
2575 2575  
2576 2576          let fg = {
2577 2577              let dF = aq
2578 2578              let dG = size(dF)
2579 2579              let dH = nil
2580 2580              func dI (dJ,dK) =             if ((dK >= dG))
2581 2581                  then dJ
2582 2582                  else kG(dJ, dF[dK])
2583 2583  
2584 2584              func dL (dJ,dK) =             if ((dK >= dG))
2585 2585                  then dJ
2586 2586                  else throw("List size exceeds 5")
2587 2587  
2588 2588              dL(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5)
2589 2589              }
2590 2590          func kI (dD,aX) =         {
2591 2591              let ig = value(assetInfo(fromBase58String(aX)))
2592 2592              let ik = split(ig.description, "_")
2593 2593              let gF = (cH(ik[cs]) / bR)
2594 2594              let kH = ik[cu]
2595 2595              let fk = fq(ik[ct])
2596 2596              let fS = value(indexOf(aq, kH))
2597 2597              let jx = split(dD[fS], "_")
2598 2598              let kJ = makeString(fi(jx, fk, gF, 1), "_")
2599 2599              let bK = kH
2600 2600              if (("Americas" == bK))
2601 2601                  then [kJ, dD[1], dD[2], dD[3], dD[4]]
2602 2602                  else if (("Europe" == bK))
2603 2603                      then [dD[0], kJ, dD[2], dD[3], dD[4]]
2604 2604                      else if (("Asia" == bK))
2605 2605                          then [dD[0], dD[1], kJ, dD[3], dD[4]]
2606 2606                          else if (("Africa" == bK))
2607 2607                              then [dD[0], dD[1], dD[2], kJ, dD[4]]
2608 2608                              else if (("Oceania" == bK))
2609 2609                                  then [dD[0], dD[1], dD[2], dD[3], kJ]
2610 2610                                  else throw("wrong continent")
2611 2611              }
2612 2612  
2613 2613          let dO = {
2614 2614              let dF = ji
2615 2615              let dG = size(dF)
2616 2616              let dH = fg
2617 2617              func gl (dJ,dK) =             if ((dK >= dG))
2618 2618                  then dJ
2619 2619                  else kI(dJ, dF[dK])
2620 2620  
2621 2621              func gm (dJ,dK) =             if ((dK >= dG))
2622 2622                  then dJ
2623 2623                  else throw("List size exceeds 100")
2624 2624  
2625 2625              gm(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(gl(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
2626 2626              }
2627 2627          $Tuple2([StringEntry(cy("Americas"), dO[0]), StringEntry(cy("Europe"), dO[1]), StringEntry(cy("Asia"), dO[2]), StringEntry(cy("Africa"), dO[3]), StringEntry(cy("Oceania"), dO[4])], 0)
2628 2628          }
2629 2629  
2630 2630  
2631 2631  
2632 2632  @Callable(fo)
2633 2633  func fixStakedPieces (bY) = if ((fo.caller != cm))
2634 2634      then throw("Access denied")
2635 2635      else {
2636 2636          let jB = if ((bY == ""))
2637 2637              then 0
2638 2638              else {
2639 2639                  let ju = getString(Z, cA(bY))
2640 2640                  let jq = if (isDefined(ju))
2641 2641                      then split_51C(value(ju), "_")
2642 2642                      else nil
2643 2643                  func kK (dD,aX) =                 {
2644 2644                      let ig = value(assetInfo(fromBase58String(aX)))
2645 2645                      let cI = split(ig.description, "_")[cs]
2646 2646                      (dD + cH(cI))
2647 2647                      }
2648 2648  
2649 2649                  let dF = jq
2650 2650                  let dG = size(dF)
2651 2651                  let dH = 0
2652 2652                  func dI (dJ,dK) =                 if ((dK >= dG))
2653 2653                      then dJ
2654 2654                      else kK(dJ, dF[dK])
2655 2655  
2656 2656                  func dL (dJ,dK) =                 if ((dK >= dG))
2657 2657                      then dJ
2658 2658                      else throw("List size exceeds 100")
2659 2659  
2660 2660                  dL(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dI(dH, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
2661 2661                  }
2662 2662          $Tuple2([IntegerEntry(cB(bY), jB)], jB)
2663 2663          }
2664 2664  
2665 2665  
2666 2666  
2667 2667  @Callable(fo)
2668 2668  func setCustomName (aN,js,aS) = {
2669 2669      let jK = jH(fo)
2670 2670      if ((size(fo.payments) != 1))
2671 2671          then throw("Exactly one payment required")
2672 2672          else {
2673 2673              let jL = value(fo.payments[0])
2674 2674              if ((jL.assetId != bJ))
2675 2675                  then throw("Allowed USDT payment only!")
2676 2676                  else if ((jL.amount != cP))
2677 2677                      then throw(("Payment should be " + toString(cP)))
2678 2678                      else if (contains(js, "__"))
2679 2679                          then throw(("Name should not contain '__': " + js))
2680 2680                          else if ((size(js) > cQ))
2681 2681                              then throw(("Name too long, maxLength=" + toString(cQ)))
2682 2682                              else {
2683 2683                                  let b = toString(fo.originCaller)
2684 2684                                  let kL = {
2685 2685                                      let bK = aS
2686 2686                                      if (("ACCOUNT" == bK))
2687 2687                                          then {
2688 2688                                              let kM = dj(js)
2689 2689                                              let kN = getString(kM)
2690 2690                                              if (isDefined(kN))
2691 2691                                                  then throw(("Name already registered: " + js))
2692 2692                                                  else {
2693 2693                                                      let kO = ba(b)
2694 2694                                                      let kP = getString(kO)
2695 2695                                                      let kQ = if (isDefined(kP))
2696 2696                                                          then [DeleteEntry(dj(value(kP)))]
2697 2697                                                          else nil
2698 2698                                                      (((kQ :+ StringEntry(kO, js)) :+ StringEntry(kM, b)) ++ iR(b, I)._1)
2699 2699                                                      }
2700 2700                                              }
2701 2701                                          else if (("LAND" == bK))
2702 2702                                              then {
2703 2703                                                  let ig = value(assetInfo(fromBase58String(aN)))
2704 2704                                                  let ih = aP(aN)
2705 2705                                                  if (!(isDefined(getInteger(ih))))
2706 2706                                                      then throw((ig.name + " is not staked"))
2707 2707                                                      else {
2708 2708                                                          let ij = valueOrErrorMessage(getString(aM(aN)), (("NFT " + ig.name) + " is orphaned"))
2709 2709                                                          if ((ij != b))
2710 2710                                                              then throw((ae + " is not yours"))
2711 2711                                                              else {
2712 2712                                                                  let kM = de(js)
2713 2713                                                                  let kN = getString(kM)
2714 2714                                                                  if (isDefined(kN))
2715 2715                                                                      then throw(("Name already registered: " + js))
2716 2716                                                                      else {
2717 2717                                                                          let kR = aO(aN)
2718 2718                                                                          let kP = getString(kR)
2719 2719                                                                          let kQ = if (isDefined(kP))
2720 2720                                                                              then [DeleteEntry(de(value(kP)))]
2721 2721                                                                              else nil
2722 2722                                                                          (((kQ :+ StringEntry(kR, js)) :+ StringEntry(kM, aN)) ++ iR(b, I)._1)
2723 2723                                                                          }
2724 2724                                                                  }
2725 2725                                                          }
2726 2726                                                  }
2727 2727                                              else if (("DUCK" == bK))
2728 2728                                                  then {
2729 2729                                                      let ig = value(assetInfo(fromBase58String(aN)))
2730 2730                                                      let ih = aP(aN)
2731 2731                                                      if (if (!(isDefined(getInteger(ih))))
2732 2732                                                          then true
2733 2733                                                          else !(isDefined(getString(bg(b)))))
2734 2734                                                          then throw((ig.name + " is not staked"))
2735 2735                                                          else {
2736 2736                                                              let ij = valueOrErrorMessage(getString(bf(aN)), (("NFT " + ig.name) + " is orphaned"))
2737 2737                                                              if ((ij != b))
2738 2738                                                                  then throw((af + " is not yours"))
2739 2739                                                                  else {
2740 2740                                                                      let kM = di(js)
2741 2741                                                                      let kN = getString(kM)
2742 2742                                                                      if (isDefined(kN))
2743 2743                                                                          then throw(("Name already registered: " + js))
2744 2744                                                                          else {
2745 2745                                                                              let kR = aZ(aN)
2746 2746                                                                              let kP = getString(kR)
2747 2747                                                                              let kQ = if (isDefined(kP))
2748 2748                                                                                  then [DeleteEntry(di(value(kP)))]
2749 2749                                                                                  else nil
2750 2750                                                                              (((kQ :+ StringEntry(kR, js)) :+ StringEntry(kM, aN)) ++ iL(aN, I)._1)
2751 2751                                                                              }
2752 2752                                                                      }
2753 2753                                                              }
2754 2754                                                      }
2755 2755                                                  else throw("Unknown entity type")
2756 2756                                      }
2757 2757                                  $Tuple2(((kL :+ ScriptTransfer(cn, jL.amount, bJ)) :+ jK), 0)
2758 2758                                  }
2759 2759              }
2760 2760      }
2761 2761  
2762 2762  
2763 2763  
2764 2764  @Callable(fo)
2765 2765  func setReferrals (kS,kT) = if ((fo.callerPublicKey != cM))
2766 2766      then throw("Permission denied")
2767 2767      else {
2768 2768          let jK = jH(fo)
2769 2769          if ((size(fo.payments) != 0))
2770 2770              then throw("No payments required")
2771 2771              else if (!(isDefined(addressFromString(kS))))
2772 2772                  then throw(("Invalid address: " + kS))
2773 2773                  else if (!(isDefined(addressFromString(kT))))
2774 2774                      then throw(("Invalid address: " + kT))
2775 2775                      else {
2776 2776                          let kU = dk()
2777 2777                          let kV = getString(kU)
2778 2778                          let kW = if (isDefined(kV))
2779 2779                              then split_4C(value(kV), "_")
2780 2780                              else nil
2781 2781                          if (containsElement(kW, kT))
2782 2782                              then throw((kT + " is not newbie (already has referrals)"))
2783 2783                              else {
2784 2784                                  let iT = bb(kT)
2785 2785                                  let iU = getString(iT)
2786 2786                                  if (if (isDefined(iU))
2787 2787                                      then isDefined(addressFromString(value(iU)))
2788 2788                                      else false)
2789 2789                                      then throw(((kT + " already has refBy: ") + value(iU)))
2790 2790                                      else {
2791 2791                                          let kX = be(kS)
2792 2792                                          let kY = getString(kX)
2793 2793                                          let kZ = if (isDefined(kY))
2794 2794                                              then split_4C(value(kY), "_")
2795 2795                                              else nil
2796 2796                                          if (containsElement(kZ, kT))
2797 2797                                              then throw((((kS + " already contains ") + kT) + " within referrals"))
2798 2798                                              else {
2799 2799                                                  let la = makeString_2C((kZ :+ kT), "_")
2800 2800                                                  let lb = if (containsElement(kW, kS))
2801 2801                                                      then value(kV)
2802 2802                                                      else makeString_2C((kW :+ kS), "_")
2803 2803                                                  $Tuple2([StringEntry(iT, kS), StringEntry(kX, la), StringEntry(kU, lb), jK], 0)
2804 2804                                                  }
2805 2805                                          }
2806 2806                                  }
2807 2807                          }
2808 2808          }
2809 2809  
2810 2810  
2811 2811  
2812 2812  @Callable(fo)
2813 2813  func distributePoints (lc,ld,le,lf,lg) = {
2814 2814      let jK = jH(fo)
2815 2815      if ((size(fo.payments) != 0))
2816 2816          then throw("No payments required")
2817 2817          else {
2818 2818              let b = toString(fo.originCaller)
2819 2819              let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
2820 2820              let lh = A(b)
2821 2821              let li = valueOrElse(getInteger(Z, lh), 0)
2822 2822              let lj = w(s)
2823 2823              let lk = valueOrElse(getInteger(Z, lj), 0)
2824 2824              let ll = (li + lk)
2825 2825              let lm = ((((lc + ld) + le) + lf) + lg)
2826 2826              if ((lm > ll))
2827 2827                  then throw((("There are only " + toString(ll)) + " free points to distribute"))
2828 2828                  else {
2829 2829                      let ln = t(s)
2830 2830                      let ab = split(valueOrElse(getString(Z, ln), "0_0_0_0_0"), "_")
2831 2831                      let lo = (li - lm)
2832 2832                      $Tuple2([IntegerEntry(lh, if ((0 > lo))
2833 2833                          then 0
2834 2834                          else lo), IntegerEntry(lj, if ((0 > lo))
2835 2835                          then (lk + lo)
2836 2836                          else lk), StringEntry(ln, makeString([toString((parseIntValue(ab[h]) + lc)), toString((parseIntValue(ab[i]) + ld)), toString((parseIntValue(ab[j]) + le)), toString((parseIntValue(ab[k]) + lf)), toString((parseIntValue(ab[l]) + lg))], "_")), jK], 0)
2837 2837                      }
2838 2838              }
2839 2839      }
2840 2840  
2841 2841  
2842 2842  
2843 2843  @Callable(fo)
2844 2844  func splitByGlobalWeightsREADONLY (du) = $Tuple2(nil, dM(du))
2845 2845  
2846 2846  
2847 2847  
2848 2848  @Callable(fo)
2849 2849  func splitByGlobalAndLocalWeightsREADONLY (lp,lq,fr) = {
2850 2850      let fk = fq(fr)
2851 2851      $Tuple2(nil, $Tuple2(dM(lp), dx(lq, fk)))
2852 2852      }
2853 2853  
2854 2854  
2855 2855  
2856 2856  @Callable(fo)
2857 2857  func getBackpackREADONLY (s) = $Tuple2(nil, makeString(gq(bh(s)), ":"))
2858 2858  
2859 2859  
2860 2860  
2861 2861  @Callable(fo)
2862 2862  func getWarehouseREADONLY (aX) = {
2863 2863      let ig = value(assetInfo(fromBase58String(aX)))
2864 2864      let gF = (cH(split(ig.description, "_")[cs]) / bR)
2865 2865      let gG = valueOrElse(getInteger(aQ(aX)), 0)
2866 2866      $Tuple2(nil, makeString_2C(gD(aW(aX), gF, gG), ":"))
2867 2867      }
2868 2868  
2869 2869  
2870 2870  
2871 2871  @Callable(fo)
2872 2872  func saveLastTx () = {
2873 2873      let hp = fo.caller
2874 2874      if (if (if ((hp != cp))
2875 2875          then (hp != cn)
2876 2876          else false)
2877 2877          then (hp != cq)
2878 2878          else false)
2879 2879          then throw("Access denied")
2880 2880          else $Tuple2([jH(fo)], 42)
2881 2881      }
2882 2882  
2883 2883  
2884 2884  
2885 2885  @Callable(fo)
2886 2886  func updateDuckStats (s,iM) = if ((fo.caller != cn))
2887 2887      then throw("Access denied")
2888 2888      else iL(s, iM)
2889 2889  
2890 2890  
2891 2891  
2892 2892  @Callable(fo)
2893 2893  func updateAccStats (b,iM) = if ((fo.caller != cn))
2894 2894      then throw("Access denied")
2895 2895      else iR(b, iM)
2896 2896  
2897 2897  
2898 2898  
2899 2899  @Callable(fo)
2900 2900  func equipDuck (lr) = {
2901 2901      let jK = jH(fo)
2902 2902      if ((size(fo.payments) != 0))
2903 2903          then throw("No payments required")
2904 2904          else {
2905 2905              let b = toString(fo.originCaller)
2906 2906              let s = valueOrErrorMessage(getString(bg(b)), "You don't have a duck staked")
2907 2907              if (jb(s))
2908 2908                  then throw("equipDuck_checkTournament")
2909 2909                  else {
2910 2910                      let hQ = x(s)
2911 2911                      let ls = split(valueOrElse(getString(hQ), ",;,_,;,_,;,_,;,_,;,_,;,"), "_")
2912 2912                      let gr = bh(s)
2913 2913                      let gU = gq(gr)
2914 2914                      let hS = split(lr, "_")
2915 2915                      if ((size(hS) != n))
2916 2916                          then throw("Wrong equipment string")
2917 2917                          else {
2918 2918                              let lt = eY(ls, ej(gU[aK]), true, nil)
2919 2919                              let lu = split(hS[m], ";")[1]
2920 2920                              let lv = if ((lu == ""))
2921 2921                                  then 0
2922 2922                                  else {
2923 2923                                      let lw = split(lu, ",")[0]
2924 2924                                      if ((lw == ""))
2925 2925                                          then 0
2926 2926                                          else {
2927 2927                                              let ey = split(lw, ":")
2928 2928                                              let cl = ey[0]
2929 2929                                              let lx = ey[1]
2930 2930                                              if (if (if (if (if ((cl == "06"))
2931 2931                                                  then true
2932 2932                                                  else (cl == "07"))
2933 2933                                                  then true
2934 2934                                                  else (cl == "08"))
2935 2935                                                  then (lx != "")
2936 2936                                                  else false)
2937 2937                                                  then (parseIntValue(lx) > 0)
2938 2938                                                  else false)
2939 2939                                                  then (parseIntValue(cl) - 5)
2940 2940                                                  else 0
2941 2941                                              }
2942 2942                                      }
2943 2943                              let eT = Y(this, s, lv)
2944 2944                              let ly = eY(hS, lt, false, eT)
2945 2945                              let lz = eo(ly)
2946 2946                              $Tuple2([StringEntry(hQ, lr), StringEntry(gr, makeString_2C([gU[aH], gU[aI], gU[aJ], lz], ":")), jK], 0)
2947 2947                              }
2948 2948                      }
2949 2949              }
2950 2950      }
2951 2951  
2952 2952  
2953 2953  
2954 2954  @Callable(fo)
2955 2955  func fortificateLand (aX,lA) = {
2956 2956      let jK = jH(fo)
2957 2957      if ((size(fo.payments) != 0))
2958 2958          then throw("No payments required")
2959 2959          else {
2960 2960              let b = toString(fo.originCaller)
2961 2961              let s = valueOrElse(getString(bg(b)), "")
2962 2962              let et = Y(this, s, 0)
2963 2963              let lB = aY(aX)
2964 2964              let lC = split(valueOrElse(getString(lB), ":0_15:0_18:0"), "_")
2965 2965              let ig = value(assetInfo(fromBase58String(aX)))
2966 2966              let gF = (cH(split(ig.description, "_")[cs]) / bR)
2967 2967              let gG = valueOrElse(getInteger(aQ(aX)), 0)
2968 2968              let gE = aW(aX)
2969 2969              let gJ = gD(gE, gF, gG)
2970 2970              let lD = split(gJ[aC], "_")
2971 2971              let lE = parseIntValue(lD[aE])
2972 2972              let lF = parseIntValue(lD[aF])
2973 2973              let lG = split(lA, "_")
2974 2974              let lH = ff(lC, ej(gJ[aB]), lE, lF, true, nil)
2975 2975              let lt = lH._1
2976 2976              let lI = lH._2
2977 2977              let lJ = lH._3
2978 2978              let lK = ff(lG, lt, lI, lJ, false, et)
2979 2979              let ly = lK._1
2980 2980              let lL = lK._2
2981 2981              let lM = lK._3
2982 2982              let lz = eo(ly)
2983 2983              let iK = makeString([lD[aD], toString(lL), toString(lM), lD[aG]], "_")
2984 2984              $Tuple2([StringEntry(lB, lA), StringEntry(gE, makeString_2C([gJ[ay], gJ[az], gJ[aA], lz, iK], ":")), jK], 0)
2985 2985              }
2986 2986      }
2987 2987  
2988 2988  
2989 2989  
2990 2990  @Callable(fo)
2991 2991  func initDuckTourAttempt (s) = if ((fo.caller != cq))
2992 2992      then throw("Access denied")
2993 2993      else {
2994 2994          let jK = jH(fo)
2995 2995          let hH = r(s)
2996 2996          let hI = Q(valueOrElse(getInteger(v(s)), 0))
2997 2997          let jY = valueOrElse(getInteger(hH), hI)
2998 2998          let lN = bi(s)
2999 2999          let id = valueOrElse(getString(lN), am)
3000 3000          let jc = valueOrElse(getInteger(cq, bn), 0)
3001 3001          let lO = (toString(jc) + "_T_0")
3002 3002          $Tuple2([jK, IntegerEntry(B(s), jY), IntegerEntry(hH, hI), StringEntry(C(s), id), StringEntry(lN, lO)], lO)
3003 3003          }
3004 3004  
3005 3005  
3006 3006  
3007 3007  @Callable(fo)
3008 - func exitTournaments () = {
3008 + func breakAttempt () = {
3009 3009      let jK = jH(fo)
3010 3010      let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
3011 3011      let lN = bi(s)
3012 3012      let id = valueOrElse(getString(lN), am)
3013 3013      if ((split(id, "_")[bB] != "T"))
3014 3014          then throw("Your duck is not in the tournament")
3015 3015          else {
3016 3016              let lP = getIntegerValue(B(s))
3017 3017              let lQ = getStringValue(C(s))
3018 3018              $Tuple2([jK, IntegerEntry(r(s), lP), StringEntry(lN, lQ)], id)
3019 3019              }
3020 3020      }
3021 3021  
3022 3022  
3023 3023  
3024 3024  @Callable(fo)
3025 3025  func exitTournamentInternal (s) = if ((fo.caller != this))
3026 3026      then throw("Access denied")
3027 3027      else {
3028 3028          let lP = getIntegerValue(B(s))
3029 3029          let lQ = getStringValue(C(s))
3030 3030          $Tuple2([IntegerEntry(r(s), lP), StringEntry(bi(s), lQ)], 0)
3031 3031          }
3032 3032  
3033 3033

Old	New		Differences
3005	3005
3006	3006
3007	3007		@Callable(fo)
3008		-	func ~~exitTournaments~~ () = {
	3008	+	func breakAttempt () = {
3009	3009		let jK = jH(fo)
3010	3010		let s = valueOrErrorMessage(getString(bg(toString(fo.caller))), "You don't have a duck staked")
3011	3011		let lN = bi(s)

Old	New	Differences
1	1	{-# STDLIB_VERSION 6 #-}
2	2	{-# SCRIPT_TYPE ACCOUNT #-}
3	3	{-# CONTENT_TYPE DAPP #-}
4	4	func a (b) = ("lastArbTimeUser_" + b)
5	5
6	6
7	7	let c = 100000000
8	8
9	9	let d = 3200
10	10
11	11	let e = 4000
12	12
13	13	let f = 3
14	14
15	15	let g = ["Strength", "Accuracy", "Intellect", "Endurance", "Dexterity", "Level", "Health"]
16	16
17	17	let h = 0
18	18
19	19	let i = 1
20	20
21	21	let j = 2
22	22
23	23	let k = 3
24	24
25	25	let l = 4
26	26
27	27	let m = 0
28	28
29	29	let n = 6
30	30
31	31	let o = 2
32	32
33	33	let p = 2
34	34
35	35	let q = 30
36	36
37	37	func r (s) = ("duckHealth_" + s)
38	38
39	39
40	40	func t (s) = ("duckChars_" + s)
41	41
42	42
43	43	func u (s) = ("duckXP_" + s)
44	44
45	45
46	46	func v (s) = ("duckLevel_" + s)
47	47
48	48
49	49	func w (s) = ("duckFreePoints_" + s)
50	50
51	51
52	52	func x (s) = ("duckEquipment_" + s)
53	53
54	54
55	55	func y (b) = ("userXP_" + b)
56	56
57	57
58	58	func z (b) = ("userLevel_" + b)
59	59
60	60
61	61	func A (b) = ("userFreePoints_" + b)
62	62
63	63
64	64	func B (s) = ("savedHealth_" + s)
65	65
66	66
67	67	func C (s) = ("savedLocation_" + s)
68	68
69	69
70	70	func D (s) = ("duckBuffs_" + s)
71	71
72	72
73	73	let E = 10000
74	74
75	75	let F = 10000
76	76
77	77	let G = 2000
78	78
79	79	let H = 100000
80	80
81	81	let I = 1000000
82	82
83	83	let J = 5000000
84	84
85	85	let K = 10000
86	86
87	87	let L = 1000000
88	88
89	89	let M = 1000000
90	90
91	91	let N = 10000
92	92
93	93	func O (P) = fraction(d, pow(P, 4, e, 4, 4, DOWN), c)
94	94
95	95
96	96	func Q (R) = (100 + R)
97	97
98	98
99	99	func S (T,U) = {
100	100	let V = O(U)
101	101	[V, (f * (V - T))]
102	102	}
103	103
104	104
105	105	func W (R) = if (if ((1 > R))
106	106	then true
107	107	else (R > 3))
108	108	then throw(("Invalid ration level: " + toString(R)))
109	109	else {
110	110	let X = [2, 4, 8]
111	111	X[(R - 1)]
112	112	}
113	113
114	114
115	115	func Y (Z,s,aa) = {
116	116	let ab = split(valueOrElse(getString(Z, t(s)), "0_0_0_0_0"), "_")
117	117	let ac = valueOrElse(getInteger(Z, v(s)), 0)
118	118	let ad = valueOrElse(getInteger(Z, r(s)), Q(ac))
119	119	let X = split(valueOrElse(getString(Z, D(s)), "0_0_0_0_0"), "_")
120	120	[parseIntValue(ab[h]), parseIntValue(ab[i]), parseIntValue(ab[j]), parseIntValue(ab[k]), parseIntValue(ab[l]), ac, ad, if ((aa > 0))
121	121	then W(aa)
122	122	else parseIntValue(X[h]), if ((aa > 0))
123	123	then W(aa)
124	124	else parseIntValue(X[i]), if ((aa > 0))
125	125	then W(aa)
126	126	else parseIntValue(X[j]), if ((aa > 0))
127	127	then W(aa)
128	128	else parseIntValue(X[k]), if ((aa > 0))
129	129	then W(aa)
130	130	else parseIntValue(X[l])]
131	131	}
132	132
133	133
134	134	let ae = "LAND"
135	135
136	136	let af = "DUCK"
137	137
138	138	let ag = "PRESALE"
139	139
140	140	let ah = 6
141	141
142	142	let ai = 25
143	143
144	144	let aj = 3456000
145	145
146	146	let ak = 86400000
147	147
148	148	let al = 10000000000
149	149
150	150	let am = "Africa_F_Africa"
151	151
152	152	let an = 39637
153	153
154	154	let ao = 10
155	155
156	156	let ap = ["First Aid Kit L1", "First Aid Kit L2", "First Aid Kit L3", "Backpack L1", "Backpack L2", "Backpack L3", "Food Ration L1", "Food Ration L2", "Food Ration L3", "Jet Pack L1", "Jet Pack L2", "Jet Pack L3", "Shield L1", "Shield L2", "Shield L3", "Mine L1", "Mine L2", "Mine L3", "Trap L1", "Trap L2", "Trap L3"]
157	157
158	158	let aq = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
159	159
160	160	let ar = 10000000
161	161
162	162	let as = [15, 16, 17, 18, 19, 20]
163	163
164	164	let at = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_011", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_011", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_30_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_50_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_70_0,0,0,0,0,0,0_201", "4_13_22_4_35_22_23_0_50,1,0_0,0,0,0,0,0,0_", "4_13_22_4_35_22_46_0_50,1,1_0,2,5,0,0,0,0_", "4_13_22_4_35_22_69_0_50,2,1_0,5,10,0,0,0,0_", "5_25_40_5_10_15_20_1_30,1,1_0,0,0,0,0,0,0_", "5_25_40_5_10_15_40_1_30,1,2_2,1,3,0,0,0,0_", "5_25_40_5_10_15_60_1_30,1,3_5,2,8,0,0,0,0_"]
165	165
166	166	let au = 6
167	167
168	168	let av = 9
169	169
170	170	let aw = 10
171	171
172	172	let ax = 10
173	173
174	174	let ay = 0
175	175
176	176	let az = 1
177	177
178	178	let aA = 2
179	179
180	180	let aB = 3
181	181
182	182	let aC = 4
183	183
184	184	let aD = 0
185	185
186	186	let aE = 1
187	187
188	188	let aF = 2
189	189
190	190	let aG = 3
191	191
192	192	let aH = 0
193	193
194	194	let aI = 1
195	195
196	196	let aJ = 2
197	197
198	198	let aK = 3
199	199
200	200	func aL (b) = ("lastTxIdByUser_" + b)
201	201
202	202
203	203	func aM (aN) = ("nftOwner_" + aN)
204	204
205	205
206	206	func aO (aN) = ("landCustomNameByAssetId_" + aN)
207	207
208	208
209	209	func aP (aN) = ("stakedTime_" + aN)
210	210
211	211
212	212	func aQ (aN) = ("infraLevel_" + aN)
213	213
214	214
215	215	func aR (aS,aN) = makeString(["landArtStatus", aS, aN], "_")
216	216
217	217
218	218	func aT (aU,aN,aV) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aU) + "_") + aN) + "_") + aV)
219	219
220	220
221	221	func aW (aX) = ("wareHouse_" + aX)
222	222
223	223
224	224	func aY (aX) = ("fortifications_" + aX)
225	225
226	226
227	227	func aZ (aN) = ("duckCustomNameByAssetId_" + aN)
228	228
229	229
230	230	func ba (b) = ("accountCustomNameByAddr_" + b)
231	231
232	232
233	233	func bb (b) = ("accRefBy_" + b)
234	234
235	235
236	236	func bc (s) = ("onboardArtActivatedOnDuck_" + s)
237	237
238	238
239	239	func bd (b) = ("onboardArtActivatedDuckBy_" + b)
240	240
241	241
242	242	func be (b) = ("accReferrals_" + b)
243	243
244	244
245	245	func bf (aN) = ("duckOwner_" + aN)
246	246
247	247
248	248	func bg (aV) = ("stakedDuckByOwner_" + aV)
249	249
250	250
251	251	func bh (s) = ("backPack_" + s)
252	252
253	253
254	254	func bi (s) = ("duckLocation_" + s)
255	255
256	256
257	257	func bj () = "contractsBlocked"
258	258
259	259
260	260	func bk (bl) = ("%s%s__userGwlReleaseTime__" + bl)
261	261
262	262
263	263	func bm () = "emergencyWarehouseProducts"
264	264
265	265
266	266	let bn = "%s__lastTourId"
267	267
268	268	func bo (bp) = ("%s%d__tourStaticData__" + toString(bp))
269	269
270	270
271	271	func bq (bp) = ("%s%d__tourDynamicData__" + toString(bp))
272	272
273	273
274	274	let br = 0
275	275
276	276	let bs = 1
277	277
278	278	func bt (bu,bp) = {
279	279	let bv = split(valueOrErrorMessage(getString(bu, bo(bp)), (("Error reading tournament " + toString(bp)) + " data")), "__")
280	280	let bw = split(valueOrErrorMessage(getString(bu, bq(bp)), (("Error reading tournament " + toString(bp)) + " data")), "__")
281	281	[bv, bw]
282	282	}
283	283
284	284
285	285	let bx = 6
286	286
287	287	let by = 1
288	288
289	289	let bz = 3
290	290
291	291	let bA = 0
292	292
293	293	let bB = 1
294	294
295	295	let bC = 2
296	296
297	297	func bD (bE) = (parseIntValue(bE[au]) * ar)
298	298
299	299
300	300	let bF = true
301	301
302	302	let bG = false
303	303
304	304	let bH = false
305	305
306	306	let bI = take(drop(this.bytes, 1), 1)
307	307
308	308	let bJ = {
309	309	let bK = bI
310	310	if ((base58'2W' == bK))
311	311	then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
312	312	else if ((base58'2T' == bK))
313	313	then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
314	314	else throw("Unknown chain")
315	315	}
316	316
317	317	let bL = {
318	318	let bK = bI
319	319	if ((base58'2W' == bK))
320	320	then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
321	321	else if ((base58'2T' == bK))
322	322	then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
323	323	else throw("Unknown chain")
324	324	}
325	325
326	326	let bM = {
327	327	let bK = bI
328	328	if ((base58'2W' == bK))
329	329	then 10000000000
330	330	else if ((base58'2T' == bK))
331	331	then 100000000
332	332	else throw("Unknown chain")
333	333	}
334	334
335	335	let bN = {
336	336	let bK = bI
337	337	if ((base58'2W' == bK))
338	338	then 86400000
339	339	else if ((base58'2T' == bK))
340	340	then 60000
341	341	else throw("Unknown chain")
342	342	}
343	343
344	344	let bO = "__"
345	345
346	346	let bP = 1000000
347	347
348	348	let bQ = 100000000
349	349
350	350	let bR = 25
351	351
352	352	let bS = 100
353	353
354	354	let bT = 225
355	355
356	356	let bU = 400
357	357
358	358	let bV = 625
359	359
360	360	let bW = [0, 1, 2, 3, 4, 5]
361	361
362	362	func bX (bY,bZ) = valueOrErrorMessage(getString(bY, bZ), makeString(["mandatory ", toString(bY), ".", bZ, " is not defined"], ""))
363	363
364	364
365	365	let ca = 1
366	366
367	367	let cb = 2
368	368
369	369	let cc = 3
370	370
371	371	let cd = 4
372	372
373	373	let ce = 7
374	374
375	375	func cf () = "%s__restConfig"
376	376
377	377
378	378	func cg () = "%s__restAddr"
379	379
380	380
381	381	func ch (ci) = split_4C(bX(ci, cf()), bO)
382	382
383	383
384	384	func cj (ck,cl) = valueOrErrorMessage(addressFromString(ck[cl]), ("Rest cfg doesn't contain address at index " + toString(cl)))
385	385
386	386
387	387	let cm = addressFromStringValue(valueOrElse(getString(this, cg()), bL))
388	388
389	389	let ck = ch(cm)
390	390
391	391	let Z = cj(ck, ca)
392	392
393	393	let cn = cj(ck, cb)
394	394
395	395	let co = cj(ck, cc)
396	396
397	397	let cp = cj(ck, cd)
398	398
399	399	let cq = cj(ck, ce)
400	400
401	401	let cr = 0
402	402
403	403	let cs = 1
404	404
405	405	let ct = 2
406	406
407	407	let cu = 3
408	408
409	409	let cv = 2
410	410
411	411	func cw (bY) = ("finishBlockForAddr_" + bY)
412	412
413	413
414	414	func cx () = "resTypesProportions"
415	415
416	416
417	417	func cy (cz) = ("resTypesByContinent_" + cz)
418	418
419	419
420	420	func cA (aV) = ("stakedLandsByOwner_" + aV)
421	421
422	422
423	423	func cB (aV) = ("stakedPiecesByOwner_" + aV)
424	424
425	425
426	426	func cC (cD) = {
427	427	let bK = cD
428	428	if ($isInstanceOf(bK, "String"))
429	429	then {
430	430	let cE = bK
431	431	cE
432	432	}
433	433	else throw("fail to cast into String")
434	434	}
435	435
436	436
437	437	func cF (cD) = {
438	438	let bK = cD
439	439	if ($isInstanceOf(bK, "Int"))
440	440	then {
441	441	let cG = bK
442	442	cG
443	443	}
444	444	else throw("fail to cast into Int")
445	445	}
446	446
447	447
448	448	func cH (cI) = {
449	449	let bK = cI
450	450	if (("S" == bK))
451	451	then bR
452	452	else if (("M" == bK))
453	453	then bS
454	454	else if (("L" == bK))
455	455	then bT
456	456	else if (("XL" == bK))
457	457	then bU
458	458	else if (("XXL" == bK))
459	459	then bV
460	460	else throw("Unknown land size")
461	461	}
462	462
463	463
464	464	func cJ (cE) = isDefined(parseInt(cE))
465	465
466	466
467	467	let cK = {
468	468	let bK = bI
469	469	if ((base58'2W' == bK))
470	470	then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
471	471	else if ((base58'2T' == bK))
472	472	then this
473	473	else throw("Unknown chain")
474	474	}
475	475
476	476	let cL = {
477	477	let bK = bI
478	478	if ((base58'2W' == bK))
479	479	then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
480	480	else if ((base58'2T' == bK))
481	481	then this
482	482	else throw("Unknown chain")
483	483	}
484	484
485	485	let cM = {
486	486	let bK = bI
487	487	if ((base58'2W' == bK))
488	488	then if (bG)
489	489	then base58'CWsMtTZC5BjjoL4Q1ayW4Wwb1ehGACQB6DrKyPgotKfm'
490	490	else base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
491	491	else if ((base58'2T' == bK))
492	492	then base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
493	493	else throw("Unknown chain")
494	494	}
495	495
496	496	let cN = [30, 60, 120]
497	497
498	498	let cO = 300000
499	499
500	500	let cP = 5000000

github/deemru/w8io/169f3d6 
256.00 ms ◑