tx · 3uLT3xvFJrum9EA7hYyaUd43BpUtujSvq8wZD9vBFFpU

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.07100000 Waves

2023.07.09 19:53 [2658636] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3uLT3xvFJrum9EA7hYyaUd43BpUtujSvq8wZD9vBFFpU",
    "fee": 7100000,
    "feeAssetId": null,
    "timestamp": 1688921638904,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "5FHKbNB39XwuyjnD2fZe9Vthh2sR7XacyzD3sEAN2viFjFi28PSwmhKXJigua9HruGqYyhnDGedugVBu7GXwh75o"
    ],
    "script": "base64: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",
    "height": 2658636,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: T17cQTMoKJ1yQuKApiukm1nbtWkCKSkagziUc6FiqPA
Next: 9Xst55oqNjqgq1aC4cQSTqk5sNTbUAqakwXRbhPHqLLj

Diff: 
Old
New
Differences
440
440
 
func cx () = "oldiesList"
441
441
 
442
442
 
443
-
let cy = 0
444
-
445
-
let cz = 1
446
-
447
-
let cA = 2
448
-
449
-
let cB = 0
450
-
451
-
let cC = 5
452
-
453
-
let cD = 6
454
-
455
-
let cE = 7
456
-
457
-
func cF (cp,bV) = ((I + cp) + bV)
458
-
459
-
460
-
func cG (cH,cI) = {
461
-
    let cJ = (((((cI[0] + cI[1]) + cI[2]) + cI[3]) + cI[4]) + cI[5])
462
-
    if ((0 >= cJ))
443
+
let cy = ["DUCK-DDDDDDDD-GG", "DUCK-BBBABAAA-HG", "DUCK-CCCBCBCC-IG", "DUCK-DDCADBAA-KG", "DUCK-EEEDECBA-LG", "DUCK-FFEDECBA-MG", "DUCK-GGFDECBA-NG", "DUCK-HGFHEHHH-NG", "DUCK-IGFDECBA-OG", "DUCK-KIGEFDCB-OG", "DUCK-LKIFGEDC-OG", "DUCK-ACACACAC-IG"]
444
+
445
+
let cz = 0
446
+
447
+
let cA = 1
448
+
449
+
let cB = 2
450
+
451
+
let cC = 0
452
+
453
+
let cD = 5
454
+
455
+
let cE = 6
456
+
457
+
let cF = 7
458
+
459
+
func cG (cp,bV) = ((I + cp) + bV)
460
+
461
+
462
+
func cH (cI,cJ) = {
463
+
    let cK = (((((cJ[0] + cJ[1]) + cJ[2]) + cJ[3]) + cJ[4]) + cJ[5])
464
+
    if ((0 >= cK))
463
465
 
        then throw("Zero weights sum")
464
466
 
        else {
465
-
            let cK = fraction(cH, bj, cJ)
466
-
            func cL (cM,cN) =             (cM :+ fraction(cN, cK, bj))
467
-
468
-
            let aW = cI
467
+
            let cL = fraction(cI, bj, cK)
468
+
            func cM (cN,cO) =             (cN :+ fraction(cO, cL, bj))
469
+
470
+
            let aW = cJ
469
471
 
            let aX = size(aW)
470
472
 
            let aY = nil
471
473
 
            func aZ (ba,bb) =             if ((bb >= aX))
472
474
 
                then ba
473
-
                else cL(ba, aW[bb])
475
+
                else cM(ba, aW[bb])
474
476
 
475
477
 
            func bc (ba,bb) =             if ((bb >= aX))
476
478
 
                then ba
481
483
 
    }
482
484
 
483
485
 
484
-
func cO (cH) = {
485
-
    let cP = split(value(getString(bN())), "_")
486
-
    if ((size(cP) != L))
486
+
func cP (cI) = {
487
+
    let cQ = split(value(getString(bN())), "_")
488
+
    if ((size(cQ) != L))
487
489
 
        then throw("Wrong proportions data")
488
490
 
        else {
489
-
            let cQ = [parseIntValue(cP[0]), parseIntValue(cP[1]), parseIntValue(cP[2]), parseIntValue(cP[3]), parseIntValue(cP[4]), parseIntValue(cP[5])]
490
-
            cG(cH, cQ)
491
-
            }
492
-
    }
493
-
494
-
495
-
func cR (cS,cT,cU) = {
496
-
    let cV = cO(cU)
497
-
    func cW (cM,bD) =     {
498
-
        let cX = (parseIntValue(cT[bD]) - cV[bD])
499
-
        if ((0 > cX))
500
-
            then throw(((((("Not enough material idx=" + toString(bD)) + ", you have ") + cT[bD]) + ", but need ") + toString(cV[bD])))
501
-
            else (cM :+ toString(cX))
491
+
            let cR = [parseIntValue(cQ[0]), parseIntValue(cQ[1]), parseIntValue(cQ[2]), parseIntValue(cQ[3]), parseIntValue(cQ[4]), parseIntValue(cQ[5])]
492
+
            cH(cI, cR)
493
+
            }
494
+
    }
495
+
496
+
497
+
func cS (cT,cU,cV) = {
498
+
    let cW = cP(cV)
499
+
    func cX (cN,bD) =     {
500
+
        let cY = (parseIntValue(cU[bD]) - cW[bD])
501
+
        if ((0 > cY))
502
+
            then throw(((((("Not enough material idx=" + toString(bD)) + ", you have ") + cU[bD]) + ", but need ") + toString(cW[bD])))
503
+
            else (cN :+ toString(cY))
502
504
 
        }
503
505
 
504
-
    if (cS)
506
+
    if (cT)
505
507
 
        then {
506
508
 
            let aW = [0, 1, 2, 3, 4, 5]
507
509
 
            let aX = size(aW)
508
510
 
            let aY = nil
509
511
 
            func aZ (ba,bb) =             if ((bb >= aX))
510
512
 
                then ba
511
-
                else cW(ba, aW[bb])
513
+
                else cX(ba, aW[bb])
512
514
 
513
515
 
            func bc (ba,bb) =             if ((bb >= aX))
514
516
 
                then ba
516
518
 
517
519
 
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
518
520
 
            }
519
-
        else cT
520
-
    }
521
-
522
-
523
-
func cY (cZ,da) = if ((da == ""))
524
-
    then cZ
521
+
        else cU
522
+
    }
523
+
524
+
525
+
func cZ (da,db) = if ((db == ""))
526
+
    then da
525
527
 
    else {
526
-
        let db = if ((cZ == ""))
528
+
        let dc = if ((da == ""))
527
529
 
            then nil
528
-
            else split(cZ, "_")
529
-
        func dc (cM,dd) =         {
530
-
            let aV = cM._1
531
-
            func de (aU,df) =             {
532
-
                let dg = split(df, ",")
533
-
                if ((size(dg) != 2))
530
+
            else split(da, "_")
531
+
        func dd (cN,de) =         {
532
+
            let aV = cN._1
533
+
            func df (aU,dg) =             {
534
+
                let dh = split(dg, ",")
535
+
                if ((size(dh) != 2))
534
536
 
                    then throw("Incorrect format, should be index,amount")
535
537
 
                    else {
536
-
                        let bD = parseIntValue(dg[0])
538
+
                        let bD = parseIntValue(dh[0])
537
539
 
                        if (if ((0 > bD))
538
540
 
                            then true
539
541
 
                            else (bD >= size(V)))
541
543
 
                            else if ((bD != aV))
542
544
 
                                then aU
543
545
 
                                else {
544
-
                                    let dh = parseIntValue(dg[1])
545
-
                                    if ((0 >= dh))
546
+
                                    let di = parseIntValue(dh[1])
547
+
                                    if ((0 >= di))
546
548
 
                                        then throw("Pass only positive amounts")
547
-
                                        else (aU + dh)
549
+
                                        else (aU + di)
548
550
 
                                    }
549
551
 
                        }
550
552
 
                }
551
553
 
552
-
            let di = {
553
-
                let aW = split(da, "_")
554
+
            let dj = {
555
+
                let aW = split(db, "_")
554
556
 
                let aX = size(aW)
555
557
 
                let aY = 0
556
558
 
                func aZ (ba,bb) =                 if ((bb >= aX))
557
559
 
                    then ba
558
-
                    else de(ba, aW[bb])
560
+
                    else df(ba, aW[bb])
559
561
 
560
562
 
                func bc (ba,bb) =                 if ((bb >= aX))
561
563
 
                    then ba
563
565
 
564
566
 
                bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
565
567
 
                }
566
-
            let dj = if ((size(db) > aV))
567
-
                then parseIntValue(db[aV])
568
+
            let dk = if ((size(dc) > aV))
569
+
                then parseIntValue(dc[aV])
568
570
 
                else 0
569
-
            let dk = if ((di > dj))
570
-
                then throw(((((("You have " + toString(dj)) + " of ") + T[aV]) + ", but tried to use ") + toString(di)))
571
-
                else (dj - di)
572
-
            $Tuple2((aV + 1), (cM._2 :+ toString(dk)))
573
-
            }
574
-
575
-
        let dl = {
571
+
            let dl = if ((dj > dk))
572
+
                then throw(((((("You have " + toString(dk)) + " of ") + T[aV]) + ", but tried to use ") + toString(dj)))
573
+
                else (dk - dj)
574
+
            $Tuple2((aV + 1), (cN._2 :+ toString(dl)))
575
+
            }
576
+
577
+
        let dm = {
576
578
 
            let aW = V
577
579
 
            let aX = size(aW)
578
580
 
            let aY = $Tuple2(0, nil)
579
581
 
            func aZ (ba,bb) =             if ((bb >= aX))
580
582
 
                then ba
581
-
                else dc(ba, aW[bb])
583
+
                else dd(ba, aW[bb])
582
584
 
583
585
 
            func bc (ba,bb) =             if ((bb >= aX))
584
586
 
                then ba
586
588
 
587
589
 
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
588
590
 
            }
589
-
        makeString(dl._2, "_")
591
+
        makeString(dm._2, "_")
590
592
 
        }
591
593
 
592
594
 
593
-
func dm (dn,do,dp,dq) = if ((size(dn) != L))
595
+
func dn (do,dp,dq,dr) = if ((size(do) != L))
594
596
 
    then throw("Wrong proportions data")
595
597
 
    else {
596
-
        func dr (cM,ds) =         {
597
-
            let cX = (parseIntValue(dn[ds]) + ((dq * do[ds]) * dp))
598
-
            if ((0 > cX))
599
-
                then throw(((((((("Panic! Pieces of type=" + toString(ds)) + ", sign=") + toString(dq)) + ",  terrainCounts[i]=") + toString(do[ds])) + ", landSizeIndex=") + toString(dp)))
600
-
                else (cM :+ toString(cX))
601
-
            }
602
-
603
-
        let cQ = {
598
+
        func ds (cN,dt) =         {
599
+
            let cY = (parseIntValue(do[dt]) + ((dr * dp[dt]) * dq))
600
+
            if ((0 > cY))
601
+
                then throw(((((((("Panic! Pieces of type=" + toString(dt)) + ", sign=") + toString(dr)) + ",  terrainCounts[i]=") + toString(dp[dt])) + ", landSizeIndex=") + toString(dq)))
602
+
                else (cN :+ toString(cY))
603
+
            }
604
+
605
+
        let cR = {
604
606
 
            let aW = [0, 1, 2, 3, 4, 5]
605
607
 
            let aX = size(aW)
606
608
 
            let aY = nil
607
609
 
            func aZ (ba,bb) =             if ((bb >= aX))
608
610
 
                then ba
609
-
                else dr(ba, aW[bb])
611
+
                else ds(ba, aW[bb])
610
612
 
611
613
 
            func bc (ba,bb) =             if ((bb >= aX))
612
614
 
                then ba
614
616
 
615
617
 
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
616
618
 
            }
617
-
        makeString(cQ, "_")
619
+
        makeString(cR, "_")
618
620
 
        }
619
621
 
620
622
 
621
-
func dt (do,dp,dq) = {
622
-
    let dn = split(valueOrElse(getString(bN()), "0_0_0_0_0_0"), "_")
623
-
    dm(dn, do, dp, dq)
624
-
    }
625
-
626
-
627
-
func du (dv) = [(size(split(dv, "A")) - 1), (size(split(dv, "B")) - 1), (size(split(dv, "C")) - 1), (size(split(dv, "D")) - 1), (size(split(dv, "E")) - 1), (size(split(dv, "F")) - 1)]
628
-
629
-
630
-
func dw (dx,do,dy,dp,dz) = {
631
-
    func dA (cM,ds) =     {
632
-
        let dB = ((fraction(dy, dz, N) * do[ds]) * dp)
633
-
        (cM :+ toString((parseIntValue(dx[ds]) + dB)))
623
+
func du (dp,dq,dr) = {
624
+
    let do = split(valueOrElse(getString(bN()), "0_0_0_0_0_0"), "_")
625
+
    dn(do, dp, dq, dr)
626
+
    }
627
+
628
+
629
+
func dv (dw) = [(size(split(dw, "A")) - 1), (size(split(dw, "B")) - 1), (size(split(dw, "C")) - 1), (size(split(dw, "D")) - 1), (size(split(dw, "E")) - 1), (size(split(dw, "F")) - 1)]
630
+
631
+
632
+
func dx (dy,dp,dz,dq,dA) = {
633
+
    func dB (cN,dt) =     {
634
+
        let dC = ((fraction(dz, dA, N) * dp[dt]) * dq)
635
+
        (cN :+ toString((parseIntValue(dy[dt]) + dC)))
634
636
 
        }
635
637
 
636
-
    let cQ = {
638
+
    let cR = {
637
639
 
        let aW = [0, 1, 2, 3, 4, 5]
638
640
 
        let aX = size(aW)
639
641
 
        let aY = nil
640
642
 
        func aZ (ba,bb) =         if ((bb >= aX))
641
643
 
            then ba
642
-
            else dA(ba, aW[bb])
644
+
            else dB(ba, aW[bb])
643
645
 
644
646
 
        func bc (ba,bb) =         if ((bb >= aX))
645
647
 
            then ba
647
649
 
648
650
 
        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
649
651
 
        }
650
-
    makeString(cQ, "_")
651
-
    }
652
-
653
-
654
-
func dC (do,dy,dp,dz) = {
655
-
    func dA (cM,ds) =     {
656
-
        let dB = ((fraction(dy, dz, N) * do[ds]) * dp)
657
-
        $Tuple2((cM._1 :+ dB), (cM._2 + dB))
652
+
    makeString(cR, "_")
653
+
    }
654
+
655
+
656
+
func dD (dp,dz,dq,dA) = {
657
+
    func dB (cN,dt) =     {
658
+
        let dC = ((fraction(dz, dA, N) * dp[dt]) * dq)
659
+
        $Tuple2((cN._1 :+ dC), (cN._2 + dC))
658
660
 
        }
659
661
 
660
662
 
    let aW = [0, 1, 2, 3, 4, 5]
662
664
 
    let aY = $Tuple2(nil, 0)
663
665
 
    func aZ (ba,bb) =     if ((bb >= aX))
664
666
 
        then ba
665
-
        else dA(ba, aW[bb])
667
+
        else dB(ba, aW[bb])
666
668
 
667
669
 
    func bc (ba,bb) =     if ((bb >= aX))
668
670
 
        then ba
672
674
 
    }
673
675
 
674
676
 
675
-
func dD (dE,dF,dG,dH) = {
676
-
    let dI = dG._1
677
-
    let dJ = dG._2
678
-
    if ((dJ == 0))
679
-
        then $Tuple2(makeString(dE, "_"), makeString(dF, "_"))
680
-
        else if ((dH >= dJ))
677
+
func dE (dF,dG,dH,dI) = {
678
+
    let dJ = dH._1
679
+
    let dK = dH._2
680
+
    if ((dK == 0))
681
+
        then $Tuple2(makeString(dF, "_"), makeString(dG, "_"))
682
+
        else if ((dI >= dK))
681
683
 
            then {
682
-
                func dK (cM,ds) =                 (cM :+ toString((parseIntValue(dE[ds]) + dI[ds])))
683
-
684
-
                let cQ = {
684
+
                func dL (cN,dt) =                 (cN :+ toString((parseIntValue(dF[dt]) + dJ[dt])))
685
+
686
+
                let cR = {
685
687
 
                    let aW = [0, 1, 2, 3, 4, 5]
686
688
 
                    let aX = size(aW)
687
689
 
                    let aY = nil
688
690
 
                    func aZ (ba,bb) =                     if ((bb >= aX))
689
691
 
                        then ba
690
-
                        else dK(ba, aW[bb])
692
+
                        else dL(ba, aW[bb])
691
693
 
692
694
 
                    func bc (ba,bb) =                     if ((bb >= aX))
693
695
 
                        then ba
695
697
 
696
698
 
                    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
697
699
 
                    }
698
-
                $Tuple2(makeString(cQ, "_"), makeString(dF, "_"))
700
+
                $Tuple2(makeString(cR, "_"), makeString(dG, "_"))
699
701
 
                }
700
702
 
            else {
701
-
                func dL (cM,ds) =                 {
702
-
                    let dM = fraction(dI[ds], dH, dJ)
703
-
                    $Tuple2((cM._1 :+ toString((parseIntValue(dE[ds]) + dM))), (cM._2 :+ toString(((parseIntValue(dF[ds]) + dI[ds]) - dM))))
703
+
                func dM (cN,dt) =                 {
704
+
                    let dN = fraction(dJ[dt], dI, dK)
705
+
                    $Tuple2((cN._1 :+ toString((parseIntValue(dF[dt]) + dN))), (cN._2 :+ toString(((parseIntValue(dG[dt]) + dJ[dt]) - dN))))
704
706
 
                    }
705
707
 
706
-
                let cQ = {
708
+
                let cR = {
707
709
 
                    let aW = [0, 1, 2, 3, 4, 5]
708
710
 
                    let aX = size(aW)
709
711
 
                    let aY = $Tuple2(nil, nil)
710
712
 
                    func aZ (ba,bb) =                     if ((bb >= aX))
711
713
 
                        then ba
712
-
                        else dL(ba, aW[bb])
714
+
                        else dM(ba, aW[bb])
713
715
 
714
716
 
                    func bc (ba,bb) =                     if ((bb >= aX))
715
717
 
                        then ba
717
719
 
718
720
 
                    bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
719
721
 
                    }
720
-
                $Tuple2(makeString(cQ._1, "_"), makeString(cQ._2, "_"))
722
+
                $Tuple2(makeString(cR._1, "_"), makeString(cR._2, "_"))
721
723
 
                }
722
724
 
    }
723
725
 
724
726
 
725
-
func dN (dO) = if ((dO >= toBigInt(0)))
726
-
    then dO
727
-
    else -(dO)
728
-
729
-
730
-
let dP = [[6, 9, 14, 15, 16], [5, 8, 13, 14, 15], [1, 4, 9, 10, 15], [1, 6, 7, 15, 19], [4, 7, 8, 13, 18]]
731
-
732
-
func dQ (bT,dR) = {
733
-
    let dS = toInt((bT % ch))
734
-
    let dT = if ((dR[0] > dS))
727
+
func dO (dP) = if ((dP >= toBigInt(0)))
728
+
    then dP
729
+
    else -(dP)
730
+
731
+
732
+
let dQ = [[6, 9, 14, 15, 16], [5, 8, 13, 14, 15], [1, 4, 9, 10, 15], [1, 6, 7, 15, 19], [4, 7, 8, 13, 18]]
733
+
734
+
func dR (bT,dS) = {
735
+
    let dT = toInt((bT % ch))
736
+
    let dU = if ((dS[0] > dT))
735
737
 
        then "A"
736
-
        else if ((dR[1] > dS))
738
+
        else if ((dS[1] > dT))
737
739
 
            then "B"
738
-
            else if ((dR[2] > dS))
740
+
            else if ((dS[2] > dT))
739
741
 
                then "C"
740
-
                else if ((dR[3] > dS))
742
+
                else if ((dS[3] > dT))
741
743
 
                    then "D"
742
-
                    else if ((dR[4] > dS))
744
+
                    else if ((dS[4] > dT))
743
745
 
                        then "E"
744
746
 
                        else "F"
745
-
    dT
746
-
    }
747
-
748
-
749
-
func dU (dV,dW) = {
750
-
    let dX = dP[dW]
751
-
    func dY (cM,cN) =     $Tuple2((((((cM._1 + dQ(cM._2, dX)) + dQ((cM._2 / ch), dX)) + dQ((cM._2 / ci), dX)) + dQ((cM._2 / cj), dX)) + dQ((cM._2 / ck), dX)), (cM._2 / cl))
752
-
753
-
    let dZ = {
747
+
    dU
748
+
    }
749
+
750
+
751
+
func dV (dW,dX) = {
752
+
    let dY = dQ[dX]
753
+
    func dZ (cN,cO) =     $Tuple2((((((cN._1 + dR(cN._2, dY)) + dR((cN._2 / ch), dY)) + dR((cN._2 / ci), dY)) + dR((cN._2 / cj), dY)) + dR((cN._2 / ck), dY)), (cN._2 / cl))
754
+
755
+
    let ea = {
754
756
 
        let aW = [1, 2, 3, 4, 5]
755
757
 
        let aX = size(aW)
756
-
        let aY = $Tuple2("", (dV / cg))
758
+
        let aY = $Tuple2("", (dW / cg))
757
759
 
        func aZ (ba,bb) =         if ((bb >= aX))
758
760
 
            then ba
759
-
            else dY(ba, aW[bb])
761
+
            else dZ(ba, aW[bb])
760
762
 
761
763
 
        func bc (ba,bb) =         if ((bb >= aX))
762
764
 
            then ba
764
766
 
765
767
 
        bc(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5)
766
768
 
        }
767
-
    dZ._1
768
-
    }
769
-
770
-
771
-
func ea (eb) = {
772
-
    let ec = split(valueOrElse(getString(eb), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
773
-
[toString(valueOrElse(parseInt(ec[ag]), 0)), if ((size(split(ec[ah], "_")) == L))
774
-
        then ec[ah]
775
-
        else "0_0_0_0_0_0", if ((size(split(ec[ai], "_")) == L))
776
-
        then ec[ai]
777
-
        else "0_0_0_0_0_0", ec[aj]]
778
-
    }
779
-
780
-
781
-
func ed (ee) = {
782
-
    let dg = split(ee, "_")
783
-
    ((O * (parseIntValue(dg[1]) + 1)) * parseIntValue(dg[0]))
784
-
    }
785
-
786
-
787
-
func ef (eg) = {
788
-
    let eh = eg[aa]
789
-
    func ei (cM,dd) =     (cM + parseIntValue(dd))
790
-
791
-
    func ej (cM,dd) =     {
792
-
        let bD = cM._1
793
-
        let ek = ak(bD)
794
-
        let el = (((parseIntValue(dd) + ek) - 1) / ek)
795
-
        $Tuple2((bD + 1), (cM._2 + (el * bk)))
769
+
    ea._1
770
+
    }
771
+
772
+
773
+
func eb (ec) = {
774
+
    let ed = split(valueOrElse(getString(ec), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
775
+
[toString(valueOrElse(parseInt(ed[ag]), 0)), if ((size(split(ed[ah], "_")) == L))
776
+
        then ed[ah]
777
+
        else "0_0_0_0_0_0", if ((size(split(ed[ai], "_")) == L))
778
+
        then ed[ai]
779
+
        else "0_0_0_0_0_0", ed[aj]]
780
+
    }
781
+
782
+
783
+
func ee (ef) = {
784
+
    let dh = split(ef, "_")
785
+
    ((O * (parseIntValue(dh[1]) + 1)) * parseIntValue(dh[0]))
786
+
    }
787
+
788
+
789
+
func eg (eh) = {
790
+
    let ei = eh[aa]
791
+
    func ej (cN,de) =     (cN + parseIntValue(de))
792
+
793
+
    func ek (cN,de) =     {
794
+
        let bD = cN._1
795
+
        let el = ak(bD)
796
+
        let em = (((parseIntValue(de) + el) - 1) / el)
797
+
        $Tuple2((bD + 1), (cN._2 + (em * bk)))
796
798
 
        }
797
799
 
798
-
    let em = {
799
-
        let aW = split(eg[Y], "_")
800
+
    let en = {
801
+
        let aW = split(eh[Y], "_")
800
802
 
        let aX = size(aW)
801
803
 
        let aY = 0
802
804
 
        func aZ (ba,bb) =         if ((bb >= aX))
803
805
 
            then ba
804
-
            else ei(ba, aW[bb])
806
+
            else ej(ba, aW[bb])
805
807
 
806
808
 
        func bc (ba,bb) =         if ((bb >= aX))
807
809
 
            then ba
809
811
 
810
812
 
        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
811
813
 
        }
812
-
    let en = {
813
-
        let aW = split(eg[Z], "_")
814
+
    let eo = {
815
+
        let aW = split(eh[Z], "_")
814
816
 
        let aX = size(aW)
815
817
 
        let aY = 0
816
-
        func eo (ba,bb) =         if ((bb >= aX))
817
-
            then ba
818
-
            else ei(ba, aW[bb])
819
-
820
818
 
        func ep (ba,bb) =         if ((bb >= aX))
821
819
 
            then ba
820
+
            else ej(ba, aW[bb])
821
+
822
+
        func eq (ba,bb) =         if ((bb >= aX))
823
+
            then ba
822
824
 
            else throw("List size exceeds 6")
823
825
 
824
-
        ep(eo(eo(eo(eo(eo(eo(aY, 0), 1), 2), 3), 4), 5), 6)
826
+
        eq(ep(ep(ep(ep(ep(ep(aY, 0), 1), 2), 3), 4), 5), 6)
825
827
 
        }
826
-
    let eq = if ((eh == ""))
828
+
    let er = if ((ei == ""))
827
829
 
        then 0
828
-
        else (        let aW = split_4C(eh, "_")
830
+
        else (        let aW = split_4C(ei, "_")
829
831
 
        let aX = size(aW)
830
832
 
        let aY = $Tuple2(0, 0)
831
-
        func er (ba,bb) =         if ((bb >= aX))
832
-
            then ba
833
-
            else ej(ba, aW[bb])
834
-
835
833
 
        func es (ba,bb) =         if ((bb >= aX))
836
834
 
            then ba
835
+
            else ek(ba, aW[bb])
836
+
837
+
        func et (ba,bb) =         if ((bb >= aX))
838
+
            then ba
837
839
 
            else throw("List size exceeds 50")
838
840
 
839
-
        es(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(aY, 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
840
-
    ((em + en) + eq)
841
-
    }
842
-
843
-
844
-
func et (eu,ev,ew) = {
845
-
    let ee = ((toString(ev) + "_") + toString(ew))
846
-
    let ex = ed(ee)
847
-
    let ey = valueOrElse(getString(eu), (ee + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
848
-
    let ez = split_4C(ey, ":")
849
-
    let eA = ef(ez)
850
-
    let eB = if ((5 > size(ez)))
851
-
        then makeString(["0", toString(eA), toString((ex - eA)), toString(ex)], "_")
852
-
        else {
853
-
            let eC = split(ez[ab], "_")
854
-
            let eD = parseIntValue(eC[ac])
855
-
            let eE = if ((size(eC) > 1))
856
-
                then parseIntValue(eC[ad])
857
-
                else eA
858
-
            makeString([toString(eD), toString(eE), toString(((ex - eD) - eE)), toString(ex)], "_")
859
-
            }
860
-
[ez[X], if ((size(split(ez[Y], "_")) == L))
861
-
        then ez[Y]
862
-
        else "0_0_0_0_0_0", if ((size(split(ez[Z], "_")) == L))
863
-
        then ez[Z]
864
-
        else "0_0_0_0_0_0", ez[aa], eB]
865
-
    }
866
-
867
-
868
-
func eF (eg) = {
869
-
    let eG = ef(eg)
870
-
    let eH = parseIntValue(split(eg[ab], "_")[ac])
871
-
    ((ed(eg[X]) - eG) - eH)
872
-
    }
873
-
874
-
875
-
func eI (eJ,ek) = {
876
-
    let el = if ((eJ >= 0))
877
-
        then (((eJ + ek) - 1) / ek)
878
-
        else -((((-(eJ) + ek) - 1) / ek))
879
-
    (el * bk)
880
-
    }
881
-
882
-
883
-
func eK (eL,eg,eM) = if ((size(eL) != 3))
841
+
        et(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(aY, 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
842
+
    ((en + eo) + er)
843
+
    }
844
+
845
+
846
+
func eu (ev,ew,ex) = {
847
+
    let ef = ((toString(ew) + "_") + toString(ex))
848
+
    let ey = ee(ef)
849
+
    let ez = valueOrElse(getString(ev), (ef + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
850
+
    let eA = split_4C(ez, ":")
851
+
    let eB = eg(eA)
852
+
    let eC = if ((5 > size(eA)))
853
+
        then makeString(["0", toString(eB), toString((ey - eB)), toString(ey)], "_")
854
+
        else {
855
+
            let eD = split(eA[ab], "_")
856
+
            let eE = parseIntValue(eD[ac])
857
+
            let eF = if ((size(eD) > 1))
858
+
                then parseIntValue(eD[ad])
859
+
                else eB
860
+
            makeString([toString(eE), toString(eF), toString(((ey - eE) - eF)), toString(ey)], "_")
861
+
            }
862
+
[eA[X], if ((size(split(eA[Y], "_")) == L))
863
+
        then eA[Y]
864
+
        else "0_0_0_0_0_0", if ((size(split(eA[Z], "_")) == L))
865
+
        then eA[Z]
866
+
        else "0_0_0_0_0_0", eA[aa], eC]
867
+
    }
868
+
869
+
870
+
func eG (eh) = {
871
+
    let eH = eg(eh)
872
+
    let eI = parseIntValue(split(eh[ab], "_")[ac])
873
+
    ((ee(eh[X]) - eH) - eI)
874
+
    }
875
+
876
+
877
+
func eJ (eK,el) = {
878
+
    let em = if ((eK >= 0))
879
+
        then (((eK + el) - 1) / el)
880
+
        else -((((-(eK) + el) - 1) / el))
881
+
    (em * bk)
882
+
    }
883
+
884
+
885
+
func eL (eM,eh,eN) = if ((size(eM) != 3))
884
886
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
885
887
 
    else {
886
-
        let eN = split(eL[0], "_")
887
-
        let eO = split(eL[1], "_")
888
-
        let eP = if ((eL[2] == ""))
888
+
        let eO = split(eM[0], "_")
889
+
        let eP = split(eM[1], "_")
890
+
        let eQ = if ((eM[2] == ""))
889
891
 
            then nil
890
-
            else split(eL[2], "_")
891
-
        if ((size(eN) != L))
892
+
            else split(eM[2], "_")
893
+
        if ((size(eO) != L))
892
894
 
            then throw("All 6 resources should be passed")
893
-
            else if ((size(eO) != L))
895
+
            else if ((size(eP) != L))
894
896
 
                then throw("All 6 materials should be passed")
895
897
 
                else {
896
-
                    let dH = eF(eg)
897
-
                    let eQ = split(eg[Y], "_")
898
-
                    let eR = split(eg[Z], "_")
899
-
                    let eS = if ((eg[aa] == ""))
898
+
                    let dI = eG(eh)
899
+
                    let eR = split(eh[Y], "_")
900
+
                    let eS = split(eh[Z], "_")
901
+
                    let eT = if ((eh[aa] == ""))
900
902
 
                        then nil
901
-
                        else split(eg[aa], "_")
902
-
                    let dF = split(eM[ah], "_")
903
-
                    let eT = split(eM[ai], "_")
904
-
                    let eU = if ((eM[aj] == ""))
903
+
                        else split(eh[aa], "_")
904
+
                    let dG = split(eN[ah], "_")
905
+
                    let eU = split(eN[ai], "_")
906
+
                    let eV = if ((eN[aj] == ""))
905
907
 
                        then nil
906
-
                        else split(eM[aj], "_")
907
-
                    func eV (cM,dd) =                     {
908
-
                        let ds = cM._1
909
-
                        let eW = parseIntValue(dd)
910
-
                        let eX = parseIntValue(eQ[ds])
911
-
                        let eY = parseIntValue(dF[ds])
912
-
                        if ((eW == 0))
913
-
                            then $Tuple4((ds + 1), (cM._2 :+ eQ[ds]), (cM._3 :+ dF[ds]), cM._4)
914
-
                            else if ((eW > 0))
915
-
                                then if ((eW > eY))
916
-
                                    then throw((((("Attempt to take " + dd) + " from backpack, but only ") + toString(eY)) + " available"))
917
-
                                    else $Tuple4((ds + 1), (cM._2 :+ toString((eX + eW))), (cM._3 :+ toString((eY - eW))), (cM._4 + eW))
918
-
                                else if ((-(eW) > eX))
919
-
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(eX)) + " available"))
920
-
                                    else $Tuple4((ds + 1), (cM._2 :+ toString((eX + eW))), (cM._3 :+ toString((eY - eW))), (cM._4 + eW))
908
+
                        else split(eN[aj], "_")
909
+
                    func eW (cN,de) =                     {
910
+
                        let dt = cN._1
911
+
                        let eX = parseIntValue(de)
912
+
                        let eY = parseIntValue(eR[dt])
913
+
                        let eZ = parseIntValue(dG[dt])
914
+
                        if ((eX == 0))
915
+
                            then $Tuple4((dt + 1), (cN._2 :+ eR[dt]), (cN._3 :+ dG[dt]), cN._4)
916
+
                            else if ((eX > 0))
917
+
                                then if ((eX > eZ))
918
+
                                    then throw((((("Attempt to take " + de) + " from backpack, but only ") + toString(eZ)) + " available"))
919
+
                                    else $Tuple4((dt + 1), (cN._2 :+ toString((eY + eX))), (cN._3 :+ toString((eZ - eX))), (cN._4 + eX))
920
+
                                else if ((-(eX) > eY))
921
+
                                    then throw((((("Attempt to take " + toString(-(eX))) + " from warehouse, but only ") + toString(eY)) + " available"))
922
+
                                    else $Tuple4((dt + 1), (cN._2 :+ toString((eY + eX))), (cN._3 :+ toString((eZ - eX))), (cN._4 + eX))
921
923
 
                        }
922
924
 
923
-
                    let cQ = {
924
-
                        let aW = eN
925
+
                    let cR = {
926
+
                        let aW = eO
925
927
 
                        let aX = size(aW)
926
928
 
                        let aY = $Tuple4(0, nil, nil, 0)
927
929
 
                        func aZ (ba,bb) =                         if ((bb >= aX))
928
930
 
                            then ba
929
-
                            else eV(ba, aW[bb])
931
+
                            else eW(ba, aW[bb])
930
932
 
931
933
 
                        func bc (ba,bb) =                         if ((bb >= aX))
932
934
 
                            then ba
934
936
 
935
937
 
                        bc(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6)
936
938
 
                        }
937
-
                    func eZ (cM,dd) =                     {
938
-
                        let ds = cM._1
939
-
                        let eW = parseIntValue(dd)
940
-
                        let fa = parseIntValue(eR[ds])
941
-
                        let fb = parseIntValue(eT[ds])
942
-
                        if ((eW == 0))
943
-
                            then $Tuple4((ds + 1), (cM._2 :+ eR[ds]), (cM._3 :+ eT[ds]), cM._4)
944
-
                            else if ((eW > 0))
945
-
                                then if ((eW > fb))
946
-
                                    then throw((((("Attempt to take " + dd) + " from backpack, but only ") + toString(fb)) + " available"))
947
-
                                    else $Tuple4((ds + 1), (cM._2 :+ toString((fa + eW))), (cM._3 :+ toString((fb - eW))), (cM._4 + eW))
948
-
                                else if ((-(eW) > fa))
949
-
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(fa)) + " available"))
950
-
                                    else $Tuple4((ds + 1), (cM._2 :+ toString((fa + eW))), (cM._3 :+ toString((fb - eW))), (cM._4 + eW))
939
+
                    func fa (cN,de) =                     {
940
+
                        let dt = cN._1
941
+
                        let eX = parseIntValue(de)
942
+
                        let fb = parseIntValue(eS[dt])
943
+
                        let fc = parseIntValue(eU[dt])
944
+
                        if ((eX == 0))
945
+
                            then $Tuple4((dt + 1), (cN._2 :+ eS[dt]), (cN._3 :+ eU[dt]), cN._4)
946
+
                            else if ((eX > 0))
947
+
                                then if ((eX > fc))
948
+
                                    then throw((((("Attempt to take " + de) + " from backpack, but only ") + toString(fc)) + " available"))
949
+
                                    else $Tuple4((dt + 1), (cN._2 :+ toString((fb + eX))), (cN._3 :+ toString((fc - eX))), (cN._4 + eX))
950
+
                                else if ((-(eX) > fb))
951
+
                                    then throw((((("Attempt to take " + toString(-(eX))) + " from warehouse, but only ") + toString(fb)) + " available"))
952
+
                                    else $Tuple4((dt + 1), (cN._2 :+ toString((fb + eX))), (cN._3 :+ toString((fc - eX))), (cN._4 + eX))
951
953
 
                        }
952
954
 
953
-
                    let fc = {
954
-
                        let aW = eO
955
+
                    let fd = {
956
+
                        let aW = eP
955
957
 
                        let aX = size(aW)
956
-
                        let aY = $Tuple4(0, nil, nil, cQ._4)
957
-
                        func eo (ba,bb) =                         if ((bb >= aX))
958
-
                            then ba
959
-
                            else eZ(ba, aW[bb])
960
-
958
+
                        let aY = $Tuple4(0, nil, nil, cR._4)
961
959
 
                        func ep (ba,bb) =                         if ((bb >= aX))
962
960
 
                            then ba
961
+
                            else fa(ba, aW[bb])
962
+
963
+
                        func eq (ba,bb) =                         if ((bb >= aX))
964
+
                            then ba
963
965
 
                            else throw("List size exceeds 6")
964
966
 
965
-
                        ep(eo(eo(eo(eo(eo(eo(aY, 0), 1), 2), 3), 4), 5), 6)
967
+
                        eq(ep(ep(ep(ep(ep(ep(aY, 0), 1), 2), 3), 4), 5), 6)
966
968
 
                        }
967
-
                    func fd (cM,dd) =                     {
968
-
                        let ds = cM._1
969
-
                        let ek = ak(ds)
970
-
                        let eW = parseIntValue(dd)
971
-
                        let fe = if ((size(eS) > ds))
972
-
                            then parseIntValue(eS[ds])
969
+
                    func fe (cN,de) =                     {
970
+
                        let dt = cN._1
971
+
                        let el = ak(dt)
972
+
                        let eX = parseIntValue(de)
973
+
                        let ff = if ((size(eT) > dt))
974
+
                            then parseIntValue(eT[dt])
973
975
 
                            else 0
974
-
                        let ff = if ((size(eU) > ds))
975
-
                            then parseIntValue(eU[ds])
976
+
                        let fg = if ((size(eV) > dt))
977
+
                            then parseIntValue(eV[dt])
976
978
 
                            else 0
977
-
                        if ((eW == 0))
978
-
                            then $Tuple4((ds + 1), (cM._2 :+ toString(fe)), (cM._3 :+ toString(ff)), cM._4)
979
-
                            else if ((eW > 0))
980
-
                                then if ((eW > ff))
981
-
                                    then throw((((("Attempt to take " + dd) + " from backpack, but only ") + toString(ff)) + " available"))
979
+
                        if ((eX == 0))
980
+
                            then $Tuple4((dt + 1), (cN._2 :+ toString(ff)), (cN._3 :+ toString(fg)), cN._4)
981
+
                            else if ((eX > 0))
982
+
                                then if ((eX > fg))
983
+
                                    then throw((((("Attempt to take " + de) + " from backpack, but only ") + toString(fg)) + " available"))
982
984
 
                                    else {
983
-
                                        let fg = (eI((fe + eW), ek) - eI(fe, ek))
984
-
                                        $Tuple4((ds + 1), (cM._2 :+ toString((fe + eW))), (cM._3 :+ toString((ff - eW))), (cM._4 + fg))
985
+
                                        let fh = (eJ((ff + eX), el) - eJ(ff, el))
986
+
                                        $Tuple4((dt + 1), (cN._2 :+ toString((ff + eX))), (cN._3 :+ toString((fg - eX))), (cN._4 + fh))
985
987
 
                                        }
986
-
                                else if ((-(eW) > fe))
987
-
                                    then throw((((("Attempt to take " + toString(-(eW))) + " from warehouse, but only ") + toString(fe)) + " available"))
988
+
                                else if ((-(eX) > ff))
989
+
                                    then throw((((("Attempt to take " + toString(-(eX))) + " from warehouse, but only ") + toString(ff)) + " available"))
988
990
 
                                    else {
989
-
                                        let fg = (eI((fe + eW), ek) - eI(fe, ek))
990
-
                                        $Tuple4((ds + 1), (cM._2 :+ toString((fe + eW))), (cM._3 :+ toString((ff - eW))), (cM._4 + fg))
991
+
                                        let fh = (eJ((ff + eX), el) - eJ(ff, el))
992
+
                                        $Tuple4((dt + 1), (cN._2 :+ toString((ff + eX))), (cN._3 :+ toString((fg - eX))), (cN._4 + fh))
991
993
 
                                        }
992
994
 
                        }
993
995
 
994
-
                    let ec = if ((size(eP) != 0))
996
+
                    let ed = if ((size(eQ) != 0))
995
997
 
                        then {
996
-
                            let aW = eP
998
+
                            let aW = eQ
997
999
 
                            let aX = size(aW)
998
-
                            let aY = $Tuple4(0, nil, nil, fc._4)
999
-
                            func er (ba,bb) =                             if ((bb >= aX))
1000
-
                                then ba
1001
-
                                else fd(ba, aW[bb])
1002
-
1000
+
                            let aY = $Tuple4(0, nil, nil, fd._4)
1003
1001
 
                            func es (ba,bb) =                             if ((bb >= aX))
1004
1002
 
                                then ba
1003
+
                                else fe(ba, aW[bb])
1004
+
1005
+
                            func et (ba,bb) =                             if ((bb >= aX))
1006
+
                                then ba
1005
1007
 
                                else throw("List size exceeds 50")
1006
1008
 
1007
-
                            es(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(er(aY, 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)
1009
+
                            et(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(es(aY, 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)
1008
1010
 
                            }
1009
-
                        else $Tuple4(0, eS, eU, fc._4)
1010
-
                    let fh = ec._4
1011
-
                    if ((fh > dH))
1012
-
                        then throw((((("Attempt to put total " + toString(fh)) + " stuff, but only ") + toString(dH)) + " warehouse space left"))
1013
-
                        else $Tuple7(makeString(cQ._2, "_"), makeString(fc._2, "_"), makeString(ec._2, "_"), makeString(cQ._3, "_"), makeString(fc._3, "_"), makeString(ec._3, "_"), fh)
1011
+
                        else $Tuple4(0, eT, eV, fd._4)
1012
+
                    let fi = ed._4
1013
+
                    if ((fi > dI))
1014
+
                        then throw((((("Attempt to put total " + toString(fi)) + " stuff, but only ") + toString(dI)) + " warehouse space left"))
1015
+
                        else $Tuple7(makeString(cR._2, "_"), makeString(fd._2, "_"), makeString(ed._2, "_"), makeString(cR._3, "_"), makeString(fd._3, "_"), makeString(ed._3, "_"), fi)
1014
1016
 
                    }
1015
1017
 
        }
1016
1018
 
1017
1019
 
1018
-
func fi (fj,fk) = {
1019
-
    let aN = toString(fj)
1020
-
    let fl = dN(toBigInt(fk))
1021
-
    let fm = valueOrElse(getInteger(cn()), (cm + 1))
1022
-
    let cp = toString(fm)
1023
-
    let dW = toInt((fl % cg))
1024
-
    let dv = dU(fl, dW)
1025
-
    let fn = U[dW]
1026
-
    let fo = Issue(cF(cp, "S"), makeString([cp, "S", dv, fn], "_"), 1, 0, false)
1027
-
    let ao = calculateAssetId(fo)
1028
-
    let fp = toBase58String(ao)
1029
-
    $Tuple2([IntegerEntry(cn(), (fm + 1)), fo, StringEntry(co(cp), fp), StringEntry(an(fp), aN), StringEntry(cu(cp), aN), IntegerEntry(ar(fp), 0), IntegerEntry(cs(fp, aN), 0), ScriptTransfer(fj, 1, ao)], $Tuple2(fp, fn))
1030
-
    }
1031
-
1032
-
1033
-
func fq (aN,fr,fs) = if (!(sigVerify_8Kb(fr, fs, bY)))
1020
+
func fj (fk,fl) = {
1021
+
    let aN = toString(fk)
1022
+
    let fm = dO(toBigInt(fl))
1023
+
    let fn = valueOrElse(getInteger(cn()), (cm + 1))
1024
+
    let cp = toString(fn)
1025
+
    let dX = toInt((fm % cg))
1026
+
    let dw = dV(fm, dX)
1027
+
    let fo = U[dX]
1028
+
    let fp = Issue(cG(cp, "S"), makeString([cp, "S", dw, fo], "_"), 1, 0, false)
1029
+
    let ao = calculateAssetId(fp)
1030
+
    let fq = toBase58String(ao)
1031
+
    $Tuple2([IntegerEntry(cn(), (fn + 1)), fp, StringEntry(co(cp), fq), StringEntry(an(fq), aN), StringEntry(cu(cp), aN), IntegerEntry(ar(fq), 0), IntegerEntry(cs(fq, aN), 0), ScriptTransfer(fk, 1, ao)], $Tuple2(fq, fo))
1032
+
    }
1033
+
1034
+
1035
+
func fr (aN,fs,ft) = if (!(sigVerify_8Kb(fs, ft, bY)))
1034
1036
 
    then throw("signature does not match")
1035
1037
 
    else {
1036
-
        let dg = split(toUtf8String(fr), ";")
1037
-
        let ft = split(dg[0], "|")
1038
-
        let fu = split(ft[cB], "_")
1039
-
        let fv = parseIntValue(fu[0])
1040
-
        let fw = parseIntValue(fu[1])
1041
-
        let fx = split(dg[1], ":")
1042
-
        let fy = fx[0]
1043
-
        let fz = parseIntValue(ft[cC])
1044
-
        if (if ((fz > (lastBlock.timestamp + ca)))
1038
+
        let dh = split(toUtf8String(fs), ";")
1039
+
        let fu = split(dh[0], "|")
1040
+
        let fv = split(fu[cC], "_")
1041
+
        let fw = parseIntValue(fv[0])
1042
+
        let fx = parseIntValue(fv[1])
1043
+
        let fy = split(dh[1], ":")
1044
+
        let fz = fy[0]
1045
+
        let fA = parseIntValue(fu[cD])
1046
+
        if (if ((fA > (lastBlock.timestamp + ca)))
1045
1047
 
            then true
1046
-
            else ((lastBlock.timestamp - ca) > fz))
1047
-
            then throw(((("signature outdated: logTime=" + toString(fz)) + ", bcTime=") + toString(lastBlock.timestamp)))
1048
+
            else ((lastBlock.timestamp - ca) > fA))
1049
+
            then throw(((("signature outdated: logTime=" + toString(fA)) + ", bcTime=") + toString(lastBlock.timestamp)))
1048
1050
 
            else {
1049
-
                let fA = fx[1]
1050
-
                let fB = valueOrElse(getString(am(aN)), "")
1051
-
                if ((fB != fA))
1052
-
                    then throw(((("Tx ids don't match! In state: " + fB) + ", in msg: ") + fA))
1051
+
                let fB = fy[1]
1052
+
                let fC = valueOrElse(getString(am(aN)), "")
1053
+
                if ((fC != fB))
1054
+
                    then throw(((("Tx ids don't match! In state: " + fC) + ", in msg: ") + fB))
1053
1055
 
                    else {
1054
1056
 
                        let k = valueOrErrorMessage(getString(aH(aN)), "You don't have a duck staked")
1055
-
                        let fC = aK(k)
1056
-
                        let fD = valueOrElse(getInteger(fC), 100)
1057
-
                        if ((fD != fv))
1058
-
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(fC), 100))) + " from state does not match one from flight log=") + toString(fv)))
1059
-
                            else if ((0 >= fv))
1057
+
                        let fD = aK(k)
1058
+
                        let fE = valueOrElse(getInteger(fD), 100)
1059
+
                        if ((fE != fw))
1060
+
                            then throw(((("oldHealth=" + toString(valueOrElse(getInteger(fD), 100))) + " from state does not match one from flight log=") + toString(fw)))
1061
+
                            else if ((0 >= fw))
1060
1062
 
                                then throw("You can't fly with zero health")
1061
1063
 
                                else {
1062
-
                                    let fE = if ((size(ft) > cD))
1063
-
                                        then ft[cD]
1064
+
                                    let fF = if ((size(fu) > cE))
1065
+
                                        then fu[cE]
1064
1066
 
                                        else ""
1065
-
                                    let fF = if ((size(ft) > cE))
1066
-
                                        then ft[cE]
1067
+
                                    let fG = if ((size(fu) > cF))
1068
+
                                        then fu[cF]
1067
1069
 
                                        else ""
1068
-
                                    let fG = if (if ((fw > 0))
1069
-
                                        then (fE == "$")
1070
+
                                    let fH = if (if ((fx > 0))
1071
+
                                        then (fF == "$")
1070
1072
 
                                        else false)
1071
1073
 
                                        then bS(invoke(bE, "sendUsdtPrize", [aN], nil))
1072
1074
 
                                        else 0
1073
-
                                    $Tuple5(fw, k, fG, fy, fF)
1075
+
                                    $Tuple5(fx, k, fH, fz, fG)
1074
1076
 
                                    }
1075
1077
 
                        }
1076
1078
 
                }
1077
1079
 
        }
1078
1080
 
1079
1081
 
1080
-
func fH (fj,fk,fr,fs) = {
1081
-
    let aN = toString(fj)
1082
-
    let dX = fq(aN, fr, fs)
1083
-
    let fC = aK(dX._2)
1084
-
    let eb = aI(dX._2)
1085
-
    let eM = ea(eb)
1086
-
    let fI = split(eM[ai], "_")
1087
-
    let fJ = makeString(cR(true, fI, ce), "_")
1088
-
    let dl = cY(eM[aj], dX._5)
1089
-
    if ((0 >= dX._1))
1090
-
        then $Tuple3([IntegerEntry(fC, 0), StringEntry(eb, makeString([eM[ag], eM[ah], eM[ai], dl], ":"))], "", 0)
1091
-
        else {
1092
-
            let fK = fi(fj, fk)
1093
-
            let fp = fK._2._1
1094
-
            $Tuple3((((fK._1 :+ StringEntry(aJ(dX._2), makeString([fK._2._2, "L", fp], "_"))) :+ IntegerEntry(fC, dX._1)) :+ StringEntry(eb, makeString([eM[ag], eM[ah], fJ, dl], ":"))), fp, dX._3)
1095
-
            }
1096
-
    }
1097
-
1098
-
1099
-
func fL (ay,fM) = {
1100
-
    let ew = valueOrElse(getInteger(ar(ay)), 0)
1101
-
    let fN = valueOrElse(getInteger(as(K, ay)), 0)
1102
-
    let fO = (ew / 6)
1103
-
    let fP = (ew / 7)
1104
-
    ((M + fraction(M, ((ew + fO) + (2 * fP)), 5)) + fraction(M, fN, (fM * 5)))
1105
-
    }
1106
-
1107
-
1108
-
func fQ (p,fR,fS) = {
1109
-
    let fT = if ((fR == cy))
1110
-
        then $Tuple2(fS, valueOrElse(getString(aH(p)), ""))
1082
+
func fI (fk,fl,fs,ft) = {
1083
+
    let aN = toString(fk)
1084
+
    let dY = fr(aN, fs, ft)
1085
+
    let fD = aK(dY._2)
1086
+
    let ec = aI(dY._2)
1087
+
    let eN = eb(ec)
1088
+
    let fJ = split(eN[ai], "_")
1089
+
    let fK = makeString(cS(true, fJ, ce), "_")
1090
+
    let dm = cZ(eN[aj], dY._5)
1091
+
    if ((0 >= dY._1))
1092
+
        then $Tuple3([IntegerEntry(fD, 0), StringEntry(ec, makeString([eN[ag], eN[ah], eN[ai], dm], ":"))], "", 0)
1093
+
        else {
1094
+
            let fL = fj(fk, fl)
1095
+
            let fq = fL._2._1
1096
+
            $Tuple3((((fL._1 :+ StringEntry(aJ(dY._2), makeString([fL._2._2, "L", fq], "_"))) :+ IntegerEntry(fD, dY._1)) :+ StringEntry(ec, makeString([eN[ag], eN[ah], fK, dm], ":"))), fq, dY._3)
1097
+
            }
1098
+
    }
1099
+
1100
+
1101
+
func fM (ay,fN) = {
1102
+
    let ex = valueOrElse(getInteger(ar(ay)), 0)
1103
+
    let fO = valueOrElse(getInteger(as(K, ay)), 0)
1104
+
    let fP = (ex / 6)
1105
+
    let fQ = (ex / 7)
1106
+
    ((M + fraction(M, ((ex + fP) + (2 * fQ)), 5)) + fraction(M, fO, (fN * 5)))
1107
+
    }
1108
+
1109
+
1110
+
func fR (p,fS,fT) = {
1111
+
    let fU = if ((fS == cz))
1112
+
        then $Tuple2(fT, valueOrElse(getString(aH(p)), ""))
1111
1113
 
        else {
1112
1114
 
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1113
-
            let fU = valueOrElse(getString(aJ(k)), P)
1114
-
            let fV = split(value(fU), "_")
1115
-
            if ((fV[aP] != "L"))
1116
-
                then throw((("Duck location type is " + fV[aP]) + ", but should be L"))
1117
-
                else $Tuple2(fV[aQ], k)
1118
-
            }
1119
-
    let ay = fT._1
1120
-
    let fW = fT._2
1121
-
    let fX = value(assetInfo(fromBase58String(ay)))
1122
-
    let fY = aq(ay)
1123
-
    let fZ = valueOrErrorMessage(getInteger(fY), (("Land " + fX.name) + " is not staked"))
1124
-
    let ga = valueOrErrorMessage(getString(an(ay)), (("NFT " + fX.name) + " is orphaned"))
1125
-
    if ((ga != p))
1115
+
            let fV = valueOrElse(getString(aJ(k)), P)
1116
+
            let fW = split(value(fV), "_")
1117
+
            if ((fW[aP] != "L"))
1118
+
                then throw((("Duck location type is " + fW[aP]) + ", but should be L"))
1119
+
                else $Tuple2(fW[aQ], k)
1120
+
            }
1121
+
    let ay = fU._1
1122
+
    let fX = fU._2
1123
+
    let fY = value(assetInfo(fromBase58String(ay)))
1124
+
    let fZ = aq(ay)
1125
+
    let ga = valueOrErrorMessage(getInteger(fZ), (("Land " + fY.name) + " is not staked"))
1126
+
    let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1127
+
    if ((gb != p))
1126
1128
 
        then throw((I + " is not yours"))
1127
1129
 
        else {
1128
-
            let gb = split(fX.description, "_")
1129
-
            $Tuple4(fW, ay, gb, fZ)
1130
-
            }
1131
-
    }
1132
-
1133
-
1134
-
func gc (p,eJ,fR,fS) = if ((0 > eJ))
1130
+
            let gc = split(fY.description, "_")
1131
+
            $Tuple4(fX, ay, gc, ga)
1132
+
            }
1133
+
    }
1134
+
1135
+
1136
+
func gd (p,eK,fS,fT) = if ((0 > eK))
1135
1137
 
    then throw("Negative amount")
1136
1138
 
    else {
1137
-
        let gd = fQ(p, fR, fS)
1138
-
        let bV = gd._3[bK]
1139
-
        let do = du(gd._3[bL])
1140
-
        let dy = (lastBlock.timestamp - gd._4)
1141
-
        if ((0 > dy))
1142
-
            then throw(((("Saved timestamp is in future, saved = " + toString(gd._4)) + ", current = ") + toString(lastBlock.timestamp)))
1139
+
        let ge = fR(p, fS, fT)
1140
+
        let bV = ge._3[bK]
1141
+
        let dp = dv(ge._3[bL])
1142
+
        let dz = (lastBlock.timestamp - ge._4)
1143
+
        if ((0 > dz))
1144
+
            then throw(((("Saved timestamp is in future, saved = " + toString(ge._4)) + ", current = ") + toString(lastBlock.timestamp)))
1143
1145
 
            else {
1144
-
                let fM = bU(bV)
1145
-
                let ge = fL(gd._2, fM)
1146
-
                let gf = fraction(dy, (ge * fM), N)
1147
-
                if ((eJ > gf))
1148
-
                    then throw(((("Not enough resources, available = " + toString(gf)) + ", requested = ") + toString(eJ)))
1146
+
                let fN = bU(bV)
1147
+
                let gf = fM(ge._2, fN)
1148
+
                let gg = fraction(dz, (gf * fN), N)
1149
+
                if ((eK > gg))
1150
+
                    then throw(((("Not enough resources, available = " + toString(gg)) + ", requested = ") + toString(eK)))
1149
1151
 
                    else {
1150
-
                        let gg = fraction((gf - eJ), N, (ge * fM))
1151
-
                        let gh = (lastBlock.timestamp - gg)
1152
-
                        let ev = (fM / bl)
1153
-
                        let dG = dC(do, (dy - gg), ev, ge)
1154
-
                        let eu = ax(gd._2)
1155
-
                        let ew = valueOrElse(getInteger(ar(gd._2)), 0)
1156
-
                        let eg = et(eu, ev, ew)
1157
-
                        let eC = split(eg[ab], "_")
1158
-
                        let dH = parseIntValue(eC[ae])
1159
-
                        if (if ((fR == cy))
1160
-
                            then (eJ > dH)
1152
+
                        let gh = fraction((gg - eK), N, (gf * fN))
1153
+
                        let gi = (lastBlock.timestamp - gh)
1154
+
                        let ew = (fN / bl)
1155
+
                        let dH = dD(dp, (dz - gh), ew, gf)
1156
+
                        let ev = ax(ge._2)
1157
+
                        let ex = valueOrElse(getInteger(ar(ge._2)), 0)
1158
+
                        let eh = eu(ev, ew, ex)
1159
+
                        let eD = split(eh[ab], "_")
1160
+
                        let dI = parseIntValue(eD[ae])
1161
+
                        if (if ((fS == cz))
1162
+
                            then (eK > dI)
1161
1163
 
                            else false)
1162
-
                            then throw((("Only " + toString(dH)) + " space left in warehouse"))
1164
+
                            then throw((("Only " + toString(dI)) + " space left in warehouse"))
1163
1165
 
                            else {
1164
-
                                let eb = aI(gd._1)
1165
-
                                let eM = ea(eb)
1166
-
                                let dF = split(eM[ah], "_")
1167
-
                                let dE = split(eg[Y], "_")
1168
-
                                let gi = if ((fR == cy))
1169
-
                                    then $Tuple4(dw(dE, do, (dy - gg), ev, ge), eM[ah], (parseIntValue(eC[ad]) + dG._2), (parseIntValue(eC[ae]) - dG._2))
1170
-
                                    else if ((fR == cz))
1171
-
                                        then $Tuple4(eg[Y], dw(dF, do, (dy - gg), ev, ge), parseIntValue(eC[ad]), parseIntValue(eC[ae]))
1166
+
                                let ec = aI(ge._1)
1167
+
                                let eN = eb(ec)
1168
+
                                let dG = split(eN[ah], "_")
1169
+
                                let dF = split(eh[Y], "_")
1170
+
                                let gj = if ((fS == cz))
1171
+
                                    then $Tuple4(dx(dF, dp, (dz - gh), ew, gf), eN[ah], (parseIntValue(eD[ad]) + dH._2), (parseIntValue(eD[ae]) - dH._2))
1172
+
                                    else if ((fS == cA))
1173
+
                                        then $Tuple4(eh[Y], dx(dG, dp, (dz - gh), ew, gf), parseIntValue(eD[ad]), parseIntValue(eD[ae]))
1172
1174
 
                                        else {
1173
-
                                            let gj = dD(dE, dF, dG, dH)
1174
-
                                            let gk = min([parseIntValue(eC[ae]), dG._2])
1175
-
                                            $Tuple4(gj._1, gj._2, (parseIntValue(eC[ad]) + gk), (parseIntValue(eC[ae]) - gk))
1175
+
                                            let gk = dE(dF, dG, dH, dI)
1176
+
                                            let gl = min([parseIntValue(eD[ae]), dH._2])
1177
+
                                            $Tuple4(gk._1, gk._2, (parseIntValue(eD[ad]) + gl), (parseIntValue(eD[ae]) - gl))
1176
1178
 
                                            }
1177
-
                                let gl = gi._1
1178
-
                                let gm = gi._2
1179
-
                                let gn = gi._3
1180
-
                                let go = gi._4
1181
-
                                $Tuple5([IntegerEntry(aq(gd._2), gh), IntegerEntry(au(I, gd._2, p), gh)], eb, [eM[ag], gm, eM[ai], eM[aj]], eu, [eg[X], gl, eg[Z], eg[aa], makeString([eC[ac], toString(gn), toString(go), eC[af]], "_")])
1179
+
                                let gm = gj._1
1180
+
                                let gn = gj._2
1181
+
                                let go = gj._3
1182
+
                                let gp = gj._4
1183
+
                                $Tuple5([IntegerEntry(aq(ge._2), gi), IntegerEntry(au(I, ge._2, p), gi)], ec, [eN[ag], gn, eN[ai], eN[aj]], ev, [eh[X], gm, eh[Z], eh[aa], makeString([eD[ac], toString(go), toString(gp), eD[af]], "_")])
1182
1184
 
                                }
1183
1185
 
                        }
1184
1186
 
                }
1185
1187
 
        }
1186
1188
 
1187
1189
 
1188
-
func gp (p,ay,fM,fR) = {
1189
-
    let fY = aq(ay)
1190
-
    let fZ = value(getInteger(fY))
1191
-
    let gf = (fraction((lastBlock.timestamp - fZ), fL(ay, fM), N) * fM)
1192
-
    gc(p, gf, fR, ay)
1193
-
    }
1194
-
1195
-
1196
-
func gq (cS,fj,gr,ay) = {
1197
-
    let p = toString(fj)
1198
-
    let gd = fQ(p, cA, ay)
1199
-
    let fM = bU(gd._3[bK])
1200
-
    let gs = ar(gd._2)
1201
-
    let gt = valueOrElse(getInteger(gs), 0)
1202
-
    if ((gt >= 3))
1190
+
func gq (p,ay,fN,fS) = {
1191
+
    let fZ = aq(ay)
1192
+
    let ga = value(getInteger(fZ))
1193
+
    let gg = (fraction((lastBlock.timestamp - ga), fM(ay, fN), N) * fN)
1194
+
    gd(p, gg, fS, ay)
1195
+
    }
1196
+
1197
+
1198
+
func gr (cT,fk,gs,ay) = {
1199
+
    let p = toString(fk)
1200
+
    let ge = fR(p, cB, ay)
1201
+
    let fN = bU(ge._3[bK])
1202
+
    let gt = ar(ge._2)
1203
+
    let gu = valueOrElse(getInteger(gt), 0)
1204
+
    if ((gu >= 3))
1203
1205
 
        then throw("Currently max infrastructure level = 3")
1204
1206
 
        else {
1205
-
            let H = (gt + 1)
1206
-
            let gu = fraction(cd, (fM * H), bl)
1207
-
            if (if (!(cS))
1208
-
                then (gr != gu)
1207
+
            let H = (gu + 1)
1208
+
            let gv = fraction(cd, (fN * H), bl)
1209
+
            if (if (!(cT))
1210
+
                then (gs != gv)
1209
1211
 
                else false)
1210
-
                then throw(("Payment attached should be " + toString(gu)))
1212
+
                then throw(("Payment attached should be " + toString(gv)))
1211
1213
 
                else {
1212
-
                    let eb = aI(gd._1)
1213
-
                    let eM = ea(eb)
1214
-
                    let fI = split(eM[ai], "_")
1215
-
                    let gv = fraction(bh, (fM * H), bl)
1216
-
                    let fJ = makeString(cR(cS, fI, gv), "_")
1217
-
                    let gw = gp(p, gd._2, fM, cA)
1218
-
                    let gx = gw._5
1219
-
                    let gy = ed(gx[X])
1220
-
                    let gz = makeString([split(gx[X], "_")[0], toString(H)], "_")
1221
-
                    let gA = ed(gz)
1222
-
                    let eC = split(gx[ab], "_")
1223
-
                    let gB = makeString([eC[ac], eC[ad], toString(((parseIntValue(eC[ae]) + gA) - gy)), toString(gA)], "_")
1224
-
                    $Tuple3(([IntegerEntry(gs, H), IntegerEntry(cs(gd._2, p), H), StringEntry(eb, makeString([eM[ag], gw._3[ah], fJ, eM[aj]], ":")), StringEntry(gw._4, makeString([gz, gx[Y], gx[Z], gx[aa], gB], ":"))] ++ gw._1), H, gv)
1214
+
                    let ec = aI(ge._1)
1215
+
                    let eN = eb(ec)
1216
+
                    let fJ = split(eN[ai], "_")
1217
+
                    let gw = fraction(bh, (fN * H), bl)
1218
+
                    let fK = makeString(cS(cT, fJ, gw), "_")
1219
+
                    let gx = gq(p, ge._2, fN, cB)
1220
+
                    let gy = gx._5
1221
+
                    let gz = ee(gy[X])
1222
+
                    let gA = makeString([split(gy[X], "_")[0], toString(H)], "_")
1223
+
                    let gB = ee(gA)
1224
+
                    let eD = split(gy[ab], "_")
1225
+
                    let gC = makeString([eD[ac], eD[ad], toString(((parseIntValue(eD[ae]) + gB) - gz)), toString(gB)], "_")
1226
+
                    $Tuple3(([IntegerEntry(gt, H), IntegerEntry(cs(ge._2, p), H), StringEntry(ec, makeString([eN[ag], gx._3[ah], fK, eN[aj]], ":")), StringEntry(gx._4, makeString([gA, gy[Y], gy[Z], gy[aa], gC], ":"))] ++ gx._1), H, gw)
1225
1227
 
                    }
1226
1228
 
            }
1227
1229
 
    }
1228
1230
 
1229
1231
 
1230
-
func gC (k,gD) = {
1231
-
    let gE = m(k)
1232
-
    let gF = l(k)
1233
-
    let D = valueOrElse(getInteger(bF, gF), 0)
1234
-
    let G = (D + gD)
1235
-
    let gG = E(valueOrElse(getInteger(bF, gE), 0), G)
1236
-
    let gH = n(k)
1237
-
    $Tuple2([IntegerEntry(gE, gG[0]), IntegerEntry(gF, G), IntegerEntry(gH, (valueOrElse(getInteger(gH), 0) + gG[1]))], G)
1238
-
    }
1239
-
1240
-
1241
-
func gI (p,gD) = {
1242
-
    let gE = q(p)
1243
-
    let gF = o(p)
1244
-
    let D = valueOrElse(getInteger(bF, gF), 0)
1245
-
    let G = (D + gD)
1246
-
    let gG = E(valueOrElse(getInteger(bF, gE), 0), G)
1247
-
    let gH = r(p)
1248
-
    $Tuple2([IntegerEntry(gE, gG[0]), IntegerEntry(gF, G), IntegerEntry(gH, (valueOrElse(getInteger(gH), 0) + gG[1]))], G)
1249
-
    }
1250
-
1251
-
1252
-
func gJ (p) = {
1232
+
func gD (k,gE) = {
1233
+
    let gF = m(k)
1234
+
    let gG = l(k)
1235
+
    let D = valueOrElse(getInteger(bF, gG), 0)
1236
+
    let G = (D + gE)
1237
+
    let gH = E(valueOrElse(getInteger(bF, gF), 0), G)
1238
+
    let gI = n(k)
1239
+
    $Tuple2([IntegerEntry(gF, gH[0]), IntegerEntry(gG, G), IntegerEntry(gI, (valueOrElse(getInteger(gI), 0) + gH[1]))], G)
1240
+
    }
1241
+
1242
+
1243
+
func gJ (p,gE) = {
1244
+
    let gF = q(p)
1245
+
    let gG = o(p)
1246
+
    let D = valueOrElse(getInteger(bF, gG), 0)
1247
+
    let G = (D + gE)
1248
+
    let gH = E(valueOrElse(getInteger(bF, gF), 0), G)
1249
+
    let gI = r(p)
1250
+
    $Tuple2([IntegerEntry(gF, gH[0]), IntegerEntry(gG, G), IntegerEntry(gI, (valueOrElse(getInteger(gI), 0) + gH[1]))], G)
1251
+
    }
1252
+
1253
+
1254
+
func gK (p) = {
1253
1255
 
    let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1254
-
    let gK = aC(p)
1255
-
    let gL = getString(gK)
1256
-
    if (!(isDefined(gL)))
1256
+
    let gL = aC(p)
1257
+
    let gM = getString(gL)
1258
+
    if (!(isDefined(gM)))
1257
1259
 
        then throw("You are not eligible for ONBOARD artifact")
1258
1260
 
        else {
1259
-
            let gM = aE(p)
1260
-
            let gN = getString(gM)
1261
-
            if (isDefined(gN))
1262
-
                then throw(("You already used your ONBOARD artifact on duck " + value(gN)))
1261
+
            let gN = aE(p)
1262
+
            let gO = getString(gN)
1263
+
            if (isDefined(gO))
1264
+
                then throw(("You already used your ONBOARD artifact on duck " + value(gO)))
1263
1265
 
                else {
1264
-
                    let gO = aD(k)
1265
-
                    let gP = getString(gO)
1266
-
                    if (isDefined(gP))
1267
-
                        then throw(((("The duck " + k) + " already got points from ONBOARD artifact from user ") + value(gP)))
1268
-
                        else ([StringEntry(gM, k), StringEntry(gO, p)] ++ gC(k, A)._1)
1266
+
                    let gP = aD(k)
1267
+
                    let gQ = getString(gP)
1268
+
                    if (isDefined(gQ))
1269
+
                        then throw(((("The duck " + k) + " already got points from ONBOARD artifact from user ") + value(gQ)))
1270
+
                        else ([StringEntry(gN, k), StringEntry(gP, p)] ++ gD(k, A)._1)
1269
1271
 
                    }
1270
1272
 
            }
1271
1273
 
    }
1272
1274
 
1273
1275
 
1274
-
func gQ (p,fS) = {
1275
-
    let gd = fQ(p, cA, fS)
1276
-
    let ay = gd._2
1277
-
    let fM = bU(gd._3[bK])
1278
-
    let gR = as(K, ay)
1279
-
    if ((valueOrElse(getInteger(gR), 0) > 0))
1276
+
func gR (p,fT) = {
1277
+
    let ge = fR(p, cB, fT)
1278
+
    let ay = ge._2
1279
+
    let fN = bU(ge._3[bK])
1280
+
    let gS = as(K, ay)
1281
+
    if ((valueOrElse(getInteger(gS), 0) > 0))
1280
1282
 
        then throw("Presale artifact is already activated")
1281
-
        else if ((parseIntValue(gd._3[bJ]) > cm))
1283
+
        else if ((parseIntValue(ge._3[bJ]) > cm))
1282
1284
 
            then throw((((I + " ") + ay) + " is not eligible for presale artifact"))
1283
1285
 
            else {
1284
-
                let gw = gp(p, ay, fM, cA)
1285
-
                ((((gw._1 :+ IntegerEntry(gR, fM)) :+ IntegerEntry(ct(K, ay, p), fM)) :+ StringEntry(gw._2, makeString(gw._3, ":"))) :+ StringEntry(gw._4, makeString(gw._5, ":")))
1286
+
                let gx = gq(p, ay, fN, cB)
1287
+
                ((((gx._1 :+ IntegerEntry(gS, fN)) :+ IntegerEntry(ct(K, ay, p), fN)) :+ StringEntry(gx._2, makeString(gx._3, ":"))) :+ StringEntry(gx._4, makeString(gx._5, ":")))
1286
1288
 
                }
1287
1289
 
    }
1288
1290
 
1289
1291
 
1290
-
func gS (gT,H,gU,p,gV,fk,gW) = {
1292
+
func gT (gU,H,gV,p,gW,fl,gX) = {
1291
1293
 
    let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1292
-
    func gX (cM,ay) =     {
1293
-
        let fX = value(assetInfo(fromBase58String(ay)))
1294
-
        let fY = aq(ay)
1295
-
        let fZ = valueOrErrorMessage(getInteger(fY), (("NFT " + fX.name) + " is not staked"))
1296
-
        let ga = valueOrErrorMessage(getString(an(ay)), (("NFT " + fX.name) + " is orphaned"))
1297
-
        if ((ga != p))
1294
+
    func gY (cN,ay) =     {
1295
+
        let fY = value(assetInfo(fromBase58String(ay)))
1296
+
        let fZ = aq(ay)
1297
+
        let ga = valueOrErrorMessage(getInteger(fZ), (("NFT " + fY.name) + " is not staked"))
1298
+
        let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1299
+
        if ((gb != p))
1298
1300
 
            then throw((I + " is not yours"))
1299
1301
 
            else {
1300
-
                let gb = split(fX.description, "_")
1301
-
                let fn = gb[bM]
1302
-
                if (if ((cM._3 != ""))
1303
-
                    then (cM._3 != fn)
1302
+
                let gc = split(fY.description, "_")
1303
+
                let fo = gc[bM]
1304
+
                if (if ((cN._3 != ""))
1305
+
                    then (cN._3 != fo)
1304
1306
 
                    else false)
1305
1307
 
                    then throw("Lands should be on the same continent to merge")
1306
1308
 
                    else {
1307
-
                        let bV = gb[bK]
1308
-
                        let gY = cM._1
1309
-
                        let ds = valueOrErrorMessage(indexOf(gY, bV), "You haven't passed all the lands needed")
1310
-
                        let gZ = (take(gY, ds) + drop(gY, (ds + 1)))
1311
-
                        let fM = bU(bV)
1312
-
                        let ha = (cM._2 + valueOrElse(getInteger(as(K, ay)), 0))
1313
-
                        let ew = valueOrElse(getInteger(ar(ay)), 0)
1314
-
                        let hb = {
1309
+
                        let bV = gc[bK]
1310
+
                        let gZ = cN._1
1311
+
                        let dt = valueOrErrorMessage(indexOf(gZ, bV), "You haven't passed all the lands needed")
1312
+
                        let ha = (take(gZ, dt) + drop(gZ, (dt + 1)))
1313
+
                        let fN = bU(bV)
1314
+
                        let hb = (cN._2 + valueOrElse(getInteger(as(K, ay)), 0))
1315
+
                        let ex = valueOrElse(getInteger(ar(ay)), 0)
1316
+
                        let hc = {
1315
1317
 
                            let bf = bV
1316
1318
 
                            if (("S" == bf))
1317
1319
 
                                then 3
1323
1325
 
                                            then 6
1324
1326
 
                                            else throw("Only S, M, L, XL can merge")
1325
1327
 
                            }
1326
-
                        if ((ew != hb))
1328
+
                        if ((ex != hc))
1327
1329
 
                            then throw("All lands should be maxed to merge")
1328
1330
 
                            else {
1329
-
                                let cp = gb[bJ]
1330
-
                                let do = du(gb[bL])
1331
-
                                let dy = (lastBlock.timestamp - fZ)
1332
-
                                if ((0 > dy))
1333
-
                                    then throw(((("Saved timestamp is in future, saved = " + toString(fZ)) + ", current = ") + toString(lastBlock.timestamp)))
1331
+
                                let cp = gc[bJ]
1332
+
                                let dp = dv(gc[bL])
1333
+
                                let dz = (lastBlock.timestamp - ga)
1334
+
                                if ((0 > dz))
1335
+
                                    then throw(((("Saved timestamp is in future, saved = " + toString(ga)) + ", current = ") + toString(lastBlock.timestamp)))
1334
1336
 
                                    else {
1335
-
                                        let ge = fL(ay, fM)
1336
-
                                        let ev = (fM / bl)
1337
-
                                        let gm = dw(split(cM._4, "_"), do, dy, ev, ge)
1338
-
                                        let cP = dm(split(cM._6, "_"), do, ev, -1)
1339
-
                                        let hc = cM._7
1340
-
                                        let bD = indexOf(hc, ay)
1337
+
                                        let gf = fM(ay, fN)
1338
+
                                        let ew = (fN / bl)
1339
+
                                        let gn = dx(split(cN._4, "_"), dp, dz, ew, gf)
1340
+
                                        let cQ = dn(split(cN._6, "_"), dp, ew, -1)
1341
+
                                        let hd = cN._7
1342
+
                                        let bD = indexOf(hd, ay)
1341
1343
 
                                        if (!(isDefined(bD)))
1342
1344
 
                                            then throw(("Your staked lands don't contain " + ay))
1343
1345
 
                                            else {
1344
-
                                                let hd = ap(ay)
1345
-
                                                let he = valueOrElse(getString(hd), "")
1346
-
                                                $Tuple8(gZ, ha, fn, gm, (((((((((((((cM._5 :+ DeleteEntry(aq(ay))) :+ DeleteEntry(au(I, ay, p))) :+ DeleteEntry(co(cp))) :+ DeleteEntry(an(ay))) :+ DeleteEntry(ar(ay))) :+ DeleteEntry(cs(ay, p))) :+ DeleteEntry(as(K, ay))) :+ DeleteEntry(ct(K, ay, p))) :+ DeleteEntry(cu(cp))) :+ DeleteEntry(ax(ay))) :+ DeleteEntry(hd)) :+ DeleteEntry(cq(he))) :+ Burn(fromBase58String(ay), 1)), cP, removeByIndex(hc, value(bD)), (cM._8 + fM))
1346
+
                                                let he = ap(ay)
1347
+
                                                let hf = valueOrElse(getString(he), "")
1348
+
                                                $Tuple8(ha, hb, fo, gn, (((((((((((((cN._5 :+ DeleteEntry(aq(ay))) :+ DeleteEntry(au(I, ay, p))) :+ DeleteEntry(co(cp))) :+ DeleteEntry(an(ay))) :+ DeleteEntry(ar(ay))) :+ DeleteEntry(cs(ay, p))) :+ DeleteEntry(as(K, ay))) :+ DeleteEntry(ct(K, ay, p))) :+ DeleteEntry(cu(cp))) :+ DeleteEntry(ax(ay))) :+ DeleteEntry(he)) :+ DeleteEntry(cq(hf))) :+ Burn(fromBase58String(ay), 1)), cQ, removeByIndex(hd, value(bD)), (cN._8 + fN))
1347
1349
 
                                                }
1348
1350
 
                                        }
1349
1351
 
                                }
1351
1353
 
                }
1352
1354
 
        }
1353
1355
 
1354
-
    let eb = aI(k)
1355
-
    let eM = ea(eb)
1356
-
    let hf = valueOrElse(getString(bN()), "0_0_0_0_0_0")
1357
-
    let hg = bO(p)
1358
-
    let hh = getString(hg)
1359
-
    let hi = if (isDefined(hh))
1360
-
        then split_51C(value(hh), "_")
1356
+
    let ec = aI(k)
1357
+
    let eN = eb(ec)
1358
+
    let hg = valueOrElse(getString(bN()), "0_0_0_0_0_0")
1359
+
    let hh = bO(p)
1360
+
    let hi = getString(hh)
1361
+
    let hj = if (isDefined(hi))
1362
+
        then split_51C(value(hi), "_")
1361
1363
 
        else nil
1362
-
    let cQ = {
1363
-
        let aW = gV
1364
+
    let cR = {
1365
+
        let aW = gW
1364
1366
 
        let aX = size(aW)
1365
-
        let aY = $Tuple8(gU, 0, "", eM[ah], nil, hf, hi, 0)
1367
+
        let aY = $Tuple8(gV, 0, "", eN[ah], nil, hg, hj, 0)
1366
1368
 
        func aZ (ba,bb) =         if ((bb >= aX))
1367
1369
 
            then ba
1368
-
            else gX(ba, aW[bb])
1370
+
            else gY(ba, aW[bb])
1369
1371
 
1370
1372
 
        func bc (ba,bb) =         if ((bb >= aX))
1371
1373
 
            then ba
1373
1375
 
1374
1376
 
        bc(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5)
1375
1377
 
        }
1376
-
    let fn = cQ._3
1377
-
    let dW = valueOrErrorMessage(indexOf(U, fn), ("Unknown continent: " + fn))
1378
-
    let dv = dU(dN(toBigInt(fk)), dW)
1379
-
    let fm = valueOrElse(getInteger(cn()), (cm + 1))
1380
-
    let hj = toString(fm)
1381
-
    let fo = Issue(cF(hj, gT), makeString([hj, gT, dv, fn], "_"), 1, 0, false)
1382
-
    let ao = calculateAssetId(fo)
1383
-
    let hk = toBase58String(ao)
1384
-
    let fJ = makeString(cR((gW > 0), split(eM[ai], "_"), gW), "_")
1385
-
    let hl = az(p)
1386
-
    let hm = valueOrElse(getInteger(hl), 0)
1387
-
    $Tuple2((((((((((((((((cQ._5 :+ (if ((size(cQ._7) > 0))
1388
-
        then StringEntry(hg, makeString_11C(cQ._7, "_"))
1389
-
        else DeleteEntry(hg))) :+ IntegerEntry(hl, if ((cQ._8 > hm))
1378
+
    let fo = cR._3
1379
+
    let dX = valueOrErrorMessage(indexOf(U, fo), ("Unknown continent: " + fo))
1380
+
    let dw = dV(dO(toBigInt(fl)), dX)
1381
+
    let fn = valueOrElse(getInteger(cn()), (cm + 1))
1382
+
    let hk = toString(fn)
1383
+
    let fp = Issue(cG(hk, gU), makeString([hk, gU, dw, fo], "_"), 1, 0, false)
1384
+
    let ao = calculateAssetId(fp)
1385
+
    let hl = toBase58String(ao)
1386
+
    let fK = makeString(cS((gX > 0), split(eN[ai], "_"), gX), "_")
1387
+
    let hm = az(p)
1388
+
    let hn = valueOrElse(getInteger(hm), 0)
1389
+
    $Tuple2((((((((((((((((cR._5 :+ (if ((size(cR._7) > 0))
1390
+
        then StringEntry(hh, makeString_11C(cR._7, "_"))
1391
+
        else DeleteEntry(hh))) :+ IntegerEntry(hm, if ((cR._8 > hn))
1390
1392
 
        then 0
1391
-
        else (hm - cQ._8))) :+ IntegerEntry(cn(), (fm + 1))) :+ fo) :+ StringEntry(co(hj), hk)) :+ StringEntry(an(hk), p)) :+ StringEntry(cu(hj), p)) :+ IntegerEntry(as(K, hk), cQ._2)) :+ IntegerEntry(ct(K, hk, p), cQ._2)) :+ IntegerEntry(ar(hk), H)) :+ IntegerEntry(cs(hk, p), H)) :+ StringEntry(eb, makeString([eM[ag], cQ._4, fJ, eM[aj]], ":"))) :+ StringEntry(bN(), cQ._6)) :+ StringEntry(aJ(k), makeString([fn, "L", hk], "_"))) :+ ScriptTransfer(addressFromStringValue(p), 1, ao)), hk)
1392
-
    }
1393
-
1394
-
1395
-
func hn (p,gV,fk) = gS("M", 3, "SSSS", p, gV, fk, 0)
1396
-
1397
-
1398
-
func ho (p,gV,fk,cS,gr) = {
1399
-
    let gu = (cd * 4)
1400
-
    if (if (!(cS))
1401
-
        then (gr != gu)
1393
+
        else (hn - cR._8))) :+ IntegerEntry(cn(), (fn + 1))) :+ fp) :+ StringEntry(co(hk), hl)) :+ StringEntry(an(hl), p)) :+ StringEntry(cu(hk), p)) :+ IntegerEntry(as(K, hl), cR._2)) :+ IntegerEntry(ct(K, hl, p), cR._2)) :+ IntegerEntry(ar(hl), H)) :+ IntegerEntry(cs(hl, p), H)) :+ StringEntry(ec, makeString([eN[ag], cR._4, fK, eN[aj]], ":"))) :+ StringEntry(bN(), cR._6)) :+ StringEntry(aJ(k), makeString([fo, "L", hl], "_"))) :+ ScriptTransfer(addressFromStringValue(p), 1, ao)), hl)
1394
+
    }
1395
+
1396
+
1397
+
func ho (p,gW,fl) = gT("M", 3, "SSSS", p, gW, fl, 0)
1398
+
1399
+
1400
+
func hp (p,gW,fl,cT,gs) = {
1401
+
    let gv = (cd * 4)
1402
+
    if (if (!(cT))
1403
+
        then (gs != gv)
1402
1404
 
        else false)
1403
-
        then throw(("Payment attached should be " + toString(gu)))
1404
-
        else gS("L", 4, "SMM", p, gV, fk, (bh * 4))
1405
-
    }
1406
-
1407
-
1408
-
func hp (p,gV,fk,cS,gr) = {
1409
-
    let gu = (cd * 47)
1410
-
    if (if (!(cS))
1411
-
        then (gr != gu)
1405
+
        then throw(("Payment attached should be " + toString(gv)))
1406
+
        else gT("L", 4, "SMM", p, gW, fl, (bh * 4))
1407
+
    }
1408
+
1409
+
1410
+
func hq (p,gW,fl,cT,gs) = {
1411
+
    let gv = (cd * 47)
1412
+
    if (if (!(cT))
1413
+
        then (gs != gv)
1412
1414
 
        else false)
1413
-
        then throw(("Payment attached should be " + toString(gu)))
1414
-
        else gS("XL", 5, "SSSML", p, gV, fk, (bh * 47))
1415
-
    }
1416
-
1417
-
1418
-
func hq (p,gV,fk,cS,gr) = {
1419
-
    let gu = (cd * 54)
1420
-
    if (if (!(cS))
1421
-
        then (gr != gu)
1415
+
        then throw(("Payment attached should be " + toString(gv)))
1416
+
        else gT("XL", 5, "SSSML", p, gW, fl, (bh * 47))
1417
+
    }
1418
+
1419
+
1420
+
func hr (p,gW,fl,cT,gs) = {
1421
+
    let gv = (cd * 54)
1422
+
    if (if (!(cT))
1423
+
        then (gs != gv)
1422
1424
 
        else false)
1423
-
        then throw(("Payment attached should be " + toString(gu)))
1424
-
        else gS("XXL", 6, "LXL", p, gV, fk, (bh * 54))
1425
-
    }
1426
-
1427
-
1428
-
func hr (cS,p,gr,gV,fk) = {
1429
-
    let hs = {
1430
-
        let bf = size(gV)
1425
+
        then throw(("Payment attached should be " + toString(gv)))
1426
+
        else gT("XXL", 6, "LXL", p, gW, fl, (bh * 54))
1427
+
    }
1428
+
1429
+
1430
+
func hs (cT,p,gs,gW,fl) = {
1431
+
    let ht = {
1432
+
        let bf = size(gW)
1431
1433
 
        if ((4 == bf))
1432
-
            then hn(p, gV, fk)
1434
+
            then ho(p, gW, fl)
1433
1435
 
            else if ((3 == bf))
1434
-
                then ho(p, gV, fk, cS, gr)
1436
+
                then hp(p, gW, fl, cT, gs)
1435
1437
 
                else if ((5 == bf))
1436
-
                    then hp(p, gV, fk, cS, gr)
1438
+
                    then hq(p, gW, fl, cT, gs)
1437
1439
 
                    else if ((2 == bf))
1438
-
                        then hq(p, gV, fk, cS, gr)
1440
+
                        then hr(p, gW, fl, cT, gs)
1439
1441
 
                        else throw("Unknown merge")
1440
1442
 
        }
1441
-
    hs
1442
-
    }
1443
-
1444
-
1445
-
func ht (ds) = if (if ((ds.originCaller != bE))
1443
+
    ht
1444
+
    }
1445
+
1446
+
1447
+
func hu (dt) = if (if ((dt.originCaller != bE))
1446
1448
 
    then valueOrElse(getBoolean(aL()), false)
1447
1449
 
    else false)
1448
1450
 
    then throw("Contracts are under maintenance")
1449
-
    else StringEntry(am(toString(ds.originCaller)), toBase58String(ds.transactionId))
1450
-
1451
-
1452
-
@Callable(ds)
1453
-
func constructorV1 (hu) = if ((ds.caller != this))
1451
+
    else StringEntry(am(toString(dt.originCaller)), toBase58String(dt.transactionId))
1452
+
1453
+
1454
+
@Callable(dt)
1455
+
func constructorV1 (hv) = if ((dt.caller != this))
1454
1456
 
    then throw("Permission denied")
1455
-
    else [StringEntry(by(), hu)]
1456
-
1457
-
1458
-
1459
-
@Callable(ds)
1460
-
func setBlocked (hv) = if ((ds.caller != this))
1457
+
    else [StringEntry(by(), hv)]
1458
+
1459
+
1460
+
1461
+
@Callable(dt)
1462
+
func setBlocked (hw) = if ((dt.caller != this))
1461
1463
 
    then throw("permission denied")
1462
-
    else [BooleanEntry(aL(), hv)]
1463
-
1464
-
1465
-
1466
-
@Callable(ds)
1464
+
    else [BooleanEntry(aL(), hw)]
1465
+
1466
+
1467
+
1468
+
@Callable(dt)
1467
1469
 
func stakeLand () = {
1468
-
    let hw = ht(ds)
1469
-
    if ((size(ds.payments) != 1))
1470
+
    let hx = hu(dt)
1471
+
    if ((size(dt.payments) != 1))
1470
1472
 
        then throw("Exactly one payment required")
1471
1473
 
        else {
1472
-
            let hx = value(ds.payments[0])
1473
-
            let ao = value(hx.assetId)
1474
-
            let br = toString(ds.caller)
1475
-
            if ((hx.amount != 1))
1474
+
            let hy = value(dt.payments[0])
1475
+
            let ao = value(hy.assetId)
1476
+
            let br = toString(dt.caller)
1477
+
            if ((hy.amount != 1))
1476
1478
 
                then throw((("NFT " + I) + " token should be attached as payment"))
1477
1479
 
                else {
1478
-
                    let fX = value(assetInfo(ao))
1479
-
                    if ((fX.issuer != this))
1480
+
                    let fY = value(assetInfo(ao))
1481
+
                    if ((fY.issuer != this))
1480
1482
 
                        then throw("Unknown issuer of token")
1481
-
                        else if (!(contains(fX.name, I)))
1483
+
                        else if (!(contains(fY.name, I)))
1482
1484
 
                            then throw((("Only NFT " + I) + " tokens are accepted"))
1483
1485
 
                            else {
1484
-
                                let hy = drop(fX.name, 4)
1485
-
                                let cp = if (contains(hy, "XXL"))
1486
-
                                    then dropRight(hy, 3)
1487
-
                                    else if (contains(hy, "XL"))
1488
-
                                        then dropRight(hy, 2)
1489
-
                                        else dropRight(hy, 1)
1486
+
                                let hz = drop(fY.name, 4)
1487
+
                                let cp = if (contains(hz, "XXL"))
1488
+
                                    then dropRight(hz, 3)
1489
+
                                    else if (contains(hz, "XL"))
1490
+
                                        then dropRight(hz, 2)
1491
+
                                        else dropRight(hz, 1)
1490
1492
 
                                if (!(isDefined(parseInt(cp))))
1491
-
                                    then throw(("Cannot parse land number from " + fX.name))
1493
+
                                    then throw(("Cannot parse land number from " + fY.name))
1492
1494
 
                                    else {
1493
1495
 
                                        let ay = toBase58String(ao)
1494
-
                                        let fY = aq(ay)
1495
-
                                        if (isDefined(getInteger(fY)))
1496
-
                                            then throw((("NFT " + fX.name) + " is already staked"))
1496
+
                                        let fZ = aq(ay)
1497
+
                                        if (isDefined(getInteger(fZ)))
1498
+
                                            then throw((("NFT " + fY.name) + " is already staked"))
1497
1499
 
                                            else {
1498
-
                                                let gb = split(fX.description, "_")
1499
-
                                                let do = du(gb[bL])
1500
-
                                                let fM = bU(gb[bK])
1501
-
                                                let cP = dt(do, (fM / bl), 1)
1502
-
                                                let fN = valueOrElse(getInteger(as(K, ay)), 0)
1503
-
                                                let hg = bO(br)
1504
-
                                                let hh = getString(hg)
1505
-
                                                let hc = if (isDefined(hh))
1506
-
                                                    then split_51C(value(hh), "_")
1500
+
                                                let gc = split(fY.description, "_")
1501
+
                                                let dp = dv(gc[bL])
1502
+
                                                let fN = bU(gc[bK])
1503
+
                                                let cQ = du(dp, (fN / bl), 1)
1504
+
                                                let fO = valueOrElse(getInteger(as(K, ay)), 0)
1505
+
                                                let hh = bO(br)
1506
+
                                                let hi = getString(hh)
1507
+
                                                let hd = if (isDefined(hi))
1508
+
                                                    then split_51C(value(hi), "_")
1507
1509
 
                                                    else nil
1508
-
                                                if (containsElement(hc, ay))
1510
+
                                                if (containsElement(hd, ay))
1509
1511
 
                                                    then throw(("Your staked lands already contain " + ay))
1510
1512
 
                                                    else {
1511
-
                                                        let ew = valueOrElse(getInteger(ar(ay)), 0)
1512
-
                                                        let hl = az(br)
1513
-
                                                        let hz = valueOrElse(getInteger(hl), 0)
1514
-
                                                        let hA = bS(invoke(bI, "onStakeLand", [br], nil))
1515
-
                                                        $Tuple2([IntegerEntry(fY, lastBlock.timestamp), IntegerEntry(au(I, ay, br), lastBlock.timestamp), StringEntry(hg, makeString_11C((hc :+ ay), "_")), IntegerEntry(hl, (hz + fM)), StringEntry(an(ay), br), StringEntry(cu(cp), br), IntegerEntry(ct(K, ay, br), fN), IntegerEntry(cs(ay, br), ew), StringEntry(bN(), cP), hw], hA)
1513
+
                                                        let ex = valueOrElse(getInteger(ar(ay)), 0)
1514
+
                                                        let hm = az(br)
1515
+
                                                        let hA = valueOrElse(getInteger(hm), 0)
1516
+
                                                        let hB = bS(invoke(bI, "onStakeLand", [br], nil))
1517
+
                                                        $Tuple2([IntegerEntry(fZ, lastBlock.timestamp), IntegerEntry(au(I, ay, br), lastBlock.timestamp), StringEntry(hh, makeString_11C((hd :+ ay), "_")), IntegerEntry(hm, (hA + fN)), StringEntry(an(ay), br), StringEntry(cu(cp), br), IntegerEntry(ct(K, ay, br), fO), IntegerEntry(cs(ay, br), ex), StringEntry(bN(), cQ), hx], hB)
1516
1518
 
                                                        }
1517
1519
 
                                                }
1518
1520
 
                                        }
1523
1525
 
1524
1526
 
1525
1527
 
1526
-
@Callable(ds)
1527
-
func unstakeLand (fS) = {
1528
-
    let hw = ht(ds)
1529
-
    if ((size(ds.payments) != 0))
1528
+
@Callable(dt)
1529
+
func unstakeLand (fT) = {
1530
+
    let hx = hu(dt)
1531
+
    if ((size(dt.payments) != 0))
1530
1532
 
        then throw("No payments required")
1531
1533
 
        else {
1532
-
            let p = toString(ds.caller)
1533
-
            let gd = fQ(p, cz, fS)
1534
-
            let ay = gd._2
1535
-
            let hg = bO(p)
1536
-
            let do = du(gd._3[bL])
1537
-
            let fM = bU(gd._3[bK])
1538
-
            let cP = dt(do, (fM / bl), -1)
1539
-
            let gw = gp(p, ay, fM, cz)
1540
-
            let hc = split_51C(valueOrElse(getString(hg), ""), "_")
1541
-
            let bD = indexOf(hc, ay)
1534
+
            let p = toString(dt.caller)
1535
+
            let ge = fR(p, cA, fT)
1536
+
            let ay = ge._2
1537
+
            let hh = bO(p)
1538
+
            let dp = dv(ge._3[bL])
1539
+
            let fN = bU(ge._3[bK])
1540
+
            let cQ = du(dp, (fN / bl), -1)
1541
+
            let gx = gq(p, ay, fN, cA)
1542
+
            let hd = split_51C(valueOrElse(getString(hh), ""), "_")
1543
+
            let bD = indexOf(hd, ay)
1542
1544
 
            if (!(isDefined(bD)))
1543
1545
 
                then throw(("Your staked lands don't contain " + ay))
1544
1546
 
                else {
1545
-
                    let dZ = value(blockInfoByHeight(height)).timestamp
1546
-
                    let hB = valueOrElse(getInteger(bH, aM(p)), 0)
1547
-
                    if ((hB >= dZ))
1548
-
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hB)))
1547
+
                    let ea = value(blockInfoByHeight(height)).timestamp
1548
+
                    let hC = valueOrElse(getInteger(bH, aM(p)), 0)
1549
+
                    if ((hC >= ea))
1550
+
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(hC)))
1549
1551
 
                        else {
1550
-
                            let hl = az(p)
1551
-
                            let hm = valueOrElse(getInteger(hl), 0)
1552
-
                            let hC = if ((fM > hm))
1552
+
                            let hm = az(p)
1553
+
                            let hn = valueOrElse(getInteger(hm), 0)
1554
+
                            let hD = if ((fN > hn))
1553
1555
 
                                then 0
1554
-
                                else (hm - fM)
1555
-
                            let hA = bS(invoke(bI, "onUnstakeLand", [p], nil))
1556
-
                            $Tuple2([ScriptTransfer(ds.caller, 1, fromBase58String(ay)), DeleteEntry(aq(ay)), DeleteEntry(au(I, ay, p)), StringEntry(bN(), cP), StringEntry(gw._2, makeString(gw._3, ":")), if ((size(hc) > 1))
1557
-
                                then StringEntry(hg, makeString_11C(removeByIndex(hc, value(bD)), "_"))
1558
-
                                else DeleteEntry(hg), IntegerEntry(hl, hC), hw], hA)
1556
+
                                else (hn - fN)
1557
+
                            let hB = bS(invoke(bI, "onUnstakeLand", [p], nil))
1558
+
                            $Tuple2([ScriptTransfer(dt.caller, 1, fromBase58String(ay)), DeleteEntry(aq(ay)), DeleteEntry(au(I, ay, p)), StringEntry(bN(), cQ), StringEntry(gx._2, makeString(gx._3, ":")), if ((size(hd) > 1))
1559
+
                                then StringEntry(hh, makeString_11C(removeByIndex(hd, value(bD)), "_"))
1560
+
                                else DeleteEntry(hh), IntegerEntry(hm, hD), hx], hB)
1559
1561
 
                            }
1560
1562
 
                    }
1561
1563
 
            }
1563
1565
 
1564
1566
 
1565
1567
 
1566
-
@Callable(ds)
1568
+
@Callable(dt)
1567
1569
 
func stakeDuck () = {
1568
-
    let hw = ht(ds)
1569
-
    if ((size(ds.payments) != 1))
1570
+
    let hx = hu(dt)
1571
+
    if ((size(dt.payments) != 1))
1570
1572
 
        then throw("Exactly one payment required")
1571
1573
 
        else {
1572
-
            let hx = value(ds.payments[0])
1573
-
            let ao = value(hx.assetId)
1574
-
            let br = toString(ds.caller)
1575
-
            if ((hx.amount != 1))
1574
+
            let hy = value(dt.payments[0])
1575
+
            let ao = value(hy.assetId)
1576
+
            let br = toString(dt.caller)
1577
+
            if ((hy.amount != 1))
1576
1578
 
                then throw((("NFT " + J) + " token should be attached as payment"))
1577
1579
 
                else {
1578
-
                    let fX = value(assetInfo(ao))
1579
-
                    if (if ((fX.issuer != bW))
1580
-
                        then (fX.issuer != bX)
1580
+
                    let fY = value(assetInfo(ao))
1581
+
                    if (if ((fY.issuer != bW))
1582
+
                        then (fY.issuer != bX)
1581
1583
 
                        else false)
1582
1584
 
                        then throw((("Unknown issuer of " + J) + " token"))
1583
-
                        else if (!(contains(fX.name, J)))
1585
+
                        else if (!(contains(fY.name, J)))
1584
1586
 
                            then throw((("Only NFT " + J) + " tokens are accepted"))
1585
1587
 
                            else {
1586
-
                                let hD = toBase58String(ao)
1587
-
                                let fY = aq(hD)
1588
-
                                if (isDefined(getInteger(fY)))
1589
-
                                    then throw((("NFT " + fX.name) + " is already staked"))
1588
+
                                let hE = toBase58String(ao)
1589
+
                                let fZ = aq(hE)
1590
+
                                if (isDefined(getInteger(fZ)))
1591
+
                                    then throw((("NFT " + fY.name) + " is already staked"))
1590
1592
 
                                    else if (isDefined(getString(aH(br))))
1591
-
                                        then throw(("You already staked one duck: " + fX.name))
1593
+
                                        then throw(("You already staked one duck: " + fY.name))
1592
1594
 
                                        else {
1593
-
                                            let hE = aJ(hD)
1594
-
                                            let hF = getString(hE)
1595
-
                                            let eb = aI(hD)
1596
-
                                            let hG = getString(eb)
1597
-
                                            ([IntegerEntry(fY, lastBlock.timestamp), IntegerEntry(au(J, toBase58String(ao), br), lastBlock.timestamp), StringEntry(aG(hD), br), StringEntry(aH(br), hD)] ++ (if (isDefined(hF))
1595
+
                                            let hF = aJ(hE)
1596
+
                                            let hG = getString(hF)
1597
+
                                            let ec = aI(hE)
1598
+
                                            let hH = getString(ec)
1599
+
                                            ([IntegerEntry(fZ, lastBlock.timestamp), IntegerEntry(au(J, toBase58String(ao), br), lastBlock.timestamp), StringEntry(aG(hE), br), StringEntry(aH(br), hE)] ++ (if (isDefined(hG))
1598
1600
 
                                                then nil
1599
-
                                                else ([StringEntry(hE, P)] ++ (if (isDefined(hG))
1601
+
                                                else ([StringEntry(hF, P)] ++ (if (isDefined(hH))
1600
1602
 
                                                    then nil
1601
-
                                                    else (([StringEntry(eb, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aK(hD), 100)) :+ hw)))))
1603
+
                                                    else (([StringEntry(ec, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(aK(hE), 100)) :+ hx)))))
1602
1604
 
                                            }
1603
1605
 
                                }
1604
1606
 
                    }
1607
1609
 
1608
1610
 
1609
1611
 
1610
-
@Callable(ds)
1611
-
func unstakeDuck (hD) = {
1612
-
    let hw = ht(ds)
1613
-
    if ((size(ds.payments) != 0))
1612
+
@Callable(dt)
1613
+
func unstakeDuck (hE) = {
1614
+
    let hx = hu(dt)
1615
+
    if ((size(dt.payments) != 0))
1614
1616
 
        then throw("No payments required")
1615
1617
 
        else {
1616
-
            let ao = fromBase58String(hD)
1617
-
            let br = toString(ds.caller)
1618
-
            let fX = value(assetInfo(ao))
1619
-
            let fY = aq(toBase58String(ao))
1620
-
            if (!(isDefined(getInteger(fY))))
1621
-
                then throw((("NFT " + fX.name) + " is not staked"))
1618
+
            let ao = fromBase58String(hE)
1619
+
            let br = toString(dt.caller)
1620
+
            let fY = value(assetInfo(ao))
1621
+
            let fZ = aq(toBase58String(ao))
1622
+
            if (!(isDefined(getInteger(fZ))))
1623
+
                then throw((("NFT " + fY.name) + " is not staked"))
1622
1624
 
                else if (!(isDefined(getString(aH(br)))))
1623
-
                    then throw((("The duck " + fX.name) + " is not staked"))
1625
+
                    then throw((("The duck " + fY.name) + " is not staked"))
1624
1626
 
                    else {
1625
-
                        let ga = valueOrErrorMessage(getString(aG(toBase58String(ao))), (("NFT " + fX.name) + " is orphaned"))
1626
-
                        if ((ga != br))
1627
+
                        let gb = valueOrErrorMessage(getString(aG(toBase58String(ao))), (("NFT " + fY.name) + " is orphaned"))
1628
+
                        if ((gb != br))
1627
1629
 
                            then throw("Staked NFT is not yours")
1628
1630
 
                            else {
1629
-
                                let fC = aK(hD)
1630
-
                                let hH = valueOrElse(getInteger(fC), 100)
1631
-
                                if ((100 > hH))
1631
+
                                let fD = aK(hE)
1632
+
                                let hI = valueOrElse(getInteger(fD), 100)
1633
+
                                if ((100 > hI))
1632
1634
 
                                    then throw("Please heal your duck before unstaking")
1633
-
                                    else [ScriptTransfer(ds.caller, 1, ao), DeleteEntry(fY), DeleteEntry(fC), DeleteEntry(aJ(hD)), DeleteEntry(aG(hD)), DeleteEntry(au(J, hD, br)), DeleteEntry(aH(br)), hw]
1635
+
                                    else [ScriptTransfer(dt.caller, 1, ao), DeleteEntry(fZ), DeleteEntry(fD), DeleteEntry(aJ(hE)), DeleteEntry(aG(hE)), DeleteEntry(au(J, hE, br)), DeleteEntry(aH(br)), hx]
1634
1636
 
                                }
1635
1637
 
                        }
1636
1638
 
            }
1638
1640
 
1639
1641
 
1640
1642
 
1641
-
@Callable(ds)
1642
-
func claimRes (eJ,hI) = {
1643
-
    let hw = ht(ds)
1644
-
    if ((size(ds.payments) != 0))
1643
+
@Callable(dt)
1644
+
func claimRes (eK,hJ) = {
1645
+
    let hx = hu(dt)
1646
+
    if ((size(dt.payments) != 0))
1645
1647
 
        then throw("No payments required")
1646
1648
 
        else {
1647
-
            let p = toString(ds.originCaller)
1648
-
            let cX = gc(p, eJ, cz, hI)
1649
+
            let p = toString(dt.originCaller)
1650
+
            let cY = gd(p, eK, cA, hJ)
1649
1651
 
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1650
-
            $Tuple2(((((cX._1 ++ gC(k, fraction(s, eJ, bk))._1) :+ StringEntry(cX._2, makeString(cX._3, ":"))) :+ StringEntry(cX._4, makeString(cX._5, ":"))) :+ hw), cX._3[ah])
1651
-
            }
1652
-
    }
1653
-
1654
-
1655
-
1656
-
@Callable(ds)
1657
-
func claimResToWH (eJ,hI) = {
1658
-
    let hw = ht(ds)
1659
-
    if ((size(ds.payments) != 0))
1652
+
            $Tuple2(((((cY._1 ++ gD(k, fraction(s, eK, bk))._1) :+ StringEntry(cY._2, makeString(cY._3, ":"))) :+ StringEntry(cY._4, makeString(cY._5, ":"))) :+ hx), cY._3[ah])
1653
+
            }
1654
+
    }
1655
+
1656
+
1657
+
1658
+
@Callable(dt)
1659
+
func claimResToWH (eK,hJ) = {
1660
+
    let hx = hu(dt)
1661
+
    if ((size(dt.payments) != 0))
1660
1662
 
        then throw("No payments required")
1661
1663
 
        else {
1662
-
            let p = toString(ds.originCaller)
1663
-
            let cX = gc(p, eJ, cy, hI)
1664
-
            $Tuple2(((((cX._1 ++ gI(p, fraction(s, eJ, bk))._1) :+ StringEntry(cX._2, makeString(cX._3, ":"))) :+ StringEntry(cX._4, makeString(cX._5, ":"))) :+ hw), cX._5[Y])
1665
-
            }
1666
-
    }
1667
-
1668
-
1669
-
1670
-
@Callable(ds)
1671
-
func flight (fr,fs) = {
1672
-
    let hw = ht(ds)
1673
-
    if ((size(ds.payments) != 0))
1664
+
            let p = toString(dt.originCaller)
1665
+
            let cY = gd(p, eK, cz, hJ)
1666
+
            $Tuple2(((((cY._1 ++ gJ(p, fraction(s, eK, bk))._1) :+ StringEntry(cY._2, makeString(cY._3, ":"))) :+ StringEntry(cY._4, makeString(cY._5, ":"))) :+ hx), cY._5[Y])
1667
+
            }
1668
+
    }
1669
+
1670
+
1671
+
1672
+
@Callable(dt)
1673
+
func flight (fs,ft) = {
1674
+
    let hx = hu(dt)
1675
+
    if ((size(dt.payments) != 0))
1674
1676
 
        then throw("No payments required")
1675
1677
 
        else {
1676
-
            let aN = toString(ds.caller)
1677
-
            let dX = fq(aN, fr, fs)
1678
-
            let k = dX._2
1679
-
            let hE = aJ(k)
1680
-
            let fU = valueOrElse(getString(hE), P)
1681
-
            if ((dX._4 == fU))
1678
+
            let aN = toString(dt.caller)
1679
+
            let dY = fr(aN, fs, ft)
1680
+
            let k = dY._2
1681
+
            let hF = aJ(k)
1682
+
            let fV = valueOrElse(getString(hF), P)
1683
+
            if ((dY._4 == fV))
1682
1684
 
                then throw("You can't fly to the same location")
1683
1685
 
                else {
1684
-
                    let eb = aI(k)
1685
-
                    let eM = ea(eb)
1686
-
                    let dl = cY(eM[aj], dX._5)
1687
-
                    $Tuple2(([StringEntry(hE, if ((dX._1 > 0))
1688
-
                        then dX._4
1689
-
                        else fU), StringEntry(eb, makeString([eM[ag], eM[ah], eM[ai], dl], ":")), IntegerEntry(aK(k), dX._1), hw] ++ gC(k, if ((dX._1 > 0))
1686
+
                    let ec = aI(k)
1687
+
                    let eN = eb(ec)
1688
+
                    let dm = cZ(eN[aj], dY._5)
1689
+
                    $Tuple2(([StringEntry(hF, if ((dY._1 > 0))
1690
+
                        then dY._4
1691
+
                        else fV), StringEntry(ec, makeString([eN[ag], eN[ah], eN[ai], dm], ":")), IntegerEntry(aK(k), dY._1), hx] ++ gD(k, if ((dY._1 > 0))
1690
1692
 
                        then t
1691
-
                        else u)._1), dX._3)
1693
+
                        else u)._1), dY._3)
1692
1694
 
                    }
1693
1695
 
            }
1694
1696
 
    }
1695
1697
 
1696
1698
 
1697
1699
 
1698
-
@Callable(ds)
1699
-
func heal (hJ,hK,hL) = {
1700
-
    let hw = ht(ds)
1701
-
    if (if (if ((0 > hJ))
1702
-
        then true
1703
-
        else (0 > hK))
1700
+
@Callable(dt)
1701
+
func heal (hK,hL,hM) = {
1702
+
    let hx = hu(dt)
1703
+
    if (if (if ((0 > hK))
1704
1704
 
        then true
1705
1705
 
        else (0 > hL))
1706
+
        then true
1707
+
        else (0 > hM))
1706
1708
 
        then throw("Quantity cannot be negative")
1707
1709
 
        else {
1708
-
            let k = valueOrErrorMessage(getString(aH(toString(ds.caller))), "You don't have a duck staked")
1709
-
            let hM = [hJ, hK, hL]
1710
-
            let fC = aK(k)
1711
-
            let hN = valueOrElse(getInteger(fC), 100)
1712
-
            if ((hN >= S))
1710
+
            let k = valueOrErrorMessage(getString(aH(toString(dt.caller))), "You don't have a duck staked")
1711
+
            let hN = [hK, hL, hM]
1712
+
            let fD = aK(k)
1713
+
            let hO = valueOrElse(getInteger(fD), 100)
1714
+
            if ((hO >= S))
1713
1715
 
                then throw((("HP should be < " + toString(S)) + " to heal"))
1714
1716
 
                else {
1715
-
                    let eb = aI(k)
1716
-
                    let eM = ea(eb)
1717
-
                    let hO = if ((eM[aj] == ""))
1717
+
                    let ec = aI(k)
1718
+
                    let eN = eb(ec)
1719
+
                    let hP = if ((eN[aj] == ""))
1718
1720
 
                        then nil
1719
-
                        else split(eM[aj], "_")
1720
-
                    func hP (cM,hQ) =                     {
1721
-
                        let bT = cM._2
1722
-
                        let dO = if ((size(hO) > bT))
1723
-
                            then parseIntValue(hO[bT])
1721
+
                        else split(eN[aj], "_")
1722
+
                    func hQ (cN,hR) =                     {
1723
+
                        let bT = cN._2
1724
+
                        let dP = if ((size(hP) > bT))
1725
+
                            then parseIntValue(hP[bT])
1724
1726
 
                            else 0
1725
1727
 
                        if ((3 > bT))
1726
1728
 
                            then {
1727
-
                                let hR = hM[bT]
1728
-
                                if ((hR > dO))
1729
-
                                    then throw(((("You have only " + toString(dO)) + " of ") + T[bT]))
1730
-
                                    else $Tuple3((cM._1 :+ toString((dO - hR))), (bT + 1), (cM._3 + (bZ[bT] * hR)))
1729
+
                                let hS = hN[bT]
1730
+
                                if ((hS > dP))
1731
+
                                    then throw(((("You have only " + toString(dP)) + " of ") + T[bT]))
1732
+
                                    else $Tuple3((cN._1 :+ toString((dP - hS))), (bT + 1), (cN._3 + (bZ[bT] * hS)))
1731
1733
 
                                }
1732
-
                            else $Tuple3((cM._1 :+ toString(dO)), (bT + 1), cM._3)
1734
+
                            else $Tuple3((cN._1 :+ toString(dP)), (bT + 1), cN._3)
1733
1735
 
                        }
1734
1736
 
1735
-
                    let cX = {
1737
+
                    let cY = {
1736
1738
 
                        let aW = V
1737
1739
 
                        let aX = size(aW)
1738
1740
 
                        let aY = $Tuple3(nil, 0, 0)
1739
1741
 
                        func aZ (ba,bb) =                         if ((bb >= aX))
1740
1742
 
                            then ba
1741
-
                            else hP(ba, aW[bb])
1743
+
                            else hQ(ba, aW[bb])
1742
1744
 
1743
1745
 
                        func bc (ba,bb) =                         if ((bb >= aX))
1744
1746
 
                            then ba
1746
1748
 
1747
1749
 
                        bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
1748
1750
 
                        }
1749
-
                    let hS = min([S, (hN + cX._3)])
1750
-
                    $Tuple2(([IntegerEntry(fC, hS), StringEntry(eb, makeString_2C([eM[ag], eM[ah], eM[ai], makeString(cX._1, "_")], ":")), hw] ++ gC(k, (B * ((hJ + hK) + hL)))._1), hS)
1751
+
                    let hT = min([S, (hO + cY._3)])
1752
+
                    $Tuple2(([IntegerEntry(fD, hT), StringEntry(ec, makeString_2C([eN[ag], eN[ah], eN[ai], makeString(cY._1, "_")], ":")), hx] ++ gD(k, (B * ((hK + hL) + hM)))._1), hT)
1751
1753
 
                    }
1752
1754
 
            }
1753
1755
 
    }
1754
1756
 
1755
1757
 
1756
1758
 
1757
-
@Callable(ds)
1759
+
@Callable(dt)
1758
1760
 
func healES () = {
1759
-
    let hw = ht(ds)
1760
-
    if ((size(ds.payments) != 1))
1761
+
    let hx = hu(dt)
1762
+
    if ((size(dt.payments) != 1))
1761
1763
 
        then throw("Exactly one payment required")
1762
1764
 
        else {
1763
-
            let hx = value(ds.payments[0])
1764
-
            if ((hx.assetId != be))
1765
+
            let hy = value(dt.payments[0])
1766
+
            if ((hy.assetId != be))
1765
1767
 
                then throw("Allowed USDT payment only!")
1766
1768
 
                else {
1767
-
                    let k = valueOrErrorMessage(getString(aH(toString(ds.caller))), "You don't have a duck staked")
1768
-
                    let fC = aK(k)
1769
-
                    let hN = valueOrElse(getInteger(fC), 100)
1770
-
                    if ((hN > 0))
1769
+
                    let k = valueOrErrorMessage(getString(aH(toString(dt.caller))), "You don't have a duck staked")
1770
+
                    let fD = aK(k)
1771
+
                    let hO = valueOrElse(getInteger(fD), 100)
1772
+
                    if ((hO > 0))
1771
1773
 
                        then throw("HP should be 0 to call Emergency Service")
1772
1774
 
                        else {
1773
-
                            let eb = aI(k)
1774
-
                            let eM = ea(eb)
1775
-
                            let hO = if ((eM[aj] == ""))
1775
+
                            let ec = aI(k)
1776
+
                            let eN = eb(ec)
1777
+
                            let hP = if ((eN[aj] == ""))
1776
1778
 
                                then nil
1777
-
                                else split(eM[aj], "_")
1778
-
                            let hT = if ((size(hO) > 0))
1779
-
                                then parseIntValue(hO[0])
1779
+
                                else split(eN[aj], "_")
1780
+
                            let hU = if ((size(hP) > 0))
1781
+
                                then parseIntValue(hP[0])
1780
1782
 
                                else 0
1781
-
                            let hU = if ((size(hO) > 1))
1782
-
                                then parseIntValue(hO[1])
1783
+
                            let hV = if ((size(hP) > 1))
1784
+
                                then parseIntValue(hP[1])
1783
1785
 
                                else 0
1784
-
                            let hV = if ((size(hO) > 2))
1785
-
                                then parseIntValue(hO[2])
1786
+
                            let hW = if ((size(hP) > 2))
1787
+
                                then parseIntValue(hP[2])
1786
1788
 
                                else 0
1787
-
                            if (if (if ((hT > 0))
1788
-
                                then true
1789
-
                                else (hU > 0))
1789
+
                            if (if (if ((hU > 0))
1790
1790
 
                                then true
1791
1791
 
                                else (hV > 0))
1792
+
                                then true
1793
+
                                else (hW > 0))
1792
1794
 
                                then throw("You have to use own Medical Kit")
1793
1795
 
                                else {
1794
-
                                    let hW = getString(bG, aO())
1795
-
                                    let hX = if (isDefined(hW))
1796
-
                                        then split(value(hW), "_")
1796
+
                                    let hX = getString(bG, aO())
1797
+
                                    let hY = if (isDefined(hX))
1798
+
                                        then split(value(hX), "_")
1797
1799
 
                                        else nil
1798
-
                                    let hY = if ((size(hX) > 0))
1799
-
                                        then parseIntValue(hX[0])
1800
+
                                    let hZ = if ((size(hY) > 0))
1801
+
                                        then parseIntValue(hY[0])
1800
1802
 
                                        else 0
1801
-
                                    if ((0 >= hY))
1803
+
                                    if ((0 >= hZ))
1802
1804
 
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1803
1805
 
                                        else {
1804
-
                                            let hS = (hN + bZ[0])
1805
-
                                            let hZ = makeString([toString((hY - 1)), removeByIndex(hX, 0)], "_")
1806
+
                                            let hT = (hO + bZ[0])
1807
+
                                            let ia = makeString([toString((hZ - 1)), removeByIndex(hY, 0)], "_")
1806
1808
 
                                            let aS = split(V[0], "_")
1807
-
                                            let ia = aR(aS)
1808
-
                                            let ib = parseIntValue(aS[W])
1809
-
                                            let ic = fraction((ia * R), Q, (10 * ib))
1810
-
                                            if ((hx.amount != ic))
1811
-
                                                then throw(("Payment attached should be " + toString(ic)))
1809
+
                                            let ib = aR(aS)
1810
+
                                            let ic = parseIntValue(aS[W])
1811
+
                                            let id = fraction((ib * R), Q, (10 * ic))
1812
+
                                            if ((hy.amount != id))
1813
+
                                                then throw(("Payment attached should be " + toString(id)))
1812
1814
 
                                                else {
1813
-
                                                    let cX = bP(invoke(bG, "updateEsStorage", [hZ], [AttachedPayment(be, ic)]))
1814
-
                                                    $Tuple2(([IntegerEntry(fC, hS), hw] ++ gC(k, v)._1), cX)
1815
+
                                                    let cY = bP(invoke(bG, "updateEsStorage", [ia], [AttachedPayment(be, id)]))
1816
+
                                                    $Tuple2(([IntegerEntry(fD, hT), hx] ++ gD(k, v)._1), cY)
1815
1817
 
                                                    }
1816
1818
 
                                            }
1817
1819
 
                                    }
1822
1824
 
1823
1825
 
1824
1826
 
1825
-
@Callable(ds)
1826
-
func updateBackpack (k,id) = if ((ds.caller != bG))
1827
+
@Callable(dt)
1828
+
func updateBackpack (k,ie) = if ((dt.caller != bG))
1827
1829
 
    then throw("permission denied")
1828
-
    else $Tuple2([StringEntry(aI(k), id)], id)
1829
-
1830
-
1831
-
1832
-
@Callable(ds)
1830
+
    else $Tuple2([StringEntry(aI(k), ie)], ie)
1831
+
1832
+
1833
+
1834
+
@Callable(dt)
1833
1835
 
func buySLand () = {
1834
-
    let hw = ht(ds)
1835
-
    if ((size(ds.payments) != 1))
1836
+
    let hx = hu(dt)
1837
+
    if ((size(dt.payments) != 1))
1836
1838
 
        then throw("Exactly one payment required")
1837
1839
 
        else {
1838
-
            let hx = value(ds.payments[0])
1839
-
            if ((hx.assetId != be))
1840
+
            let hy = value(dt.payments[0])
1841
+
            if ((hy.assetId != be))
1840
1842
 
                then throw("Allowed USDT payment only!")
1841
-
                else if ((hx.amount != cf))
1843
+
                else if ((hy.amount != cf))
1842
1844
 
                    then throw(("Payment attached should be " + toString(cf)))
1843
1845
 
                    else {
1844
-
                        let cX = fi(ds.caller, ds.transactionId)
1845
-
                        $Tuple2((((cX._1 :+ ScriptTransfer(bG, hx.amount, be)) ++ gI(toString(ds.caller), x)._1) :+ hw), cX._2._1)
1846
+
                        let cY = fj(dt.caller, dt.transactionId)
1847
+
                        $Tuple2((((cY._1 :+ ScriptTransfer(bG, hy.amount, be)) ++ gJ(toString(dt.caller), x)._1) :+ hx), cY._2._1)
1846
1848
 
                        }
1847
1849
 
            }
1848
1850
 
    }
1849
1851
 
1850
1852
 
1851
1853
 
1852
-
@Callable(ds)
1853
-
func expedition (fr,fs) = {
1854
-
    let hw = ht(ds)
1855
-
    if ((size(ds.payments) != 0))
1854
+
@Callable(dt)
1855
+
func expedition (fs,ft) = {
1856
+
    let hx = hu(dt)
1857
+
    if ((size(dt.payments) != 0))
1856
1858
 
        then throw("No payments required")
1857
1859
 
        else {
1858
-
            let cX = fH(ds.caller, ds.transactionId, fr, fs)
1859
-
            let k = valueOrErrorMessage(getString(aH(toString(ds.caller))), "You don't have a duck staked")
1860
-
            $Tuple2(((cX._1 ++ gC(k, x)._1) :+ hw), $Tuple2(cX._2, cX._3))
1861
-
            }
1862
-
    }
1863
-
1864
-
1865
-
1866
-
@Callable(ds)
1860
+
            let cY = fI(dt.caller, dt.transactionId, fs, ft)
1861
+
            let k = valueOrErrorMessage(getString(aH(toString(dt.caller))), "You don't have a duck staked")
1862
+
            $Tuple2(((cY._1 ++ gD(k, x)._1) :+ hx), $Tuple2(cY._2, cY._3))
1863
+
            }
1864
+
    }
1865
+
1866
+
1867
+
1868
+
@Callable(dt)
1867
1869
 
func upgradeInfra (ay) = {
1868
-
    let hw = ht(ds)
1869
-
    if ((size(ds.payments) != 0))
1870
+
    let hx = hu(dt)
1871
+
    if ((size(dt.payments) != 0))
1870
1872
 
        then throw("No payments required")
1871
1873
 
        else {
1872
-
            let cX = gq(true, ds.caller, 0, ay)
1873
-
            let k = valueOrErrorMessage(getString(aH(toString(ds.caller))), "You don't have a duck staked")
1874
-
            $Tuple2(((cX._1 :+ hw) ++ gC(k, fraction(y, cX._3, bk))._1), cX._2)
1875
-
            }
1876
-
    }
1877
-
1878
-
1879
-
1880
-
@Callable(ds)
1881
-
func upgradeInfraUsdt (ay) = if ((ds.caller != this))
1874
+
            let cY = gr(true, dt.caller, 0, ay)
1875
+
            let k = valueOrErrorMessage(getString(aH(toString(dt.caller))), "You don't have a duck staked")
1876
+
            $Tuple2(((cY._1 :+ hx) ++ gD(k, fraction(y, cY._3, bk))._1), cY._2)
1877
+
            }
1878
+
    }
1879
+
1880
+
1881
+
1882
+
@Callable(dt)
1883
+
func upgradeInfraUsdt (ay) = if ((dt.caller != this))
1882
1884
 
    then throw("Permission denied")
1883
1885
 
    else {
1884
-
        let hw = ht(ds)
1885
-
        if ((size(ds.payments) != 1))
1886
+
        let hx = hu(dt)
1887
+
        if ((size(dt.payments) != 1))
1886
1888
 
            then throw("Exactly one payment required")
1887
1889
 
            else {
1888
-
                let hx = value(ds.payments[0])
1889
-
                if ((hx.assetId != be))
1890
+
                let hy = value(dt.payments[0])
1891
+
                if ((hy.assetId != be))
1890
1892
 
                    then throw("Allowed USDT payment only!")
1891
1893
 
                    else {
1892
-
                        let cX = gq(false, ds.caller, hx.amount, ay)
1893
-
                        $Tuple2(((cX._1 :+ ScriptTransfer(bG, hx.amount, be)) :+ hw), cX._2)
1894
+
                        let cY = gr(false, dt.caller, hy.amount, ay)
1895
+
                        $Tuple2(((cY._1 :+ ScriptTransfer(bG, hy.amount, be)) :+ hx), cY._2)
1894
1896
 
                        }
1895
1897
 
                }
1896
1898
 
        }
1897
1899
 
1898
1900
 
1899
1901
 
1900
-
@Callable(ds)
1901
-
func activateArtifact (ie,if) = {
1902
-
    let hw = ht(ds)
1903
-
    if ((size(ds.payments) != 0))
1902
+
@Callable(dt)
1903
+
func activateArtifact (if,ig) = {
1904
+
    let hx = hu(dt)
1905
+
    if ((size(dt.payments) != 0))
1904
1906
 
        then throw("No payments required")
1905
1907
 
        else {
1906
-
            let p = toString(ds.caller)
1907
-
            let cX = {
1908
-
                let bf = ie
1908
+
            let p = toString(dt.caller)
1909
+
            let cY = {
1910
+
                let bf = if
1909
1911
 
                if (("PRESALE" == bf))
1910
-
                    then gQ(p, if)
1912
+
                    then gR(p, ig)
1911
1913
 
                    else if (("ONBOARD" == bf))
1912
-
                        then gJ(p)
1914
+
                        then gK(p)
1913
1915
 
                        else throw("Unknown artifact")
1914
1916
 
                }
1915
-
            (cX :+ hw)
1916
-
            }
1917
-
    }
1918
-
1919
-
1920
-
1921
-
@Callable(ds)
1922
-
func mergeLands (gV) = {
1923
-
    let hw = ht(ds)
1924
-
    if ((size(ds.payments) != 0))
1917
+
            (cY :+ hx)
1918
+
            }
1919
+
    }
1920
+
1921
+
1922
+
1923
+
@Callable(dt)
1924
+
func mergeLands (gW) = {
1925
+
    let hx = hu(dt)
1926
+
    if ((size(dt.payments) != 0))
1925
1927
 
        then throw("No payments required")
1926
1928
 
        else {
1927
-
            let cX = hr(true, toString(ds.caller), 0, gV, ds.transactionId)
1928
-
            $Tuple2(((cX._1 :+ hw) ++ gI(toString(ds.caller), z)._1), cX._2)
1929
-
            }
1930
-
    }
1931
-
1932
-
1933
-
1934
-
@Callable(ds)
1935
-
func mergeLandsUsdt (gV) = {
1936
-
    let hw = ht(ds)
1937
-
    if ((size(ds.payments) != 1))
1929
+
            let cY = hs(true, toString(dt.caller), 0, gW, dt.transactionId)
1930
+
            $Tuple2(((cY._1 :+ hx) ++ gJ(toString(dt.caller), z)._1), cY._2)
1931
+
            }
1932
+
    }
1933
+
1934
+
1935
+
1936
+
@Callable(dt)
1937
+
func mergeLandsUsdt (gW) = {
1938
+
    let hx = hu(dt)
1939
+
    if ((size(dt.payments) != 1))
1938
1940
 
        then throw("Exactly one payment required")
1939
1941
 
        else {
1940
-
            let hx = value(ds.payments[0])
1941
-
            if ((hx.assetId != be))
1942
+
            let hy = value(dt.payments[0])
1943
+
            if ((hy.assetId != be))
1942
1944
 
                then throw("Allowed USDT payment only!")
1943
1945
 
                else {
1944
-
                    let cX = hr(false, toString(ds.caller), hx.amount, gV, ds.transactionId)
1945
-
                    $Tuple2(((cX._1 :+ ScriptTransfer(bG, hx.amount, be)) :+ hw), cX._2)
1946
+
                    let cY = hs(false, toString(dt.caller), hy.amount, gW, dt.transactionId)
1947
+
                    $Tuple2(((cY._1 :+ ScriptTransfer(bG, hy.amount, be)) :+ hx), cY._2)
1946
1948
 
                    }
1947
1949
 
            }
1948
1950
 
    }
1949
1951
 
1950
1952
 
1951
1953
 
1952
-
@Callable(ds)
1953
-
func cargoExchange (ig,ay) = {
1954
-
    let hw = ht(ds)
1955
-
    if ((size(ds.payments) != 0))
1954
+
@Callable(dt)
1955
+
func cargoExchange (ih,ay) = {
1956
+
    let hx = hu(dt)
1957
+
    if ((size(dt.payments) != 0))
1956
1958
 
        then throw("No payments required")
1957
1959
 
        else {
1958
-
            let eL = split_4C(ig, ":")
1959
-
            let p = toString(ds.originCaller)
1960
-
            let fX = value(assetInfo(fromBase58String(ay)))
1961
-
            let fY = aq(ay)
1962
-
            if (!(isDefined(getInteger(fY))))
1963
-
                then throw((fX.name + " is not staked"))
1960
+
            let eM = split_4C(ih, ":")
1961
+
            let p = toString(dt.originCaller)
1962
+
            let fY = value(assetInfo(fromBase58String(ay)))
1963
+
            let fZ = aq(ay)
1964
+
            if (!(isDefined(getInteger(fZ))))
1965
+
                then throw((fY.name + " is not staked"))
1964
1966
 
                else {
1965
-
                    let ga = valueOrErrorMessage(getString(an(ay)), (("NFT " + fX.name) + " is orphaned"))
1966
-
                    if ((ga != p))
1967
+
                    let gb = valueOrErrorMessage(getString(an(ay)), (("NFT " + fY.name) + " is orphaned"))
1968
+
                    if ((gb != p))
1967
1969
 
                        then throw((I + " is not yours"))
1968
1970
 
                        else {
1969
-
                            let ev = (bU(split(fX.description, "_")[bK]) / bl)
1970
-
                            let ew = valueOrElse(getInteger(ar(ay)), 0)
1971
+
                            let ew = (bU(split(fY.description, "_")[bK]) / bl)
1972
+
                            let ex = valueOrElse(getInteger(ar(ay)), 0)
1971
1973
 
                            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
1972
-
                            let fU = valueOrElse(getString(aJ(k)), P)
1973
-
                            let fV = split(value(fU), "_")
1974
-
                            if ((fV[aP] != "L"))
1975
-
                                then throw((("Duck location type is " + fV[aP]) + ", but should be L"))
1976
-
                                else if ((fV[aQ] != ay))
1974
+
                            let fV = valueOrElse(getString(aJ(k)), P)
1975
+
                            let fW = split(value(fV), "_")
1976
+
                            if ((fW[aP] != "L"))
1977
+
                                then throw((("Duck location type is " + fW[aP]) + ", but should be L"))
1978
+
                                else if ((fW[aQ] != ay))
1977
1979
 
                                    then throw(("Duck should be on the land " + ay))
1978
1980
 
                                    else {
1979
-
                                        let eu = ax(ay)
1980
-
                                        let eg = et(eu, ev, ew)
1981
-
                                        let eb = aI(k)
1982
-
                                        let eM = ea(eb)
1983
-
                                        let cX = eK(eL, eg, eM)
1984
-
                                        let eC = split(eg[ab], "_")
1985
-
                                        let gn = (parseIntValue(eC[ad]) + cX._7)
1986
-
                                        let go = (parseIntValue(eC[ae]) - cX._7)
1987
-
[StringEntry(eb, makeString_2C([eM[ag], cX._4, cX._5, cX._6], ":")), StringEntry(eu, makeString_2C([eg[X], cX._1, cX._2, cX._3, makeString([eC[ac], toString(gn), toString(go), eC[af]], "_")], ":")), hw]
1981
+
                                        let ev = ax(ay)
1982
+
                                        let eh = eu(ev, ew, ex)
1983
+
                                        let ec = aI(k)
1984
+
                                        let eN = eb(ec)
1985
+
                                        let cY = eL(eM, eh, eN)
1986
+
                                        let eD = split(eh[ab], "_")
1987
+
                                        let go = (parseIntValue(eD[ad]) + cY._7)
1988
+
                                        let gp = (parseIntValue(eD[ae]) - cY._7)
1989
+
[StringEntry(ec, makeString_2C([eN[ag], cY._4, cY._5, cY._6], ":")), StringEntry(ev, makeString_2C([eh[X], cY._1, cY._2, cY._3, makeString([eD[ac], toString(go), toString(gp), eD[af]], "_")], ":")), hx]
1988
1990
 
                                        }
1989
1991
 
                            }
1990
1992
 
                    }
1993
1995
 
1994
1996
 
1995
1997
 
1996
-
@Callable(ds)
1997
-
func saveWarehouse (ey,ay) = if ((ds.caller != bG))
1998
+
@Callable(dt)
1999
+
func saveWarehouse (ez,ay) = if ((dt.caller != bG))
1998
2000
 
    then throw("Access denied")
1999
2001
 
    else {
2000
-
        let eu = ax(ay)
2001
-
        let ez = split_4C(ey, ":")
2002
-
        if ((size(ez) != 5))
2002
+
        let ev = ax(ay)
2003
+
        let eA = split_4C(ez, ":")
2004
+
        if ((size(eA) != 5))
2003
2005
 
            then throw("warehouse string should contain 4 ':' separators")
2004
2006
 
            else {
2005
-
                let ih = split(ez[ab], "_")[ac]
2006
-
                let gn = ef(ez)
2007
-
                let ii = ed(ez[X])
2008
-
                let go = ((ii - parseIntValue(ih)) - gn)
2009
-
                let ij = makeString_2C([ez[X], ez[Y], ez[Z], ez[aa], makeString([ih, toString(gn), toString(go), toString(ii)], "_")], ":")
2010
-
                $Tuple2([StringEntry(eu, ij)], ij)
2007
+
                let ii = split(eA[ab], "_")[ac]
2008
+
                let go = eg(eA)
2009
+
                let ij = ee(eA[X])
2010
+
                let gp = ((ij - parseIntValue(ii)) - go)
2011
+
                let ik = makeString_2C([eA[X], eA[Y], eA[Z], eA[aa], makeString([ii, toString(go), toString(gp), toString(ij)], "_")], ":")
2012
+
                $Tuple2([StringEntry(ev, ik)], ik)
2011
2013
 
                }
2012
2014
 
        }
2013
2015
 
2014
2016
 
2015
2017
 
2016
-
@Callable(ds)
2017
-
func fixWarehouseFormat (ay) = if ((ds.caller != bE))
2018
+
@Callable(dt)
2019
+
func fixWarehouseFormat (ay) = if ((dt.caller != bE))
2018
2020
 
    then throw("Access denied")
2019
2021
 
    else {
2020
-
        let eu = ax(ay)
2021
-
        let fX = value(assetInfo(fromBase58String(ay)))
2022
-
        let ev = (bU(split(fX.description, "_")[bK]) / bl)
2023
-
        let ew = valueOrElse(getInteger(ar(ay)), 0)
2024
-
        let ez = et(eu, ev, ew)
2025
-
        let ih = bS(invoke(bG, "recalcLockedVolumeREADONLY", [ay, ez], nil))
2026
-
        let gn = ef(ez)
2027
-
        let ii = ed(ez[X])
2028
-
        let go = ((ii - ih) - gn)
2029
-
        let ij = makeString_2C([ez[X], ez[Y], ez[Z], ez[aa], makeString([toString(ih), toString(gn), toString(go), toString(ii)], "_")], ":")
2030
-
        $Tuple2([StringEntry(eu, ij)], ij)
2022
+
        let ev = ax(ay)
2023
+
        let fY = value(assetInfo(fromBase58String(ay)))
2024
+
        let ew = (bU(split(fY.description, "_")[bK]) / bl)
2025
+
        let ex = valueOrElse(getInteger(ar(ay)), 0)
2026
+
        let eA = eu(ev, ew, ex)
2027
+
        let ii = bS(invoke(bG, "recalcLockedVolumeREADONLY", [ay, eA], nil))
2028
+
        let go = eg(eA)
2029
+
        let ij = ee(eA[X])
2030
+
        let gp = ((ij - ii) - go)
2031
+
        let ik = makeString_2C([eA[X], eA[Y], eA[Z], eA[aa], makeString([toString(ii), toString(go), toString(gp), toString(ij)], "_")], ":")
2032
+
        $Tuple2([StringEntry(ev, ik)], ik)
2031
2033
 
        }
2032
2034
 
2033
2035
 
2034
2036
 
2035
-
@Callable(ds)
2036
-
func fixStakedPieces (br) = if ((ds.caller != bE))
2037
+
@Callable(dt)
2038
+
func fixStakedPieces (br) = if ((dt.caller != bE))
2037
2039
 
    then throw("Access denied")
2038
2040
 
    else {
2039
-
        let hm = if ((br == ""))
2041
+
        let hn = if ((br == ""))
2040
2042
 
            then 0
2041
2043
 
            else {
2042
-
                let hh = getString(bF, bO(br))
2043
-
                let hc = if (isDefined(hh))
2044
-
                    then split_51C(value(hh), "_")
2044
+
                let hi = getString(bF, bO(br))
2045
+
                let hd = if (isDefined(hi))
2046
+
                    then split_51C(value(hi), "_")
2045
2047
 
                    else nil
2046
-
                func ik (cM,ay) =                 {
2047
-
                    let fX = value(assetInfo(fromBase58String(ay)))
2048
-
                    let bV = split(fX.description, "_")[bK]
2049
-
                    (cM + bU(bV))
2048
+
                func il (cN,ay) =                 {
2049
+
                    let fY = value(assetInfo(fromBase58String(ay)))
2050
+
                    let bV = split(fY.description, "_")[bK]
2051
+
                    (cN + bU(bV))
2050
2052
 
                    }
2051
2053
 
2052
-
                let aW = hc
2054
+
                let aW = hd
2053
2055
 
                let aX = size(aW)
2054
2056
 
                let aY = 0
2055
2057
 
                func aZ (ba,bb) =                 if ((bb >= aX))
2056
2058
 
                    then ba
2057
-
                    else ik(ba, aW[bb])
2059
+
                    else il(ba, aW[bb])
2058
2060
 
2059
2061
 
                func bc (ba,bb) =                 if ((bb >= aX))
2060
2062
 
                    then ba
2062
2064
 
2063
2065
 
                bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
2064
2066
 
                }
2065
-
        $Tuple2([IntegerEntry(az(br), hm)], hm)
2067
+
        $Tuple2([IntegerEntry(az(br), hn)], hn)
2066
2068
 
        }
2067
2069
 
2068
2070
 
2069
2071
 
2070
-
@Callable(ds)
2071
-
func setCustomName (ao,he,at) = {
2072
-
    let hw = ht(ds)
2073
-
    if ((size(ds.payments) != 1))
2072
+
@Callable(dt)
2073
+
func setCustomName (ao,hf,at) = {
2074
+
    let hx = hu(dt)
2075
+
    if ((size(dt.payments) != 1))
2074
2076
 
        then throw("Exactly one payment required")
2075
2077
 
        else {
2076
-
            let hx = value(ds.payments[0])
2077
-
            if ((hx.assetId != be))
2078
+
            let hy = value(dt.payments[0])
2079
+
            if ((hy.assetId != be))
2078
2080
 
                then throw("Allowed USDT payment only!")
2079
-
                else if ((hx.amount != cb))
2081
+
                else if ((hy.amount != cb))
2080
2082
 
                    then throw(("Payment should be " + toString(cb)))
2081
-
                    else if (contains(he, "__"))
2082
-
                        then throw(("Name should not contain '__': " + he))
2083
-
                        else if ((size(he) > cc))
2083
+
                    else if (contains(hf, "__"))
2084
+
                        then throw(("Name should not contain '__': " + hf))
2085
+
                        else if ((size(hf) > cc))
2084
2086
 
                            then throw(("Name too long, maxLength=" + toString(cc)))
2085
2087
 
                            else {
2086
-
                                let p = toString(ds.originCaller)
2087
-
                                let il = {
2088
+
                                let p = toString(dt.originCaller)
2089
+
                                let im = {
2088
2090
 
                                    let bf = at
2089
2091
 
                                    if (("ACCOUNT" == bf))
2090
2092
 
                                        then {
2091
-
                                            let im = cw(he)
2092
-
                                            let in = getString(im)
2093
-
                                            if (isDefined(in))
2094
-
                                                then throw(("Name already registered: " + he))
2093
+
                                            let in = cw(hf)
2094
+
                                            let io = getString(in)
2095
+
                                            if (isDefined(io))
2096
+
                                                then throw(("Name already registered: " + hf))
2095
2097
 
                                                else {
2096
-
                                                    let io = aB(p)
2097
-
                                                    let ip = getString(io)
2098
-
                                                    let iq = if (isDefined(ip))
2099
-
                                                        then [DeleteEntry(cw(value(ip)))]
2098
+
                                                    let ip = aB(p)
2099
+
                                                    let iq = getString(ip)
2100
+
                                                    let ir = if (isDefined(iq))
2101
+
                                                        then [DeleteEntry(cw(value(iq)))]
2100
2102
 
                                                        else nil
2101
-
                                                    (((iq :+ StringEntry(io, he)) :+ StringEntry(im, p)) ++ gI(p, w)._1)
2103
+
                                                    (((ir :+ StringEntry(ip, hf)) :+ StringEntry(in, p)) ++ gJ(p, w)._1)
2102
2104
 
                                                    }
2103
2105
 
                                            }
2104
2106
 
                                        else if (("LAND" == bf))
2105
2107
 
                                            then {
2106
-
                                                let fX = value(assetInfo(fromBase58String(ao)))
2107
-
                                                let fY = aq(ao)
2108
-
                                                if (!(isDefined(getInteger(fY))))
2109
-
                                                    then throw((fX.name + " is not staked"))
2108
+
                                                let fY = value(assetInfo(fromBase58String(ao)))
2109
+
                                                let fZ = aq(ao)
2110
+
                                                if (!(isDefined(getInteger(fZ))))
2111
+
                                                    then throw((fY.name + " is not staked"))
2110
2112
 
                                                    else {
2111
-
                                                        let ga = valueOrErrorMessage(getString(an(ao)), (("NFT " + fX.name) + " is orphaned"))
2112
-
                                                        if ((ga != p))
2113
+
                                                        let gb = valueOrErrorMessage(getString(an(ao)), (("NFT " + fY.name) + " is orphaned"))
2114
+
                                                        if ((gb != p))
2113
2115
 
                                                            then throw((I + " is not yours"))
2114
2116
 
                                                            else {
2115
-
                                                                let im = cq(he)
2116
-
                                                                let in = getString(im)
2117
-
                                                                if (isDefined(in))
2118
-
                                                                    then throw(("Name already registered: " + he))
2117
+
                                                                let in = cq(hf)
2118
+
                                                                let io = getString(in)
2119
+
                                                                if (isDefined(io))
2120
+
                                                                    then throw(("Name already registered: " + hf))
2119
2121
 
                                                                    else {
2120
-
                                                                        let ir = ap(ao)
2121
-
                                                                        let ip = getString(ir)
2122
-
                                                                        let iq = if (isDefined(ip))
2123
-
                                                                            then [DeleteEntry(cq(value(ip)))]
2122
+
                                                                        let is = ap(ao)
2123
+
                                                                        let iq = getString(is)
2124
+
                                                                        let ir = if (isDefined(iq))
2125
+
                                                                            then [DeleteEntry(cq(value(iq)))]
2124
2126
 
                                                                            else nil
2125
-
                                                                        (((iq :+ StringEntry(ir, he)) :+ StringEntry(im, ao)) ++ gI(p, w)._1)
2127
+
                                                                        (((ir :+ StringEntry(is, hf)) :+ StringEntry(in, ao)) ++ gJ(p, w)._1)
2126
2128
 
                                                                        }
2127
2129
 
                                                                }
2128
2130
 
                                                        }
2129
2131
 
                                                }
2130
2132
 
                                            else if (("DUCK" == bf))
2131
2133
 
                                                then {
2132
-
                                                    let fX = value(assetInfo(fromBase58String(ao)))
2133
-
                                                    let fY = aq(ao)
2134
-
                                                    if (if (!(isDefined(getInteger(fY))))
2134
+
                                                    let fY = value(assetInfo(fromBase58String(ao)))
2135
+
                                                    let fZ = aq(ao)
2136
+
                                                    if (if (!(isDefined(getInteger(fZ))))
2135
2137
 
                                                        then true
2136
2138
 
                                                        else !(isDefined(getString(aH(p)))))
2137
-
                                                        then throw((fX.name + " is not staked"))
2139
+
                                                        then throw((fY.name + " is not staked"))
2138
2140
 
                                                        else {
2139
-
                                                            let ga = valueOrErrorMessage(getString(aG(ao)), (("NFT " + fX.name) + " is orphaned"))
2140
-
                                                            if ((ga != p))
2141
+
                                                            let gb = valueOrErrorMessage(getString(aG(ao)), (("NFT " + fY.name) + " is orphaned"))
2142
+
                                                            if ((gb != p))
2141
2143
 
                                                                then throw((J + " is not yours"))
2142
2144
 
                                                                else {
2143
-
                                                                    let im = cv(he)
2144
-
                                                                    let in = getString(im)
2145
-
                                                                    if (isDefined(in))
2146
-
                                                                        then throw(("Name already registered: " + he))
2145
+
                                                                    let in = cv(hf)
2146
+
                                                                    let io = getString(in)
2147
+
                                                                    if (isDefined(io))
2148
+
                                                                        then throw(("Name already registered: " + hf))
2147
2149
 
                                                                        else {
2148
-
                                                                            let ir = aA(ao)
2149
-
                                                                            let ip = getString(ir)
2150
-
                                                                            let iq = if (isDefined(ip))
2151
-
                                                                                then [DeleteEntry(cv(value(ip)))]
2150
+
                                                                            let is = aA(ao)
2151
+
                                                                            let iq = getString(is)
2152
+
                                                                            let ir = if (isDefined(iq))
2153
+
                                                                                then [DeleteEntry(cv(value(iq)))]
2152
2154
 
                                                                                else nil
2153
-
                                                                            (((iq :+ StringEntry(ir, he)) :+ StringEntry(im, ao)) ++ gC(ao, w)._1)
2155
+
                                                                            (((ir :+ StringEntry(is, hf)) :+ StringEntry(in, ao)) ++ gD(ao, w)._1)
2154
2156
 
                                                                            }
2155
2157
 
                                                                    }
2156
2158
 
                                                            }
2157
2159
 
                                                    }
2158
2160
 
                                                else throw("Unknown entity type")
2159
2161
 
                                    }
2160
-
                                $Tuple2(((il :+ ScriptTransfer(bG, hx.amount, be)) :+ hw), 0)
2162
+
                                $Tuple2(((im :+ ScriptTransfer(bG, hy.amount, be)) :+ hx), 0)
2161
2163
 
                                }
2162
2164
 
            }
2163
2165
 
    }
2164
2166
 
2165
2167
 
2166
2168
 
2167
-
@Callable(ds)
2168
-
func setReferrals (is,it) = if ((ds.callerPublicKey != bY))
2169
+
@Callable(dt)
2170
+
func setReferrals (it,iu) = if ((dt.callerPublicKey != bY))
2169
2171
 
    then throw("Permission denied")
2170
2172
 
    else {
2171
-
        let hw = ht(ds)
2172
-
        if ((size(ds.payments) != 0))
2173
+
        let hx = hu(dt)
2174
+
        if ((size(dt.payments) != 0))
2173
2175
 
            then throw("No payments required")
2174
-
            else if (!(isDefined(addressFromString(is))))
2175
-
                then throw(("Invalid address: " + is))
2176
-
                else if (!(isDefined(addressFromString(it))))
2177
-
                    then throw(("Invalid address: " + it))
2176
+
            else if (!(isDefined(addressFromString(it))))
2177
+
                then throw(("Invalid address: " + it))
2178
+
                else if (!(isDefined(addressFromString(iu))))
2179
+
                    then throw(("Invalid address: " + iu))
2178
2180
 
                    else {
2179
-
                        let iu = cx()
2180
-
                        let iv = getString(iu)
2181
-
                        let iw = if (isDefined(iv))
2182
-
                            then split_4C(value(iv), "_")
2181
+
                        let iv = cx()
2182
+
                        let iw = getString(iv)
2183
+
                        let ix = if (isDefined(iw))
2184
+
                            then split_4C(value(iw), "_")
2183
2185
 
                            else nil
2184
-
                        if (containsElement(iw, it))
2185
-
                            then throw((it + " is not newbie (already has referrals)"))
2186
+
                        if (containsElement(ix, iu))
2187
+
                            then throw((iu + " is not newbie (already has referrals)"))
2186
2188
 
                            else {
2187
-
                                let gK = aC(it)
2188
-
                                let gL = getString(gK)
2189
-
                                if (if (isDefined(gL))
2190
-
                                    then isDefined(addressFromString(value(gL)))
2189
+
                                let gL = aC(iu)
2190
+
                                let gM = getString(gL)
2191
+
                                if (if (isDefined(gM))
2192
+
                                    then isDefined(addressFromString(value(gM)))
2191
2193
 
                                    else false)
2192
-
                                    then throw(((it + " already has refBy: ") + value(gL)))
2194
+
                                    then throw(((iu + " already has refBy: ") + value(gM)))
2193
2195
 
                                    else {
2194
-
                                        let ix = aF(is)
2195
-
                                        let iy = getString(ix)
2196
-
                                        let iz = if (isDefined(iy))
2197
-
                                            then split_4C(value(iy), "_")
2196
+
                                        let iy = aF(it)
2197
+
                                        let iz = getString(iy)
2198
+
                                        let iA = if (isDefined(iz))
2199
+
                                            then split_4C(value(iz), "_")
2198
2200
 
                                            else nil
2199
-
                                        if (containsElement(iz, it))
2200
-
                                            then throw((((is + " already contains ") + it) + " within referrals"))
2201
+
                                        if (containsElement(iA, iu))
2202
+
                                            then throw((((it + " already contains ") + iu) + " within referrals"))
2201
2203
 
                                            else {
2202
-
                                                let iA = makeString_2C((iz :+ it), "_")
2203
-
                                                let iB = if (containsElement(iw, is))
2204
-
                                                    then value(iv)
2205
-
                                                    else makeString_2C((iw :+ is), "_")
2206
-
                                                $Tuple2([StringEntry(gK, is), StringEntry(ix, iA), StringEntry(iu, iB), hw], 0)
2204
+
                                                let iB = makeString_2C((iA :+ iu), "_")
2205
+
                                                let iC = if (containsElement(ix, it))
2206
+
                                                    then value(iw)
2207
+
                                                    else makeString_2C((ix :+ it), "_")
2208
+
                                                $Tuple2([StringEntry(gL, it), StringEntry(iy, iB), StringEntry(iv, iC), hx], 0)
2207
2209
 
                                                }
2208
2210
 
                                        }
2209
2211
 
                                }
2212
2214
 
2213
2215
 
2214
2216
 
2215
-
@Callable(ds)
2216
-
func distributePoints (iC,iD,iE,iF,iG) = {
2217
-
    let hw = ht(ds)
2218
-
    if ((size(ds.payments) != 0))
2217
+
@Callable(dt)
2218
+
func distributePoints (iD,iE,iF,iG,iH) = {
2219
+
    let hx = hu(dt)
2220
+
    if ((size(dt.payments) != 0))
2219
2221
 
        then throw("No payments required")
2220
2222
 
        else {
2221
-
            let p = toString(ds.originCaller)
2223
+
            let p = toString(dt.originCaller)
2222
2224
 
            let k = valueOrErrorMessage(getString(aH(p)), "You don't have a duck staked")
2223
-
            let iH = r(p)
2224
-
            let iI = valueOrElse(getInteger(bF, iH), 0)
2225
-
            let iJ = n(k)
2226
-
            let iK = valueOrElse(getInteger(bF, iJ), 0)
2227
-
            let iL = (iI + iK)
2228
-
            let iM = ((((iC + iD) + iE) + iF) + iG)
2229
-
            if ((iM > iL))
2230
-
                then throw((("There are only " + toString(iL)) + " free points to distribute"))
2225
+
            let iI = r(p)
2226
+
            let iJ = valueOrElse(getInteger(bF, iI), 0)
2227
+
            let iK = n(k)
2228
+
            let iL = valueOrElse(getInteger(bF, iK), 0)
2229
+
            let iM = (iJ + iL)
2230
+
            let iN = ((((iD + iE) + iF) + iG) + iH)
2231
+
            if ((iN > iM))
2232
+
                then throw((("There are only " + toString(iM)) + " free points to distribute"))
2231
2233
 
                else {
2232
-
                    let iN = j(k)
2233
-
                    let iO = split(valueOrElse(getString(bF, iN), "0_0_0_0_0"), "_")
2234
-
                    let iP = (iI - iM)
2235
-
                    $Tuple2([IntegerEntry(iH, if ((0 > iP))
2234
+
                    let iO = j(k)
2235
+
                    let iP = split(valueOrElse(getString(bF, iO), "0_0_0_0_0"), "_")
2236
+
                    let iQ = (iJ - iN)
2237
+
                    $Tuple2([IntegerEntry(iI, if ((0 > iQ))
2236
2238
 
                        then 0
2237
-
                        else iP), IntegerEntry(iJ, if ((0 > iP))
2238
-
                        then (iK + iP)
2239
-
                        else iK), StringEntry(iN, makeString([toString((parseIntValue(iO[e]) + iC)), toString((parseIntValue(iO[f]) + iD)), toString((parseIntValue(iO[g]) + iE)), toString((parseIntValue(iO[h]) + iF)), toString((parseIntValue(iO[i]) + iG))], "_")), hw], 0)
2239
+
                        else iQ), IntegerEntry(iK, if ((0 > iQ))
2240
+
                        then (iL + iQ)
2241
+
                        else iL), StringEntry(iO, makeString([toString((parseIntValue(iP[e]) + iD)), toString((parseIntValue(iP[f]) + iE)), toString((parseIntValue(iP[g]) + iF)), toString((parseIntValue(iP[h]) + iG)), toString((parseIntValue(iP[i]) + iH))], "_")), hx], 0)
2240
2242
 
                    }
2241
2243
 
            }
2242
2244
 
    }
2243
2245
 
2244
2246
 
2245
2247
 
2246
-
@Callable(ds)
2247
-
func splitByGlobalWeightsREADONLY (eJ) = $Tuple2(nil, cO(eJ))
2248
-
2249
-
2250
-
2251
-
@Callable(ds)
2252
-
func splitByGlobalAndLocalWeightsREADONLY (iQ,iR,dv) = {
2253
-
    let do = du(dv)
2254
-
    $Tuple2(nil, $Tuple2(cO(iQ), cG(iR, do)))
2255
-
    }
2256
-
2257
-
2258
-
2259
-
@Callable(ds)
2260
-
func getBackpackREADONLY (k) = $Tuple2(nil, makeString(ea(aI(k)), ":"))
2261
-
2262
-
2263
-
2264
-
@Callable(ds)
2248
+
@Callable(dt)
2249
+
func splitByGlobalWeightsREADONLY (eK) = $Tuple2(nil, cP(eK))
2250
+
2251
+
2252
+
2253
+
@Callable(dt)
2254
+
func splitByGlobalAndLocalWeightsREADONLY (iR,iS,dw) = {
2255
+
    let dp = dv(dw)
2256
+
    $Tuple2(nil, $Tuple2(cP(iR), cH(iS, dp)))
2257
+
    }
2258
+
2259
+
2260
+
2261
+
@Callable(dt)
2262
+
func getBackpackREADONLY (k) = $Tuple2(nil, makeString(eb(aI(k)), ":"))
2263
+
2264
+
2265
+
2266
+
@Callable(dt)
2265
2267
 
func getWarehouseREADONLY (ay) = {
2266
-
    let fX = value(assetInfo(fromBase58String(ay)))
2267
-
    let ev = (bU(split(fX.description, "_")[bK]) / bl)
2268
-
    let ew = valueOrElse(getInteger(ar(ay)), 0)
2269
-
    $Tuple2(nil, makeString_2C(et(ax(ay), ev, ew), ":"))
2270
-
    }
2271
-
2272
-
2273
-
2274
-
@Callable(ds)
2275
-
func saveLastTx () = if (if ((ds.caller != bI))
2276
-
    then (ds.caller != bG)
2268
+
    let fY = value(assetInfo(fromBase58String(ay)))
2269
+
    let ew = (bU(split(fY.description, "_")[bK]) / bl)
2270
+
    let ex = valueOrElse(getInteger(ar(ay)), 0)
2271
+
    $Tuple2(nil, makeString_2C(eu(ax(ay), ew, ex), ":"))
2272
+
    }
2273
+
2274
+
2275
+
2276
+
@Callable(dt)
2277
+
func saveLastTx () = if (if ((dt.caller != bI))
2278
+
    then (dt.caller != bG)
2277
2279
 
    else false)
2278
2280
 
    then throw("Access denied")
2279
-
    else $Tuple2([ht(ds)], 42)
2280
-
2281
-
2282
-
2283
-
@Callable(ds)
2284
-
func updateDuckStats (k,gD) = if ((ds.caller != bG))
2281
+
    else $Tuple2([hu(dt)], 42)
2282
+
2283
+
2284
+
2285
+
@Callable(dt)
2286
+
func updateDuckStats (k,gE) = if ((dt.caller != bG))
2285
2287
 
    then throw("Access denied")
2286
-
    else gC(k, gD)
2287
-
2288
-
2289
-
2290
-
@Callable(ds)
2291
-
func updateAccStats (p,gD) = if ((ds.caller != bG))
2288
+
    else gD(k, gE)
2289
+
2290
+
2291
+
2292
+
@Callable(dt)
2293
+
func updateAccStats (p,gE) = if ((dt.caller != bG))
2292
2294
 
    then throw("Access denied")
2293
-
    else gI(p, gD)
2295
+
    else gJ(p, gE)
2296
+
2297
+
2298
+
2299
+
@Callable(dt)
2300
+
func issueDucks () = if ((dt.caller != this))
2301
+
    then throw("Permission denied")
2302
+
    else {
2303
+
        func iT (cN,cO) =         {
2304
+
            let fp = Issue(cO, "{\"genotype\": \" + elem + \", \"crossbreeding\": true}", 1, 0, false)
2305
+
            (cN :+ fp)
2306
+
            }
2307
+
2308
+
        let im = {
2309
+
            let aW = cy
2310
+
            let aX = size(aW)
2311
+
            let aY = nil
2312
+
            func aZ (ba,bb) =             if ((bb >= aX))
2313
+
                then ba
2314
+
                else iT(ba, aW[bb])
2315
+
2316
+
            func bc (ba,bb) =             if ((bb >= aX))
2317
+
                then ba
2318
+
                else throw("List size exceeds 12")
2319
+
2320
+
            bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
2321
+
            }
2322
+
        $Tuple2(im, unit)
2323
+
        }
2294
2324
 
2295
2325
 

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