tx · EkigtXR54sN3P2SpugWLUV7EeoMQYcb1MXtfaJsCMWUr

3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy:  -0.03500000 Waves

2024.12.04 13:21 [3399781] smart account 3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EkigtXR54sN3P2SpugWLUV7EeoMQYcb1MXtfaJsCMWUr",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1733307726434,
    "version": 2,
    "chainId": 84,
    "sender": "3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy",
    "senderPublicKey": "FsR18761ZAsUqsTd7TK3XmR6bhihs1UXVmpHYxz5JzQ1",
    "proofs": [
        "3rW1KRnzLb9VMwpyJSqUb9Sz4apQuit6RSqRm8T2HQfGwVB2xhL9EgGDnmxa4d1RcZ2ZiN449YMJmhJdmehRb1gd"
    ],
    "script": "base64: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",
    "height": 3399781,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: DjvJTxECEqNT2eT1T1BYXAFRmrwEgFHFQoaR7up1QfP6
Next: 3FvJxmJR9sgBtD197FaZNXvGHBau9GFUq8weBbWd2LC4

Diff: 

OldNewDifferences
368368 
369369 let cb = 3
370370 
371-func cc (cd,ce,cf,cg,ch) = {
372-    let ci = valueOrErrorMessage(getInteger(ce[bD], bt), "WLGOLD is not issued yet")
373-    let cj = assetBalance(ce[bC], cf)
374-    let ck = assetBalance(ce[bA], cf)
375-    let cl = (assetBalance(ce[bD], cf) - cg)
376-    let cm = assetBalance(ce[bE], cf)
377-    let cn = ce[bF]
378-    let co = (assetBalance(cn, cf) + valueOrElse(getInteger(cn, bu), 0))
379-    let cp = ((cj + cl) + co)
380-    let cq = valueOrErrorMessage(getBinary(ce[bD], "wlg_assetId"), "Not initialized yet")
381-    let cr = lastBlock.timestamp
382-    let cs = valueOrErrorMessage(getInteger(ce[bD], bs), "Not initialized")
383-    let ct = assetBalance(ce[bB], cq)
384-    let cu = fraction(aY, aZ, aW)
385-    let cv = valueOrElse(getInteger(ce[bD], bj), cu)
386-    let cw = valueOrElse(getInteger(ce[bD], bi), cs)
387-    let cx = addressFromStringValue(value(getString(ce[bD], bh)))
388-    let cy = min([fraction(cu, (cr - cw), (3 * bc)), cv])
389-    let cz = assetBalance(cx, cq)
390-    let cA = fraction(aY, ba, aW)
391-    let cB = valueOrElse(getInteger(ce[bD], bl), cA)
392-    let cC = valueOrElse(getInteger(ce[bD], bk), cs)
393-    let cD = min([fraction(cA, (cr - cC), (3 * bc)), cB])
394-    let cE = assetBalance(ce[bA], cq)
395-    let cF = valueOrElse(getInteger(ce[bD], bn(cd)), cs)
396-    let cG = ((cF - cs) / bc)
397-    let cH = min([cr, (cs + (3 * bc))])
398-    let cI = min([((cr - cs) / bc), 2])
399-    let cJ = bH(cd, ce[bB], ce[bG])
400-    let cK = bq(cI)
401-    let cL = if ((cG == cI))
371+let cc = 1733335200000
372+
373+func cd (ce,cf,cg,ch,ci) = {
374+    let cj = valueOrErrorMessage(getInteger(cf[bD], bt), "WLGOLD is not issued yet")
375+    let ck = assetBalance(cf[bC], cg)
376+    let cl = assetBalance(cf[bA], cg)
377+    let cm = (assetBalance(cf[bD], cg) - ch)
378+    let cn = assetBalance(cf[bE], cg)
379+    let co = cf[bF]
380+    let cp = (assetBalance(co, cg) + valueOrElse(getInteger(co, bu), 0))
381+    let cq = ((ck + cm) + cp)
382+    let cr = valueOrErrorMessage(getBinary(cf[bD], "wlg_assetId"), "Not initialized yet")
383+    let cs = lastBlock.timestamp
384+    let ct = valueOrErrorMessage(getInteger(cf[bD], bs), "Not initialized")
385+    let cu = assetBalance(cf[bB], cr)
386+    let cv = fraction(aY, aZ, aW)
387+    let cw = valueOrElse(getInteger(cf[bD], bj), cv)
388+    let cx = valueOrElse(getInteger(cf[bD], bi), ct)
389+    let cy = addressFromStringValue(value(getString(cf[bD], bh)))
390+    let cz = min([fraction(cv, (cs - cx), (3 * bc)), cw])
391+    let cA = assetBalance(cy, cr)
392+    let cB = fraction(aY, ba, aW)
393+    let cC = valueOrElse(getInteger(cf[bD], bl), cB)
394+    let cD = valueOrElse(getInteger(cf[bD], bk), ct)
395+    let cE = min([fraction(cB, (cs - cD), (3 * bc)), cC])
396+    let cF = assetBalance(cf[bA], cr)
397+    let cG = valueOrElse(getInteger(cf[bD], bn(ce)), ct)
398+    let cH = ((cG - ct) / bc)
399+    let cI = min([min([cs, (ct + (3 * bc))]), cc])
400+    let cJ = min([((cs - ct) / bc), 2])
401+    let cK = bH(ce, cf[bB], cf[bG])
402+    let cL = bq(cJ)
403+    let cM = if ((cH == cJ))
402404         then {
403-            let cM = fraction(cK, (cH - cF), bc)
404-            let cN = fraction(cM, ch, aW)
405-            let cO = (cF + fraction((cH - cF), ch, aW))
406-            $Tuple3(cN, cM, cO)
405+            let cN = fraction(cL, (cI - cG), bc)
406+            let cO = fraction(cN, ci, aW)
407+            let cP = (cG + fraction((cI - cG), ci, aW))
408+            $Tuple3(cO, cN, cP)
407409             }
408-        else if ((cG == (cI - 1)))
410+        else if ((cH == (cJ - 1)))
409411             then {
410-                let cP = fraction(bq((cI - 1)), ((cs + (bc * cI)) - cF), bc)
411-                let cM = fraction(cK, (cH - (cs + (bc * cI))), bc)
412-                let cQ = (cP + cM)
413-                let cN = fraction(cQ, ch, aW)
414-                let cO = if ((cP >= cN))
415-                    then (cF + fraction(bc, cN, bq((cI - 1))))
416-                    else ((cs + (bc * cI)) + fraction(bc, (cN - cP), cK))
417-                $Tuple3(cN, cQ, cO)
412+                let cQ = fraction(bq((cJ - 1)), ((ct + (bc * cJ)) - cG), bc)
413+                let cN = fraction(cL, (cI - (ct + (bc * cJ))), bc)
414+                let cR = (cQ + cN)
415+                let cO = fraction(cR, ci, aW)
416+                let cP = if ((cQ >= cO))
417+                    then (cG + fraction(bc, cO, bq((cJ - 1))))
418+                    else ((ct + (bc * cJ)) + fraction(bc, (cO - cQ), cL))
419+                $Tuple3(cO, cR, cP)
418420                 }
419421             else {
420-                let cR = fraction(bq((cI - 2)), ((cs + (bc * (cI - 1))) - cF), bc)
421-                let cP = bq((cI - 1))
422-                let cM = fraction(cK, (cH - (cs + (bc * cI))), bc)
423-                let cQ = ((cR + cP) + cM)
424-                let cN = fraction(cQ, ch, aW)
425-                let cO = if ((cR >= cN))
426-                    then (cF + fraction(bc, cN, bq((cI - 2))))
427-                    else if (((cR + cP) >= cN))
428-                        then ((cs + (bc * (cI - 1))) + fraction(bc, (cN - cR), bq((cI - 1))))
429-                        else ((cs + (bc * cI)) + fraction(bc, ((cN - cR) - cP), cK))
430-                $Tuple3(cN, cQ, cO)
422+                let cS = fraction(bq((cJ - 2)), ((ct + (bc * (cJ - 1))) - cG), bc)
423+                let cQ = bq((cJ - 1))
424+                let cN = fraction(cL, (cI - (ct + (bc * cJ))), bc)
425+                let cR = ((cS + cQ) + cN)
426+                let cO = fraction(cR, ci, aW)
427+                let cP = if ((cS >= cO))
428+                    then (cG + fraction(bc, cO, bq((cJ - 2))))
429+                    else if (((cS + cQ) >= cO))
430+                        then ((ct + (bc * (cJ - 1))) + fraction(bc, (cO - cS), bq((cJ - 1))))
431+                        else ((ct + (bc * cJ)) + fraction(bc, ((cO - cS) - cQ), cL))
432+                $Tuple3(cO, cR, cP)
431433                 }
432-    let cS = cL._1
433-    let cT = cL._2
434-    let cU = cL._3
435-    let cV = fraction(fraction(cK, bd, bc), 25, cJ[bY])
436-    let cW = valueOrElse(getInteger(ce[bD], bm), 0)
437-    let cX = fraction(cS, ((cJ[bZ] * aX) + cJ[cb]), ((cJ[bY] * aX) + cJ[ca]))
438-    let cY = fraction(cX, be, aW)
439-    let cZ = (cX - cY)
440-    let da = fraction(cT, ((cJ[bZ] * aX) + cJ[cb]), ((cJ[bY] * aX) + cJ[ca]))
441-[ci, fraction((cp - bg), aX, ci), cp, cj, ck, cl, cm, cs, cw, cu, cv, cy, cz, cA, cB, cD, cE, cI, cW, cK, cF, cZ, cV, co, da, cU, ct]
434+    let cT = cM._1
435+    let cU = cM._2
436+    let cV = cM._3
437+    let cW = fraction(fraction(cL, bd, bc), 25, cK[bY])
438+    let cX = valueOrElse(getInteger(cf[bD], bm), 0)
439+    let cY = fraction(cT, ((cK[bZ] * aX) + cK[cb]), ((cK[bY] * aX) + cK[ca]))
440+    let cZ = fraction(cY, be, aW)
441+    let da = (cY - cZ)
442+    let db = fraction(cU, ((cK[bZ] * aX) + cK[cb]), ((cK[bY] * aX) + cK[ca]))
443+[cj, fraction((cq - bg), aX, cj), cq, ck, cl, cm, cn, ct, cx, cv, cw, cz, cA, cB, cC, cE, cF, cJ, cX, cL, cG, da, cW, cp, db, cV, cu]
442444     }
443445 
444446 
445-let db = 1000000
447+let dc = 1000000
446448 
447-let dc = 100000000
449+let dd = 100000000
448450 
449-let dd = 200000
451+let de = 200000
450452 
451-let de = 100000
453+let df = 100000
452454 
453-let df = 400000
455+let dg = 400000
454456 
455-let dg = 31557600000
457+let dh = 31557600000
456458 
457-let dh = 86400000
459+let di = 86400000
458460 
459-let di = 1000000000
461+let dj = 1000000000
460462 
461-let dj = 800000
462-
463-let dk = 100000
463+let dk = 800000
464464 
465465 let dl = 100000
466466 
467-let dm = 1731279600000
467+let dm = 100000
468468 
469-let dn = "marketingAddr"
469+let dn = 1731279600000
470470 
471-let do = "teamAddr"
471+let do = "marketingAddr"
472472 
473-let dp = "lastClaimedTime_team"
473+let dp = "teamAddr"
474474 
475-let dq = "teamAmountLeft"
475+let dq = "lastClaimedTime_team"
476476 
477-let dr = "lastClaimedTime_activities"
477+let dr = "teamAmountLeft"
478478 
479-let ds = "activitiesAmountLeft"
479+let ds = "lastClaimedTime_activities"
480480 
481-let dt = "stakersAmountLeft"
481+let dt = "activitiesAmountLeft"
482482 
483-func du (P) = ("lastClaimedTimeUser_" + P)
483+let du = "stakersAmountLeft"
484+
485+func dv (P) = ("lastClaimedTimeUser_" + P)
484486 
485487 
486-func dv (ci,br) = fraction(ci, (df * (br + 1)), (6 * db))
488+func dw (cj,br) = fraction(cj, (dg * (br + 1)), (6 * dc))
487489 
488490 
489-let dw = "wlg_issue10Time"
491+let dx = "wlg_issue10Time"
490492 
491-let dx = "wlg_issueTime"
493+let dy = "wlg_issueTime"
492494 
493-let dy = "wlg_issuedAmount"
495+let dz = "wlg_issuedAmount"
494496 
495-let dz = "zbill_issuedAmount"
497+let dA = "zbill_issuedAmount"
496498 
497-func dA (P) = ("acresStakedAmountByUser_" + P)
499+func dB (P) = ("acresStakedAmountByUser_" + P)
498500 
499501 
500-let dB = "acresStakedAmountTotal"
502+let dC = "acresStakedAmountTotal"
501503 
502-let dC = "totalFarmingPower"
504+let dD = "totalFarmingPower"
503505 
504-let dD = 0
506+let dE = 0
505507 
506-let dE = 1
508+let dF = 1
507509 
508-let dF = 2
510+let dG = 2
509511 
510-let dG = 3
512+let dH = 3
511513 
512-let dH = 4
514+let dI = 4
513515 
514-let dI = 5
516+let dJ = 5
515517 
516-let dJ = 100000000
518+let dK = 100000000
517519 
518-let dK = "nftTotalIssued"
520+let dL = "nftTotalIssued"
519521 
520-let dL = "nftTotalBurned"
522+let dM = "nftTotalBurned"
521523 
522-let dM = "WlNftTotalStaked"
524+let dN = "WlNftTotalStaked"
523525 
524-func dN (P) = ("userWlNftNumber_" + P)
526+func dO (P) = ("userWlNftNumber_" + P)
525527 
526528 
527-func dO (P) = ("userFullBonus_" + P)
529+func dP (P) = ("userFullBonus_" + P)
528530 
529531 
530-let dP = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
532+let dQ = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
531533 
532-func dQ (dR) = {
533-    let dS = ((dR + 99999999) / dc)
534-    func dT (bL,bM) =     if ((bM >= dS))
534+func dR (dS) = {
535+    let dT = ((dS + 99999999) / dd)
536+    func dU (bL,bM) =     if ((bM >= dT))
535537         then bL
536538         else (bL + 1)
537539 
538-    let bO = dP
540+    let bO = dQ
539541     let bP = size(bO)
540542     let bQ = 0
541543     func bR (bS,bT) =     if ((bT >= bP))
542544         then bS
543-        else dT(bS, bO[bT])
545+        else dU(bS, bO[bT])
544546 
545547     func bU (bS,bT) =     if ((bT >= bP))
546548         then bS
550552     }
551553 
552554 
553-func dU (dR) = ((dR * 20) * (dQ(dR) + 4))
555+func dV (dS) = ((dS * 20) * (dR(dS) + 4))
554556 
555557 
556-func dV (dR,dW) = {
557-    let dX = dU(dR)
558-    $Tuple2(fraction(dX, (db + dW), db), dX)
558+func dW (dS,dX) = {
559+    let dY = dV(dS)
560+    $Tuple2(fraction(dY, (dc + dX), dc), dY)
559561     }
560562 
561563 
562-func dY (bI,K) = {
563-    let dZ = valueOrElse(getInteger(K, dC), 0)
564-    let bX = valueOrElse(getInteger(K, dA(bI)), 0)
565-    let ea = valueOrElse(getInteger(K, dO(bI)), 0)
566-    let cL = dV(bX, ea)
567-    let eb = cL._1
568-    let ec = cL._2
569-[dZ, eb, ec, ea]
564+func dZ (bI,K) = {
565+    let ea = valueOrElse(getInteger(K, dD), 0)
566+    let bX = valueOrElse(getInteger(K, dB(bI)), 0)
567+    let eb = valueOrElse(getInteger(K, dP(bI)), 0)
568+    let cM = dW(bX, eb)
569+    let ec = cM._1
570+    let ed = cM._2
571+[ea, ec, ed, eb]
570572     }
571573 
572574 
573-let ed = 0
575+let ee = 0
574576 
575-let ee = 1
577+let ef = 1
576578 
577-func ef (cd,ce,cf,cg) = {
578-    let ci = valueOrErrorMessage(getInteger(ce[dF], dy), "WLGOLD is not issued yet")
579-    let ck = assetBalance(ce[dD], cf)
580-    let cl = (assetBalance(ce[dF], cf) - cg)
581-    let cm = assetBalance(ce[dG], cf)
582-    let eg = assetBalance(ce[dE], cf)
583-    let cn = ce[dH]
584-    let co = (assetBalance(cn, cf) + valueOrElse(getInteger(cn, dz), 0))
585-    let cp = ((eg + cl) + co)
586-    let cq = valueOrErrorMessage(getBinary(ce[dF], "wlg_assetId"), "Not initialized yet")
587-    let cr = lastBlock.timestamp
588-    let cs = valueOrErrorMessage(getInteger(ce[dF], dx), "Not initialized")
589-    let eh = assetBalance(ce[dF], cq)
590-    let cu = fraction(ci, dd, db)
591-    let cv = valueOrElse(getInteger(ce[dF], dq), cu)
592-    let cw = valueOrElse(getInteger(ce[dF], dp), cs)
593-    let cx = addressFromStringValue(value(getString(ce[dF], do)))
594-    let cy = min([fraction(cu, (cr - cw), (3 * dg)), cv])
595-    let cz = assetBalance(cx, cq)
596-    let cA = fraction(ci, de, db)
597-    let cB = valueOrElse(getInteger(ce[dF], ds), cA)
598-    let cC = valueOrElse(getInteger(ce[dF], dr), cs)
599-    let cD = min([fraction(cA, (cr - cC), (3 * dg)), cB])
600-    let cE = assetBalance(ce[dD], cq)
601-    let cF = valueOrElse(getInteger(ce[dF], du(cd)), cs)
602-    let cG = ((cF - cs) / dg)
603-    let cH = min([cr, (cs + (3 * dg))])
604-    let cI = min([((cr - cs) / dg), 2])
605-    let cJ = dY(cd, ce[dE])
606-    let cK = dv(ci, cI)
607-    let ei = (cs + (dg * cI))
608-    let ej = (cs + (dg * (cI - 1)))
609-    let cM = fraction(cK, (cH - cF), dg)
610-    let cT = if ((cG == cI))
611-        then cM
612-        else if ((cG == (cI - 1)))
579+func eg (ce,cf,cg,ch) = {
580+    let cj = valueOrErrorMessage(getInteger(cf[dG], dz), "WLGOLD is not issued yet")
581+    let cl = assetBalance(cf[dE], cg)
582+    let cm = (assetBalance(cf[dG], cg) - ch)
583+    let cn = assetBalance(cf[dH], cg)
584+    let eh = assetBalance(cf[dF], cg)
585+    let co = cf[dI]
586+    let cp = (assetBalance(co, cg) + valueOrElse(getInteger(co, dA), 0))
587+    let cq = ((eh + cm) + cp)
588+    let cr = valueOrErrorMessage(getBinary(cf[dG], "wlg_assetId"), "Not initialized yet")
589+    let cs = lastBlock.timestamp
590+    let ct = valueOrErrorMessage(getInteger(cf[dG], dy), "Not initialized")
591+    let ei = assetBalance(cf[dG], cr)
592+    let cv = fraction(cj, de, dc)
593+    let cw = valueOrElse(getInteger(cf[dG], dr), cv)
594+    let cx = valueOrElse(getInteger(cf[dG], dq), ct)
595+    let cy = addressFromStringValue(value(getString(cf[dG], dp)))
596+    let cz = min([fraction(cv, (cs - cx), (3 * dh)), cw])
597+    let cA = assetBalance(cy, cr)
598+    let cB = fraction(cj, df, dc)
599+    let cC = valueOrElse(getInteger(cf[dG], dt), cB)
600+    let cD = valueOrElse(getInteger(cf[dG], ds), ct)
601+    let cE = min([fraction(cB, (cs - cD), (3 * dh)), cC])
602+    let cF = assetBalance(cf[dE], cr)
603+    let cG = valueOrElse(getInteger(cf[dG], dv(ce)), ct)
604+    let cH = ((cG - ct) / dh)
605+    let cI = min([cs, (ct + (3 * dh))])
606+    let cJ = min([((cs - ct) / dh), 2])
607+    let cK = dZ(ce, cf[dF])
608+    let cL = dw(cj, cJ)
609+    let ej = (ct + (dh * cJ))
610+    let ek = (ct + (dh * (cJ - 1)))
611+    let cN = fraction(cL, (cI - cG), dh)
612+    let cU = if ((cH == cJ))
613+        then cN
614+        else if ((cH == (cJ - 1)))
613615             then {
614-                let cP = fraction(dv(ci, (cI - 1)), (ei - cF), dg)
615-                (cP + cM)
616+                let cQ = fraction(dw(cj, (cJ - 1)), (ej - cG), dh)
617+                (cQ + cN)
616618                 }
617619             else {
618-                let cR = fraction(dv(ci, (cI - 2)), (ej - cF), dg)
619-                let cP = dv(ci, (cI - 1))
620-                ((cR + cP) + cM)
620+                let cS = fraction(dw(cj, (cJ - 2)), (ek - cG), dh)
621+                let cQ = dw(cj, (cJ - 1))
622+                ((cS + cQ) + cN)
621623                 }
622-    let cW = valueOrElse(getInteger(ce[dF], dt), 0)
623-    let cS = if ((cJ[ed] != 0))
624-        then fraction(cT, cJ[ee], cJ[ed])
624+    let cX = valueOrElse(getInteger(cf[dG], du), 0)
625+    let cT = if ((cK[ee] != 0))
626+        then fraction(cU, cK[ef], cK[ee])
625627         else 0
626-    let ek = valueOrElse(getInteger(ce[dF], dw), dm)
627-    let el = fraction(di, max([(cr - ek), 0]), dh)
628-    let em = fraction(el, dk, db)
629-    let en = fraction(el, dl, db)
630-    let eo = max([(cr - max([dm, cF])), 0])
631-    let ep = if ((cJ[ed] != 0))
632-        then fraction(fraction(fraction(di, eo, dh), cJ[ee], cJ[ed]), dj, db)
628+    let el = valueOrElse(getInteger(cf[dG], dx), dn)
629+    let em = fraction(dj, max([(cs - el), 0]), di)
630+    let en = fraction(em, dl, dc)
631+    let eo = fraction(em, dm, dc)
632+    let ep = max([(cs - max([dn, cG])), 0])
633+    let eq = if ((cK[ee] != 0))
634+        then fraction(fraction(fraction(dj, ep, di), cK[ef], cK[ee]), dk, dc)
633635         else 0
634-    let eq = max([dm, cr])
635-    let er = valueOrElse(getInteger(ce[dE], dB), 0)
636-    let es = valueOrElse(getInteger(ce[dE], dK), 0)
637-    let et = valueOrElse(getInteger(ce[dE], dL), 0)
638-    let eu = valueOrElse(getInteger(ce[dE], dM), 0)
639-    let ev = valueOrElse(getInteger(ce[dE], dN(valueOrElse(cd, ""))), 0)
640-[ci, eh, fraction(cp, dc, ci), cp, ck, eg, cl, cm, cs, cw, cu, cv, cy, cz, cA, cB, cD, cE, cI, cW, cK, cF, co, cS, cH, el, em, en, ep, eq, cJ[ed], er, es, et, eu, ev]
636+    let er = max([dn, cs])
637+    let es = valueOrElse(getInteger(cf[dF], dC), 0)
638+    let et = valueOrElse(getInteger(cf[dF], dL), 0)
639+    let eu = valueOrElse(getInteger(cf[dF], dM), 0)
640+    let ev = valueOrElse(getInteger(cf[dF], dN), 0)
641+    let ew = valueOrElse(getInteger(cf[dF], dO(valueOrElse(ce, ""))), 0)
642+[cj, ei, fraction(cq, dd, cj), cq, cl, eh, cm, cn, ct, cx, cv, cw, cz, cA, cB, cC, cE, cF, cJ, cX, cL, cG, cp, cT, cI, em, en, eo, eq, er, cK[ee], es, et, eu, ev, ew]
641643     }
642644 
643645 
644-let ew = "profitAddr"
646+let ex = "profitAddr"
645647 
646-let ex = "stakersAmountPaidTotal"
648+let ey = "stakersAmountPaidTotal"
647649 
648-func ey (P) = ("stakersAmountPaidUser_" + P)
650+func ez (P) = ("stakersAmountPaidUser_" + P)
649651 
650652 
651-func ez () = au(reentrantInvoke(K, "saveLastTx", nil, nil))
653+func eA () = au(reentrantInvoke(K, "saveLastTx", nil, nil))
652654 
653655 
654-func eA (P) = {
655-    let eB = valueOrElse(getInteger(bo(P)), 0)
656-    let eC = valueOrElse(getInteger(K, bv(P)), 0)
657-    let eD = valueOrElse(getInteger(bp(P)), eC)
658-    let eE = (eD + fraction(eC, (lastBlock.timestamp - eB), e))
659-    min([eE, eC])
656+func eB (P) = {
657+    let eC = valueOrElse(getInteger(bo(P)), 0)
658+    let eD = valueOrElse(getInteger(K, bv(P)), 0)
659+    let eE = valueOrElse(getInteger(bp(P)), eD)
660+    let eF = (eE + fraction(eD, (lastBlock.timestamp - eC), e))
661+    min([eF, eD])
660662     }
661663 
662664 
663-let eF = 10
665+let eG = 10
664666 
665-let eG = 11
667+let eH = 11
666668 
667-let eH = 14
669+let eI = 14
668670 
669-let eI = 15
671+let eJ = 15
670672 
671-let eJ = 18
673+let eK = 18
672674 
673-let eK = 21
675+let eL = 21
674676 
675-let eL = 24
677+let eM = 24
676678 
677-let eM = 25
679+let eN = 25
678680 
679-func eN (P) = {
680-    let eO = addressFromStringValue(P)
681-    let eP = addressFromStringValue(n)
682-    let eQ = cc(P, [y, H, eP, L, M, N, I], k, 0, b)
683-    let cr = lastBlock.timestamp
684-    let cv = eQ[eF]
685-    let eR = eQ[eG]
686-    let cB = eQ[eH]
687-    let eS = eQ[eI]
688-    let cS = eQ[eK]
689-    let eT = ey(P)
690-    let eU = eQ[eL]
691-    let eV = eQ[eM]
692-    $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(bh))), eR, R), ScriptTransfer(y, eS, R), IntegerEntry(eT, (valueOrElse(getInteger(eT), 0) + cS)), IntegerEntry(ex, (valueOrElse(getInteger(ex), 0) + eU)), IntegerEntry(bm, (eQ[eJ] - eU)), IntegerEntry(bj, (cv - eR)), IntegerEntry(bi, cr), IntegerEntry(bl, (cB - eS)), IntegerEntry(bk, cr), IntegerEntry(bn(P), eV)], cS)
681+func eO (P) = {
682+    let eP = addressFromStringValue(P)
683+    let eQ = addressFromStringValue(n)
684+    let eR = cd(P, [y, H, eQ, L, M, N, I], k, 0, b)
685+    let cs = lastBlock.timestamp
686+    let cw = eR[eG]
687+    let eS = eR[eH]
688+    let cC = eR[eI]
689+    let eT = eR[eJ]
690+    let cT = eR[eL]
691+    let eU = ez(P)
692+    let eV = eR[eM]
693+    let eW = eR[eN]
694+    $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(bh))), eS, R), ScriptTransfer(y, eT, R), IntegerEntry(eU, (valueOrElse(getInteger(eU), 0) + cT)), IntegerEntry(ey, (valueOrElse(getInteger(ey), 0) + eV)), IntegerEntry(bm, (eR[eK] - eV)), IntegerEntry(bj, (cw - eS)), IntegerEntry(bi, cs), IntegerEntry(bl, (cC - eT)), IntegerEntry(bk, cs), IntegerEntry(bn(P), eW)], cT)
693695     }
694696 
695697 
696-func eW (P) = {
697-    let eQ = ef(P, [J, K, L, M, N], k, 0)
698-    let eX = du(P)
699-    let cF = valueOrElse(getInteger(eX), 0)
700-    let eV = eQ[ao]
701-    if ((cF == eV))
698+func eX (P) = {
699+    let eR = eg(P, [J, K, L, M, N], k, 0)
700+    let eY = dv(P)
701+    let cG = valueOrElse(getInteger(eY), 0)
702+    let eW = eR[ao]
703+    if ((cG == eW))
702704         then $Tuple2(nil, 0)
703705         else {
704-            let cr = lastBlock.timestamp
705-            let cs = eQ[ah]
706-            let cv = eQ[ai]
707-            let eR = (eQ[aj] + eQ[ar])
708-            let eY = if ((eR > 0))
709-                then [ScriptTransfer(addressFromStringValue(value(getString(bh))), eR, R)]
706+            let cs = lastBlock.timestamp
707+            let ct = eR[ah]
708+            let cw = eR[ai]
709+            let eS = (eR[aj] + eR[ar])
710+            let eZ = if ((eS > 0))
711+                then [ScriptTransfer(addressFromStringValue(value(getString(bh))), eS, R)]
710712                 else nil
711-            let cB = eQ[ak]
712-            let eS = eQ[al]
713-            let eZ = if ((eS > 0))
714-                then [ScriptTransfer(y, eS, R)]
713+            let cC = eR[ak]
714+            let eT = eR[al]
715+            let fa = if ((eT > 0))
716+                then [ScriptTransfer(y, eT, R)]
715717                 else nil
716-            let fa = eQ[aq]
717-            let fb = if ((fa > 0))
718-                then [ScriptTransfer(addressFromStringValue(value(getString(dn))), fa, R)]
718+            let fb = eR[aq]
719+            let fc = if ((fb > 0))
720+                then [ScriptTransfer(addressFromStringValue(value(getString(do))), fb, R)]
719721                 else nil
720-            let cS = eQ[an]
721-            let eT = ey(P)
722-            let eU = (cS + eQ[as])
723-            let fc = eQ[ap]
724-            $Tuple2(((([Reissue(R, fc, true), IntegerEntry(bt, (eQ[ae] + fc)), IntegerEntry(dw, eQ[at]), IntegerEntry(eT, (valueOrElse(getInteger(eT), 0) + cS)), IntegerEntry(ex, (valueOrElse(getInteger(ex), 0) + cS)), IntegerEntry(bm, (eQ[am] - cS)), IntegerEntry(bj, ((cv - eR) + eQ[ar])), IntegerEntry(bi, cr), IntegerEntry(bl, (cB - eS)), IntegerEntry(bk, cr), IntegerEntry(eX, eV)] ++ eY) ++ eZ) ++ fb), eU)
722+            let cT = eR[an]
723+            let eU = ez(P)
724+            let eV = (cT + eR[as])
725+            let fd = eR[ap]
726+            $Tuple2(((([Reissue(R, fd, true), IntegerEntry(bt, (eR[ae] + fd)), IntegerEntry(dx, eR[at]), IntegerEntry(eU, (valueOrElse(getInteger(eU), 0) + cT)), IntegerEntry(ey, (valueOrElse(getInteger(ey), 0) + cT)), IntegerEntry(bm, (eR[am] - cT)), IntegerEntry(bj, ((cw - eS) + eR[ar])), IntegerEntry(bi, cs), IntegerEntry(bl, (cC - eT)), IntegerEntry(bk, cs), IntegerEntry(eY, eW)] ++ eZ) ++ fa) ++ fc), eV)
725727             }
726728     }
727729 
728730 
729-func fd (P,fe) = {
730-    let cr = lastBlock.timestamp
731-    let ff = bz(P)
732-    let fg = bx(P)
733-    let eB = valueOrElse(getInteger(ff), 0)
734-    let fh = valueOrElse(getInteger(fg), 0)
735-    let fi = valueOrElse(getInteger(by), 0)
736-    let aR = fraction(fraction(aP, fh, aM), (eB - cr), bd)
737-    $Tuple3([IntegerEntry(ff, cr), IntegerEntry(fg, (fh + fe)), IntegerEntry(by, (fi + fe))], aR, fh)
731+func fe (P,ff) = {
732+    let cs = lastBlock.timestamp
733+    let fg = bz(P)
734+    let fh = bx(P)
735+    let eC = valueOrElse(getInteger(fg), 0)
736+    let fi = valueOrElse(getInteger(fh), 0)
737+    let fj = valueOrElse(getInteger(by), 0)
738+    let aR = fraction(fraction(aP, fi, aM), (eC - cs), bd)
739+    $Tuple3([IntegerEntry(fg, cs), IntegerEntry(fh, (fi + ff)), IntegerEntry(by, (fj + ff))], aR, fi)
738740     }
739741 
740742 
741-func fj (P) = {
743+func fk (P) = {
742744     let U = (height / i)
743-    let fk = (U - 1)
744-    let fl = valueOrElse(getInteger(X(fk)), dI)
745-    let fm = valueOrElse(getInteger(Y(fk)), 0)
746-    let fn = valueOrElse(getInteger(T(P, fk)), 0)
747-    if ((0 >= fn))
745+    let fl = (U - 1)
746+    let fm = valueOrElse(getInteger(X(fl)), dJ)
747+    let fn = valueOrElse(getInteger(Y(fl)), 0)
748+    let fo = valueOrElse(getInteger(T(P, fl)), 0)
749+    if ((0 >= fo))
748750         then $Tuple2(nil, unit)
749751         else {
750-            let fo = valueOrElse(getInteger(V(fk)), 0)
751-            if ((0 >= fo))
752-                then $Tuple2([DeleteEntry(T(P, fk))], unit)
752+            let fp = valueOrElse(getInteger(V(fl)), 0)
753+            if ((0 >= fp))
754+                then $Tuple2([DeleteEntry(T(P, fl))], unit)
753755                 else {
754756                     let aG = value(value(blockInfoByHeight((U * i))).vrf)
755757                     let aF = fromBase58String(split(valueOrElse(getString(K, O(P)), "42_DEFAULT"), "_")[1])
756-                    let fp = aD(fo, aF, aG)
757-                    if (((fn * fl) > fp))
758+                    let fq = aD(fp, aF, aG)
759+                    if (((fo * fm) > fq))
758760                         then {
759-                            let fq = invoke(K, "issuePickC1", [P], nil)
760-                            let fr = getString(Z(fk))
761-                            let fs = if (isDefined(fr))
762-                                then ((value(fr) + "_") + P)
761+                            let fr = invoke(K, "issuePickC1", [P], nil)
762+                            let fs = getString(Z(fl))
763+                            let ft = if (isDefined(fs))
764+                                then ((value(fs) + "_") + P)
763765                                 else P
764-                            $Tuple2([IntegerEntry(Y(fk), (fm + 1)), DeleteEntry(T(P, fk)), StringEntry(Z(fk), fs)], fq)
766+                            $Tuple2([IntegerEntry(Y(fl), (fn + 1)), DeleteEntry(T(P, fl)), StringEntry(Z(fl), ft)], fr)
765767                             }
766768                         else {
767-                            let ft = (aD(9, (base58'29' + aF), aG) + 1)
768-                            let fu = fraction(fn, ft, 10)
769-                            let fv = T(P, U)
770-                            let fw = valueOrElse(getInteger(fv), 0)
771-                            $Tuple2(((if ((fu == 0))
769+                            let fu = (aD(9, (base58'29' + aF), aG) + 1)
770+                            let fv = fraction(fo, fu, 10)
771+                            let fw = T(P, U)
772+                            let fx = valueOrElse(getInteger(fw), 0)
773+                            $Tuple2(((if ((fv == 0))
772774                                 then nil
773775                                 else {
774-                                    let fx = [IntegerEntry(V(U), (valueOrElse(getInteger(V(U)), 0) + fu)), IntegerEntry(fv, (fw + fu))]
775-                                    if ((fw > 0))
776-                                        then fx
777-                                        else (fx :+ IntegerEntry(W(U), (valueOrElse(getInteger(W(U)), 0) + 1)))
778-                                    }) :+ DeleteEntry(T(P, fk))), fu)
776+                                    let fy = [IntegerEntry(V(U), (valueOrElse(getInteger(V(U)), 0) + fv)), IntegerEntry(fw, (fx + fv))]
777+                                    if ((fx > 0))
778+                                        then fy
779+                                        else (fy :+ IntegerEntry(W(U), (valueOrElse(getInteger(W(U)), 0) + 1)))
780+                                    }) :+ DeleteEntry(T(P, fl))), fv)
779781                             }
780782                     }
781783             }
782784     }
783785 
784786 
785-func fy (P,fz) = {
787+func fz (P,fA) = {
786788     let U = (height / i)
787-    let fv = T(P, U)
788-    let fA = split(fz, "_")
789-    let fB = valueOrElse(getInteger(V(U)), 0)
790-    let fw = valueOrElse(getInteger(fv), 0)
791-    let fC = if ((aa(parseIntValue(fA[0])) == parseIntValue(fA[1])))
789+    let fw = T(P, U)
790+    let fB = split(fA, "_")
791+    let fC = valueOrElse(getInteger(V(U)), 0)
792+    let fx = valueOrElse(getInteger(fw), 0)
793+    let fD = if ((aa(parseIntValue(fB[0])) == parseIntValue(fB[1])))
792794         then 1
793795         else 0
794-    let fD = valueOrElse(getInteger(W(U)), 0)
795-    let fE = if (if ((fw == 0))
796-        then (fC == 1)
796+    let fE = valueOrElse(getInteger(W(U)), 0)
797+    let fF = if (if ((fx == 0))
798+        then (fD == 1)
797799         else false)
798-        then [IntegerEntry(W(U), (fD + 1))]
800+        then [IntegerEntry(W(U), (fE + 1))]
799801         else nil
800-    $Tuple2(if ((fC == 0))
802+    $Tuple2(if ((fD == 0))
801803         then nil
802-        else ((fE :+ IntegerEntry(fv, (fw + fC))) :+ IntegerEntry(V(U), (fB + fC))), fC)
804+        else ((fF :+ IntegerEntry(fw, (fx + fD))) :+ IntegerEntry(V(U), (fC + fD))), fD)
803805     }
804806 
805807 
806-@Callable(fF)
807-func constructorV1 (fG,fH,cx,fI) = if ((fF.caller != this))
808+@Callable(fG)
809+func constructorV1 (fH,fI,cy,fJ) = if ((fG.caller != this))
808810     then throw("Permission denied")
809811     else if (isDefined(getBinary(Q)))
810812         then throw("Already initialized")
811813         else {
812-            let ci = aY
813-            let fJ = Issue("WLGOLD", "WavesLands Gold investment token", ci, 8, true, unit, 0)
814-            let fK = calculateAssetId(fJ)
815-[fJ, IntegerEntry(bs, lastBlock.timestamp), IntegerEntry(bt, ci), IntegerEntry(ex, 0), IntegerEntry(bm, fraction(aY, bb, b)), BinaryEntry(Q, fK), StringEntry(x(), fG), StringEntry(dn, fH), StringEntry(bh, cx), StringEntry(ew, fI)]
814+            let cj = aY
815+            let fK = Issue("WLGOLD", "WavesLands Gold investment token", cj, 8, true, unit, 0)
816+            let fL = calculateAssetId(fK)
817+[fK, IntegerEntry(bs, lastBlock.timestamp), IntegerEntry(bt, cj), IntegerEntry(ey, 0), IntegerEntry(bm, fraction(aY, bb, b)), BinaryEntry(Q, fL), StringEntry(x(), fH), StringEntry(do, fI), StringEntry(bh, cy), StringEntry(ex, fJ)]
816818             }
817819 
818820 
819821 
820-@Callable(fF)
821-func constructorV2 (fL) = if ((fF.caller != this))
822+@Callable(fG)
823+func constructorV2 (fM) = if ((fG.caller != this))
822824     then throw("Permission denied")
823-    else [StringEntry(w(), fL)]
825+    else [StringEntry(w(), fM)]
824826 
825827 
826828 
827-@Callable(fF)
828-func buyWlg (fM) = {
829-    let fN = ez()
830-    if ((fN == fN))
831-        then if ((size(fF.payments) != 1))
829+@Callable(fG)
830+func buyWlg (fN) = {
831+    let fO = eA()
832+    if ((fO == fO))
833+        then if ((size(fG.payments) != 1))
832834             then throw("exactly 1 payment must be attached")
833835             else {
834-                let fO = fF.payments[0]
835-                let fP = fO.amount
836-                if (if (!(isDefined(fO.assetId)))
836+                let fP = fG.payments[0]
837+                let fQ = fP.amount
838+                if (if (!(isDefined(fP.assetId)))
837839                     then true
838-                    else (value(fO.assetId) != k))
840+                    else (value(fP.assetId) != k))
839841                     then throw("USDT payments only!")
840842                     else {
841-                        let eO = fF.caller
842-                        let P = toString(eO)
843-                        if ((d > fP))
843+                        let eP = fG.caller
844+                        let P = toString(eP)
845+                        if ((d > fQ))
844846                             then throw((("You can trade min " + ax(d, 6)) + " USDT"))
845847                             else {
846-                                let eQ = ef("", [J, K, L, M, N], k, fP)
847-                                let fQ = eQ[ae]
848-                                let fR = eQ[ag]
849-                                let fS = fraction(fR, 6, 5, CEILING)
850-                                let fT = fraction(fP, c, fS)
851-                                let fU = eA(P)
852-                                if ((fT > fU))
853-                                    then throw((("You can get max " + ax(fU, 8)) + " WLGOLD at the moment"))
854-                                    else if ((fM > fT))
848+                                let eR = eg("", [J, K, L, M, N], k, fQ)
849+                                let fR = eR[ae]
850+                                let fS = eR[ag]
851+                                let fT = fraction(fS, 6, 5, CEILING)
852+                                let fU = fraction(fQ, c, fT)
853+                                let fV = eB(P)
854+                                if ((fU > fV))
855+                                    then throw((("You can get max " + ax(fV, 8)) + " WLGOLD at the moment"))
856+                                    else if ((fN > fU))
855857                                         then throw("Price changed during operation, please try again")
856858                                         else {
857-                                            let fV = (fP / 6)
858-                                            $Tuple2([Reissue(R, fT, true), IntegerEntry(bt, (fQ + fT)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fU - fT)), ScriptTransfer(addressFromStringValue(value(getString(ew))), fV, k), ScriptTransfer(eO, fT, R)], fN)
859+                                            let fW = (fQ / 6)
860+                                            $Tuple2([Reissue(R, fU, true), IntegerEntry(bt, (fR + fU)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fV - fU)), ScriptTransfer(addressFromStringValue(value(getString(ex))), fW, k), ScriptTransfer(eP, fU, R)], fO)
859861                                             }
860862                                 }
861863                         }
865867 
866868 
867869 
868-@Callable(fF)
869-func buyWlgREADONLY (p,fP) = {
870-    let eQ = ef("", [J, K, L, M, N], k, fP)
871-    let fR = eQ[ag]
872-    let fS = fraction(fR, 6, 5, CEILING)
873-    let fT = fraction(fP, c, fS)
874-    let fU = eA(p)
875-    let fW = fraction(fU, fS, c)
876-    let fV = (fP / 6)
877-    $Tuple2(nil, [fT, d, fW, fV])
870+@Callable(fG)
871+func buyWlgREADONLY (p,fQ) = {
872+    let eR = eg("", [J, K, L, M, N], k, fQ)
873+    let fS = eR[ag]
874+    let fT = fraction(fS, 6, 5, CEILING)
875+    let fU = fraction(fQ, c, fT)
876+    let fV = eB(p)
877+    let fX = fraction(fV, fT, c)
878+    let fW = (fQ / 6)
879+    $Tuple2(nil, [fU, d, fX, fW])
878880     }
879881 
880882 
881883 
882-@Callable(fF)
883-func sellWlg (fX) = {
884-    let fN = ez()
885-    if ((fN == fN))
886-        then if ((size(fF.payments) != 1))
884+@Callable(fG)
885+func sellWlg (fY) = {
886+    let fO = eA()
887+    if ((fO == fO))
888+        then if ((size(fG.payments) != 1))
887889             then throw("exactly 1 payment must be attached")
888890             else {
889-                let fO = fF.payments[0]
890-                let fY = fO.amount
891-                let eO = fF.caller
892-                let P = toString(eO)
893-                let fU = eA(P)
894-                if ((fY > fU))
895-                    then throw((("You can spend max " + ax(fU, 8)) + " WLGOLD at the moment"))
896-                    else if (if (!(isDefined(fO.assetId)))
891+                let fP = fG.payments[0]
892+                let fZ = fP.amount
893+                let eP = fG.caller
894+                let P = toString(eP)
895+                let fV = eB(P)
896+                if ((fZ > fV))
897+                    then throw((("You can spend max " + ax(fV, 8)) + " WLGOLD at the moment"))
898+                    else if (if (!(isDefined(fP.assetId)))
897899                         then true
898-                        else (value(fO.assetId) != R))
900+                        else (value(fP.assetId) != R))
899901                         then throw("WLGOLD payments only!")
900902                         else {
901-                            let eQ = ef("", [J, K, L, M, N], k, 0)
902-                            let fQ = eQ[ae]
903-                            let fZ = (eQ[ag] / 2)
904-                            let fP = fraction(fY, fZ, c)
905-                            if ((d > fP))
903+                            let eR = eg("", [J, K, L, M, N], k, 0)
904+                            let fR = eR[ae]
905+                            let ga = (eR[ag] / 2)
906+                            let fQ = fraction(fZ, ga, c)
907+                            if ((d > fQ))
906908                                 then throw((("You can trade min " + ax(d, 6)) + " USDT"))
907-                                else if ((fX > fP))
909+                                else if ((fY > fQ))
908910                                     then throw("Price changed during operation, please try again")
909911                                     else {
910-                                        let fV = (fP / 5)
911-                                        $Tuple2([Burn(R, fY), IntegerEntry(bt, (fQ - fY)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fU - fY)), ScriptTransfer(addressFromStringValue(value(getString(ew))), fV, k), ScriptTransfer(eO, fP, k)], fN)
912+                                        let fW = (fQ / 5)
913+                                        $Tuple2([Burn(R, fZ), IntegerEntry(bt, (fR - fZ)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fV - fZ)), ScriptTransfer(addressFromStringValue(value(getString(ex))), fW, k), ScriptTransfer(eP, fQ, k)], fO)
912914                                         }
913915                             }
914916                 }
917919 
918920 
919921 
920-@Callable(fF)
921-func sellWlgREADONLY (p,fY) = {
922-    let fU = eA(p)
923-    let eQ = ef("", [J, K, L, M, N], k, 0)
924-    let fZ = (eQ[ag] / 2)
925-    let fP = fraction(fY, fZ, c)
926-    let ga = fraction(d, c, fZ)
927-    let fV = (fP / 5)
928-    $Tuple2(nil, [fP, ga, fU, fV])
922+@Callable(fG)
923+func sellWlgREADONLY (p,fZ) = {
924+    let fV = eB(p)
925+    let eR = eg("", [J, K, L, M, N], k, 0)
926+    let ga = (eR[ag] / 2)
927+    let fQ = fraction(fZ, ga, c)
928+    let gb = fraction(d, c, ga)
929+    let fW = (fQ / 5)
930+    $Tuple2(nil, [fQ, gb, fV, fW])
929931     }
930932 
931933 
932934 
933-@Callable(fF)
935+@Callable(fG)
934936 func claim () = {
935-    let fN = ez()
936-    if ((fN == fN))
937-        then if ((size(fF.payments) != 0))
937+    let fO = eA()
938+    if ((fO == fO))
939+        then if ((size(fG.payments) != 0))
938940             then throw("No payments required")
939941             else {
940-                let gb = eW(toString(fF.caller))
941-                let gc = gb._1
942-                let gd = gb._2
943-                $Tuple2((gc :+ ScriptTransfer(fF.caller, gd, R)), fN)
942+                let gc = eX(toString(fG.caller))
943+                let gd = gc._1
944+                let ge = gc._2
945+                $Tuple2((gd :+ ScriptTransfer(fG.caller, ge, R)), fO)
944946                 }
945947         else throw("Strict value is not equal to itself.")
946948     }
947949 
948950 
949951 
950-@Callable(fF)
951-func onStakeUnstakeLand (P,ge) = if (if (if ((fF.caller != H))
952-    then (fF.caller != I)
952+@Callable(fG)
953+func onStakeUnstakeLand (P,gf) = if (if (if ((fG.caller != H))
954+    then (fG.caller != I)
953955     else false)
954-    then (fF.caller != K)
956+    then (fG.caller != K)
955957     else false)
956958     then throw("Permission denied")
957959     else {
958-        let gf = if (ge)
959-            then eW(P)
960-            else eN(P)
961-        let gc = gf._1
962-        let gd = gf._2
963-        $Tuple2(if ((gd > 0))
964-            then (gc :+ ScriptTransfer(addressFromStringValue(P), gd, R))
965-            else gc, gd)
960+        let gg = if (gf)
961+            then eX(P)
962+            else eO(P)
963+        let gd = gg._1
964+        let ge = gg._2
965+        $Tuple2(if ((ge > 0))
966+            then (gd :+ ScriptTransfer(addressFromStringValue(P), ge, R))
967+            else gd, ge)
966968         }
967969 
968970 
969971 
970-@Callable(fF)
971-func burnWlgold (fY) = if ((fF.caller != K))
972+@Callable(fG)
973+func burnWlgold (fZ) = if ((fG.caller != K))
972974     then throw("Permission denied")
973975     else {
974-        let eQ = ef("", [J, K, L, M, N], k, 0)
975-        if ((fY > eQ[af]))
976-            then throw(((("Only " + ax(eQ[af], 8)) + " WLGOLD left on contract, can't burn ") + ax(fY, 8)))
976+        let eR = eg("", [J, K, L, M, N], k, 0)
977+        if ((fZ > eR[af]))
978+            then throw(((("Only " + ax(eR[af], 8)) + " WLGOLD left on contract, can't burn ") + ax(fZ, 8)))
977979             else {
978-                let gg = (eQ[ae] - fY)
979-                $Tuple2([Burn(R, fY), IntegerEntry(bt, gg)], gg)
980+                let gh = (eR[ae] - fZ)
981+                $Tuple2([Burn(R, fZ), IntegerEntry(bt, gh)], gh)
980982                 }
981983         }
982984 
983985 
984986 
985-@Callable(fF)
986-func betForTicket (gh) = {
987-    let fN = ez()
988-    if ((fN == fN))
989-        then if ((size(fF.payments) != 0))
987+@Callable(fG)
988+func betForTicket (gi) = {
989+    let fO = eA()
990+    if ((fO == fO))
991+        then if ((size(fG.payments) != 0))
990992             then throw("No payments required")
991993             else {
992-                let P = toString(fF.caller)
993-                let fk = ((height / i) - 1)
994-                let fn = valueOrElse(getInteger(T(P, fk)), 0)
995-                let fo = valueOrElse(getInteger(V(fk)), 0)
996-                if (if ((fn > 0))
997-                    then (fo > 0)
994+                let P = toString(fG.caller)
995+                let fl = ((height / i) - 1)
996+                let fo = valueOrElse(getInteger(T(P, fl)), 0)
997+                let fp = valueOrElse(getInteger(V(fl)), 0)
998+                if (if ((fo > 0))
999+                    then (fp > 0)
9981000                     else false)
9991001                     then throw("Please open the chest first")
1000-                    else if (((gh / 4) != 0))
1002+                    else if (((gi / 4) != 0))
10011003                         then throw("Invalid bet: should be 0..3")
10021004                         else {
1003-                            let gi = (height % g)
1004-                            if ((gi > (g - 3)))
1005-                                then throw((("Cannot bet: the day is almost ended, please wait " + toString((g - gi))) + " blocks"))
1005+                            let gj = (height % g)
1006+                            if ((gj > (g - 3)))
1007+                                then throw((("Cannot bet: the day is almost ended, please wait " + toString((g - gj))) + " blocks"))
10061008                                 else {
1007-                                    let gj = valueOrElse(getInteger(K, dA(P)), 0)
1008-                                    if ((dJ > gj))
1009-                                        then throw((("You need to stake at least " + ax(dJ, 8)) + " ACRES to bet"))
1009+                                    let gk = valueOrElse(getInteger(K, dB(P)), 0)
1010+                                    if ((dK > gk))
1011+                                        then throw((("You need to stake at least " + ax(dK, 8)) + " ACRES to bet"))
10101012                                         else {
1011-                                            let gk = ((height / g) + 1)
1012-                                            let gl = S(P)
1013-                                            let gm = getString(gl)
1014-                                            let gn = StringEntry(gl, ((toString(gk) + "_") + toString(gh)))
1015-                                            if (isDefined(gm))
1013+                                            let gl = ((height / g) + 1)
1014+                                            let gm = S(P)
1015+                                            let gn = getString(gm)
1016+                                            let go = StringEntry(gm, ((toString(gl) + "_") + toString(gi)))
1017+                                            if (isDefined(gn))
10161018                                                 then {
1017-                                                    let go = value(gm)
1018-                                                    if ((split(go, "_")[0] == toString(gk)))
1019+                                                    let gp = value(gn)
1020+                                                    if ((split(gp, "_")[0] == toString(gl)))
10191021                                                         then throw("You already bet for tomorrow")
10201022                                                         else {
1021-                                                            let gp = fy(P, go)
1022-                                                            $Tuple2((gp._1 :+ gn), gp._2)
1023+                                                            let gq = fz(P, gp)
1024+                                                            $Tuple2((gq._1 :+ go), gq._2)
10231025                                                             }
10241026                                                     }
1025-                                                else $Tuple2([gn], 0)
1027+                                                else $Tuple2([go], 0)
10261028                                             }
10271029                                     }
10281030                             }
10321034 
10331035 
10341036 
1035-@Callable(fF)
1036-func takeWlgXp (P) = if ((fF.caller != H))
1037+@Callable(fG)
1038+func takeWlgXp (P) = if ((fG.caller != H))
10371039     then throw("Permission denied")
10381040     else {
1039-        let gq = fd(P, 0)
1040-        let gc = gq._1
1041-        let aR = gq._2
1042-        $Tuple2(gc, aR)
1041+        let gr = fe(P, 0)
1042+        let gd = gr._1
1043+        let aR = gr._2
1044+        $Tuple2(gd, aR)
10431045         }
10441046 
10451047 
10461048 
1047-@Callable(fF)
1049+@Callable(fG)
10481050 func checkWlgXpREADONLY (P) = {
1049-    let gr = fd(P, 0)
1050-    let gs = gr._1
1051-    let gt = gr._2
1052-    let aU = (valueOrElse(getInteger(H, aN(P)), 0) + gt)
1053-    let gu = aS(valueOrElse(getInteger(H, aO(P)), 0), aU)
1054-    $Tuple2(nil, (gu :+ aU))
1051+    let gs = fe(P, 0)
1052+    let gt = gs._1
1053+    let gu = gs._2
1054+    let aU = (valueOrElse(getInteger(H, aN(P)), 0) + gu)
1055+    let gv = aS(valueOrElse(getInteger(H, aO(P)), 0), aU)
1056+    $Tuple2(nil, (gv :+ aU))
10551057     }
10561058 
10571059 
10581060 
1059-@Callable(fF)
1060-func setNumPrizes (fl) = if ((fF.caller != this))
1061+@Callable(fG)
1062+func setNumPrizes (fm) = if ((fG.caller != this))
10611063     then throw("Permission denied")
10621064     else {
10631065         let U = (height / i)
1064-        $Tuple2([IntegerEntry(X(U), fl)], fl)
1066+        $Tuple2([IntegerEntry(X(U), fm)], fm)
10651067         }
10661068 
10671069 
10681070 
1069-@Callable(fF)
1071+@Callable(fG)
10701072 func openChest () = {
1071-    let fN = ez()
1072-    if ((fN == fN))
1073-        then if ((size(fF.payments) != 0))
1073+    let fO = eA()
1074+    if ((fO == fO))
1075+        then if ((size(fG.payments) != 0))
10741076             then throw("No payments required")
10751077             else {
1076-                let fk = ((height / i) - 1)
1077-                let P = toString(fF.caller)
1078-                let fn = valueOrElse(getInteger(T(P, fk)), 0)
1079-                if ((0 >= fn))
1078+                let fl = ((height / i) - 1)
1079+                let P = toString(fG.caller)
1080+                let fo = valueOrElse(getInteger(T(P, fl)), 0)
1081+                if ((0 >= fo))
10801082                     then throw("No gems to open the chest")
1081-                    else fj(P)
1083+                    else fk(P)
10821084                 }
10831085         else throw("Strict value is not equal to itself.")
10841086     }
10851087 
10861088 
10871089 
1088-@Callable(fF)
1089-func addGemsFor (P,fC) = if ((fF.caller != this))
1090+@Callable(fG)
1091+func addGemsFor (P,fD) = if ((fG.caller != this))
10901092     then throw("Permission denied")
10911093     else {
10921094         let U = (height / i)
1093-        let fv = T(P, U)
1094-        let fB = valueOrElse(getInteger(V(U)), 0)
1095-        let fw = valueOrElse(getInteger(fv), 0)
1096-        let fD = valueOrElse(getInteger(W(U)), 0)
1097-        let fE = if (if ((fw == 0))
1098-            then (fC == 1)
1095+        let fw = T(P, U)
1096+        let fC = valueOrElse(getInteger(V(U)), 0)
1097+        let fx = valueOrElse(getInteger(fw), 0)
1098+        let fE = valueOrElse(getInteger(W(U)), 0)
1099+        let fF = if (if ((fx == 0))
1100+            then (fD == 1)
10991101             else false)
1100-            then [IntegerEntry(W(U), (fD + 1))]
1102+            then [IntegerEntry(W(U), (fE + 1))]
11011103             else nil
1102-        $Tuple2(((fE :+ IntegerEntry(fv, (fw + fC))) :+ IntegerEntry(V(U), (fB + fC))), fC)
1104+        $Tuple2(((fF :+ IntegerEntry(fw, (fx + fD))) :+ IntegerEntry(V(U), (fC + fD))), fD)
11031105         }
11041106 
11051107 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = "__"
55 
66 let b = 1000000
77 
88 let c = 100000000
99 
1010 let d = 100000
1111 
1212 let e = 86400000
1313 
1414 let f = take(drop(this.bytes, 1), 1)
1515 
1616 let g = {
1717     let h = f
1818     if ((base58'2W' == h))
1919         then 1440
2020         else if ((base58'2T' == h))
2121             then 60
2222             else throw("Unknown chain")
2323     }
2424 
2525 let i = {
2626     let h = f
2727     if ((base58'2W' == h))
2828         then 10080
2929         else if ((base58'2T' == h))
3030             then 180
3131             else throw("Unknown chain")
3232     }
3333 
3434 let j = {
3535     let h = f
3636     if ((base58'2W' == h))
3737         then 0
3838         else if ((base58'2T' == h))
3939             then 1146000
4040             else throw("Unknown chain")
4141     }
4242 
4343 let k = {
4444     let h = f
4545     if ((base58'2W' == h))
4646         then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
4747         else if ((base58'2T' == h))
4848             then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
4949             else throw("Unknown chain")
5050     }
5151 
5252 let l = {
5353     let h = f
5454     if ((base58'2W' == h))
5555         then "3PFwYta8biEz31zpeFe5DJK8wE5trSpQVF8"
5656         else if ((base58'2T' == h))
5757             then "3N7UuYar6264P58FBhVWKPQAh4Yua2hgngv"
5858             else throw("Unknown chain")
5959     }
6060 
6161 let m = {
6262     let h = f
6363     if ((base58'2W' == h))
6464         then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
6565         else if ((base58'2T' == h))
6666             then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
6767             else throw("Unknown chain")
6868     }
6969 
7070 let n = {
7171     let h = f
7272     if ((base58'2W' == h))
7373         then "3P2sk1KncSxRaZs8b4CWGPw2jkvvav74u4D"
7474         else if ((base58'2T' == h))
7575             then "3N8y4wxX3JC4TdrCJBXX16SjWf6X256hrep"
7676             else throw("Unknown chain")
7777     }
7878 
7979 func o (p,q) = valueOrErrorMessage(getString(p, q), makeString(["mandatory ", toString(p), ".", q, " is not defined"], ""))
8080 
8181 
8282 let r = 1
8383 
8484 let s = 2
8585 
8686 let t = 4
8787 
8888 let u = 5
8989 
9090 func v () = "%s__restConfig"
9191 
9292 
9393 func w () = "%s__rest2Addr"
9494 
9595 
9696 func x () = "%s__restAddr"
9797 
9898 
9999 let y = addressFromStringValue(valueOrElse(getString(this, x()), m))
100100 
101101 func z (A) = split_4C(o(A, v()), a)
102102 
103103 
104104 func B (C,D) = valueOrErrorMessage(addressFromString(C[D]), ("Rest cfg doesn't contain address at index " + toString(D)))
105105 
106106 
107107 let E = 1
108108 
109109 let F = 8
110110 
111111 let G = z(y)
112112 
113113 let H = B(G, E)
114114 
115115 let I = B(G, F)
116116 
117117 let J = addressFromStringValue(valueOrElse(getString(this, w()), l))
118118 
119119 let C = z(J)
120120 
121121 let K = B(C, r)
122122 
123123 let L = B(C, s)
124124 
125125 let M = B(C, t)
126126 
127127 let N = B(C, u)
128128 
129129 func O (P) = ("lastWeekTxIdByUser_" + P)
130130 
131131 
132132 let Q = "wlg_assetId"
133133 
134134 let R = valueOrErrorMessage(getBinary(L, Q), "WLGOLD is not issued yet")
135135 
136136 func S (P) = ("userBet_" + P)
137137 
138138 
139139 func T (P,U) = ((("userWeekTickets_" + P) + "_") + toString(U))
140140 
141141 
142142 func V (U) = ("totalWeekTickets_" + toString(U))
143143 
144144 
145145 func W (U) = ("totalWeekParticipants_" + toString(U))
146146 
147147 
148148 func X (U) = ("numNFT2Draw_" + toString(U))
149149 
150150 
151151 func Y (U) = ("numNFTDrawn_" + toString(U))
152152 
153153 
154154 func Z (U) = ("weekWinners_" + toString(U))
155155 
156156 
157157 func aa (ab) = {
158158     let ac = (ab * g)
159159     let ad = if ((ac > j))
160160         then ac
161161         else (ac + j)
162162     (toInt(value(value(blockInfoByHeight(ad)).vrf)) % 4)
163163     }
164164 
165165 
166166 let ae = 0
167167 
168168 let af = 1
169169 
170170 let ag = 2
171171 
172172 let ah = 8
173173 
174174 let ai = 11
175175 
176176 let aj = 12
177177 
178178 let ak = 15
179179 
180180 let al = 16
181181 
182182 let am = 19
183183 
184184 let an = 23
185185 
186186 let ao = 24
187187 
188188 let ap = 25
189189 
190190 let aq = 26
191191 
192192 let ar = 27
193193 
194194 let as = 28
195195 
196196 let at = 29
197197 
198198 func au (av) = {
199199     let h = av
200200     if ($isInstanceOf(h, "Int"))
201201         then {
202202             let aw = h
203203             aw
204204             }
205205         else throw("fail to cast into Int")
206206     }
207207 
208208 
209209 func ax (ay,az) = {
210210     let aA = pow(10, 0, az, 0, 0, DOWN)
211211     let aB = toString((ay % aA))
212212     let aC = drop(toString(aA), (1 + size(aB)))
213213     (((toString((ay / aA)) + ".") + aC) + aB)
214214     }
215215 
216216 
217217 func aD (aE,aF,aG) = if ((0 >= aE))
218218     then throw("maxValue should be > 0")
219219     else {
220220         let aH = sha256_16Kb((aF + aG))
221221         (toInt(aH) % aE)
222222         }
223223 
224224 
225225 let aI = 100000000
226226 
227227 let aJ = 3200
228228 
229229 let aK = 4000
230230 
231231 let aL = 3
232232 
233233 let aM = 100000000000
234234 
235235 func aN (P) = ("userXP_" + P)
236236 
237237 
238238 func aO (P) = ("userLevel_" + P)
239239 
240240 
241241 let aP = 10000
242242 
243243 func aQ (aR) = fraction(aJ, pow(aR, 4, aK, 4, 4, DOWN), aI)
244244 
245245 
246246 func aS (aT,aU) = {
247247     let aV = aQ(aU)
248248 [aV, (aL * (aV - aT))]
249249     }
250250 
251251 
252252 let aW = 1000000
253253 
254254 let aX = 100000000
255255 
256256 let aY = 100000000000000
257257 
258258 let aZ = 200000
259259 
260260 let ba = 100000
261261 
262262 let bb = 400000
263263 
264264 let bc = 31557600000
265265 
266266 let bd = 86400000
267267 
268268 let be = 50000
269269 
270270 let bf = take(drop(this.bytes, 1), 1)
271271 
272272 let bg = {
273273     let h = bf
274274     if ((base58'2W' == h))
275275         then 1208630000
276276         else if ((base58'2T' == h))
277277             then 0
278278             else throw("Unknown chain")
279279     }
280280 
281281 let bh = "teamAddr"
282282 
283283 let bi = "lastClaimedTime_team"
284284 
285285 let bj = "teamAmountLeft"
286286 
287287 let bk = "lastClaimedTime_activities"
288288 
289289 let bl = "activitiesAmountLeft"
290290 
291291 let bm = "stakersAmountLeft"
292292 
293293 func bn (P) = ("lastClaimedTimeUserOld_" + P)
294294 
295295 
296296 func bo (P) = ("lastArbTimeUser_" + P)
297297 
298298 
299299 func bp (P) = ("lastWlgLimitUser_" + P)
300300 
301301 
302302 func bq (br) = fraction(aY, (bb * (br + 1)), (6 * aW))
303303 
304304 
305305 let bs = "wlg_issueTime"
306306 
307307 let bt = "wlg_issuedAmount"
308308 
309309 let bu = "zbill_issuedAmount"
310310 
311311 func bv (P) = ("acresStakedAmountByUser_" + P)
312312 
313313 
314314 let bw = "acresStakedAmountTotal"
315315 
316316 func bx (P) = ("wlgStakedAmountByUser_" + P)
317317 
318318 
319319 let by = "wlgStakedAmountTotal"
320320 
321321 func bz (P) = ("wlgStakedTimeByUser_" + P)
322322 
323323 
324324 let bA = 0
325325 
326326 let bB = 1
327327 
328328 let bC = 2
329329 
330330 let bD = 3
331331 
332332 let bE = 4
333333 
334334 let bF = 5
335335 
336336 let bG = 6
337337 
338338 func bH (bI,H,I) = {
339339     let bJ = split(valueOrElse(getString(H, "resTypesProportions"), "0_0_0_0_0_0"), "_")
340340     func bK (bL,bM) =     (bL + parseIntValue(bM))
341341 
342342     let bN = {
343343         let bO = bJ
344344         let bP = size(bO)
345345         let bQ = 0
346346         func bR (bS,bT) =         if ((bT >= bP))
347347             then bS
348348             else bK(bS, bO[bT])
349349 
350350         func bU (bS,bT) =         if ((bT >= bP))
351351             then bS
352352             else throw("List size exceeds 6")
353353 
354354         bU(bR(bR(bR(bR(bR(bR(bQ, 0), 1), 2), 3), 4), 5), 6)
355355         }
356356     let bV = valueOrElse(getInteger(H, ("stakedPiecesByOwner_" + bI)), 0)
357357     let bW = valueOrElse(getInteger(I, bw), 0)
358358     let bX = valueOrElse(getInteger(I, bv(bI)), 0)
359359 [bN, bV, bW, bX]
360360     }
361361 
362362 
363363 let bY = 0
364364 
365365 let bZ = 1
366366 
367367 let ca = 2
368368 
369369 let cb = 3
370370 
371-func cc (cd,ce,cf,cg,ch) = {
372-    let ci = valueOrErrorMessage(getInteger(ce[bD], bt), "WLGOLD is not issued yet")
373-    let cj = assetBalance(ce[bC], cf)
374-    let ck = assetBalance(ce[bA], cf)
375-    let cl = (assetBalance(ce[bD], cf) - cg)
376-    let cm = assetBalance(ce[bE], cf)
377-    let cn = ce[bF]
378-    let co = (assetBalance(cn, cf) + valueOrElse(getInteger(cn, bu), 0))
379-    let cp = ((cj + cl) + co)
380-    let cq = valueOrErrorMessage(getBinary(ce[bD], "wlg_assetId"), "Not initialized yet")
381-    let cr = lastBlock.timestamp
382-    let cs = valueOrErrorMessage(getInteger(ce[bD], bs), "Not initialized")
383-    let ct = assetBalance(ce[bB], cq)
384-    let cu = fraction(aY, aZ, aW)
385-    let cv = valueOrElse(getInteger(ce[bD], bj), cu)
386-    let cw = valueOrElse(getInteger(ce[bD], bi), cs)
387-    let cx = addressFromStringValue(value(getString(ce[bD], bh)))
388-    let cy = min([fraction(cu, (cr - cw), (3 * bc)), cv])
389-    let cz = assetBalance(cx, cq)
390-    let cA = fraction(aY, ba, aW)
391-    let cB = valueOrElse(getInteger(ce[bD], bl), cA)
392-    let cC = valueOrElse(getInteger(ce[bD], bk), cs)
393-    let cD = min([fraction(cA, (cr - cC), (3 * bc)), cB])
394-    let cE = assetBalance(ce[bA], cq)
395-    let cF = valueOrElse(getInteger(ce[bD], bn(cd)), cs)
396-    let cG = ((cF - cs) / bc)
397-    let cH = min([cr, (cs + (3 * bc))])
398-    let cI = min([((cr - cs) / bc), 2])
399-    let cJ = bH(cd, ce[bB], ce[bG])
400-    let cK = bq(cI)
401-    let cL = if ((cG == cI))
371+let cc = 1733335200000
372+
373+func cd (ce,cf,cg,ch,ci) = {
374+    let cj = valueOrErrorMessage(getInteger(cf[bD], bt), "WLGOLD is not issued yet")
375+    let ck = assetBalance(cf[bC], cg)
376+    let cl = assetBalance(cf[bA], cg)
377+    let cm = (assetBalance(cf[bD], cg) - ch)
378+    let cn = assetBalance(cf[bE], cg)
379+    let co = cf[bF]
380+    let cp = (assetBalance(co, cg) + valueOrElse(getInteger(co, bu), 0))
381+    let cq = ((ck + cm) + cp)
382+    let cr = valueOrErrorMessage(getBinary(cf[bD], "wlg_assetId"), "Not initialized yet")
383+    let cs = lastBlock.timestamp
384+    let ct = valueOrErrorMessage(getInteger(cf[bD], bs), "Not initialized")
385+    let cu = assetBalance(cf[bB], cr)
386+    let cv = fraction(aY, aZ, aW)
387+    let cw = valueOrElse(getInteger(cf[bD], bj), cv)
388+    let cx = valueOrElse(getInteger(cf[bD], bi), ct)
389+    let cy = addressFromStringValue(value(getString(cf[bD], bh)))
390+    let cz = min([fraction(cv, (cs - cx), (3 * bc)), cw])
391+    let cA = assetBalance(cy, cr)
392+    let cB = fraction(aY, ba, aW)
393+    let cC = valueOrElse(getInteger(cf[bD], bl), cB)
394+    let cD = valueOrElse(getInteger(cf[bD], bk), ct)
395+    let cE = min([fraction(cB, (cs - cD), (3 * bc)), cC])
396+    let cF = assetBalance(cf[bA], cr)
397+    let cG = valueOrElse(getInteger(cf[bD], bn(ce)), ct)
398+    let cH = ((cG - ct) / bc)
399+    let cI = min([min([cs, (ct + (3 * bc))]), cc])
400+    let cJ = min([((cs - ct) / bc), 2])
401+    let cK = bH(ce, cf[bB], cf[bG])
402+    let cL = bq(cJ)
403+    let cM = if ((cH == cJ))
402404         then {
403-            let cM = fraction(cK, (cH - cF), bc)
404-            let cN = fraction(cM, ch, aW)
405-            let cO = (cF + fraction((cH - cF), ch, aW))
406-            $Tuple3(cN, cM, cO)
405+            let cN = fraction(cL, (cI - cG), bc)
406+            let cO = fraction(cN, ci, aW)
407+            let cP = (cG + fraction((cI - cG), ci, aW))
408+            $Tuple3(cO, cN, cP)
407409             }
408-        else if ((cG == (cI - 1)))
410+        else if ((cH == (cJ - 1)))
409411             then {
410-                let cP = fraction(bq((cI - 1)), ((cs + (bc * cI)) - cF), bc)
411-                let cM = fraction(cK, (cH - (cs + (bc * cI))), bc)
412-                let cQ = (cP + cM)
413-                let cN = fraction(cQ, ch, aW)
414-                let cO = if ((cP >= cN))
415-                    then (cF + fraction(bc, cN, bq((cI - 1))))
416-                    else ((cs + (bc * cI)) + fraction(bc, (cN - cP), cK))
417-                $Tuple3(cN, cQ, cO)
412+                let cQ = fraction(bq((cJ - 1)), ((ct + (bc * cJ)) - cG), bc)
413+                let cN = fraction(cL, (cI - (ct + (bc * cJ))), bc)
414+                let cR = (cQ + cN)
415+                let cO = fraction(cR, ci, aW)
416+                let cP = if ((cQ >= cO))
417+                    then (cG + fraction(bc, cO, bq((cJ - 1))))
418+                    else ((ct + (bc * cJ)) + fraction(bc, (cO - cQ), cL))
419+                $Tuple3(cO, cR, cP)
418420                 }
419421             else {
420-                let cR = fraction(bq((cI - 2)), ((cs + (bc * (cI - 1))) - cF), bc)
421-                let cP = bq((cI - 1))
422-                let cM = fraction(cK, (cH - (cs + (bc * cI))), bc)
423-                let cQ = ((cR + cP) + cM)
424-                let cN = fraction(cQ, ch, aW)
425-                let cO = if ((cR >= cN))
426-                    then (cF + fraction(bc, cN, bq((cI - 2))))
427-                    else if (((cR + cP) >= cN))
428-                        then ((cs + (bc * (cI - 1))) + fraction(bc, (cN - cR), bq((cI - 1))))
429-                        else ((cs + (bc * cI)) + fraction(bc, ((cN - cR) - cP), cK))
430-                $Tuple3(cN, cQ, cO)
422+                let cS = fraction(bq((cJ - 2)), ((ct + (bc * (cJ - 1))) - cG), bc)
423+                let cQ = bq((cJ - 1))
424+                let cN = fraction(cL, (cI - (ct + (bc * cJ))), bc)
425+                let cR = ((cS + cQ) + cN)
426+                let cO = fraction(cR, ci, aW)
427+                let cP = if ((cS >= cO))
428+                    then (cG + fraction(bc, cO, bq((cJ - 2))))
429+                    else if (((cS + cQ) >= cO))
430+                        then ((ct + (bc * (cJ - 1))) + fraction(bc, (cO - cS), bq((cJ - 1))))
431+                        else ((ct + (bc * cJ)) + fraction(bc, ((cO - cS) - cQ), cL))
432+                $Tuple3(cO, cR, cP)
431433                 }
432-    let cS = cL._1
433-    let cT = cL._2
434-    let cU = cL._3
435-    let cV = fraction(fraction(cK, bd, bc), 25, cJ[bY])
436-    let cW = valueOrElse(getInteger(ce[bD], bm), 0)
437-    let cX = fraction(cS, ((cJ[bZ] * aX) + cJ[cb]), ((cJ[bY] * aX) + cJ[ca]))
438-    let cY = fraction(cX, be, aW)
439-    let cZ = (cX - cY)
440-    let da = fraction(cT, ((cJ[bZ] * aX) + cJ[cb]), ((cJ[bY] * aX) + cJ[ca]))
441-[ci, fraction((cp - bg), aX, ci), cp, cj, ck, cl, cm, cs, cw, cu, cv, cy, cz, cA, cB, cD, cE, cI, cW, cK, cF, cZ, cV, co, da, cU, ct]
434+    let cT = cM._1
435+    let cU = cM._2
436+    let cV = cM._3
437+    let cW = fraction(fraction(cL, bd, bc), 25, cK[bY])
438+    let cX = valueOrElse(getInteger(cf[bD], bm), 0)
439+    let cY = fraction(cT, ((cK[bZ] * aX) + cK[cb]), ((cK[bY] * aX) + cK[ca]))
440+    let cZ = fraction(cY, be, aW)
441+    let da = (cY - cZ)
442+    let db = fraction(cU, ((cK[bZ] * aX) + cK[cb]), ((cK[bY] * aX) + cK[ca]))
443+[cj, fraction((cq - bg), aX, cj), cq, ck, cl, cm, cn, ct, cx, cv, cw, cz, cA, cB, cC, cE, cF, cJ, cX, cL, cG, da, cW, cp, db, cV, cu]
442444     }
443445 
444446 
445-let db = 1000000
447+let dc = 1000000
446448 
447-let dc = 100000000
449+let dd = 100000000
448450 
449-let dd = 200000
451+let de = 200000
450452 
451-let de = 100000
453+let df = 100000
452454 
453-let df = 400000
455+let dg = 400000
454456 
455-let dg = 31557600000
457+let dh = 31557600000
456458 
457-let dh = 86400000
459+let di = 86400000
458460 
459-let di = 1000000000
461+let dj = 1000000000
460462 
461-let dj = 800000
462-
463-let dk = 100000
463+let dk = 800000
464464 
465465 let dl = 100000
466466 
467-let dm = 1731279600000
467+let dm = 100000
468468 
469-let dn = "marketingAddr"
469+let dn = 1731279600000
470470 
471-let do = "teamAddr"
471+let do = "marketingAddr"
472472 
473-let dp = "lastClaimedTime_team"
473+let dp = "teamAddr"
474474 
475-let dq = "teamAmountLeft"
475+let dq = "lastClaimedTime_team"
476476 
477-let dr = "lastClaimedTime_activities"
477+let dr = "teamAmountLeft"
478478 
479-let ds = "activitiesAmountLeft"
479+let ds = "lastClaimedTime_activities"
480480 
481-let dt = "stakersAmountLeft"
481+let dt = "activitiesAmountLeft"
482482 
483-func du (P) = ("lastClaimedTimeUser_" + P)
483+let du = "stakersAmountLeft"
484+
485+func dv (P) = ("lastClaimedTimeUser_" + P)
484486 
485487 
486-func dv (ci,br) = fraction(ci, (df * (br + 1)), (6 * db))
488+func dw (cj,br) = fraction(cj, (dg * (br + 1)), (6 * dc))
487489 
488490 
489-let dw = "wlg_issue10Time"
491+let dx = "wlg_issue10Time"
490492 
491-let dx = "wlg_issueTime"
493+let dy = "wlg_issueTime"
492494 
493-let dy = "wlg_issuedAmount"
495+let dz = "wlg_issuedAmount"
494496 
495-let dz = "zbill_issuedAmount"
497+let dA = "zbill_issuedAmount"
496498 
497-func dA (P) = ("acresStakedAmountByUser_" + P)
499+func dB (P) = ("acresStakedAmountByUser_" + P)
498500 
499501 
500-let dB = "acresStakedAmountTotal"
502+let dC = "acresStakedAmountTotal"
501503 
502-let dC = "totalFarmingPower"
504+let dD = "totalFarmingPower"
503505 
504-let dD = 0
506+let dE = 0
505507 
506-let dE = 1
508+let dF = 1
507509 
508-let dF = 2
510+let dG = 2
509511 
510-let dG = 3
512+let dH = 3
511513 
512-let dH = 4
514+let dI = 4
513515 
514-let dI = 5
516+let dJ = 5
515517 
516-let dJ = 100000000
518+let dK = 100000000
517519 
518-let dK = "nftTotalIssued"
520+let dL = "nftTotalIssued"
519521 
520-let dL = "nftTotalBurned"
522+let dM = "nftTotalBurned"
521523 
522-let dM = "WlNftTotalStaked"
524+let dN = "WlNftTotalStaked"
523525 
524-func dN (P) = ("userWlNftNumber_" + P)
526+func dO (P) = ("userWlNftNumber_" + P)
525527 
526528 
527-func dO (P) = ("userFullBonus_" + P)
529+func dP (P) = ("userFullBonus_" + P)
528530 
529531 
530-let dP = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
532+let dQ = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
531533 
532-func dQ (dR) = {
533-    let dS = ((dR + 99999999) / dc)
534-    func dT (bL,bM) =     if ((bM >= dS))
534+func dR (dS) = {
535+    let dT = ((dS + 99999999) / dd)
536+    func dU (bL,bM) =     if ((bM >= dT))
535537         then bL
536538         else (bL + 1)
537539 
538-    let bO = dP
540+    let bO = dQ
539541     let bP = size(bO)
540542     let bQ = 0
541543     func bR (bS,bT) =     if ((bT >= bP))
542544         then bS
543-        else dT(bS, bO[bT])
545+        else dU(bS, bO[bT])
544546 
545547     func bU (bS,bT) =     if ((bT >= bP))
546548         then bS
547549         else throw("List size exceeds 10")
548550 
549551     bU(bR(bR(bR(bR(bR(bR(bR(bR(bR(bR(bQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
550552     }
551553 
552554 
553-func dU (dR) = ((dR * 20) * (dQ(dR) + 4))
555+func dV (dS) = ((dS * 20) * (dR(dS) + 4))
554556 
555557 
556-func dV (dR,dW) = {
557-    let dX = dU(dR)
558-    $Tuple2(fraction(dX, (db + dW), db), dX)
558+func dW (dS,dX) = {
559+    let dY = dV(dS)
560+    $Tuple2(fraction(dY, (dc + dX), dc), dY)
559561     }
560562 
561563 
562-func dY (bI,K) = {
563-    let dZ = valueOrElse(getInteger(K, dC), 0)
564-    let bX = valueOrElse(getInteger(K, dA(bI)), 0)
565-    let ea = valueOrElse(getInteger(K, dO(bI)), 0)
566-    let cL = dV(bX, ea)
567-    let eb = cL._1
568-    let ec = cL._2
569-[dZ, eb, ec, ea]
564+func dZ (bI,K) = {
565+    let ea = valueOrElse(getInteger(K, dD), 0)
566+    let bX = valueOrElse(getInteger(K, dB(bI)), 0)
567+    let eb = valueOrElse(getInteger(K, dP(bI)), 0)
568+    let cM = dW(bX, eb)
569+    let ec = cM._1
570+    let ed = cM._2
571+[ea, ec, ed, eb]
570572     }
571573 
572574 
573-let ed = 0
575+let ee = 0
574576 
575-let ee = 1
577+let ef = 1
576578 
577-func ef (cd,ce,cf,cg) = {
578-    let ci = valueOrErrorMessage(getInteger(ce[dF], dy), "WLGOLD is not issued yet")
579-    let ck = assetBalance(ce[dD], cf)
580-    let cl = (assetBalance(ce[dF], cf) - cg)
581-    let cm = assetBalance(ce[dG], cf)
582-    let eg = assetBalance(ce[dE], cf)
583-    let cn = ce[dH]
584-    let co = (assetBalance(cn, cf) + valueOrElse(getInteger(cn, dz), 0))
585-    let cp = ((eg + cl) + co)
586-    let cq = valueOrErrorMessage(getBinary(ce[dF], "wlg_assetId"), "Not initialized yet")
587-    let cr = lastBlock.timestamp
588-    let cs = valueOrErrorMessage(getInteger(ce[dF], dx), "Not initialized")
589-    let eh = assetBalance(ce[dF], cq)
590-    let cu = fraction(ci, dd, db)
591-    let cv = valueOrElse(getInteger(ce[dF], dq), cu)
592-    let cw = valueOrElse(getInteger(ce[dF], dp), cs)
593-    let cx = addressFromStringValue(value(getString(ce[dF], do)))
594-    let cy = min([fraction(cu, (cr - cw), (3 * dg)), cv])
595-    let cz = assetBalance(cx, cq)
596-    let cA = fraction(ci, de, db)
597-    let cB = valueOrElse(getInteger(ce[dF], ds), cA)
598-    let cC = valueOrElse(getInteger(ce[dF], dr), cs)
599-    let cD = min([fraction(cA, (cr - cC), (3 * dg)), cB])
600-    let cE = assetBalance(ce[dD], cq)
601-    let cF = valueOrElse(getInteger(ce[dF], du(cd)), cs)
602-    let cG = ((cF - cs) / dg)
603-    let cH = min([cr, (cs + (3 * dg))])
604-    let cI = min([((cr - cs) / dg), 2])
605-    let cJ = dY(cd, ce[dE])
606-    let cK = dv(ci, cI)
607-    let ei = (cs + (dg * cI))
608-    let ej = (cs + (dg * (cI - 1)))
609-    let cM = fraction(cK, (cH - cF), dg)
610-    let cT = if ((cG == cI))
611-        then cM
612-        else if ((cG == (cI - 1)))
579+func eg (ce,cf,cg,ch) = {
580+    let cj = valueOrErrorMessage(getInteger(cf[dG], dz), "WLGOLD is not issued yet")
581+    let cl = assetBalance(cf[dE], cg)
582+    let cm = (assetBalance(cf[dG], cg) - ch)
583+    let cn = assetBalance(cf[dH], cg)
584+    let eh = assetBalance(cf[dF], cg)
585+    let co = cf[dI]
586+    let cp = (assetBalance(co, cg) + valueOrElse(getInteger(co, dA), 0))
587+    let cq = ((eh + cm) + cp)
588+    let cr = valueOrErrorMessage(getBinary(cf[dG], "wlg_assetId"), "Not initialized yet")
589+    let cs = lastBlock.timestamp
590+    let ct = valueOrErrorMessage(getInteger(cf[dG], dy), "Not initialized")
591+    let ei = assetBalance(cf[dG], cr)
592+    let cv = fraction(cj, de, dc)
593+    let cw = valueOrElse(getInteger(cf[dG], dr), cv)
594+    let cx = valueOrElse(getInteger(cf[dG], dq), ct)
595+    let cy = addressFromStringValue(value(getString(cf[dG], dp)))
596+    let cz = min([fraction(cv, (cs - cx), (3 * dh)), cw])
597+    let cA = assetBalance(cy, cr)
598+    let cB = fraction(cj, df, dc)
599+    let cC = valueOrElse(getInteger(cf[dG], dt), cB)
600+    let cD = valueOrElse(getInteger(cf[dG], ds), ct)
601+    let cE = min([fraction(cB, (cs - cD), (3 * dh)), cC])
602+    let cF = assetBalance(cf[dE], cr)
603+    let cG = valueOrElse(getInteger(cf[dG], dv(ce)), ct)
604+    let cH = ((cG - ct) / dh)
605+    let cI = min([cs, (ct + (3 * dh))])
606+    let cJ = min([((cs - ct) / dh), 2])
607+    let cK = dZ(ce, cf[dF])
608+    let cL = dw(cj, cJ)
609+    let ej = (ct + (dh * cJ))
610+    let ek = (ct + (dh * (cJ - 1)))
611+    let cN = fraction(cL, (cI - cG), dh)
612+    let cU = if ((cH == cJ))
613+        then cN
614+        else if ((cH == (cJ - 1)))
613615             then {
614-                let cP = fraction(dv(ci, (cI - 1)), (ei - cF), dg)
615-                (cP + cM)
616+                let cQ = fraction(dw(cj, (cJ - 1)), (ej - cG), dh)
617+                (cQ + cN)
616618                 }
617619             else {
618-                let cR = fraction(dv(ci, (cI - 2)), (ej - cF), dg)
619-                let cP = dv(ci, (cI - 1))
620-                ((cR + cP) + cM)
620+                let cS = fraction(dw(cj, (cJ - 2)), (ek - cG), dh)
621+                let cQ = dw(cj, (cJ - 1))
622+                ((cS + cQ) + cN)
621623                 }
622-    let cW = valueOrElse(getInteger(ce[dF], dt), 0)
623-    let cS = if ((cJ[ed] != 0))
624-        then fraction(cT, cJ[ee], cJ[ed])
624+    let cX = valueOrElse(getInteger(cf[dG], du), 0)
625+    let cT = if ((cK[ee] != 0))
626+        then fraction(cU, cK[ef], cK[ee])
625627         else 0
626-    let ek = valueOrElse(getInteger(ce[dF], dw), dm)
627-    let el = fraction(di, max([(cr - ek), 0]), dh)
628-    let em = fraction(el, dk, db)
629-    let en = fraction(el, dl, db)
630-    let eo = max([(cr - max([dm, cF])), 0])
631-    let ep = if ((cJ[ed] != 0))
632-        then fraction(fraction(fraction(di, eo, dh), cJ[ee], cJ[ed]), dj, db)
628+    let el = valueOrElse(getInteger(cf[dG], dx), dn)
629+    let em = fraction(dj, max([(cs - el), 0]), di)
630+    let en = fraction(em, dl, dc)
631+    let eo = fraction(em, dm, dc)
632+    let ep = max([(cs - max([dn, cG])), 0])
633+    let eq = if ((cK[ee] != 0))
634+        then fraction(fraction(fraction(dj, ep, di), cK[ef], cK[ee]), dk, dc)
633635         else 0
634-    let eq = max([dm, cr])
635-    let er = valueOrElse(getInteger(ce[dE], dB), 0)
636-    let es = valueOrElse(getInteger(ce[dE], dK), 0)
637-    let et = valueOrElse(getInteger(ce[dE], dL), 0)
638-    let eu = valueOrElse(getInteger(ce[dE], dM), 0)
639-    let ev = valueOrElse(getInteger(ce[dE], dN(valueOrElse(cd, ""))), 0)
640-[ci, eh, fraction(cp, dc, ci), cp, ck, eg, cl, cm, cs, cw, cu, cv, cy, cz, cA, cB, cD, cE, cI, cW, cK, cF, co, cS, cH, el, em, en, ep, eq, cJ[ed], er, es, et, eu, ev]
636+    let er = max([dn, cs])
637+    let es = valueOrElse(getInteger(cf[dF], dC), 0)
638+    let et = valueOrElse(getInteger(cf[dF], dL), 0)
639+    let eu = valueOrElse(getInteger(cf[dF], dM), 0)
640+    let ev = valueOrElse(getInteger(cf[dF], dN), 0)
641+    let ew = valueOrElse(getInteger(cf[dF], dO(valueOrElse(ce, ""))), 0)
642+[cj, ei, fraction(cq, dd, cj), cq, cl, eh, cm, cn, ct, cx, cv, cw, cz, cA, cB, cC, cE, cF, cJ, cX, cL, cG, cp, cT, cI, em, en, eo, eq, er, cK[ee], es, et, eu, ev, ew]
641643     }
642644 
643645 
644-let ew = "profitAddr"
646+let ex = "profitAddr"
645647 
646-let ex = "stakersAmountPaidTotal"
648+let ey = "stakersAmountPaidTotal"
647649 
648-func ey (P) = ("stakersAmountPaidUser_" + P)
650+func ez (P) = ("stakersAmountPaidUser_" + P)
649651 
650652 
651-func ez () = au(reentrantInvoke(K, "saveLastTx", nil, nil))
653+func eA () = au(reentrantInvoke(K, "saveLastTx", nil, nil))
652654 
653655 
654-func eA (P) = {
655-    let eB = valueOrElse(getInteger(bo(P)), 0)
656-    let eC = valueOrElse(getInteger(K, bv(P)), 0)
657-    let eD = valueOrElse(getInteger(bp(P)), eC)
658-    let eE = (eD + fraction(eC, (lastBlock.timestamp - eB), e))
659-    min([eE, eC])
656+func eB (P) = {
657+    let eC = valueOrElse(getInteger(bo(P)), 0)
658+    let eD = valueOrElse(getInteger(K, bv(P)), 0)
659+    let eE = valueOrElse(getInteger(bp(P)), eD)
660+    let eF = (eE + fraction(eD, (lastBlock.timestamp - eC), e))
661+    min([eF, eD])
660662     }
661663 
662664 
663-let eF = 10
665+let eG = 10
664666 
665-let eG = 11
667+let eH = 11
666668 
667-let eH = 14
669+let eI = 14
668670 
669-let eI = 15
671+let eJ = 15
670672 
671-let eJ = 18
673+let eK = 18
672674 
673-let eK = 21
675+let eL = 21
674676 
675-let eL = 24
677+let eM = 24
676678 
677-let eM = 25
679+let eN = 25
678680 
679-func eN (P) = {
680-    let eO = addressFromStringValue(P)
681-    let eP = addressFromStringValue(n)
682-    let eQ = cc(P, [y, H, eP, L, M, N, I], k, 0, b)
683-    let cr = lastBlock.timestamp
684-    let cv = eQ[eF]
685-    let eR = eQ[eG]
686-    let cB = eQ[eH]
687-    let eS = eQ[eI]
688-    let cS = eQ[eK]
689-    let eT = ey(P)
690-    let eU = eQ[eL]
691-    let eV = eQ[eM]
692-    $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(bh))), eR, R), ScriptTransfer(y, eS, R), IntegerEntry(eT, (valueOrElse(getInteger(eT), 0) + cS)), IntegerEntry(ex, (valueOrElse(getInteger(ex), 0) + eU)), IntegerEntry(bm, (eQ[eJ] - eU)), IntegerEntry(bj, (cv - eR)), IntegerEntry(bi, cr), IntegerEntry(bl, (cB - eS)), IntegerEntry(bk, cr), IntegerEntry(bn(P), eV)], cS)
681+func eO (P) = {
682+    let eP = addressFromStringValue(P)
683+    let eQ = addressFromStringValue(n)
684+    let eR = cd(P, [y, H, eQ, L, M, N, I], k, 0, b)
685+    let cs = lastBlock.timestamp
686+    let cw = eR[eG]
687+    let eS = eR[eH]
688+    let cC = eR[eI]
689+    let eT = eR[eJ]
690+    let cT = eR[eL]
691+    let eU = ez(P)
692+    let eV = eR[eM]
693+    let eW = eR[eN]
694+    $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(bh))), eS, R), ScriptTransfer(y, eT, R), IntegerEntry(eU, (valueOrElse(getInteger(eU), 0) + cT)), IntegerEntry(ey, (valueOrElse(getInteger(ey), 0) + eV)), IntegerEntry(bm, (eR[eK] - eV)), IntegerEntry(bj, (cw - eS)), IntegerEntry(bi, cs), IntegerEntry(bl, (cC - eT)), IntegerEntry(bk, cs), IntegerEntry(bn(P), eW)], cT)
693695     }
694696 
695697 
696-func eW (P) = {
697-    let eQ = ef(P, [J, K, L, M, N], k, 0)
698-    let eX = du(P)
699-    let cF = valueOrElse(getInteger(eX), 0)
700-    let eV = eQ[ao]
701-    if ((cF == eV))
698+func eX (P) = {
699+    let eR = eg(P, [J, K, L, M, N], k, 0)
700+    let eY = dv(P)
701+    let cG = valueOrElse(getInteger(eY), 0)
702+    let eW = eR[ao]
703+    if ((cG == eW))
702704         then $Tuple2(nil, 0)
703705         else {
704-            let cr = lastBlock.timestamp
705-            let cs = eQ[ah]
706-            let cv = eQ[ai]
707-            let eR = (eQ[aj] + eQ[ar])
708-            let eY = if ((eR > 0))
709-                then [ScriptTransfer(addressFromStringValue(value(getString(bh))), eR, R)]
706+            let cs = lastBlock.timestamp
707+            let ct = eR[ah]
708+            let cw = eR[ai]
709+            let eS = (eR[aj] + eR[ar])
710+            let eZ = if ((eS > 0))
711+                then [ScriptTransfer(addressFromStringValue(value(getString(bh))), eS, R)]
710712                 else nil
711-            let cB = eQ[ak]
712-            let eS = eQ[al]
713-            let eZ = if ((eS > 0))
714-                then [ScriptTransfer(y, eS, R)]
713+            let cC = eR[ak]
714+            let eT = eR[al]
715+            let fa = if ((eT > 0))
716+                then [ScriptTransfer(y, eT, R)]
715717                 else nil
716-            let fa = eQ[aq]
717-            let fb = if ((fa > 0))
718-                then [ScriptTransfer(addressFromStringValue(value(getString(dn))), fa, R)]
718+            let fb = eR[aq]
719+            let fc = if ((fb > 0))
720+                then [ScriptTransfer(addressFromStringValue(value(getString(do))), fb, R)]
719721                 else nil
720-            let cS = eQ[an]
721-            let eT = ey(P)
722-            let eU = (cS + eQ[as])
723-            let fc = eQ[ap]
724-            $Tuple2(((([Reissue(R, fc, true), IntegerEntry(bt, (eQ[ae] + fc)), IntegerEntry(dw, eQ[at]), IntegerEntry(eT, (valueOrElse(getInteger(eT), 0) + cS)), IntegerEntry(ex, (valueOrElse(getInteger(ex), 0) + cS)), IntegerEntry(bm, (eQ[am] - cS)), IntegerEntry(bj, ((cv - eR) + eQ[ar])), IntegerEntry(bi, cr), IntegerEntry(bl, (cB - eS)), IntegerEntry(bk, cr), IntegerEntry(eX, eV)] ++ eY) ++ eZ) ++ fb), eU)
722+            let cT = eR[an]
723+            let eU = ez(P)
724+            let eV = (cT + eR[as])
725+            let fd = eR[ap]
726+            $Tuple2(((([Reissue(R, fd, true), IntegerEntry(bt, (eR[ae] + fd)), IntegerEntry(dx, eR[at]), IntegerEntry(eU, (valueOrElse(getInteger(eU), 0) + cT)), IntegerEntry(ey, (valueOrElse(getInteger(ey), 0) + cT)), IntegerEntry(bm, (eR[am] - cT)), IntegerEntry(bj, ((cw - eS) + eR[ar])), IntegerEntry(bi, cs), IntegerEntry(bl, (cC - eT)), IntegerEntry(bk, cs), IntegerEntry(eY, eW)] ++ eZ) ++ fa) ++ fc), eV)
725727             }
726728     }
727729 
728730 
729-func fd (P,fe) = {
730-    let cr = lastBlock.timestamp
731-    let ff = bz(P)
732-    let fg = bx(P)
733-    let eB = valueOrElse(getInteger(ff), 0)
734-    let fh = valueOrElse(getInteger(fg), 0)
735-    let fi = valueOrElse(getInteger(by), 0)
736-    let aR = fraction(fraction(aP, fh, aM), (eB - cr), bd)
737-    $Tuple3([IntegerEntry(ff, cr), IntegerEntry(fg, (fh + fe)), IntegerEntry(by, (fi + fe))], aR, fh)
731+func fe (P,ff) = {
732+    let cs = lastBlock.timestamp
733+    let fg = bz(P)
734+    let fh = bx(P)
735+    let eC = valueOrElse(getInteger(fg), 0)
736+    let fi = valueOrElse(getInteger(fh), 0)
737+    let fj = valueOrElse(getInteger(by), 0)
738+    let aR = fraction(fraction(aP, fi, aM), (eC - cs), bd)
739+    $Tuple3([IntegerEntry(fg, cs), IntegerEntry(fh, (fi + ff)), IntegerEntry(by, (fj + ff))], aR, fi)
738740     }
739741 
740742 
741-func fj (P) = {
743+func fk (P) = {
742744     let U = (height / i)
743-    let fk = (U - 1)
744-    let fl = valueOrElse(getInteger(X(fk)), dI)
745-    let fm = valueOrElse(getInteger(Y(fk)), 0)
746-    let fn = valueOrElse(getInteger(T(P, fk)), 0)
747-    if ((0 >= fn))
745+    let fl = (U - 1)
746+    let fm = valueOrElse(getInteger(X(fl)), dJ)
747+    let fn = valueOrElse(getInteger(Y(fl)), 0)
748+    let fo = valueOrElse(getInteger(T(P, fl)), 0)
749+    if ((0 >= fo))
748750         then $Tuple2(nil, unit)
749751         else {
750-            let fo = valueOrElse(getInteger(V(fk)), 0)
751-            if ((0 >= fo))
752-                then $Tuple2([DeleteEntry(T(P, fk))], unit)
752+            let fp = valueOrElse(getInteger(V(fl)), 0)
753+            if ((0 >= fp))
754+                then $Tuple2([DeleteEntry(T(P, fl))], unit)
753755                 else {
754756                     let aG = value(value(blockInfoByHeight((U * i))).vrf)
755757                     let aF = fromBase58String(split(valueOrElse(getString(K, O(P)), "42_DEFAULT"), "_")[1])
756-                    let fp = aD(fo, aF, aG)
757-                    if (((fn * fl) > fp))
758+                    let fq = aD(fp, aF, aG)
759+                    if (((fo * fm) > fq))
758760                         then {
759-                            let fq = invoke(K, "issuePickC1", [P], nil)
760-                            let fr = getString(Z(fk))
761-                            let fs = if (isDefined(fr))
762-                                then ((value(fr) + "_") + P)
761+                            let fr = invoke(K, "issuePickC1", [P], nil)
762+                            let fs = getString(Z(fl))
763+                            let ft = if (isDefined(fs))
764+                                then ((value(fs) + "_") + P)
763765                                 else P
764-                            $Tuple2([IntegerEntry(Y(fk), (fm + 1)), DeleteEntry(T(P, fk)), StringEntry(Z(fk), fs)], fq)
766+                            $Tuple2([IntegerEntry(Y(fl), (fn + 1)), DeleteEntry(T(P, fl)), StringEntry(Z(fl), ft)], fr)
765767                             }
766768                         else {
767-                            let ft = (aD(9, (base58'29' + aF), aG) + 1)
768-                            let fu = fraction(fn, ft, 10)
769-                            let fv = T(P, U)
770-                            let fw = valueOrElse(getInteger(fv), 0)
771-                            $Tuple2(((if ((fu == 0))
769+                            let fu = (aD(9, (base58'29' + aF), aG) + 1)
770+                            let fv = fraction(fo, fu, 10)
771+                            let fw = T(P, U)
772+                            let fx = valueOrElse(getInteger(fw), 0)
773+                            $Tuple2(((if ((fv == 0))
772774                                 then nil
773775                                 else {
774-                                    let fx = [IntegerEntry(V(U), (valueOrElse(getInteger(V(U)), 0) + fu)), IntegerEntry(fv, (fw + fu))]
775-                                    if ((fw > 0))
776-                                        then fx
777-                                        else (fx :+ IntegerEntry(W(U), (valueOrElse(getInteger(W(U)), 0) + 1)))
778-                                    }) :+ DeleteEntry(T(P, fk))), fu)
776+                                    let fy = [IntegerEntry(V(U), (valueOrElse(getInteger(V(U)), 0) + fv)), IntegerEntry(fw, (fx + fv))]
777+                                    if ((fx > 0))
778+                                        then fy
779+                                        else (fy :+ IntegerEntry(W(U), (valueOrElse(getInteger(W(U)), 0) + 1)))
780+                                    }) :+ DeleteEntry(T(P, fl))), fv)
779781                             }
780782                     }
781783             }
782784     }
783785 
784786 
785-func fy (P,fz) = {
787+func fz (P,fA) = {
786788     let U = (height / i)
787-    let fv = T(P, U)
788-    let fA = split(fz, "_")
789-    let fB = valueOrElse(getInteger(V(U)), 0)
790-    let fw = valueOrElse(getInteger(fv), 0)
791-    let fC = if ((aa(parseIntValue(fA[0])) == parseIntValue(fA[1])))
789+    let fw = T(P, U)
790+    let fB = split(fA, "_")
791+    let fC = valueOrElse(getInteger(V(U)), 0)
792+    let fx = valueOrElse(getInteger(fw), 0)
793+    let fD = if ((aa(parseIntValue(fB[0])) == parseIntValue(fB[1])))
792794         then 1
793795         else 0
794-    let fD = valueOrElse(getInteger(W(U)), 0)
795-    let fE = if (if ((fw == 0))
796-        then (fC == 1)
796+    let fE = valueOrElse(getInteger(W(U)), 0)
797+    let fF = if (if ((fx == 0))
798+        then (fD == 1)
797799         else false)
798-        then [IntegerEntry(W(U), (fD + 1))]
800+        then [IntegerEntry(W(U), (fE + 1))]
799801         else nil
800-    $Tuple2(if ((fC == 0))
802+    $Tuple2(if ((fD == 0))
801803         then nil
802-        else ((fE :+ IntegerEntry(fv, (fw + fC))) :+ IntegerEntry(V(U), (fB + fC))), fC)
804+        else ((fF :+ IntegerEntry(fw, (fx + fD))) :+ IntegerEntry(V(U), (fC + fD))), fD)
803805     }
804806 
805807 
806-@Callable(fF)
807-func constructorV1 (fG,fH,cx,fI) = if ((fF.caller != this))
808+@Callable(fG)
809+func constructorV1 (fH,fI,cy,fJ) = if ((fG.caller != this))
808810     then throw("Permission denied")
809811     else if (isDefined(getBinary(Q)))
810812         then throw("Already initialized")
811813         else {
812-            let ci = aY
813-            let fJ = Issue("WLGOLD", "WavesLands Gold investment token", ci, 8, true, unit, 0)
814-            let fK = calculateAssetId(fJ)
815-[fJ, IntegerEntry(bs, lastBlock.timestamp), IntegerEntry(bt, ci), IntegerEntry(ex, 0), IntegerEntry(bm, fraction(aY, bb, b)), BinaryEntry(Q, fK), StringEntry(x(), fG), StringEntry(dn, fH), StringEntry(bh, cx), StringEntry(ew, fI)]
814+            let cj = aY
815+            let fK = Issue("WLGOLD", "WavesLands Gold investment token", cj, 8, true, unit, 0)
816+            let fL = calculateAssetId(fK)
817+[fK, IntegerEntry(bs, lastBlock.timestamp), IntegerEntry(bt, cj), IntegerEntry(ey, 0), IntegerEntry(bm, fraction(aY, bb, b)), BinaryEntry(Q, fL), StringEntry(x(), fH), StringEntry(do, fI), StringEntry(bh, cy), StringEntry(ex, fJ)]
816818             }
817819 
818820 
819821 
820-@Callable(fF)
821-func constructorV2 (fL) = if ((fF.caller != this))
822+@Callable(fG)
823+func constructorV2 (fM) = if ((fG.caller != this))
822824     then throw("Permission denied")
823-    else [StringEntry(w(), fL)]
825+    else [StringEntry(w(), fM)]
824826 
825827 
826828 
827-@Callable(fF)
828-func buyWlg (fM) = {
829-    let fN = ez()
830-    if ((fN == fN))
831-        then if ((size(fF.payments) != 1))
829+@Callable(fG)
830+func buyWlg (fN) = {
831+    let fO = eA()
832+    if ((fO == fO))
833+        then if ((size(fG.payments) != 1))
832834             then throw("exactly 1 payment must be attached")
833835             else {
834-                let fO = fF.payments[0]
835-                let fP = fO.amount
836-                if (if (!(isDefined(fO.assetId)))
836+                let fP = fG.payments[0]
837+                let fQ = fP.amount
838+                if (if (!(isDefined(fP.assetId)))
837839                     then true
838-                    else (value(fO.assetId) != k))
840+                    else (value(fP.assetId) != k))
839841                     then throw("USDT payments only!")
840842                     else {
841-                        let eO = fF.caller
842-                        let P = toString(eO)
843-                        if ((d > fP))
843+                        let eP = fG.caller
844+                        let P = toString(eP)
845+                        if ((d > fQ))
844846                             then throw((("You can trade min " + ax(d, 6)) + " USDT"))
845847                             else {
846-                                let eQ = ef("", [J, K, L, M, N], k, fP)
847-                                let fQ = eQ[ae]
848-                                let fR = eQ[ag]
849-                                let fS = fraction(fR, 6, 5, CEILING)
850-                                let fT = fraction(fP, c, fS)
851-                                let fU = eA(P)
852-                                if ((fT > fU))
853-                                    then throw((("You can get max " + ax(fU, 8)) + " WLGOLD at the moment"))
854-                                    else if ((fM > fT))
848+                                let eR = eg("", [J, K, L, M, N], k, fQ)
849+                                let fR = eR[ae]
850+                                let fS = eR[ag]
851+                                let fT = fraction(fS, 6, 5, CEILING)
852+                                let fU = fraction(fQ, c, fT)
853+                                let fV = eB(P)
854+                                if ((fU > fV))
855+                                    then throw((("You can get max " + ax(fV, 8)) + " WLGOLD at the moment"))
856+                                    else if ((fN > fU))
855857                                         then throw("Price changed during operation, please try again")
856858                                         else {
857-                                            let fV = (fP / 6)
858-                                            $Tuple2([Reissue(R, fT, true), IntegerEntry(bt, (fQ + fT)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fU - fT)), ScriptTransfer(addressFromStringValue(value(getString(ew))), fV, k), ScriptTransfer(eO, fT, R)], fN)
859+                                            let fW = (fQ / 6)
860+                                            $Tuple2([Reissue(R, fU, true), IntegerEntry(bt, (fR + fU)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fV - fU)), ScriptTransfer(addressFromStringValue(value(getString(ex))), fW, k), ScriptTransfer(eP, fU, R)], fO)
859861                                             }
860862                                 }
861863                         }
862864                 }
863865         else throw("Strict value is not equal to itself.")
864866     }
865867 
866868 
867869 
868-@Callable(fF)
869-func buyWlgREADONLY (p,fP) = {
870-    let eQ = ef("", [J, K, L, M, N], k, fP)
871-    let fR = eQ[ag]
872-    let fS = fraction(fR, 6, 5, CEILING)
873-    let fT = fraction(fP, c, fS)
874-    let fU = eA(p)
875-    let fW = fraction(fU, fS, c)
876-    let fV = (fP / 6)
877-    $Tuple2(nil, [fT, d, fW, fV])
870+@Callable(fG)
871+func buyWlgREADONLY (p,fQ) = {
872+    let eR = eg("", [J, K, L, M, N], k, fQ)
873+    let fS = eR[ag]
874+    let fT = fraction(fS, 6, 5, CEILING)
875+    let fU = fraction(fQ, c, fT)
876+    let fV = eB(p)
877+    let fX = fraction(fV, fT, c)
878+    let fW = (fQ / 6)
879+    $Tuple2(nil, [fU, d, fX, fW])
878880     }
879881 
880882 
881883 
882-@Callable(fF)
883-func sellWlg (fX) = {
884-    let fN = ez()
885-    if ((fN == fN))
886-        then if ((size(fF.payments) != 1))
884+@Callable(fG)
885+func sellWlg (fY) = {
886+    let fO = eA()
887+    if ((fO == fO))
888+        then if ((size(fG.payments) != 1))
887889             then throw("exactly 1 payment must be attached")
888890             else {
889-                let fO = fF.payments[0]
890-                let fY = fO.amount
891-                let eO = fF.caller
892-                let P = toString(eO)
893-                let fU = eA(P)
894-                if ((fY > fU))
895-                    then throw((("You can spend max " + ax(fU, 8)) + " WLGOLD at the moment"))
896-                    else if (if (!(isDefined(fO.assetId)))
891+                let fP = fG.payments[0]
892+                let fZ = fP.amount
893+                let eP = fG.caller
894+                let P = toString(eP)
895+                let fV = eB(P)
896+                if ((fZ > fV))
897+                    then throw((("You can spend max " + ax(fV, 8)) + " WLGOLD at the moment"))
898+                    else if (if (!(isDefined(fP.assetId)))
897899                         then true
898-                        else (value(fO.assetId) != R))
900+                        else (value(fP.assetId) != R))
899901                         then throw("WLGOLD payments only!")
900902                         else {
901-                            let eQ = ef("", [J, K, L, M, N], k, 0)
902-                            let fQ = eQ[ae]
903-                            let fZ = (eQ[ag] / 2)
904-                            let fP = fraction(fY, fZ, c)
905-                            if ((d > fP))
903+                            let eR = eg("", [J, K, L, M, N], k, 0)
904+                            let fR = eR[ae]
905+                            let ga = (eR[ag] / 2)
906+                            let fQ = fraction(fZ, ga, c)
907+                            if ((d > fQ))
906908                                 then throw((("You can trade min " + ax(d, 6)) + " USDT"))
907-                                else if ((fX > fP))
909+                                else if ((fY > fQ))
908910                                     then throw("Price changed during operation, please try again")
909911                                     else {
910-                                        let fV = (fP / 5)
911-                                        $Tuple2([Burn(R, fY), IntegerEntry(bt, (fQ - fY)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fU - fY)), ScriptTransfer(addressFromStringValue(value(getString(ew))), fV, k), ScriptTransfer(eO, fP, k)], fN)
912+                                        let fW = (fQ / 5)
913+                                        $Tuple2([Burn(R, fZ), IntegerEntry(bt, (fR - fZ)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fV - fZ)), ScriptTransfer(addressFromStringValue(value(getString(ex))), fW, k), ScriptTransfer(eP, fQ, k)], fO)
912914                                         }
913915                             }
914916                 }
915917         else throw("Strict value is not equal to itself.")
916918     }
917919 
918920 
919921 
920-@Callable(fF)
921-func sellWlgREADONLY (p,fY) = {
922-    let fU = eA(p)
923-    let eQ = ef("", [J, K, L, M, N], k, 0)
924-    let fZ = (eQ[ag] / 2)
925-    let fP = fraction(fY, fZ, c)
926-    let ga = fraction(d, c, fZ)
927-    let fV = (fP / 5)
928-    $Tuple2(nil, [fP, ga, fU, fV])
922+@Callable(fG)
923+func sellWlgREADONLY (p,fZ) = {
924+    let fV = eB(p)
925+    let eR = eg("", [J, K, L, M, N], k, 0)
926+    let ga = (eR[ag] / 2)
927+    let fQ = fraction(fZ, ga, c)
928+    let gb = fraction(d, c, ga)
929+    let fW = (fQ / 5)
930+    $Tuple2(nil, [fQ, gb, fV, fW])
929931     }
930932 
931933 
932934 
933-@Callable(fF)
935+@Callable(fG)
934936 func claim () = {
935-    let fN = ez()
936-    if ((fN == fN))
937-        then if ((size(fF.payments) != 0))
937+    let fO = eA()
938+    if ((fO == fO))
939+        then if ((size(fG.payments) != 0))
938940             then throw("No payments required")
939941             else {
940-                let gb = eW(toString(fF.caller))
941-                let gc = gb._1
942-                let gd = gb._2
943-                $Tuple2((gc :+ ScriptTransfer(fF.caller, gd, R)), fN)
942+                let gc = eX(toString(fG.caller))
943+                let gd = gc._1
944+                let ge = gc._2
945+                $Tuple2((gd :+ ScriptTransfer(fG.caller, ge, R)), fO)
944946                 }
945947         else throw("Strict value is not equal to itself.")
946948     }
947949 
948950 
949951 
950-@Callable(fF)
951-func onStakeUnstakeLand (P,ge) = if (if (if ((fF.caller != H))
952-    then (fF.caller != I)
952+@Callable(fG)
953+func onStakeUnstakeLand (P,gf) = if (if (if ((fG.caller != H))
954+    then (fG.caller != I)
953955     else false)
954-    then (fF.caller != K)
956+    then (fG.caller != K)
955957     else false)
956958     then throw("Permission denied")
957959     else {
958-        let gf = if (ge)
959-            then eW(P)
960-            else eN(P)
961-        let gc = gf._1
962-        let gd = gf._2
963-        $Tuple2(if ((gd > 0))
964-            then (gc :+ ScriptTransfer(addressFromStringValue(P), gd, R))
965-            else gc, gd)
960+        let gg = if (gf)
961+            then eX(P)
962+            else eO(P)
963+        let gd = gg._1
964+        let ge = gg._2
965+        $Tuple2(if ((ge > 0))
966+            then (gd :+ ScriptTransfer(addressFromStringValue(P), ge, R))
967+            else gd, ge)
966968         }
967969 
968970 
969971 
970-@Callable(fF)
971-func burnWlgold (fY) = if ((fF.caller != K))
972+@Callable(fG)
973+func burnWlgold (fZ) = if ((fG.caller != K))
972974     then throw("Permission denied")
973975     else {
974-        let eQ = ef("", [J, K, L, M, N], k, 0)
975-        if ((fY > eQ[af]))
976-            then throw(((("Only " + ax(eQ[af], 8)) + " WLGOLD left on contract, can't burn ") + ax(fY, 8)))
976+        let eR = eg("", [J, K, L, M, N], k, 0)
977+        if ((fZ > eR[af]))
978+            then throw(((("Only " + ax(eR[af], 8)) + " WLGOLD left on contract, can't burn ") + ax(fZ, 8)))
977979             else {
978-                let gg = (eQ[ae] - fY)
979-                $Tuple2([Burn(R, fY), IntegerEntry(bt, gg)], gg)
980+                let gh = (eR[ae] - fZ)
981+                $Tuple2([Burn(R, fZ), IntegerEntry(bt, gh)], gh)
980982                 }
981983         }
982984 
983985 
984986 
985-@Callable(fF)
986-func betForTicket (gh) = {
987-    let fN = ez()
988-    if ((fN == fN))
989-        then if ((size(fF.payments) != 0))
987+@Callable(fG)
988+func betForTicket (gi) = {
989+    let fO = eA()
990+    if ((fO == fO))
991+        then if ((size(fG.payments) != 0))
990992             then throw("No payments required")
991993             else {
992-                let P = toString(fF.caller)
993-                let fk = ((height / i) - 1)
994-                let fn = valueOrElse(getInteger(T(P, fk)), 0)
995-                let fo = valueOrElse(getInteger(V(fk)), 0)
996-                if (if ((fn > 0))
997-                    then (fo > 0)
994+                let P = toString(fG.caller)
995+                let fl = ((height / i) - 1)
996+                let fo = valueOrElse(getInteger(T(P, fl)), 0)
997+                let fp = valueOrElse(getInteger(V(fl)), 0)
998+                if (if ((fo > 0))
999+                    then (fp > 0)
9981000                     else false)
9991001                     then throw("Please open the chest first")
1000-                    else if (((gh / 4) != 0))
1002+                    else if (((gi / 4) != 0))
10011003                         then throw("Invalid bet: should be 0..3")
10021004                         else {
1003-                            let gi = (height % g)
1004-                            if ((gi > (g - 3)))
1005-                                then throw((("Cannot bet: the day is almost ended, please wait " + toString((g - gi))) + " blocks"))
1005+                            let gj = (height % g)
1006+                            if ((gj > (g - 3)))
1007+                                then throw((("Cannot bet: the day is almost ended, please wait " + toString((g - gj))) + " blocks"))
10061008                                 else {
1007-                                    let gj = valueOrElse(getInteger(K, dA(P)), 0)
1008-                                    if ((dJ > gj))
1009-                                        then throw((("You need to stake at least " + ax(dJ, 8)) + " ACRES to bet"))
1009+                                    let gk = valueOrElse(getInteger(K, dB(P)), 0)
1010+                                    if ((dK > gk))
1011+                                        then throw((("You need to stake at least " + ax(dK, 8)) + " ACRES to bet"))
10101012                                         else {
1011-                                            let gk = ((height / g) + 1)
1012-                                            let gl = S(P)
1013-                                            let gm = getString(gl)
1014-                                            let gn = StringEntry(gl, ((toString(gk) + "_") + toString(gh)))
1015-                                            if (isDefined(gm))
1013+                                            let gl = ((height / g) + 1)
1014+                                            let gm = S(P)
1015+                                            let gn = getString(gm)
1016+                                            let go = StringEntry(gm, ((toString(gl) + "_") + toString(gi)))
1017+                                            if (isDefined(gn))
10161018                                                 then {
1017-                                                    let go = value(gm)
1018-                                                    if ((split(go, "_")[0] == toString(gk)))
1019+                                                    let gp = value(gn)
1020+                                                    if ((split(gp, "_")[0] == toString(gl)))
10191021                                                         then throw("You already bet for tomorrow")
10201022                                                         else {
1021-                                                            let gp = fy(P, go)
1022-                                                            $Tuple2((gp._1 :+ gn), gp._2)
1023+                                                            let gq = fz(P, gp)
1024+                                                            $Tuple2((gq._1 :+ go), gq._2)
10231025                                                             }
10241026                                                     }
1025-                                                else $Tuple2([gn], 0)
1027+                                                else $Tuple2([go], 0)
10261028                                             }
10271029                                     }
10281030                             }
10291031                 }
10301032         else throw("Strict value is not equal to itself.")
10311033     }
10321034 
10331035 
10341036 
1035-@Callable(fF)
1036-func takeWlgXp (P) = if ((fF.caller != H))
1037+@Callable(fG)
1038+func takeWlgXp (P) = if ((fG.caller != H))
10371039     then throw("Permission denied")
10381040     else {
1039-        let gq = fd(P, 0)
1040-        let gc = gq._1
1041-        let aR = gq._2
1042-        $Tuple2(gc, aR)
1041+        let gr = fe(P, 0)
1042+        let gd = gr._1
1043+        let aR = gr._2
1044+        $Tuple2(gd, aR)
10431045         }
10441046 
10451047 
10461048 
1047-@Callable(fF)
1049+@Callable(fG)
10481050 func checkWlgXpREADONLY (P) = {
1049-    let gr = fd(P, 0)
1050-    let gs = gr._1
1051-    let gt = gr._2
1052-    let aU = (valueOrElse(getInteger(H, aN(P)), 0) + gt)
1053-    let gu = aS(valueOrElse(getInteger(H, aO(P)), 0), aU)
1054-    $Tuple2(nil, (gu :+ aU))
1051+    let gs = fe(P, 0)
1052+    let gt = gs._1
1053+    let gu = gs._2
1054+    let aU = (valueOrElse(getInteger(H, aN(P)), 0) + gu)
1055+    let gv = aS(valueOrElse(getInteger(H, aO(P)), 0), aU)
1056+    $Tuple2(nil, (gv :+ aU))
10551057     }
10561058 
10571059 
10581060 
1059-@Callable(fF)
1060-func setNumPrizes (fl) = if ((fF.caller != this))
1061+@Callable(fG)
1062+func setNumPrizes (fm) = if ((fG.caller != this))
10611063     then throw("Permission denied")
10621064     else {
10631065         let U = (height / i)
1064-        $Tuple2([IntegerEntry(X(U), fl)], fl)
1066+        $Tuple2([IntegerEntry(X(U), fm)], fm)
10651067         }
10661068 
10671069 
10681070 
1069-@Callable(fF)
1071+@Callable(fG)
10701072 func openChest () = {
1071-    let fN = ez()
1072-    if ((fN == fN))
1073-        then if ((size(fF.payments) != 0))
1073+    let fO = eA()
1074+    if ((fO == fO))
1075+        then if ((size(fG.payments) != 0))
10741076             then throw("No payments required")
10751077             else {
1076-                let fk = ((height / i) - 1)
1077-                let P = toString(fF.caller)
1078-                let fn = valueOrElse(getInteger(T(P, fk)), 0)
1079-                if ((0 >= fn))
1078+                let fl = ((height / i) - 1)
1079+                let P = toString(fG.caller)
1080+                let fo = valueOrElse(getInteger(T(P, fl)), 0)
1081+                if ((0 >= fo))
10801082                     then throw("No gems to open the chest")
1081-                    else fj(P)
1083+                    else fk(P)
10821084                 }
10831085         else throw("Strict value is not equal to itself.")
10841086     }
10851087 
10861088 
10871089 
1088-@Callable(fF)
1089-func addGemsFor (P,fC) = if ((fF.caller != this))
1090+@Callable(fG)
1091+func addGemsFor (P,fD) = if ((fG.caller != this))
10901092     then throw("Permission denied")
10911093     else {
10921094         let U = (height / i)
1093-        let fv = T(P, U)
1094-        let fB = valueOrElse(getInteger(V(U)), 0)
1095-        let fw = valueOrElse(getInteger(fv), 0)
1096-        let fD = valueOrElse(getInteger(W(U)), 0)
1097-        let fE = if (if ((fw == 0))
1098-            then (fC == 1)
1095+        let fw = T(P, U)
1096+        let fC = valueOrElse(getInteger(V(U)), 0)
1097+        let fx = valueOrElse(getInteger(fw), 0)
1098+        let fE = valueOrElse(getInteger(W(U)), 0)
1099+        let fF = if (if ((fx == 0))
1100+            then (fD == 1)
10991101             else false)
1100-            then [IntegerEntry(W(U), (fD + 1))]
1102+            then [IntegerEntry(W(U), (fE + 1))]
11011103             else nil
1102-        $Tuple2(((fE :+ IntegerEntry(fv, (fw + fC))) :+ IntegerEntry(V(U), (fB + fC))), fC)
1104+        $Tuple2(((fF :+ IntegerEntry(fw, (fx + fD))) :+ IntegerEntry(V(U), (fC + fD))), fD)
11031105         }
11041106 
11051107 
github/deemru/w8io/169f3d6 
318.51 ms ◑