tx · FthxRrbD4mpvwvvs5X7nEGjKx6yJXT5EhN1PbvSZLWJm

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.05700000 Waves

2023.05.29 23:38 [2599756] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FthxRrbD4mpvwvvs5X7nEGjKx6yJXT5EhN1PbvSZLWJm",
    "fee": 5700000,
    "feeAssetId": null,
    "timestamp": 1685392675204,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "46M7beq3deJDKyo57ediGkYYmVppNpunECaUgrKMZiErem9Yx6D9Ch2g43umxgCxvf62jykeNQySpHKN56ZKtqc8"
    ],
    "script": "base64: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",
    "height": 2599756,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: H8kdpwVBwfn2jzKHiGFZsUE2XvUkXix3UFxEqhQD4pHy
Next: HhcmQtpDBkhfc4ABTYY5V24h5T9ui3dc6YjDKiUAoTsQ

Diff: 
Old
New
Differences
178
178
 
func ak (al) = ("landToAsset_" + al)
179
179
 
180
180
 
181
-
func am (al,an) = ((i + al) + an)
181
+
func am (an) = ("nftOwner_" + an)
182
182
 
183
183
 
184
-
func ao (ap) = ("nftOwner_" + ap)
184
+
func ao (an) = ("landCustomNameByAssetId_" + an)
185
185
 
186
186
 
187
-
func aq (ap) = ("landCustomNameByAssetId_" + ap)
187
+
func ap (aq) = ("landByCustomName_" + aq)
188
188
 
189
189
 
190
-
func ar (ap) = ("duckCustomNameByAssetId_" + ap)
190
+
func ar (an) = ("stakedTime_" + an)
191
191
 
192
192
 
193
-
func as (ai) = ("accountCustomNameByAddr_" + ai)
193
+
func as (an) = ("infraLevel_" + an)
194
194
 
195
195
 
196
-
func at (au) = ("landByCustomName_" + au)
196
+
func at (an,au) = ((("infraLevelByAssetIdAndOwner_" + an) + "_") + au)
197
197
 
198
198
 
199
-
func av (au) = ("duckByCustomName_" + au)
199
+
func av (an) = ("presaleArtActivated_" + an)
200
200
 
201
201
 
202
-
func aw (au) = ("accountByCustomName_" + au)
202
+
func aw (an,au) = ((("presaleArtActivatedByAssetIdAndOwner_" + an) + "_") + au)
203
203
 
204
204
 
205
-
func ax (ai) = ("accRefBy_" + ai)
205
+
func ax (ay,an) = makeString(["landArtStatus", ay, an], "_")
206
206
 
207
207
 
208
-
func ay (ai) = ("accReferrals_" + ai)
208
+
func az (ay,an,au) = makeString(["landArtStatusByTypeAssetIdAndOwner", ay, an, au], "_")
209
209
 
210
210
 
211
-
func az () = "oldiesList"
211
+
func aA (aB,an,au) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aB) + "_") + an) + "_") + au)
212
212
 
213
213
 
214
-
func aA (ap) = ("duckOwner_" + ap)
214
+
func aC (aD) = ("wareHouse_" + aD)
215
215
 
216
216
 
217
-
func aB (ap) = ("stakedTime_" + ap)
217
+
func aE (al) = ("landOwner_" + al)
218
218
 
219
219
 
220
-
func aC (ap) = ("infraLevel_" + ap)
220
+
func aF (au) = ("stakedLandsByOwner_" + au)
221
221
 
222
222
 
223
-
func aD (ap,aE) = ((("infraLevelByAssetIdAndOwner_" + ap) + "_") + aE)
223
+
func aG (an) = ("duckCustomNameByAssetId_" + an)
224
224
 
225
225
 
226
-
func aF (ap) = ("presaleArtActivated_" + ap)
226
+
func aH (ai) = ("accountCustomNameByAddr_" + ai)
227
227
 
228
228
 
229
-
func aG (ap,aE) = ((("presaleArtActivatedByAssetIdAndOwner_" + ap) + "_") + aE)
229
+
func aI (aq) = ("duckByCustomName_" + aq)
230
230
 
231
231
 
232
-
func aH (aI,ap) = makeString(["landArtStatus", aI, ap], "_")
232
+
func aJ (aq) = ("accountByCustomName_" + aq)
233
233
 
234
234
 
235
-
func aJ (aI,ap,aE) = makeString(["landArtStatusByTypeAssetIdAndOwner", aI, ap, aE], "_")
235
+
func aK (ai) = ("accRefBy_" + ai)
236
236
 
237
237
 
238
-
func aK (aE) = ("stakedDuckByOwner_" + aE)
238
+
func aL (ai) = ("accReferrals_" + ai)
239
239
 
240
240
 
241
-
func aL (aM,ap,aE) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aM) + "_") + ap) + "_") + aE)
241
+
func aM () = "oldiesList"
242
242
 
243
243
 
244
-
func aN (al) = ("landOwner_" + al)
244
+
func aN (an) = ("duckOwner_" + an)
245
245
 
246
246
 
247
-
func aO (aP) = ("backPack_" + aP)
247
+
func aO (au) = ("stakedDuckByOwner_" + au)
248
248
 
249
249
 
250
-
func aQ (aR) = ("wareHouse_" + aR)
250
+
func aP (aQ) = ("backPack_" + aQ)
251
251
 
252
252
 
253
-
func aS (aP) = ("duckLocation_" + aP)
253
+
func aR (aQ) = ("duckLocation_" + aQ)
254
254
 
255
255
 
256
-
func aT (aP) = ("duckHealth_" + aP)
256
+
func aS (aQ) = ("duckHealth_" + aQ)
257
257
 
258
258
 
259
-
func aU () = "resTypesProportions"
259
+
func aT () = "resTypesProportions"
260
260
 
261
261
 
262
-
func aV (aE) = ("stakedLandsByOwner_" + aE)
262
+
func aU () = "contractsBlocked"
263
263
 
264
264
 
265
-
func aW () = "contractsBlocked"
265
+
func aV (aW) = ("%s%s__userGwlReleaseTime__" + aW)
266
266
 
267
267
 
268
-
func aX (aY) = ("%s%s__userGwlReleaseTime__" + aY)
268
+
func aX (aD) = ("landOrder_" + aD)
269
269
 
270
270
 
271
-
let aZ = 0
271
+
let aY = 0
272
272
 
273
-
let ba = 1
273
+
let aZ = 1
274
274
 
275
-
let bb = 2
275
+
let ba = 2
276
276
 
277
-
let bc = 3
277
+
let bb = 3
278
278
 
279
-
let bd = 0
279
+
let bc = 0
280
280
 
281
-
let be = 1
281
+
let bd = 1
282
282
 
283
-
let bf = 2
283
+
let be = 2
284
284
 
285
-
let bg = 0
285
+
let bf = 0
286
286
 
287
-
let bh = 1
287
+
let bg = 1
288
288
 
289
-
let bi = 2
289
+
let bh = 2
290
290
 
291
-
let bj = 3
291
+
let bi = 3
292
292
 
293
-
let bk = 0
293
+
let bj = 0
294
294
 
295
-
let bl = 1
295
+
let bk = 1
296
296
 
297
-
let bm = 2
297
+
let bl = 2
298
298
 
299
-
let bn = 3
299
+
let bm = 3
300
300
 
301
-
let bo = 4
301
+
let bn = 4
302
302
 
303
-
let bp = 0
303
+
let bo = 0
304
304
 
305
-
let bq = 1
305
+
let bp = 1
306
306
 
307
-
let br = 2
307
+
let bq = 2
308
308
 
309
-
let bs = 3
309
+
let br = 3
310
310
 
311
-
let bt = 0
311
+
let bs = 0
312
312
 
313
-
let bu = 1
313
+
let bt = 1
314
314
 
315
-
let bv = 2
315
+
let bu = 2
316
316
 
317
-
let bw = 0
317
+
let bv = 0
318
318
 
319
-
let bx = 1
319
+
let bw = 1
320
320
 
321
-
let by = 2
321
+
let bx = 2
322
322
 
323
-
let bz = 3
323
+
let by = 3
324
324
 
325
-
let bA = 4
325
+
let bz = 4
326
326
 
327
-
let bB = 5
327
+
let bA = 5
328
328
 
329
-
let bC = 6
329
+
let bB = 6
330
330
 
331
-
let bD = [10, 10, 10, 100, 100, 100, 10, 10, 10, 100, 100, 100, 10, 10, 10]
331
+
let bC = [10, 10, 10, 100, 100, 100, 10, 10, 10, 100, 100, 100, 10, 10, 10]
332
332
 
333
-
func bE (bF) = {
334
-
    let c = bF
333
+
func bD (al,bE) = ((i + al) + bE)
334
+
335
+
336
+
func bF (bG) = {
337
+
    let c = bG
335
338
 
    if ($isInstanceOf(c, "String"))
336
339
 
        then {
337
-
            let bG = c
338
-
            bG
340
+
            let bH = c
341
+
            bH
339
342
 
            }
340
343
 
        else throw("fail to cast into String")
341
344
 
    }
342
345
 
343
346
 
344
-
func bH (bF) = {
345
-
    let c = bF
347
+
func bI (bG) = {
348
+
    let c = bG
346
349
 
    if ($isInstanceOf(c, "Int"))
347
350
 
        then {
348
-
            let bI = c
349
-
            bI
351
+
            let bJ = c
352
+
            bJ
350
353
 
            }
351
354
 
        else throw("fail to cast into Int")
352
355
 
    }
353
356
 
354
357
 
355
-
func bJ (bK,bL) = {
356
-
    let bM = (((((bL[0] + bL[1]) + bL[2]) + bL[3]) + bL[4]) + bL[5])
357
-
    if ((0 >= bM))
358
+
func bK (bL,bM) = {
359
+
    let bN = (((((bM[0] + bM[1]) + bM[2]) + bM[3]) + bM[4]) + bM[5])
360
+
    if ((0 >= bN))
358
361
 
        then throw("Zero weights sum")
359
362
 
        else {
360
-
            let bN = fraction(bK, D, bM)
361
-
            func bO (bP,bQ) =             (bP :+ fraction(bQ, bN, D))
363
+
            let bO = fraction(bL, D, bN)
364
+
            func bP (bQ,bR) =             (bQ :+ fraction(bR, bO, D))
362
365
 
363
-
            let bR = bL
364
-
            let bS = size(bR)
365
-
            let bT = nil
366
-
            func bU (bV,bW) =             if ((bW >= bS))
367
-
                then bV
368
-
                else bO(bV, bR[bW])
366
+
            let bS = bM
367
+
            let bT = size(bS)
368
+
            let bU = nil
369
+
            func bV (bW,bX) =             if ((bX >= bT))
370
+
                then bW
371
+
                else bP(bW, bS[bX])
369
372
 
370
-
            func bX (bV,bW) =             if ((bW >= bS))
371
-
                then bV
373
+
            func bY (bW,bX) =             if ((bX >= bT))
374
+
                then bW
372
375
 
                else throw("List size exceeds 6")
373
376
 
374
-
            bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
377
+
            bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
375
378
 
            }
376
379
 
    }
377
380
 
378
381
 
379
-
func bY (bK) = {
380
-
    let bZ = split(value(getString(aU())), "_")
381
-
    if ((size(bZ) != l))
382
+
func bZ (bL) = {
383
+
    let ca = split(value(getString(aT())), "_")
384
+
    if ((size(ca) != l))
382
385
 
        then throw("Wrong proportions data")
383
386
 
        else {
384
-
            let ca = [parseIntValue(bZ[0]), parseIntValue(bZ[1]), parseIntValue(bZ[2]), parseIntValue(bZ[3]), parseIntValue(bZ[4]), parseIntValue(bZ[5])]
385
-
            bJ(bK, ca)
387
+
            let cb = [parseIntValue(ca[0]), parseIntValue(ca[1]), parseIntValue(ca[2]), parseIntValue(ca[3]), parseIntValue(ca[4]), parseIntValue(ca[5])]
388
+
            bK(bL, cb)
386
389
 
            }
387
390
 
    }
388
391
 
389
392
 
390
-
func cb (cc,cd,ce) = {
391
-
    let cf = bY(ce)
392
-
    func cg (bP,ad) =     {
393
-
        let ch = (parseIntValue(cd[ad]) - cf[ad])
394
-
        if ((0 > ch))
395
-
            then throw(((((("Not enough material idx=" + toString(ad)) + ", you have ") + cd[ad]) + ", but need ") + toString(cf[ad])))
396
-
            else (bP :+ toString(ch))
393
+
func cc (cd,ce,cf) = {
394
+
    let cg = bZ(cf)
395
+
    func ch (bQ,ad) =     {
396
+
        let ci = (parseIntValue(ce[ad]) - cg[ad])
397
+
        if ((0 > ci))
398
+
            then throw(((((("Not enough material idx=" + toString(ad)) + ", you have ") + ce[ad]) + ", but need ") + toString(cg[ad])))
399
+
            else (bQ :+ toString(ci))
397
400
 
        }
398
401
 
399
-
    if (cc)
402
+
    if (cd)
400
403
 
        then {
401
-
            let bR = [0, 1, 2, 3, 4, 5]
402
-
            let bS = size(bR)
403
-
            let bT = nil
404
-
            func bU (bV,bW) =             if ((bW >= bS))
405
-
                then bV
406
-
                else cg(bV, bR[bW])
404
+
            let bS = [0, 1, 2, 3, 4, 5]
405
+
            let bT = size(bS)
406
+
            let bU = nil
407
+
            func bV (bW,bX) =             if ((bX >= bT))
408
+
                then bW
409
+
                else ch(bW, bS[bX])
407
410
 
408
-
            func bX (bV,bW) =             if ((bW >= bS))
409
-
                then bV
411
+
            func bY (bW,bX) =             if ((bX >= bT))
412
+
                then bW
410
413
 
                else throw("List size exceeds 6")
411
414
 
412
-
            bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
415
+
            bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
413
416
 
            }
414
-
        else cd
417
+
        else ce
415
418
 
    }
416
419
 
417
420
 
418
-
func ci (cj,ck,cl,cm) = if ((size(cj) != l))
421
+
func cj (ck,cl,cm,cn) = if ((size(ck) != l))
419
422
 
    then throw("Wrong proportions data")
420
423
 
    else {
421
-
        func cn (bP,co) =         {
422
-
            let ch = (parseIntValue(cj[co]) + ((cm * ck[co]) * cl))
423
-
            if ((0 > ch))
424
-
                then throw(((((((("Panic! Pieces of type=" + toString(co)) + ", sign=") + toString(cm)) + ",  terrainCounts[i]=") + toString(ck[co])) + ", landSizeIndex=") + toString(cl)))
425
-
                else (bP :+ toString(ch))
424
+
        func co (bQ,cp) =         {
425
+
            let ci = (parseIntValue(ck[cp]) + ((cn * cl[cp]) * cm))
426
+
            if ((0 > ci))
427
+
                then throw(((((((("Panic! Pieces of type=" + toString(cp)) + ", sign=") + toString(cn)) + ",  terrainCounts[i]=") + toString(cl[cp])) + ", landSizeIndex=") + toString(cm)))
428
+
                else (bQ :+ toString(ci))
426
429
 
            }
427
430
 
428
-
        let ca = {
429
-
            let bR = [0, 1, 2, 3, 4, 5]
430
-
            let bS = size(bR)
431
-
            let bT = nil
432
-
            func bU (bV,bW) =             if ((bW >= bS))
433
-
                then bV
434
-
                else cn(bV, bR[bW])
431
+
        let cb = {
432
+
            let bS = [0, 1, 2, 3, 4, 5]
433
+
            let bT = size(bS)
434
+
            let bU = nil
435
+
            func bV (bW,bX) =             if ((bX >= bT))
436
+
                then bW
437
+
                else co(bW, bS[bX])
435
438
 
436
-
            func bX (bV,bW) =             if ((bW >= bS))
437
-
                then bV
439
+
            func bY (bW,bX) =             if ((bX >= bT))
440
+
                then bW
438
441
 
                else throw("List size exceeds 6")
439
442
 
440
-
            bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
443
+
            bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
441
444
 
            }
442
-
        makeString(ca, "_")
445
+
        makeString(cb, "_")
443
446
 
        }
444
447
 
445
448
 
446
-
func cp (ck,cl,cm) = {
447
-
    let cj = split(valueOrElse(getString(aU()), "0_0_0_0_0_0"), "_")
448
-
    ci(cj, ck, cl, cm)
449
+
func cq (cl,cm,cn) = {
450
+
    let ck = split(valueOrElse(getString(aT()), "0_0_0_0_0_0"), "_")
451
+
    cj(ck, cl, cm, cn)
449
452
 
    }
450
453
 
451
454
 
452
-
func cq (cr) = [(size(split(cr, "A")) - 1), (size(split(cr, "B")) - 1), (size(split(cr, "C")) - 1), (size(split(cr, "D")) - 1), (size(split(cr, "E")) - 1), (size(split(cr, "F")) - 1)]
455
+
func cr (cs) = [(size(split(cs, "A")) - 1), (size(split(cs, "B")) - 1), (size(split(cs, "C")) - 1), (size(split(cs, "D")) - 1), (size(split(cs, "E")) - 1), (size(split(cs, "F")) - 1)]
453
456
 
454
457
 
455
-
func cs (an) = {
456
-
    let c = an
458
+
func ct (bE) = {
459
+
    let c = bE
457
460
 
    if (("S" == c))
458
461
 
        then m
459
462
 
        else if (("M" == c))
468
471
 
    }
469
472
 
470
473
 
471
-
func ct (cu,ad,cv) = {
472
-
    func cw (bP,co) =     (bP :+ (if ((co == ad))
473
-
        then toString((parseIntValue(cu[co]) - cv))
474
-
        else cu[co]))
474
+
func cu (cv,ad,cw) = {
475
+
    func cx (bQ,cp) =     (bQ :+ (if ((cp == ad))
476
+
        then toString((parseIntValue(cv[cp]) - cw))
477
+
        else cv[cp]))
475
478
 
476
-
    let ca = {
477
-
        let bR = [0, 1, 2, 3, 4, 5]
478
-
        let bS = size(bR)
479
-
        let bT = nil
480
-
        func bU (bV,bW) =         if ((bW >= bS))
481
-
            then bV
482
-
            else cw(bV, bR[bW])
479
+
    let cb = {
480
+
        let bS = [0, 1, 2, 3, 4, 5]
481
+
        let bT = size(bS)
482
+
        let bU = nil
483
+
        func bV (bW,bX) =         if ((bX >= bT))
484
+
            then bW
485
+
            else cx(bW, bS[bX])
483
486
 
484
-
        func bX (bV,bW) =         if ((bW >= bS))
485
-
            then bV
487
+
        func bY (bW,bX) =         if ((bX >= bT))
488
+
            then bW
486
489
 
            else throw("List size exceeds 6")
487
490
 
488
-
        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
491
+
        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
489
492
 
        }
490
-
    makeString(ca, "_")
493
+
    makeString(cb, "_")
491
494
 
    }
492
495
 
493
496
 
494
-
func cx (cy,ck,cz,cl,cA) = {
495
-
    func cB (bP,co) =     {
496
-
        let cC = ((fraction(cz, cA, s) * ck[co]) * cl)
497
-
        (bP :+ toString((parseIntValue(cy[co]) + cC)))
497
+
func cy (cz,cl,cA,cm,cB) = {
498
+
    func cC (bQ,cp) =     {
499
+
        let cD = ((fraction(cA, cB, s) * cl[cp]) * cm)
500
+
        (bQ :+ toString((parseIntValue(cz[cp]) + cD)))
498
501
 
        }
499
502
 
500
-
    let ca = {
501
-
        let bR = [0, 1, 2, 3, 4, 5]
502
-
        let bS = size(bR)
503
-
        let bT = nil
504
-
        func bU (bV,bW) =         if ((bW >= bS))
505
-
            then bV
506
-
            else cB(bV, bR[bW])
503
+
    let cb = {
504
+
        let bS = [0, 1, 2, 3, 4, 5]
505
+
        let bT = size(bS)
506
+
        let bU = nil
507
+
        func bV (bW,bX) =         if ((bX >= bT))
508
+
            then bW
509
+
            else cC(bW, bS[bX])
507
510
 
508
-
        func bX (bV,bW) =         if ((bW >= bS))
509
-
            then bV
511
+
        func bY (bW,bX) =         if ((bX >= bT))
512
+
            then bW
510
513
 
            else throw("List size exceeds 6")
511
514
 
512
-
        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
515
+
        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
513
516
 
        }
514
-
    makeString(ca, "_")
517
+
    makeString(cb, "_")
515
518
 
    }
516
519
 
517
520
 
518
-
func cD (ck,cz,cl,cA) = {
519
-
    func cB (bP,co) =     {
520
-
        let cC = ((fraction(cz, cA, s) * ck[co]) * cl)
521
-
        $Tuple2((bP._1 :+ cC), (bP._2 + cC))
521
+
func cE (cl,cA,cm,cB) = {
522
+
    func cC (bQ,cp) =     {
523
+
        let cD = ((fraction(cA, cB, s) * cl[cp]) * cm)
524
+
        $Tuple2((bQ._1 :+ cD), (bQ._2 + cD))
522
525
 
        }
523
526
 
524
-
    let bR = [0, 1, 2, 3, 4, 5]
525
-
    let bS = size(bR)
526
-
    let bT = $Tuple2(nil, 0)
527
-
    func bU (bV,bW) =     if ((bW >= bS))
528
-
        then bV
529
-
        else cB(bV, bR[bW])
527
+
    let bS = [0, 1, 2, 3, 4, 5]
528
+
    let bT = size(bS)
529
+
    let bU = $Tuple2(nil, 0)
530
+
    func bV (bW,bX) =     if ((bX >= bT))
531
+
        then bW
532
+
        else cC(bW, bS[bX])
530
533
 
531
-
    func bX (bV,bW) =     if ((bW >= bS))
532
-
        then bV
534
+
    func bY (bW,bX) =     if ((bX >= bT))
535
+
        then bW
533
536
 
        else throw("List size exceeds 6")
534
537
 
535
-
    bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
538
+
    bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
536
539
 
    }
537
540
 
538
541
 
539
-
func cE (cF,cG,cH,cI) = {
540
-
    let cJ = cH._1
541
-
    let cK = cH._2
542
-
    if ((cK == 0))
543
-
        then $Tuple2(makeString(cF, "_"), makeString(cG, "_"))
544
-
        else if ((cI >= cK))
542
+
func cF (cG,cH,cI,cJ) = {
543
+
    let cK = cI._1
544
+
    let cL = cI._2
545
+
    if ((cL == 0))
546
+
        then $Tuple2(makeString(cG, "_"), makeString(cH, "_"))
547
+
        else if ((cJ >= cL))
545
548
 
            then {
546
-
                func cL (bP,co) =                 (bP :+ toString((parseIntValue(cF[co]) + cJ[co])))
549
+
                func cM (bQ,cp) =                 (bQ :+ toString((parseIntValue(cG[cp]) + cK[cp])))
547
550
 
548
-
                let ca = {
549
-
                    let bR = [0, 1, 2, 3, 4, 5]
550
-
                    let bS = size(bR)
551
-
                    let bT = nil
552
-
                    func bU (bV,bW) =                     if ((bW >= bS))
553
-
                        then bV
554
-
                        else cL(bV, bR[bW])
551
+
                let cb = {
552
+
                    let bS = [0, 1, 2, 3, 4, 5]
553
+
                    let bT = size(bS)
554
+
                    let bU = nil
555
+
                    func bV (bW,bX) =                     if ((bX >= bT))
556
+
                        then bW
557
+
                        else cM(bW, bS[bX])
555
558
 
556
-
                    func bX (bV,bW) =                     if ((bW >= bS))
557
-
                        then bV
559
+
                    func bY (bW,bX) =                     if ((bX >= bT))
560
+
                        then bW
558
561
 
                        else throw("List size exceeds 6")
559
562
 
560
-
                    bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
563
+
                    bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
561
564
 
                    }
562
-
                $Tuple2(makeString(ca, "_"), makeString(cG, "_"))
565
+
                $Tuple2(makeString(cb, "_"), makeString(cH, "_"))
563
566
 
                }
564
567
 
            else {
565
-
                func cM (bP,co) =                 {
566
-
                    let cN = fraction(cJ[co], cI, cK)
567
-
                    $Tuple2((bP._1 :+ toString((parseIntValue(cF[co]) + cN))), (bP._2 :+ toString(((parseIntValue(cG[co]) + cJ[co]) - cN))))
568
+
                func cN (bQ,cp) =                 {
569
+
                    let cO = fraction(cK[cp], cJ, cL)
570
+
                    $Tuple2((bQ._1 :+ toString((parseIntValue(cG[cp]) + cO))), (bQ._2 :+ toString(((parseIntValue(cH[cp]) + cK[cp]) - cO))))
568
571
 
                    }
569
572
 
570
-
                let ca = {
571
-
                    let bR = [0, 1, 2, 3, 4, 5]
572
-
                    let bS = size(bR)
573
-
                    let bT = $Tuple2(nil, nil)
574
-
                    func bU (bV,bW) =                     if ((bW >= bS))
575
-
                        then bV
576
-
                        else cM(bV, bR[bW])
573
+
                let cb = {
574
+
                    let bS = [0, 1, 2, 3, 4, 5]
575
+
                    let bT = size(bS)
576
+
                    let bU = $Tuple2(nil, nil)
577
+
                    func bV (bW,bX) =                     if ((bX >= bT))
578
+
                        then bW
579
+
                        else cN(bW, bS[bX])
577
580
 
578
-
                    func bX (bV,bW) =                     if ((bW >= bS))
579
-
                        then bV
581
+
                    func bY (bW,bX) =                     if ((bX >= bT))
582
+
                        then bW
580
583
 
                        else throw("List size exceeds 6")
581
584
 
582
-
                    bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
585
+
                    bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
583
586
 
                    }
584
-
                $Tuple2(makeString(ca._1, "_"), makeString(ca._2, "_"))
587
+
                $Tuple2(makeString(cb._1, "_"), makeString(cb._2, "_"))
585
588
 
                }
586
589
 
    }
587
590
 
588
591
 
589
-
func cO (cP) = if ((cP >= toBigInt(0)))
590
-
    then cP
591
-
    else -(cP)
592
+
func cP (cQ) = if ((cQ >= toBigInt(0)))
593
+
    then cQ
594
+
    else -(cQ)
592
595
 
593
596
 
594
-
let cQ = [[1, 4, 9, 10, 15], [5, 8, 13, 14, 15], [6, 9, 14, 15, 16], [4, 7, 8, 13, 18], [1, 6, 7, 15, 19]]
597
+
let cR = [[1, 4, 9, 10, 15], [5, 8, 13, 14, 15], [6, 9, 14, 15, 16], [4, 7, 8, 13, 18], [1, 6, 7, 15, 19]]
595
598
 
596
-
func cR (bI,cS) = {
597
-
    let cT = toInt((bI % G))
598
-
    let cU = if ((cS[0] > cT))
599
+
func cS (bJ,cT) = {
600
+
    let cU = toInt((bJ % G))
601
+
    let cV = if ((cT[0] > cU))
599
602
 
        then "A"
600
-
        else if ((cS[1] > cT))
603
+
        else if ((cT[1] > cU))
601
604
 
            then "B"
602
-
            else if ((cS[2] > cT))
605
+
            else if ((cT[2] > cU))
603
606
 
                then "C"
604
-
                else if ((cS[3] > cT))
607
+
                else if ((cT[3] > cU))
605
608
 
                    then "D"
606
-
                    else if ((cS[4] > cT))
609
+
                    else if ((cT[4] > cU))
607
610
 
                        then "E"
608
611
 
                        else "F"
609
-
    cU
612
+
    cV
610
613
 
    }
611
614
 
612
615
 
613
-
func cV (cW,cX) = {
614
-
    let cY = cQ[cX]
615
-
    func cZ (bP,bQ) =     $Tuple2((((((bP._1 + cR(bP._2, cY)) + cR((bP._2 / G), cY)) + cR((bP._2 / H), cY)) + cR((bP._2 / I), cY)) + cR((bP._2 / J), cY)), (bP._2 / K))
616
+
func cW (cX,cY) = {
617
+
    let cZ = cR[cY]
618
+
    func da (bQ,bR) =     $Tuple2((((((bQ._1 + cS(bQ._2, cZ)) + cS((bQ._2 / G), cZ)) + cS((bQ._2 / H), cZ)) + cS((bQ._2 / I), cZ)) + cS((bQ._2 / J), cZ)), (bQ._2 / K))
616
619
 
617
-
    let da = {
618
-
        let bR = [1, 2, 3, 4, 5]
619
-
        let bS = size(bR)
620
-
        let bT = $Tuple2("", (cW / F))
621
-
        func bU (bV,bW) =         if ((bW >= bS))
622
-
            then bV
623
-
            else cZ(bV, bR[bW])
620
+
    let db = {
621
+
        let bS = [1, 2, 3, 4, 5]
622
+
        let bT = size(bS)
623
+
        let bU = $Tuple2("", (cX / F))
624
+
        func bV (bW,bX) =         if ((bX >= bT))
625
+
            then bW
626
+
            else da(bW, bS[bX])
624
627
 
625
-
        func bX (bV,bW) =         if ((bW >= bS))
626
-
            then bV
628
+
        func bY (bW,bX) =         if ((bX >= bT))
629
+
            then bW
627
630
 
            else throw("List size exceeds 5")
628
631
 
629
-
        bX(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5)
632
+
        bY(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5)
630
633
 
        }
631
-
    da._1
634
+
    db._1
632
635
 
    }
633
636
 
634
637
 
635
-
func db (dc) = {
636
-
    let dd = split(valueOrElse(getString(dc), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
637
-
[toString(valueOrElse(parseInt(dd[bg]), 0)), if ((size(split(dd[bh], "_")) == l))
638
-
        then dd[bh]
639
-
        else "0_0_0_0_0_0", if ((size(split(dd[bi], "_")) == l))
640
-
        then dd[bi]
641
-
        else "0_0_0_0_0_0", dd[bj]]
638
+
func dc (dd) = {
639
+
    let de = split(valueOrElse(getString(dd), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
640
+
[toString(valueOrElse(parseInt(de[bf]), 0)), if ((size(split(de[bg], "_")) == l))
641
+
        then de[bg]
642
+
        else "0_0_0_0_0_0", if ((size(split(de[bh], "_")) == l))
643
+
        then de[bh]
644
+
        else "0_0_0_0_0_0", de[bi]]
642
645
 
    }
643
646
 
644
647
 
645
-
func de (df) = {
646
-
    let dg = split(df, "_")
647
-
    ((v * (parseIntValue(dg[1]) + 1)) * parseIntValue(dg[0]))
648
+
func df (dg) = {
649
+
    let dh = split(dg, "_")
650
+
    ((v * (parseIntValue(dh[1]) + 1)) * parseIntValue(dh[0]))
648
651
 
    }
649
652
 
650
653
 
651
-
func dh (di) = {
652
-
    let dj = di[bn]
653
-
    func dk (bP,dl) =     (bP + parseIntValue(dl))
654
+
func di (dj) = {
655
+
    let dk = dj[bm]
656
+
    func dl (bQ,dm) =     (bQ + parseIntValue(dm))
654
657
 
655
-
    func dm (bP,dl) =     {
656
-
        let ad = bP._1
657
-
        let dn = bD[ad]
658
-
        let do = (((parseIntValue(dl) + dn) - 1) / dn)
659
-
        $Tuple2((ad + 1), (bP._2 + (do * E)))
658
+
    func dn (bQ,dm) =     {
659
+
        let ad = bQ._1
660
+
        let do = bC[ad]
661
+
        let dp = (((parseIntValue(dm) + do) - 1) / do)
662
+
        $Tuple2((ad + 1), (bQ._2 + (dp * E)))
660
663
 
        }
661
664
 
662
-
    let dp = {
663
-
        let bR = split(di[bl], "_")
664
-
        let bS = size(bR)
665
-
        let bT = 0
666
-
        func bU (bV,bW) =         if ((bW >= bS))
667
-
            then bV
668
-
            else dk(bV, bR[bW])
665
+
    let dq = {
666
+
        let bS = split(dj[bk], "_")
667
+
        let bT = size(bS)
668
+
        let bU = 0
669
+
        func bV (bW,bX) =         if ((bX >= bT))
670
+
            then bW
671
+
            else dl(bW, bS[bX])
669
672
 
670
-
        func bX (bV,bW) =         if ((bW >= bS))
671
-
            then bV
673
+
        func bY (bW,bX) =         if ((bX >= bT))
674
+
            then bW
672
675
 
            else throw("List size exceeds 6")
673
676
 
674
-
        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
677
+
        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
675
678
 
        }
676
-
    let dq = {
677
-
        let bR = split(di[bm], "_")
678
-
        let bS = size(bR)
679
-
        let bT = 0
680
-
        func dr (bV,bW) =         if ((bW >= bS))
681
-
            then bV
682
-
            else dk(bV, bR[bW])
679
+
    let dr = {
680
+
        let bS = split(dj[bl], "_")
681
+
        let bT = size(bS)
682
+
        let bU = 0
683
+
        func ds (bW,bX) =         if ((bX >= bT))
684
+
            then bW
685
+
            else dl(bW, bS[bX])
683
686
 
684
-
        func ds (bV,bW) =         if ((bW >= bS))
685
-
            then bV
687
+
        func dt (bW,bX) =         if ((bX >= bT))
688
+
            then bW
686
689
 
            else throw("List size exceeds 6")
687
690
 
688
-
        ds(dr(dr(dr(dr(dr(dr(bT, 0), 1), 2), 3), 4), 5), 6)
691
+
        dt(ds(ds(ds(ds(ds(ds(bU, 0), 1), 2), 3), 4), 5), 6)
689
692
 
        }
690
-
    let dt = if ((dj == ""))
693
+
    let du = if ((dk == ""))
691
694
 
        then 0
692
-
        else (        let bR = split_4C(dj, "_")
693
-
        let bS = size(bR)
694
-
        let bT = $Tuple2(0, 0)
695
-
        func du (bV,bW) =         if ((bW >= bS))
696
-
            then bV
697
-
            else dm(bV, bR[bW])
695
+
        else (        let bS = split_4C(dk, "_")
696
+
        let bT = size(bS)
697
+
        let bU = $Tuple2(0, 0)
698
+
        func dv (bW,bX) =         if ((bX >= bT))
699
+
            then bW
700
+
            else dn(bW, bS[bX])
698
701
 
699
-
        func dv (bV,bW) =         if ((bW >= bS))
700
-
            then bV
702
+
        func dw (bW,bX) =         if ((bX >= bT))
703
+
            then bW
701
704
 
            else throw("List size exceeds 50")
702
705
 
703
-
        dv(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(bT, 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
704
-
    ((dp + dq) + dt)
706
+
        dw(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(bU, 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
707
+
    ((dq + dr) + du)
705
708
 
    }
706
709
 
707
710
 
708
-
func dw (dx,dy,dz) = {
709
-
    let df = ((toString(dy) + "_") + toString(dz))
710
-
    let dA = de(df)
711
-
    let dB = valueOrElse(getString(dx), (df + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
712
-
    let dC = split_4C(dB, ":")
713
-
    let dD = dh(dC)
714
-
    let dE = if ((5 > size(dC)))
715
-
        then makeString(["0", toString(dD), toString((dA - dD)), toString(dA)], "_")
711
+
func dx (dy,dz,dA) = {
712
+
    let dg = ((toString(dz) + "_") + toString(dA))
713
+
    let dB = df(dg)
714
+
    let dC = valueOrElse(getString(dy), (dg + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
715
+
    let dD = split_4C(dC, ":")
716
+
    let dE = di(dD)
717
+
    let dF = if ((5 > size(dD)))
718
+
        then makeString(["0", toString(dE), toString((dB - dE)), toString(dB)], "_")
716
719
 
        else {
717
-
            let dF = split(dC[bo], "_")
718
-
            let dG = parseIntValue(dF[bp])
719
-
            let dH = if ((size(dF) > 1))
720
-
                then parseIntValue(dF[bq])
721
-
                else dD
722
-
            makeString([toString(dG), toString(dH), toString(((dA - dG) - dH)), toString(dA)], "_")
720
+
            let dG = split(dD[bn], "_")
721
+
            let dH = parseIntValue(dG[bo])
722
+
            let dI = if ((size(dG) > 1))
723
+
                then parseIntValue(dG[bp])
724
+
                else dE
725
+
            makeString([toString(dH), toString(dI), toString(((dB - dH) - dI)), toString(dB)], "_")
723
726
 
            }
724
-
[dC[bk], if ((size(split(dC[bl], "_")) == l))
725
-
        then dC[bl]
726
-
        else "0_0_0_0_0_0", if ((size(split(dC[bm], "_")) == l))
727
-
        then dC[bm]
728
-
        else "0_0_0_0_0_0", dC[bn], dE]
727
+
[dD[bj], if ((size(split(dD[bk], "_")) == l))
728
+
        then dD[bk]
729
+
        else "0_0_0_0_0_0", if ((size(split(dD[bl], "_")) == l))
730
+
        then dD[bl]
731
+
        else "0_0_0_0_0_0", dD[bm], dF]
729
732
 
    }
730
733
 
731
734
 
732
-
func dI (di) = {
733
-
    let dJ = dh(di)
734
-
    let dK = parseIntValue(split(di[bo], "_")[bp])
735
-
    ((de(di[bk]) - dJ) - dK)
735
+
func dJ (dj) = {
736
+
    let dK = di(dj)
737
+
    let dL = parseIntValue(split(dj[bn], "_")[bo])
738
+
    ((df(dj[bj]) - dK) - dL)
736
739
 
    }
737
740
 
738
741
 
739
-
func dL (cv,dn) = {
740
-
    let do = if ((cv >= 0))
741
-
        then (((cv + dn) - 1) / dn)
742
-
        else -((((-(cv) + dn) - 1) / dn))
743
-
    (do * E)
742
+
func dM (cw,do) = {
743
+
    let dp = if ((cw >= 0))
744
+
        then (((cw + do) - 1) / do)
745
+
        else -((((-(cw) + do) - 1) / do))
746
+
    (dp * E)
744
747
 
    }
745
748
 
746
749
 
747
-
func dM (dN,di,dO) = if ((size(dN) != 3))
750
+
func dN (dO,dj,dP) = if ((size(dO) != 3))
748
751
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
749
752
 
    else {
750
-
        let dP = split(dN[0], "_")
751
-
        let dQ = split(dN[1], "_")
752
-
        let dR = if ((dN[2] == ""))
753
+
        let dQ = split(dO[0], "_")
754
+
        let dR = split(dO[1], "_")
755
+
        let dS = if ((dO[2] == ""))
753
756
 
            then nil
754
-
            else split(dN[2], "_")
755
-
        if ((size(dP) != l))
757
+
            else split(dO[2], "_")
758
+
        if ((size(dQ) != l))
756
759
 
            then throw("All 6 resources should be passed")
757
-
            else if ((size(dQ) != l))
760
+
            else if ((size(dR) != l))
758
761
 
                then throw("All 6 materials should be passed")
759
762
 
                else {
760
-
                    let cI = dI(di)
761
-
                    let dS = split(di[bl], "_")
762
-
                    let dT = split(di[bm], "_")
763
-
                    let dU = if ((di[bn] == ""))
763
+
                    let cJ = dJ(dj)
764
+
                    let dT = split(dj[bk], "_")
765
+
                    let dU = split(dj[bl], "_")
766
+
                    let dV = if ((dj[bm] == ""))
764
767
 
                        then nil
765
-
                        else split(di[bn], "_")
766
-
                    let cG = split(dO[bh], "_")
767
-
                    let dV = split(dO[bi], "_")
768
-
                    let dW = if ((dO[bj] == ""))
768
+
                        else split(dj[bm], "_")
769
+
                    let cH = split(dP[bg], "_")
770
+
                    let dW = split(dP[bh], "_")
771
+
                    let dX = if ((dP[bi] == ""))
769
772
 
                        then nil
770
-
                        else split(dO[bj], "_")
771
-
                    func dX (bP,dl) =                     {
772
-
                        let co = bP._1
773
-
                        let dY = parseIntValue(dl)
774
-
                        let dZ = parseIntValue(dS[co])
775
-
                        let ea = parseIntValue(cG[co])
776
-
                        if ((dY == 0))
777
-
                            then $Tuple4((co + 1), (bP._2 :+ dS[co]), (bP._3 :+ cG[co]), bP._4)
778
-
                            else if ((dY > 0))
779
-
                                then if ((dY > ea))
780
-
                                    then throw((((("Attempt to take " + dl) + " from backpack, but only ") + toString(ea)) + " available"))
781
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((dZ + dY))), (bP._3 :+ toString((ea - dY))), (bP._4 + dY))
782
-
                                else if ((-(dY) > dZ))
783
-
                                    then throw((((("Attempt to take " + toString(-(dY))) + " from warehouse, but only ") + toString(dZ)) + " available"))
784
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((dZ + dY))), (bP._3 :+ toString((ea - dY))), (bP._4 + dY))
773
+
                        else split(dP[bi], "_")
774
+
                    func dY (bQ,dm) =                     {
775
+
                        let cp = bQ._1
776
+
                        let dZ = parseIntValue(dm)
777
+
                        let ea = parseIntValue(dT[cp])
778
+
                        let eb = parseIntValue(cH[cp])
779
+
                        if ((dZ == 0))
780
+
                            then $Tuple4((cp + 1), (bQ._2 :+ dT[cp]), (bQ._3 :+ cH[cp]), bQ._4)
781
+
                            else if ((dZ > 0))
782
+
                                then if ((dZ > eb))
783
+
                                    then throw((((("Attempt to take " + dm) + " from backpack, but only ") + toString(eb)) + " available"))
784
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ea + dZ))), (bQ._3 :+ toString((eb - dZ))), (bQ._4 + dZ))
785
+
                                else if ((-(dZ) > ea))
786
+
                                    then throw((((("Attempt to take " + toString(-(dZ))) + " from warehouse, but only ") + toString(ea)) + " available"))
787
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ea + dZ))), (bQ._3 :+ toString((eb - dZ))), (bQ._4 + dZ))
785
788
 
                        }
786
789
 
787
-
                    let ca = {
788
-
                        let bR = dP
789
-
                        let bS = size(bR)
790
-
                        let bT = $Tuple4(0, nil, nil, 0)
791
-
                        func bU (bV,bW) =                         if ((bW >= bS))
792
-
                            then bV
793
-
                            else dX(bV, bR[bW])
790
+
                    let cb = {
791
+
                        let bS = dQ
792
+
                        let bT = size(bS)
793
+
                        let bU = $Tuple4(0, nil, nil, 0)
794
+
                        func bV (bW,bX) =                         if ((bX >= bT))
795
+
                            then bW
796
+
                            else dY(bW, bS[bX])
794
797
 
795
-
                        func bX (bV,bW) =                         if ((bW >= bS))
796
-
                            then bV
798
+
                        func bY (bW,bX) =                         if ((bX >= bT))
799
+
                            then bW
797
800
 
                            else throw("List size exceeds 6")
798
801
 
799
-
                        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
802
+
                        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
800
803
 
                        }
801
-
                    func eb (bP,dl) =                     {
802
-
                        let co = bP._1
803
-
                        let dY = parseIntValue(dl)
804
-
                        let ec = parseIntValue(dT[co])
805
-
                        let ed = parseIntValue(dV[co])
806
-
                        if ((dY == 0))
807
-
                            then $Tuple4((co + 1), (bP._2 :+ dT[co]), (bP._3 :+ dV[co]), bP._4)
808
-
                            else if ((dY > 0))
809
-
                                then if ((dY > ed))
810
-
                                    then throw((((("Attempt to take " + dl) + " from backpack, but only ") + toString(ed)) + " available"))
811
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((ec + dY))), (bP._3 :+ toString((ed - dY))), (bP._4 + dY))
812
-
                                else if ((-(dY) > ec))
813
-
                                    then throw((((("Attempt to take " + toString(-(dY))) + " from warehouse, but only ") + toString(ec)) + " available"))
814
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((ec + dY))), (bP._3 :+ toString((ed - dY))), (bP._4 + dY))
804
+
                    func ec (bQ,dm) =                     {
805
+
                        let cp = bQ._1
806
+
                        let dZ = parseIntValue(dm)
807
+
                        let ed = parseIntValue(dU[cp])
808
+
                        let ee = parseIntValue(dW[cp])
809
+
                        if ((dZ == 0))
810
+
                            then $Tuple4((cp + 1), (bQ._2 :+ dU[cp]), (bQ._3 :+ dW[cp]), bQ._4)
811
+
                            else if ((dZ > 0))
812
+
                                then if ((dZ > ee))
813
+
                                    then throw((((("Attempt to take " + dm) + " from backpack, but only ") + toString(ee)) + " available"))
814
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ed + dZ))), (bQ._3 :+ toString((ee - dZ))), (bQ._4 + dZ))
815
+
                                else if ((-(dZ) > ed))
816
+
                                    then throw((((("Attempt to take " + toString(-(dZ))) + " from warehouse, but only ") + toString(ed)) + " available"))
817
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ed + dZ))), (bQ._3 :+ toString((ee - dZ))), (bQ._4 + dZ))
815
818
 
                        }
816
819
 
817
-
                    let ee = {
818
-
                        let bR = dQ
819
-
                        let bS = size(bR)
820
-
                        let bT = $Tuple4(0, nil, nil, ca._4)
821
-
                        func dr (bV,bW) =                         if ((bW >= bS))
822
-
                            then bV
823
-
                            else eb(bV, bR[bW])
820
+
                    let ef = {
821
+
                        let bS = dR
822
+
                        let bT = size(bS)
823
+
                        let bU = $Tuple4(0, nil, nil, cb._4)
824
+
                        func ds (bW,bX) =                         if ((bX >= bT))
825
+
                            then bW
826
+
                            else ec(bW, bS[bX])
824
827
 
825
-
                        func ds (bV,bW) =                         if ((bW >= bS))
826
-
                            then bV
828
+
                        func dt (bW,bX) =                         if ((bX >= bT))
829
+
                            then bW
827
830
 
                            else throw("List size exceeds 6")
828
831
 
829
-
                        ds(dr(dr(dr(dr(dr(dr(bT, 0), 1), 2), 3), 4), 5), 6)
832
+
                        dt(ds(ds(ds(ds(ds(ds(bU, 0), 1), 2), 3), 4), 5), 6)
830
833
 
                        }
831
-
                    func ef (bP,dl) =                     {
832
-
                        let co = bP._1
833
-
                        let dn = bD[co]
834
-
                        let dY = parseIntValue(dl)
835
-
                        let eg = if ((size(dU) > co))
836
-
                            then parseIntValue(dU[co])
834
+
                    func eg (bQ,dm) =                     {
835
+
                        let cp = bQ._1
836
+
                        let do = bC[cp]
837
+
                        let dZ = parseIntValue(dm)
838
+
                        let eh = if ((size(dV) > cp))
839
+
                            then parseIntValue(dV[cp])
837
840
 
                            else 0
838
-
                        let eh = if ((size(dW) > co))
839
-
                            then parseIntValue(dW[co])
841
+
                        let ei = if ((size(dX) > cp))
842
+
                            then parseIntValue(dX[cp])
840
843
 
                            else 0
841
-
                        if ((dY == 0))
842
-
                            then $Tuple4((co + 1), (bP._2 :+ toString(eg)), (bP._3 :+ toString(eh)), bP._4)
843
-
                            else if ((dY > 0))
844
-
                                then if ((dY > eh))
845
-
                                    then throw((((("Attempt to take " + dl) + " from backpack, but only ") + toString(eh)) + " available"))
844
+
                        if ((dZ == 0))
845
+
                            then $Tuple4((cp + 1), (bQ._2 :+ toString(eh)), (bQ._3 :+ toString(ei)), bQ._4)
846
+
                            else if ((dZ > 0))
847
+
                                then if ((dZ > ei))
848
+
                                    then throw((((("Attempt to take " + dm) + " from backpack, but only ") + toString(ei)) + " available"))
846
849
 
                                    else {
847
-
                                        let ei = (dL((eg + dY), dn) - dL(eg, dn))
848
-
                                        $Tuple4((co + 1), (bP._2 :+ toString((eg + dY))), (bP._3 :+ toString((eh - dY))), (bP._4 + ei))
850
+
                                        let ej = (dM((eh + dZ), do) - dM(eh, do))
851
+
                                        $Tuple4((cp + 1), (bQ._2 :+ toString((eh + dZ))), (bQ._3 :+ toString((ei - dZ))), (bQ._4 + ej))
849
852
 
                                        }
850
-
                                else if ((-(dY) > eg))
851
-
                                    then throw((((("Attempt to take " + toString(-(dY))) + " from warehouse, but only ") + toString(eg)) + " available"))
853
+
                                else if ((-(dZ) > eh))
854
+
                                    then throw((((("Attempt to take " + toString(-(dZ))) + " from warehouse, but only ") + toString(eh)) + " available"))
852
855
 
                                    else {
853
-
                                        let ei = (dL((eg + dY), dn) - dL(eg, dn))
854
-
                                        $Tuple4((co + 1), (bP._2 :+ toString((eg + dY))), (bP._3 :+ toString((eh - dY))), (bP._4 + ei))
856
+
                                        let ej = (dM((eh + dZ), do) - dM(eh, do))
857
+
                                        $Tuple4((cp + 1), (bQ._2 :+ toString((eh + dZ))), (bQ._3 :+ toString((ei - dZ))), (bQ._4 + ej))
855
858
 
                                        }
856
859
 
                        }
857
860
 
858
-
                    let dd = if ((size(dR) != 0))
861
+
                    let de = if ((size(dS) != 0))
859
862
 
                        then {
860
-
                            let bR = dR
861
-
                            let bS = size(bR)
862
-
                            let bT = $Tuple4(0, nil, nil, ee._4)
863
-
                            func du (bV,bW) =                             if ((bW >= bS))
864
-
                                then bV
865
-
                                else ef(bV, bR[bW])
863
+
                            let bS = dS
864
+
                            let bT = size(bS)
865
+
                            let bU = $Tuple4(0, nil, nil, ef._4)
866
+
                            func dv (bW,bX) =                             if ((bX >= bT))
867
+
                                then bW
868
+
                                else eg(bW, bS[bX])
866
869
 
867
-
                            func dv (bV,bW) =                             if ((bW >= bS))
868
-
                                then bV
870
+
                            func dw (bW,bX) =                             if ((bX >= bT))
871
+
                                then bW
869
872
 
                                else throw("List size exceeds 50")
870
873
 
871
-
                            dv(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(bT, 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)
874
+
                            dw(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(bU, 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)
872
875
 
                            }
873
-
                        else $Tuple4(0, dU, dW, ee._4)
874
-
                    let ej = dd._4
875
-
                    if ((ej > cI))
876
-
                        then throw((((("Attempt to put total " + toString(ej)) + " stuff, but only ") + toString(cI)) + " warehouse space left"))
877
-
                        else $Tuple7(makeString(ca._2, "_"), makeString(ee._2, "_"), makeString(dd._2, "_"), makeString(ca._3, "_"), makeString(ee._3, "_"), makeString(dd._3, "_"), ej)
876
+
                        else $Tuple4(0, dV, dX, ef._4)
877
+
                    let ek = de._4
878
+
                    if ((ek > cJ))
879
+
                        then throw((((("Attempt to put total " + toString(ek)) + " stuff, but only ") + toString(cJ)) + " warehouse space left"))
880
+
                        else $Tuple7(makeString(cb._2, "_"), makeString(ef._2, "_"), makeString(de._2, "_"), makeString(cb._3, "_"), makeString(ef._3, "_"), makeString(de._3, "_"), ek)
878
881
 
                    }
879
882
 
        }
880
883
 
881
884
 
882
-
func ek (el,em) = {
883
-
    let aY = toString(el)
884
-
    let en = cO(toBigInt(em))
885
-
    let eo = valueOrElse(getInteger(aj()), (O + 1))
886
-
    let al = toString(eo)
887
-
    let cX = toInt((en % F))
888
-
    let cr = cV(en, cX)
889
-
    let ep = M[cX]
890
-
    let eq = Issue(am(al, "S"), makeString([al, "S", cr, ep], "_"), 1, 0, false)
891
-
    let ap = calculateAssetId(eq)
892
-
    let er = toBase58String(ap)
893
-
    $Tuple2([IntegerEntry(aj(), (eo + 1)), eq, StringEntry(ak(al), er), StringEntry(ao(er), aY), StringEntry(aN(al), aY), IntegerEntry(aC(er), 0), IntegerEntry(aD(er, aY), 0), ScriptTransfer(el, 1, ap)], $Tuple2(er, ep))
885
+
func el (em,en) = {
886
+
    let aW = toString(em)
887
+
    let eo = cP(toBigInt(en))
888
+
    let ep = valueOrElse(getInteger(aj()), (O + 1))
889
+
    let al = toString(ep)
890
+
    let cY = toInt((eo % F))
891
+
    let cs = cW(eo, cY)
892
+
    let eq = M[cY]
893
+
    let er = Issue(bD(al, "S"), makeString([al, "S", cs, eq], "_"), 1, 0, false)
894
+
    let an = calculateAssetId(er)
895
+
    let es = toBase58String(an)
896
+
    $Tuple2([IntegerEntry(aj(), (ep + 1)), er, StringEntry(ak(al), es), StringEntry(am(es), aW), StringEntry(aE(al), aW), IntegerEntry(as(es), 0), IntegerEntry(at(es, aW), 0), ScriptTransfer(em, 1, an)], $Tuple2(es, eq))
894
897
 
    }
895
898
 
896
899
 
897
-
func es (cc,el,em,et,eu) = if (!(sigVerify_8Kb(et, eu, g)))
900
+
func et (cd,em,en,eu,ev) = if (!(sigVerify_8Kb(eu, ev, g)))
898
901
 
    then throw("signature does not match")
899
902
 
    else {
900
-
        let dg = split(toUtf8String(et), ";")
901
-
        let ev = split(split(dg[0], "|")[0], "_")
902
-
        let ew = parseIntValue(ev[0])
903
-
        let ex = parseIntValue(ev[1])
904
-
        let ey = split(dg[1], ":")
905
-
        let ez = split(ey[0], "_")
906
-
        if ((ez[1] != "E"))
903
+
        let dh = split(toUtf8String(eu), ";")
904
+
        let ew = split(split(dh[0], "|")[0], "_")
905
+
        let ex = parseIntValue(ew[0])
906
+
        let ey = parseIntValue(ew[1])
907
+
        let ez = split(dh[1], ":")
908
+
        let eA = split(ez[0], "_")
909
+
        if ((eA[1] != "E"))
907
910
 
            then throw("expedition target location type should be E")
908
911
 
            else {
909
-
                let eA = parseIntValue(ey[1])
910
-
                if (if ((eA > (lastBlock.timestamp + t)))
912
+
                let eB = parseIntValue(ez[1])
913
+
                if (if ((eB > (lastBlock.timestamp + t)))
911
914
 
                    then true
912
-
                    else ((lastBlock.timestamp - t) > eA))
915
+
                    else ((lastBlock.timestamp - t) > eB))
913
916
 
                    then throw("signature outdated")
914
917
 
                    else {
915
-
                        let aY = toString(el)
916
-
                        let aP = valueOrErrorMessage(getString(aK(aY)), "You don't have a duck staked")
917
-
                        let eB = aT(aP)
918
-
                        let eC = valueOrElse(getInteger(eB), 100)
919
-
                        if ((eC != ew))
920
-
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eB), 100))) + " from state does not match one from flight log=") + toString(ew)))
921
-
                            else if ((0 >= ew))
918
+
                        let aW = toString(em)
919
+
                        let aQ = valueOrErrorMessage(getString(aO(aW)), "You don't have a duck staked")
920
+
                        let eC = aS(aQ)
921
+
                        let eD = valueOrElse(getInteger(eC), 100)
922
+
                        if ((eD != ex))
923
+
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eC), 100))) + " from state does not match one from flight log=") + toString(ex)))
924
+
                            else if ((0 >= ex))
922
925
 
                                then throw("You can't fly with zero health")
923
-
                                else if ((0 >= ex))
924
-
                                    then $Tuple2(((if (!(cc))
925
-
                                        then [ScriptTransfer(el, B, b)]
926
-
                                        else nil) :+ IntegerEntry(eB, 0)), "")
926
+
                                else if ((0 >= ey))
927
+
                                    then $Tuple2(((if (!(cd))
928
+
                                        then [ScriptTransfer(em, B, b)]
929
+
                                        else nil) :+ IntegerEntry(eC, 0)), "")
927
930
 
                                    else {
928
-
                                        let dc = aO(aP)
929
-
                                        let dO = db(dc)
930
-
                                        let eD = split(dO[bi], "_")
931
-
                                        let eE = makeString(cb(cc, eD, A), "_")
932
-
                                        let eF = ek(el, em)
933
-
                                        let er = eF._2._1
934
-
                                        $Tuple2((((eF._1 :+ StringEntry(aS(aP), makeString([eF._2._2, "L", er], "_"))) :+ IntegerEntry(eB, ex)) :+ StringEntry(dc, makeString([dO[bg], dO[bh], eE, dO[bj]], ":"))), er)
931
+
                                        let dd = aP(aQ)
932
+
                                        let dP = dc(dd)
933
+
                                        let eE = split(dP[bh], "_")
934
+
                                        let eF = makeString(cc(cd, eE, A), "_")
935
+
                                        let eG = el(em, en)
936
+
                                        let es = eG._2._1
937
+
                                        $Tuple2((((eG._1 :+ StringEntry(aR(aQ), makeString([eG._2._2, "L", es], "_"))) :+ IntegerEntry(eC, ey)) :+ StringEntry(dd, makeString([dP[bf], dP[bg], eF, dP[bi]], ":"))), es)
935
938
 
                                        }
936
939
 
                        }
937
940
 
                }
938
941
 
        }
939
942
 
940
943
 
941
-
func eG (aR,eH) = {
942
-
    let dz = valueOrElse(getInteger(aC(aR)), 0)
943
-
    let eI = valueOrElse(getInteger(aH(N, aR)), if (valueOrElse(getBoolean(aF(aR)), false))
944
-
        then eH
944
+
func eH (aD,eI) = {
945
+
    let dA = valueOrElse(getInteger(as(aD)), 0)
946
+
    let eJ = valueOrElse(getInteger(ax(N, aD)), if (valueOrElse(getBoolean(av(aD)), false))
947
+
        then eI
945
948
 
        else 0)
946
-
    let eJ = (dz / 6)
947
-
    let eK = (dz / 7)
948
-
    ((r + fraction(r, ((dz + eJ) + (2 * eK)), 5)) + fraction(r, eI, (eH * 5)))
949
+
    let eK = (dA / 6)
950
+
    let eL = (dA / 7)
951
+
    ((r + fraction(r, ((dA + eK) + (2 * eL)), 5)) + fraction(r, eJ, (eI * 5)))
949
952
 
    }
950
953
 
951
954
 
952
-
func eL (ai,eM,eN) = {
953
-
    let eO = if ((eM == bt))
954
-
        then $Tuple2(eN, valueOrElse(getString(aK(ai)), ""))
955
+
func eM (ai,eN,eO) = {
956
+
    let eP = if ((eN == bs))
957
+
        then $Tuple2(eO, valueOrElse(getString(aO(ai)), ""))
955
958
 
        else {
956
-
            let aP = valueOrErrorMessage(getString(aK(ai)), "You don't have a duck staked")
957
-
            let eP = valueOrElse(getString(aS(aP)), k)
958
-
            let eQ = split(value(eP), "_")
959
-
            if ((eQ[be] != "L"))
960
-
                then throw((("Duck location type is " + eQ[be]) + ", but should be L"))
961
-
                else $Tuple2(eQ[bf], aP)
959
+
            let aQ = valueOrErrorMessage(getString(aO(ai)), "You don't have a duck staked")
960
+
            let eQ = valueOrElse(getString(aR(aQ)), k)
961
+
            let eR = split(value(eQ), "_")
962
+
            if ((eR[bd] != "L"))
963
+
                then throw((("Duck location type is " + eR[bd]) + ", but should be L"))
964
+
                else $Tuple2(eR[be], aQ)
962
965
 
            }
963
-
    let aR = eO._1
964
-
    let eR = eO._2
965
-
    let eS = value(assetInfo(fromBase58String(aR)))
966
-
    let eT = aB(aR)
967
-
    let eU = valueOrErrorMessage(getInteger(eT), (("Land " + eS.name) + " is not staked"))
968
-
    let eV = valueOrErrorMessage(getString(ao(aR)), (("NFT " + eS.name) + " is orphaned"))
969
-
    if ((eV != ai))
966
+
    let aD = eP._1
967
+
    let eS = eP._2
968
+
    let eT = value(assetInfo(fromBase58String(aD)))
969
+
    let eU = ar(aD)
970
+
    let eV = valueOrErrorMessage(getInteger(eU), (("Land " + eT.name) + " is not staked"))
971
+
    let eW = valueOrErrorMessage(getString(am(aD)), (("NFT " + eT.name) + " is orphaned"))
972
+
    if ((eW != ai))
970
973
 
        then throw((i + " is not yours"))
971
974
 
        else {
972
-
            let eW = split(eS.description, "_")
973
-
            $Tuple4(eR, aR, eW, eU)
975
+
            let eX = split(eT.description, "_")
976
+
            $Tuple4(eS, aD, eX, eV)
974
977
 
            }
975
978
 
    }
976
979
 
977
980
 
978
-
func eX (ai,cv,eM,eN) = if ((0 > cv))
981
+
func eY (ai,cw,eN,eO) = if ((0 > cw))
979
982
 
    then throw("Negative amount")
980
983
 
    else {
981
-
        let eY = eL(ai, eM, eN)
982
-
        let an = eY._3[ba]
983
-
        let ck = cq(eY._3[bb])
984
-
        let cz = (lastBlock.timestamp - eY._4)
985
-
        if ((0 > cz))
986
-
            then throw(((("Saved timestamp is in future, saved = " + toString(eY._4)) + ", current = ") + toString(lastBlock.timestamp)))
984
+
        let eZ = eM(ai, eN, eO)
985
+
        let bE = eZ._3[aZ]
986
+
        let cl = cr(eZ._3[ba])
987
+
        let cA = (lastBlock.timestamp - eZ._4)
988
+
        if ((0 > cA))
989
+
            then throw(((("Saved timestamp is in future, saved = " + toString(eZ._4)) + ", current = ") + toString(lastBlock.timestamp)))
987
990
 
            else {
988
-
                let eH = cs(an)
989
-
                let eZ = eG(eY._2, eH)
990
-
                let fa = fraction(cz, (eZ * eH), s)
991
-
                if ((cv > fa))
992
-
                    then throw(((("Not enough resources, available = " + toString(fa)) + ", requested = ") + toString(cv)))
991
+
                let eI = ct(bE)
992
+
                let fa = eH(eZ._2, eI)
993
+
                let fb = fraction(cA, (fa * eI), s)
994
+
                if ((cw > fb))
995
+
                    then throw(((("Not enough resources, available = " + toString(fb)) + ", requested = ") + toString(cw)))
993
996
 
                    else {
994
-
                        let fb = fraction((fa - cv), s, (eZ * eH))
995
-
                        let fc = (lastBlock.timestamp - fb)
996
-
                        let dy = (eH / m)
997
-
                        let cH = cD(ck, (cz - fb), dy, eZ)
998
-
                        let dx = aQ(eY._2)
999
-
                        let dz = valueOrElse(getInteger(aC(eY._2)), 0)
1000
-
                        let di = dw(dx, dy, dz)
1001
-
                        let dF = split(di[bo], "_")
1002
-
                        let cI = parseIntValue(dF[br])
1003
-
                        if (if ((eM == bt))
1004
-
                            then (cv > cI)
997
+
                        let fc = fraction((fb - cw), s, (fa * eI))
998
+
                        let fd = (lastBlock.timestamp - fc)
999
+
                        let dz = (eI / m)
1000
+
                        let cI = cE(cl, (cA - fc), dz, fa)
1001
+
                        let dy = aC(eZ._2)
1002
+
                        let dA = valueOrElse(getInteger(as(eZ._2)), 0)
1003
+
                        let dj = dx(dy, dz, dA)
1004
+
                        let dG = split(dj[bn], "_")
1005
+
                        let cJ = parseIntValue(dG[bq])
1006
+
                        if (if ((eN == bs))
1007
+
                            then (cw > cJ)
1005
1008
 
                            else false)
1006
-
                            then throw((("Only " + toString(cI)) + " space left in warehouse"))
1009
+
                            then throw((("Only " + toString(cJ)) + " space left in warehouse"))
1007
1010
 
                            else {
1008
-
                                let dc = aO(eY._1)
1009
-
                                let dO = db(dc)
1010
-
                                let cG = split(dO[bh], "_")
1011
-
                                let cF = split(di[bl], "_")
1012
-
                                let fd = if ((eM == bt))
1013
-
                                    then $Tuple4(cx(cF, ck, (cz - fb), dy, eZ), dO[bh], (parseIntValue(dF[bq]) + cH._2), (parseIntValue(dF[br]) - cH._2))
1014
-
                                    else if ((eM == bu))
1015
-
                                        then $Tuple4(di[bl], cx(cG, ck, (cz - fb), dy, eZ), parseIntValue(dF[bq]), parseIntValue(dF[br]))
1011
+
                                let dd = aP(eZ._1)
1012
+
                                let dP = dc(dd)
1013
+
                                let cH = split(dP[bg], "_")
1014
+
                                let cG = split(dj[bk], "_")
1015
+
                                let fe = if ((eN == bs))
1016
+
                                    then $Tuple4(cy(cG, cl, (cA - fc), dz, fa), dP[bg], (parseIntValue(dG[bp]) + cI._2), (parseIntValue(dG[bq]) - cI._2))
1017
+
                                    else if ((eN == bt))
1018
+
                                        then $Tuple4(dj[bk], cy(cH, cl, (cA - fc), dz, fa), parseIntValue(dG[bp]), parseIntValue(dG[bq]))
1016
1019
 
                                        else {
1017
-
                                            let fe = cE(cF, cG, cH, cI)
1018
-
                                            let ff = min([parseIntValue(dF[br]), cH._2])
1019
-
                                            $Tuple4(fe._1, fe._2, (parseIntValue(dF[bq]) + ff), (parseIntValue(dF[br]) - ff))
1020
+
                                            let ff = cF(cG, cH, cI, cJ)
1021
+
                                            let fg = min([parseIntValue(dG[bq]), cI._2])
1022
+
                                            $Tuple4(ff._1, ff._2, (parseIntValue(dG[bp]) + fg), (parseIntValue(dG[bq]) - fg))
1020
1023
 
                                            }
1021
-
                                let fg = fd._1
1022
-
                                let fh = fd._2
1023
-
                                let fi = fd._3
1024
-
                                let fj = fd._4
1025
-
                                $Tuple5([IntegerEntry(aB(eY._2), fc), IntegerEntry(aL(i, eY._2, ai), fc)], dc, [dO[bg], fh, dO[bi], dO[bj]], dx, [di[bk], fg, di[bm], di[bn], makeString([dF[bp], toString(fi), toString(fj), dF[bs]], "_")])
1024
+
                                let fh = fe._1
1025
+
                                let fi = fe._2
1026
+
                                let fj = fe._3
1027
+
                                let fk = fe._4
1028
+
                                $Tuple5([IntegerEntry(ar(eZ._2), fd), IntegerEntry(aA(i, eZ._2, ai), fd)], dd, [dP[bf], fi, dP[bh], dP[bi]], dy, [dj[bj], fh, dj[bl], dj[bm], makeString([dG[bo], toString(fj), toString(fk), dG[br]], "_")])
1026
1029
 
                                }
1027
1030
 
                        }
1028
1031
 
                }
1029
1032
 
        }
1030
1033
 
1031
1034
 
1032
-
func fk (ai,aR,eH,eM) = {
1033
-
    let eT = aB(aR)
1034
-
    let eU = value(getInteger(eT))
1035
-
    let fa = (fraction((lastBlock.timestamp - eU), eG(aR, eH), s) * eH)
1036
-
    eX(ai, fa, eM, aR)
1035
+
func fl (ai,aD,eI,eN) = {
1036
+
    let eU = ar(aD)
1037
+
    let eV = value(getInteger(eU))
1038
+
    let fb = (fraction((lastBlock.timestamp - eV), eH(aD, eI), s) * eI)
1039
+
    eY(ai, fb, eN, aD)
1037
1040
 
    }
1038
1041
 
1039
1042
 
1040
-
func fl (cc,el,fm,aR) = {
1041
-
    let ai = toString(el)
1042
-
    let eY = eL(ai, bv, aR)
1043
-
    let eH = cs(eY._3[ba])
1044
-
    let fn = aC(eY._2)
1045
-
    let fo = valueOrElse(getInteger(fn), 0)
1046
-
    if ((fo >= 3))
1043
+
func fm (cd,em,fn,aD) = {
1044
+
    let ai = toString(em)
1045
+
    let eZ = eM(ai, bu, aD)
1046
+
    let eI = ct(eZ._3[aZ])
1047
+
    let fo = as(eZ._2)
1048
+
    let fp = valueOrElse(getInteger(fo), 0)
1049
+
    if ((fp >= 3))
1047
1050
 
        then throw("Currently max infrastructure level = 3")
1048
1051
 
        else {
1049
-
            let fp = (fo + 1)
1050
-
            let fq = fraction(z, (eH * fp), m)
1051
-
            if (if (!(cc))
1052
-
                then (fm != fq)
1052
+
            let fq = (fp + 1)
1053
+
            let fr = fraction(z, (eI * fq), m)
1054
+
            if (if (!(cd))
1055
+
                then (fn != fr)
1053
1056
 
                else false)
1054
-
                then throw(("Payment attached should be " + toString(fq)))
1057
+
                then throw(("Payment attached should be " + toString(fr)))
1055
1058
 
                else {
1056
-
                    let dc = aO(eY._1)
1057
-
                    let dO = db(dc)
1058
-
                    let eD = split(dO[bi], "_")
1059
-
                    let eE = makeString(cb(cc, eD, fraction(y, (eH * fp), m)), "_")
1060
-
                    let fr = fk(ai, eY._2, eH, bv)
1061
-
                    let fs = fr._5
1062
-
                    let ft = de(fs[bk])
1063
-
                    let fu = makeString([split(fs[bk], "_")[0], toString(fp)], "_")
1064
-
                    let fv = de(fu)
1065
-
                    let dF = split(fs[bo], "_")
1066
-
                    let fw = makeString([dF[bp], dF[bq], toString(((parseIntValue(dF[br]) + fv) - ft)), toString(fv)], "_")
1067
-
                    $Tuple2(([IntegerEntry(fn, fp), IntegerEntry(aD(eY._2, ai), fp), StringEntry(dc, makeString([dO[bg], fr._3[bh], eE, dO[bj]], ":")), StringEntry(fr._4, makeString([fu, fs[bl], fs[bm], fs[bn], fw], ":"))] ++ fr._1), fp)
1059
+
                    let dd = aP(eZ._1)
1060
+
                    let dP = dc(dd)
1061
+
                    let eE = split(dP[bh], "_")
1062
+
                    let eF = makeString(cc(cd, eE, fraction(y, (eI * fq), m)), "_")
1063
+
                    let fs = fl(ai, eZ._2, eI, bu)
1064
+
                    let ft = fs._5
1065
+
                    let fu = df(ft[bj])
1066
+
                    let fv = makeString([split(ft[bj], "_")[0], toString(fq)], "_")
1067
+
                    let fw = df(fv)
1068
+
                    let dG = split(ft[bn], "_")
1069
+
                    let fx = makeString([dG[bo], dG[bp], toString(((parseIntValue(dG[bq]) + fw) - fu)), toString(fw)], "_")
1070
+
                    $Tuple2(([IntegerEntry(fo, fq), IntegerEntry(at(eZ._2, ai), fq), StringEntry(dd, makeString([dP[bf], fs._3[bg], eF, dP[bi]], ":")), StringEntry(fs._4, makeString([fv, ft[bk], ft[bl], ft[bm], fx], ":"))] ++ fs._1), fq)
1068
1071
 
                    }
1069
1072
 
            }
1070
1073
 
    }
1071
1074
 
1072
1075
 
1073
-
func fx (ai) = 0
1076
+
func fy (ai) = 0
1074
1077
 
1075
1078
 
1076
-
func fy (ai,eN) = {
1077
-
    let eY = eL(ai, bv, eN)
1078
-
    let aR = eY._2
1079
-
    let eH = cs(eY._3[ba])
1080
-
    let fz = aH(N, aR)
1081
-
    if ((valueOrElse(getInteger(fz), if (valueOrElse(getBoolean(aF(aR)), false))
1082
-
        then eH
1079
+
func fz (ai,eO) = {
1080
+
    let eZ = eM(ai, bu, eO)
1081
+
    let aD = eZ._2
1082
+
    let eI = ct(eZ._3[aZ])
1083
+
    let fA = ax(N, aD)
1084
+
    if ((valueOrElse(getInteger(fA), if (valueOrElse(getBoolean(av(aD)), false))
1085
+
        then eI
1083
1086
 
        else 0) > 0))
1084
1087
 
        then throw("Presale artifact is already activated")
1085
-
        else if ((parseIntValue(eY._3[aZ]) > O))
1086
-
            then throw((((i + " ") + aR) + " is not eligible for presale artifact"))
1088
+
        else if ((parseIntValue(eZ._3[aY]) > O))
1089
+
            then throw((((i + " ") + aD) + " is not eligible for presale artifact"))
1087
1090
 
            else {
1088
-
                let fr = fk(ai, aR, eH, bv)
1089
-
                ((((fr._1 :+ IntegerEntry(fz, eH)) :+ IntegerEntry(aJ(N, aR, ai), eH)) :+ StringEntry(fr._2, makeString(fr._3, ":"))) :+ StringEntry(fr._4, makeString(fr._5, ":")))
1091
+
                let fs = fl(ai, aD, eI, bu)
1092
+
                ((((fs._1 :+ IntegerEntry(fA, eI)) :+ IntegerEntry(az(N, aD, ai), eI)) :+ StringEntry(fs._2, makeString(fs._3, ":"))) :+ StringEntry(fs._4, makeString(fs._5, ":")))
1090
1093
 
                }
1091
1094
 
    }
1092
1095
 
1093
1096
 
1094
-
func fA (fB,fp,fC,ai,fD,em,fE) = {
1095
-
    let aP = valueOrErrorMessage(getString(aK(ai)), "You don't have a duck staked")
1096
-
    func fF (bP,aR) =     {
1097
-
        let eS = value(assetInfo(fromBase58String(aR)))
1098
-
        let eT = aB(aR)
1099
-
        let eU = valueOrErrorMessage(getInteger(eT), (("NFT " + eS.name) + " is not staked"))
1100
-
        let eV = valueOrErrorMessage(getString(ao(aR)), (("NFT " + eS.name) + " is orphaned"))
1101
-
        if ((eV != ai))
1097
+
func fB (fC,fq,fD,ai,fE,en,fF) = {
1098
+
    let aQ = valueOrErrorMessage(getString(aO(ai)), "You don't have a duck staked")
1099
+
    func fG (bQ,aD) =     {
1100
+
        let eT = value(assetInfo(fromBase58String(aD)))
1101
+
        let eU = ar(aD)
1102
+
        let eV = valueOrErrorMessage(getInteger(eU), (("NFT " + eT.name) + " is not staked"))
1103
+
        let eW = valueOrErrorMessage(getString(am(aD)), (("NFT " + eT.name) + " is orphaned"))
1104
+
        if ((eW != ai))
1102
1105
 
            then throw((i + " is not yours"))
1103
1106
 
            else {
1104
-
                let eW = split(eS.description, "_")
1105
-
                let ep = eW[bc]
1106
-
                if (if ((bP._3 != ""))
1107
-
                    then (bP._3 != ep)
1107
+
                let eX = split(eT.description, "_")
1108
+
                let eq = eX[bb]
1109
+
                if (if ((bQ._3 != ""))
1110
+
                    then (bQ._3 != eq)
1108
1111
 
                    else false)
1109
1112
 
                    then throw("Lands should be on the same continent to merge")
1110
1113
 
                    else {
1111
-
                        let an = eW[ba]
1112
-
                        let fG = bP._1
1113
-
                        let co = valueOrErrorMessage(indexOf(fG, an), "You haven't passed all the lands needed")
1114
-
                        let fH = (take(fG, co) + drop(fG, (co + 1)))
1115
-
                        let eH = cs(an)
1116
-
                        let fI = (bP._2 + valueOrElse(getInteger(aH(N, aR)), if (valueOrElse(getBoolean(aF(aR)), false))
1117
-
                            then eH
1114
+
                        let bE = eX[aZ]
1115
+
                        let fH = bQ._1
1116
+
                        let cp = valueOrErrorMessage(indexOf(fH, bE), "You haven't passed all the lands needed")
1117
+
                        let fI = (take(fH, cp) + drop(fH, (cp + 1)))
1118
+
                        let eI = ct(bE)
1119
+
                        let fJ = (bQ._2 + valueOrElse(getInteger(ax(N, aD)), if (valueOrElse(getBoolean(av(aD)), false))
1120
+
                            then eI
1118
1121
 
                            else 0))
1119
-
                        let dz = valueOrElse(getInteger(aC(aR)), 0)
1120
-
                        let fJ = {
1121
-
                            let c = an
1122
+
                        let dA = valueOrElse(getInteger(as(aD)), 0)
1123
+
                        let fK = {
1124
+
                            let c = bE
1122
1125
 
                            if (("S" == c))
1123
1126
 
                                then 3
1124
1127
 
                                else if (("M" == c))
1129
1132
 
                                            then 6
1130
1133
 
                                            else throw("Only S, M, L, XL can merge")
1131
1134
 
                            }
1132
-
                        if ((dz != fJ))
1135
+
                        if ((dA != fK))
1133
1136
 
                            then throw("All lands should be maxed to merge")
1134
1137
 
                            else {
1135
-
                                let al = eW[aZ]
1136
-
                                let ck = cq(eW[bb])
1137
-
                                let cz = (lastBlock.timestamp - eU)
1138
-
                                if ((0 > cz))
1139
-
                                    then throw(((("Saved timestamp is in future, saved = " + toString(eU)) + ", current = ") + toString(lastBlock.timestamp)))
1138
+
                                let al = eX[aY]
1139
+
                                let cl = cr(eX[ba])
1140
+
                                let cA = (lastBlock.timestamp - eV)
1141
+
                                if ((0 > cA))
1142
+
                                    then throw(((("Saved timestamp is in future, saved = " + toString(eV)) + ", current = ") + toString(lastBlock.timestamp)))
1140
1143
 
                                    else {
1141
-
                                        let eZ = eG(aR, eH)
1142
-
                                        let dy = (eH / m)
1143
-
                                        let fh = cx(split(bP._4, "_"), ck, cz, dy, eZ)
1144
-
                                        let bZ = ci(split(bP._6, "_"), ck, dy, -1)
1145
-
                                        let fK = bP._7
1146
-
                                        let ad = indexOf(fK, aR)
1144
+
                                        let fa = eH(aD, eI)
1145
+
                                        let dz = (eI / m)
1146
+
                                        let fi = cy(split(bQ._4, "_"), cl, cA, dz, fa)
1147
+
                                        let ca = cj(split(bQ._6, "_"), cl, dz, -1)
1148
+
                                        let fL = bQ._7
1149
+
                                        let ad = indexOf(fL, aD)
1147
1150
 
                                        if (!(isDefined(ad)))
1148
-
                                            then throw(("Your staked lands don't contain " + aR))
1151
+
                                            then throw(("Your staked lands don't contain " + aD))
1149
1152
 
                                            else {
1150
-
                                                let fL = aq(aR)
1151
-
                                                let fM = valueOrElse(getString(fL), "")
1152
-
                                                $Tuple7(fH, fI, ep, fh, ((((((((((((((bP._5 :+ DeleteEntry(aB(aR))) :+ DeleteEntry(aL(i, aR, ai))) :+ DeleteEntry(ak(al))) :+ DeleteEntry(am(al, an))) :+ DeleteEntry(ao(aR))) :+ DeleteEntry(aC(aR))) :+ DeleteEntry(aD(aR, ai))) :+ DeleteEntry(aH(N, aR))) :+ DeleteEntry(aJ(N, aR, ai))) :+ DeleteEntry(aN(al))) :+ DeleteEntry(aQ(aR))) :+ DeleteEntry(fL)) :+ DeleteEntry(at(fM))) :+ Burn(fromBase58String(aR), 1)), bZ, removeByIndex(fK, value(ad)))
1153
+
                                                let fM = ao(aD)
1154
+
                                                let fN = valueOrElse(getString(fM), "")
1155
+
                                                $Tuple7(fI, fJ, eq, fi, (((((((((((((bQ._5 :+ DeleteEntry(ar(aD))) :+ DeleteEntry(aA(i, aD, ai))) :+ DeleteEntry(ak(al))) :+ DeleteEntry(am(aD))) :+ DeleteEntry(as(aD))) :+ DeleteEntry(at(aD, ai))) :+ DeleteEntry(ax(N, aD))) :+ DeleteEntry(az(N, aD, ai))) :+ DeleteEntry(aE(al))) :+ DeleteEntry(aC(aD))) :+ DeleteEntry(fM)) :+ DeleteEntry(ap(fN))) :+ Burn(fromBase58String(aD), 1)), ca, removeByIndex(fL, value(ad)))
1153
1156
 
                                                }
1154
1157
 
                                        }
1155
1158
 
                                }
1157
1160
 
                }
1158
1161
 
        }
1159
1162
 
1160
-
    let dc = aO(aP)
1161
-
    let dO = db(dc)
1162
-
    let fN = valueOrElse(getString(aU()), "0_0_0_0_0_0")
1163
-
    let fO = aV(ai)
1164
-
    let fP = getString(fO)
1165
-
    let fQ = if (isDefined(fP))
1166
-
        then split_51C(value(fP), "_")
1163
+
    let dd = aP(aQ)
1164
+
    let dP = dc(dd)
1165
+
    let fO = valueOrElse(getString(aT()), "0_0_0_0_0_0")
1166
+
    let fP = aF(ai)
1167
+
    let fQ = getString(fP)
1168
+
    let fR = if (isDefined(fQ))
1169
+
        then split_51C(value(fQ), "_")
1167
1170
 
        else nil
1168
-
    let ca = {
1169
-
        let bR = fD
1170
-
        let bS = size(bR)
1171
-
        let bT = $Tuple7(fC, 0, "", dO[bh], nil, fN, fQ)
1172
-
        func bU (bV,bW) =         if ((bW >= bS))
1173
-
            then bV
1174
-
            else fF(bV, bR[bW])
1171
+
    let cb = {
1172
+
        let bS = fE
1173
+
        let bT = size(bS)
1174
+
        let bU = $Tuple7(fD, 0, "", dP[bg], nil, fO, fR)
1175
+
        func bV (bW,bX) =         if ((bX >= bT))
1176
+
            then bW
1177
+
            else fG(bW, bS[bX])
1175
1178
 
1176
-
        func bX (bV,bW) =         if ((bW >= bS))
1177
-
            then bV
1179
+
        func bY (bW,bX) =         if ((bX >= bT))
1180
+
            then bW
1178
1181
 
            else throw("List size exceeds 5")
1179
1182
 
1180
-
        bX(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5)
1183
+
        bY(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5)
1181
1184
 
        }
1182
-
    let ep = ca._3
1183
-
    let cX = valueOrErrorMessage(indexOf(M, ep), ("Unknown continent: " + ep))
1184
-
    let cr = cV(cO(toBigInt(em)), cX)
1185
-
    let eo = valueOrElse(getInteger(aj()), (O + 1))
1186
-
    let fR = toString(eo)
1187
-
    let eq = Issue(am(fR, fB), makeString([fR, fB, cr, ep], "_"), 1, 0, false)
1188
-
    let ap = calculateAssetId(eq)
1189
-
    let fS = toBase58String(ap)
1190
-
    let eE = makeString(cb((fE > 0), split(dO[bi], "_"), fE), "_")
1191
-
    $Tuple2(((((((((((((((ca._5 :+ (if ((size(ca._7) > 0))
1192
-
        then StringEntry(fO, makeString_11C(ca._7, "_"))
1193
-
        else DeleteEntry(fO))) :+ IntegerEntry(aj(), (eo + 1))) :+ eq) :+ StringEntry(ak(fR), fS)) :+ StringEntry(ao(fS), ai)) :+ StringEntry(aN(fR), ai)) :+ IntegerEntry(aH(N, fS), ca._2)) :+ IntegerEntry(aJ(N, fS, ai), ca._2)) :+ IntegerEntry(aC(fS), fp)) :+ IntegerEntry(aD(fS, ai), fp)) :+ StringEntry(dc, makeString([dO[bg], ca._4, eE, dO[bj]], ":"))) :+ StringEntry(aU(), ca._6)) :+ StringEntry(aS(aP), makeString([ep, "L", fS], "_"))) :+ ScriptTransfer(addressFromStringValue(ai), 1, ap)), fS)
1185
+
    let eq = cb._3
1186
+
    let cY = valueOrErrorMessage(indexOf(M, eq), ("Unknown continent: " + eq))
1187
+
    let cs = cW(cP(toBigInt(en)), cY)
1188
+
    let ep = valueOrElse(getInteger(aj()), (O + 1))
1189
+
    let fS = toString(ep)
1190
+
    let er = Issue(bD(fS, fC), makeString([fS, fC, cs, eq], "_"), 1, 0, false)
1191
+
    let an = calculateAssetId(er)
1192
+
    let fT = toBase58String(an)
1193
+
    let eF = makeString(cc((fF > 0), split(dP[bh], "_"), fF), "_")
1194
+
    $Tuple2(((((((((((((((cb._5 :+ (if ((size(cb._7) > 0))
1195
+
        then StringEntry(fP, makeString_11C(cb._7, "_"))
1196
+
        else DeleteEntry(fP))) :+ IntegerEntry(aj(), (ep + 1))) :+ er) :+ StringEntry(ak(fS), fT)) :+ StringEntry(am(fT), ai)) :+ StringEntry(aE(fS), ai)) :+ IntegerEntry(ax(N, fT), cb._2)) :+ IntegerEntry(az(N, fT, ai), cb._2)) :+ IntegerEntry(as(fT), fq)) :+ IntegerEntry(at(fT, ai), fq)) :+ StringEntry(dd, makeString([dP[bf], cb._4, eF, dP[bi]], ":"))) :+ StringEntry(aT(), cb._6)) :+ StringEntry(aR(aQ), makeString([eq, "L", fT], "_"))) :+ ScriptTransfer(addressFromStringValue(ai), 1, an)), fT)
1194
1197
 
    }
1195
1198
 
1196
1199
 
1197
-
func fT (ai,fD,em) = fA("M", 3, "SSSS", ai, fD, em, 0)
1200
+
func fU (ai,fE,en) = fB("M", 3, "SSSS", ai, fE, en, 0)
1198
1201
 
1199
1202
 
1200
-
func fU (ai,fD,em,cc,fm) = {
1201
-
    let fq = (z * 4)
1202
-
    if (if (!(cc))
1203
-
        then (fm != fq)
1203
+
func fV (ai,fE,en,cd,fn) = {
1204
+
    let fr = (z * 4)
1205
+
    if (if (!(cd))
1206
+
        then (fn != fr)
1204
1207
 
        else false)
1205
-
        then throw(("Payment attached should be " + toString(fq)))
1206
-
        else fA("L", 4, "SMM", ai, fD, em, (y * 4))
1208
+
        then throw(("Payment attached should be " + toString(fr)))
1209
+
        else fB("L", 4, "SMM", ai, fE, en, (y * 4))
1207
1210
 
    }
1208
1211
 
1209
1212
 
1210
-
func fV (ai,fD,em,cc,fm) = {
1211
-
    let fq = (z * 47)
1212
-
    if (if (!(cc))
1213
-
        then (fm != fq)
1213
+
func fW (ai,fE,en,cd,fn) = {
1214
+
    let fr = (z * 47)
1215
+
    if (if (!(cd))
1216
+
        then (fn != fr)
1214
1217
 
        else false)
1215
-
        then throw(("Payment attached should be " + toString(fq)))
1216
-
        else fA("XL", 5, "SSSML", ai, fD, em, (y * 47))
1218
+
        then throw(("Payment attached should be " + toString(fr)))
1219
+
        else fB("XL", 5, "SSSML", ai, fE, en, (y * 47))
1217
1220
 
    }
1218
1221
 
1219
1222
 
1220
-
func fW (ai,fD,em,cc,fm) = {
1221
-
    let fq = (z * 54)
1222
-
    if (if (!(cc))
1223
-
        then (fm != fq)
1223
+
func fX (ai,fE,en,cd,fn) = {
1224
+
    let fr = (z * 54)
1225
+
    if (if (!(cd))
1226
+
        then (fn != fr)
1224
1227
 
        else false)
1225
-
        then throw(("Payment attached should be " + toString(fq)))
1226
-
        else fA("XXL", 6, "LXL", ai, fD, em, (y * 54))
1228
+
        then throw(("Payment attached should be " + toString(fr)))
1229
+
        else fB("XXL", 6, "LXL", ai, fE, en, (y * 54))
1227
1230
 
    }
1228
1231
 
1229
1232
 
1230
-
func fX (cc,ai,fm,fD,em) = {
1231
-
    let fY = {
1232
-
        let c = size(fD)
1233
+
func fY (cd,ai,fn,fE,en) = {
1234
+
    let fZ = {
1235
+
        let c = size(fE)
1233
1236
 
        if ((4 == c))
1234
-
            then fT(ai, fD, em)
1237
+
            then fU(ai, fE, en)
1235
1238
 
            else if ((3 == c))
1236
-
                then fU(ai, fD, em, cc, fm)
1239
+
                then fV(ai, fE, en, cd, fn)
1237
1240
 
                else if ((5 == c))
1238
-
                    then fV(ai, fD, em, cc, fm)
1241
+
                    then fW(ai, fE, en, cd, fn)
1239
1242
 
                    else if ((2 == c))
1240
-
                        then fW(ai, fD, em, cc, fm)
1243
+
                        then fX(ai, fE, en, cd, fn)
1241
1244
 
                        else throw("Unknown merge")
1242
1245
 
        }
1243
-
    fY
1246
+
    fZ
1244
1247
 
    }
1245
1248
 
1246
1249
 
1247
-
func fZ (co) = if (if ((co.originCaller != ae))
1248
-
    then valueOrElse(getBoolean(aW()), false)
1250
+
func ga (cp) = if (if ((cp.originCaller != ae))
1251
+
    then valueOrElse(getBoolean(aU()), false)
1249
1252
 
    else false)
1250
1253
 
    then throw("Contracts are under maintenance")
1251
-
    else StringEntry(ah(toString(co.originCaller)), toBase58String(co.transactionId))
1254
+
    else StringEntry(ah(toString(cp.originCaller)), toBase58String(cp.transactionId))
1252
1255
 
1253
1256
 
1254
-
@Callable(co)
1255
-
func constructorV1 (ga) = if ((co.caller != this))
1257
+
@Callable(cp)
1258
+
func constructorV1 (gb) = if ((cp.caller != this))
1256
1259
 
    then throw("Permission denied")
1257
-
    else [StringEntry(Y(), ga)]
1260
+
    else [StringEntry(Y(), gb)]
1258
1261
 
1259
1262
 
1260
1263
 
1261
-
@Callable(co)
1262
-
func setBlocked (gb) = if ((co.caller != this))
1264
+
@Callable(cp)
1265
+
func setBlocked (gc) = if ((cp.caller != this))
1263
1266
 
    then throw("permission denied")
1264
-
    else [BooleanEntry(aW(), gb)]
1267
+
    else [BooleanEntry(aU(), gc)]
1265
1268
 
1266
1269
 
1267
1270
 
1268
-
@Callable(co)
1271
+
@Callable(cp)
1269
1272
 
func stakeLand () = {
1270
-
    let gc = fZ(co)
1271
-
    if ((size(co.payments) != 1))
1273
+
    let gd = ga(cp)
1274
+
    if ((size(cp.payments) != 1))
1272
1275
 
        then throw("Exactly one payment required")
1273
1276
 
        else {
1274
-
            let gd = value(co.payments[0])
1275
-
            let ap = value(gd.assetId)
1276
-
            let Q = toString(co.caller)
1277
-
            if ((gd.amount != 1))
1277
+
            let ge = value(cp.payments[0])
1278
+
            let an = value(ge.assetId)
1279
+
            let Q = toString(cp.caller)
1280
+
            if ((ge.amount != 1))
1278
1281
 
                then throw((("NFT " + i) + " token should be attached as payment"))
1279
1282
 
                else {
1280
-
                    let eS = value(assetInfo(ap))
1281
-
                    if ((eS.issuer != this))
1283
+
                    let eT = value(assetInfo(an))
1284
+
                    if ((eT.issuer != this))
1282
1285
 
                        then throw("Unknown issuer of token")
1283
-
                        else if (!(contains(eS.name, i)))
1286
+
                        else if (!(contains(eT.name, i)))
1284
1287
 
                            then throw((("Only NFT " + i) + " tokens are accepted"))
1285
1288
 
                            else {
1286
-
                                let ge = drop(eS.name, 4)
1287
-
                                let al = if (contains(ge, "XXL"))
1288
-
                                    then dropRight(ge, 3)
1289
-
                                    else if (contains(ge, "XL"))
1290
-
                                        then dropRight(ge, 2)
1291
-
                                        else dropRight(ge, 1)
1289
+
                                let gf = drop(eT.name, 4)
1290
+
                                let al = if (contains(gf, "XXL"))
1291
+
                                    then dropRight(gf, 3)
1292
+
                                    else if (contains(gf, "XL"))
1293
+
                                        then dropRight(gf, 2)
1294
+
                                        else dropRight(gf, 1)
1292
1295
 
                                if (!(isDefined(parseInt(al))))
1293
-
                                    then throw(("Cannot parse land number from " + eS.name))
1296
+
                                    then throw(("Cannot parse land number from " + eT.name))
1294
1297
 
                                    else {
1295
-
                                        let aR = toBase58String(ap)
1296
-
                                        let eT = aB(aR)
1297
-
                                        if (isDefined(getInteger(eT)))
1298
-
                                            then throw((("NFT " + eS.name) + " is already staked"))
1298
+
                                        let aD = toBase58String(an)
1299
+
                                        let eU = ar(aD)
1300
+
                                        if (isDefined(getInteger(eU)))
1301
+
                                            then throw((("NFT " + eT.name) + " is already staked"))
1299
1302
 
                                            else {
1300
-
                                                let eW = split(eS.description, "_")
1301
-
                                                let ck = cq(eW[bb])
1302
-
                                                let eH = cs(eW[ba])
1303
-
                                                let bZ = cp(ck, (eH / m), 1)
1304
-
                                                let eI = valueOrElse(getInteger(aH(N, aR)), if (valueOrElse(getBoolean(aF(aR)), false))
1305
-
                                                    then eH
1303
+
                                                let eX = split(eT.description, "_")
1304
+
                                                let cl = cr(eX[ba])
1305
+
                                                let eI = ct(eX[aZ])
1306
+
                                                let ca = cq(cl, (eI / m), 1)
1307
+
                                                let eJ = valueOrElse(getInteger(ax(N, aD)), if (valueOrElse(getBoolean(av(aD)), false))
1308
+
                                                    then eI
1306
1309
 
                                                    else 0)
1307
-
                                                let fP = getString(aV(Q))
1308
-
                                                let fK = if (isDefined(fP))
1309
-
                                                    then split_51C(value(fP), "_")
1310
+
                                                let fQ = getString(aF(Q))
1311
+
                                                let fL = if (isDefined(fQ))
1312
+
                                                    then split_51C(value(fQ), "_")
1310
1313
 
                                                    else nil
1311
-
                                                if (containsElement(fK, aR))
1312
-
                                                    then throw(("Your staked lands already contain " + aR))
1313
-
                                                    else [IntegerEntry(eT, lastBlock.timestamp), IntegerEntry(aL(i, aR, Q), lastBlock.timestamp), StringEntry(aV(Q), makeString_11C((fK :+ aR), "_")), StringEntry(ao(aR), Q), StringEntry(aN(al), Q), IntegerEntry(aJ(N, aR, Q), eI), StringEntry(aU(), bZ), gc]
1314
+
                                                if (containsElement(fL, aD))
1315
+
                                                    then throw(("Your staked lands already contain " + aD))
1316
+
                                                    else [IntegerEntry(eU, lastBlock.timestamp), IntegerEntry(aA(i, aD, Q), lastBlock.timestamp), StringEntry(aF(Q), makeString_11C((fL :+ aD), "_")), StringEntry(am(aD), Q), StringEntry(aE(al), Q), IntegerEntry(az(N, aD, Q), eJ), StringEntry(aT(), ca), gd]
1314
1317
 
                                                }
1315
1318
 
                                        }
1316
1319
 
                                }
1320
1323
 
1321
1324
 
1322
1325
 
1323
-
@Callable(co)
1324
-
func unstakeLand (eN) = {
1325
-
    let gc = fZ(co)
1326
-
    if ((size(co.payments) != 0))
1326
+
@Callable(cp)
1327
+
func unstakeLand (eO) = {
1328
+
    let gd = ga(cp)
1329
+
    if ((size(cp.payments) != 0))
1327
1330
 
        then throw("No payments required")
1328
1331
 
        else {
1329
-
            let ai = toString(co.caller)
1330
-
            let eY = eL(ai, bu, eN)
1331
-
            let aR = eY._2
1332
-
            let fO = aV(ai)
1333
-
            let ck = cq(eY._3[bb])
1334
-
            let eH = cs(eY._3[ba])
1335
-
            let bZ = cp(ck, (eH / m), -1)
1336
-
            let fr = fk(ai, aR, eH, bu)
1337
-
            let fK = split_51C(valueOrElse(getString(fO), ""), "_")
1338
-
            let ad = indexOf(fK, aR)
1332
+
            let ai = toString(cp.caller)
1333
+
            let eZ = eM(ai, bt, eO)
1334
+
            let aD = eZ._2
1335
+
            let fP = aF(ai)
1336
+
            let cl = cr(eZ._3[ba])
1337
+
            let eI = ct(eZ._3[aZ])
1338
+
            let ca = cq(cl, (eI / m), -1)
1339
+
            let fs = fl(ai, aD, eI, bt)
1340
+
            let fL = split_51C(valueOrElse(getString(fP), ""), "_")
1341
+
            let ad = indexOf(fL, aD)
1339
1342
 
            if (!(isDefined(ad)))
1340
-
                then throw(("Your staked lands don't contain " + aR))
1343
+
                then throw(("Your staked lands don't contain " + aD))
1341
1344
 
                else {
1342
-
                    let da = value(blockInfoByHeight(height)).timestamp
1343
-
                    let gf = valueOrElse(getInteger(ag, aX(ai)), 0)
1344
-
                    if ((gf >= da))
1345
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(gf)))
1346
-
                        else [ScriptTransfer(co.caller, 1, fromBase58String(aR)), DeleteEntry(aB(aR)), DeleteEntry(aL(i, aR, ai)), StringEntry(aU(), bZ), StringEntry(fr._2, makeString(fr._3, ":")), if ((size(fK) > 1))
1347
-
                            then StringEntry(fO, makeString_11C(removeByIndex(fK, value(ad)), "_"))
1348
-
                            else DeleteEntry(fO), gc]
1345
+
                    let db = value(blockInfoByHeight(height)).timestamp
1346
+
                    let gg = valueOrElse(getInteger(ag, aV(ai)), 0)
1347
+
                    if ((gg >= db))
1348
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(gg)))
1349
+
                        else [ScriptTransfer(cp.caller, 1, fromBase58String(aD)), DeleteEntry(ar(aD)), DeleteEntry(aA(i, aD, ai)), StringEntry(aT(), ca), StringEntry(fs._2, makeString(fs._3, ":")), if ((size(fL) > 1))
1350
+
                            then StringEntry(fP, makeString_11C(removeByIndex(fL, value(ad)), "_"))
1351
+
                            else DeleteEntry(fP), gd]
1349
1352
 
                    }
1350
1353
 
            }
1351
1354
 
    }
1352
1355
 
1353
1356
 
1354
1357
 
1355
-
@Callable(co)
1358
+
@Callable(cp)
1356
1359
 
func stakeDuck () = {
1357
-
    let gc = fZ(co)
1358
-
    if ((size(co.payments) != 1))
1360
+
    let gd = ga(cp)
1361
+
    if ((size(cp.payments) != 1))
1359
1362
 
        then throw("Exactly one payment required")
1360
1363
 
        else {
1361
-
            let gd = value(co.payments[0])
1362
-
            let ap = value(gd.assetId)
1363
-
            let Q = toString(co.caller)
1364
-
            if ((gd.amount != 1))
1364
+
            let ge = value(cp.payments[0])
1365
+
            let an = value(ge.assetId)
1366
+
            let Q = toString(cp.caller)
1367
+
            if ((ge.amount != 1))
1365
1368
 
                then throw((("NFT " + j) + " token should be attached as payment"))
1366
1369
 
                else {
1367
-
                    let eS = value(assetInfo(ap))
1368
-
                    if (if ((eS.issuer != d))
1369
-
                        then (eS.issuer != e)
1370
+
                    let eT = value(assetInfo(an))
1371
+
                    if (if ((eT.issuer != d))
1372
+
                        then (eT.issuer != e)
1370
1373
 
                        else false)
1371
1374
 
                        then throw((("Unknown issuer of " + j) + " token"))
1372
-
                        else if (!(contains(eS.name, j)))
1375
+
                        else if (!(contains(eT.name, j)))
1373
1376
 
                            then throw((("Only NFT " + j) + " tokens are accepted"))
1374
1377
 
                            else {
1375
-
                                let gg = toBase58String(ap)
1376
-
                                let eT = aB(gg)
1377
-
                                if (isDefined(getInteger(eT)))
1378
-
                                    then throw((("NFT " + eS.name) + " is already staked"))
1379
-
                                    else if (isDefined(getString(aK(Q))))
1380
-
                                        then throw(("You already staked one duck: " + eS.name))
1378
+
                                let gh = toBase58String(an)
1379
+
                                let eU = ar(gh)
1380
+
                                if (isDefined(getInteger(eU)))
1381
+
                                    then throw((("NFT " + eT.name) + " is already staked"))
1382
+
                                    else if (isDefined(getString(aO(Q))))
1383
+
                                        then throw(("You already staked one duck: " + eT.name))
1381
1384
 
                                        else {
1382
-
                                            let gh = aS(gg)
1383
-
                                            let gi = getString(gh)
1384
-
                                            let dc = aO(gg)
1385
-
                                            let gj = getString(dc)
1386
-
                                            ([IntegerEntry(eT, lastBlock.timestamp), IntegerEntry(aL(j, toBase58String(ap), Q), lastBlock.timestamp), StringEntry(aA(gg), Q), StringEntry(aK(Q), gg)] ++ (if (isDefined(gi))
1385
+
                                            let gi = aR(gh)
1386
+
                                            let gj = getString(gi)
1387
+
                                            let dd = aP(gh)
1388
+
                                            let gk = getString(dd)
1389
+
                                            ([IntegerEntry(eU, lastBlock.timestamp), IntegerEntry(aA(j, toBase58String(an), Q), lastBlock.timestamp), StringEntry(aN(gh), Q), StringEntry(aO(Q), gh)] ++ (if (isDefined(gj))
1387
1390
 
                                                then nil
1388
-
                                                else ([StringEntry(gh, k)] ++ (if (isDefined(gj))
1391
+
                                                else ([StringEntry(gi, k)] ++ (if (isDefined(gk))
1389
1392
 
                                                    then nil
1390
-
                                                    else (([StringEntry(dc, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aT(gg), 100)) :+ gc)))))
1393
+
                                                    else (([StringEntry(dd, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aS(gh), 100)) :+ gd)))))
1391
1394
 
                                            }
1392
1395
 
                                }
1393
1396
 
                    }
1396
1399
 
1397
1400
 
1398
1401
 
1399
-
@Callable(co)
1400
-
func unstakeDuck (gg) = {
1401
-
    let gc = fZ(co)
1402
-
    if ((size(co.payments) != 0))
1402
+
@Callable(cp)
1403
+
func unstakeDuck (gh) = {
1404
+
    let gd = ga(cp)
1405
+
    if ((size(cp.payments) != 0))
1403
1406
 
        then throw("No payments required")
1404
1407
 
        else {
1405
-
            let ap = fromBase58String(gg)
1406
-
            let Q = toString(co.caller)
1407
-
            let eS = value(assetInfo(ap))
1408
-
            let eT = aB(toBase58String(ap))
1409
-
            if (!(isDefined(getInteger(eT))))
1410
-
                then throw((("NFT " + eS.name) + " is not staked"))
1411
-
                else if (!(isDefined(getString(aK(Q)))))
1412
-
                    then throw((("The duck " + eS.name) + " is not staked"))
1408
+
            let an = fromBase58String(gh)
1409
+
            let Q = toString(cp.caller)
1410
+
            let eT = value(assetInfo(an))
1411
+
            let eU = ar(toBase58String(an))
1412
+
            if (!(isDefined(getInteger(eU))))
1413
+
                then throw((("NFT " + eT.name) + " is not staked"))
1414
+
                else if (!(isDefined(getString(aO(Q)))))
1415
+
                    then throw((("The duck " + eT.name) + " is not staked"))
1413
1416
 
                    else {
1414
-
                        let eV = valueOrErrorMessage(getString(aA(toBase58String(ap))), (("NFT " + eS.name) + " is orphaned"))
1415
-
                        if ((eV != Q))
1417
+
                        let eW = valueOrErrorMessage(getString(aN(toBase58String(an))), (("NFT " + eT.name) + " is orphaned"))
1418
+
                        if ((eW != Q))
1416
1419
 
                            then throw("Staked NFT is not yours")
1417
1420
 
                            else {
1418
-
                                let eB = aT(gg)
1419
-
                                let gk = valueOrElse(getInteger(eB), 100)
1420
-
                                if ((100 > gk))
1421
+
                                let eC = aS(gh)
1422
+
                                let gl = valueOrElse(getInteger(eC), 100)
1423
+
                                if ((100 > gl))
1421
1424
 
                                    then throw("Please heal your duck before unstaking")
1422
-
                                    else [ScriptTransfer(co.caller, 1, ap), DeleteEntry(eT), DeleteEntry(eB), DeleteEntry(aS(gg)), DeleteEntry(aA(gg)), DeleteEntry(aL(j, gg, Q)), DeleteEntry(aK(Q)), gc]
1425
+
                                    else [ScriptTransfer(cp.caller, 1, an), DeleteEntry(eU), DeleteEntry(eC), DeleteEntry(aR(gh)), DeleteEntry(aN(gh)), DeleteEntry(aA(j, gh, Q)), DeleteEntry(aO(Q)), gd]
1423
1426
 
                                }
1424
1427
 
                        }
1425
1428
 
            }
1427
1430
 
1428
1431
 
1429
1432
 
1430
-
@Callable(co)
1431
-
func claimRes (cv,gl) = {
1432
-
    let gc = fZ(co)
1433
-
    if ((size(co.payments) != 0))
1433
+
@Callable(cp)
1434
+
func claimRes (cw,gm) = {
1435
+
    let gd = ga(cp)
1436
+
    if ((size(cp.payments) != 0))
1434
1437
 
        then throw("No payments required")
1435
1438
 
        else {
1436
-
            let ai = toString(co.originCaller)
1437
-
            let ch = eX(ai, cv, bu, gl)
1438
-
            $Tuple2((((ch._1 :+ StringEntry(ch._2, makeString(ch._3, ":"))) :+ StringEntry(ch._4, makeString(ch._5, ":"))) :+ gc), ch._3[bh])
1439
+
            let ai = toString(cp.originCaller)
1440
+
            let ci = eY(ai, cw, bt, gm)
1441
+
            $Tuple2((((ci._1 :+ StringEntry(ci._2, makeString(ci._3, ":"))) :+ StringEntry(ci._4, makeString(ci._5, ":"))) :+ gd), ci._3[bg])
1439
1442
 
            }
1440
1443
 
    }
1441
1444
 
1442
1445
 
1443
1446
 
1444
-
@Callable(co)
1445
-
func claimResToWH (cv,gl) = {
1446
-
    let gc = fZ(co)
1447
-
    if ((size(co.payments) != 0))
1447
+
@Callable(cp)
1448
+
func claimResToWH (cw,gm) = {
1449
+
    let gd = ga(cp)
1450
+
    if ((size(cp.payments) != 0))
1448
1451
 
        then throw("No payments required")
1449
1452
 
        else {
1450
-
            let ai = toString(co.originCaller)
1451
-
            let ch = eX(ai, cv, bt, gl)
1452
-
            $Tuple2((((ch._1 :+ StringEntry(ch._2, makeString(ch._3, ":"))) :+ StringEntry(ch._4, makeString(ch._5, ":"))) :+ gc), ch._5[bl])
1453
+
            let ai = toString(cp.originCaller)
1454
+
            let ci = eY(ai, cw, bs, gm)
1455
+
            $Tuple2((((ci._1 :+ StringEntry(ci._2, makeString(ci._3, ":"))) :+ StringEntry(ci._4, makeString(ci._5, ":"))) :+ gd), ci._5[bk])
1453
1456
 
            }
1454
1457
 
    }
1455
1458
 
1456
1459
 
1457
1460
 
1458
-
@Callable(co)
1459
-
func flight (et,eu) = {
1460
-
    let gc = fZ(co)
1461
-
    if (!(sigVerify_8Kb(et, eu, g)))
1461
+
@Callable(cp)
1462
+
func flight (eu,ev) = {
1463
+
    let gd = ga(cp)
1464
+
    if (!(sigVerify_8Kb(eu, ev, g)))
1462
1465
 
        then throw("signature does not match")
1463
-
        else if ((size(co.payments) != 0))
1466
+
        else if ((size(cp.payments) != 0))
1464
1467
 
            then throw("No payments required")
1465
1468
 
            else {
1466
-
                let dg = split(toUtf8String(et), ";")
1467
-
                let gm = split(dg[0], "|")
1468
-
                let ev = split(gm[bw], "_")
1469
-
                let ew = parseIntValue(ev[0])
1470
-
                let ex = parseIntValue(ev[1])
1471
-
                let gn = split(dg[1], ":")
1472
-
                let go = gn[0]
1473
-
                let eA = parseIntValue(gm[bB])
1474
-
                if (if ((eA > (lastBlock.timestamp + t)))
1469
+
                let dh = split(toUtf8String(eu), ";")
1470
+
                let gn = split(dh[0], "|")
1471
+
                let ew = split(gn[bv], "_")
1472
+
                let ex = parseIntValue(ew[0])
1473
+
                let ey = parseIntValue(ew[1])
1474
+
                let go = split(dh[1], ":")
1475
+
                let gp = go[0]
1476
+
                let eB = parseIntValue(gn[bA])
1477
+
                if (if ((eB > (lastBlock.timestamp + t)))
1475
1478
 
                    then true
1476
-
                    else ((lastBlock.timestamp - t) > eA))
1479
+
                    else ((lastBlock.timestamp - t) > eB))
1477
1480
 
                    then throw("signature outdated")
1478
1481
 
                    else {
1479
-
                        let gp = gn[1]
1480
-
                        let gq = valueOrElse(getString(ah(toString(co.originCaller))), "")
1481
-
                        if ((gq != gp))
1482
-
                            then throw(((("Tx ids don't match! In state: " + gq) + ", in msg: ") + gp))
1482
+
                        let gq = go[1]
1483
+
                        let gr = valueOrElse(getString(ah(toString(cp.originCaller))), "")
1484
+
                        if ((gr != gq))
1485
+
                            then throw(((("Tx ids don't match! In state: " + gr) + ", in msg: ") + gq))
1483
1486
 
                            else {
1484
-
                                let aY = toString(co.caller)
1485
-
                                let aP = valueOrErrorMessage(getString(aK(aY)), "You don't have a duck staked")
1486
-
                                let eB = aT(aP)
1487
-
                                let eC = valueOrElse(getInteger(eB), 100)
1488
-
                                if ((eC != ew))
1489
-
                                    then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eB), 100))) + " from state does not match one from flight log=") + toString(ew)))
1490
-
                                    else if ((0 >= ew))
1487
+
                                let aW = toString(cp.caller)
1488
+
                                let aQ = valueOrErrorMessage(getString(aO(aW)), "You don't have a duck staked")
1489
+
                                let eC = aS(aQ)
1490
+
                                let eD = valueOrElse(getInteger(eC), 100)
1491
+
                                if ((eD != ex))
1492
+
                                    then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eC), 100))) + " from state does not match one from flight log=") + toString(ex)))
1493
+
                                    else if ((0 >= ex))
1491
1494
 
                                        then throw("You can't fly with zero health")
1492
1495
 
                                        else {
1493
-
                                            let gh = aS(aP)
1494
-
                                            let eP = valueOrElse(getString(gh), k)
1495
-
                                            if ((go == eP))
1496
+
                                            let gi = aR(aQ)
1497
+
                                            let eQ = valueOrElse(getString(gi), k)
1498
+
                                            if ((gp == eQ))
1496
1499
 
                                                then throw("You can't fly to the same location")
1497
1500
 
                                                else {
1498
-
                                                    let gr = if ((size(gm) > bC))
1499
-
                                                        then gm[bC]
1501
+
                                                    let gs = if ((size(gn) > bB))
1502
+
                                                        then gn[bB]
1500
1503
 
                                                        else ""
1501
-
                                                    let gs = if (if ((ex > 0))
1502
-
                                                        then (gr == "$")
1504
+
                                                    let gt = if (if ((ey > 0))
1505
+
                                                        then (gs == "$")
1503
1506
 
                                                        else false)
1504
-
                                                        then bH(invoke(ae, "sendUsdtPrize", [aY], nil))
1507
+
                                                        then bI(invoke(ae, "sendUsdtPrize", [aW], nil))
1505
1508
 
                                                        else 0
1506
-
                                                    $Tuple2([StringEntry(gh, if ((ex > 0))
1507
-
                                                        then go
1508
-
                                                        else eP), IntegerEntry(eB, ex), gc], gs)
1509
+
                                                    $Tuple2([StringEntry(gi, if ((ey > 0))
1510
+
                                                        then gp
1511
+
                                                        else eQ), IntegerEntry(eC, ey), gd], gt)
1509
1512
 
                                                    }
1510
1513
 
                                            }
1511
1514
 
                                }
1515
1518
 
1516
1519
 
1517
1520
 
1518
-
@Callable(co)
1519
-
func setHealth (gk,aP) = {
1520
-
    let gc = fZ(co)
1521
-
    if (if ((0 > gk))
1521
+
@Callable(cp)
1522
+
func setHealth (gl,aQ) = {
1523
+
    let gd = ga(cp)
1524
+
    if (if ((0 > gl))
1522
1525
 
        then true
1523
-
        else (gk > 100))
1526
+
        else (gl > 100))
1524
1527
 
        then throw("HP should be within 0..100")
1525
-
        else [IntegerEntry(aT(aP), gk), gc]
1528
+
        else [IntegerEntry(aS(aQ), gl), gd]
1526
1529
 
    }
1527
1530
 
1528
1531
 
1529
1532
 
1530
-
@Callable(co)
1531
-
func heal (gt,cv) = {
1532
-
    let gc = fZ(co)
1533
-
    if (if ((0 > gt))
1533
+
@Callable(cp)
1534
+
func heal (gu,cw) = {
1535
+
    let gd = ga(cp)
1536
+
    if (if ((0 > gu))
1534
1537
 
        then true
1535
-
        else (gt >= l))
1536
-
        then throw(("Unknown material: " + toString(gt)))
1537
-
        else if ((0 >= cv))
1538
-
            then throw(("Amount should be positive! " + toString(cv)))
1538
+
        else (gu >= l))
1539
+
        then throw(("Unknown material: " + toString(gu)))
1540
+
        else if ((0 >= cw))
1541
+
            then throw(("Amount should be positive! " + toString(cw)))
1539
1542
 
            else {
1540
-
                let aP = valueOrErrorMessage(getString(aK(toString(co.caller))), "You don't have a duck staked")
1541
-
                let eB = aT(aP)
1542
-
                let gu = valueOrElse(getInteger(eB), 100)
1543
-
                if ((gu >= 100))
1543
+
                let aQ = valueOrErrorMessage(getString(aO(toString(cp.caller))), "You don't have a duck staked")
1544
+
                let eC = aS(aQ)
1545
+
                let gv = valueOrElse(getInteger(eC), 100)
1546
+
                if ((gv >= 100))
1544
1547
 
                    then throw("HP should be < 100 to heal")
1545
1548
 
                    else {
1546
-
                        let dc = aO(aP)
1547
-
                        let dO = db(dc)
1548
-
                        let eD = split(dO[bi], "_")
1549
-
                        let gv = parseIntValue(eD[gt])
1550
-
                        let gw = min([(cv / h), (100 - gu)])
1551
-
                        let gx = (gw * h)
1552
-
                        if ((gx > gv))
1553
-
                            then throw(((((("You need " + toString(gx)) + " of ") + L[gt]) + " to heal, but you backpack contains ") + toString(gv)))
1549
+
                        let dd = aP(aQ)
1550
+
                        let dP = dc(dd)
1551
+
                        let eE = split(dP[bh], "_")
1552
+
                        let gw = parseIntValue(eE[gu])
1553
+
                        let gx = min([(cw / h), (100 - gv)])
1554
+
                        let gy = (gx * h)
1555
+
                        if ((gy > gw))
1556
+
                            then throw(((((("You need " + toString(gy)) + " of ") + L[gu]) + " to heal, but you backpack contains ") + toString(gw)))
1554
1557
 
                            else {
1555
-
                                let eE = ct(eD, gt, gx)
1556
-
[IntegerEntry(eB, (gu + gw)), StringEntry(dc, makeString([dO[bg], dO[bh], eE, dO[bj]], ":")), gc]
1558
+
                                let eF = cu(eE, gu, gy)
1559
+
[IntegerEntry(eC, (gv + gx)), StringEntry(dd, makeString([dP[bf], dP[bg], eF, dP[bi]], ":")), gd]
1557
1560
 
                                }
1558
1561
 
                        }
1559
1562
 
                }
1561
1564
 
1562
1565
 
1563
1566
 
1564
-
@Callable(co)
1565
-
func updateBackpack (aP,gy) = {
1566
-
    let gc = fZ(co)
1567
-
    if ((co.caller != af))
1567
+
@Callable(cp)
1568
+
func updateBackpack (aQ,gz) = {
1569
+
    let gd = ga(cp)
1570
+
    if ((cp.caller != af))
1568
1571
 
        then throw("permission denied")
1569
-
        else $Tuple2([StringEntry(aO(aP), gy), gc], gy)
1572
+
        else $Tuple2([StringEntry(aP(aQ), gz), gd], gz)
1570
1573
 
    }
1571
1574
 
1572
1575
 
1573
1576
 
1574
-
@Callable(co)
1577
+
@Callable(cp)
1575
1578
 
func buySLand () = {
1576
-
    let gc = fZ(co)
1577
-
    if ((size(co.payments) != 1))
1579
+
    let gd = ga(cp)
1580
+
    if ((size(cp.payments) != 1))
1578
1581
 
        then throw("Exactly one payment required")
1579
1582
 
        else {
1580
-
            let gd = value(co.payments[0])
1581
-
            if ((gd.assetId != b))
1583
+
            let ge = value(cp.payments[0])
1584
+
            if ((ge.assetId != b))
1582
1585
 
                then throw("Allowed USDT payment only!")
1583
-
                else if ((gd.amount != B))
1586
+
                else if ((ge.amount != B))
1584
1587
 
                    then throw(("Payment attached should be " + toString(B)))
1585
1588
 
                    else {
1586
-
                        let ch = ek(co.caller, co.transactionId)
1587
-
                        $Tuple2(((ch._1 :+ ScriptTransfer(af, gd.amount, b)) :+ gc), ch._2._1)
1589
+
                        let ci = el(cp.caller, cp.transactionId)
1590
+
                        $Tuple2(((ci._1 :+ ScriptTransfer(af, ge.amount, b)) :+ gd), ci._2._1)
1588
1591
 
                        }
1589
1592
 
            }
1590
1593
 
    }
1591
1594
 
1592
1595
 
1593
1596
 
1594
-
@Callable(co)
1595
-
func expedition (et,eu) = {
1596
-
    let gc = fZ(co)
1597
-
    if ((size(co.payments) != 0))
1597
+
@Callable(cp)
1598
+
func expedition (eu,ev) = {
1599
+
    let gd = ga(cp)
1600
+
    if ((size(cp.payments) != 0))
1598
1601
 
        then throw("No payments required")
1599
1602
 
        else {
1600
-
            let ch = es(true, co.caller, co.transactionId, et, eu)
1601
-
            $Tuple2((ch._1 :+ gc), ch._2)
1603
+
            let ci = et(true, cp.caller, cp.transactionId, eu, ev)
1604
+
            $Tuple2((ci._1 :+ gd), ci._2)
1602
1605
 
            }
1603
1606
 
    }
1604
1607
 
1605
1608
 
1606
1609
 
1607
-
@Callable(co)
1608
-
func upgradeInfra (aR) = {
1609
-
    let gc = fZ(co)
1610
-
    if ((size(co.payments) != 0))
1610
+
@Callable(cp)
1611
+
func upgradeInfra (aD) = {
1612
+
    let gd = ga(cp)
1613
+
    if ((size(cp.payments) != 0))
1611
1614
 
        then throw("No payments required")
1612
1615
 
        else {
1613
-
            let ch = fl(true, co.caller, 0, aR)
1614
-
            $Tuple2((ch._1 :+ gc), ch._2)
1616
+
            let ci = fm(true, cp.caller, 0, aD)
1617
+
            $Tuple2((ci._1 :+ gd), ci._2)
1615
1618
 
            }
1616
1619
 
    }
1617
1620
 
1618
1621
 
1619
1622
 
1620
-
@Callable(co)
1621
-
func upgradeInfraUsdt (aR) = if ((co.caller != this))
1623
+
@Callable(cp)
1624
+
func upgradeInfraUsdt (aD) = if ((cp.caller != this))
1622
1625
 
    then throw("Permission denied")
1623
1626
 
    else {
1624
-
        let gc = fZ(co)
1625
-
        if ((size(co.payments) != 1))
1627
+
        let gd = ga(cp)
1628
+
        if ((size(cp.payments) != 1))
1626
1629
 
            then throw("Exactly one payment required")
1627
1630
 
            else {
1628
-
                let gd = value(co.payments[0])
1629
-
                if ((gd.assetId != b))
1631
+
                let ge = value(cp.payments[0])
1632
+
                if ((ge.assetId != b))
1630
1633
 
                    then throw("Allowed USDT payment only!")
1631
1634
 
                    else {
1632
-
                        let ch = fl(false, co.caller, gd.amount, aR)
1633
-
                        $Tuple2(((ch._1 :+ ScriptTransfer(af, gd.amount, b)) :+ gc), ch._2)
1635
+
                        let ci = fm(false, cp.caller, ge.amount, aD)
1636
+
                        $Tuple2(((ci._1 :+ ScriptTransfer(af, ge.amount, b)) :+ gd), ci._2)
1634
1637
 
                        }
1635
1638
 
                }
1636
1639
 
        }
1637
1640
 
1638
1641
 
1639
1642
 
1640
-
@Callable(co)
1641
-
func activateArtifact (gz,aR) = {
1642
-
    let gc = fZ(co)
1643
-
    if ((size(co.payments) != 0))
1643
+
@Callable(cp)
1644
+
func activateArtifact (gA,aD) = {
1645
+
    let gd = ga(cp)
1646
+
    if ((size(cp.payments) != 0))
1644
1647
 
        then throw("No payments required")
1645
1648
 
        else {
1646
-
            let ch = {
1647
-
                let c = gz
1649
+
            let ci = {
1650
+
                let c = gA
1648
1651
 
                if (("PRESALE" == c))
1649
-
                    then fy(toString(co.caller), aR)
1652
+
                    then fz(toString(cp.caller), aD)
1650
1653
 
                    else throw("Unknown artifact")
1651
1654
 
                }
1652
-
            (ch :+ gc)
1655
+
            (ci :+ gd)
1653
1656
 
            }
1654
1657
 
    }
1655
1658
 
1656
1659
 
1657
1660
 
1658
-
@Callable(co)
1659
-
func mergeLands (fD) = {
1660
-
    let gc = fZ(co)
1661
-
    if ((size(co.payments) != 0))
1661
+
@Callable(cp)
1662
+
func mergeLands (fE) = {
1663
+
    let gd = ga(cp)
1664
+
    if ((size(cp.payments) != 0))
1662
1665
 
        then throw("No payments required")
1663
1666
 
        else {
1664
-
            let ch = fX(true, toString(co.caller), 0, fD, co.transactionId)
1665
-
            $Tuple2((ch._1 :+ gc), ch._2)
1667
+
            let ci = fY(true, toString(cp.caller), 0, fE, cp.transactionId)
1668
+
            $Tuple2((ci._1 :+ gd), ci._2)
1666
1669
 
            }
1667
1670
 
    }
1668
1671
 
1669
1672
 
1670
1673
 
1671
-
@Callable(co)
1672
-
func mergeLandsUsdt (fD) = {
1673
-
    let gc = fZ(co)
1674
-
    if ((size(co.payments) != 1))
1674
+
@Callable(cp)
1675
+
func mergeLandsUsdt (fE) = {
1676
+
    let gd = ga(cp)
1677
+
    if ((size(cp.payments) != 1))
1675
1678
 
        then throw("Exactly one payment required")
1676
1679
 
        else {
1677
-
            let gd = value(co.payments[0])
1678
-
            if ((gd.assetId != b))
1680
+
            let ge = value(cp.payments[0])
1681
+
            if ((ge.assetId != b))
1679
1682
 
                then throw("Allowed USDT payment only!")
1680
1683
 
                else {
1681
-
                    let ch = fX(false, toString(co.caller), gd.amount, fD, co.transactionId)
1682
-
                    $Tuple2(((ch._1 :+ ScriptTransfer(af, gd.amount, b)) :+ gc), ch._2)
1684
+
                    let ci = fY(false, toString(cp.caller), ge.amount, fE, cp.transactionId)
1685
+
                    $Tuple2(((ci._1 :+ ScriptTransfer(af, ge.amount, b)) :+ gd), ci._2)
1683
1686
 
                    }
1684
1687
 
            }
1685
1688
 
    }
1686
1689
 
1687
1690
 
1688
1691
 
1689
-
@Callable(co)
1690
-
func cargoExchange (gA,aR) = {
1691
-
    let gc = fZ(co)
1692
-
    if ((size(co.payments) != 0))
1692
+
@Callable(cp)
1693
+
func cargoExchange (gB,aD) = {
1694
+
    let gd = ga(cp)
1695
+
    if ((size(cp.payments) != 0))
1693
1696
 
        then throw("No payments required")
1694
1697
 
        else {
1695
-
            let dN = split_4C(gA, ":")
1696
-
            let ai = toString(co.originCaller)
1697
-
            let eS = value(assetInfo(fromBase58String(aR)))
1698
-
            let eT = aB(aR)
1699
-
            if (!(isDefined(getInteger(eT))))
1700
-
                then throw((eS.name + " is not staked"))
1698
+
            let dO = split_4C(gB, ":")
1699
+
            let ai = toString(cp.originCaller)
1700
+
            let eT = value(assetInfo(fromBase58String(aD)))
1701
+
            let eU = ar(aD)
1702
+
            if (!(isDefined(getInteger(eU))))
1703
+
                then throw((eT.name + " is not staked"))
1701
1704
 
                else {
1702
-
                    let eV = valueOrErrorMessage(getString(ao(aR)), (("NFT " + eS.name) + " is orphaned"))
1703
-
                    if ((eV != ai))
1705
+
                    let eW = valueOrErrorMessage(getString(am(aD)), (("NFT " + eT.name) + " is orphaned"))
1706
+
                    if ((eW != ai))
1704
1707
 
                        then throw((i + " is not yours"))
1705
1708
 
                        else {
1706
-
                            let dy = (cs(split(eS.description, "_")[ba]) / m)
1707
-
                            let dz = valueOrElse(getInteger(aC(aR)), 0)
1708
-
                            let aP = valueOrErrorMessage(getString(aK(ai)), "You don't have a duck staked")
1709
-
                            let eP = valueOrElse(getString(aS(aP)), k)
1710
-
                            let eQ = split(value(eP), "_")
1711
-
                            if ((eQ[be] != "L"))
1712
-
                                then throw((("Duck location type is " + eQ[be]) + ", but should be L"))
1713
-
                                else if ((eQ[bf] != aR))
1714
-
                                    then throw(("Duck should be on the land " + aR))
1709
+
                            let dz = (ct(split(eT.description, "_")[aZ]) / m)
1710
+
                            let dA = valueOrElse(getInteger(as(aD)), 0)
1711
+
                            let aQ = valueOrErrorMessage(getString(aO(ai)), "You don't have a duck staked")
1712
+
                            let eQ = valueOrElse(getString(aR(aQ)), k)
1713
+
                            let eR = split(value(eQ), "_")
1714
+
                            if ((eR[bd] != "L"))
1715
+
                                then throw((("Duck location type is " + eR[bd]) + ", but should be L"))
1716
+
                                else if ((eR[be] != aD))
1717
+
                                    then throw(("Duck should be on the land " + aD))
1715
1718
 
                                    else {
1716
-
                                        let dx = aQ(aR)
1717
-
                                        let di = dw(dx, dy, dz)
1718
-
                                        let dc = aO(aP)
1719
-
                                        let dO = db(dc)
1720
-
                                        let ch = dM(dN, di, dO)
1721
-
                                        let dF = split(di[bo], "_")
1722
-
                                        let fi = (parseIntValue(dF[bq]) + ch._7)
1723
-
                                        let fj = (parseIntValue(dF[br]) - ch._7)
1724
-
[StringEntry(dc, makeString_2C([dO[bg], ch._4, ch._5, ch._6], ":")), StringEntry(dx, makeString_2C([di[bk], ch._1, ch._2, ch._3, makeString([dF[bp], toString(fi), toString(fj), dF[bs]], "_")], ":")), gc]
1719
+
                                        let dy = aC(aD)
1720
+
                                        let dj = dx(dy, dz, dA)
1721
+
                                        let dd = aP(aQ)
1722
+
                                        let dP = dc(dd)
1723
+
                                        let ci = dN(dO, dj, dP)
1724
+
                                        let dG = split(dj[bn], "_")
1725
+
                                        let fj = (parseIntValue(dG[bp]) + ci._7)
1726
+
                                        let fk = (parseIntValue(dG[bq]) - ci._7)
1727
+
[StringEntry(dd, makeString_2C([dP[bf], ci._4, ci._5, ci._6], ":")), StringEntry(dy, makeString_2C([dj[bj], ci._1, ci._2, ci._3, makeString([dG[bo], toString(fj), toString(fk), dG[br]], "_")], ":")), gd]
1725
1728
 
                                        }
1726
1729
 
                            }
1727
1730
 
                    }
1730
1733
 
1731
1734
 
1732
1735
 
1733
-
@Callable(co)
1734
-
func saveWarehouse (dB,aR) = {
1735
-
    let gc = fZ(co)
1736
-
    if ((co.caller != af))
1736
+
@Callable(cp)
1737
+
func saveWarehouse (dC,aD) = {
1738
+
    let gd = ga(cp)
1739
+
    if ((cp.caller != af))
1737
1740
 
        then throw("Access denied")
1738
1741
 
        else {
1739
-
            let dx = aQ(aR)
1740
-
            let dC = split_4C(dB, ":")
1741
-
            if ((size(dC) != 5))
1742
+
            let dy = aC(aD)
1743
+
            let dD = split_4C(dC, ":")
1744
+
            if ((size(dD) != 5))
1742
1745
 
                then throw("warehouse string should contain 4 ':' separators")
1743
1746
 
                else {
1744
-
                    let gB = split(dC[bo], "_")[bp]
1745
-
                    let fi = dh(dC)
1746
-
                    let gC = de(dC[bk])
1747
-
                    let fj = ((gC - parseIntValue(gB)) - fi)
1748
-
                    let gD = makeString_2C([dC[bk], dC[bl], dC[bm], dC[bn], makeString([gB, toString(fi), toString(fj), toString(gC)], "_")], ":")
1749
-
                    $Tuple2([StringEntry(dx, gD), gc], gD)
1747
+
                    let gC = split(dD[bn], "_")[bo]
1748
+
                    let fj = di(dD)
1749
+
                    let gD = df(dD[bj])
1750
+
                    let fk = ((gD - parseIntValue(gC)) - fj)
1751
+
                    let gE = makeString_2C([dD[bj], dD[bk], dD[bl], dD[bm], makeString([gC, toString(fj), toString(fk), toString(gD)], "_")], ":")
1752
+
                    $Tuple2([StringEntry(dy, gE), gd], gE)
1750
1753
 
                    }
1751
1754
 
            }
1752
1755
 
    }
1753
1756
 
1754
1757
 
1755
1758
 
1756
-
@Callable(co)
1757
-
func replaceBooleanArtifact (aR) = if ((co.caller != ae))
1759
+
@Callable(cp)
1760
+
func replaceBooleanArtifact (aD) = if ((cp.caller != ae))
1758
1761
 
    then throw("Access denied")
1759
1762
 
    else {
1760
-
        let gE = aF(aR)
1761
-
        let gF = aH(N, aR)
1762
-
        let gG = getBoolean(gE)
1763
-
        if (isDefined(gG))
1763
+
        let gF = av(aD)
1764
+
        let gG = ax(N, aD)
1765
+
        let gH = getBoolean(gF)
1766
+
        if (isDefined(gH))
1764
1767
 
            then {
1765
-
                let eW = split(value(assetInfo(fromBase58String(aR))).description, "_")
1766
-
                let eH = cs(eW[ba])
1767
-
                let eI = valueOrElse(getInteger(gF), eH)
1768
-
                let eV = getString(ao(aR))
1769
-
                let gH = if (isDefined(eV))
1770
-
                    then [IntegerEntry(aJ(N, aR, value(eV)), eI), DeleteEntry(aG(aR, value(eV)))]
1768
+
                let eX = split(value(assetInfo(fromBase58String(aD))).description, "_")
1769
+
                let eI = ct(eX[aZ])
1770
+
                let eJ = valueOrElse(getInteger(gG), eI)
1771
+
                let eW = getString(am(aD))
1772
+
                let gI = if (isDefined(eW))
1773
+
                    then [IntegerEntry(az(N, aD, value(eW)), eJ), DeleteEntry(aw(aD, value(eW)))]
1771
1774
 
                    else nil
1772
-
                if (value(gG))
1773
-
                    then $Tuple2(((gH :+ IntegerEntry(gF, eI)) :+ DeleteEntry(gE)), 2)
1774
-
                    else $Tuple2([DeleteEntry(gE)], 1)
1775
+
                if (value(gH))
1776
+
                    then $Tuple2(((gI :+ IntegerEntry(gG, eJ)) :+ DeleteEntry(gF)), 2)
1777
+
                    else $Tuple2([DeleteEntry(gF)], 1)
1775
1778
 
                }
1776
1779
 
            else $Tuple2(nil, 0)
1777
1780
 
        }
1778
1781
 
1779
1782
 
1780
1783
 
1781
-
@Callable(co)
1782
-
func setCustomName (ap,fM,aI) = {
1783
-
    let gc = fZ(co)
1784
-
    if ((size(co.payments) != 1))
1784
+
@Callable(cp)
1785
+
func fixWarehouseFormat (aD) = if ((cp.caller != ae))
1786
+
    then throw("Access denied")
1787
+
    else {
1788
+
        let dy = aC(aD)
1789
+
        let eT = value(assetInfo(fromBase58String(aD)))
1790
+
        let dz = (ct(split(eT.description, "_")[aZ]) / m)
1791
+
        let dA = valueOrElse(getInteger(as(aD)), 0)
1792
+
        let dC = dx(dy, dz, dA)
1793
+
        let gJ = valueOrElse(getString(af, aX(aD)), "0@0_0@0_0@0_0@0_0@0_0@0:0@0_0@0_0@0_0@0_0@0_0@0:")
1794
+
        nil
1795
+
        }
1796
+
1797
+
1798
+
1799
+
@Callable(cp)
1800
+
func setCustomName (an,fN,ay) = {
1801
+
    let gd = ga(cp)
1802
+
    if ((size(cp.payments) != 1))
1785
1803
 
        then throw("Exactly one payment required")
1786
1804
 
        else {
1787
-
            let gd = value(co.payments[0])
1788
-
            if ((gd.assetId != b))
1805
+
            let ge = value(cp.payments[0])
1806
+
            if ((ge.assetId != b))
1789
1807
 
                then throw("Allowed USDT payment only!")
1790
-
                else if ((gd.amount != w))
1808
+
                else if ((ge.amount != w))
1791
1809
 
                    then throw(("Payment should be " + toString(w)))
1792
-
                    else if (contains(fM, "__"))
1793
-
                        then throw(("Name should not contain '__': " + fM))
1794
-
                        else if ((size(fM) > x))
1810
+
                    else if (contains(fN, "__"))
1811
+
                        then throw(("Name should not contain '__': " + fN))
1812
+
                        else if ((size(fN) > x))
1795
1813
 
                            then throw(("Name too long, maxLength=" + toString(x)))
1796
1814
 
                            else {
1797
-
                                let ai = toString(co.originCaller)
1798
-
                                let gI = {
1799
-
                                    let c = aI
1815
+
                                let ai = toString(cp.originCaller)
1816
+
                                let gK = {
1817
+
                                    let c = ay
1800
1818
 
                                    if (("ACCOUNT" == c))
1801
1819
 
                                        then {
1802
-
                                            let gJ = aw(fM)
1803
-
                                            let gK = getString(gJ)
1804
-
                                            if (isDefined(gK))
1805
-
                                                then throw(("Name already registered: " + fM))
1806
-
                                                else [StringEntry(as(ai), fM), StringEntry(gJ, ai)]
1820
+
                                            let gL = aJ(fN)
1821
+
                                            let gM = getString(gL)
1822
+
                                            if (isDefined(gM))
1823
+
                                                then throw(("Name already registered: " + fN))
1824
+
                                                else [StringEntry(aH(ai), fN), StringEntry(gL, ai)]
1807
1825
 
                                            }
1808
1826
 
                                        else if (("LAND" == c))
1809
1827
 
                                            then {
1810
-
                                                let eS = value(assetInfo(fromBase58String(ap)))
1811
-
                                                let eT = aB(ap)
1812
-
                                                if (!(isDefined(getInteger(eT))))
1813
-
                                                    then throw((eS.name + " is not staked"))
1828
+
                                                let eT = value(assetInfo(fromBase58String(an)))
1829
+
                                                let eU = ar(an)
1830
+
                                                if (!(isDefined(getInteger(eU))))
1831
+
                                                    then throw((eT.name + " is not staked"))
1814
1832
 
                                                    else {
1815
-
                                                        let eV = valueOrErrorMessage(getString(ao(ap)), (("NFT " + eS.name) + " is orphaned"))
1816
-
                                                        if ((eV != ai))
1833
+
                                                        let eW = valueOrErrorMessage(getString(am(an)), (("NFT " + eT.name) + " is orphaned"))
1834
+
                                                        if ((eW != ai))
1817
1835
 
                                                            then throw((i + " is not yours"))
1818
1836
 
                                                            else {
1819
-
                                                                let gJ = at(fM)
1820
-
                                                                let gK = getString(gJ)
1821
-
                                                                if (isDefined(gK))
1822
-
                                                                    then throw(("Name already registered: " + fM))
1823
-
                                                                    else [StringEntry(aq(ap), fM), StringEntry(gJ, ap)]
1837
+
                                                                let gL = ap(fN)
1838
+
                                                                let gM = getString(gL)
1839
+
                                                                if (isDefined(gM))
1840
+
                                                                    then throw(("Name already registered: " + fN))
1841
+
                                                                    else [StringEntry(ao(an), fN), StringEntry(gL, an)]
1824
1842
 
                                                                }
1825
1843
 
                                                        }
1826
1844
 
                                                }
1827
1845
 
                                            else if (("DUCK" == c))
1828
1846
 
                                                then {
1829
-
                                                    let eS = value(assetInfo(fromBase58String(ap)))
1830
-
                                                    let eT = aB(ap)
1831
-
                                                    if (if (!(isDefined(getInteger(eT))))
1847
+
                                                    let eT = value(assetInfo(fromBase58String(an)))
1848
+
                                                    let eU = ar(an)
1849
+
                                                    if (if (!(isDefined(getInteger(eU))))
1832
1850
 
                                                        then true
1833
-
                                                        else !(isDefined(getString(aK(ai)))))
1834
-
                                                        then throw((eS.name + " is not staked"))
1851
+
                                                        else !(isDefined(getString(aO(ai)))))
1852
+
                                                        then throw((eT.name + " is not staked"))
1835
1853
 
                                                        else {
1836
-
                                                            let eV = valueOrErrorMessage(getString(aA(ap)), (("NFT " + eS.name) + " is orphaned"))
1837
-
                                                            if ((eV != ai))
1854
+
                                                            let eW = valueOrErrorMessage(getString(aN(an)), (("NFT " + eT.name) + " is orphaned"))
1855
+
                                                            if ((eW != ai))
1838
1856
 
                                                                then throw((j + " is not yours"))
1839
1857
 
                                                                else {
1840
-
                                                                    let gJ = av(fM)
1841
-
                                                                    let gK = getString(gJ)
1842
-
                                                                    if (isDefined(gK))
1843
-
                                                                        then throw(("Name already registered: " + fM))
1844
-
                                                                        else [StringEntry(ar(ap), fM), StringEntry(gJ, ap)]
1858
+
                                                                    let gL = aI(fN)
1859
+
                                                                    let gM = getString(gL)
1860
+
                                                                    if (isDefined(gM))
1861
+
                                                                        then throw(("Name already registered: " + fN))
1862
+
                                                                        else [StringEntry(aG(an), fN), StringEntry(gL, an)]
1845
1863
 
                                                                    }
1846
1864
 
                                                            }
1847
1865
 
                                                    }
1848
1866
 
                                                else throw("Unknown entity type")
1849
1867
 
                                    }
1850
-
                                $Tuple2(((gI :+ ScriptTransfer(af, gd.amount, b)) :+ gc), 0)
1868
+
                                $Tuple2(((gK :+ ScriptTransfer(af, ge.amount, b)) :+ gd), 0)
1851
1869
 
                                }
1852
1870
 
            }
1853
1871
 
    }
1854
1872
 
1855
1873
 
1856
1874
 
1857
-
@Callable(co)
1858
-
func setReferrals (gL,gM) = if ((co.callerPublicKey != g))
1875
+
@Callable(cp)
1876
+
func setReferrals (gN,gO) = if ((cp.callerPublicKey != g))
1859
1877
 
    then throw("Permission denied")
1860
1878
 
    else {
1861
-
        let gc = fZ(co)
1862
-
        if ((size(co.payments) != 0))
1879
+
        let gd = ga(cp)
1880
+
        if ((size(cp.payments) != 0))
1863
1881
 
            then throw("No payments required")
1864
-
            else if (!(isDefined(addressFromString(gL))))
1865
-
                then throw(("Invalid address: " + gL))
1866
-
                else if (!(isDefined(addressFromString(gM))))
1867
-
                    then throw(("Invalid address: " + gM))
1882
+
            else if (!(isDefined(addressFromString(gN))))
1883
+
                then throw(("Invalid address: " + gN))
1884
+
                else if (!(isDefined(addressFromString(gO))))
1885
+
                    then throw(("Invalid address: " + gO))
1868
1886
 
                    else {
1869
-
                        let gN = az()
1870
-
                        let gO = getString(gN)
1871
-
                        let gP = if (isDefined(gO))
1872
-
                            then split_4C(value(gO), "_")
1887
+
                        let gP = aM()
1888
+
                        let gQ = getString(gP)
1889
+
                        let gR = if (isDefined(gQ))
1890
+
                            then split_4C(value(gQ), "_")
1873
1891
 
                            else nil
1874
-
                        if (containsElement(gP, gM))
1875
-
                            then throw((gM + " is not newbie (already has referrals)"))
1892
+
                        if (containsElement(gR, gO))
1893
+
                            then throw((gO + " is not newbie (already has referrals)"))
1876
1894
 
                            else {
1877
-
                                let gQ = ax(gM)
1878
-
                                let gR = getString(gQ)
1879
-
                                if (if (isDefined(gR))
1880
-
                                    then isDefined(addressFromString(value(gR)))
1895
+
                                let gS = aK(gO)
1896
+
                                let gT = getString(gS)
1897
+
                                if (if (isDefined(gT))
1898
+
                                    then isDefined(addressFromString(value(gT)))
1881
1899
 
                                    else false)
1882
-
                                    then throw(((gM + " already has refBy: ") + value(gR)))
1900
+
                                    then throw(((gO + " already has refBy: ") + value(gT)))
1883
1901
 
                                    else {
1884
-
                                        let gS = ay(gL)
1885
-
                                        let gT = getString(gS)
1886
-
                                        let gU = if (isDefined(gT))
1887
-
                                            then split_4C(value(gT), "_")
1902
+
                                        let gU = aL(gN)
1903
+
                                        let gV = getString(gU)
1904
+
                                        let gW = if (isDefined(gV))
1905
+
                                            then split_4C(value(gV), "_")
1888
1906
 
                                            else nil
1889
-
                                        if (containsElement(gU, gM))
1890
-
                                            then throw((((gL + " already contains ") + gM) + " within referrals"))
1907
+
                                        if (containsElement(gW, gO))
1908
+
                                            then throw((((gN + " already contains ") + gO) + " within referrals"))
1891
1909
 
                                            else {
1892
-
                                                let gV = makeString_2C((gU :+ gM), "_")
1893
-
                                                let gW = makeString_2C((gP :+ gL), "_")
1894
-
                                                $Tuple2([StringEntry(gQ, gL), StringEntry(gS, gV), StringEntry(gN, gW), gc], 0)
1910
+
                                                let gX = makeString_2C((gW :+ gO), "_")
1911
+
                                                let gY = makeString_2C((gR :+ gN), "_")
1912
+
                                                $Tuple2([StringEntry(gS, gN), StringEntry(gU, gX), StringEntry(gP, gY), gd], 0)
1895
1913
 
                                                }
1896
1914
 
                                        }
1897
1915
 
                                }
1900
1918
 
1901
1919
 
1902
1920
 
1903
-
@Callable(co)
1904
-
func splitByGlobalWeightsREADONLY (cv) = $Tuple2(nil, bY(cv))
1921
+
@Callable(cp)
1922
+
func splitByGlobalWeightsREADONLY (cw) = $Tuple2(nil, bZ(cw))
1905
1923
 
1906
1924
 
1907
1925
 
1908
-
@Callable(co)
1909
-
func splitByGlobalAndLocalWeightsREADONLY (gX,gY,cr) = {
1910
-
    let ck = cq(cr)
1911
-
    $Tuple2(nil, $Tuple2(bY(gX), bJ(gY, ck)))
1926
+
@Callable(cp)
1927
+
func splitByGlobalAndLocalWeightsREADONLY (gZ,ha,cs) = {
1928
+
    let cl = cr(cs)
1929
+
    $Tuple2(nil, $Tuple2(bZ(gZ), bK(ha, cl)))
1912
1930
 
    }
1913
1931
 
1914
1932
 
1915
1933
 
1916
-
@Callable(co)
1917
-
func getBackpackREADONLY (aP) = $Tuple2(nil, makeString(db(aO(aP)), ":"))
1934
+
@Callable(cp)
1935
+
func getBackpackREADONLY (aQ) = $Tuple2(nil, makeString(dc(aP(aQ)), ":"))
1918
1936
 
1919
1937
 
1920
1938
 
1921
-
@Callable(co)
1922
-
func getWarehouseREADONLY (aR) = {
1923
-
    let eS = value(assetInfo(fromBase58String(aR)))
1924
-
    let dy = (cs(split(eS.description, "_")[ba]) / m)
1925
-
    let dz = valueOrElse(getInteger(aC(aR)), 0)
1926
-
    $Tuple2(nil, makeString_2C(dw(aQ(aR), dy, dz), ":"))
1939
+
@Callable(cp)
1940
+
func getWarehouseREADONLY (aD) = {
1941
+
    let eT = value(assetInfo(fromBase58String(aD)))
1942
+
    let dz = (ct(split(eT.description, "_")[aZ]) / m)
1943
+
    let dA = valueOrElse(getInteger(as(aD)), 0)
1944
+
    $Tuple2(nil, makeString_2C(dx(aC(aD), dz, dA), ":"))
1927
1945
 
    }
1928
1946
 
1929
1947
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = take(drop(this.bytes, 1), 1)
5
5
 
6
6
 
let b = {
7
7
 
    let c = a
8
8
 
    if ((base58'2W' == c))
9
9
 
        then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
10
10
 
        else if ((base58'2T' == c))
11
11
 
            then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
12
12
 
            else throw("Unknown chain")
13
13
 
    }
14
14
 
15
15
 
let d = {
16
16
 
    let c = a
17
17
 
    if ((base58'2W' == c))
18
18
 
        then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
19
19
 
        else if ((base58'2T' == c))
20
20
 
            then this
21
21
 
            else throw("Unknown chain")
22
22
 
    }
23
23
 
24
24
 
let e = {
25
25
 
    let c = a
26
26
 
    if ((base58'2W' == c))
27
27
 
        then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
28
28
 
        else if ((base58'2T' == c))
29
29
 
            then this
30
30
 
            else throw("Unknown chain")
31
31
 
    }
32
32
 
33
33
 
let f = {
34
34
 
    let c = a
35
35
 
    if ((base58'2W' == c))
36
36
 
        then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
37
37
 
        else if ((base58'2T' == c))
38
38
 
            then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
39
39
 
            else throw("Unknown chain")
40
40
 
    }
41
41
 
42
42
 
let g = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
43
43
 
44
44
 
let h = 10000
45
45
 
46
46
 
let i = "LAND"
47
47
 
48
48
 
let j = "DUCK"
49
49
 
50
50
 
let k = "Africa_F_Africa"
51
51
 
52
52
 
let l = 6
53
53
 
54
54
 
let m = 25
55
55
 
56
56
 
let n = 100
57
57
 
58
58
 
let o = 225
59
59
 
60
60
 
let p = 400
61
61
 
62
62
 
let q = 625
63
63
 
64
64
 
let r = 3456000
65
65
 
66
66
 
let s = 86400000
67
67
 
68
68
 
let t = 300000
69
69
 
70
70
 
let u = 39637
71
71
 
72
72
 
let v = 10000000000
73
73
 
74
74
 
let w = 5000000
75
75
 
76
76
 
let x = 50
77
77
 
78
78
 
let y = {
79
79
 
    let c = a
80
80
 
    if ((base58'2W' == c))
81
81
 
        then 10000000000
82
82
 
        else if ((base58'2T' == c))
83
83
 
            then 100000000
84
84
 
            else throw("Unknown chain")
85
85
 
    }
86
86
 
87
87
 
let z = {
88
88
 
    let c = a
89
89
 
    if ((base58'2W' == c))
90
90
 
        then 10000000
91
91
 
        else if ((base58'2T' == c))
92
92
 
            then 10000000
93
93
 
            else throw("Unknown chain")
94
94
 
    }
95
95
 
96
96
 
let A = {
97
97
 
    let c = a
98
98
 
    if ((base58'2W' == c))
99
99
 
        then 252289527462
100
100
 
        else if ((base58'2T' == c))
101
101
 
            then 2522895274
102
102
 
            else throw("Unknown chain")
103
103
 
    }
104
104
 
105
105
 
let B = {
106
106
 
    let c = a
107
107
 
    if ((base58'2W' == c))
108
108
 
        then 250000000
109
109
 
        else if ((base58'2T' == c))
110
110
 
            then 250000000
111
111
 
            else throw("Unknown chain")
112
112
 
    }
113
113
 
114
114
 
let C = "__"
115
115
 
116
116
 
let D = 1000000
117
117
 
118
118
 
let E = 100000000
119
119
 
120
120
 
let F = toBigInt(5)
121
121
 
122
122
 
let G = toBigInt(20)
123
123
 
124
124
 
let H = toBigInt((20 * 20))
125
125
 
126
126
 
let I = toBigInt(((20 * 20) * 20))
127
127
 
128
128
 
let J = toBigInt((((20 * 20) * 20) * 20))
129
129
 
130
130
 
let K = toBigInt(((((20 * 20) * 20) * 20) * 20))
131
131
 
132
132
 
let L = ["Fuel", "Metal", "Plank", "Glass", "Plastic", "Protein"]
133
133
 
134
134
 
let M = ["Asia", "Europe", "Americas", "Oceania", "Africa"]
135
135
 
136
136
 
let N = "PRESALE"
137
137
 
138
138
 
let O = 500
139
139
 
140
140
 
func P (Q,R) = valueOrErrorMessage(getString(Q, R), makeString(["mandatory ", toString(Q), ".", R, " is not defined"], ""))
141
141
 
142
142
 
143
143
 
func S (R,T) = valueOrElse(getInteger(this, R), T)
144
144
 
145
145
 
146
146
 
let U = 1
147
147
 
148
148
 
let V = 2
149
149
 
150
150
 
let W = 3
151
151
 
152
152
 
func X () = "%s__restConfig"
153
153
 
154
154
 
155
155
 
func Y () = "%s__restAddr"
156
156
 
157
157
 
158
158
 
func Z (aa) = split_4C(P(aa, X()), C)
159
159
 
160
160
 
161
161
 
func ab (ac,ad) = valueOrErrorMessage(addressFromString(ac[ad]), ("Rest cfg doesn't contain address at index " + toString(ad)))
162
162
 
163
163
 
164
164
 
let ae = addressFromStringValue(valueOrElse(getString(this, Y()), f))
165
165
 
166
166
 
let ac = Z(ae)
167
167
 
168
168
 
let af = ab(ac, V)
169
169
 
170
170
 
let ag = ab(ac, W)
171
171
 
172
172
 
func ah (ai) = ("lastTxIdByUser_" + ai)
173
173
 
174
174
 
175
175
 
func aj () = "nextLandNum"
176
176
 
177
177
 
178
178
 
func ak (al) = ("landToAsset_" + al)
179
179
 
180
180
 
181
-
func am (al,an) = ((i + al) + an)
181
+
func am (an) = ("nftOwner_" + an)
182
182
 
183
183
 
184
-
func ao (ap) = ("nftOwner_" + ap)
184
+
func ao (an) = ("landCustomNameByAssetId_" + an)
185
185
 
186
186
 
187
-
func aq (ap) = ("landCustomNameByAssetId_" + ap)
187
+
func ap (aq) = ("landByCustomName_" + aq)
188
188
 
189
189
 
190
-
func ar (ap) = ("duckCustomNameByAssetId_" + ap)
190
+
func ar (an) = ("stakedTime_" + an)
191
191
 
192
192
 
193
-
func as (ai) = ("accountCustomNameByAddr_" + ai)
193
+
func as (an) = ("infraLevel_" + an)
194
194
 
195
195
 
196
-
func at (au) = ("landByCustomName_" + au)
196
+
func at (an,au) = ((("infraLevelByAssetIdAndOwner_" + an) + "_") + au)
197
197
 
198
198
 
199
-
func av (au) = ("duckByCustomName_" + au)
199
+
func av (an) = ("presaleArtActivated_" + an)
200
200
 
201
201
 
202
-
func aw (au) = ("accountByCustomName_" + au)
202
+
func aw (an,au) = ((("presaleArtActivatedByAssetIdAndOwner_" + an) + "_") + au)
203
203
 
204
204
 
205
-
func ax (ai) = ("accRefBy_" + ai)
205
+
func ax (ay,an) = makeString(["landArtStatus", ay, an], "_")
206
206
 
207
207
 
208
-
func ay (ai) = ("accReferrals_" + ai)
208
+
func az (ay,an,au) = makeString(["landArtStatusByTypeAssetIdAndOwner", ay, an, au], "_")
209
209
 
210
210
 
211
-
func az () = "oldiesList"
211
+
func aA (aB,an,au) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aB) + "_") + an) + "_") + au)
212
212
 
213
213
 
214
-
func aA (ap) = ("duckOwner_" + ap)
214
+
func aC (aD) = ("wareHouse_" + aD)
215
215
 
216
216
 
217
-
func aB (ap) = ("stakedTime_" + ap)
217
+
func aE (al) = ("landOwner_" + al)
218
218
 
219
219
 
220
-
func aC (ap) = ("infraLevel_" + ap)
220
+
func aF (au) = ("stakedLandsByOwner_" + au)
221
221
 
222
222
 
223
-
func aD (ap,aE) = ((("infraLevelByAssetIdAndOwner_" + ap) + "_") + aE)
223
+
func aG (an) = ("duckCustomNameByAssetId_" + an)
224
224
 
225
225
 
226
-
func aF (ap) = ("presaleArtActivated_" + ap)
226
+
func aH (ai) = ("accountCustomNameByAddr_" + ai)
227
227
 
228
228
 
229
-
func aG (ap,aE) = ((("presaleArtActivatedByAssetIdAndOwner_" + ap) + "_") + aE)
229
+
func aI (aq) = ("duckByCustomName_" + aq)
230
230
 
231
231
 
232
-
func aH (aI,ap) = makeString(["landArtStatus", aI, ap], "_")
232
+
func aJ (aq) = ("accountByCustomName_" + aq)
233
233
 
234
234
 
235
-
func aJ (aI,ap,aE) = makeString(["landArtStatusByTypeAssetIdAndOwner", aI, ap, aE], "_")
235
+
func aK (ai) = ("accRefBy_" + ai)
236
236
 
237
237
 
238
-
func aK (aE) = ("stakedDuckByOwner_" + aE)
238
+
func aL (ai) = ("accReferrals_" + ai)
239
239
 
240
240
 
241
-
func aL (aM,ap,aE) = ((((("stakedTimeByTypeAssetIdAndOwner_" + aM) + "_") + ap) + "_") + aE)
241
+
func aM () = "oldiesList"
242
242
 
243
243
 
244
-
func aN (al) = ("landOwner_" + al)
244
+
func aN (an) = ("duckOwner_" + an)
245
245
 
246
246
 
247
-
func aO (aP) = ("backPack_" + aP)
247
+
func aO (au) = ("stakedDuckByOwner_" + au)
248
248
 
249
249
 
250
-
func aQ (aR) = ("wareHouse_" + aR)
250
+
func aP (aQ) = ("backPack_" + aQ)
251
251
 
252
252
 
253
-
func aS (aP) = ("duckLocation_" + aP)
253
+
func aR (aQ) = ("duckLocation_" + aQ)
254
254
 
255
255
 
256
-
func aT (aP) = ("duckHealth_" + aP)
256
+
func aS (aQ) = ("duckHealth_" + aQ)
257
257
 
258
258
 
259
-
func aU () = "resTypesProportions"
259
+
func aT () = "resTypesProportions"
260
260
 
261
261
 
262
-
func aV (aE) = ("stakedLandsByOwner_" + aE)
262
+
func aU () = "contractsBlocked"
263
263
 
264
264
 
265
-
func aW () = "contractsBlocked"
265
+
func aV (aW) = ("%s%s__userGwlReleaseTime__" + aW)
266
266
 
267
267
 
268
-
func aX (aY) = ("%s%s__userGwlReleaseTime__" + aY)
268
+
func aX (aD) = ("landOrder_" + aD)
269
269
 
270
270
 
271
-
let aZ = 0
271
+
let aY = 0
272
272
 
273
-
let ba = 1
273
+
let aZ = 1
274
274
 
275
-
let bb = 2
275
+
let ba = 2
276
276
 
277
-
let bc = 3
277
+
let bb = 3
278
278
 
279
-
let bd = 0
279
+
let bc = 0
280
280
 
281
-
let be = 1
281
+
let bd = 1
282
282
 
283
-
let bf = 2
283
+
let be = 2
284
284
 
285
-
let bg = 0
285
+
let bf = 0
286
286
 
287
-
let bh = 1
287
+
let bg = 1
288
288
 
289
-
let bi = 2
289
+
let bh = 2
290
290
 
291
-
let bj = 3
291
+
let bi = 3
292
292
 
293
-
let bk = 0
293
+
let bj = 0
294
294
 
295
-
let bl = 1
295
+
let bk = 1
296
296
 
297
-
let bm = 2
297
+
let bl = 2
298
298
 
299
-
let bn = 3
299
+
let bm = 3
300
300
 
301
-
let bo = 4
301
+
let bn = 4
302
302
 
303
-
let bp = 0
303
+
let bo = 0
304
304
 
305
-
let bq = 1
305
+
let bp = 1
306
306
 
307
-
let br = 2
307
+
let bq = 2
308
308
 
309
-
let bs = 3
309
+
let br = 3
310
310
 
311
-
let bt = 0
311
+
let bs = 0
312
312
 
313
-
let bu = 1
313
+
let bt = 1
314
314
 
315
-
let bv = 2
315
+
let bu = 2
316
316
 
317
-
let bw = 0
317
+
let bv = 0
318
318
 
319
-
let bx = 1
319
+
let bw = 1
320
320
 
321
-
let by = 2
321
+
let bx = 2
322
322
 
323
-
let bz = 3
323
+
let by = 3
324
324
 
325
-
let bA = 4
325
+
let bz = 4
326
326
 
327
-
let bB = 5
327
+
let bA = 5
328
328
 
329
-
let bC = 6
329
+
let bB = 6
330
330
 
331
-
let bD = [10, 10, 10, 100, 100, 100, 10, 10, 10, 100, 100, 100, 10, 10, 10]
331
+
let bC = [10, 10, 10, 100, 100, 100, 10, 10, 10, 100, 100, 100, 10, 10, 10]
332
332
 
333
-
func bE (bF) = {
334
-
    let c = bF
333
+
func bD (al,bE) = ((i + al) + bE)
334
+
335
+
336
+
func bF (bG) = {
337
+
    let c = bG
335
338
 
    if ($isInstanceOf(c, "String"))
336
339
 
        then {
337
-
            let bG = c
338
-
            bG
340
+
            let bH = c
341
+
            bH
339
342
 
            }
340
343
 
        else throw("fail to cast into String")
341
344
 
    }
342
345
 
343
346
 
344
-
func bH (bF) = {
345
-
    let c = bF
347
+
func bI (bG) = {
348
+
    let c = bG
346
349
 
    if ($isInstanceOf(c, "Int"))
347
350
 
        then {
348
-
            let bI = c
349
-
            bI
351
+
            let bJ = c
352
+
            bJ
350
353
 
            }
351
354
 
        else throw("fail to cast into Int")
352
355
 
    }
353
356
 
354
357
 
355
-
func bJ (bK,bL) = {
356
-
    let bM = (((((bL[0] + bL[1]) + bL[2]) + bL[3]) + bL[4]) + bL[5])
357
-
    if ((0 >= bM))
358
+
func bK (bL,bM) = {
359
+
    let bN = (((((bM[0] + bM[1]) + bM[2]) + bM[3]) + bM[4]) + bM[5])
360
+
    if ((0 >= bN))
358
361
 
        then throw("Zero weights sum")
359
362
 
        else {
360
-
            let bN = fraction(bK, D, bM)
361
-
            func bO (bP,bQ) =             (bP :+ fraction(bQ, bN, D))
363
+
            let bO = fraction(bL, D, bN)
364
+
            func bP (bQ,bR) =             (bQ :+ fraction(bR, bO, D))
362
365
 
363
-
            let bR = bL
364
-
            let bS = size(bR)
365
-
            let bT = nil
366
-
            func bU (bV,bW) =             if ((bW >= bS))
367
-
                then bV
368
-
                else bO(bV, bR[bW])
366
+
            let bS = bM
367
+
            let bT = size(bS)
368
+
            let bU = nil
369
+
            func bV (bW,bX) =             if ((bX >= bT))
370
+
                then bW
371
+
                else bP(bW, bS[bX])
369
372
 
370
-
            func bX (bV,bW) =             if ((bW >= bS))
371
-
                then bV
373
+
            func bY (bW,bX) =             if ((bX >= bT))
374
+
                then bW
372
375
 
                else throw("List size exceeds 6")
373
376
 
374
-
            bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
377
+
            bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
375
378
 
            }
376
379
 
    }
377
380
 
378
381
 
379
-
func bY (bK) = {
380
-
    let bZ = split(value(getString(aU())), "_")
381
-
    if ((size(bZ) != l))
382
+
func bZ (bL) = {
383
+
    let ca = split(value(getString(aT())), "_")
384
+
    if ((size(ca) != l))
382
385
 
        then throw("Wrong proportions data")
383
386
 
        else {
384
-
            let ca = [parseIntValue(bZ[0]), parseIntValue(bZ[1]), parseIntValue(bZ[2]), parseIntValue(bZ[3]), parseIntValue(bZ[4]), parseIntValue(bZ[5])]
385
-
            bJ(bK, ca)
387
+
            let cb = [parseIntValue(ca[0]), parseIntValue(ca[1]), parseIntValue(ca[2]), parseIntValue(ca[3]), parseIntValue(ca[4]), parseIntValue(ca[5])]
388
+
            bK(bL, cb)
386
389
 
            }
387
390
 
    }
388
391
 
389
392
 
390
-
func cb (cc,cd,ce) = {
391
-
    let cf = bY(ce)
392
-
    func cg (bP,ad) =     {
393
-
        let ch = (parseIntValue(cd[ad]) - cf[ad])
394
-
        if ((0 > ch))
395
-
            then throw(((((("Not enough material idx=" + toString(ad)) + ", you have ") + cd[ad]) + ", but need ") + toString(cf[ad])))
396
-
            else (bP :+ toString(ch))
393
+
func cc (cd,ce,cf) = {
394
+
    let cg = bZ(cf)
395
+
    func ch (bQ,ad) =     {
396
+
        let ci = (parseIntValue(ce[ad]) - cg[ad])
397
+
        if ((0 > ci))
398
+
            then throw(((((("Not enough material idx=" + toString(ad)) + ", you have ") + ce[ad]) + ", but need ") + toString(cg[ad])))
399
+
            else (bQ :+ toString(ci))
397
400
 
        }
398
401
 
399
-
    if (cc)
402
+
    if (cd)
400
403
 
        then {
401
-
            let bR = [0, 1, 2, 3, 4, 5]
402
-
            let bS = size(bR)
403
-
            let bT = nil
404
-
            func bU (bV,bW) =             if ((bW >= bS))
405
-
                then bV
406
-
                else cg(bV, bR[bW])
404
+
            let bS = [0, 1, 2, 3, 4, 5]
405
+
            let bT = size(bS)
406
+
            let bU = nil
407
+
            func bV (bW,bX) =             if ((bX >= bT))
408
+
                then bW
409
+
                else ch(bW, bS[bX])
407
410
 
408
-
            func bX (bV,bW) =             if ((bW >= bS))
409
-
                then bV
411
+
            func bY (bW,bX) =             if ((bX >= bT))
412
+
                then bW
410
413
 
                else throw("List size exceeds 6")
411
414
 
412
-
            bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
415
+
            bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
413
416
 
            }
414
-
        else cd
417
+
        else ce
415
418
 
    }
416
419
 
417
420
 
418
-
func ci (cj,ck,cl,cm) = if ((size(cj) != l))
421
+
func cj (ck,cl,cm,cn) = if ((size(ck) != l))
419
422
 
    then throw("Wrong proportions data")
420
423
 
    else {
421
-
        func cn (bP,co) =         {
422
-
            let ch = (parseIntValue(cj[co]) + ((cm * ck[co]) * cl))
423
-
            if ((0 > ch))
424
-
                then throw(((((((("Panic! Pieces of type=" + toString(co)) + ", sign=") + toString(cm)) + ",  terrainCounts[i]=") + toString(ck[co])) + ", landSizeIndex=") + toString(cl)))
425
-
                else (bP :+ toString(ch))
424
+
        func co (bQ,cp) =         {
425
+
            let ci = (parseIntValue(ck[cp]) + ((cn * cl[cp]) * cm))
426
+
            if ((0 > ci))
427
+
                then throw(((((((("Panic! Pieces of type=" + toString(cp)) + ", sign=") + toString(cn)) + ",  terrainCounts[i]=") + toString(cl[cp])) + ", landSizeIndex=") + toString(cm)))
428
+
                else (bQ :+ toString(ci))
426
429
 
            }
427
430
 
428
-
        let ca = {
429
-
            let bR = [0, 1, 2, 3, 4, 5]
430
-
            let bS = size(bR)
431
-
            let bT = nil
432
-
            func bU (bV,bW) =             if ((bW >= bS))
433
-
                then bV
434
-
                else cn(bV, bR[bW])
431
+
        let cb = {
432
+
            let bS = [0, 1, 2, 3, 4, 5]
433
+
            let bT = size(bS)
434
+
            let bU = nil
435
+
            func bV (bW,bX) =             if ((bX >= bT))
436
+
                then bW
437
+
                else co(bW, bS[bX])
435
438
 
436
-
            func bX (bV,bW) =             if ((bW >= bS))
437
-
                then bV
439
+
            func bY (bW,bX) =             if ((bX >= bT))
440
+
                then bW
438
441
 
                else throw("List size exceeds 6")
439
442
 
440
-
            bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
443
+
            bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
441
444
 
            }
442
-
        makeString(ca, "_")
445
+
        makeString(cb, "_")
443
446
 
        }
444
447
 
445
448
 
446
-
func cp (ck,cl,cm) = {
447
-
    let cj = split(valueOrElse(getString(aU()), "0_0_0_0_0_0"), "_")
448
-
    ci(cj, ck, cl, cm)
449
+
func cq (cl,cm,cn) = {
450
+
    let ck = split(valueOrElse(getString(aT()), "0_0_0_0_0_0"), "_")
451
+
    cj(ck, cl, cm, cn)
449
452
 
    }
450
453
 
451
454
 
452
-
func cq (cr) = [(size(split(cr, "A")) - 1), (size(split(cr, "B")) - 1), (size(split(cr, "C")) - 1), (size(split(cr, "D")) - 1), (size(split(cr, "E")) - 1), (size(split(cr, "F")) - 1)]
455
+
func cr (cs) = [(size(split(cs, "A")) - 1), (size(split(cs, "B")) - 1), (size(split(cs, "C")) - 1), (size(split(cs, "D")) - 1), (size(split(cs, "E")) - 1), (size(split(cs, "F")) - 1)]
453
456
 
454
457
 
455
-
func cs (an) = {
456
-
    let c = an
458
+
func ct (bE) = {
459
+
    let c = bE
457
460
 
    if (("S" == c))
458
461
 
        then m
459
462
 
        else if (("M" == c))
460
463
 
            then n
461
464
 
            else if (("L" == c))
462
465
 
                then o
463
466
 
                else if (("XL" == c))
464
467
 
                    then p
465
468
 
                    else if (("XXL" == c))
466
469
 
                        then q
467
470
 
                        else throw("Unknown land size")
468
471
 
    }
469
472
 
470
473
 
471
-
func ct (cu,ad,cv) = {
472
-
    func cw (bP,co) =     (bP :+ (if ((co == ad))
473
-
        then toString((parseIntValue(cu[co]) - cv))
474
-
        else cu[co]))
474
+
func cu (cv,ad,cw) = {
475
+
    func cx (bQ,cp) =     (bQ :+ (if ((cp == ad))
476
+
        then toString((parseIntValue(cv[cp]) - cw))
477
+
        else cv[cp]))
475
478
 
476
-
    let ca = {
477
-
        let bR = [0, 1, 2, 3, 4, 5]
478
-
        let bS = size(bR)
479
-
        let bT = nil
480
-
        func bU (bV,bW) =         if ((bW >= bS))
481
-
            then bV
482
-
            else cw(bV, bR[bW])
479
+
    let cb = {
480
+
        let bS = [0, 1, 2, 3, 4, 5]
481
+
        let bT = size(bS)
482
+
        let bU = nil
483
+
        func bV (bW,bX) =         if ((bX >= bT))
484
+
            then bW
485
+
            else cx(bW, bS[bX])
483
486
 
484
-
        func bX (bV,bW) =         if ((bW >= bS))
485
-
            then bV
487
+
        func bY (bW,bX) =         if ((bX >= bT))
488
+
            then bW
486
489
 
            else throw("List size exceeds 6")
487
490
 
488
-
        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
491
+
        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
489
492
 
        }
490
-
    makeString(ca, "_")
493
+
    makeString(cb, "_")
491
494
 
    }
492
495
 
493
496
 
494
-
func cx (cy,ck,cz,cl,cA) = {
495
-
    func cB (bP,co) =     {
496
-
        let cC = ((fraction(cz, cA, s) * ck[co]) * cl)
497
-
        (bP :+ toString((parseIntValue(cy[co]) + cC)))
497
+
func cy (cz,cl,cA,cm,cB) = {
498
+
    func cC (bQ,cp) =     {
499
+
        let cD = ((fraction(cA, cB, s) * cl[cp]) * cm)
500
+
        (bQ :+ toString((parseIntValue(cz[cp]) + cD)))
498
501
 
        }
499
502
 
500
-
    let ca = {
501
-
        let bR = [0, 1, 2, 3, 4, 5]
502
-
        let bS = size(bR)
503
-
        let bT = nil
504
-
        func bU (bV,bW) =         if ((bW >= bS))
505
-
            then bV
506
-
            else cB(bV, bR[bW])
503
+
    let cb = {
504
+
        let bS = [0, 1, 2, 3, 4, 5]
505
+
        let bT = size(bS)
506
+
        let bU = nil
507
+
        func bV (bW,bX) =         if ((bX >= bT))
508
+
            then bW
509
+
            else cC(bW, bS[bX])
507
510
 
508
-
        func bX (bV,bW) =         if ((bW >= bS))
509
-
            then bV
511
+
        func bY (bW,bX) =         if ((bX >= bT))
512
+
            then bW
510
513
 
            else throw("List size exceeds 6")
511
514
 
512
-
        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
515
+
        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
513
516
 
        }
514
-
    makeString(ca, "_")
517
+
    makeString(cb, "_")
515
518
 
    }
516
519
 
517
520
 
518
-
func cD (ck,cz,cl,cA) = {
519
-
    func cB (bP,co) =     {
520
-
        let cC = ((fraction(cz, cA, s) * ck[co]) * cl)
521
-
        $Tuple2((bP._1 :+ cC), (bP._2 + cC))
521
+
func cE (cl,cA,cm,cB) = {
522
+
    func cC (bQ,cp) =     {
523
+
        let cD = ((fraction(cA, cB, s) * cl[cp]) * cm)
524
+
        $Tuple2((bQ._1 :+ cD), (bQ._2 + cD))
522
525
 
        }
523
526
 
524
-
    let bR = [0, 1, 2, 3, 4, 5]
525
-
    let bS = size(bR)
526
-
    let bT = $Tuple2(nil, 0)
527
-
    func bU (bV,bW) =     if ((bW >= bS))
528
-
        then bV
529
-
        else cB(bV, bR[bW])
527
+
    let bS = [0, 1, 2, 3, 4, 5]
528
+
    let bT = size(bS)
529
+
    let bU = $Tuple2(nil, 0)
530
+
    func bV (bW,bX) =     if ((bX >= bT))
531
+
        then bW
532
+
        else cC(bW, bS[bX])
530
533
 
531
-
    func bX (bV,bW) =     if ((bW >= bS))
532
-
        then bV
534
+
    func bY (bW,bX) =     if ((bX >= bT))
535
+
        then bW
533
536
 
        else throw("List size exceeds 6")
534
537
 
535
-
    bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
538
+
    bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
536
539
 
    }
537
540
 
538
541
 
539
-
func cE (cF,cG,cH,cI) = {
540
-
    let cJ = cH._1
541
-
    let cK = cH._2
542
-
    if ((cK == 0))
543
-
        then $Tuple2(makeString(cF, "_"), makeString(cG, "_"))
544
-
        else if ((cI >= cK))
542
+
func cF (cG,cH,cI,cJ) = {
543
+
    let cK = cI._1
544
+
    let cL = cI._2
545
+
    if ((cL == 0))
546
+
        then $Tuple2(makeString(cG, "_"), makeString(cH, "_"))
547
+
        else if ((cJ >= cL))
545
548
 
            then {
546
-
                func cL (bP,co) =                 (bP :+ toString((parseIntValue(cF[co]) + cJ[co])))
549
+
                func cM (bQ,cp) =                 (bQ :+ toString((parseIntValue(cG[cp]) + cK[cp])))
547
550
 
548
-
                let ca = {
549
-
                    let bR = [0, 1, 2, 3, 4, 5]
550
-
                    let bS = size(bR)
551
-
                    let bT = nil
552
-
                    func bU (bV,bW) =                     if ((bW >= bS))
553
-
                        then bV
554
-
                        else cL(bV, bR[bW])
551
+
                let cb = {
552
+
                    let bS = [0, 1, 2, 3, 4, 5]
553
+
                    let bT = size(bS)
554
+
                    let bU = nil
555
+
                    func bV (bW,bX) =                     if ((bX >= bT))
556
+
                        then bW
557
+
                        else cM(bW, bS[bX])
555
558
 
556
-
                    func bX (bV,bW) =                     if ((bW >= bS))
557
-
                        then bV
559
+
                    func bY (bW,bX) =                     if ((bX >= bT))
560
+
                        then bW
558
561
 
                        else throw("List size exceeds 6")
559
562
 
560
-
                    bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
563
+
                    bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
561
564
 
                    }
562
-
                $Tuple2(makeString(ca, "_"), makeString(cG, "_"))
565
+
                $Tuple2(makeString(cb, "_"), makeString(cH, "_"))
563
566
 
                }
564
567
 
            else {
565
-
                func cM (bP,co) =                 {
566
-
                    let cN = fraction(cJ[co], cI, cK)
567
-
                    $Tuple2((bP._1 :+ toString((parseIntValue(cF[co]) + cN))), (bP._2 :+ toString(((parseIntValue(cG[co]) + cJ[co]) - cN))))
568
+
                func cN (bQ,cp) =                 {
569
+
                    let cO = fraction(cK[cp], cJ, cL)
570
+
                    $Tuple2((bQ._1 :+ toString((parseIntValue(cG[cp]) + cO))), (bQ._2 :+ toString(((parseIntValue(cH[cp]) + cK[cp]) - cO))))
568
571
 
                    }
569
572
 
570
-
                let ca = {
571
-
                    let bR = [0, 1, 2, 3, 4, 5]
572
-
                    let bS = size(bR)
573
-
                    let bT = $Tuple2(nil, nil)
574
-
                    func bU (bV,bW) =                     if ((bW >= bS))
575
-
                        then bV
576
-
                        else cM(bV, bR[bW])
573
+
                let cb = {
574
+
                    let bS = [0, 1, 2, 3, 4, 5]
575
+
                    let bT = size(bS)
576
+
                    let bU = $Tuple2(nil, nil)
577
+
                    func bV (bW,bX) =                     if ((bX >= bT))
578
+
                        then bW
579
+
                        else cN(bW, bS[bX])
577
580
 
578
-
                    func bX (bV,bW) =                     if ((bW >= bS))
579
-
                        then bV
581
+
                    func bY (bW,bX) =                     if ((bX >= bT))
582
+
                        then bW
580
583
 
                        else throw("List size exceeds 6")
581
584
 
582
-
                    bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
585
+
                    bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
583
586
 
                    }
584
-
                $Tuple2(makeString(ca._1, "_"), makeString(ca._2, "_"))
587
+
                $Tuple2(makeString(cb._1, "_"), makeString(cb._2, "_"))
585
588
 
                }
586
589
 
    }
587
590
 
588
591
 
589
-
func cO (cP) = if ((cP >= toBigInt(0)))
590
-
    then cP
591
-
    else -(cP)
592
+
func cP (cQ) = if ((cQ >= toBigInt(0)))
593
+
    then cQ
594
+
    else -(cQ)
592
595
 
593
596
 
594
-
let cQ = [[1, 4, 9, 10, 15], [5, 8, 13, 14, 15], [6, 9, 14, 15, 16], [4, 7, 8, 13, 18], [1, 6, 7, 15, 19]]
597
+
let cR = [[1, 4, 9, 10, 15], [5, 8, 13, 14, 15], [6, 9, 14, 15, 16], [4, 7, 8, 13, 18], [1, 6, 7, 15, 19]]
595
598
 
596
-
func cR (bI,cS) = {
597
-
    let cT = toInt((bI % G))
598
-
    let cU = if ((cS[0] > cT))
599
+
func cS (bJ,cT) = {
600
+
    let cU = toInt((bJ % G))
601
+
    let cV = if ((cT[0] > cU))
599
602
 
        then "A"
600
-
        else if ((cS[1] > cT))
603
+
        else if ((cT[1] > cU))
601
604
 
            then "B"
602
-
            else if ((cS[2] > cT))
605
+
            else if ((cT[2] > cU))
603
606
 
                then "C"
604
-
                else if ((cS[3] > cT))
607
+
                else if ((cT[3] > cU))
605
608
 
                    then "D"
606
-
                    else if ((cS[4] > cT))
609
+
                    else if ((cT[4] > cU))
607
610
 
                        then "E"
608
611
 
                        else "F"
609
-
    cU
612
+
    cV
610
613
 
    }
611
614
 
612
615
 
613
-
func cV (cW,cX) = {
614
-
    let cY = cQ[cX]
615
-
    func cZ (bP,bQ) =     $Tuple2((((((bP._1 + cR(bP._2, cY)) + cR((bP._2 / G), cY)) + cR((bP._2 / H), cY)) + cR((bP._2 / I), cY)) + cR((bP._2 / J), cY)), (bP._2 / K))
616
+
func cW (cX,cY) = {
617
+
    let cZ = cR[cY]
618
+
    func da (bQ,bR) =     $Tuple2((((((bQ._1 + cS(bQ._2, cZ)) + cS((bQ._2 / G), cZ)) + cS((bQ._2 / H), cZ)) + cS((bQ._2 / I), cZ)) + cS((bQ._2 / J), cZ)), (bQ._2 / K))
616
619
 
617
-
    let da = {
618
-
        let bR = [1, 2, 3, 4, 5]
619
-
        let bS = size(bR)
620
-
        let bT = $Tuple2("", (cW / F))
621
-
        func bU (bV,bW) =         if ((bW >= bS))
622
-
            then bV
623
-
            else cZ(bV, bR[bW])
620
+
    let db = {
621
+
        let bS = [1, 2, 3, 4, 5]
622
+
        let bT = size(bS)
623
+
        let bU = $Tuple2("", (cX / F))
624
+
        func bV (bW,bX) =         if ((bX >= bT))
625
+
            then bW
626
+
            else da(bW, bS[bX])
624
627
 
625
-
        func bX (bV,bW) =         if ((bW >= bS))
626
-
            then bV
628
+
        func bY (bW,bX) =         if ((bX >= bT))
629
+
            then bW
627
630
 
            else throw("List size exceeds 5")
628
631
 
629
-
        bX(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5)
632
+
        bY(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5)
630
633
 
        }
631
-
    da._1
634
+
    db._1
632
635
 
    }
633
636
 
634
637
 
635
-
func db (dc) = {
636
-
    let dd = split(valueOrElse(getString(dc), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
637
-
[toString(valueOrElse(parseInt(dd[bg]), 0)), if ((size(split(dd[bh], "_")) == l))
638
-
        then dd[bh]
639
-
        else "0_0_0_0_0_0", if ((size(split(dd[bi], "_")) == l))
640
-
        then dd[bi]
641
-
        else "0_0_0_0_0_0", dd[bj]]
638
+
func dc (dd) = {
639
+
    let de = split(valueOrElse(getString(dd), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
640
+
[toString(valueOrElse(parseInt(de[bf]), 0)), if ((size(split(de[bg], "_")) == l))
641
+
        then de[bg]
642
+
        else "0_0_0_0_0_0", if ((size(split(de[bh], "_")) == l))
643
+
        then de[bh]
644
+
        else "0_0_0_0_0_0", de[bi]]
642
645
 
    }
643
646
 
644
647
 
645
-
func de (df) = {
646
-
    let dg = split(df, "_")
647
-
    ((v * (parseIntValue(dg[1]) + 1)) * parseIntValue(dg[0]))
648
+
func df (dg) = {
649
+
    let dh = split(dg, "_")
650
+
    ((v * (parseIntValue(dh[1]) + 1)) * parseIntValue(dh[0]))
648
651
 
    }
649
652
 
650
653
 
651
-
func dh (di) = {
652
-
    let dj = di[bn]
653
-
    func dk (bP,dl) =     (bP + parseIntValue(dl))
654
+
func di (dj) = {
655
+
    let dk = dj[bm]
656
+
    func dl (bQ,dm) =     (bQ + parseIntValue(dm))
654
657
 
655
-
    func dm (bP,dl) =     {
656
-
        let ad = bP._1
657
-
        let dn = bD[ad]
658
-
        let do = (((parseIntValue(dl) + dn) - 1) / dn)
659
-
        $Tuple2((ad + 1), (bP._2 + (do * E)))
658
+
    func dn (bQ,dm) =     {
659
+
        let ad = bQ._1
660
+
        let do = bC[ad]
661
+
        let dp = (((parseIntValue(dm) + do) - 1) / do)
662
+
        $Tuple2((ad + 1), (bQ._2 + (dp * E)))
660
663
 
        }
661
664
 
662
-
    let dp = {
663
-
        let bR = split(di[bl], "_")
664
-
        let bS = size(bR)
665
-
        let bT = 0
666
-
        func bU (bV,bW) =         if ((bW >= bS))
667
-
            then bV
668
-
            else dk(bV, bR[bW])
665
+
    let dq = {
666
+
        let bS = split(dj[bk], "_")
667
+
        let bT = size(bS)
668
+
        let bU = 0
669
+
        func bV (bW,bX) =         if ((bX >= bT))
670
+
            then bW
671
+
            else dl(bW, bS[bX])
669
672
 
670
-
        func bX (bV,bW) =         if ((bW >= bS))
671
-
            then bV
673
+
        func bY (bW,bX) =         if ((bX >= bT))
674
+
            then bW
672
675
 
            else throw("List size exceeds 6")
673
676
 
674
-
        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
677
+
        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
675
678
 
        }
676
-
    let dq = {
677
-
        let bR = split(di[bm], "_")
678
-
        let bS = size(bR)
679
-
        let bT = 0
680
-
        func dr (bV,bW) =         if ((bW >= bS))
681
-
            then bV
682
-
            else dk(bV, bR[bW])
679
+
    let dr = {
680
+
        let bS = split(dj[bl], "_")
681
+
        let bT = size(bS)
682
+
        let bU = 0
683
+
        func ds (bW,bX) =         if ((bX >= bT))
684
+
            then bW
685
+
            else dl(bW, bS[bX])
683
686
 
684
-
        func ds (bV,bW) =         if ((bW >= bS))
685
-
            then bV
687
+
        func dt (bW,bX) =         if ((bX >= bT))
688
+
            then bW
686
689
 
            else throw("List size exceeds 6")
687
690
 
688
-
        ds(dr(dr(dr(dr(dr(dr(bT, 0), 1), 2), 3), 4), 5), 6)
691
+
        dt(ds(ds(ds(ds(ds(ds(bU, 0), 1), 2), 3), 4), 5), 6)
689
692
 
        }
690
-
    let dt = if ((dj == ""))
693
+
    let du = if ((dk == ""))
691
694
 
        then 0
692
-
        else (        let bR = split_4C(dj, "_")
693
-
        let bS = size(bR)
694
-
        let bT = $Tuple2(0, 0)
695
-
        func du (bV,bW) =         if ((bW >= bS))
696
-
            then bV
697
-
            else dm(bV, bR[bW])
695
+
        else (        let bS = split_4C(dk, "_")
696
+
        let bT = size(bS)
697
+
        let bU = $Tuple2(0, 0)
698
+
        func dv (bW,bX) =         if ((bX >= bT))
699
+
            then bW
700
+
            else dn(bW, bS[bX])
698
701
 
699
-
        func dv (bV,bW) =         if ((bW >= bS))
700
-
            then bV
702
+
        func dw (bW,bX) =         if ((bX >= bT))
703
+
            then bW
701
704
 
            else throw("List size exceeds 50")
702
705
 
703
-
        dv(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(bT, 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
704
-
    ((dp + dq) + dt)
706
+
        dw(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(bU, 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
707
+
    ((dq + dr) + du)
705
708
 
    }
706
709
 
707
710
 
708
-
func dw (dx,dy,dz) = {
709
-
    let df = ((toString(dy) + "_") + toString(dz))
710
-
    let dA = de(df)
711
-
    let dB = valueOrElse(getString(dx), (df + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
712
-
    let dC = split_4C(dB, ":")
713
-
    let dD = dh(dC)
714
-
    let dE = if ((5 > size(dC)))
715
-
        then makeString(["0", toString(dD), toString((dA - dD)), toString(dA)], "_")
711
+
func dx (dy,dz,dA) = {
712
+
    let dg = ((toString(dz) + "_") + toString(dA))
713
+
    let dB = df(dg)
714
+
    let dC = valueOrElse(getString(dy), (dg + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
715
+
    let dD = split_4C(dC, ":")
716
+
    let dE = di(dD)
717
+
    let dF = if ((5 > size(dD)))
718
+
        then makeString(["0", toString(dE), toString((dB - dE)), toString(dB)], "_")
716
719
 
        else {
717
-
            let dF = split(dC[bo], "_")
718
-
            let dG = parseIntValue(dF[bp])
719
-
            let dH = if ((size(dF) > 1))
720
-
                then parseIntValue(dF[bq])
721
-
                else dD
722
-
            makeString([toString(dG), toString(dH), toString(((dA - dG) - dH)), toString(dA)], "_")
720
+
            let dG = split(dD[bn], "_")
721
+
            let dH = parseIntValue(dG[bo])
722
+
            let dI = if ((size(dG) > 1))
723
+
                then parseIntValue(dG[bp])
724
+
                else dE
725
+
            makeString([toString(dH), toString(dI), toString(((dB - dH) - dI)), toString(dB)], "_")
723
726
 
            }
724
-
[dC[bk], if ((size(split(dC[bl], "_")) == l))
725
-
        then dC[bl]
726
-
        else "0_0_0_0_0_0", if ((size(split(dC[bm], "_")) == l))
727
-
        then dC[bm]
728
-
        else "0_0_0_0_0_0", dC[bn], dE]
727
+
[dD[bj], if ((size(split(dD[bk], "_")) == l))
728
+
        then dD[bk]
729
+
        else "0_0_0_0_0_0", if ((size(split(dD[bl], "_")) == l))
730
+
        then dD[bl]
731
+
        else "0_0_0_0_0_0", dD[bm], dF]
729
732
 
    }
730
733
 
731
734
 
732
-
func dI (di) = {
733
-
    let dJ = dh(di)
734
-
    let dK = parseIntValue(split(di[bo], "_")[bp])
735
-
    ((de(di[bk]) - dJ) - dK)
735
+
func dJ (dj) = {
736
+
    let dK = di(dj)
737
+
    let dL = parseIntValue(split(dj[bn], "_")[bo])
738
+
    ((df(dj[bj]) - dK) - dL)
736
739
 
    }
737
740
 
738
741
 
739
-
func dL (cv,dn) = {
740
-
    let do = if ((cv >= 0))
741
-
        then (((cv + dn) - 1) / dn)
742
-
        else -((((-(cv) + dn) - 1) / dn))
743
-
    (do * E)
742
+
func dM (cw,do) = {
743
+
    let dp = if ((cw >= 0))
744
+
        then (((cw + do) - 1) / do)
745
+
        else -((((-(cw) + do) - 1) / do))
746
+
    (dp * E)
744
747
 
    }
745
748
 
746
749
 
747
-
func dM (dN,di,dO) = if ((size(dN) != 3))
750
+
func dN (dO,dj,dP) = if ((size(dO) != 3))
748
751
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
749
752
 
    else {
750
-
        let dP = split(dN[0], "_")
751
-
        let dQ = split(dN[1], "_")
752
-
        let dR = if ((dN[2] == ""))
753
+
        let dQ = split(dO[0], "_")
754
+
        let dR = split(dO[1], "_")
755
+
        let dS = if ((dO[2] == ""))
753
756
 
            then nil
754
-
            else split(dN[2], "_")
755
-
        if ((size(dP) != l))
757
+
            else split(dO[2], "_")
758
+
        if ((size(dQ) != l))
756
759
 
            then throw("All 6 resources should be passed")
757
-
            else if ((size(dQ) != l))
760
+
            else if ((size(dR) != l))
758
761
 
                then throw("All 6 materials should be passed")
759
762
 
                else {
760
-
                    let cI = dI(di)
761
-
                    let dS = split(di[bl], "_")
762
-
                    let dT = split(di[bm], "_")
763
-
                    let dU = if ((di[bn] == ""))
763
+
                    let cJ = dJ(dj)
764
+
                    let dT = split(dj[bk], "_")
765
+
                    let dU = split(dj[bl], "_")
766
+
                    let dV = if ((dj[bm] == ""))
764
767
 
                        then nil
765
-
                        else split(di[bn], "_")
766
-
                    let cG = split(dO[bh], "_")
767
-
                    let dV = split(dO[bi], "_")
768
-
                    let dW = if ((dO[bj] == ""))
768
+
                        else split(dj[bm], "_")
769
+
                    let cH = split(dP[bg], "_")
770
+
                    let dW = split(dP[bh], "_")
771
+
                    let dX = if ((dP[bi] == ""))
769
772
 
                        then nil
770
-
                        else split(dO[bj], "_")
771
-
                    func dX (bP,dl) =                     {
772
-
                        let co = bP._1
773
-
                        let dY = parseIntValue(dl)
774
-
                        let dZ = parseIntValue(dS[co])
775
-
                        let ea = parseIntValue(cG[co])
776
-
                        if ((dY == 0))
777
-
                            then $Tuple4((co + 1), (bP._2 :+ dS[co]), (bP._3 :+ cG[co]), bP._4)
778
-
                            else if ((dY > 0))
779
-
                                then if ((dY > ea))
780
-
                                    then throw((((("Attempt to take " + dl) + " from backpack, but only ") + toString(ea)) + " available"))
781
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((dZ + dY))), (bP._3 :+ toString((ea - dY))), (bP._4 + dY))
782
-
                                else if ((-(dY) > dZ))
783
-
                                    then throw((((("Attempt to take " + toString(-(dY))) + " from warehouse, but only ") + toString(dZ)) + " available"))
784
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((dZ + dY))), (bP._3 :+ toString((ea - dY))), (bP._4 + dY))
773
+
                        else split(dP[bi], "_")
774
+
                    func dY (bQ,dm) =                     {
775
+
                        let cp = bQ._1
776
+
                        let dZ = parseIntValue(dm)
777
+
                        let ea = parseIntValue(dT[cp])
778
+
                        let eb = parseIntValue(cH[cp])
779
+
                        if ((dZ == 0))
780
+
                            then $Tuple4((cp + 1), (bQ._2 :+ dT[cp]), (bQ._3 :+ cH[cp]), bQ._4)
781
+
                            else if ((dZ > 0))
782
+
                                then if ((dZ > eb))
783
+
                                    then throw((((("Attempt to take " + dm) + " from backpack, but only ") + toString(eb)) + " available"))
784
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ea + dZ))), (bQ._3 :+ toString((eb - dZ))), (bQ._4 + dZ))
785
+
                                else if ((-(dZ) > ea))
786
+
                                    then throw((((("Attempt to take " + toString(-(dZ))) + " from warehouse, but only ") + toString(ea)) + " available"))
787
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ea + dZ))), (bQ._3 :+ toString((eb - dZ))), (bQ._4 + dZ))
785
788
 
                        }
786
789
 
787
-
                    let ca = {
788
-
                        let bR = dP
789
-
                        let bS = size(bR)
790
-
                        let bT = $Tuple4(0, nil, nil, 0)
791
-
                        func bU (bV,bW) =                         if ((bW >= bS))
792
-
                            then bV
793
-
                            else dX(bV, bR[bW])
790
+
                    let cb = {
791
+
                        let bS = dQ
792
+
                        let bT = size(bS)
793
+
                        let bU = $Tuple4(0, nil, nil, 0)
794
+
                        func bV (bW,bX) =                         if ((bX >= bT))
795
+
                            then bW
796
+
                            else dY(bW, bS[bX])
794
797
 
795
-
                        func bX (bV,bW) =                         if ((bW >= bS))
796
-
                            then bV
798
+
                        func bY (bW,bX) =                         if ((bX >= bT))
799
+
                            then bW
797
800
 
                            else throw("List size exceeds 6")
798
801
 
799
-
                        bX(bU(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5), 6)
802
+
                        bY(bV(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5), 6)
800
803
 
                        }
801
-
                    func eb (bP,dl) =                     {
802
-
                        let co = bP._1
803
-
                        let dY = parseIntValue(dl)
804
-
                        let ec = parseIntValue(dT[co])
805
-
                        let ed = parseIntValue(dV[co])
806
-
                        if ((dY == 0))
807
-
                            then $Tuple4((co + 1), (bP._2 :+ dT[co]), (bP._3 :+ dV[co]), bP._4)
808
-
                            else if ((dY > 0))
809
-
                                then if ((dY > ed))
810
-
                                    then throw((((("Attempt to take " + dl) + " from backpack, but only ") + toString(ed)) + " available"))
811
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((ec + dY))), (bP._3 :+ toString((ed - dY))), (bP._4 + dY))
812
-
                                else if ((-(dY) > ec))
813
-
                                    then throw((((("Attempt to take " + toString(-(dY))) + " from warehouse, but only ") + toString(ec)) + " available"))
814
-
                                    else $Tuple4((co + 1), (bP._2 :+ toString((ec + dY))), (bP._3 :+ toString((ed - dY))), (bP._4 + dY))
804
+
                    func ec (bQ,dm) =                     {
805
+
                        let cp = bQ._1
806
+
                        let dZ = parseIntValue(dm)
807
+
                        let ed = parseIntValue(dU[cp])
808
+
                        let ee = parseIntValue(dW[cp])
809
+
                        if ((dZ == 0))
810
+
                            then $Tuple4((cp + 1), (bQ._2 :+ dU[cp]), (bQ._3 :+ dW[cp]), bQ._4)
811
+
                            else if ((dZ > 0))
812
+
                                then if ((dZ > ee))
813
+
                                    then throw((((("Attempt to take " + dm) + " from backpack, but only ") + toString(ee)) + " available"))
814
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ed + dZ))), (bQ._3 :+ toString((ee - dZ))), (bQ._4 + dZ))
815
+
                                else if ((-(dZ) > ed))
816
+
                                    then throw((((("Attempt to take " + toString(-(dZ))) + " from warehouse, but only ") + toString(ed)) + " available"))
817
+
                                    else $Tuple4((cp + 1), (bQ._2 :+ toString((ed + dZ))), (bQ._3 :+ toString((ee - dZ))), (bQ._4 + dZ))
815
818
 
                        }
816
819
 
817
-
                    let ee = {
818
-
                        let bR = dQ
819
-
                        let bS = size(bR)
820
-
                        let bT = $Tuple4(0, nil, nil, ca._4)
821
-
                        func dr (bV,bW) =                         if ((bW >= bS))
822
-
                            then bV
823
-
                            else eb(bV, bR[bW])
820
+
                    let ef = {
821
+
                        let bS = dR
822
+
                        let bT = size(bS)
823
+
                        let bU = $Tuple4(0, nil, nil, cb._4)
824
+
                        func ds (bW,bX) =                         if ((bX >= bT))
825
+
                            then bW
826
+
                            else ec(bW, bS[bX])
824
827
 
825
-
                        func ds (bV,bW) =                         if ((bW >= bS))
826
-
                            then bV
828
+
                        func dt (bW,bX) =                         if ((bX >= bT))
829
+
                            then bW
827
830
 
                            else throw("List size exceeds 6")
828
831
 
829
-
                        ds(dr(dr(dr(dr(dr(dr(bT, 0), 1), 2), 3), 4), 5), 6)
832
+
                        dt(ds(ds(ds(ds(ds(ds(bU, 0), 1), 2), 3), 4), 5), 6)
830
833
 
                        }
831
-
                    func ef (bP,dl) =                     {
832
-
                        let co = bP._1
833
-
                        let dn = bD[co]
834
-
                        let dY = parseIntValue(dl)
835
-
                        let eg = if ((size(dU) > co))
836
-
                            then parseIntValue(dU[co])
834
+
                    func eg (bQ,dm) =                     {
835
+
                        let cp = bQ._1
836
+
                        let do = bC[cp]
837
+
                        let dZ = parseIntValue(dm)
838
+
                        let eh = if ((size(dV) > cp))
839
+
                            then parseIntValue(dV[cp])
837
840
 
                            else 0
838
-
                        let eh = if ((size(dW) > co))
839
-
                            then parseIntValue(dW[co])
841
+
                        let ei = if ((size(dX) > cp))
842
+
                            then parseIntValue(dX[cp])
840
843
 
                            else 0
841
-
                        if ((dY == 0))
842
-
                            then $Tuple4((co + 1), (bP._2 :+ toString(eg)), (bP._3 :+ toString(eh)), bP._4)
843
-
                            else if ((dY > 0))
844
-
                                then if ((dY > eh))
845
-
                                    then throw((((("Attempt to take " + dl) + " from backpack, but only ") + toString(eh)) + " available"))
844
+
                        if ((dZ == 0))
845
+
                            then $Tuple4((cp + 1), (bQ._2 :+ toString(eh)), (bQ._3 :+ toString(ei)), bQ._4)
846
+
                            else if ((dZ > 0))
847
+
                                then if ((dZ > ei))
848
+
                                    then throw((((("Attempt to take " + dm) + " from backpack, but only ") + toString(ei)) + " available"))
846
849
 
                                    else {
847
-
                                        let ei = (dL((eg + dY), dn) - dL(eg, dn))
848
-
                                        $Tuple4((co + 1), (bP._2 :+ toString((eg + dY))), (bP._3 :+ toString((eh - dY))), (bP._4 + ei))
850
+
                                        let ej = (dM((eh + dZ), do) - dM(eh, do))
851
+
                                        $Tuple4((cp + 1), (bQ._2 :+ toString((eh + dZ))), (bQ._3 :+ toString((ei - dZ))), (bQ._4 + ej))
849
852
 
                                        }
850
-
                                else if ((-(dY) > eg))
851
-
                                    then throw((((("Attempt to take " + toString(-(dY))) + " from warehouse, but only ") + toString(eg)) + " available"))
853
+
                                else if ((-(dZ) > eh))
854
+
                                    then throw((((("Attempt to take " + toString(-(dZ))) + " from warehouse, but only ") + toString(eh)) + " available"))
852
855
 
                                    else {
853
-
                                        let ei = (dL((eg + dY), dn) - dL(eg, dn))
854
-
                                        $Tuple4((co + 1), (bP._2 :+ toString((eg + dY))), (bP._3 :+ toString((eh - dY))), (bP._4 + ei))
856
+
                                        let ej = (dM((eh + dZ), do) - dM(eh, do))
857
+
                                        $Tuple4((cp + 1), (bQ._2 :+ toString((eh + dZ))), (bQ._3 :+ toString((ei - dZ))), (bQ._4 + ej))
855
858
 
                                        }
856
859
 
                        }
857
860
 
858
-
                    let dd = if ((size(dR) != 0))
861
+
                    let de = if ((size(dS) != 0))
859
862
 
                        then {
860
-
                            let bR = dR
861
-
                            let bS = size(bR)
862
-
                            let bT = $Tuple4(0, nil, nil, ee._4)
863
-
                            func du (bV,bW) =                             if ((bW >= bS))
864
-
                                then bV
865
-
                                else ef(bV, bR[bW])
863
+
                            let bS = dS
864
+
                            let bT = size(bS)
865
+
                            let bU = $Tuple4(0, nil, nil, ef._4)
866
+
                            func dv (bW,bX) =                             if ((bX >= bT))
867
+
                                then bW
868
+
                                else eg(bW, bS[bX])
866
869
 
867
-
                            func dv (bV,bW) =                             if ((bW >= bS))
868
-
                                then bV
870
+
                            func dw (bW,bX) =                             if ((bX >= bT))
871
+
                                then bW
869
872
 
                                else throw("List size exceeds 50")
870
873
 
871
-
                            dv(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(du(bT, 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)
874
+
                            dw(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(dv(bU, 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)
872
875
 
                            }
873
-
                        else $Tuple4(0, dU, dW, ee._4)
874
-
                    let ej = dd._4
875
-
                    if ((ej > cI))
876
-
                        then throw((((("Attempt to put total " + toString(ej)) + " stuff, but only ") + toString(cI)) + " warehouse space left"))
877
-
                        else $Tuple7(makeString(ca._2, "_"), makeString(ee._2, "_"), makeString(dd._2, "_"), makeString(ca._3, "_"), makeString(ee._3, "_"), makeString(dd._3, "_"), ej)
876
+
                        else $Tuple4(0, dV, dX, ef._4)
877
+
                    let ek = de._4
878
+
                    if ((ek > cJ))
879
+
                        then throw((((("Attempt to put total " + toString(ek)) + " stuff, but only ") + toString(cJ)) + " warehouse space left"))
880
+
                        else $Tuple7(makeString(cb._2, "_"), makeString(ef._2, "_"), makeString(de._2, "_"), makeString(cb._3, "_"), makeString(ef._3, "_"), makeString(de._3, "_"), ek)
878
881
 
                    }
879
882
 
        }
880
883
 
881
884
 
882
-
func ek (el,em) = {
883
-
    let aY = toString(el)
884
-
    let en = cO(toBigInt(em))
885
-
    let eo = valueOrElse(getInteger(aj()), (O + 1))
886
-
    let al = toString(eo)
887
-
    let cX = toInt((en % F))
888
-
    let cr = cV(en, cX)
889
-
    let ep = M[cX]
890
-
    let eq = Issue(am(al, "S"), makeString([al, "S", cr, ep], "_"), 1, 0, false)
891
-
    let ap = calculateAssetId(eq)
892
-
    let er = toBase58String(ap)
893
-
    $Tuple2([IntegerEntry(aj(), (eo + 1)), eq, StringEntry(ak(al), er), StringEntry(ao(er), aY), StringEntry(aN(al), aY), IntegerEntry(aC(er), 0), IntegerEntry(aD(er, aY), 0), ScriptTransfer(el, 1, ap)], $Tuple2(er, ep))
885
+
func el (em,en) = {
886
+
    let aW = toString(em)
887
+
    let eo = cP(toBigInt(en))
888
+
    let ep = valueOrElse(getInteger(aj()), (O + 1))
889
+
    let al = toString(ep)
890
+
    let cY = toInt((eo % F))
891
+
    let cs = cW(eo, cY)
892
+
    let eq = M[cY]
893
+
    let er = Issue(bD(al, "S"), makeString([al, "S", cs, eq], "_"), 1, 0, false)
894
+
    let an = calculateAssetId(er)
895
+
    let es = toBase58String(an)
896
+
    $Tuple2([IntegerEntry(aj(), (ep + 1)), er, StringEntry(ak(al), es), StringEntry(am(es), aW), StringEntry(aE(al), aW), IntegerEntry(as(es), 0), IntegerEntry(at(es, aW), 0), ScriptTransfer(em, 1, an)], $Tuple2(es, eq))
894
897
 
    }
895
898
 
896
899
 
897
-
func es (cc,el,em,et,eu) = if (!(sigVerify_8Kb(et, eu, g)))
900
+
func et (cd,em,en,eu,ev) = if (!(sigVerify_8Kb(eu, ev, g)))
898
901
 
    then throw("signature does not match")
899
902
 
    else {
900
-
        let dg = split(toUtf8String(et), ";")
901
-
        let ev = split(split(dg[0], "|")[0], "_")
902
-
        let ew = parseIntValue(ev[0])
903
-
        let ex = parseIntValue(ev[1])
904
-
        let ey = split(dg[1], ":")
905
-
        let ez = split(ey[0], "_")
906
-
        if ((ez[1] != "E"))
903
+
        let dh = split(toUtf8String(eu), ";")
904
+
        let ew = split(split(dh[0], "|")[0], "_")
905
+
        let ex = parseIntValue(ew[0])
906
+
        let ey = parseIntValue(ew[1])
907
+
        let ez = split(dh[1], ":")
908
+
        let eA = split(ez[0], "_")
909
+
        if ((eA[1] != "E"))
907
910
 
            then throw("expedition target location type should be E")
908
911
 
            else {
909
-
                let eA = parseIntValue(ey[1])
910
-
                if (if ((eA > (lastBlock.timestamp + t)))
912
+
                let eB = parseIntValue(ez[1])
913
+
                if (if ((eB > (lastBlock.timestamp + t)))
911
914
 
                    then true
912
-
                    else ((lastBlock.timestamp - t) > eA))
915
+
                    else ((lastBlock.timestamp - t) > eB))
913
916
 
                    then throw("signature outdated")
914
917
 
                    else {
915
-
                        let aY = toString(el)
916
-
                        let aP = valueOrErrorMessage(getString(aK(aY)), "You don't have a duck staked")
917
-
                        let eB = aT(aP)
918
-
                        let eC = valueOrElse(getInteger(eB), 100)
919
-
                        if ((eC != ew))
920
-
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eB), 100))) + " from state does not match one from flight log=") + toString(ew)))
921
-
                            else if ((0 >= ew))
918
+
                        let aW = toString(em)
919
+
                        let aQ = valueOrErrorMessage(getString(aO(aW)), "You don't have a duck staked")
920
+
                        let eC = aS(aQ)
921
+
                        let eD = valueOrElse(getInteger(eC), 100)
922
+
                        if ((eD != ex))
923
+
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eC), 100))) + " from state does not match one from flight log=") + toString(ex)))
924
+
                            else if ((0 >= ex))
922
925
 
                                then throw("You can't fly with zero health")
923
-
                                else if ((0 >= ex))
924
-
                                    then $Tuple2(((if (!(cc))
925
-
                                        then [ScriptTransfer(el, B, b)]
926
-
                                        else nil) :+ IntegerEntry(eB, 0)), "")
926
+
                                else if ((0 >= ey))
927
+
                                    then $Tuple2(((if (!(cd))
928
+
                                        then [ScriptTransfer(em, B, b)]
929
+
                                        else nil) :+ IntegerEntry(eC, 0)), "")
927
930
 
                                    else {
928
-
                                        let dc = aO(aP)
929
-
                                        let dO = db(dc)
930
-
                                        let eD = split(dO[bi], "_")
931
-
                                        let eE = makeString(cb(cc, eD, A), "_")
932
-
                                        let eF = ek(el, em)
933
-
                                        let er = eF._2._1
934
-
                                        $Tuple2((((eF._1 :+ StringEntry(aS(aP), makeString([eF._2._2, "L", er], "_"))) :+ IntegerEntry(eB, ex)) :+ StringEntry(dc, makeString([dO[bg], dO[bh], eE, dO[bj]], ":"))), er)
931
+
                                        let dd = aP(aQ)
932
+
                                        let dP = dc(dd)
933
+
                                        let eE = split(dP[bh], "_")
934
+
                                        let eF = makeString(cc(cd, eE, A), "_")
935
+
                                        let eG = el(em, en)
936
+
                                        let es = eG._2._1
937
+
                                        $Tuple2((((eG._1 :+ StringEntry(aR(aQ), makeString([eG._2._2, "L", es], "_"))) :+ IntegerEntry(eC, ey)) :+ StringEntry(dd, makeString([dP[bf], dP[bg], eF, dP[bi]], ":"))), es)
935
938
 
                                        }
936
939
 
                        }
937
940
 
                }
938
941
 
        }
939
942
 
940
943
 
941
-
func eG (aR,eH) = {
942
-
    let dz = valueOrElse(getInteger(aC(aR)), 0)
943
-
    let eI = valueOrElse(getInteger(aH(N, aR)), if (valueOrElse(getBoolean(aF(aR)), false))
944
-
        then eH
944
+
func eH (aD,eI) = {
945
+
    let dA = valueOrElse(getInteger(as(aD)), 0)
946
+
    let eJ = valueOrElse(getInteger(ax(N, aD)), if (valueOrElse(getBoolean(av(aD)), false))
947
+
        then eI
945
948
 
        else 0)
946
-
    let eJ = (dz / 6)
947
-
    let eK = (dz / 7)
948
-
    ((r + fraction(r, ((dz + eJ) + (2 * eK)), 5)) + fraction(r, eI, (eH * 5)))
949
+
    let eK = (dA / 6)
950
+
    let eL = (dA / 7)
951
+
    ((r + fraction(r, ((dA + eK) + (2 * eL)), 5)) + fraction(r, eJ, (eI * 5)))
949
952
 
    }
950
953
 
951
954
 
952
-
func eL (ai,eM,eN) = {
953
-
    let eO = if ((eM == bt))
954
-
        then $Tuple2(eN, valueOrElse(getString(aK(ai)), ""))
955
+
func eM (ai,eN,eO) = {
956
+
    let eP = if ((eN == bs))
957
+
        then $Tuple2(eO, valueOrElse(getString(aO(ai)), ""))
955
958
 
        else {
956
-
            let aP = valueOrErrorMessage(getString(aK(ai)), "You don't have a duck staked")
957
-
            let eP = valueOrElse(getString(aS(aP)), k)
958
-
            let eQ = split(value(eP), "_")
959
-
            if ((eQ[be] != "L"))
960
-
                then throw((("Duck location type is " + eQ[be]) + ", but should be L"))
961
-
                else $Tuple2(eQ[bf], aP)
959
+
            let aQ = valueOrErrorMessage(getString(aO(ai)), "You don't have a duck staked")
960
+
            let eQ = valueOrElse(getString(aR(aQ)), k)
961
+
            let eR = split(value(eQ), "_")
962
+
            if ((eR[bd] != "L"))
963
+
                then throw((("Duck location type is " + eR[bd]) + ", but should be L"))
964
+
                else $Tuple2(eR[be], aQ)
962
965
 
            }
963
-
    let aR = eO._1
964
-
    let eR = eO._2
965
-
    let eS = value(assetInfo(fromBase58String(aR)))
966
-
    let eT = aB(aR)
967
-
    let eU = valueOrErrorMessage(getInteger(eT), (("Land " + eS.name) + " is not staked"))
968
-
    let eV = valueOrErrorMessage(getString(ao(aR)), (("NFT " + eS.name) + " is orphaned"))
969
-
    if ((eV != ai))
966
+
    let aD = eP._1
967
+
    let eS = eP._2
968
+
    let eT = value(assetInfo(fromBase58String(aD)))
969
+
    let eU = ar(aD)
970
+
    let eV = valueOrErrorMessage(getInteger(eU), (("Land " + eT.name) + " is not staked"))
971
+
    let eW = valueOrErrorMessage(getString(am(aD)), (("NFT " + eT.name) + " is orphaned"))
972
+
    if ((eW != ai))
970
973
 
        then throw((i + " is not yours"))
971
974
 
        else {
972
-
            let eW = split(eS.description, "_")
973
-
            $Tuple4(eR, aR, eW, eU)
975
+
            let eX = split(eT.description, "_")
976
+
            $Tuple4(eS, aD, eX, eV)
974
977
 
            }
975
978
 
    }
976
979
 
977
980
 
978
-
func eX (ai,cv,eM,eN) = if ((0 > cv))
981
+
func eY (ai,cw,eN,eO) = if ((0 > cw))
979
982
 
    then throw("Negative amount")
980
983
 
    else {
981
-
        let eY = eL(ai, eM, eN)
982
-
        let an = eY._3[ba]
983
-
        let ck = cq(eY._3[bb])
984
-
        let cz = (lastBlock.timestamp - eY._4)
985
-
        if ((0 > cz))
986
-
            then throw(((("Saved timestamp is in future, saved = " + toString(eY._4)) + ", current = ") + toString(lastBlock.timestamp)))
984
+
        let eZ = eM(ai, eN, eO)
985
+
        let bE = eZ._3[aZ]
986
+
        let cl = cr(eZ._3[ba])
987
+
        let cA = (lastBlock.timestamp - eZ._4)
988
+
        if ((0 > cA))
989
+
            then throw(((("Saved timestamp is in future, saved = " + toString(eZ._4)) + ", current = ") + toString(lastBlock.timestamp)))
987
990
 
            else {
988
-
                let eH = cs(an)
989
-
                let eZ = eG(eY._2, eH)
990
-
                let fa = fraction(cz, (eZ * eH), s)
991
-
                if ((cv > fa))
992
-
                    then throw(((("Not enough resources, available = " + toString(fa)) + ", requested = ") + toString(cv)))
991
+
                let eI = ct(bE)
992
+
                let fa = eH(eZ._2, eI)
993
+
                let fb = fraction(cA, (fa * eI), s)
994
+
                if ((cw > fb))
995
+
                    then throw(((("Not enough resources, available = " + toString(fb)) + ", requested = ") + toString(cw)))
993
996
 
                    else {
994
-
                        let fb = fraction((fa - cv), s, (eZ * eH))
995
-
                        let fc = (lastBlock.timestamp - fb)
996
-
                        let dy = (eH / m)
997
-
                        let cH = cD(ck, (cz - fb), dy, eZ)
998
-
                        let dx = aQ(eY._2)
999
-
                        let dz = valueOrElse(getInteger(aC(eY._2)), 0)
1000
-
                        let di = dw(dx, dy, dz)
1001
-
                        let dF = split(di[bo], "_")
1002
-
                        let cI = parseIntValue(dF[br])
1003
-
                        if (if ((eM == bt))
1004
-
                            then (cv > cI)
997
+
                        let fc = fraction((fb - cw), s, (fa * eI))
998
+
                        let fd = (lastBlock.timestamp - fc)
999
+
                        let dz = (eI / m)
1000
+
                        let cI = cE(cl, (cA - fc), dz, fa)
1001
+
                        let dy = aC(eZ._2)
1002
+
                        let dA = valueOrElse(getInteger(as(eZ._2)), 0)
1003
+
                        let dj = dx(dy, dz, dA)
1004
+
                        let dG = split(dj[bn], "_")
1005
+
                        let cJ = parseIntValue(dG[bq])
1006
+
                        if (if ((eN == bs))
1007
+
                            then (cw > cJ)
1005
1008
 
                            else false)
1006
-
                            then throw((("Only " + toString(cI)) + " space left in warehouse"))
1009
+
                            then throw((("Only " + toString(cJ)) + " space left in warehouse"))
1007
1010
 
                            else {
1008
-
                                let dc = aO(eY._1)
1009
-
                                let dO = db(dc)
1010
-
                                let cG = split(dO[bh], "_")
1011
-
                                let cF = split(di[bl], "_")
1012
-
                                let fd = if ((eM == bt))
1013
-
                                    then $Tuple4(cx(cF, ck, (cz - fb), dy, eZ), dO[bh], (parseIntValue(dF[bq]) + cH._2), (parseIntValue(dF[br]) - cH._2))
1014
-
                                    else if ((eM == bu))
1015
-
                                        then $Tuple4(di[bl], cx(cG, ck, (cz - fb), dy, eZ), parseIntValue(dF[bq]), parseIntValue(dF[br]))
1011
+
                                let dd = aP(eZ._1)
1012
+
                                let dP = dc(dd)
1013
+
                                let cH = split(dP[bg], "_")
1014
+
                                let cG = split(dj[bk], "_")
1015
+
                                let fe = if ((eN == bs))
1016
+
                                    then $Tuple4(cy(cG, cl, (cA - fc), dz, fa), dP[bg], (parseIntValue(dG[bp]) + cI._2), (parseIntValue(dG[bq]) - cI._2))
1017
+
                                    else if ((eN == bt))
1018
+
                                        then $Tuple4(dj[bk], cy(cH, cl, (cA - fc), dz, fa), parseIntValue(dG[bp]), parseIntValue(dG[bq]))
1016
1019
 
                                        else {
1017
-
                                            let fe = cE(cF, cG, cH, cI)
1018
-
                                            let ff = min([parseIntValue(dF[br]), cH._2])
1019
-
                                            $Tuple4(fe._1, fe._2, (parseIntValue(dF[bq]) + ff), (parseIntValue(dF[br]) - ff))
1020
+
                                            let ff = cF(cG, cH, cI, cJ)
1021
+
                                            let fg = min([parseIntValue(dG[bq]), cI._2])
1022
+
                                            $Tuple4(ff._1, ff._2, (parseIntValue(dG[bp]) + fg), (parseIntValue(dG[bq]) - fg))
1020
1023
 
                                            }
1021
-
                                let fg = fd._1
1022
-
                                let fh = fd._2
1023
-
                                let fi = fd._3
1024
-
                                let fj = fd._4
1025
-
                                $Tuple5([IntegerEntry(aB(eY._2), fc), IntegerEntry(aL(i, eY._2, ai), fc)], dc, [dO[bg], fh, dO[bi], dO[bj]], dx, [di[bk], fg, di[bm], di[bn], makeString([dF[bp], toString(fi), toString(fj), dF[bs]], "_")])
1024
+
                                let fh = fe._1
1025
+
                                let fi = fe._2
1026
+
                                let fj = fe._3
1027
+
                                let fk = fe._4
1028
+
                                $Tuple5([IntegerEntry(ar(eZ._2), fd), IntegerEntry(aA(i, eZ._2, ai), fd)], dd, [dP[bf], fi, dP[bh], dP[bi]], dy, [dj[bj], fh, dj[bl], dj[bm], makeString([dG[bo], toString(fj), toString(fk), dG[br]], "_")])
1026
1029
 
                                }
1027
1030
 
                        }
1028
1031
 
                }
1029
1032
 
        }
1030
1033
 
1031
1034
 
1032
-
func fk (ai,aR,eH,eM) = {
1033
-
    let eT = aB(aR)
1034
-
    let eU = value(getInteger(eT))
1035
-
    let fa = (fraction((lastBlock.timestamp - eU), eG(aR, eH), s) * eH)
1036
-
    eX(ai, fa, eM, aR)
1035
+
func fl (ai,aD,eI,eN) = {
1036
+
    let eU = ar(aD)
1037
+
    let eV = value(getInteger(eU))
1038
+
    let fb = (fraction((lastBlock.timestamp - eV), eH(aD, eI), s) * eI)
1039
+
    eY(ai, fb, eN, aD)
1037
1040
 
    }
1038
1041
 
1039
1042
 
1040
-
func fl (cc,el,fm,aR) = {
1041
-
    let ai = toString(el)
1042
-
    let eY = eL(ai, bv, aR)
1043
-
    let eH = cs(eY._3[ba])
1044
-
    let fn = aC(eY._2)
1045
-
    let fo = valueOrElse(getInteger(fn), 0)
1046
-
    if ((fo >= 3))
1043
+
func fm (cd,em,fn,aD) = {
1044
+
    let ai = toString(em)
1045
+
    let eZ = eM(ai, bu, aD)
1046
+
    let eI = ct(eZ._3[aZ])
1047
+
    let fo = as(eZ._2)
1048
+
    let fp = valueOrElse(getInteger(fo), 0)
1049
+
    if ((fp >= 3))
1047
1050
 
        then throw("Currently max infrastructure level = 3")
1048
1051
 
        else {
1049
-
            let fp = (fo + 1)
1050
-
            let fq = fraction(z, (eH * fp), m)
1051
-
            if (if (!(cc))
1052
-
                then (fm != fq)
1052
+
            let fq = (fp + 1)
1053
+
            let fr = fraction(z, (eI * fq), m)
1054
+
            if (if (!(cd))
1055
+
                then (fn != fr)
1053
1056
 
                else false)
1054
-
                then throw(("Payment attached should be " + toString(fq)))
1057
+
                then throw(("Payment attached should be " + toString(fr)))
1055
1058
 
                else {
1056
-
                    let dc = aO(eY._1)
1057
-
                    let dO = db(dc)
1058
-
                    let eD = split(dO[bi], "_")
1059
-
                    let eE = makeString(cb(cc, eD, fraction(y, (eH * fp), m)), "_")
1060
-
                    let fr = fk(ai, eY._2, eH, bv)
1061
-
                    let fs = fr._5
1062
-
                    let ft = de(fs[bk])
1063
-
                    let fu = makeString([split(fs[bk], "_")[0], toString(fp)], "_")
1064
-
                    let fv = de(fu)
1065
-
                    let dF = split(fs[bo], "_")
1066
-
                    let fw = makeString([dF[bp], dF[bq], toString(((parseIntValue(dF[br]) + fv) - ft)), toString(fv)], "_")
1067
-
                    $Tuple2(([IntegerEntry(fn, fp), IntegerEntry(aD(eY._2, ai), fp), StringEntry(dc, makeString([dO[bg], fr._3[bh], eE, dO[bj]], ":")), StringEntry(fr._4, makeString([fu, fs[bl], fs[bm], fs[bn], fw], ":"))] ++ fr._1), fp)
1059
+
                    let dd = aP(eZ._1)
1060
+
                    let dP = dc(dd)
1061
+
                    let eE = split(dP[bh], "_")
1062
+
                    let eF = makeString(cc(cd, eE, fraction(y, (eI * fq), m)), "_")
1063
+
                    let fs = fl(ai, eZ._2, eI, bu)
1064
+
                    let ft = fs._5
1065
+
                    let fu = df(ft[bj])
1066
+
                    let fv = makeString([split(ft[bj], "_")[0], toString(fq)], "_")
1067
+
                    let fw = df(fv)
1068
+
                    let dG = split(ft[bn], "_")
1069
+
                    let fx = makeString([dG[bo], dG[bp], toString(((parseIntValue(dG[bq]) + fw) - fu)), toString(fw)], "_")
1070
+
                    $Tuple2(([IntegerEntry(fo, fq), IntegerEntry(at(eZ._2, ai), fq), StringEntry(dd, makeString([dP[bf], fs._3[bg], eF, dP[bi]], ":")), StringEntry(fs._4, makeString([fv, ft[bk], ft[bl], ft[bm], fx], ":"))] ++ fs._1), fq)
1068
1071
 
                    }
1069
1072
 
            }
1070
1073
 
    }
1071
1074
 
1072
1075
 
1073
-
func fx (ai) = 0
1076
+
func fy (ai) = 0
1074
1077
 
1075
1078
 
1076
-
func fy (ai,eN) = {
1077
-
    let eY = eL(ai, bv, eN)
1078
-
    let aR = eY._2
1079
-
    let eH = cs(eY._3[ba])
1080
-
    let fz = aH(N, aR)
1081
-
    if ((valueOrElse(getInteger(fz), if (valueOrElse(getBoolean(aF(aR)), false))
1082
-
        then eH
1079
+
func fz (ai,eO) = {
1080
+
    let eZ = eM(ai, bu, eO)
1081
+
    let aD = eZ._2
1082
+
    let eI = ct(eZ._3[aZ])
1083
+
    let fA = ax(N, aD)
1084
+
    if ((valueOrElse(getInteger(fA), if (valueOrElse(getBoolean(av(aD)), false))
1085
+
        then eI
1083
1086
 
        else 0) > 0))
1084
1087
 
        then throw("Presale artifact is already activated")
1085
-
        else if ((parseIntValue(eY._3[aZ]) > O))
1086
-
            then throw((((i + " ") + aR) + " is not eligible for presale artifact"))
1088
+
        else if ((parseIntValue(eZ._3[aY]) > O))
1089
+
            then throw((((i + " ") + aD) + " is not eligible for presale artifact"))
1087
1090
 
            else {
1088
-
                let fr = fk(ai, aR, eH, bv)
1089
-
                ((((fr._1 :+ IntegerEntry(fz, eH)) :+ IntegerEntry(aJ(N, aR, ai), eH)) :+ StringEntry(fr._2, makeString(fr._3, ":"))) :+ StringEntry(fr._4, makeString(fr._5, ":")))
1091
+
                let fs = fl(ai, aD, eI, bu)
1092
+
                ((((fs._1 :+ IntegerEntry(fA, eI)) :+ IntegerEntry(az(N, aD, ai), eI)) :+ StringEntry(fs._2, makeString(fs._3, ":"))) :+ StringEntry(fs._4, makeString(fs._5, ":")))
1090
1093
 
                }
1091
1094
 
    }
1092
1095
 
1093
1096
 
1094
-
func fA (fB,fp,fC,ai,fD,em,fE) = {
1095
-
    let aP = valueOrErrorMessage(getString(aK(ai)), "You don't have a duck staked")
1096
-
    func fF (bP,aR) =     {
1097
-
        let eS = value(assetInfo(fromBase58String(aR)))
1098
-
        let eT = aB(aR)
1099
-
        let eU = valueOrErrorMessage(getInteger(eT), (("NFT " + eS.name) + " is not staked"))
1100
-
        let eV = valueOrErrorMessage(getString(ao(aR)), (("NFT " + eS.name) + " is orphaned"))
1101
-
        if ((eV != ai))
1097
+
func fB (fC,fq,fD,ai,fE,en,fF) = {
1098
+
    let aQ = valueOrErrorMessage(getString(aO(ai)), "You don't have a duck staked")
1099
+
    func fG (bQ,aD) =     {
1100
+
        let eT = value(assetInfo(fromBase58String(aD)))
1101
+
        let eU = ar(aD)
1102
+
        let eV = valueOrErrorMessage(getInteger(eU), (("NFT " + eT.name) + " is not staked"))
1103
+
        let eW = valueOrErrorMessage(getString(am(aD)), (("NFT " + eT.name) + " is orphaned"))
1104
+
        if ((eW != ai))
1102
1105
 
            then throw((i + " is not yours"))
1103
1106
 
            else {
1104
-
                let eW = split(eS.description, "_")
1105
-
                let ep = eW[bc]
1106
-
                if (if ((bP._3 != ""))
1107
-
                    then (bP._3 != ep)
1107
+
                let eX = split(eT.description, "_")
1108
+
                let eq = eX[bb]
1109
+
                if (if ((bQ._3 != ""))
1110
+
                    then (bQ._3 != eq)
1108
1111
 
                    else false)
1109
1112
 
                    then throw("Lands should be on the same continent to merge")
1110
1113
 
                    else {
1111
-
                        let an = eW[ba]
1112
-
                        let fG = bP._1
1113
-
                        let co = valueOrErrorMessage(indexOf(fG, an), "You haven't passed all the lands needed")
1114
-
                        let fH = (take(fG, co) + drop(fG, (co + 1)))
1115
-
                        let eH = cs(an)
1116
-
                        let fI = (bP._2 + valueOrElse(getInteger(aH(N, aR)), if (valueOrElse(getBoolean(aF(aR)), false))
1117
-
                            then eH
1114
+
                        let bE = eX[aZ]
1115
+
                        let fH = bQ._1
1116
+
                        let cp = valueOrErrorMessage(indexOf(fH, bE), "You haven't passed all the lands needed")
1117
+
                        let fI = (take(fH, cp) + drop(fH, (cp + 1)))
1118
+
                        let eI = ct(bE)
1119
+
                        let fJ = (bQ._2 + valueOrElse(getInteger(ax(N, aD)), if (valueOrElse(getBoolean(av(aD)), false))
1120
+
                            then eI
1118
1121
 
                            else 0))
1119
-
                        let dz = valueOrElse(getInteger(aC(aR)), 0)
1120
-
                        let fJ = {
1121
-
                            let c = an
1122
+
                        let dA = valueOrElse(getInteger(as(aD)), 0)
1123
+
                        let fK = {
1124
+
                            let c = bE
1122
1125
 
                            if (("S" == c))
1123
1126
 
                                then 3
1124
1127
 
                                else if (("M" == c))
1125
1128
 
                                    then 4
1126
1129
 
                                    else if (("L" == c))
1127
1130
 
                                        then 5
1128
1131
 
                                        else if (("XL" == c))
1129
1132
 
                                            then 6
1130
1133
 
                                            else throw("Only S, M, L, XL can merge")
1131
1134
 
                            }
1132
-
                        if ((dz != fJ))
1135
+
                        if ((dA != fK))
1133
1136
 
                            then throw("All lands should be maxed to merge")
1134
1137
 
                            else {
1135
-
                                let al = eW[aZ]
1136
-
                                let ck = cq(eW[bb])
1137
-
                                let cz = (lastBlock.timestamp - eU)
1138
-
                                if ((0 > cz))
1139
-
                                    then throw(((("Saved timestamp is in future, saved = " + toString(eU)) + ", current = ") + toString(lastBlock.timestamp)))
1138
+
                                let al = eX[aY]
1139
+
                                let cl = cr(eX[ba])
1140
+
                                let cA = (lastBlock.timestamp - eV)
1141
+
                                if ((0 > cA))
1142
+
                                    then throw(((("Saved timestamp is in future, saved = " + toString(eV)) + ", current = ") + toString(lastBlock.timestamp)))
1140
1143
 
                                    else {
1141
-
                                        let eZ = eG(aR, eH)
1142
-
                                        let dy = (eH / m)
1143
-
                                        let fh = cx(split(bP._4, "_"), ck, cz, dy, eZ)
1144
-
                                        let bZ = ci(split(bP._6, "_"), ck, dy, -1)
1145
-
                                        let fK = bP._7
1146
-
                                        let ad = indexOf(fK, aR)
1144
+
                                        let fa = eH(aD, eI)
1145
+
                                        let dz = (eI / m)
1146
+
                                        let fi = cy(split(bQ._4, "_"), cl, cA, dz, fa)
1147
+
                                        let ca = cj(split(bQ._6, "_"), cl, dz, -1)
1148
+
                                        let fL = bQ._7
1149
+
                                        let ad = indexOf(fL, aD)
1147
1150
 
                                        if (!(isDefined(ad)))
1148
-
                                            then throw(("Your staked lands don't contain " + aR))
1151
+
                                            then throw(("Your staked lands don't contain " + aD))
1149
1152
 
                                            else {
1150
-
                                                let fL = aq(aR)
1151
-
                                                let fM = valueOrElse(getString(fL), "")
1152
-
                                                $Tuple7(fH, fI, ep, fh, ((((((((((((((bP._5 :+ DeleteEntry(aB(aR))) :+ DeleteEntry(aL(i, aR, ai))) :+ DeleteEntry(ak(al))) :+ DeleteEntry(am(al, an))) :+ DeleteEntry(ao(aR))) :+ DeleteEntry(aC(aR))) :+ DeleteEntry(aD(aR, ai))) :+ DeleteEntry(aH(N, aR))) :+ DeleteEntry(aJ(N, aR, ai))) :+ DeleteEntry(aN(al))) :+ DeleteEntry(aQ(aR))) :+ DeleteEntry(fL)) :+ DeleteEntry(at(fM))) :+ Burn(fromBase58String(aR), 1)), bZ, removeByIndex(fK, value(ad)))
1153
+
                                                let fM = ao(aD)
1154
+
                                                let fN = valueOrElse(getString(fM), "")
1155
+
                                                $Tuple7(fI, fJ, eq, fi, (((((((((((((bQ._5 :+ DeleteEntry(ar(aD))) :+ DeleteEntry(aA(i, aD, ai))) :+ DeleteEntry(ak(al))) :+ DeleteEntry(am(aD))) :+ DeleteEntry(as(aD))) :+ DeleteEntry(at(aD, ai))) :+ DeleteEntry(ax(N, aD))) :+ DeleteEntry(az(N, aD, ai))) :+ DeleteEntry(aE(al))) :+ DeleteEntry(aC(aD))) :+ DeleteEntry(fM)) :+ DeleteEntry(ap(fN))) :+ Burn(fromBase58String(aD), 1)), ca, removeByIndex(fL, value(ad)))
1153
1156
 
                                                }
1154
1157
 
                                        }
1155
1158
 
                                }
1156
1159
 
                        }
1157
1160
 
                }
1158
1161
 
        }
1159
1162
 
1160
-
    let dc = aO(aP)
1161
-
    let dO = db(dc)
1162
-
    let fN = valueOrElse(getString(aU()), "0_0_0_0_0_0")
1163
-
    let fO = aV(ai)
1164
-
    let fP = getString(fO)
1165
-
    let fQ = if (isDefined(fP))
1166
-
        then split_51C(value(fP), "_")
1163
+
    let dd = aP(aQ)
1164
+
    let dP = dc(dd)
1165
+
    let fO = valueOrElse(getString(aT()), "0_0_0_0_0_0")
1166
+
    let fP = aF(ai)
1167
+
    let fQ = getString(fP)
1168
+
    let fR = if (isDefined(fQ))
1169
+
        then split_51C(value(fQ), "_")
1167
1170
 
        else nil
1168
-
    let ca = {
1169
-
        let bR = fD
1170
-
        let bS = size(bR)
1171
-
        let bT = $Tuple7(fC, 0, "", dO[bh], nil, fN, fQ)
1172
-
        func bU (bV,bW) =         if ((bW >= bS))
1173
-
            then bV
1174
-
            else fF(bV, bR[bW])
1171
+
    let cb = {
1172
+
        let bS = fE
1173
+
        let bT = size(bS)
1174
+
        let bU = $Tuple7(fD, 0, "", dP[bg], nil, fO, fR)
1175
+
        func bV (bW,bX) =         if ((bX >= bT))
1176
+
            then bW
1177
+
            else fG(bW, bS[bX])
1175
1178
 
1176
-
        func bX (bV,bW) =         if ((bW >= bS))
1177
-
            then bV
1179
+
        func bY (bW,bX) =         if ((bX >= bT))
1180
+
            then bW
1178
1181
 
            else throw("List size exceeds 5")
1179
1182
 
1180
-
        bX(bU(bU(bU(bU(bU(bT, 0), 1), 2), 3), 4), 5)
1183
+
        bY(bV(bV(bV(bV(bV(bU, 0), 1), 2), 3), 4), 5)
1181
1184
 
        }
1182
-
    let ep = ca._3
1183
-
    let cX = valueOrErrorMessage(indexOf(M, ep), ("Unknown continent: " + ep))
1184
-
    let cr = cV(cO(toBigInt(em)), cX)
1185
-
    let eo = valueOrElse(getInteger(aj()), (O + 1))
1186
-
    let fR = toString(eo)
1187
-
    let eq = Issue(am(fR, fB), makeString([fR, fB, cr, ep], "_"), 1, 0, false)
1188
-
    let ap = calculateAssetId(eq)
1189
-
    let fS = toBase58String(ap)
1190
-
    let eE = makeString(cb((fE > 0), split(dO[bi], "_"), fE), "_")
1191
-
    $Tuple2(((((((((((((((ca._5 :+ (if ((size(ca._7) > 0))
1192
-
        then StringEntry(fO, makeString_11C(ca._7, "_"))
1193
-
        else DeleteEntry(fO))) :+ IntegerEntry(aj(), (eo + 1))) :+ eq) :+ StringEntry(ak(fR), fS)) :+ StringEntry(ao(fS), ai)) :+ StringEntry(aN(fR), ai)) :+ IntegerEntry(aH(N, fS), ca._2)) :+ IntegerEntry(aJ(N, fS, ai), ca._2)) :+ IntegerEntry(aC(fS), fp)) :+ IntegerEntry(aD(fS, ai), fp)) :+ StringEntry(dc, makeString([dO[bg], ca._4, eE, dO[bj]], ":"))) :+ StringEntry(aU(), ca._6)) :+ StringEntry(aS(aP), makeString([ep, "L", fS], "_"))) :+ ScriptTransfer(addressFromStringValue(ai), 1, ap)), fS)
1185
+
    let eq = cb._3
1186
+
    let cY = valueOrErrorMessage(indexOf(M, eq), ("Unknown continent: " + eq))
1187
+
    let cs = cW(cP(toBigInt(en)), cY)
1188
+
    let ep = valueOrElse(getInteger(aj()), (O + 1))
1189
+
    let fS = toString(ep)
1190
+
    let er = Issue(bD(fS, fC), makeString([fS, fC, cs, eq], "_"), 1, 0, false)
1191
+
    let an = calculateAssetId(er)
1192
+
    let fT = toBase58String(an)
1193
+
    let eF = makeString(cc((fF > 0), split(dP[bh], "_"), fF), "_")
1194
+
    $Tuple2(((((((((((((((cb._5 :+ (if ((size(cb._7) > 0))
1195
+
        then StringEntry(fP, makeString_11C(cb._7, "_"))
1196
+
        else DeleteEntry(fP))) :+ IntegerEntry(aj(), (ep + 1))) :+ er) :+ StringEntry(ak(fS), fT)) :+ StringEntry(am(fT), ai)) :+ StringEntry(aE(fS), ai)) :+ IntegerEntry(ax(N, fT), cb._2)) :+ IntegerEntry(az(N, fT, ai), cb._2)) :+ IntegerEntry(as(fT), fq)) :+ IntegerEntry(at(fT, ai), fq)) :+ StringEntry(dd, makeString([dP[bf], cb._4, eF, dP[bi]], ":"))) :+ StringEntry(aT(), cb._6)) :+ StringEntry(aR(aQ), makeString([eq, "L", fT], "_"))) :+ ScriptTransfer(addressFromStringValue(ai), 1, an)), fT)
1194
1197
 
    }
1195
1198
 
1196
1199
 
1197
-
func fT (ai,fD,em) = fA("M", 3, "SSSS", ai, fD, em, 0)
1200
+
func fU (ai,fE,en) = fB("M", 3, "SSSS", ai, fE, en, 0)
1198
1201
 
1199
1202
 
1200
-
func fU (ai,fD,em,cc,fm) = {
1201
-
    let fq = (z * 4)
1202
-
    if (if (!(cc))
1203
-
        then (fm != fq)
1203
+
func fV (ai,fE,en,cd,fn) = {
1204
+
    let fr = (z * 4)
1205
+
    if (if (!(cd))
1206
+
        then (fn != fr)
1204
1207
 
        else false)
1205
-
        then throw(("Payment attached should be " + toString(fq)))
1206
-
        else fA("L", 4, "SMM", ai, fD, em, (y * 4))
1208
+
        then throw(("Payment attached should be " + toString(fr)))
1209
+
        else fB("L", 4, "SMM", ai, fE, en, (y * 4))
1207
1210
 
    }
1208
1211
 
1209
1212
 
1210
-
func fV (ai,fD,em,cc,fm) = {
1211
-
    let fq = (z * 47)
1212
-
    if (if (!(cc))
1213
-
        then (fm != fq)
1213
+
func fW (ai,fE,en,cd,fn) = {
1214
+
    let fr = (z * 47)
1215
+
    if (if (!(cd))
1216
+
        then (fn != fr)
1214
1217
 
        else false)
1215
-
        then throw(("Payment attached should be " + toString(fq)))
1216
-
        else fA("XL", 5, "SSSML", ai, fD, em, (y * 47))
1218
+
        then throw(("Payment attached should be " + toString(fr)))
1219
+
        else fB("XL", 5, "SSSML", ai, fE, en, (y * 47))
1217
1220
 
    }
1218
1221
 
1219
1222
 
1220
-
func fW (ai,fD,em,cc,fm) = {
1221
-
    let fq = (z * 54)
1222
-
    if (if (!(cc))
1223
-
        then (fm != fq)
1223
+
func fX (ai,fE,en,cd,fn) = {
1224
+
    let fr = (z * 54)
1225
+
    if (if (!(cd))
1226
+
        then (fn != fr)
1224
1227
 
        else false)
1225
-
        then throw(("Payment attached should be " + toString(fq)))
1226
-
        else fA("XXL", 6, "LXL", ai, fD, em, (y * 54))
1228
+
        then throw(("Payment attached should be " + toString(fr)))
1229
+
        else fB("XXL", 6, "LXL", ai, fE, en, (y * 54))
1227
1230
 
    }
1228
1231
 
1229
1232
 
1230
-
func fX (cc,ai,fm,fD,em) = {
1231
-
    let fY = {
1232
-
        let c = size(fD)
1233
+
func fY (cd,ai,fn,fE,en) = {
1234
+
    let fZ = {
1235
+
        let c = size(fE)
1233
1236
 
        if ((4 == c))
1234
-
            then fT(ai, fD, em)
1237
+
            then fU(ai, fE, en)
1235
1238
 
            else if ((3 == c))
1236
-
                then fU(ai, fD, em, cc, fm)
1239
+
                then fV(ai, fE, en, cd, fn)
1237
1240
 
                else if ((5 == c))
1238
-
                    then fV(ai, fD, em, cc, fm)
1241
+
                    then fW(ai, fE, en, cd, fn)
1239
1242
 
                    else if ((2 == c))
1240
-
                        then fW(ai, fD, em, cc, fm)
1243
+
                        then fX(ai, fE, en, cd, fn)
1241
1244
 
                        else throw("Unknown merge")
1242
1245
 
        }
1243
-
    fY
1246
+
    fZ
1244
1247
 
    }
1245
1248
 
1246
1249
 
1247
-
func fZ (co) = if (if ((co.originCaller != ae))
1248
-
    then valueOrElse(getBoolean(aW()), false)
1250
+
func ga (cp) = if (if ((cp.originCaller != ae))
1251
+
    then valueOrElse(getBoolean(aU()), false)
1249
1252
 
    else false)
1250
1253
 
    then throw("Contracts are under maintenance")
1251
-
    else StringEntry(ah(toString(co.originCaller)), toBase58String(co.transactionId))
1254
+
    else StringEntry(ah(toString(cp.originCaller)), toBase58String(cp.transactionId))
1252
1255
 
1253
1256
 
1254
-
@Callable(co)
1255
-
func constructorV1 (ga) = if ((co.caller != this))
1257
+
@Callable(cp)
1258
+
func constructorV1 (gb) = if ((cp.caller != this))
1256
1259
 
    then throw("Permission denied")
1257
-
    else [StringEntry(Y(), ga)]
1260
+
    else [StringEntry(Y(), gb)]
1258
1261
 
1259
1262
 
1260
1263
 
1261
-
@Callable(co)
1262
-
func setBlocked (gb) = if ((co.caller != this))
1264
+
@Callable(cp)
1265
+
func setBlocked (gc) = if ((cp.caller != this))
1263
1266
 
    then throw("permission denied")
1264
-
    else [BooleanEntry(aW(), gb)]
1267
+
    else [BooleanEntry(aU(), gc)]
1265
1268
 
1266
1269
 
1267
1270
 
1268
-
@Callable(co)
1271
+
@Callable(cp)
1269
1272
 
func stakeLand () = {
1270
-
    let gc = fZ(co)
1271
-
    if ((size(co.payments) != 1))
1273
+
    let gd = ga(cp)
1274
+
    if ((size(cp.payments) != 1))
1272
1275
 
        then throw("Exactly one payment required")
1273
1276
 
        else {
1274
-
            let gd = value(co.payments[0])
1275
-
            let ap = value(gd.assetId)
1276
-
            let Q = toString(co.caller)
1277
-
            if ((gd.amount != 1))
1277
+
            let ge = value(cp.payments[0])
1278
+
            let an = value(ge.assetId)
1279
+
            let Q = toString(cp.caller)
1280
+
            if ((ge.amount != 1))
1278
1281
 
                then throw((("NFT " + i) + " token should be attached as payment"))
1279
1282
 
                else {
1280
-
                    let eS = value(assetInfo(ap))
1281
-
                    if ((eS.issuer != this))
1283
+
                    let eT = value(assetInfo(an))
1284
+
                    if ((eT.issuer != this))
1282
1285
 
                        then throw("Unknown issuer of token")
1283
-
                        else if (!(contains(eS.name, i)))
1286
+
                        else if (!(contains(eT.name, i)))
1284
1287
 
                            then throw((("Only NFT " + i) + " tokens are accepted"))
1285
1288
 
                            else {
1286
-
                                let ge = drop(eS.name, 4)
1287
-
                                let al = if (contains(ge, "XXL"))
1288
-
                                    then dropRight(ge, 3)
1289
-
                                    else if (contains(ge, "XL"))
1290
-
                                        then dropRight(ge, 2)
1291
-
                                        else dropRight(ge, 1)
1289
+
                                let gf = drop(eT.name, 4)
1290
+
                                let al = if (contains(gf, "XXL"))
1291
+
                                    then dropRight(gf, 3)
1292
+
                                    else if (contains(gf, "XL"))
1293
+
                                        then dropRight(gf, 2)
1294
+
                                        else dropRight(gf, 1)
1292
1295
 
                                if (!(isDefined(parseInt(al))))
1293
-
                                    then throw(("Cannot parse land number from " + eS.name))
1296
+
                                    then throw(("Cannot parse land number from " + eT.name))
1294
1297
 
                                    else {
1295
-
                                        let aR = toBase58String(ap)
1296
-
                                        let eT = aB(aR)
1297
-
                                        if (isDefined(getInteger(eT)))
1298
-
                                            then throw((("NFT " + eS.name) + " is already staked"))
1298
+
                                        let aD = toBase58String(an)
1299
+
                                        let eU = ar(aD)
1300
+
                                        if (isDefined(getInteger(eU)))
1301
+
                                            then throw((("NFT " + eT.name) + " is already staked"))
1299
1302
 
                                            else {
1300
-
                                                let eW = split(eS.description, "_")
1301
-
                                                let ck = cq(eW[bb])
1302
-
                                                let eH = cs(eW[ba])
1303
-
                                                let bZ = cp(ck, (eH / m), 1)
1304
-
                                                let eI = valueOrElse(getInteger(aH(N, aR)), if (valueOrElse(getBoolean(aF(aR)), false))
1305
-
                                                    then eH
1303
+
                                                let eX = split(eT.description, "_")
1304
+
                                                let cl = cr(eX[ba])
1305
+
                                                let eI = ct(eX[aZ])
1306
+
                                                let ca = cq(cl, (eI / m), 1)
1307
+
                                                let eJ = valueOrElse(getInteger(ax(N, aD)), if (valueOrElse(getBoolean(av(aD)), false))
1308
+
                                                    then eI
1306
1309
 
                                                    else 0)
1307
-
                                                let fP = getString(aV(Q))
1308
-
                                                let fK = if (isDefined(fP))
1309
-
                                                    then split_51C(value(fP), "_")
1310
+
                                                let fQ = getString(aF(Q))
1311
+
                                                let fL = if (isDefined(fQ))
1312
+
                                                    then split_51C(value(fQ), "_")
1310
1313
 
                                                    else nil
1311
-
                                                if (containsElement(fK, aR))
1312
-
                                                    then throw(("Your staked lands already contain " + aR))
1313
-
                                                    else [IntegerEntry(eT, lastBlock.timestamp), IntegerEntry(aL(i, aR, Q), lastBlock.timestamp), StringEntry(aV(Q), makeString_11C((fK :+ aR), "_")), StringEntry(ao(aR), Q), StringEntry(aN(al), Q), IntegerEntry(aJ(N, aR, Q), eI), StringEntry(aU(), bZ), gc]
1314
+
                                                if (containsElement(fL, aD))
1315
+
                                                    then throw(("Your staked lands already contain " + aD))
1316
+
                                                    else [IntegerEntry(eU, lastBlock.timestamp), IntegerEntry(aA(i, aD, Q), lastBlock.timestamp), StringEntry(aF(Q), makeString_11C((fL :+ aD), "_")), StringEntry(am(aD), Q), StringEntry(aE(al), Q), IntegerEntry(az(N, aD, Q), eJ), StringEntry(aT(), ca), gd]
1314
1317
 
                                                }
1315
1318
 
                                        }
1316
1319
 
                                }
1317
1320
 
                    }
1318
1321
 
            }
1319
1322
 
    }
1320
1323
 
1321
1324
 
1322
1325
 
1323
-
@Callable(co)
1324
-
func unstakeLand (eN) = {
1325
-
    let gc = fZ(co)
1326
-
    if ((size(co.payments) != 0))
1326
+
@Callable(cp)
1327
+
func unstakeLand (eO) = {
1328
+
    let gd = ga(cp)
1329
+
    if ((size(cp.payments) != 0))
1327
1330
 
        then throw("No payments required")
1328
1331
 
        else {
1329
-
            let ai = toString(co.caller)
1330
-
            let eY = eL(ai, bu, eN)
1331
-
            let aR = eY._2
1332
-
            let fO = aV(ai)
1333
-
            let ck = cq(eY._3[bb])
1334
-
            let eH = cs(eY._3[ba])
1335
-
            let bZ = cp(ck, (eH / m), -1)
1336
-
            let fr = fk(ai, aR, eH, bu)
1337
-
            let fK = split_51C(valueOrElse(getString(fO), ""), "_")
1338
-
            let ad = indexOf(fK, aR)
1332
+
            let ai = toString(cp.caller)
1333
+
            let eZ = eM(ai, bt, eO)
1334
+
            let aD = eZ._2
1335
+
            let fP = aF(ai)
1336
+
            let cl = cr(eZ._3[ba])
1337
+
            let eI = ct(eZ._3[aZ])
1338
+
            let ca = cq(cl, (eI / m), -1)
1339
+
            let fs = fl(ai, aD, eI, bt)
1340
+
            let fL = split_51C(valueOrElse(getString(fP), ""), "_")
1341
+
            let ad = indexOf(fL, aD)
1339
1342
 
            if (!(isDefined(ad)))
1340
-
                then throw(("Your staked lands don't contain " + aR))
1343
+
                then throw(("Your staked lands don't contain " + aD))
1341
1344
 
                else {
1342
-
                    let da = value(blockInfoByHeight(height)).timestamp
1343
-
                    let gf = valueOrElse(getInteger(ag, aX(ai)), 0)
1344
-
                    if ((gf >= da))
1345
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(gf)))
1346
-
                        else [ScriptTransfer(co.caller, 1, fromBase58String(aR)), DeleteEntry(aB(aR)), DeleteEntry(aL(i, aR, ai)), StringEntry(aU(), bZ), StringEntry(fr._2, makeString(fr._3, ":")), if ((size(fK) > 1))
1347
-
                            then StringEntry(fO, makeString_11C(removeByIndex(fK, value(ad)), "_"))
1348
-
                            else DeleteEntry(fO), gc]
1345
+
                    let db = value(blockInfoByHeight(height)).timestamp
1346
+
                    let gg = valueOrElse(getInteger(ag, aV(ai)), 0)
1347
+
                    if ((gg >= db))
1348
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(gg)))
1349
+
                        else [ScriptTransfer(cp.caller, 1, fromBase58String(aD)), DeleteEntry(ar(aD)), DeleteEntry(aA(i, aD, ai)), StringEntry(aT(), ca), StringEntry(fs._2, makeString(fs._3, ":")), if ((size(fL) > 1))
1350
+
                            then StringEntry(fP, makeString_11C(removeByIndex(fL, value(ad)), "_"))
1351
+
                            else DeleteEntry(fP), gd]
1349
1352
 
                    }
1350
1353
 
            }
1351
1354
 
    }
1352
1355
 
1353
1356
 
1354
1357
 
1355
-
@Callable(co)
1358
+
@Callable(cp)
1356
1359
 
func stakeDuck () = {
1357
-
    let gc = fZ(co)
1358
-
    if ((size(co.payments) != 1))
1360
+
    let gd = ga(cp)
1361
+
    if ((size(cp.payments) != 1))
1359
1362
 
        then throw("Exactly one payment required")
1360
1363
 
        else {
1361
-
            let gd = value(co.payments[0])
1362
-
            let ap = value(gd.assetId)
1363
-
            let Q = toString(co.caller)
1364
-
            if ((gd.amount != 1))
1364
+
            let ge = value(cp.payments[0])
1365
+
            let an = value(ge.assetId)
1366
+
            let Q = toString(cp.caller)
1367
+
            if ((ge.amount != 1))
1365
1368
 
                then throw((("NFT " + j) + " token should be attached as payment"))
1366
1369
 
                else {
1367
-
                    let eS = value(assetInfo(ap))
1368
-
                    if (if ((eS.issuer != d))
1369
-
                        then (eS.issuer != e)
1370
+
                    let eT = value(assetInfo(an))
1371
+
                    if (if ((eT.issuer != d))
1372
+
                        then (eT.issuer != e)
1370
1373
 
                        else false)
1371
1374
 
                        then throw((("Unknown issuer of " + j) + " token"))
1372
-
                        else if (!(contains(eS.name, j)))
1375
+
                        else if (!(contains(eT.name, j)))
1373
1376
 
                            then throw((("Only NFT " + j) + " tokens are accepted"))
1374
1377
 
                            else {
1375
-
                                let gg = toBase58String(ap)
1376
-
                                let eT = aB(gg)
1377
-
                                if (isDefined(getInteger(eT)))
1378
-
                                    then throw((("NFT " + eS.name) + " is already staked"))
1379
-
                                    else if (isDefined(getString(aK(Q))))
1380
-
                                        then throw(("You already staked one duck: " + eS.name))
1378
+
                                let gh = toBase58String(an)
1379
+
                                let eU = ar(gh)
1380
+
                                if (isDefined(getInteger(eU)))
1381
+
                                    then throw((("NFT " + eT.name) + " is already staked"))
1382
+
                                    else if (isDefined(getString(aO(Q))))
1383
+
                                        then throw(("You already staked one duck: " + eT.name))
1381
1384
 
                                        else {
1382
-
                                            let gh = aS(gg)
1383
-
                                            let gi = getString(gh)
1384
-
                                            let dc = aO(gg)
1385
-
                                            let gj = getString(dc)
1386
-
                                            ([IntegerEntry(eT, lastBlock.timestamp), IntegerEntry(aL(j, toBase58String(ap), Q), lastBlock.timestamp), StringEntry(aA(gg), Q), StringEntry(aK(Q), gg)] ++ (if (isDefined(gi))
1385
+
                                            let gi = aR(gh)
1386
+
                                            let gj = getString(gi)
1387
+
                                            let dd = aP(gh)
1388
+
                                            let gk = getString(dd)
1389
+
                                            ([IntegerEntry(eU, lastBlock.timestamp), IntegerEntry(aA(j, toBase58String(an), Q), lastBlock.timestamp), StringEntry(aN(gh), Q), StringEntry(aO(Q), gh)] ++ (if (isDefined(gj))
1387
1390
 
                                                then nil
1388
-
                                                else ([StringEntry(gh, k)] ++ (if (isDefined(gj))
1391
+
                                                else ([StringEntry(gi, k)] ++ (if (isDefined(gk))
1389
1392
 
                                                    then nil
1390
-
                                                    else (([StringEntry(dc, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aT(gg), 100)) :+ gc)))))
1393
+
                                                    else (([StringEntry(dd, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aS(gh), 100)) :+ gd)))))
1391
1394
 
                                            }
1392
1395
 
                                }
1393
1396
 
                    }
1394
1397
 
            }
1395
1398
 
    }
1396
1399
 
1397
1400
 
1398
1401
 
1399
-
@Callable(co)
1400
-
func unstakeDuck (gg) = {
1401
-
    let gc = fZ(co)
1402
-
    if ((size(co.payments) != 0))
1402
+
@Callable(cp)
1403
+
func unstakeDuck (gh) = {
1404
+
    let gd = ga(cp)
1405
+
    if ((size(cp.payments) != 0))
1403
1406
 
        then throw("No payments required")
1404
1407
 
        else {
1405
-
            let ap = fromBase58String(gg)
1406
-
            let Q = toString(co.caller)
1407
-
            let eS = value(assetInfo(ap))
1408
-
            let eT = aB(toBase58String(ap))
1409
-
            if (!(isDefined(getInteger(eT))))
1410
-
                then throw((("NFT " + eS.name) + " is not staked"))
1411
-
                else if (!(isDefined(getString(aK(Q)))))
1412
-
                    then throw((("The duck " + eS.name) + " is not staked"))
1408
+
            let an = fromBase58String(gh)
1409
+
            let Q = toString(cp.caller)
1410
+
            let eT = value(assetInfo(an))
1411
+
            let eU = ar(toBase58String(an))
1412
+
            if (!(isDefined(getInteger(eU))))
1413
+
                then throw((("NFT " + eT.name) + " is not staked"))
1414
+
                else if (!(isDefined(getString(aO(Q)))))
1415
+
                    then throw((("The duck " + eT.name) + " is not staked"))
1413
1416
 
                    else {
1414
-
                        let eV = valueOrErrorMessage(getString(aA(toBase58String(ap))), (("NFT " + eS.name) + " is orphaned"))
1415
-
                        if ((eV != Q))
1417
+
                        let eW = valueOrErrorMessage(getString(aN(toBase58String(an))), (("NFT " + eT.name) + " is orphaned"))
1418
+
                        if ((eW != Q))
1416
1419
 
                            then throw("Staked NFT is not yours")
1417
1420
 
                            else {
1418
-
                                let eB = aT(gg)
1419
-
                                let gk = valueOrElse(getInteger(eB), 100)
1420
-
                                if ((100 > gk))
1421
+
                                let eC = aS(gh)
1422
+
                                let gl = valueOrElse(getInteger(eC), 100)
1423
+
                                if ((100 > gl))
1421
1424
 
                                    then throw("Please heal your duck before unstaking")
1422
-
                                    else [ScriptTransfer(co.caller, 1, ap), DeleteEntry(eT), DeleteEntry(eB), DeleteEntry(aS(gg)), DeleteEntry(aA(gg)), DeleteEntry(aL(j, gg, Q)), DeleteEntry(aK(Q)), gc]
1425
+
                                    else [ScriptTransfer(cp.caller, 1, an), DeleteEntry(eU), DeleteEntry(eC), DeleteEntry(aR(gh)), DeleteEntry(aN(gh)), DeleteEntry(aA(j, gh, Q)), DeleteEntry(aO(Q)), gd]
1423
1426
 
                                }
1424
1427
 
                        }
1425
1428
 
            }
1426
1429
 
    }
1427
1430
 
1428
1431
 
1429
1432
 
1430
-
@Callable(co)
1431
-
func claimRes (cv,gl) = {
1432
-
    let gc = fZ(co)
1433
-
    if ((size(co.payments) != 0))
1433
+
@Callable(cp)
1434
+
func claimRes (cw,gm) = {
1435
+
    let gd = ga(cp)
1436
+
    if ((size(cp.payments) != 0))
1434
1437
 
        then throw("No payments required")
1435
1438
 
        else {
1436
-
            let ai = toString(co.originCaller)
1437
-
            let ch = eX(ai, cv, bu, gl)
1438
-
            $Tuple2((((ch._1 :+ StringEntry(ch._2, makeString(ch._3, ":"))) :+ StringEntry(ch._4, makeString(ch._5, ":"))) :+ gc), ch._3[bh])
1439
+
            let ai = toString(cp.originCaller)
1440
+
            let ci = eY(ai, cw, bt, gm)
1441
+
            $Tuple2((((ci._1 :+ StringEntry(ci._2, makeString(ci._3, ":"))) :+ StringEntry(ci._4, makeString(ci._5, ":"))) :+ gd), ci._3[bg])
1439
1442
 
            }
1440
1443
 
    }
1441
1444
 
1442
1445
 
1443
1446
 
1444
-
@Callable(co)
1445
-
func claimResToWH (cv,gl) = {
1446
-
    let gc = fZ(co)
1447
-
    if ((size(co.payments) != 0))
1447
+
@Callable(cp)
1448
+
func claimResToWH (cw,gm) = {
1449
+
    let gd = ga(cp)
1450
+
    if ((size(cp.payments) != 0))
1448
1451
 
        then throw("No payments required")
1449
1452
 
        else {
1450
-
            let ai = toString(co.originCaller)
1451
-
            let ch = eX(ai, cv, bt, gl)
1452
-
            $Tuple2((((ch._1 :+ StringEntry(ch._2, makeString(ch._3, ":"))) :+ StringEntry(ch._4, makeString(ch._5, ":"))) :+ gc), ch._5[bl])
1453
+
            let ai = toString(cp.originCaller)
1454
+
            let ci = eY(ai, cw, bs, gm)
1455
+
            $Tuple2((((ci._1 :+ StringEntry(ci._2, makeString(ci._3, ":"))) :+ StringEntry(ci._4, makeString(ci._5, ":"))) :+ gd), ci._5[bk])
1453
1456
 
            }
1454
1457
 
    }
1455
1458
 
1456
1459
 
1457
1460
 
1458
-
@Callable(co)
1459
-
func flight (et,eu) = {
1460
-
    let gc = fZ(co)
1461
-
    if (!(sigVerify_8Kb(et, eu, g)))
1461
+
@Callable(cp)
1462
+
func flight (eu,ev) = {
1463
+
    let gd = ga(cp)
1464
+
    if (!(sigVerify_8Kb(eu, ev, g)))
1462
1465
 
        then throw("signature does not match")
1463
-
        else if ((size(co.payments) != 0))
1466
+
        else if ((size(cp.payments) != 0))
1464
1467
 
            then throw("No payments required")
1465
1468
 
            else {
1466
-
                let dg = split(toUtf8String(et), ";")
1467
-
                let gm = split(dg[0], "|")
1468
-
                let ev = split(gm[bw], "_")
1469
-
                let ew = parseIntValue(ev[0])
1470
-
                let ex = parseIntValue(ev[1])
1471
-
                let gn = split(dg[1], ":")
1472
-
                let go = gn[0]
1473
-
                let eA = parseIntValue(gm[bB])
1474
-
                if (if ((eA > (lastBlock.timestamp + t)))
1469
+
                let dh = split(toUtf8String(eu), ";")
1470
+
                let gn = split(dh[0], "|")
1471
+
                let ew = split(gn[bv], "_")
1472
+
                let ex = parseIntValue(ew[0])
1473
+
                let ey = parseIntValue(ew[1])
1474
+
                let go = split(dh[1], ":")
1475
+
                let gp = go[0]
1476
+
                let eB = parseIntValue(gn[bA])
1477
+
                if (if ((eB > (lastBlock.timestamp + t)))
1475
1478
 
                    then true
1476
-
                    else ((lastBlock.timestamp - t) > eA))
1479
+
                    else ((lastBlock.timestamp - t) > eB))
1477
1480
 
                    then throw("signature outdated")
1478
1481
 
                    else {
1479
-
                        let gp = gn[1]
1480
-
                        let gq = valueOrElse(getString(ah(toString(co.originCaller))), "")
1481
-
                        if ((gq != gp))
1482
-
                            then throw(((("Tx ids don't match! In state: " + gq) + ", in msg: ") + gp))
1482
+
                        let gq = go[1]
1483
+
                        let gr = valueOrElse(getString(ah(toString(cp.originCaller))), "")
1484
+
                        if ((gr != gq))
1485
+
                            then throw(((("Tx ids don't match! In state: " + gr) + ", in msg: ") + gq))
1483
1486
 
                            else {
1484
-
                                let aY = toString(co.caller)
1485
-
                                let aP = valueOrErrorMessage(getString(aK(aY)), "You don't have a duck staked")
1486
-
                                let eB = aT(aP)
1487
-
                                let eC = valueOrElse(getInteger(eB), 100)
1488
-
                                if ((eC != ew))
1489
-
                                    then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eB), 100))) + " from state does not match one from flight log=") + toString(ew)))
1490
-
                                    else if ((0 >= ew))
1487
+
                                let aW = toString(cp.caller)
1488
+
                                let aQ = valueOrErrorMessage(getString(aO(aW)), "You don't have a duck staked")
1489
+
                                let eC = aS(aQ)
1490
+
                                let eD = valueOrElse(getInteger(eC), 100)
1491
+
                                if ((eD != ex))
1492
+
                                    then throw(((("oldHealth=" + toString(valueOrElse(getInteger(eC), 100))) + " from state does not match one from flight log=") + toString(ex)))
1493
+
                                    else if ((0 >= ex))
1491
1494
 
                                        then throw("You can't fly with zero health")
1492
1495
 
                                        else {
1493
-
                                            let gh = aS(aP)
1494
-
                                            let eP = valueOrElse(getString(gh), k)
1495
-
                                            if ((go == eP))
1496
+
                                            let gi = aR(aQ)
1497
+
                                            let eQ = valueOrElse(getString(gi), k)
1498
+
                                            if ((gp == eQ))
1496
1499
 
                                                then throw("You can't fly to the same location")
1497
1500
 
                                                else {
1498
-
                                                    let gr = if ((size(gm) > bC))
1499
-
                                                        then gm[bC]
1501
+
                                                    let gs = if ((size(gn) > bB))
1502
+
                                                        then gn[bB]
1500
1503
 
                                                        else ""
1501
-
                                                    let gs = if (if ((ex > 0))
1502
-
                                                        then (gr == "$")
1504
+
                                                    let gt = if (if ((ey > 0))
1505
+
                                                        then (gs == "$")
1503
1506
 
                                                        else false)
1504
-
                                                        then bH(invoke(ae, "sendUsdtPrize", [aY], nil))
1507
+
                                                        then bI(invoke(ae, "sendUsdtPrize", [aW], nil))
1505
1508
 
                                                        else 0
1506
-
                                                    $Tuple2([StringEntry(gh, if ((ex > 0))
1507
-
                                                        then go
1508
-
                                                        else eP), IntegerEntry(eB, ex), gc], gs)
1509
+
                                                    $Tuple2([StringEntry(gi, if ((ey > 0))
1510
+
                                                        then gp
1511
+
                                                        else eQ), IntegerEntry(eC, ey), gd], gt)
1509
1512
 
                                                    }
1510
1513
 
                                            }
1511
1514
 
                                }
1512
1515
 
                        }
1513
1516
 
                }
1514
1517
 
    }
1515
1518
 
1516
1519
 
1517
1520
 
1518
-
@Callable(co)
1519
-
func setHealth (gk,aP) = {
1520
-
    let gc = fZ(co)
1521
-
    if (if ((0 > gk))
1521
+
@Callable(cp)
1522
+
func setHealth (gl,aQ) = {
1523
+
    let gd = ga(cp)
1524
+
    if (if ((0 > gl))
1522
1525
 
        then true
1523
-
        else (gk > 100))
1526
+
        else (gl > 100))
1524
1527
 
        then throw("HP should be within 0..100")
1525
-
        else [IntegerEntry(aT(aP), gk), gc]
1528
+
        else [IntegerEntry(aS(aQ), gl), gd]
1526
1529
 
    }
1527
1530
 
1528
1531
 
1529
1532
 
1530
-
@Callable(co)
1531
-
func heal (gt,cv) = {
1532
-
    let gc = fZ(co)
1533
-
    if (if ((0 > gt))
1533
+
@Callable(cp)
1534
+
func heal (gu,cw) = {
1535
+
    let gd = ga(cp)
1536
+
    if (if ((0 > gu))
1534
1537
 
        then true
1535
-
        else (gt >= l))
1536
-
        then throw(("Unknown material: " + toString(gt)))
1537
-
        else if ((0 >= cv))
1538
-
            then throw(("Amount should be positive! " + toString(cv)))
1538
+
        else (gu >= l))
1539
+
        then throw(("Unknown material: " + toString(gu)))
1540
+
        else if ((0 >= cw))
1541
+
            then throw(("Amount should be positive! " + toString(cw)))
1539
1542
 
            else {
1540
-
                let aP = valueOrErrorMessage(getString(aK(toString(co.caller))), "You don't have a duck staked")
1541
-
                let eB = aT(aP)
1542
-
                let gu = valueOrElse(getInteger(eB), 100)
1543
-
                if ((gu >= 100))
1543
+
                let aQ = valueOrErrorMessage(getString(aO(toString(cp.caller))), "You don't have a duck staked")
1544
+
                let eC = aS(aQ)
1545
+
                let gv = valueOrElse(getInteger(eC), 100)
1546
+
                if ((gv >= 100))
1544
1547
 
                    then throw("HP should be < 100 to heal")
1545
1548
 
                    else {
1546
-
                        let dc = aO(aP)
1547
-
                        let dO = db(dc)
1548
-
                        let eD = split(dO[bi], "_")
1549
-
                        let gv = parseIntValue(eD[gt])
1550
-
                        let gw = min([(cv / h), (100 - gu)])
1551
-
                        let gx = (gw * h)
1552
-
                        if ((gx > gv))
1553
-
                            then throw(((((("You need " + toString(gx)) + " of ") + L[gt]) + " to heal, but you backpack contains ") + toString(gv)))
1549
+
                        let dd = aP(aQ)
1550
+
                        let dP = dc(dd)
1551
+
                        let eE = split(dP[bh], "_")
1552
+
                        let gw = parseIntValue(eE[gu])
1553
+
                        let gx = min([(cw / h), (100 - gv)])
1554
+
                        let gy = (gx * h)
1555
+
                        if ((gy > gw))
1556
+
                            then throw(((((("You need " + toString(gy)) + " of ") + L[gu]) + " to heal, but you backpack contains ") + toString(gw)))
1554
1557
 
                            else {
1555
-
                                let eE = ct(eD, gt, gx)
1556
-
[IntegerEntry(eB, (gu + gw)), StringEntry(dc, makeString([dO[bg], dO[bh], eE, dO[bj]], ":")), gc]
1558
+
                                let eF = cu(eE, gu, gy)
1559
+
[IntegerEntry(eC, (gv + gx)), StringEntry(dd, makeString([dP[bf], dP[bg], eF, dP[bi]], ":")), gd]
1557
1560
 
                                }
1558
1561
 
                        }
1559
1562
 
                }
1560
1563
 
    }
1561
1564
 
1562
1565
 
1563
1566
 
1564
-
@Callable(co)
1565
-
func updateBackpack (aP,gy) = {
1566
-
    let gc = fZ(co)
1567
-
    if ((co.caller != af))
1567
+
@Callable(cp)
1568
+
func updateBackpack (aQ,gz) = {
1569
+
    let gd = ga(cp)
1570
+
    if ((cp.caller != af))
1568
1571
 
        then throw("permission denied")
1569
-
        else $Tuple2([StringEntry(aO(aP), gy), gc], gy)
1572
+
        else $Tuple2([StringEntry(aP(aQ), gz), gd], gz)
1570
1573
 
    }
1571
1574
 
1572
1575
 
1573
1576
 
1574
-
@Callable(co)
1577
+
@Callable(cp)
1575
1578
 
func buySLand () = {
1576
-
    let gc = fZ(co)
1577
-
    if ((size(co.payments) != 1))
1579
+
    let gd = ga(cp)
1580
+
    if ((size(cp.payments) != 1))
1578
1581
 
        then throw("Exactly one payment required")
1579
1582
 
        else {
1580
-
            let gd = value(co.payments[0])
1581
-
            if ((gd.assetId != b))
1583
+
            let ge = value(cp.payments[0])
1584
+
            if ((ge.assetId != b))
1582
1585
 
                then throw("Allowed USDT payment only!")
1583
-
                else if ((gd.amount != B))
1586
+
                else if ((ge.amount != B))
1584
1587
 
                    then throw(("Payment attached should be " + toString(B)))
1585
1588
 
                    else {
1586
-
                        let ch = ek(co.caller, co.transactionId)
1587
-
                        $Tuple2(((ch._1 :+ ScriptTransfer(af, gd.amount, b)) :+ gc), ch._2._1)
1589
+
                        let ci = el(cp.caller, cp.transactionId)
1590
+
                        $Tuple2(((ci._1 :+ ScriptTransfer(af, ge.amount, b)) :+ gd), ci._2._1)
1588
1591
 
                        }
1589
1592
 
            }
1590
1593
 
    }
1591
1594
 
1592
1595
 
1593
1596
 
1594
-
@Callable(co)
1595
-
func expedition (et,eu) = {
1596
-
    let gc = fZ(co)
1597
-
    if ((size(co.payments) != 0))
1597
+
@Callable(cp)
1598
+
func expedition (eu,ev) = {
1599
+
    let gd = ga(cp)
1600
+
    if ((size(cp.payments) != 0))
1598
1601
 
        then throw("No payments required")
1599
1602
 
        else {
1600
-
            let ch = es(true, co.caller, co.transactionId, et, eu)
1601
-
            $Tuple2((ch._1 :+ gc), ch._2)
1603
+
            let ci = et(true, cp.caller, cp.transactionId, eu, ev)
1604
+
            $Tuple2((ci._1 :+ gd), ci._2)
1602
1605
 
            }
1603
1606
 
    }
1604
1607
 
1605
1608
 
1606
1609
 
1607
-
@Callable(co)
1608
-
func upgradeInfra (aR) = {
1609
-
    let gc = fZ(co)
1610
-
    if ((size(co.payments) != 0))
1610
+
@Callable(cp)
1611
+
func upgradeInfra (aD) = {
1612
+
    let gd = ga(cp)
1613
+
    if ((size(cp.payments) != 0))
1611
1614
 
        then throw("No payments required")
1612
1615
 
        else {
1613
-
            let ch = fl(true, co.caller, 0, aR)
1614
-
            $Tuple2((ch._1 :+ gc), ch._2)
1616
+
            let ci = fm(true, cp.caller, 0, aD)
1617
+
            $Tuple2((ci._1 :+ gd), ci._2)
1615
1618
 
            }
1616
1619
 
    }
1617
1620
 
1618
1621
 
1619
1622
 
1620
-
@Callable(co)
1621
-
func upgradeInfraUsdt (aR) = if ((co.caller != this))
1623
+
@Callable(cp)
1624
+
func upgradeInfraUsdt (aD) = if ((cp.caller != this))
1622
1625
 
    then throw("Permission denied")
1623
1626
 
    else {
1624
-
        let gc = fZ(co)
1625
-
        if ((size(co.payments) != 1))
1627
+
        let gd = ga(cp)
1628
+
        if ((size(cp.payments) != 1))
1626
1629
 
            then throw("Exactly one payment required")
1627
1630
 
            else {
1628
-
                let gd = value(co.payments[0])
1629
-
                if ((gd.assetId != b))
1631
+
                let ge = value(cp.payments[0])
1632
+
                if ((ge.assetId != b))
1630
1633
 
                    then throw("Allowed USDT payment only!")
1631
1634
 
                    else {
1632
-
                        let ch = fl(false, co.caller, gd.amount, aR)
1633
-
                        $Tuple2(((ch._1 :+ ScriptTransfer(af, gd.amount, b)) :+ gc), ch._2)
1635
+
                        let ci = fm(false, cp.caller, ge.amount, aD)
1636
+
                        $Tuple2(((ci._1 :+ ScriptTransfer(af, ge.amount, b)) :+ gd), ci._2)
1634
1637
 
                        }
1635
1638
 
                }
1636
1639
 
        }
1637
1640
 
1638
1641
 
1639
1642
 
1640
-
@Callable(co)
1641
-
func activateArtifact (gz,aR) = {
1642
-
    let gc = fZ(co)
1643
-
    if ((size(co.payments) != 0))
1643
+
@Callable(cp)
1644
+
func activateArtifact (gA,aD) = {
1645
+
    let gd = ga(cp)
1646
+
    if ((size(cp.payments) != 0))
1644
1647
 
        then throw("No payments required")
1645
1648
 
        else {
1646
-
            let ch = {
1647
-
                let c = gz
1649
+
            let ci = {
1650
+
                let c = gA
1648
1651
 
                if (("PRESALE" == c))
1649
-
                    then fy(toString(co.caller), aR)
1652
+
                    then fz(toString(cp.caller), aD)
1650
1653
 
                    else throw("Unknown artifact")
1651
1654
 
                }
1652
-
            (ch :+ gc)
1655
+
            (ci :+ gd)
1653
1656
 
            }
1654
1657
 
    }
1655
1658
 
1656
1659
 
1657
1660
 
1658
-
@Callable(co)
1659
-
func mergeLands (fD) = {
1660
-
    let gc = fZ(co)
1661
-
    if ((size(co.payments) != 0))
1661
+
@Callable(cp)
1662
+
func mergeLands (fE) = {
1663
+
    let gd = ga(cp)
1664
+
    if ((size(cp.payments) != 0))
1662
1665
 
        then throw("No payments required")
1663
1666
 
        else {
1664
-
            let ch = fX(true, toString(co.caller), 0, fD, co.transactionId)
1665
-
            $Tuple2((ch._1 :+ gc), ch._2)
1667
+
            let ci = fY(true, toString(cp.caller), 0, fE, cp.transactionId)
1668
+
            $Tuple2((ci._1 :+ gd), ci._2)
1666
1669
 
            }
1667
1670
 
    }
1668
1671
 
1669
1672
 
1670
1673
 
1671
-
@Callable(co)
1672
-
func mergeLandsUsdt (fD) = {
1673
-
    let gc = fZ(co)
1674
-
    if ((size(co.payments) != 1))
1674
+
@Callable(cp)
1675
+
func mergeLandsUsdt (fE) = {
1676
+
    let gd = ga(cp)
1677
+
    if ((size(cp.payments) != 1))
1675
1678
 
        then throw("Exactly one payment required")
1676
1679
 
        else {
1677
-
            let gd = value(co.payments[0])
1678
-
            if ((gd.assetId != b))
1680
+
            let ge = value(cp.payments[0])
1681
+
            if ((ge.assetId != b))
1679
1682
 
                then throw("Allowed USDT payment only!")
1680
1683
 
                else {
1681
-
                    let ch = fX(false, toString(co.caller), gd.amount, fD, co.transactionId)
1682
-
                    $Tuple2(((ch._1 :+ ScriptTransfer(af, gd.amount, b)) :+ gc), ch._2)
1684
+
                    let ci = fY(false, toString(cp.caller), ge.amount, fE, cp.transactionId)
1685
+
                    $Tuple2(((ci._1 :+ ScriptTransfer(af, ge.amount, b)) :+ gd), ci._2)
1683
1686
 
                    }
1684
1687
 
            }
1685
1688
 
    }
1686
1689
 
1687
1690
 
1688
1691
 
1689
-
@Callable(co)
1690
-
func cargoExchange (gA,aR) = {
1691
-
    let gc = fZ(co)
1692
-
    if ((size(co.payments) != 0))
1692
+
@Callable(cp)
1693
+
func cargoExchange (gB,aD) = {
1694
+
    let gd = ga(cp)
1695
+
    if ((size(cp.payments) != 0))
1693
1696
 
        then throw("No payments required")
1694
1697
 
        else {
1695
-
            let dN = split_4C(gA, ":")
1696
-
            let ai = toString(co.originCaller)
1697
-
            let eS = value(assetInfo(fromBase58String(aR)))
1698
-
            let eT = aB(aR)
1699
-
            if (!(isDefined(getInteger(eT))))
1700
-
                then throw((eS.name + " is not staked"))
1698
+
            let dO = split_4C(gB, ":")
1699
+
            let ai = toString(cp.originCaller)
1700
+
            let eT = value(assetInfo(fromBase58String(aD)))
1701
+
            let eU = ar(aD)
1702
+
            if (!(isDefined(getInteger(eU))))
1703
+
                then throw((eT.name + " is not staked"))
1701
1704
 
                else {
1702
-
                    let eV = valueOrErrorMessage(getString(ao(aR)), (("NFT " + eS.name) + " is orphaned"))
1703
-
                    if ((eV != ai))
1705
+
                    let eW = valueOrErrorMessage(getString(am(aD)), (("NFT " + eT.name) + " is orphaned"))
1706
+
                    if ((eW != ai))
1704
1707
 
                        then throw((i + " is not yours"))
1705
1708
 
                        else {
1706
-
                            let dy = (cs(split(eS.description, "_")[ba]) / m)
1707
-
                            let dz = valueOrElse(getInteger(aC(aR)), 0)
1708
-
                            let aP = valueOrErrorMessage(getString(aK(ai)), "You don't have a duck staked")
1709
-
                            let eP = valueOrElse(getString(aS(aP)), k)
1710
-
                            let eQ = split(value(eP), "_")
1711
-
                            if ((eQ[be] != "L"))
1712
-
                                then throw((("Duck location type is " + eQ[be]) + ", but should be L"))
1713
-
                                else if ((eQ[bf] != aR))
1714
-
                                    then throw(("Duck should be on the land " + aR))
1709
+
                            let dz = (ct(split(eT.description, "_")[aZ]) / m)
1710
+
                            let dA = valueOrElse(getInteger(as(aD)), 0)
1711
+
                            let aQ = valueOrErrorMessage(getString(aO(ai)), "You don't have a duck staked")
1712
+
                            let eQ = valueOrElse(getString(aR(aQ)), k)
1713
+
                            let eR = split(value(eQ), "_")
1714
+
                            if ((eR[bd] != "L"))
1715
+
                                then throw((("Duck location type is " + eR[bd]) + ", but should be L"))
1716
+
                                else if ((eR[be] != aD))
1717
+
                                    then throw(("Duck should be on the land " + aD))
1715
1718
 
                                    else {
1716
-
                                        let dx = aQ(aR)
1717
-
                                        let di = dw(dx, dy, dz)
1718
-
                                        let dc = aO(aP)
1719
-
                                        let dO = db(dc)
1720
-
                                        let ch = dM(dN, di, dO)
1721
-
                                        let dF = split(di[bo], "_")
1722
-
                                        let fi = (parseIntValue(dF[bq]) + ch._7)
1723
-
                                        let fj = (parseIntValue(dF[br]) - ch._7)
1724
-
[StringEntry(dc, makeString_2C([dO[bg], ch._4, ch._5, ch._6], ":")), StringEntry(dx, makeString_2C([di[bk], ch._1, ch._2, ch._3, makeString([dF[bp], toString(fi), toString(fj), dF[bs]], "_")], ":")), gc]
1719
+
                                        let dy = aC(aD)
1720
+
                                        let dj = dx(dy, dz, dA)
1721
+
                                        let dd = aP(aQ)
1722
+
                                        let dP = dc(dd)
1723
+
                                        let ci = dN(dO, dj, dP)
1724
+
                                        let dG = split(dj[bn], "_")
1725
+
                                        let fj = (parseIntValue(dG[bp]) + ci._7)
1726
+
                                        let fk = (parseIntValue(dG[bq]) - ci._7)
1727
+
[StringEntry(dd, makeString_2C([dP[bf], ci._4, ci._5, ci._6], ":")), StringEntry(dy, makeString_2C([dj[bj], ci._1, ci._2, ci._3, makeString([dG[bo], toString(fj), toString(fk), dG[br]], "_")], ":")), gd]
1725
1728
 
                                        }
1726
1729
 
                            }
1727
1730
 
                    }
1728
1731
 
            }
1729
1732
 
    }
1730
1733
 
1731
1734
 
1732
1735
 
1733
-
@Callable(co)
1734
-
func saveWarehouse (dB,aR) = {
1735
-
    let gc = fZ(co)
1736
-
    if ((co.caller != af))
1736
+
@Callable(cp)
1737
+
func saveWarehouse (dC,aD) = {
1738
+
    let gd = ga(cp)
1739
+
    if ((cp.caller != af))
1737
1740
 
        then throw("Access denied")
1738
1741
 
        else {
1739
-
            let dx = aQ(aR)
1740
-
            let dC = split_4C(dB, ":")
1741
-
            if ((size(dC) != 5))
1742
+
            let dy = aC(aD)
1743
+
            let dD = split_4C(dC, ":")
1744
+
            if ((size(dD) != 5))
1742
1745
 
                then throw("warehouse string should contain 4 ':' separators")
1743
1746
 
                else {
1744
-
                    let gB = split(dC[bo], "_")[bp]
1745
-
                    let fi = dh(dC)
1746
-
                    let gC = de(dC[bk])
1747
-
                    let fj = ((gC - parseIntValue(gB)) - fi)
1748
-
                    let gD = makeString_2C([dC[bk], dC[bl], dC[bm], dC[bn], makeString([gB, toString(fi), toString(fj), toString(gC)], "_")], ":")
1749
-
                    $Tuple2([StringEntry(dx, gD), gc], gD)
1747
+
                    let gC = split(dD[bn], "_")[bo]
1748
+
                    let fj = di(dD)
1749
+
                    let gD = df(dD[bj])
1750
+
                    let fk = ((gD - parseIntValue(gC)) - fj)
1751
+
                    let gE = makeString_2C([dD[bj], dD[bk], dD[bl], dD[bm], makeString([gC, toString(fj), toString(fk), toString(gD)], "_")], ":")
1752
+
                    $Tuple2([StringEntry(dy, gE), gd], gE)
1750
1753
 
                    }
1751
1754
 
            }
1752
1755
 
    }
1753
1756
 
1754
1757
 
1755
1758
 
1756
-
@Callable(co)
1757
-
func replaceBooleanArtifact (aR) = if ((co.caller != ae))
1759
+
@Callable(cp)
1760
+
func replaceBooleanArtifact (aD) = if ((cp.caller != ae))
1758
1761
 
    then throw("Access denied")
1759
1762
 
    else {
1760
-
        let gE = aF(aR)
1761
-
        let gF = aH(N, aR)
1762
-
        let gG = getBoolean(gE)
1763
-
        if (isDefined(gG))
1763
+
        let gF = av(aD)
1764
+
        let gG = ax(N, aD)
1765
+
        let gH = getBoolean(gF)
1766
+
        if (isDefined(gH))
1764
1767
 
            then {
1765
-
                let eW = split(value(assetInfo(fromBase58String(aR))).description, "_")
1766
-
                let eH = cs(eW[ba])
1767
-
                let eI = valueOrElse(getInteger(gF), eH)
1768
-
                let eV = getString(ao(aR))
1769
-
                let gH = if (isDefined(eV))
1770
-
                    then [IntegerEntry(aJ(N, aR, value(eV)), eI), DeleteEntry(aG(aR, value(eV)))]
1768
+
                let eX = split(value(assetInfo(fromBase58String(aD))).description, "_")
1769
+
                let eI = ct(eX[aZ])
1770
+
                let eJ = valueOrElse(getInteger(gG), eI)
1771
+
                let eW = getString(am(aD))
1772
+
                let gI = if (isDefined(eW))
1773
+
                    then [IntegerEntry(az(N, aD, value(eW)), eJ), DeleteEntry(aw(aD, value(eW)))]
1771
1774
 
                    else nil
1772
-
                if (value(gG))
1773
-
                    then $Tuple2(((gH :+ IntegerEntry(gF, eI)) :+ DeleteEntry(gE)), 2)
1774
-
                    else $Tuple2([DeleteEntry(gE)], 1)
1775
+
                if (value(gH))
1776
+
                    then $Tuple2(((gI :+ IntegerEntry(gG, eJ)) :+ DeleteEntry(gF)), 2)
1777
+
                    else $Tuple2([DeleteEntry(gF)], 1)
1775
1778
 
                }
1776
1779
 
            else $Tuple2(nil, 0)
1777
1780
 
        }
1778
1781
 
1779
1782
 
1780
1783
 
1781
-
@Callable(co)
1782
-
func setCustomName (ap,fM,aI) = {
1783
-
    let gc = fZ(co)
1784
-
    if ((size(co.payments) != 1))
1784
+
@Callable(cp)
1785
+
func fixWarehouseFormat (aD) = if ((cp.caller != ae))
1786
+
    then throw("Access denied")
1787
+
    else {
1788
+
        let dy = aC(aD)
1789
+
        let eT = value(assetInfo(fromBase58String(aD)))
1790
+
        let dz = (ct(split(eT.description, "_")[aZ]) / m)
1791
+
        let dA = valueOrElse(getInteger(as(aD)), 0)
1792
+
        let dC = dx(dy, dz, dA)
1793
+
        let gJ = valueOrElse(getString(af, aX(aD)), "0@0_0@0_0@0_0@0_0@0_0@0:0@0_0@0_0@0_0@0_0@0_0@0:")
1794
+
        nil
1795
+
        }
1796
+
1797
+
1798
+
1799
+
@Callable(cp)
1800
+
func setCustomName (an,fN,ay) = {
1801
+
    let gd = ga(cp)
1802
+
    if ((size(cp.payments) != 1))
1785
1803
 
        then throw("Exactly one payment required")
1786
1804
 
        else {
1787
-
            let gd = value(co.payments[0])
1788
-
            if ((gd.assetId != b))
1805
+
            let ge = value(cp.payments[0])
1806
+
            if ((ge.assetId != b))
1789
1807
 
                then throw("Allowed USDT payment only!")
1790
-
                else if ((gd.amount != w))
1808
+
                else if ((ge.amount != w))
1791
1809
 
                    then throw(("Payment should be " + toString(w)))
1792
-
                    else if (contains(fM, "__"))
1793
-
                        then throw(("Name should not contain '__': " + fM))
1794
-
                        else if ((size(fM) > x))
1810
+
                    else if (contains(fN, "__"))
1811
+
                        then throw(("Name should not contain '__': " + fN))
1812
+
                        else if ((size(fN) > x))
1795
1813
 
                            then throw(("Name too long, maxLength=" + toString(x)))
1796
1814
 
                            else {
1797
-
                                let ai = toString(co.originCaller)
1798
-
                                let gI = {
1799
-
                                    let c = aI
1815
+
                                let ai = toString(cp.originCaller)
1816
+
                                let gK = {
1817
+
                                    let c = ay
1800
1818
 
                                    if (("ACCOUNT" == c))
1801
1819
 
                                        then {
1802
-
                                            let gJ = aw(fM)
1803
-
                                            let gK = getString(gJ)
1804
-
                                            if (isDefined(gK))
1805
-
                                                then throw(("Name already registered: " + fM))
1806
-
                                                else [StringEntry(as(ai), fM), StringEntry(gJ, ai)]
1820
+
                                            let gL = aJ(fN)
1821
+
                                            let gM = getString(gL)
1822
+
                                            if (isDefined(gM))
1823
+
                                                then throw(("Name already registered: " + fN))
1824
+
                                                else [StringEntry(aH(ai), fN), StringEntry(gL, ai)]
1807
1825
 
                                            }
1808
1826
 
                                        else if (("LAND" == c))
1809
1827
 
                                            then {
1810
-
                                                let eS = value(assetInfo(fromBase58String(ap)))
1811
-
                                                let eT = aB(ap)
1812
-
                                                if (!(isDefined(getInteger(eT))))
1813
-
                                                    then throw((eS.name + " is not staked"))
1828
+
                                                let eT = value(assetInfo(fromBase58String(an)))
1829
+
                                                let eU = ar(an)
1830
+
                                                if (!(isDefined(getInteger(eU))))
1831
+
                                                    then throw((eT.name + " is not staked"))
1814
1832
 
                                                    else {
1815
-
                                                        let eV = valueOrErrorMessage(getString(ao(ap)), (("NFT " + eS.name) + " is orphaned"))
1816
-
                                                        if ((eV != ai))
1833
+
                                                        let eW = valueOrErrorMessage(getString(am(an)), (("NFT " + eT.name) + " is orphaned"))
1834
+
                                                        if ((eW != ai))
1817
1835
 
                                                            then throw((i + " is not yours"))
1818
1836
 
                                                            else {
1819
-
                                                                let gJ = at(fM)
1820
-
                                                                let gK = getString(gJ)
1821
-
                                                                if (isDefined(gK))
1822
-
                                                                    then throw(("Name already registered: " + fM))
1823
-
                                                                    else [StringEntry(aq(ap), fM), StringEntry(gJ, ap)]
1837
+
                                                                let gL = ap(fN)
1838
+
                                                                let gM = getString(gL)
1839
+
                                                                if (isDefined(gM))
1840
+
                                                                    then throw(("Name already registered: " + fN))
1841
+
                                                                    else [StringEntry(ao(an), fN), StringEntry(gL, an)]
1824
1842
 
                                                                }
1825
1843
 
                                                        }
1826
1844
 
                                                }
1827
1845
 
                                            else if (("DUCK" == c))
1828
1846
 
                                                then {
1829
-
                                                    let eS = value(assetInfo(fromBase58String(ap)))
1830
-
                                                    let eT = aB(ap)
1831
-
                                                    if (if (!(isDefined(getInteger(eT))))
1847
+
                                                    let eT = value(assetInfo(fromBase58String(an)))
1848
+
                                                    let eU = ar(an)
1849
+
                                                    if (if (!(isDefined(getInteger(eU))))
1832
1850
 
                                                        then true
1833
-
                                                        else !(isDefined(getString(aK(ai)))))
1834
-
                                                        then throw((eS.name + " is not staked"))
1851
+
                                                        else !(isDefined(getString(aO(ai)))))
1852
+
                                                        then throw((eT.name + " is not staked"))
1835
1853
 
                                                        else {
1836
-
                                                            let eV = valueOrErrorMessage(getString(aA(ap)), (("NFT " + eS.name) + " is orphaned"))
1837
-
                                                            if ((eV != ai))
1854
+
                                                            let eW = valueOrErrorMessage(getString(aN(an)), (("NFT " + eT.name) + " is orphaned"))
1855
+
                                                            if ((eW != ai))
1838
1856
 
                                                                then throw((j + " is not yours"))
1839
1857
 
                                                                else {
1840
-
                                                                    let gJ = av(fM)
1841
-
                                                                    let gK = getString(gJ)
1842
-
                                                                    if (isDefined(gK))
1843
-
                                                                        then throw(("Name already registered: " + fM))
1844
-
                                                                        else [StringEntry(ar(ap), fM), StringEntry(gJ, ap)]
1858
+
                                                                    let gL = aI(fN)
1859
+
                                                                    let gM = getString(gL)
1860
+
                                                                    if (isDefined(gM))
1861
+
                                                                        then throw(("Name already registered: " + fN))
1862
+
                                                                        else [StringEntry(aG(an), fN), StringEntry(gL, an)]
1845
1863
 
                                                                    }
1846
1864
 
                                                            }
1847
1865
 
                                                    }
1848
1866
 
                                                else throw("Unknown entity type")
1849
1867
 
                                    }
1850
-
                                $Tuple2(((gI :+ ScriptTransfer(af, gd.amount, b)) :+ gc), 0)
1868
+
                                $Tuple2(((gK :+ ScriptTransfer(af, ge.amount, b)) :+ gd), 0)
1851
1869
 
                                }
1852
1870
 
            }
1853
1871
 
    }
1854
1872
 
1855
1873
 
1856
1874
 
1857
-
@Callable(co)
1858
-
func setReferrals (gL,gM) = if ((co.callerPublicKey != g))
1875
+
@Callable(cp)
1876
+
func setReferrals (gN,gO) = if ((cp.callerPublicKey != g))
1859
1877
 
    then throw("Permission denied")
1860
1878
 
    else {
1861
-
        let gc = fZ(co)
1862
-
        if ((size(co.payments) != 0))
1879
+
        let gd = ga(cp)
1880
+
        if ((size(cp.payments) != 0))
1863
1881
 
            then throw("No payments required")
1864
-
            else if (!(isDefined(addressFromString(gL))))
1865
-
                then throw(("Invalid address: " + gL))
1866
-
                else if (!(isDefined(addressFromString(gM))))
1867
-
                    then throw(("Invalid address: " + gM))
1882
+
            else if (!(isDefined(addressFromString(gN))))
1883
+
                then throw(("Invalid address: " + gN))
1884
+
                else if (!(isDefined(addressFromString(gO))))
1885
+
                    then throw(("Invalid address: " + gO))
1868
1886
 
                    else {
1869
-
                        let gN = az()
1870
-
                        let gO = getString(gN)
1871
-
                        let gP = if (isDefined(gO))
1872
-
                            then split_4C(value(gO), "_")
1887
+
                        let gP = aM()
1888
+
                        let gQ = getString(gP)
1889
+
                        let gR = if (isDefined(gQ))
1890
+
                            then split_4C(value(gQ), "_")
1873
1891
 
                            else nil
1874
-
                        if (containsElement(gP, gM))
1875
-
                            then throw((gM + " is not newbie (already has referrals)"))
1892
+
                        if (containsElement(gR, gO))
1893
+
                            then throw((gO + " is not newbie (already has referrals)"))
1876
1894
 
                            else {
1877
-
                                let gQ = ax(gM)
1878
-
                                let gR = getString(gQ)
1879
-
                                if (if (isDefined(gR))
1880
-
                                    then isDefined(addressFromString(value(gR)))
1895
+
                                let gS = aK(gO)
1896
+
                                let gT = getString(gS)
1897
+
                                if (if (isDefined(gT))
1898
+
                                    then isDefined(addressFromString(value(gT)))
1881
1899
 
                                    else false)
1882
-
                                    then throw(((gM + " already has refBy: ") + value(gR)))
1900
+
                                    then throw(((gO + " already has refBy: ") + value(gT)))
1883
1901
 
                                    else {
1884
-
                                        let gS = ay(gL)
1885
-
                                        let gT = getString(gS)
1886
-
                                        let gU = if (isDefined(gT))
1887
-
                                            then split_4C(value(gT), "_")
1902
+
                                        let gU = aL(gN)
1903
+
                                        let gV = getString(gU)
1904
+
                                        let gW = if (isDefined(gV))
1905
+
                                            then split_4C(value(gV), "_")
1888
1906
 
                                            else nil
1889
-
                                        if (containsElement(gU, gM))
1890
-
                                            then throw((((gL + " already contains ") + gM) + " within referrals"))
1907
+
                                        if (containsElement(gW, gO))
1908
+
                                            then throw((((gN + " already contains ") + gO) + " within referrals"))
1891
1909
 
                                            else {
1892
-
                                                let gV = makeString_2C((gU :+ gM), "_")
1893
-
                                                let gW = makeString_2C((gP :+ gL), "_")
1894
-
                                                $Tuple2([StringEntry(gQ, gL), StringEntry(gS, gV), StringEntry(gN, gW), gc], 0)
1910
+
                                                let gX = makeString_2C((gW :+ gO), "_")
1911
+
                                                let gY = makeString_2C((gR :+ gN), "_")
1912
+
                                                $Tuple2([StringEntry(gS, gN), StringEntry(gU, gX), StringEntry(gP, gY), gd], 0)
1895
1913
 
                                                }
1896
1914
 
                                        }
1897
1915
 
                                }
1898
1916
 
                        }
1899
1917
 
        }
1900
1918
 
1901
1919
 
1902
1920
 
1903
-
@Callable(co)
1904
-
func splitByGlobalWeightsREADONLY (cv) = $Tuple2(nil, bY(cv))
1921
+
@Callable(cp)
1922
+
func splitByGlobalWeightsREADONLY (cw) = $Tuple2(nil, bZ(cw))
1905
1923
 
1906
1924
 
1907
1925
 
1908
-
@Callable(co)
1909
-
func splitByGlobalAndLocalWeightsREADONLY (gX,gY,cr) = {
1910
-
    let ck = cq(cr)
1911
-
    $Tuple2(nil, $Tuple2(bY(gX), bJ(gY, ck)))
1926
+
@Callable(cp)
1927
+
func splitByGlobalAndLocalWeightsREADONLY (gZ,ha,cs) = {
1928
+
    let cl = cr(cs)
1929
+
    $Tuple2(nil, $Tuple2(bZ(gZ), bK(ha, cl)))
1912
1930
 
    }
1913
1931
 
1914
1932
 
1915
1933
 
1916
-
@Callable(co)
1917
-
func getBackpackREADONLY (aP) = $Tuple2(nil, makeString(db(aO(aP)), ":"))
1934
+
@Callable(cp)
1935
+
func getBackpackREADONLY (aQ) = $Tuple2(nil, makeString(dc(aP(aQ)), ":"))
1918
1936
 
1919
1937
 
1920
1938
 
1921
-
@Callable(co)
1922
-
func getWarehouseREADONLY (aR) = {
1923
-
    let eS = value(assetInfo(fromBase58String(aR)))
1924
-
    let dy = (cs(split(eS.description, "_")[ba]) / m)
1925
-
    let dz = valueOrElse(getInteger(aC(aR)), 0)
1926
-
    $Tuple2(nil, makeString_2C(dw(aQ(aR), dy, dz), ":"))
1939
+
@Callable(cp)
1940
+
func getWarehouseREADONLY (aD) = {
1941
+
    let eT = value(assetInfo(fromBase58String(aD)))
1942
+
    let dz = (ct(split(eT.description, "_")[aZ]) / m)
1943
+
    let dA = valueOrElse(getInteger(as(aD)), 0)
1944
+
    $Tuple2(nil, makeString_2C(dx(aC(aD), dz, dA), ":"))
1927
1945
 
    }
1928
1946
 
1929
1947