tx · 8izLCTE3yVT8ynDQSJ812eRMzX6mRA5en3n7nGg9PZUM

3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA:  -0.04100000 Waves

2023.06.01 15:34 [2603600] smart account 3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8izLCTE3yVT8ynDQSJ812eRMzX6mRA5en3n7nGg9PZUM",
    "fee": 4100000,
    "feeAssetId": null,
    "timestamp": 1685622914690,
    "version": 2,
    "chainId": 84,
    "sender": "3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA",
    "senderPublicKey": "35yd3qw1gxKDxKwGAykHN9fANbXNWwseaUwbWDj24o3x",
    "proofs": [
        "2ovHsYn37BWkaKG4W3diNfoaRzCTeJAhLh2GxUnrP4Aq97VttwPqx6AtebFESEpEXikDw2ZhuytDcPMSzTz5bt8J"
    ],
    "script": "base64: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",
    "height": 2603600,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 588uvrDNcdPngaEhLh3jM28edjA1n14UNE7ndBUQpB5h
Next: FScn96AwLBy9S2vmMXsNbH85BaCQgmUyFnU5YN7THGmp

Diff: 

OldNewDifferences
2323 
2424 let k = "WAVES"
2525 
26-let l = "100"
26+let l = 50
2727 
28-let m = "1"
28+let m = "100"
2929 
30-let n = "__"
30+let n = "1"
3131 
32-let o = ""
32+let o = "__"
3333 
34-let p = 1
34+let p = ""
3535 
36-let q = 2
36+let q = 1
3737 
38-let r = 3
38+let r = 2
3939 
40-let s = 4
40+let s = 3
4141 
42-let t = 1
42+let t = 4
4343 
44-let u = 2
44+let u = 1
4545 
46-let v = 3
46+let v = 2
4747 
48-let w = 4
48+let w = 3
4949 
50-let x = 5
50+let x = 4
5151 
52-let y = 6
52+let y = 5
5353 
54-let z = 7
54+let z = 6
5555 
56-let A = 8
56+let A = 7
5757 
58-let B = 9
58+let B = 8
5959 
60-let C = 1
60+let C = 9
6161 
62-let D = 6
62+let D = 1
6363 
64-let E = 7
64+let E = 6
6565 
66-let F = 10
66+let F = 7
6767 
68-let G = fraction(10, a, 10000)
68+let G = 10
6969 
70-func H (I,J) = fraction(toBigInt(I), c, toBigInt(J))
70+let H = fraction(10, a, 10000)
71+
72+func I (J,K) = fraction(toBigInt(J), c, toBigInt(K))
7173 
7274 
73-func K (I,J) = fraction(I, c, J)
75+func L (J,K) = fraction(J, c, K)
7476 
7577 
76-func L (M,N) = toInt(fraction(M, toBigInt(N), c))
78+func M (N,O) = toInt(fraction(N, toBigInt(O), c))
7779 
7880 
79-func O (M,N,P) = toInt(fraction(M, toBigInt(N), c, P))
81+func P (N,O,Q) = toInt(fraction(N, toBigInt(O), c, Q))
8082 
8183 
82-func Q (I,J) = fraction(I, c, toBigInt(J))
84+func R (J,K) = fraction(J, c, toBigInt(K))
8385 
8486 
85-func R (M,N) = fraction(M, toBigInt(N), c)
87+func S (N,O) = fraction(N, toBigInt(O), c)
8688 
8789 
88-func S (T,U,V) = fraction(T, U, V)
90+func T (U,V,W) = fraction(U, V, W)
8991 
9092 
91-func W (M) = if ((d > M))
92-    then -(M)
93-    else M
93+func X (N) = if ((d > N))
94+    then -(N)
95+    else N
9496 
9597 
96-func X (M) = if ((d > M))
97-    then -(M)
98-    else M
98+func Y (N) = if ((d > N))
99+    then -(N)
100+    else N
99101 
100102 
101-func Y () = "%s__factoryContract"
103+func Z () = "%s__factoryContract"
102104 
103105 
104-func Z () = "%s__managerPublicKey"
106+func aa () = "%s__managerPublicKey"
105107 
106108 
107-func aa () = "%s__managerVaultAddress"
109+func ab () = "%s__managerVaultAddress"
108110 
109111 
110-func ab () = "%s%s__price__last"
112+func ac () = "%s%s__price__last"
111113 
112114 
113-func ac (ad,ae) = makeString(["%s%s%d%d__price__history", toString(ad), toString(ae)], n)
115+func ad (ae,af) = makeString(["%s%s%d%d__price__history", toString(ae), toString(af)], o)
114116 
115117 
116-func af (ag,ah) = ((("%s%s%s__P__" + ag) + "__") + ah)
118+func ag (ah,ai) = ((("%s%s%s__P__" + ah) + "__") + ai)
117119 
118120 
119-func ai (ag,ah) = ((("%s%s%s__G__" + ag) + "__") + ah)
121+func aj (ah,ai) = ((("%s%s%s__G__" + ah) + "__") + ai)
120122 
121123 
122-func aj () = "%s__amountAsset"
124+func ak () = "%s__amountAsset"
123125 
124126 
125-func ak () = "%s__priceAsset"
127+func al () = "%s__priceAsset"
126128 
127129 
128-func al () = "%s__amp"
130+func am () = "%s__amp"
129131 
130132 
131-func am (an) = ("%s%d__amp__" + toString(an))
133+func an (ao) = ("%s%d__amp__" + toString(ao))
132134 
133135 
134-func ao () = "%s__changeAmpLastCall"
136+func ap () = "%s__changeAmpLastCall"
135137 
136138 
137-let ap = "%s__fee"
139+let aq = "%s__fee"
138140 
139-let aq = valueOrElse(getInteger(this, ap), G)
141+let ar = valueOrElse(getInteger(this, aq), H)
140142 
141-let ar = makeString(["%s", "dLp"], n)
143+let as = makeString(["%s", "dLp"], o)
142144 
143-let as = makeString(["%s", "dLpRefreshedHeight"], n)
145+let at = makeString(["%s", "dLpRefreshedHeight"], o)
144146 
145-let at = makeString(["%s", "refreshDLpDelay"], n)
147+let au = makeString(["%s", "refreshDLpDelay"], o)
146148 
147-let au = 30
149+let av = 30
148150 
149-let av = valueOrElse(getInteger(this, at), au)
151+let aw = valueOrElse(getInteger(this, au), av)
150152 
151-func aw () = "%s__factoryConfig"
153+func ax () = "%s__factoryConfig"
152154 
153155 
154-func ax () = "%s%s__matcher__publicKey"
156+func ay () = "%s%s__matcher__publicKey"
155157 
156158 
157-func ay (az,aA) = (((("%d%d%s__" + az) + "__") + aA) + "__config")
159+func az (aA,aB) = (((("%d%d%s__" + aA) + "__") + aB) + "__config")
158160 
159161 
160-func aB (aC) = ("%s%s%s__mappings__baseAsset2internalId__" + aC)
162+func aC (aD) = ("%s%s%s__mappings__baseAsset2internalId__" + aD)
161163 
162164 
163-func aD () = "%s__shutdown"
165+func aE () = "%s__shutdown"
164166 
165167 
166-func aE () = "%s__allowedLpStableScriptHash"
168+func aF () = "%s__allowedLpStableScriptHash"
167169 
168170 
169-func aF () = "%s__feeCollectorAddress"
171+func aG () = "%s__feeCollectorAddress"
170172 
171173 
172-func aG (aH) = ("%s%s__skipOrderValidation__" + aH)
174+func aH (aI) = ("%s%s__skipOrderValidation__" + aI)
173175 
174176 
175-func aI (aJ,aK,aL,aM) = throw((((((((("order validation failed: orderValid=" + toString(aJ)) + " (") + aK) + ")") + " senderValid=") + toString(aL)) + " matcherValid=") + toString(aM)))
177+func aJ (aK,aL,aM,aN) = throw((((((((("order validation failed: orderValid=" + toString(aK)) + " (") + aL) + ")") + " senderValid=") + toString(aM)) + " matcherValid=") + toString(aN)))
176178 
177179 
178-func aN (aO) = {
179-    let aP = addressFromString(aO)
180-    if ($isInstanceOf(aP, "Address"))
180+func aO (aP) = {
181+    let aQ = addressFromString(aP)
182+    if ($isInstanceOf(aQ, "Address"))
181183         then {
182-            let aQ = aP
183-            aQ
184+            let aR = aQ
185+            aR
184186             }
185187         else this
186188     }
187189 
188190 
189-func aR () = {
190-    let aS = {
191-        let aP = getString(Y())
192-        if ($isInstanceOf(aP, "String"))
191+func aS () = {
192+    let aT = {
193+        let aQ = getString(Z())
194+        if ($isInstanceOf(aQ, "String"))
193195             then {
194-                let aT = aP
195-                aN(aT)
196+                let aU = aQ
197+                aO(aU)
196198                 }
197199             else this
198200         }
199-    let aP = getString(aS, aa())
200-    if ($isInstanceOf(aP, "String"))
201+    let aQ = getString(aT, ab())
202+    if ($isInstanceOf(aQ, "String"))
201203         then {
202-            let aU = aP
203-            aN(aU)
204+            let aV = aQ
205+            aO(aV)
204206             }
205207         else this
206208     }
207209 
208210 
209-func aV (aW,aX) = valueOrErrorMessage(getString(aW, aX), makeString(["mandatory ", toString(aW), ".", aX, " not defined"], ""))
211+func aW (aX,aY) = valueOrErrorMessage(getString(aX, aY), makeString(["mandatory ", toString(aX), ".", aY, " not defined"], ""))
210212 
211213 
212-func aY (aW,aX) = valueOrErrorMessage(getInteger(aW, aX), makeString(["mandatory ", toString(aW), ".", aX, " not defined"], ""))
214+func aZ (aX,aY) = valueOrErrorMessage(getInteger(aX, aY), makeString(["mandatory ", toString(aX), ".", aY, " not defined"], ""))
213215 
214216 
215-func aZ (ba) = throw(makeString(["lp_stable.ride:", ba], " "))
217+func ba (bb) = throw(makeString(["lp_stable.ride:", bb], " "))
216218 
217219 
218-func bb (ba) = makeString(["lp_stable.ride:", ba], " ")
220+func bc (bb) = makeString(["lp_stable.ride:", bb], " ")
219221 
220222 
221-let aT = addressFromStringValue(aV(this, Y()))
223+let aU = addressFromStringValue(aW(this, Z()))
222224 
223-let bc = {
224-    let bd = invoke(aT, "getInFeeREADONLY", [toString(this)], nil)
225-    if ($isInstanceOf(bd, "Int"))
226-        then bd
227-        else throw(($getType(bd) + " couldn't be cast to Int"))
225+let bd = {
226+    let be = invoke(aU, "getInFeeREADONLY", [toString(this)], nil)
227+    if ($isInstanceOf(be, "Int"))
228+        then be
229+        else throw(($getType(be) + " couldn't be cast to Int"))
228230     }
229231 
230-let be = {
231-    let bd = invoke(aT, "getOutFeeREADONLY", [toString(this)], nil)
232-    if ($isInstanceOf(bd, "Int"))
233-        then bd
234-        else throw(($getType(bd) + " couldn't be cast to Int"))
232+let bf = {
233+    let be = invoke(aU, "getOutFeeREADONLY", [toString(this)], nil)
234+    if ($isInstanceOf(be, "Int"))
235+        then be
236+        else throw(($getType(be) + " couldn't be cast to Int"))
235237     }
236238 
237-let bf = aV(this, al())
239+let bg = aW(this, am())
238240 
239-func bg () = valueOrElse(getBoolean(aT, aD()), false)
241+func bh () = valueOrElse(getBoolean(aU, aE()), false)
240242 
241243 
242-func bh () = fromBase58String(aV(aT, ax()))
244+func bi () = fromBase58String(aW(aU, ay()))
243245 
244246 
245-let bi = addressFromStringValue(aV(aT, aF()))
247+let bj = addressFromStringValue(aW(aU, aG()))
246248 
247-func bj () = {
248-    let bk = aV(this, aj())
249-    let bl = aV(this, ak())
250-    let bm = aY(aT, aB(bl))
251-    let az = aY(aT, aB(bk))
252-    split(aV(aT, ay(toString(az), toString(bm))), n)
249+func bk () = {
250+    let bl = aW(this, ak())
251+    let bm = aW(this, al())
252+    let bn = aZ(aU, aC(bm))
253+    let aA = aZ(aU, aC(bl))
254+    split(aW(aU, az(toString(aA), toString(bn))), o)
253255     }
254256 
255257 
256-func bn (bo) = if ((bo == k))
258+func bo (bp) = if ((bp == k))
257259     then unit
258-    else fromBase58String(bo)
260+    else fromBase58String(bp)
259261 
260262 
261-func bp (bo) = if ((bo == unit))
263+func bq (bp) = if ((bp == unit))
262264     then k
263-    else toBase58String(value(bo))
265+    else toBase58String(value(bp))
264266 
265267 
266-func bq (br) = $Tuple9(addressFromStringValue(br[t]), parseIntValue(br[u]), fromBase58String(br[v]), bn(br[w]), bn(br[x]), parseIntValue(br[y]), parseIntValue(br[z]), fromBase58String(br[A]), fromBase58String(br[B]))
268+func br (bs) = $Tuple7(addressFromStringValue(bs[u]), parseIntValue(bs[v]), fromBase58String(bs[w]), bo(bs[x]), bo(bs[y]), parseIntValue(bs[z]), parseIntValue(bs[A]))
267269 
268270 
269-let bs = bq(bj())
271+let bt = br(bk())
270272 
271-let bt = bs
273+let bu = bt
272274 
273-let bu = bt._1
275+let bv = bu._1
274276 
275-let bv = bt._2
277+let bw = bu._2
276278 
277-let bw = bt._3
279+let bx = bu._3
278280 
279-let bx = bt._4
281+let by = bu._4
280282 
281-let by = bt._5
283+let bz = bu._5
282284 
283-let bz = bt._6
285+let bA = bu._6
284286 
285-let bA = bt._7
287+let bB = bu._7
286288 
287-let bB = bt._8
288-
289-let bC = bt._9
290-
291-func bD () = split(aV(aT, aw()), n)
289+func bC () = split(aW(aU, ax()), o)
292290 
293291 
294-let bE = bD()
292+let bD = bC()
295293 
296-let bF = valueOrErrorMessage(addressFromString(bE[C]), "Invalid staking contract address")
294+let bE = valueOrErrorMessage(addressFromString(bD[D]), "Invalid staking contract address")
297295 
298-let bG = valueOrErrorMessage(addressFromString(bE[E]), "Invalid slipage contract address")
296+let bF = valueOrErrorMessage(addressFromString(bD[F]), "Invalid slipage contract address")
299297 
300-let bH = valueOrErrorMessage(addressFromString(bE[F]), "Invalid gwx contract address")
298+let bG = valueOrErrorMessage(addressFromString(bD[G]), "Invalid gwx contract address")
301299 
302-let bI = valueOrErrorMessage(addressFromString(bE[D]), "Invalid gwx contract address")
300+let bH = valueOrErrorMessage(addressFromString(bD[E]), "Invalid gwx contract address")
303301 
304-func bJ (bK,bL,bM,bN,bO,bP,bQ,bR,bS,bT) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bK), toString(bL), toString(bM), toString(bN), toString(bO), toString(bP), toString(bQ), toString(bR), toString(bS), toString(bT)], n)
302+func bI (bJ,bK,bL,bM,bN,bO,bP,bQ,bR,bS) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bJ), toString(bK), toString(bL), toString(bM), toString(bN), toString(bO), toString(bP), toString(bQ), toString(bR), toString(bS)], o)
305303 
306304 
307-func bU (bV,bW,bX,bN,bQ,bR) = makeString(["%d%d%d%d%d%d", toString(bV), toString(bW), toString(bX), toString(bN), toString(bQ), toString(bR)], n)
305+func bT (bU,bV,bW,bM,bP,bQ) = makeString(["%d%d%d%d%d%d", toString(bU), toString(bV), toString(bW), toString(bM), toString(bP), toString(bQ)], o)
308306 
309307 
310-func bY (bZ) = if ((bZ == "WAVES"))
308+func bX (bY) = if ((bY == "WAVES"))
311309     then wavesBalance(this).available
312-    else assetBalance(this, fromBase58String(bZ))
310+    else assetBalance(this, fromBase58String(bY))
313311 
314312 
315-func ca (cb,cc) = fraction(cb, c, cc)
313+func bZ (ca,cb) = fraction(ca, c, cb)
316314 
317315 
318-func cd (cb,cc,P) = fraction(cb, c, cc, P)
316+func cc (ca,cb,Q) = fraction(ca, c, cb, Q)
319317 
320318 
321-func ce (cf,cg,ch) = {
322-    let ci = fraction((cf - cg), b, cg)
323-    let cj = ((ch - W(ci)) > d)
324-    if (!(cj))
325-        then throw(("Big slpg: " + toString(ci)))
326-        else $Tuple2(cj, min([cf, cg]))
319+func cd (ce,cf,cg) = {
320+    let ch = fraction((ce - cf), b, cf)
321+    let ci = ((cg - X(ch)) > d)
322+    if (!(ci))
323+        then throw(("Big slpg: " + toString(ch)))
324+        else $Tuple2(ci, min([ce, cf]))
327325     }
328326 
329327 
330-func ck (cl,cm,cn) = {
331-    let ci = fraction(cm, b, cl)
332-    let co = (cn > ci)
333-    if (if (co)
328+func cj (ck,cl,cm) = {
329+    let ch = fraction(cl, b, ck)
330+    let cn = (cm > ch)
331+    if (if (cn)
334332         then true
335-        else (cm > cl))
336-        then throw(((((((toString(cm) + " ") + toString(cl)) + " ") + toString(ci)) + " ") + toString(cn)))
337-        else co
333+        else (cl > ck))
334+        then throw(((((((toString(cl) + " ") + toString(ck)) + " ") + toString(ch)) + " ") + toString(cm)))
335+        else cn
338336     }
339337 
340338 
341-func cp (cq,cr,cs,ct) = {
342-    let cu = H(cs, cq)
343-    let cv = H(ct, cr)
344-    ca(cv, cu)
339+func co (cp,cq,cr,cs) = {
340+    let ct = I(cr, cp)
341+    let cu = I(cs, cq)
342+    bZ(cu, ct)
345343     }
346344 
347345 
348-func cw (cs,ct,cx) = {
349-    let cy = bz
350-    let cz = bA
351-    let cA = cp(cy, cz, cs, ct)
352-    let cc = H(cs, cy)
353-    let cb = H(ct, cz)
354-    let cB = H(cx, a)
355-    let cC = ca(cc, cB)
356-    let cD = ca(cb, cB)
357-[cA, cC, cD]
346+func cv (cr,cs,cw) = {
347+    let cx = bA
348+    let cy = bB
349+    let cz = co(cx, cy, cr, cs)
350+    let cb = I(cr, cx)
351+    let ca = I(cs, cy)
352+    let cA = I(cw, a)
353+    let cB = bZ(cb, cA)
354+    let cC = bZ(ca, cA)
355+[cz, cB, cC]
358356     }
359357 
360358 
361-func cE (cs,ct,cx) = {
362-    let cF = cw(cs, ct, cx)
363-[L(cF[0], a), L(cF[1], a), L(cF[2], a)]
359+func cD (cr,cs,cw) = {
360+    let cE = cv(cr, cs, cw)
361+[M(cE[0], a), M(cE[1], a), M(cE[2], a)]
364362     }
365363 
366364 
367-func cG (cH,aq) = {
368-    let cI = if ((aq == 0))
365+func cF (cG,ar) = {
366+    let cH = if ((ar == 0))
369367         then 0
370-        else fraction(cH, aq, a)
371-    $Tuple2((cH - cI), cI)
368+        else fraction(cG, ar, a)
369+    $Tuple2((cG - cH), cH)
372370     }
373371 
374372 
375-func cJ (cK) = {
376-    let cL = cK[0]
377-    let cM = cK[1]
378-    let aU = (cL + cM)
379-    if ((aU == e))
373+func cI (cJ) = {
374+    let cK = cJ[0]
375+    let cL = cJ[1]
376+    let aV = (cK + cL)
377+    if ((aV == e))
380378         then e
381379         else {
382-            let aQ = parseIntValue(bf)
383-            let cN = (aQ * 2)
384-            let cF = fraction(cL, cM, f)
385-            let cO = fraction(cF, i, f)
386-            let cP = fraction(toBigInt(cN), aU, f)
387-            let cQ = toBigInt((cN - 1))
388-            func cR (cS) =             {
389-                let cT = fraction(cS, cS, f)
390-                let cU = fraction(cT, cS, f)
391-                let cV = fraction(cU, f, cO)
392-                fraction((cP + fraction(cV, g, f)), cS, (fraction(cQ, cS, f) + fraction(h, cV, f)))
380+            let aR = parseIntValue(bg)
381+            let cM = (aR * 2)
382+            let cE = fraction(cK, cL, f)
383+            let cN = fraction(cE, i, f)
384+            let cO = fraction(toBigInt(cM), aV, f)
385+            let cP = toBigInt((cM - 1))
386+            func cQ (cR) =             {
387+                let cS = fraction(cR, cR, f)
388+                let cT = fraction(cS, cR, f)
389+                let cU = fraction(cT, f, cN)
390+                fraction((cO + fraction(cU, g, f)), cR, (fraction(cP, cR, f) + fraction(h, cU, f)))
393391                 }
394392 
395-            func cW (cX,cY) =             if (cX._2)
396-                then cX
393+            func cV (cW,cX) =             if (cW._2)
394+                then cW
397395                 else {
398-                    let cS = cX._1
399-                    let cZ = cR(cS)
400-                    let da = (cZ - value(cS))
401-                    let db = if ((e > da))
402-                        then -(da)
403-                        else da
404-                    if ((f >= db))
405-                        then $Tuple2(cZ, true)
406-                        else $Tuple2(cZ, false)
396+                    let cR = cW._1
397+                    let cY = cQ(cR)
398+                    let cZ = (cY - value(cR))
399+                    let da = if ((e > cZ))
400+                        then -(cZ)
401+                        else cZ
402+                    if ((f >= da))
403+                        then $Tuple2(cY, true)
404+                        else $Tuple2(cY, false)
407405                     }
408406 
409-            let dc = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
410-            let dd = {
411-                let de = dc
412-                let df = size(de)
413-                let dg = $Tuple2(aU, false)
414-                func dh (di,dj) =                 if ((dj >= df))
415-                    then di
416-                    else cW(di, de[dj])
407+            let db = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
408+            let dc = {
409+                let dd = db
410+                let de = size(dd)
411+                let df = $Tuple2(aV, false)
412+                func dg (dh,di) =                 if ((di >= de))
413+                    then dh
414+                    else cV(dh, dd[di])
417415 
418-                func dk (di,dj) =                 if ((dj >= df))
419-                    then di
416+                func dj (dh,di) =                 if ((di >= de))
417+                    then dh
420418                     else throw("List size exceeds 17")
421419 
422-                dk(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dg, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
420+                dj(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(df, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
423421                 }
424-            let cS = dd._1
425-            let dl = dd._2
426-            if (dl)
427-                then cS
428-                else throw(("D calculation error, D = " + toString(cS)))
422+            let cR = dc._1
423+            let dk = dc._2
424+            if (dk)
425+                then cR
426+                else throw(("D calculation error, D = " + toString(cR)))
429427             }
430428     }
431429 
432430 
433-func dm (dn,do,dp,dq) = {
434-    let dr = bw
435-    let ds = toBase58String(value(bx))
436-    let dt = toBase58String(value(by))
437-    let du = bz
438-    let dv = bA
439-    let dw = toString(bv)
440-    let dx = valueOrErrorMessage(assetInfo(dr), "Wrong LP id").quantity
441-    if ((toBase58String(dr) != do))
431+func dl (dm,dn,do,dp) = {
432+    let dq = bx
433+    let dr = toBase58String(value(by))
434+    let ds = toBase58String(value(bz))
435+    let dt = bA
436+    let du = bB
437+    let dv = toString(bw)
438+    let dw = valueOrErrorMessage(assetInfo(dq), "Wrong LP id").quantity
439+    if ((toBase58String(dq) != dn))
442440         then throw("Wrong pmt asset")
443441         else {
444-            let dy = bY(ds)
445-            let dz = H(dy, du)
446-            let dA = bY(dt)
447-            let dB = H(dA, dv)
448-            let dC = ca(dB, dz)
449-            let dD = L(dC, a)
450-            let dE = H(dp, a)
451-            let dF = H(dx, a)
452-            let dG = fraction(dz, dE, dF)
453-            let dH = fraction(dB, dE, dF)
454-            let dI = O(dG, du, FLOOR)
455-            let dJ = O(dH, dv, FLOOR)
456-            let dK = if ((dn == ""))
442+            let dx = bX(dr)
443+            let dy = I(dx, dt)
444+            let dz = bX(ds)
445+            let dA = I(dz, du)
446+            let dB = bZ(dA, dy)
447+            let dC = M(dB, a)
448+            let dD = I(do, a)
449+            let dE = I(dw, a)
450+            let dF = fraction(dy, dD, dE)
451+            let dG = fraction(dA, dD, dE)
452+            let dH = P(dF, dt, FLOOR)
453+            let dI = P(dG, du, FLOOR)
454+            let dJ = if ((dm == ""))
457455                 then nil
458-                else [ScriptTransfer(dq, dI, if ((ds == "WAVES"))
456+                else [ScriptTransfer(dp, dH, if ((dr == "WAVES"))
459457                     then unit
460-                    else fromBase58String(ds)), ScriptTransfer(dq, dJ, if ((dt == "WAVES"))
458+                    else fromBase58String(dr)), ScriptTransfer(dp, dI, if ((ds == "WAVES"))
461459                     then unit
462-                    else fromBase58String(dt)), StringEntry(ai(toString(dq), dn), bU(dI, dJ, dp, dD, height, lastBlock.timestamp)), IntegerEntry(ab(), dD), IntegerEntry(ac(height, lastBlock.timestamp), dD)]
463-            $Tuple10(dI, dJ, ds, dt, dy, dA, dx, dC, dw, dK)
460+                    else fromBase58String(ds)), StringEntry(aj(toString(dp), dm), bT(dH, dI, do, dC, height, lastBlock.timestamp)), IntegerEntry(ac(), dC), IntegerEntry(ad(height, lastBlock.timestamp), dC)]
461+            $Tuple10(dH, dI, dr, ds, dx, dz, dw, dB, dv, dJ)
464462             }
465463     }
466464 
467465 
468-func dL (dn,ch,dM,dN,dO,dP,dq,dQ,dR,dS,dT,dU,dV) = {
469-    let dr = bw
470-    let dW = toBase58String(value(bx))
471-    let dX = toBase58String(value(by))
466+func dK (dm,cg,dL,dM,dN,dO,dp,dP,dQ,dR,dS,dT,dU) = {
467+    let dq = bx
468+    let dV = toBase58String(value(by))
469+    let dW = toBase58String(value(bz))
470+    let dX = bA
472471     let dY = bB
473-    let dZ = bC
474-    let ea = bz
475-    let eb = bA
476-    let dw = toString(bv)
477-    let ec = valueOrErrorMessage(assetInfo(dr), "Wr lp as").quantity
478-    let dy = if (dQ)
479-        then bY(dW)
480-        else if (if (dS)
481-            then (dV == dW)
472+    let dv = toString(bw)
473+    let dZ = valueOrErrorMessage(assetInfo(dq), "Wr lp as").quantity
474+    let dx = if (dP)
475+        then bX(dV)
476+        else if (if (dR)
477+            then (dU == dV)
482478             else false)
483-            then (bY(dW) - dU)
484-            else if (dS)
485-                then bY(dW)
486-                else (bY(dW) - dM)
487-    let dA = if (dQ)
488-        then bY(dX)
489-        else if (if (dS)
490-            then (dV == dX)
479+            then (bX(dV) - dT)
480+            else if (dR)
481+                then bX(dV)
482+                else (bX(dV) - dL)
483+    let dz = if (dP)
484+        then bX(dW)
485+        else if (if (dR)
486+            then (dU == dW)
491487             else false)
492-            then (bY(dX) - dU)
493-            else if (dS)
494-                then bY(dX)
495-                else (bY(dX) - dO)
496-    let ed = H(dM, ea)
497-    let ee = H(dO, eb)
498-    let ef = ca(ee, ed)
499-    let dz = H(dy, ea)
500-    let dB = H(dA, eb)
501-    let cm = cJ([dz, dB])
502-    let eg = if ((ec == 0))
488+            then (bX(dW) - dT)
489+            else if (dR)
490+                then bX(dW)
491+                else (bX(dW) - dN)
492+    let ea = I(dL, dX)
493+    let eb = I(dN, dY)
494+    let ec = bZ(eb, ea)
495+    let dy = I(dx, dX)
496+    let dA = I(dz, dY)
497+    let cl = cI([dy, dA])
498+    let ed = if ((dZ == 0))
503499         then {
504-            let cl = cJ([(dz + ed), (dB + ee)])
505-            let eh = if ((cl > cm))
500+            let ck = cI([(dy + ea), (dA + eb)])
501+            let ee = if ((ck > cl))
506502                 then true
507503                 else throw("D1 should be greater than D0")
508-            if ((eh == eh))
504+            if ((ee == ee))
509505                 then {
510-                    let dC = d
511-                    let ei = d
512-                    let cB = cl
513-                    $Tuple5(L(cB, a), L(ed, ea), L(ee, eb), ca((dB + ee), (dz + ed)), ei)
506+                    let dB = d
507+                    let ef = d
508+                    let cA = ck
509+                    $Tuple5(M(cA, a), M(ea, dX), M(eb, dY), bZ((dA + eb), (dy + ea)), ef)
514510                     }
515511                 else throw("Strict value is not equal to itself.")
516512             }
517513         else {
518-            let dC = ca(dB, dz)
519-            let ej = fraction(W((dC - ef)), c, dC)
520-            let ei = H(ch, a)
521-            if (if (if (dT)
522-                then (dC != d)
514+            let dB = bZ(dA, dy)
515+            let eg = fraction(X((dB - ec)), c, dB)
516+            let ef = I(cg, a)
517+            if (if (if (dS)
518+                then (dB != d)
523519                 else false)
524-                then (ej > ei)
520+                then (eg > ef)
525521                 else false)
526-                then throw(((("Price slippage " + toString(ej)) + " > ") + toString(ei)))
522+                then throw(((("Price slippage " + toString(eg)) + " > ") + toString(ef)))
527523                 else {
528-                    let ek = H(ec, a)
529-                    let el = fraction(ed, cd(dB, dz, CEILING), c, CEILING)
530-                    let em = fraction(ee, c, cd(dB, dz, FLOOR), CEILING)
531-                    let en = if ((el > ee))
532-                        then $Tuple2(em, ee)
533-                        else $Tuple2(ed, el)
534-                    let eo = en._1
535-                    let ep = en._2
536-                    let cl = cJ([(dz + eo), (dB + ep)])
537-                    let eh = if ((cl > cm))
524+                    let eh = I(dZ, a)
525+                    let ei = fraction(ea, cc(dA, dy, CEILING), c, CEILING)
526+                    let ej = fraction(eb, c, cc(dA, dy, FLOOR), CEILING)
527+                    let ek = if ((ei > eb))
528+                        then $Tuple2(ej, eb)
529+                        else $Tuple2(ea, ei)
530+                    let el = ek._1
531+                    let em = ek._2
532+                    let ck = cI([(dy + el), (dA + em)])
533+                    let ee = if ((ck > cl))
538534                         then true
539535                         else throw("D1 should be greater than D0")
540-                    if ((eh == eh))
536+                    if ((ee == ee))
541537                         then {
542-                            let cB = fraction(ek, (cl - cm), cm)
543-                            $Tuple5(O(cB, a, FLOOR), O(eo, ea, CEILING), O(ep, eb, CEILING), dC, ei)
538+                            let cA = fraction(eh, (ck - cl), cl)
539+                            $Tuple5(P(cA, a, FLOOR), P(el, dX, CEILING), P(em, dY, CEILING), dB, ef)
544540                             }
545541                         else throw("Strict value is not equal to itself.")
546542                     }
547543             }
548-    let eq = eg._1
549-    let er = eg._2
550-    let es = eg._3
551-    let dD = L(eg._4, a)
552-    let et = L(eg._5, a)
553-    if ((0 >= eq))
544+    let en = ed._1
545+    let eo = ed._2
546+    let ep = ed._3
547+    let dC = M(ed._4, a)
548+    let eq = M(ed._5, a)
549+    if ((0 >= en))
554550         then throw("LP <= 0")
555551         else {
556-            let eu = if (!(dR))
552+            let er = if (!(dQ))
557553                 then 0
558-                else eq
559-            let ev = (dM - er)
560-            let ew = (dO - es)
561-            let ex = if (if (dS)
562-                then (dV == dW)
554+                else en
555+            let es = (dL - eo)
556+            let et = (dN - ep)
557+            let eu = if (if (dR)
558+                then (dU == dV)
563559                 else false)
564-                then $Tuple2(dU, 0)
565-                else if (if (dS)
566-                    then (dV == dX)
560+                then $Tuple2(dT, 0)
561+                else if (if (dR)
562+                    then (dU == dW)
567563                     else false)
568-                    then $Tuple2(0, dU)
569-                    else $Tuple2(er, es)
570-            let ey = ex._1
571-            let ez = ex._2
572-            let eA = [IntegerEntry(ab(), dD), IntegerEntry(ac(height, lastBlock.timestamp), dD), StringEntry(af(dq, dn), bJ(ey, ez, eu, dD, ch, et, height, lastBlock.timestamp, ev, ew))]
573-            $Tuple13(eq, eu, dD, dy, dA, ec, dr, dw, eA, ev, ew, dN, dP)
564+                    then $Tuple2(0, dT)
565+                    else $Tuple2(eo, ep)
566+            let ev = eu._1
567+            let ew = eu._2
568+            let ex = [IntegerEntry(ac(), dC), IntegerEntry(ad(height, lastBlock.timestamp), dC), StringEntry(ag(dp, dm), bI(ev, ew, er, dC, cg, eq, height, lastBlock.timestamp, es, et))]
569+            $Tuple13(en, er, dC, dx, dz, dZ, dq, dv, ex, es, et, dM, dO)
574570             }
575571     }
576572 
577573 
578-func eB (cK,cY,eC) = {
579-    let eD = g
580-    let eE = cK[if ((cY == 0))
574+func ey (cJ,cX,ez) = {
575+    let eA = g
576+    let eB = cJ[if ((cX == 0))
581577         then 1
582578         else 0]
583-    let eF = parseBigIntValue(l)
584-    let aQ = (parseBigIntValue(bf) * eF)
585-    let aU = eE
586-    let cN = (aQ * eD)
587-    let eG = (((((eC * eC) / (eE * eD)) * eC) * eF) / (cN * eD))
588-    let eH = ((aU + ((eC * eF) / cN)) - eC)
589-    func cW (cX,eI) =     {
590-        let eJ = cX
591-        let eK = eJ._1
592-        let dl = eJ._2
593-        if ((dl != unit))
594-            then cX
579+    let eC = parseBigIntValue(m)
580+    let aR = (parseBigIntValue(bg) * eC)
581+    let aV = eB
582+    let cM = (aR * eA)
583+    let eD = (((((ez * ez) / (eB * eA)) * ez) * eC) / (cM * eA))
584+    let eE = ((aV + ((ez * eC) / cM)) - ez)
585+    func cV (cW,eF) =     {
586+        let eG = cW
587+        let eH = eG._1
588+        let dk = eG._2
589+        if ((dk != unit))
590+            then cW
595591             else {
596-                let eL = (((eK * eK) + eG) / ((g * eK) + eH))
597-                let eM = X((eL - value(eK)))
598-                if ((f >= eM))
599-                    then $Tuple2(eL, eI)
600-                    else $Tuple2(eL, unit)
592+                let eI = (((eH * eH) + eD) / ((g * eH) + eE))
593+                let eJ = Y((eI - value(eH)))
594+                if ((f >= eJ))
595+                    then $Tuple2(eI, eF)
596+                    else $Tuple2(eI, unit)
601597                 }
602598         }
603599 
604-    let dc = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
605-    let eN = {
606-        let de = dc
607-        let df = size(de)
608-        let dg = $Tuple2(eC, unit)
609-        func dh (di,dj) =         if ((dj >= df))
610-            then di
611-            else cW(di, de[dj])
600+    let db = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
601+    let eK = {
602+        let dd = db
603+        let de = size(dd)
604+        let df = $Tuple2(ez, unit)
605+        func dg (dh,di) =         if ((di >= de))
606+            then dh
607+            else cV(dh, dd[di])
612608 
613-        func dk (di,dj) =         if ((dj >= df))
614-            then di
609+        func dj (dh,di) =         if ((di >= de))
610+            then dh
615611             else throw("List size exceeds 15")
616612 
617-        dk(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dg, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
613+        dj(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(df, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
618614         }
619-    let eK = eN._1
620-    let dl = eN._2
621-    if ((dl != unit))
622-        then eK
623-        else throw(("Y calculation error, Y = " + toString(eK)))
615+    let eH = eK._1
616+    let dk = eK._2
617+    if ((dk != unit))
618+        then eH
619+        else throw(("Y calculation error, Y = " + toString(eH)))
624620     }
625621 
626622 
627-func eO (eP,eQ,eR) = {
628-    let eS = fraction(cJ([K(eP, toBigInt(bz)), K(eQ, toBigInt(bA))]), c, eR)
629-    if ((eR == e))
623+func eL (eM,eN,eO) = {
624+    let eP = fraction(cI([L(eM, toBigInt(bA)), L(eN, toBigInt(bB))]), c, eO)
625+    if ((eO == e))
630626         then e
631-        else eS
627+        else eP
632628     }
633629 
634630 
635-func eT (eU,eV,eW) = {
636-    let eX = (toBigInt(bY(bp(bx))) - eU)
637-    let eY = (toBigInt(bY(bp(by))) - eV)
638-    let eZ = (toBigInt(value(assetInfo(bw)).quantity) - eW)
639-    let fa = eO(eX, eY, eZ)
640-    fa
631+func eQ (eR,eS,eT) = {
632+    let eU = (toBigInt(bX(bq(by))) - eR)
633+    let eV = (toBigInt(bX(bq(bz))) - eS)
634+    let eW = (toBigInt(value(assetInfo(bx)).quantity) - eT)
635+    let eX = eL(eU, eV, eW)
636+    eX
641637     }
642638 
643639 
644-func fb (fc,fd,eW) = {
645-    let eX = (bY(bp(bx)) + fc)
646-    let eY = (bY(bp(by)) + fd)
647-    let eZ = (value(assetInfo(bw)).quantity + eW)
648-    let eS = eO(toBigInt(eX), toBigInt(eY), toBigInt(eZ))
649-    let fe = [IntegerEntry(as, height), StringEntry(ar, toString(eS))]
650-    $Tuple2(fe, eS)
640+func eY (eZ,fa,eT) = {
641+    let eU = (bX(bq(by)) + eZ)
642+    let eV = (bX(bq(bz)) + fa)
643+    let eW = (value(assetInfo(bx)).quantity + eT)
644+    let eP = eL(toBigInt(eU), toBigInt(eV), toBigInt(eW))
645+    let fb = [IntegerEntry(at, height), StringEntry(as, toString(eP))]
646+    $Tuple2(fb, eP)
651647     }
652648 
653649 
654-func ff (fg,eS) = if ((eS >= fg))
650+func fc (fd,eP) = if ((eP >= fd))
655651     then true
656-    else aZ("updated DLp lower than current DLp")
652+    else ba("updated DLp lower than current DLp")
657653 
658654 
659-func fh (fi) = {
660-    let eX = bY(bp(bx))
661-    let eY = bY(bp(by))
662-    let fj = fi.amount
663-    let fk = fraction(fi.amount, fi.price, a, FLOOR)
664-    let fl = if ((fi.orderType == Buy))
665-        then $Tuple2(fj, -(fk))
666-        else $Tuple2(-(fj), fk)
667-    let fc = fl._1
668-    let fd = fl._2
669-    if (if (if (bg())
655+func fe (ff) = {
656+    let eU = bX(bq(by))
657+    let eV = bX(bq(bz))
658+    let fg = ff.amount
659+    let fh = fraction(ff.amount, ff.price, a, FLOOR)
660+    let fi = if ((ff.orderType == Buy))
661+        then $Tuple2(fg, -(fh))
662+        else $Tuple2(-(fg), fh)
663+    let eZ = fi._1
664+    let fa = fi._2
665+    if (if (if (bh())
670666         then true
671-        else (bv == r))
667+        else (bw == s))
672668         then true
673-        else (bv == s))
669+        else (bw == t))
674670         then throw("Admin blocked")
675-        else if (if ((fi.assetPair.amountAsset != bx))
671+        else if (if ((ff.assetPair.amountAsset != by))
676672             then true
677-            else (fi.assetPair.priceAsset != by))
673+            else (ff.assetPair.priceAsset != bz))
678674             then throw("Wr assets")
679675             else {
680-                let fm = parseBigIntValue(valueOrElse(getString(this, ar), "0"))
681-                let fn = fb(fc, fd, 0)
682-                let fo = fn._1
683-                let fp = fn._2
684-                let fq = (fp >= fm)
685-                let fr = makeString(["dLp=", toString(fm), " dLpNew=", toString(fp), " amountAssetBalance=", toString(eX), " priceAssetBalance=", toString(eY), " amountAssetBalanceDelta=", toString(fc), " priceAssetBalanceDelta=", toString(fd), " height=", toString(height)], "")
686-                $Tuple2(fq, fr)
676+                let fj = parseBigIntValue(valueOrElse(getString(this, as), "0"))
677+                let fk = eY(eZ, fa, 0)
678+                let fl = fk._1
679+                let fm = fk._2
680+                let fn = (fm >= fj)
681+                let fo = makeString(["dLp=", toString(fj), " dLpNew=", toString(fm), " amountAssetBalance=", toString(eU), " priceAssetBalance=", toString(eV), " amountAssetBalanceDelta=", toString(eZ), " priceAssetBalanceDelta=", toString(fa), " height=", toString(height)], "")
682+                $Tuple2(fn, fo)
687683                 }
688684     }
689685 
690686 
691-func fs (cY) = if ((size(cY.payments) != 1))
687+func fp (cX) = if ((size(cX.payments) != 1))
692688     then throw("1 pmnt exp")
693689     else {
694-        let ft = value(cY.payments[0])
695-        let do = value(ft.assetId)
696-        let dU = ft.amount
697-        let eg = dm(toBase58String(cY.transactionId), toBase58String(do), dU, cY.caller)
698-        let dI = eg._1
699-        let dJ = eg._2
700-        let dw = parseIntValue(eg._9)
701-        let dK = eg._10
702-        if (if (bg())
690+        let fq = value(cX.payments[0])
691+        let dn = value(fq.assetId)
692+        let dT = fq.amount
693+        let ed = dl(toBase58String(cX.transactionId), toBase58String(dn), dT, cX.caller)
694+        let dH = ed._1
695+        let dI = ed._2
696+        let dv = parseIntValue(ed._9)
697+        let dJ = ed._10
698+        if (if (bh())
703699             then true
704-            else (dw == s))
705-            then throw(("Admin blocked: " + toString(dw)))
706-            else $Tuple5(dI, dJ, dU, do, dK)
700+            else (dv == t))
701+            then throw(("Admin blocked: " + toString(dv)))
702+            else $Tuple5(dH, dI, dT, dn, dJ)
707703         }
708704 
709705 
710-func fu (fv,ah,fw,fx,ch,dR,dS,dT,dU,dV) = {
711-    let eg = dL(ah, ch, value(fw).amount, value(fw).assetId, value(fx).amount, value(fx).assetId, fv, (ah == ""), dR, dS, dT, dU, dV)
712-    let dw = parseIntValue(eg._8)
713-    if (if (if (bg())
706+func fr (fs,ai,ft,fu,cg,dQ,dR,dS,dT,dU) = {
707+    let ed = dK(ai, cg, value(ft).amount, value(ft).assetId, value(fu).amount, value(fu).assetId, fs, (ai == ""), dQ, dR, dS, dT, dU)
708+    let dv = parseIntValue(ed._8)
709+    if (if (if (bh())
714710         then true
715-        else (dw == q))
711+        else (dv == r))
716712         then true
717-        else (dw == s))
718-        then throw(("Blocked:" + toString(dw)))
719-        else eg
713+        else (dv == t))
714+        then throw(("Blocked:" + toString(dv)))
715+        else ed
720716     }
721717 
722718 
723-func fy (fz,do,dq,ah,fA) = {
724-    let ds = toBase58String(value(bx))
725-    let dt = toBase58String(value(by))
726-    let dr = bw
727-    let ea = bz
728-    let eb = bA
729-    let eZ = toBigInt(valueOrErrorMessage(assetInfo(dr), "invalid lp asset").quantity)
730-    let fB = if ((eZ > e))
719+func fv (fw,dn,dp,ai,fx) = {
720+    let dr = toBase58String(value(by))
721+    let ds = toBase58String(value(bz))
722+    let dq = bx
723+    let dX = bA
724+    let dY = bB
725+    let eW = toBigInt(valueOrErrorMessage(assetInfo(dq), "invalid lp asset").quantity)
726+    let fy = if ((eW > e))
731727         then true
732728         else throw("initial deposit requires all coins")
733-    if ((fB == fB))
729+    if ((fy == fy))
734730         then {
735-            let dy = bY(ds)
736-            let dA = bY(dt)
737-            let fC = if ((ah == ""))
738-                then $Tuple2(dy, dA)
739-                else if ((do == ds))
740-                    then if ((fz > dy))
731+            let dx = bX(dr)
732+            let dz = bX(ds)
733+            let fz = if ((ai == ""))
734+                then $Tuple2(dx, dz)
735+                else if ((dn == dr))
736+                    then if ((fw > dx))
741737                         then throw("invalid payment amount")
742-                        else $Tuple2((dy - fz), dA)
743-                    else if ((do == dt))
744-                        then if ((fz > dA))
738+                        else $Tuple2((dx - fw), dz)
739+                    else if ((dn == ds))
740+                        then if ((fw > dz))
745741                             then throw("invalid payment amount")
746-                            else $Tuple2(dy, (dA - fz))
742+                            else $Tuple2(dx, (dz - fw))
747743                         else throw("wrong pmtAssetId")
744+            let fA = fz._1
745+            let fB = fz._2
746+            let fC = if ((dn == dr))
747+                then $Tuple2(fw, 0)
748+                else if ((dn == ds))
749+                    then $Tuple2(0, fw)
750+                    else throw("invalid payment")
748751             let fD = fC._1
749752             let fE = fC._2
750-            let fF = if ((do == ds))
751-                then $Tuple2(fz, 0)
752-                else if ((do == dt))
753-                    then $Tuple2(0, fz)
754-                    else throw("invalid payment")
753+            let fF = if (fx)
754+                then $Tuple3(cF(fD, bd)._1, cF(fE, bd)._1, cF(fw, bd)._2)
755+                else $Tuple3(fD, fE, 0)
755756             let fG = fF._1
756757             let fH = fF._2
757-            let fI = if (fA)
758-                then $Tuple3(cG(fG, bc)._1, cG(fH, bc)._1, cG(fz, bc)._2)
759-                else $Tuple3(fG, fH, 0)
760-            let fJ = fI._1
761-            let fK = fI._2
762-            let cI = fI._3
763-            let fL = (fD + fJ)
764-            let fM = (fE + fK)
765-            let cm = cJ([H(fD, bz), H(fE, bA)])
766-            let cl = cJ([H(fL, bz), H(fM, bA)])
767-            let eh = if ((cl > cm))
758+            let cH = fF._3
759+            let fI = (fA + fG)
760+            let fJ = (fB + fH)
761+            let cl = cI([I(fA, bA), I(fB, bB)])
762+            let ck = cI([I(fI, bA), I(fJ, bB)])
763+            let ee = if ((ck > cl))
768764                 then true
769765                 else throw()
770-            if ((eh == eh))
766+            if ((ee == ee))
771767                 then {
772-                    let fN = fraction(eZ, (cl - cm), cm, FLOOR)
773-                    let dD = L(ca(H(fM, eb), H(fL, ea)), a)
774-                    let eA = [IntegerEntry(ab(), dD), IntegerEntry(ac(height, lastBlock.timestamp), dD), StringEntry(af(dq, ah), bJ(fG, fH, toInt(fN), dD, 0, 0, height, lastBlock.timestamp, 0, 0))]
775-                    let fO = fraction(fE, a, fD)
776-                    let fP = fraction(fz, a, (fO + a))
777-                    let fQ = (fz - fP)
778-                    let fR = fraction(eZ, toBigInt(fQ), toBigInt(fE))
779-                    let fS = toInt(fraction((fN - fR), b, fR))
780-                    $Tuple4(toInt(fN), eA, cI, fS)
768+                    let fK = fraction(eW, (ck - cl), cl, FLOOR)
769+                    let dC = M(bZ(I(fJ, dY), I(fI, dX)), a)
770+                    let ex = [IntegerEntry(ac(), dC), IntegerEntry(ad(height, lastBlock.timestamp), dC), StringEntry(ag(dp, ai), bI(fD, fE, toInt(fK), dC, 0, 0, height, lastBlock.timestamp, 0, 0))]
771+                    let fL = fraction(fB, a, fA)
772+                    let fM = fraction(fw, a, (fL + a))
773+                    let fN = (fw - fM)
774+                    let fO = fraction(eW, toBigInt(fN), toBigInt(fB))
775+                    let fP = toInt(fraction((fK - fO), b, fO))
776+                    $Tuple4(toInt(fK), ex, cH, fP)
781777                     }
782778                 else throw("Strict value is not equal to itself.")
783779             }
785781     }
786782 
787783 
788-func fT (fU,fV,fW,fv,fX,fY) = {
789-    let dr = toBase58String(value(bw))
790-    let ds = toBase58String(value(bx))
791-    let dt = toBase58String(value(by))
792-    let fZ = bz
793-    let ga = bA
794-    let gb = bv
795-    let dq = if ((fv == bI))
796-        then fX
797-        else fv
798-    let ft = value(fW[0])
799-    let do = value(ft.assetId)
800-    let dU = ft.amount
801-    let fa = eT(e, e, e)
802-    if ((fa == fa))
784+func fQ (fR,fS,fT,fs,fU,fV) = {
785+    let dq = toBase58String(value(bx))
786+    let dr = toBase58String(value(by))
787+    let ds = toBase58String(value(bz))
788+    let fW = bA
789+    let fX = bB
790+    let fY = bw
791+    let dp = if ((fs == bH))
792+        then fU
793+        else fs
794+    let fq = value(fT[0])
795+    let dn = value(fq.assetId)
796+    let dT = fq.amount
797+    let eX = eQ(e, e, e)
798+    if ((eX == eX))
803799         then {
804-            let dn = toBase58String(fY)
805-            if ((dr != toBase58String(do)))
800+            let dm = toBase58String(fV)
801+            if ((dq != toBase58String(dn)))
806802                 then throw("Wrong LP")
807803                 else {
808-                    let dy = bY(ds)
809-                    let dA = bY(dt)
810-                    let gc = {
811-                        let bd = invoke(this, "getOneTknV2READONLY", [fU, dU], nil)
812-                        if ($isInstanceOf(bd, "(Int, Int)"))
813-                            then bd
814-                            else throw(($getType(bd) + " couldn't be cast to (Int, Int)"))
804+                    let dx = bX(dr)
805+                    let dz = bX(ds)
806+                    let fZ = {
807+                        let be = invoke(this, "getOneTknV2READONLY", [fR, dT], nil)
808+                        if ($isInstanceOf(be, "(Int, Int)"))
809+                            then be
810+                            else throw(($getType(be) + " couldn't be cast to (Int, Int)"))
815811                         }
816-                    if ((gc == gc))
812+                    if ((fZ == fZ))
817813                         then {
818-                            let cI = gc._2
814+                            let cH = fZ._2
815+                            let ga = fZ._1
816+                            let gb = if (if ((fS > 0))
817+                                then (fS > ga)
818+                                else false)
819+                                then ba(makeString(["amount to receive is less than ", toString(fS)], ""))
820+                                else ga
821+                            let gc = if ((fR == dr))
822+                                then $Tuple4(gb, 0, ((dx - gb) - cH), dz)
823+                                else if ((fR == ds))
824+                                    then $Tuple4(0, gb, dx, ((dz - gb) - cH))
825+                                    else throw("invalid out asset id")
819826                             let gd = gc._1
820-                            let ge = if (if ((fV > 0))
821-                                then (fV > gd)
822-                                else false)
823-                                then aZ(makeString(["amount to receive is less than ", toString(fV)], ""))
824-                                else gd
825-                            let gf = if ((fU == ds))
826-                                then $Tuple4(ge, 0, ((dy - ge) - cI), dA)
827-                                else if ((fU == dt))
828-                                    then $Tuple4(0, ge, dy, ((dA - ge) - cI))
829-                                    else throw("invalid out asset id")
830-                            let gg = gf._1
831-                            let gh = gf._2
832-                            let fL = gf._3
833-                            let fM = gf._4
834-                            let gi = ca(H(fM, ga), H(fL, fZ))
835-                            let gj = L(gi, a)
836-                            let gk = if ((fU == "WAVES"))
827+                            let ge = gc._2
828+                            let fI = gc._3
829+                            let fJ = gc._4
830+                            let gf = bZ(I(fJ, fX), I(fI, fW))
831+                            let gg = M(gf, a)
832+                            let gh = if ((fR == "WAVES"))
837833                                 then unit
838-                                else fromBase58String(fU)
839-                            let gl = if ((cI > 0))
840-                                then [ScriptTransfer(bi, cI, gk)]
834+                                else fromBase58String(fR)
835+                            let gi = if ((cH > 0))
836+                                then [ScriptTransfer(bj, cH, gh)]
841837                                 else nil
842-                            let dK = ([ScriptTransfer(dq, ge, gk), StringEntry(ai(toString(dq), dn), bU(gg, gh, dU, gj, height, lastBlock.timestamp)), IntegerEntry(ab(), gj), IntegerEntry(ac(height, lastBlock.timestamp), gj)] ++ gl)
843-                            if ((dK == dK))
838+                            let dJ = ([ScriptTransfer(dp, gb, gh), StringEntry(aj(toString(dp), dm), bT(gd, ge, dT, gg, height, lastBlock.timestamp)), IntegerEntry(ac(), gg), IntegerEntry(ad(height, lastBlock.timestamp), gg)] ++ gi)
839+                            if ((dJ == dJ))
844840                                 then {
845-                                    let gm = invoke(aT, "burn", [dU], [AttachedPayment(do, dU)])
846-                                    if ((gm == gm))
841+                                    let gj = invoke(aU, "burn", [dT], [AttachedPayment(dn, dT)])
842+                                    if ((gj == gj))
847843                                         then {
848-                                            let gn = {
849-                                                let go = if ((this == bi))
844+                                            let gk = {
845+                                                let gl = if ((this == bj))
850846                                                     then 0
851-                                                    else cI
852-                                                let gp = if ((bn(fU) == bx))
847+                                                    else cH
848+                                                let gm = if ((bo(fR) == by))
853849                                                     then true
854850                                                     else false
855-                                                if (gp)
856-                                                    then $Tuple2(-((gd + go)), 0)
857-                                                    else $Tuple2(0, -((gd + go)))
851+                                                if (gm)
852+                                                    then $Tuple2(-((ga + gl)), 0)
853+                                                    else $Tuple2(0, -((ga + gl)))
858854                                                 }
859-                                            let fc = gn._1
860-                                            let fd = gn._2
861-                                            let gq = fb(fc, fd, 0)
862-                                            let gr = gq._1
863-                                            let eS = gq._2
864-                                            let gs = ff(fa, eS)
865-                                            if ((gs == gs))
866-                                                then $Tuple2((dK ++ gr), ge)
855+                                            let eZ = gk._1
856+                                            let fa = gk._2
857+                                            let gn = eY(eZ, fa, 0)
858+                                            let go = gn._1
859+                                            let eP = gn._2
860+                                            let gp = fc(eX, eP)
861+                                            if ((gp == gp))
862+                                                then $Tuple2((dJ ++ go), gb)
867863                                                 else throw("Strict value is not equal to itself.")
868864                                             }
869865                                         else throw("Strict value is not equal to itself.")
877873     }
878874 
879875 
880-func gt () = {
881-    let gu = aR()
882-    let aP = getString(gu, Z())
883-    if ($isInstanceOf(aP, "String"))
876+func gq () = {
877+    let gr = aS()
878+    let aQ = getString(gr, aa())
879+    if ($isInstanceOf(aQ, "String"))
884880         then {
885-            let aU = aP
886-            fromBase58String(aU)
881+            let aV = aQ
882+            fromBase58String(aV)
887883             }
888-        else if ($isInstanceOf(aP, "Unit"))
884+        else if ($isInstanceOf(aQ, "Unit"))
889885             then unit
890886             else throw("Match error")
891887     }
892888 
893889 
894-let gv = throw("Permission denied")
890+let gs = throw("Permission denied")
895891 
896-func gw (cY) = {
897-    let aP = gt()
898-    if ($isInstanceOf(aP, "ByteVector"))
892+func gt (cX) = {
893+    let aQ = gq()
894+    if ($isInstanceOf(aQ, "ByteVector"))
899895         then {
900-            let gx = aP
901-            (cY.callerPublicKey == gx)
896+            let gu = aQ
897+            (cX.callerPublicKey == gu)
902898             }
903-        else if ($isInstanceOf(aP, "Unit"))
904-            then (cY.caller == this)
899+        else if ($isInstanceOf(aQ, "Unit"))
900+            then (cX.caller == this)
905901             else throw("Match error")
906902     }
907903 
908904 
909-func gy (cY) = {
910-    let aP = gt()
911-    if ($isInstanceOf(aP, "ByteVector"))
905+func gv (cX) = {
906+    let aQ = gq()
907+    if ($isInstanceOf(aQ, "ByteVector"))
912908         then {
913-            let gx = aP
914-            if ((cY.callerPublicKey == gx))
909+            let gu = aQ
910+            if ((cX.callerPublicKey == gu))
915911                 then true
916-                else gv
912+                else gs
917913             }
918-        else if ($isInstanceOf(aP, "Unit"))
919-            then if ((cY.caller == this))
914+        else if ($isInstanceOf(aQ, "Unit"))
915+            then if ((cX.caller == this))
920916                 then true
921-                else gv
917+                else gs
922918             else throw("Match error")
923919     }
924920 
925921 
926-func gz (gA,eC,gB) = {
927-    let br = bj()
928-    let ds = br[w]
929-    let dt = br[x]
930-    let eD = g
931-    let eF = parseBigIntValue(l)
932-    let aQ = (parseBigIntValue(bf) * eF)
933-    let cK = if ((gA == false))
934-        then [(toBigInt(bY(ds)) + gB), toBigInt(bY(dt))]
935-        else [(toBigInt(bY(dt)) + gB), toBigInt(bY(ds))]
936-    let eE = cK[0]
937-    let aU = eE
938-    let cN = (aQ * eD)
939-    let eG = (((((eC * eC) / (eE * eD)) * eC) * eF) / (cN * eD))
940-    let eH = ((aU + ((eC * eF) / cN)) - eC)
941-    func cW (cX,eI) =     {
942-        let gC = cX
943-        let eK = gC._1
944-        let dl = gC._2
945-        if ((dl != unit))
946-            then cX
922+func gw (gx,ez,gy) = {
923+    let bs = bk()
924+    let dr = bs[x]
925+    let ds = bs[y]
926+    let eA = g
927+    let eC = parseBigIntValue(m)
928+    let aR = (parseBigIntValue(bg) * eC)
929+    let cJ = if ((gx == false))
930+        then [(toBigInt(bX(dr)) + gy), toBigInt(bX(ds))]
931+        else [(toBigInt(bX(ds)) + gy), toBigInt(bX(dr))]
932+    let eB = cJ[0]
933+    let aV = eB
934+    let cM = (aR * eA)
935+    let eD = (((((ez * ez) / (eB * eA)) * ez) * eC) / (cM * eA))
936+    let eE = ((aV + ((ez * eC) / cM)) - ez)
937+    func cV (cW,eF) =     {
938+        let gz = cW
939+        let eH = gz._1
940+        let dk = gz._2
941+        if ((dk != unit))
942+            then cW
947943             else {
948-                let eL = (((eK * eK) + eG) / ((g * eK) + eH))
949-                let eM = X((eL - value(eK)))
950-                if ((f >= eM))
951-                    then $Tuple2(eL, eI)
952-                    else $Tuple2(eL, unit)
944+                let eI = (((eH * eH) + eD) / ((g * eH) + eE))
945+                let eJ = Y((eI - value(eH)))
946+                if ((f >= eJ))
947+                    then $Tuple2(eI, eF)
948+                    else $Tuple2(eI, unit)
953949                 }
954950         }
955951 
956-    let dc = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
957-    let gD = {
958-        let de = dc
959-        let df = size(de)
960-        let dg = $Tuple2(eC, unit)
961-        func dh (di,dj) =         if ((dj >= df))
962-            then di
963-            else cW(di, de[dj])
952+    let db = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
953+    let gA = {
954+        let dd = db
955+        let de = size(dd)
956+        let df = $Tuple2(ez, unit)
957+        func dg (dh,di) =         if ((di >= de))
958+            then dh
959+            else cV(dh, dd[di])
964960 
965-        func dk (di,dj) =         if ((dj >= df))
966-            then di
961+        func dj (dh,di) =         if ((di >= de))
962+            then dh
967963             else throw("List size exceeds 15")
968964 
969-        dk(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dg, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
965+        dj(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(df, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
970966         }
971-    let eK = gD._1
972-    let dl = gD._2
973-    if ((dl != unit))
974-        then eK
975-        else throw(("Y calculation error, Y = " + toString(eK)))
967+    let eH = gA._1
968+    let dk = gA._2
969+    if ((dk != unit))
970+        then eH
971+        else throw(("Y calculation error, Y = " + toString(eH)))
976972     }
977973 
978974 
979-func gE () = valueOrElse(getBoolean(aT, aG(toString(this))), false)
975+func gB () = valueOrElse(getBoolean(aU, aH(toString(this))), false)
980976 
981977 
982-@Callable(cY)
983-func calculateAmountOutForSwapREADONLY (gF,gA,gG) = {
984-    let gH = if ((gA == false))
978+@Callable(cX)
979+func calculateAmountOutForSwapREADONLY (gC,gx,gD) = {
980+    let gE = if ((gx == false))
985981         then {
986-            let gI = aV(this, ak())
987-            let gB = (toBigInt(bY(aV(this, aj()))) + toBigInt(gF))
988-            $Tuple2(gI, gB)
982+            let gF = aW(this, al())
983+            let gy = (toBigInt(bX(aW(this, ak()))) + toBigInt(gC))
984+            $Tuple2(gF, gy)
989985             }
990986         else {
991-            let gI = aV(this, aj())
992-            let gB = (toBigInt(bY(aV(this, ak()))) + toBigInt(gF))
993-            $Tuple2(gI, gB)
987+            let gF = aW(this, ak())
988+            let gy = (toBigInt(bX(aW(this, al()))) + toBigInt(gC))
989+            $Tuple2(gF, gy)
994990             }
995-    let gI = gH._1
996-    let gB = gH._2
997-    let br = bj()
998-    let ds = br[w]
999-    let dt = br[x]
1000-    let cK = [toBigInt(bY(ds)), toBigInt(bY(dt))]
1001-    let eC = cJ(cK)
1002-    let eK = gz(gA, eC, toBigInt(gF))
1003-    let gJ = ((toBigInt(bY(gI)) - eK) - toBigInt(1))
1004-    let gK = max([0, toInt(gJ)])
1005-    let gL = if ((gA == false))
1006-        then [((toBigInt(bY(ds)) + toBigInt(gF)) + toBigInt(gG)), (toBigInt(bY(dt)) - gJ)]
1007-        else [(toBigInt(bY(ds)) - gJ), ((toBigInt(bY(dt)) + toBigInt(gF)) + toBigInt(gG))]
1008-    let gM = cJ(gL)
1009-    let eh = if ((gM >= eC))
991+    let gF = gE._1
992+    let gy = gE._2
993+    let bs = bk()
994+    let dr = bs[x]
995+    let ds = bs[y]
996+    let cJ = [toBigInt(bX(dr)), toBigInt(bX(ds))]
997+    let ez = cI(cJ)
998+    let eH = gw(gx, ez, toBigInt(gC))
999+    let gG = ((toBigInt(bX(gF)) - eH) - toBigInt(1))
1000+    let gH = max([0, toInt(gG)])
1001+    let gI = if ((gx == false))
1002+        then [((toBigInt(bX(dr)) + toBigInt(gC)) + toBigInt(gD)), (toBigInt(bX(ds)) - gG)]
1003+        else [(toBigInt(bX(dr)) - gG), ((toBigInt(bX(ds)) + toBigInt(gC)) + toBigInt(gD))]
1004+    let gJ = cI(gI)
1005+    let ee = if ((gJ >= ez))
10101006         then true
1011-        else throw(makeString(["new D is fewer error", toString(eC), toString(gM)], "__"))
1012-    if ((eh == eh))
1013-        then $Tuple2(nil, gK)
1007+        else throw(makeString(["new D is fewer error", toString(ez), toString(gJ)], "__"))
1008+    if ((ee == ee))
1009+        then $Tuple2(nil, gH)
10141010         else throw("Strict value is not equal to itself.")
10151011     }
10161012 
10171013 
10181014 
1019-@Callable(cY)
1020-func calculateAmountOutForSwapAndSendTokens (gF,gA,gN,gO,gG) = {
1021-    let gP = {
1022-        let bd = invoke(aT, "getSwapContractREADONLY", nil, nil)
1023-        if ($isInstanceOf(bd, "String"))
1024-            then bd
1025-            else throw(($getType(bd) + " couldn't be cast to String"))
1015+@Callable(cX)
1016+func calculateAmountOutForSwapAndSendTokens (gC,gx,gK,gL,gD) = {
1017+    let gM = {
1018+        let be = invoke(aU, "getSwapContractREADONLY", nil, nil)
1019+        if ($isInstanceOf(be, "String"))
1020+            then be
1021+            else throw(($getType(be) + " couldn't be cast to String"))
10261022         }
1027-    let gQ = [if ((value(cY.payments[0]).amount >= gF))
1023+    let gN = [if ((value(cX.payments[0]).amount >= gC))
10281024         then true
1029-        else aZ("Wrong amount"), if ((cY.caller == addressFromStringValue(gP)))
1025+        else ba("Wrong amount"), if ((cX.caller == addressFromStringValue(gM)))
10301026         then true
1031-        else aZ("Permission denied")]
1032-    if ((gQ == gQ))
1027+        else ba("Permission denied")]
1028+    if ((gN == gN))
10331029         then {
1034-            let ft = value(cY.payments[0])
1035-            let gR = bp(ft.assetId)
1036-            let gS = if ((gA == false))
1030+            let fq = value(cX.payments[0])
1031+            let gO = bq(fq.assetId)
1032+            let gP = if ((gx == false))
10371033                 then {
1038-                    let gI = aV(this, ak())
1039-                    let gB = (bY(gR) - value(cY.payments[0]).amount)
1040-                    $Tuple2(gI, gB)
1034+                    let gF = aW(this, al())
1035+                    let gy = (bX(gO) - value(cX.payments[0]).amount)
1036+                    $Tuple2(gF, gy)
10411037                     }
10421038                 else {
1043-                    let gI = aV(this, aj())
1044-                    let gB = (bY(gR) - value(cY.payments[0]).amount)
1045-                    $Tuple2(gI, gB)
1039+                    let gF = aW(this, ak())
1040+                    let gy = (bX(gO) - value(cX.payments[0]).amount)
1041+                    $Tuple2(gF, gy)
10461042                     }
1047-            let gI = gS._1
1048-            let gB = gS._2
1049-            let br = bj()
1050-            let ds = br[w]
1051-            let dt = br[x]
1052-            let cK = if ((gA == false))
1053-                then [(toBigInt(bY(ds)) - toBigInt(value(cY.payments[0]).amount)), toBigInt(bY(dt))]
1054-                else [toBigInt(bY(ds)), (toBigInt(bY(dt)) - toBigInt(value(cY.payments[0]).amount))]
1055-            let eC = cJ(cK)
1056-            let eK = gz(gA, eC, toBigInt(0))
1057-            let gJ = ((toBigInt(bY(gI)) - eK) - toBigInt(1))
1058-            let gK = max([0, toInt(gJ)])
1059-            let gT = if ((gK >= gN))
1043+            let gF = gP._1
1044+            let gy = gP._2
1045+            let bs = bk()
1046+            let dr = bs[x]
1047+            let ds = bs[y]
1048+            let cJ = if ((gx == false))
1049+                then [(toBigInt(bX(dr)) - toBigInt(value(cX.payments[0]).amount)), toBigInt(bX(ds))]
1050+                else [toBigInt(bX(dr)), (toBigInt(bX(ds)) - toBigInt(value(cX.payments[0]).amount))]
1051+            let ez = cI(cJ)
1052+            let eH = gw(gx, ez, toBigInt(0))
1053+            let gG = ((toBigInt(bX(gF)) - eH) - toBigInt(1))
1054+            let gH = max([0, toInt(gG)])
1055+            let gQ = if ((gH >= gK))
10601056                 then true
10611057                 else throw("Exchange result is fewer coins than expected")
1062-            if ((gT == gT))
1058+            if ((gQ == gQ))
10631059                 then {
1064-                    let gL = if ((gA == false))
1065-                        then [(toBigInt(bY(ds)) + toBigInt(gG)), (toBigInt(bY(dt)) - gJ)]
1066-                        else [(toBigInt(bY(ds)) - gJ), (toBigInt(bY(dt)) + toBigInt(gG))]
1067-                    let gM = cJ(gL)
1068-                    let eh = if ((gM >= eC))
1060+                    let gI = if ((gx == false))
1061+                        then [(toBigInt(bX(dr)) + toBigInt(gD)), (toBigInt(bX(ds)) - gG)]
1062+                        else [(toBigInt(bX(dr)) - gG), (toBigInt(bX(ds)) + toBigInt(gD))]
1063+                    let gJ = cI(gI)
1064+                    let ee = if ((gJ >= ez))
10691065                         then true
10701066                         else throw("new D is fewer error")
1071-                    if ((eh == eh))
1072-                        then $Tuple2([ScriptTransfer(addressFromStringValue(gO), gK, bn(gI))], gK)
1067+                    if ((ee == ee))
1068+                        then $Tuple2([ScriptTransfer(addressFromStringValue(gL), gH, bo(gF))], gH)
10731069                         else throw("Strict value is not equal to itself.")
10741070                     }
10751071                 else throw("Strict value is not equal to itself.")
10791075 
10801076 
10811077 
1082-@Callable(cY)
1083-func constructor (Y) = {
1084-    let eG = gy(cY)
1085-    if ((eG == eG))
1086-        then [StringEntry(Y(), Y)]
1078+@Callable(cX)
1079+func constructor (Z) = {
1080+    let eD = gv(cX)
1081+    if ((eD == eD))
1082+        then [StringEntry(Z(), Z)]
10871083         else throw("Strict value is not equal to itself.")
10881084     }
10891085 
10901086 
10911087 
1092-@Callable(cY)
1093-func put (gU,gV) = {
1094-    let gW = bD()
1095-    let gX = valueOrErrorMessage(addressFromString(gW[C]), "Wr st addr")
1096-    let gY = valueOrErrorMessage(addressFromString(gW[E]), "Wr sl addr")
1097-    if ((0 > gU))
1088+@Callable(cX)
1089+func put (gR,gS) = {
1090+    let gT = bC()
1091+    let gU = valueOrErrorMessage(addressFromString(gT[D]), "Wr st addr")
1092+    let gV = valueOrErrorMessage(addressFromString(gT[F]), "Wr sl addr")
1093+    if ((0 > gR))
10981094         then throw("Wrong slippage")
1099-        else if ((size(cY.payments) != 2))
1095+        else if ((size(cX.payments) != 2))
11001096             then throw("2 pmnts expd")
11011097             else {
1102-                let gZ = toBigInt(value(cY.payments[0]).amount)
1103-                let ha = toBigInt(value(cY.payments[1]).amount)
1104-                let eX = (toBigInt(bY(bp(bx))) - gZ)
1105-                if ((eX == eX))
1098+                let gW = toBigInt(value(cX.payments[0]).amount)
1099+                let gX = toBigInt(value(cX.payments[1]).amount)
1100+                let eU = (toBigInt(bX(bq(by))) - gW)
1101+                if ((eU == eU))
11061102                     then {
1107-                        let eY = (toBigInt(bY(bp(by))) - ha)
1108-                        if ((eY == eY))
1103+                        let eV = (toBigInt(bX(bq(bz))) - gX)
1104+                        if ((eV == eV))
11091105                             then {
1110-                                let eZ = toBigInt(value(assetInfo(bw)).quantity)
1111-                                if ((eZ == eZ))
1106+                                let eW = toBigInt(value(assetInfo(bx)).quantity)
1107+                                if ((eW == eW))
11121108                                     then {
1113-                                        let fa = eT(gZ, ha, toBigInt(0))
1114-                                        if ((fa == fa))
1109+                                        let eX = eQ(gW, gX, toBigInt(0))
1110+                                        if ((eX == eX))
11151111                                             then {
1116-                                                let hb = fu(toString(cY.caller), toBase58String(cY.transactionId), AttachedPayment(value(cY.payments[0]).assetId, value(cY.payments[0]).amount), cY.payments[1], gU, true, false, true, 0, "")
1117-                                                let eu = hb._2
1118-                                                let hc = hb._7
1119-                                                let dK = hb._9
1120-                                                let ev = hb._10
1121-                                                let ew = hb._11
1122-                                                let ds = hb._12
1123-                                                let dt = hb._13
1124-                                                let eg = invoke(aT, "emit", [eu], nil)
1125-                                                if ((eg == eg))
1112+                                                let gY = fr(toString(cX.caller), toBase58String(cX.transactionId), AttachedPayment(value(cX.payments[0]).assetId, value(cX.payments[0]).amount), cX.payments[1], gR, true, false, true, 0, "")
1113+                                                let er = gY._2
1114+                                                let gZ = gY._7
1115+                                                let dJ = gY._9
1116+                                                let es = gY._10
1117+                                                let et = gY._11
1118+                                                let dr = gY._12
1119+                                                let ds = gY._13
1120+                                                let ed = invoke(aU, "emit", [er], nil)
1121+                                                if ((ed == ed))
11261122                                                     then {
1127-                                                        let hd = {
1128-                                                            let aP = eg
1129-                                                            if ($isInstanceOf(aP, "Address"))
1123+                                                        let ha = {
1124+                                                            let aQ = ed
1125+                                                            if ($isInstanceOf(aQ, "Address"))
11301126                                                                 then {
1131-                                                                    let he = aP
1132-                                                                    invoke(he, "emit", [eu], nil)
1127+                                                                    let hb = aQ
1128+                                                                    invoke(hb, "emit", [er], nil)
11331129                                                                     }
11341130                                                                 else unit
11351131                                                             }
1136-                                                        if ((hd == hd))
1132+                                                        if ((ha == ha))
11371133                                                             then {
1138-                                                                let hf = if ((ev > 0))
1139-                                                                    then invoke(gY, "put", nil, [AttachedPayment(ds, ev)])
1134+                                                                let hc = if ((es > 0))
1135+                                                                    then invoke(gV, "put", nil, [AttachedPayment(dr, es)])
11401136                                                                     else nil
1141-                                                                if ((hf == hf))
1137+                                                                if ((hc == hc))
11421138                                                                     then {
1143-                                                                        let hg = if ((ew > 0))
1144-                                                                            then invoke(gY, "put", nil, [AttachedPayment(dt, ew)])
1139+                                                                        let hd = if ((et > 0))
1140+                                                                            then invoke(gV, "put", nil, [AttachedPayment(ds, et)])
11451141                                                                             else nil
1146-                                                                        if ((hg == hg))
1142+                                                                        if ((hd == hd))
11471143                                                                             then {
1148-                                                                                let hh = if (gV)
1144+                                                                                let he = if (gS)
11491145                                                                                     then {
1150-                                                                                        let hi = invoke(gX, "stake", nil, [AttachedPayment(hc, eu)])
1151-                                                                                        if ((hi == hi))
1146+                                                                                        let hf = invoke(gU, "stake", nil, [AttachedPayment(gZ, er)])
1147+                                                                                        if ((hf == hf))
11521148                                                                                             then nil
11531149                                                                                             else throw("Strict value is not equal to itself.")
11541150                                                                                         }
1155-                                                                                    else [ScriptTransfer(cY.caller, eu, hc)]
1156-                                                                                let hj = fb(0, 0, 0)
1157-                                                                                let gr = hj._1
1158-                                                                                let eS = hj._2
1159-                                                                                let hk = if ((eS >= fa))
1151+                                                                                    else [ScriptTransfer(cX.caller, er, gZ)]
1152+                                                                                let hg = eY(0, 0, 0)
1153+                                                                                let go = hg._1
1154+                                                                                let eP = hg._2
1155+                                                                                let hh = if ((eP >= eX))
11601156                                                                                     then true
1161-                                                                                    else aZ(makeString(["updated DLp lower than current DLp", toString(eX), toString(eY), toString(eZ), toString(fa), toString(eS), toString(ev), toString(ew)], " "))
1162-                                                                                if ((hk == hk))
1157+                                                                                    else ba(makeString(["updated DLp lower than current DLp", toString(eU), toString(eV), toString(eW), toString(eX), toString(eP), toString(es), toString(et)], " "))
1158+                                                                                if ((hh == hh))
11631159                                                                                     then {
1164-                                                                                        let hl = value(assetInfo(bw)).quantity
1165-                                                                                        if ((hl == hl))
1166-                                                                                            then ((dK ++ hh) ++ gr)
1160+                                                                                        let hi = value(assetInfo(bx)).quantity
1161+                                                                                        if ((hi == hi))
1162+                                                                                            then ((dJ ++ he) ++ go)
11671163                                                                                             else throw("Strict value is not equal to itself.")
11681164                                                                                         }
11691165                                                                                     else throw("Strict value is not equal to itself.")
11881184 
11891185 
11901186 
1191-@Callable(cY)
1192-func putOneTknV2 (fV,gV) = {
1193-    let hm = {
1194-        let bd = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1195-        if ($isInstanceOf(bd, "Boolean"))
1196-            then bd
1197-            else throw(($getType(bd) + " couldn't be cast to Boolean"))
1187+@Callable(cX)
1188+func putOneTknV2 (fS,gS) = {
1189+    let hj = {
1190+        let be = invoke(aU, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1191+        if ($isInstanceOf(be, "Boolean"))
1192+            then be
1193+            else throw(($getType(be) + " couldn't be cast to Boolean"))
11981194         }
1199-    let hn = if (if (if (bg())
1195+    let hk = if (if (if (bh())
12001196         then true
1201-        else (bv == q))
1197+        else (bw == r))
12021198         then true
1203-        else (bv == s))
1199+        else (bw == t))
12041200         then true
1205-        else hm
1206-    let gQ = [if (if (!(hn))
1201+        else hj
1202+    let gN = [if (if (!(hk))
12071203         then true
1208-        else gw(cY))
1204+        else gt(cX))
12091205         then true
1210-        else aZ("put operation is blocked by admin"), if ((size(cY.payments) == 1))
1206+        else ba("put operation is blocked by admin"), if ((size(cX.payments) == 1))
12111207         then true
1212-        else aZ("exactly 1 payment are expected")]
1213-    if ((gQ == gQ))
1208+        else ba("exactly 1 payment are expected")]
1209+    if ((gN == gN))
12141210         then {
1215-            let ds = toBase58String(value(bx))
1216-            let dt = toBase58String(value(by))
1217-            let dr = bw
1218-            let fZ = bz
1219-            let ga = bA
1220-            let dq = if ((cY.caller == this))
1221-                then cY.originCaller
1222-                else cY.caller
1223-            let ft = value(cY.payments[0])
1224-            let do = toBase58String(value(ft.assetId))
1225-            let dU = ft.amount
1226-            let fa = if ((ft.assetId == bx))
1227-                then eT(toBigInt(dU), toBigInt(0), toBigInt(0))
1228-                else eT(toBigInt(0), toBigInt(dU), toBigInt(0))
1229-            if ((fa == fa))
1211+            let dr = toBase58String(value(by))
1212+            let ds = toBase58String(value(bz))
1213+            let dq = bx
1214+            let fW = bA
1215+            let fX = bB
1216+            let dp = if ((cX.caller == this))
1217+                then cX.originCaller
1218+                else cX.caller
1219+            let fq = value(cX.payments[0])
1220+            let dn = toBase58String(value(fq.assetId))
1221+            let dT = fq.amount
1222+            let eX = if ((fq.assetId == by))
1223+                then eQ(toBigInt(dT), toBigInt(0), toBigInt(0))
1224+                else eQ(toBigInt(0), toBigInt(dT), toBigInt(0))
1225+            if ((eX == eX))
12301226                 then {
1231-                    let ho = fy(dU, do, toString(dq), toBase58String(cY.transactionId), true)
1232-                    if ((ho == ho))
1227+                    let hl = fv(dT, dn, toString(dp), toBase58String(cX.transactionId), true)
1228+                    if ((hl == hl))
12331229                         then {
1234-                            let cI = ho._3
1235-                            let dK = ho._2
1236-                            let hp = ho._1
1237-                            let eu = if (if ((fV > 0))
1238-                                then (fV > hp)
1230+                            let cH = hl._3
1231+                            let dJ = hl._2
1232+                            let hm = hl._1
1233+                            let er = if (if ((fS > 0))
1234+                                then (fS > hm)
12391235                                 else false)
1240-                                then aZ(makeString(["amount to receive is less than ", toString(fV)], ""))
1241-                                else hp
1242-                            let hb = invoke(aT, "emit", [eu], nil)
1243-                            if ((hb == hb))
1236+                                then ba(makeString(["amount to receive is less than ", toString(fS)], ""))
1237+                                else hm
1238+                            let gY = invoke(aU, "emit", [er], nil)
1239+                            if ((gY == gY))
12441240                                 then {
1245-                                    let hd = {
1246-                                        let aP = hb
1247-                                        if ($isInstanceOf(aP, "Address"))
1241+                                    let ha = {
1242+                                        let aQ = gY
1243+                                        if ($isInstanceOf(aQ, "Address"))
12481244                                             then {
1249-                                                let he = aP
1250-                                                invoke(he, "emit", [eu], nil)
1245+                                                let hb = aQ
1246+                                                invoke(hb, "emit", [er], nil)
12511247                                                 }
12521248                                             else unit
12531249                                         }
1254-                                    if ((hd == hd))
1250+                                    if ((ha == ha))
12551251                                         then {
1256-                                            let hh = if (gV)
1252+                                            let he = if (gS)
12571253                                                 then {
1258-                                                    let hi = invoke(bF, "stakeFor", [toString(cY.caller)], [AttachedPayment(dr, eu)])
1259-                                                    if ((hi == hi))
1254+                                                    let hf = invoke(bE, "stakeFor", [toString(cX.caller)], [AttachedPayment(dq, er)])
1255+                                                    if ((hf == hf))
12601256                                                         then nil
12611257                                                         else throw("Strict value is not equal to itself.")
12621258                                                     }
1263-                                                else [ScriptTransfer(cY.caller, eu, dr)]
1264-                                            let gl = if ((cI > 0))
1265-                                                then [ScriptTransfer(bi, cI, fromBase58String(do))]
1259+                                                else [ScriptTransfer(cX.caller, er, dq)]
1260+                                            let gi = if ((cH > 0))
1261+                                                then [ScriptTransfer(bj, cH, fromBase58String(dn))]
12661262                                                 else nil
1267-                                            let hq = if ((this == bi))
1263+                                            let hn = if ((this == bj))
12681264                                                 then $Tuple2(0, 0)
12691265                                                 else {
1270-                                                    let hr = if ((ft.assetId == bx))
1266+                                                    let ho = if ((fq.assetId == by))
12711267                                                         then true
12721268                                                         else false
1273-                                                    if (hr)
1274-                                                        then $Tuple2(-(cI), 0)
1275-                                                        else $Tuple2(0, -(cI))
1269+                                                    if (ho)
1270+                                                        then $Tuple2(-(cH), 0)
1271+                                                        else $Tuple2(0, -(cH))
12761272                                                     }
1277-                                            let fc = hq._1
1278-                                            let fd = hq._2
1279-                                            let hs = fb(fc, fd, 0)
1280-                                            let gr = hs._1
1281-                                            let eS = hs._2
1282-                                            let gs = ff(fa, eS)
1283-                                            if ((gs == gs))
1284-                                                then $Tuple2((((dK ++ hh) ++ gl) ++ gr), eu)
1273+                                            let eZ = hn._1
1274+                                            let fa = hn._2
1275+                                            let hp = eY(eZ, fa, 0)
1276+                                            let go = hp._1
1277+                                            let eP = hp._2
1278+                                            let gp = fc(eX, eP)
1279+                                            if ((gp == gp))
1280+                                                then $Tuple2((((dJ ++ he) ++ gi) ++ go), er)
12851281                                                 else throw("Strict value is not equal to itself.")
12861282                                             }
12871283                                         else throw("Strict value is not equal to itself.")
12971293 
12981294 
12991295 
1300-@Callable(cY)
1301-func putForFree (ht) = if ((0 > ht))
1296+@Callable(cX)
1297+func putForFree (hq) = if ((0 > hq))
13021298     then throw("Wrong slpg")
1303-    else if ((size(cY.payments) != 2))
1299+    else if ((size(cX.payments) != 2))
13041300         then throw("2 pmnts expd")
13051301         else {
1306-            let hu = fu(toString(cY.caller), toBase58String(cY.transactionId), AttachedPayment(value(cY.payments[0]).assetId, value(cY.payments[0]).amount), cY.payments[1], ht, false, false, true, 0, "")
1307-            let dK = hu._9
1308-            let gZ = toBigInt(value(cY.payments[0]).amount)
1309-            let ha = toBigInt(value(cY.payments[1]).amount)
1310-            let fa = eT(gZ, ha, toBigInt(0))
1311-            if ((fa == fa))
1302+            let hr = fr(toString(cX.caller), toBase58String(cX.transactionId), AttachedPayment(value(cX.payments[0]).assetId, value(cX.payments[0]).amount), cX.payments[1], hq, false, false, true, 0, "")
1303+            let dJ = hr._9
1304+            let gW = toBigInt(value(cX.payments[0]).amount)
1305+            let gX = toBigInt(value(cX.payments[1]).amount)
1306+            let eX = eQ(gW, gX, toBigInt(0))
1307+            if ((eX == eX))
13121308                 then {
1313-                    let hv = fb(0, 0, 0)
1314-                    let gr = hv._1
1315-                    let eS = hv._2
1316-                    let gs = ff(fa, eS)
1317-                    if ((gs == gs))
1318-                        then (dK ++ gr)
1309+                    let hs = eY(0, 0, 0)
1310+                    let go = hs._1
1311+                    let eP = hs._2
1312+                    let gp = fc(eX, eP)
1313+                    if ((gp == gp))
1314+                        then (dJ ++ go)
13191315                         else throw("Strict value is not equal to itself.")
13201316                     }
13211317                 else throw("Strict value is not equal to itself.")
13231319 
13241320 
13251321 
1326-@Callable(cY)
1322+@Callable(cX)
13271323 func get () = {
1328-    let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1329-    if ((fa == fa))
1324+    let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1325+    if ((eX == eX))
13301326         then {
1331-            let eg = fs(cY)
1332-            let hw = eg._1
1333-            let dJ = eg._2
1334-            let dU = eg._3
1335-            let do = eg._4
1336-            let dK = eg._5
1337-            let eH = invoke(aT, "burn", [dU], [AttachedPayment(do, dU)])
1338-            if ((eH == eH))
1327+            let ed = fp(cX)
1328+            let ht = ed._1
1329+            let dI = ed._2
1330+            let dT = ed._3
1331+            let dn = ed._4
1332+            let dJ = ed._5
1333+            let eE = invoke(aU, "burn", [dT], [AttachedPayment(dn, dT)])
1334+            if ((eE == eE))
13391335                 then {
1340-                    let hx = fb(-(hw), -(dJ), 0)
1341-                    let gr = hx._1
1342-                    let eS = hx._2
1343-                    let gs = ff(fa, eS)
1344-                    if ((gs == gs))
1345-                        then (dK ++ gr)
1336+                    let hu = eY(-(ht), -(dI), 0)
1337+                    let go = hu._1
1338+                    let eP = hu._2
1339+                    let gp = fc(eX, eP)
1340+                    if ((gp == gp))
1341+                        then (dJ ++ go)
13461342                         else throw("Strict value is not equal to itself.")
13471343                     }
13481344                 else throw("Strict value is not equal to itself.")
13521348 
13531349 
13541350 
1355-@Callable(cY)
1356-func getOneTknV2 (fU,fV) = {
1357-    let hm = {
1358-        let bd = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1359-        if ($isInstanceOf(bd, "Boolean"))
1360-            then bd
1361-            else throw(($getType(bd) + " couldn't be cast to Boolean"))
1351+@Callable(cX)
1352+func getOneTknV2 (fR,fS) = {
1353+    let hj = {
1354+        let be = invoke(aU, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1355+        if ($isInstanceOf(be, "Boolean"))
1356+            then be
1357+            else throw(($getType(be) + " couldn't be cast to Boolean"))
13621358         }
1363-    let hy = if (if (bg())
1359+    let hv = if (if (bh())
13641360         then true
1365-        else (bv == s))
1361+        else (bw == t))
13661362         then true
1367-        else hm
1368-    let gQ = [if (if (!(hy))
1363+        else hj
1364+    let gN = [if (if (!(hv))
13691365         then true
1370-        else gw(cY))
1366+        else gt(cX))
13711367         then true
1372-        else aZ("get operation is blocked by admin"), if ((size(cY.payments) == 1))
1368+        else ba("get operation is blocked by admin"), if ((size(cX.payments) == 1))
13731369         then true
1374-        else aZ("exactly 1 payment are expected")]
1375-    if ((gQ == gQ))
1370+        else ba("exactly 1 payment are expected")]
1371+    if ((gN == gN))
13761372         then {
1377-            let hz = fT(fU, fV, cY.payments, cY.caller, cY.originCaller, cY.transactionId)
1378-            let dK = hz._1
1379-            let ge = hz._2
1380-            $Tuple2(dK, ge)
1373+            let hw = fQ(fR, fS, cX.payments, cX.caller, cX.originCaller, cX.transactionId)
1374+            let dJ = hw._1
1375+            let gb = hw._2
1376+            $Tuple2(dJ, gb)
13811377             }
13821378         else throw("Strict value is not equal to itself.")
13831379     }
13841380 
13851381 
13861382 
1387-@Callable(cY)
1383+@Callable(cX)
13881384 func refreshDLp () = {
1389-    let hA = valueOrElse(getInteger(as), 0)
1390-    let hB = if (((height - hA) >= av))
1385+    let hx = valueOrElse(getInteger(at), 0)
1386+    let hy = if (((height - hx) >= aw))
13911387         then unit
1392-        else aZ(makeString([toString(av), " blocks have not passed since the previous call"], ""))
1393-    if ((hB == hB))
1388+        else ba(makeString([toString(aw), " blocks have not passed since the previous call"], ""))
1389+    if ((hy == hy))
13941390         then {
1395-            let fm = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, ar), "0")), bb("invalid dLp"))
1396-            let hC = fb(0, 0, 0)
1397-            let hD = hC._1
1398-            let eS = hC._2
1399-            let fe = if ((fm != eS))
1400-                then hD
1401-                else aZ("nothing to refresh")
1402-            $Tuple2(fe, toString(eS))
1391+            let fj = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, as), "0")), bc("invalid dLp"))
1392+            let hz = eY(0, 0, 0)
1393+            let hA = hz._1
1394+            let eP = hz._2
1395+            let fb = if ((fj != eP))
1396+                then hA
1397+                else ba("nothing to refresh")
1398+            $Tuple2(fb, toString(eP))
14031399             }
14041400         else throw("Strict value is not equal to itself.")
14051401     }
14061402 
14071403 
14081404 
1409-@Callable(cY)
1410-func getOneTknV2READONLY (fU,hE) = {
1411-    let ds = toBase58String(value(bx))
1412-    let dt = toBase58String(value(by))
1413-    let dr = toBase58String(value(bw))
1414-    let cK = [toBigInt(bY(ds)), toBigInt(bY(dt))]
1415-    let eR = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(dr)), "invalid lp asset").quantity)
1416-    let cm = cJ(cK)
1417-    let cl = (cm - fraction(toBigInt(hE), cm, eR))
1418-    let hF = if ((fU == ds))
1405+@Callable(cX)
1406+func getOneTknV2READONLY (fR,hB) = {
1407+    let dr = toBase58String(value(by))
1408+    let ds = toBase58String(value(bz))
1409+    let dq = toBase58String(value(bx))
1410+    let cJ = [toBigInt(bX(dr)), toBigInt(bX(ds))]
1411+    let eO = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(dq)), "invalid lp asset").quantity)
1412+    let cl = cI(cJ)
1413+    let ck = (cl - fraction(toBigInt(hB), cl, eO))
1414+    let hC = if ((fR == dr))
14191415         then 0
1420-        else if ((fU == dt))
1416+        else if ((fR == ds))
14211417             then 1
14221418             else throw("invalid out asset id")
1423-    let hG = eB(cK, hF, cl)
1424-    let gJ = (cK[hF] - hG)
1425-    let gK = max([0, toInt((gJ - f))])
1426-    let hH = cG(gK, be)
1427-    let gd = hH._1
1428-    let cI = hH._2
1429-    $Tuple2(nil, $Tuple2(gd, cI))
1419+    let hD = ey(cJ, hC, ck)
1420+    let gG = (cJ[hC] - hD)
1421+    let gH = max([0, toInt((gG - f))])
1422+    let hE = cF(gH, bf)
1423+    let ga = hE._1
1424+    let cH = hE._2
1425+    $Tuple2(nil, $Tuple2(ga, cH))
14301426     }
14311427 
14321428 
14331429 
1434-@Callable(cY)
1435-func getOneTknV2WithBonusREADONLY (fU,hE) = {
1436-    let ds = toBase58String(value(bx))
1437-    let dt = toBase58String(value(by))
1438-    let dr = toBase58String(value(bw))
1439-    let dy = bY(ds)
1440-    let dA = bY(dt)
1441-    let hI = {
1442-        let bd = invoke(this, "getOneTknV2READONLY", [fU, hE], nil)
1443-        if ($isInstanceOf(bd, "(Int, Int)"))
1444-            then bd
1445-            else throw(($getType(bd) + " couldn't be cast to (Int, Int)"))
1430+@Callable(cX)
1431+func getOneTknV2WithBonusREADONLY (fR,hB) = {
1432+    let dr = toBase58String(value(by))
1433+    let ds = toBase58String(value(bz))
1434+    let dq = toBase58String(value(bx))
1435+    let dx = bX(dr)
1436+    let dz = bX(ds)
1437+    let hF = {
1438+        let be = invoke(this, "getOneTknV2READONLY", [fR, hB], nil)
1439+        if ($isInstanceOf(be, "(Int, Int)"))
1440+            then be
1441+            else throw(($getType(be) + " couldn't be cast to (Int, Int)"))
14461442         }
1447-    let gd = hI._1
1448-    let cI = hI._2
1449-    let eg = dm("", dr, hE, this)
1450-    let dI = eg._1
1451-    let dJ = eg._2
1452-    let hJ = (dI + dJ)
1453-    let fS = if ((hJ == 0))
1454-        then if ((gd == 0))
1443+    let ga = hF._1
1444+    let cH = hF._2
1445+    let ed = dl("", dq, hB, this)
1446+    let dH = ed._1
1447+    let dI = ed._2
1448+    let hG = (dH + dI)
1449+    let fP = if ((hG == 0))
1450+        then if ((ga == 0))
14551451             then 0
14561452             else throw("bonus calculation error")
1457-        else fraction((gd - hJ), a, hJ)
1458-    $Tuple2(nil, $Tuple3(gd, cI, fS))
1453+        else fraction((ga - hG), a, hG)
1454+    $Tuple2(nil, $Tuple3(ga, cH, fP))
14591455     }
14601456 
14611457 
14621458 
1463-@Callable(cY)
1464-func getNoLess (hK,hL) = {
1465-    let eg = fs(cY)
1466-    let dI = eg._1
1467-    let dJ = eg._2
1468-    let dU = eg._3
1469-    let do = eg._4
1470-    let dK = eg._5
1471-    if ((hK > dI))
1472-        then throw(((("Failed:  " + toString(dI)) + " < ") + toString(hK)))
1473-        else if ((hL > dJ))
1474-            then throw(((("Failed: " + toString(dJ)) + " < ") + toString(hL)))
1459+@Callable(cX)
1460+func getNoLess (hH,hI) = {
1461+    let ed = fp(cX)
1462+    let dH = ed._1
1463+    let dI = ed._2
1464+    let dT = ed._3
1465+    let dn = ed._4
1466+    let dJ = ed._5
1467+    if ((hH > dH))
1468+        then throw(((("Failed:  " + toString(dH)) + " < ") + toString(hH)))
1469+        else if ((hI > dI))
1470+            then throw(((("Failed: " + toString(dI)) + " < ") + toString(hI)))
14751471             else {
1476-                let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1477-                if ((fa == fa))
1472+                let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1473+                if ((eX == eX))
14781474                     then {
1479-                        let hM = invoke(aT, "burn", [dU], [AttachedPayment(do, dU)])
1480-                        if ((hM == hM))
1475+                        let hJ = invoke(aU, "burn", [dT], [AttachedPayment(dn, dT)])
1476+                        if ((hJ == hJ))
14811477                             then {
1482-                                let hN = fb(-(dI), -(dJ), 0)
1483-                                let gr = hN._1
1484-                                let eS = hN._2
1485-                                let gs = ff(fa, eS)
1486-                                if ((gs == gs))
1487-                                    then (dK ++ gr)
1478+                                let hK = eY(-(dH), -(dI), 0)
1479+                                let go = hK._1
1480+                                let eP = hK._2
1481+                                let gp = fc(eX, eP)
1482+                                if ((gp == gp))
1483+                                    then (dJ ++ go)
14881484                                     else throw("Strict value is not equal to itself.")
14891485                                 }
14901486                             else throw("Strict value is not equal to itself.")
14951491 
14961492 
14971493 
1498-@Callable(cY)
1499-func unstakeAndGet (cH) = {
1500-    let hO = if ((size(cY.payments) != 0))
1494+@Callable(cX)
1495+func unstakeAndGet (cG) = {
1496+    let hL = if ((size(cX.payments) != 0))
15011497         then throw("No pmnts expd")
15021498         else true
1503-    if ((hO == hO))
1499+    if ((hL == hL))
15041500         then {
1505-            let hP = bD()
1506-            let hc = bw
1507-            let hQ = valueOrErrorMessage(addressFromString(hP[C]), "Wr st addr")
1508-            let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1509-            if ((fa == fa))
1501+            let hM = bC()
1502+            let gZ = bx
1503+            let hN = valueOrErrorMessage(addressFromString(hM[D]), "Wr st addr")
1504+            let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1505+            if ((eX == eX))
15101506                 then {
1511-                    let hR = invoke(hQ, "unstake", [toBase58String(hc), cH], nil)
1512-                    if ((hR == hR))
1507+                    let hO = invoke(hN, "unstake", [toBase58String(gZ), cG], nil)
1508+                    if ((hO == hO))
15131509                         then {
1514-                            let eg = dm(toBase58String(cY.transactionId), toBase58String(hc), cH, cY.caller)
1515-                            let dI = eg._1
1516-                            let dJ = eg._2
1517-                            let dw = parseIntValue(eg._9)
1518-                            let dK = eg._10
1519-                            let hS = if (if (bg())
1510+                            let ed = dl(toBase58String(cX.transactionId), toBase58String(gZ), cG, cX.caller)
1511+                            let dH = ed._1
1512+                            let dI = ed._2
1513+                            let dv = parseIntValue(ed._9)
1514+                            let dJ = ed._10
1515+                            let hP = if (if (bh())
15201516                                 then true
1521-                                else (dw == s))
1522-                                then throw(("Blocked: " + toString(dw)))
1517+                                else (dv == t))
1518+                                then throw(("Blocked: " + toString(dv)))
15231519                                 else true
1524-                            if ((hS == hS))
1520+                            if ((hP == hP))
15251521                                 then {
1526-                                    let hT = invoke(aT, "burn", [cH], [AttachedPayment(hc, cH)])
1527-                                    if ((hT == hT))
1522+                                    let hQ = invoke(aU, "burn", [cG], [AttachedPayment(gZ, cG)])
1523+                                    if ((hQ == hQ))
15281524                                         then {
1529-                                            let hU = fb(-(dI), -(dJ), 0)
1530-                                            let gr = hU._1
1531-                                            let eS = hU._2
1532-                                            let gs = ff(fa, eS)
1533-                                            if ((gs == gs))
1534-                                                then (dK ++ gr)
1525+                                            let hR = eY(-(dH), -(dI), 0)
1526+                                            let go = hR._1
1527+                                            let eP = hR._2
1528+                                            let gp = fc(eX, eP)
1529+                                            if ((gp == gp))
1530+                                                then (dJ ++ go)
15351531                                                 else throw("Strict value is not equal to itself.")
15361532                                             }
15371533                                         else throw("Strict value is not equal to itself.")
15471543 
15481544 
15491545 
1550-@Callable(cY)
1551-func unstakeAndGetNoLess (hV,hW,hL) = {
1552-    let hy = if (bg())
1546+@Callable(cX)
1547+func unstakeAndGetNoLess (hS,hT,hI) = {
1548+    let hv = if (bh())
15531549         then true
1554-        else (bv == s)
1555-    let gQ = [if (!(hy))
1550+        else (bw == t)
1551+    let gN = [if (!(hv))
15561552         then true
1557-        else throw("get operation is blocked by admin"), if ((size(cY.payments) == 0))
1553+        else throw("get operation is blocked by admin"), if ((size(cX.payments) == 0))
15581554         then true
15591555         else throw("no payments are expected")]
1560-    if ((gQ == gQ))
1556+    if ((gN == gN))
15611557         then {
1562-            let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1563-            if ((fa == fa))
1558+            let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1559+            if ((eX == eX))
15641560                 then {
1565-                    let hR = invoke(bF, "unstake", [toBase58String(bw), hV], nil)
1566-                    if ((hR == hR))
1561+                    let hO = invoke(bE, "unstake", [toBase58String(bx), hS], nil)
1562+                    if ((hO == hO))
15671563                         then {
1568-                            let hX = dm(toBase58String(cY.transactionId), toBase58String(bw), hV, cY.caller)
1569-                            let dI = hX._1
1570-                            let dJ = hX._2
1571-                            let dK = hX._10
1572-                            let hY = [if ((dI >= hW))
1564+                            let hU = dl(toBase58String(cX.transactionId), toBase58String(bx), hS, cX.caller)
1565+                            let dH = hU._1
1566+                            let dI = hU._2
1567+                            let dJ = hU._10
1568+                            let hV = [if ((dH >= hT))
15731569                                 then true
1574-                                else throw(makeString(["amount asset amount to receive is less than ", toString(hW)], "")), if ((dJ >= hL))
1570+                                else throw(makeString(["amount asset amount to receive is less than ", toString(hT)], "")), if ((dI >= hI))
15751571                                 then true
1576-                                else throw(makeString(["price asset amount to receive is less than ", toString(hL)], ""))]
1577-                            if ((hY == hY))
1572+                                else throw(makeString(["price asset amount to receive is less than ", toString(hI)], ""))]
1573+                            if ((hV == hV))
15781574                                 then {
1579-                                    let hM = invoke(aT, "burn", [hV], [AttachedPayment(bw, hV)])
1580-                                    if ((hM == hM))
1575+                                    let hJ = invoke(aU, "burn", [hS], [AttachedPayment(bx, hS)])
1576+                                    if ((hJ == hJ))
15811577                                         then {
1582-                                            let hZ = fb(-(dI), -(dJ), 0)
1583-                                            let gr = hZ._1
1584-                                            let eS = hZ._2
1585-                                            let gs = ff(fa, eS)
1586-                                            if ((gs == gs))
1587-                                                then (dK ++ gr)
1578+                                            let hW = eY(-(dH), -(dI), 0)
1579+                                            let go = hW._1
1580+                                            let eP = hW._2
1581+                                            let gp = fc(eX, eP)
1582+                                            if ((gp == gp))
1583+                                                then (dJ ++ go)
15881584                                                 else throw("Strict value is not equal to itself.")
15891585                                             }
15901586                                         else throw("Strict value is not equal to itself.")
16001596 
16011597 
16021598 
1603-@Callable(cY)
1604-func unstakeAndGetOneTknV2 (hV,fU,fV) = {
1605-    let hm = {
1606-        let bd = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1607-        if ($isInstanceOf(bd, "Boolean"))
1608-            then bd
1609-            else throw(($getType(bd) + " couldn't be cast to Boolean"))
1599+@Callable(cX)
1600+func unstakeAndGetOneTknV2 (hS,fR,fS) = {
1601+    let hj = {
1602+        let be = invoke(aU, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1603+        if ($isInstanceOf(be, "Boolean"))
1604+            then be
1605+            else throw(($getType(be) + " couldn't be cast to Boolean"))
16101606         }
1611-    let hy = if (if (bg())
1607+    let hv = if (if (bh())
16121608         then true
1613-        else (bv == s))
1609+        else (bw == t))
16141610         then true
1615-        else hm
1616-    let gQ = [if (if (!(hy))
1611+        else hj
1612+    let gN = [if (if (!(hv))
16171613         then true
1618-        else gw(cY))
1614+        else gt(cX))
16191615         then true
1620-        else aZ("get operation is blocked by admin"), if ((size(cY.payments) == 0))
1616+        else ba("get operation is blocked by admin"), if ((size(cX.payments) == 0))
16211617         then true
1622-        else aZ("no payments are expected")]
1623-    if ((gQ == gQ))
1618+        else ba("no payments are expected")]
1619+    if ((gN == gN))
16241620         then {
1625-            let hP = bD()
1626-            let hc = bw
1627-            let hQ = valueOrErrorMessage(addressFromString(hP[C]), "Wr st addr")
1628-            let dq = cY.caller
1629-            let ia = this
1630-            let hR = invoke(hQ, "unstakeINTERNAL", [hc, hV, dq.bytes, ia.bytes], nil)
1631-            if ((hR == hR))
1621+            let hM = bC()
1622+            let gZ = bx
1623+            let hN = valueOrErrorMessage(addressFromString(hM[D]), "Wr st addr")
1624+            let dp = cX.caller
1625+            let hX = this
1626+            let hO = invoke(hN, "unstakeINTERNAL", [gZ, hS, dp.bytes, hX.bytes], nil)
1627+            if ((hO == hO))
16321628                 then {
1633-                    let ib = fT(fU, fV, [AttachedPayment(hc, hV)], cY.caller, cY.originCaller, cY.transactionId)
1634-                    let dK = ib._1
1635-                    let ge = ib._2
1636-                    $Tuple2(dK, ge)
1629+                    let hY = fQ(fR, fS, [AttachedPayment(gZ, hS)], cX.caller, cX.originCaller, cX.transactionId)
1630+                    let dJ = hY._1
1631+                    let gb = hY._2
1632+                    $Tuple2(dJ, gb)
16371633                     }
16381634                 else throw("Strict value is not equal to itself.")
16391635             }
16421638 
16431639 
16441640 
1645-@Callable(cY)
1646-func putOneTknV2WithBonusREADONLY (ic,id) = {
1647-    let ie = fy(ic, id, "", "", true)
1648-    let fN = ie._1
1649-    let dK = ie._2
1650-    let cI = ie._3
1651-    let fS = ie._4
1652-    $Tuple2(nil, $Tuple3(fN, cI, fS))
1641+@Callable(cX)
1642+func putOneTknV2WithBonusREADONLY (hZ,ia) = {
1643+    let ib = fv(hZ, ia, "", "", true)
1644+    let fK = ib._1
1645+    let dJ = ib._2
1646+    let cH = ib._3
1647+    let fP = ib._4
1648+    $Tuple2(nil, $Tuple3(fK, cH, fP))
16531649     }
16541650 
16551651 
16561652 
1657-@Callable(cY)
1658-func putOneTknV2WithoutTakeFeeREADONLY (ic,id) = {
1659-    let if = fy(ic, id, "", "", false)
1660-    let fN = if._1
1661-    let dK = if._2
1662-    let cI = if._3
1663-    let fS = if._4
1664-    $Tuple2(nil, $Tuple3(fN, cI, fS))
1653+@Callable(cX)
1654+func putOneTknV2WithoutTakeFeeREADONLY (hZ,ia) = {
1655+    let ic = fv(hZ, ia, "", "", false)
1656+    let fK = ic._1
1657+    let dJ = ic._2
1658+    let cH = ic._3
1659+    let fP = ic._4
1660+    $Tuple2(nil, $Tuple3(fK, cH, fP))
16651661     }
16661662 
16671663 
16681664 
1669-@Callable(cY)
1670-func activate (ig,ih) = if ((toString(cY.caller) != toString(aT)))
1665+@Callable(cX)
1666+func activate (id,ie) = if ((toString(cX.caller) != toString(aU)))
16711667     then throw("denied")
1672-    else $Tuple2([StringEntry(aj(), ig), StringEntry(ak(), ih)], "success")
1668+    else $Tuple2([StringEntry(ak(), id), StringEntry(al(), ie), StringEntry(am(), toString(l))], "success")
16731669 
16741670 
16751671 
1676-@Callable(cY)
1677-func getPoolConfigWrapperREADONLY () = $Tuple2(nil, bj())
1672+@Callable(cX)
1673+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, bk())
16781674 
16791675 
16801676 
1681-@Callable(cY)
1682-func getAccBalanceWrapperREADONLY (bZ) = $Tuple2(nil, bY(bZ))
1677+@Callable(cX)
1678+func getAccBalanceWrapperREADONLY (bY) = $Tuple2(nil, bX(bY))
16831679 
16841680 
16851681 
1686-@Callable(cY)
1687-func calcPricesWrapperREADONLY (cs,ct,cx) = {
1688-    let ii = cw(cs, ct, cx)
1689-    $Tuple2(nil, [toString(ii[0]), toString(ii[1]), toString(ii[2])])
1682+@Callable(cX)
1683+func calcPricesWrapperREADONLY (cr,cs,cw) = {
1684+    let if = cv(cr, cs, cw)
1685+    $Tuple2(nil, [toString(if[0]), toString(if[1]), toString(if[2])])
16901686     }
16911687 
16921688 
16931689 
1694-@Callable(cY)
1695-func fromX18WrapperREADONLY (M,ij) = $Tuple2(nil, L(parseBigIntValue(M), ij))
1690+@Callable(cX)
1691+func fromX18WrapperREADONLY (N,ig) = $Tuple2(nil, M(parseBigIntValue(N), ig))
16961692 
16971693 
16981694 
1699-@Callable(cY)
1700-func toX18WrapperREADONLY (I,J) = $Tuple2(nil, toString(H(I, J)))
1695+@Callable(cX)
1696+func toX18WrapperREADONLY (J,K) = $Tuple2(nil, toString(I(J, K)))
17011697 
17021698 
17031699 
1704-@Callable(cY)
1705-func calcPriceBigIntWrapperREADONLY (cb,cc) = $Tuple2(nil, toString(ca(parseBigIntValue(cb), parseBigIntValue(cc))))
1700+@Callable(cX)
1701+func calcPriceBigIntWrapperREADONLY (ca,cb) = $Tuple2(nil, toString(bZ(parseBigIntValue(ca), parseBigIntValue(cb))))
17061702 
17071703 
17081704 
1709-@Callable(cY)
1710-func estimatePutOperationWrapperREADONLY (dn,ch,dM,dN,dO,dP,ik,dQ,dR) = $Tuple2(nil, dL(dn, ch, dM, dN, dO, dP, ik, dQ, dR, true, false, 0, ""))
1705+@Callable(cX)
1706+func estimatePutOperationWrapperREADONLY (dm,cg,dL,dM,dN,dO,ih,dP,dQ) = $Tuple2(nil, dK(dm, cg, dL, dM, dN, dO, ih, dP, dQ, true, false, 0, ""))
17111707 
17121708 
17131709 
1714-@Callable(cY)
1715-func estimateGetOperationWrapperREADONLY (dn,il,dp,ik) = {
1716-    let eg = dm(dn, il, dp, addressFromStringValue(ik))
1717-    $Tuple2(nil, $Tuple10(eg._1, eg._2, eg._3, eg._4, eg._5, eg._6, eg._7, toString(eg._8), eg._9, eg._10))
1710+@Callable(cX)
1711+func estimateGetOperationWrapperREADONLY (dm,ii,do,ih) = {
1712+    let ed = dl(dm, ii, do, addressFromStringValue(ih))
1713+    $Tuple2(nil, $Tuple10(ed._1, ed._2, ed._3, ed._4, ed._5, ed._6, ed._7, toString(ed._8), ed._9, ed._10))
17181714     }
17191715 
17201716 
17211717 
1722-@Callable(cY)
1718+@Callable(cX)
17231719 func changeAmp () = {
1724-    let im = invoke(aT, "getChangeAmpConfigREADONLY", [toString(this)], nil)
1725-    let in = {
1726-        let aP = im
1727-        if ($isInstanceOf(aP, "List[Any]"))
1720+    let ij = invoke(aU, "getChangeAmpConfigREADONLY", [toString(this)], nil)
1721+    let ik = {
1722+        let aQ = ij
1723+        if ($isInstanceOf(aQ, "List[Any]"))
17281724             then {
1729-                let io = aP
1725+                let il = aQ
17301726                 $Tuple3({
1731-                    let bd = io[0]
1732-                    if ($isInstanceOf(bd, "Int"))
1733-                        then bd
1734-                        else throw(($getType(bd) + " couldn't be cast to Int"))
1727+                    let be = il[0]
1728+                    if ($isInstanceOf(be, "Int"))
1729+                        then be
1730+                        else throw(($getType(be) + " couldn't be cast to Int"))
17351731                     }, {
1736-                    let bd = io[1]
1737-                    if ($isInstanceOf(bd, "Int"))
1738-                        then bd
1739-                        else throw(($getType(bd) + " couldn't be cast to Int"))
1732+                    let be = il[1]
1733+                    if ($isInstanceOf(be, "Int"))
1734+                        then be
1735+                        else throw(($getType(be) + " couldn't be cast to Int"))
17401736                     }, {
1741-                    let bd = io[2]
1742-                    if ($isInstanceOf(bd, "Int"))
1743-                        then bd
1744-                        else throw(($getType(bd) + " couldn't be cast to Int"))
1737+                    let be = il[2]
1738+                    if ($isInstanceOf(be, "Int"))
1739+                        then be
1740+                        else throw(($getType(be) + " couldn't be cast to Int"))
17451741                     })
17461742                 }
1747-            else aZ("invalid entry type")
1743+            else ba("invalid entry type")
17481744         }
1749-    let ip = in._1
1750-    let iq = in._2
1751-    let ir = in._3
1752-    let is = parseIntValue(getStringValue(al()))
1753-    let it = (is + iq)
1754-    let iu = if ((0 > iq))
1755-        then if ((ir > it))
1756-            then ir
1757-            else it
1758-        else if ((it > ir))
1759-            then ir
1760-            else it
1761-    let iv = valueOrElse(getInteger(ao()), 0)
1762-    let iw = (iv + ip)
1763-    let gQ = [if ((height > iw))
1745+    let im = ik._1
1746+    let in = ik._2
1747+    let io = ik._3
1748+    let ip = parseIntValue(getStringValue(am()))
1749+    let iq = (ip + in)
1750+    let ir = if ((0 > in))
1751+        then if ((io > iq))
1752+            then io
1753+            else iq
1754+        else if ((iq > io))
1755+            then io
1756+            else iq
1757+    let is = valueOrElse(getInteger(ap()), 0)
1758+    let it = (is + im)
1759+    let gN = [if ((height > it))
17641760         then true
1765-        else aZ("try again in few blocks"), if ((is != iu))
1761+        else ba("try again in few blocks"), if ((ip != ir))
17661762         then true
1767-        else aZ("already reached target")]
1768-    if ((gQ == gQ))
1769-        then [IntegerEntry(ao(), height), StringEntry(al(), toString(iu)), StringEntry(am(height), toString(iu))]
1763+        else ba("already reached target")]
1764+    if ((gN == gN))
1765+        then [IntegerEntry(ap(), height), StringEntry(am(), toString(ir)), StringEntry(an(height), toString(ir))]
17701766         else throw("Strict value is not equal to itself.")
17711767     }
17721768 
17731769 
1774-@Verifier(ix)
1775-func iy () = {
1776-    let iz = {
1777-        let aP = gt()
1778-        if ($isInstanceOf(aP, "ByteVector"))
1770+@Verifier(iu)
1771+func iv () = {
1772+    let iw = {
1773+        let aQ = gq()
1774+        if ($isInstanceOf(aQ, "ByteVector"))
17791775             then {
1780-                let gx = aP
1781-                gx
1776+                let gu = aQ
1777+                gu
17821778                 }
1783-            else if ($isInstanceOf(aP, "Unit"))
1784-                then ix.senderPublicKey
1779+            else if ($isInstanceOf(aQ, "Unit"))
1780+                then iu.senderPublicKey
17851781                 else throw("Match error")
17861782         }
1787-    let aP = ix
1788-    if ($isInstanceOf(aP, "Order"))
1783+    let aQ = iu
1784+    if ($isInstanceOf(aQ, "Order"))
17891785         then {
1790-            let fi = aP
1791-            let iA = bh()
1792-            let iB = if (gE())
1786+            let ff = aQ
1787+            let ix = bi()
1788+            let iy = if (gB())
17931789                 then $Tuple2(true, "")
1794-                else fh(fi)
1795-            let aJ = iB._1
1796-            let aK = iB._2
1797-            let aL = sigVerify(fi.bodyBytes, fi.proofs[0], fi.senderPublicKey)
1798-            let aM = sigVerify(fi.bodyBytes, fi.proofs[1], iA)
1799-            if (if (if (aJ)
1800-                then aL
1801-                else false)
1790+                else fe(ff)
1791+            let aK = iy._1
1792+            let aL = iy._2
1793+            let aM = sigVerify(ff.bodyBytes, ff.proofs[0], ff.senderPublicKey)
1794+            let aN = sigVerify(ff.bodyBytes, ff.proofs[1], ix)
1795+            if (if (if (aK)
18021796                 then aM
18031797                 else false)
1798+                then aN
1799+                else false)
18041800                 then true
1805-                else aI(aJ, aK, aL, aM)
1801+                else aJ(aK, aL, aM, aN)
18061802             }
1807-        else if ($isInstanceOf(aP, "SetScriptTransaction"))
1803+        else if ($isInstanceOf(aQ, "SetScriptTransaction"))
18081804             then {
1809-                let aU = aP
1810-                if (sigVerify(ix.bodyBytes, ix.proofs[0], iz))
1805+                let aV = aQ
1806+                if (sigVerify(iu.bodyBytes, iu.proofs[0], iw))
18111807                     then true
18121808                     else {
1813-                        let iC = blake2b256(value(aU.script))
1814-                        let iD = fromBase64String(value(getString(aT, aE())))
1815-                        let iE = scriptHash(this)
1816-                        if ((iD == iC))
1817-                            then (iE != iC)
1809+                        let iz = blake2b256(value(aV.script))
1810+                        let iA = fromBase64String(value(getString(aU, aF())))
1811+                        let iB = scriptHash(this)
1812+                        if ((iA == iz))
1813+                            then (iB != iz)
18181814                             else false
18191815                         }
18201816                 }
1821-            else sigVerify(ix.bodyBytes, ix.proofs[0], iz)
1817+            else sigVerify(iu.bodyBytes, iu.proofs[0], iw)
18221818     }
18231819 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = 100000000
55 
66 let b = toBigInt(100000000)
77 
88 let c = toBigInt(1000000000000000000)
99 
1010 let d = toBigInt(0)
1111 
1212 let e = toBigInt(0)
1313 
1414 let f = toBigInt(1)
1515 
1616 let g = toBigInt(2)
1717 
1818 let h = toBigInt(3)
1919 
2020 let i = toBigInt(4)
2121 
2222 let j = toBigInt((a - ((a * 1) / a)))
2323 
2424 let k = "WAVES"
2525 
26-let l = "100"
26+let l = 50
2727 
28-let m = "1"
28+let m = "100"
2929 
30-let n = "__"
30+let n = "1"
3131 
32-let o = ""
32+let o = "__"
3333 
34-let p = 1
34+let p = ""
3535 
36-let q = 2
36+let q = 1
3737 
38-let r = 3
38+let r = 2
3939 
40-let s = 4
40+let s = 3
4141 
42-let t = 1
42+let t = 4
4343 
44-let u = 2
44+let u = 1
4545 
46-let v = 3
46+let v = 2
4747 
48-let w = 4
48+let w = 3
4949 
50-let x = 5
50+let x = 4
5151 
52-let y = 6
52+let y = 5
5353 
54-let z = 7
54+let z = 6
5555 
56-let A = 8
56+let A = 7
5757 
58-let B = 9
58+let B = 8
5959 
60-let C = 1
60+let C = 9
6161 
62-let D = 6
62+let D = 1
6363 
64-let E = 7
64+let E = 6
6565 
66-let F = 10
66+let F = 7
6767 
68-let G = fraction(10, a, 10000)
68+let G = 10
6969 
70-func H (I,J) = fraction(toBigInt(I), c, toBigInt(J))
70+let H = fraction(10, a, 10000)
71+
72+func I (J,K) = fraction(toBigInt(J), c, toBigInt(K))
7173 
7274 
73-func K (I,J) = fraction(I, c, J)
75+func L (J,K) = fraction(J, c, K)
7476 
7577 
76-func L (M,N) = toInt(fraction(M, toBigInt(N), c))
78+func M (N,O) = toInt(fraction(N, toBigInt(O), c))
7779 
7880 
79-func O (M,N,P) = toInt(fraction(M, toBigInt(N), c, P))
81+func P (N,O,Q) = toInt(fraction(N, toBigInt(O), c, Q))
8082 
8183 
82-func Q (I,J) = fraction(I, c, toBigInt(J))
84+func R (J,K) = fraction(J, c, toBigInt(K))
8385 
8486 
85-func R (M,N) = fraction(M, toBigInt(N), c)
87+func S (N,O) = fraction(N, toBigInt(O), c)
8688 
8789 
88-func S (T,U,V) = fraction(T, U, V)
90+func T (U,V,W) = fraction(U, V, W)
8991 
9092 
91-func W (M) = if ((d > M))
92-    then -(M)
93-    else M
93+func X (N) = if ((d > N))
94+    then -(N)
95+    else N
9496 
9597 
96-func X (M) = if ((d > M))
97-    then -(M)
98-    else M
98+func Y (N) = if ((d > N))
99+    then -(N)
100+    else N
99101 
100102 
101-func Y () = "%s__factoryContract"
103+func Z () = "%s__factoryContract"
102104 
103105 
104-func Z () = "%s__managerPublicKey"
106+func aa () = "%s__managerPublicKey"
105107 
106108 
107-func aa () = "%s__managerVaultAddress"
109+func ab () = "%s__managerVaultAddress"
108110 
109111 
110-func ab () = "%s%s__price__last"
112+func ac () = "%s%s__price__last"
111113 
112114 
113-func ac (ad,ae) = makeString(["%s%s%d%d__price__history", toString(ad), toString(ae)], n)
115+func ad (ae,af) = makeString(["%s%s%d%d__price__history", toString(ae), toString(af)], o)
114116 
115117 
116-func af (ag,ah) = ((("%s%s%s__P__" + ag) + "__") + ah)
118+func ag (ah,ai) = ((("%s%s%s__P__" + ah) + "__") + ai)
117119 
118120 
119-func ai (ag,ah) = ((("%s%s%s__G__" + ag) + "__") + ah)
121+func aj (ah,ai) = ((("%s%s%s__G__" + ah) + "__") + ai)
120122 
121123 
122-func aj () = "%s__amountAsset"
124+func ak () = "%s__amountAsset"
123125 
124126 
125-func ak () = "%s__priceAsset"
127+func al () = "%s__priceAsset"
126128 
127129 
128-func al () = "%s__amp"
130+func am () = "%s__amp"
129131 
130132 
131-func am (an) = ("%s%d__amp__" + toString(an))
133+func an (ao) = ("%s%d__amp__" + toString(ao))
132134 
133135 
134-func ao () = "%s__changeAmpLastCall"
136+func ap () = "%s__changeAmpLastCall"
135137 
136138 
137-let ap = "%s__fee"
139+let aq = "%s__fee"
138140 
139-let aq = valueOrElse(getInteger(this, ap), G)
141+let ar = valueOrElse(getInteger(this, aq), H)
140142 
141-let ar = makeString(["%s", "dLp"], n)
143+let as = makeString(["%s", "dLp"], o)
142144 
143-let as = makeString(["%s", "dLpRefreshedHeight"], n)
145+let at = makeString(["%s", "dLpRefreshedHeight"], o)
144146 
145-let at = makeString(["%s", "refreshDLpDelay"], n)
147+let au = makeString(["%s", "refreshDLpDelay"], o)
146148 
147-let au = 30
149+let av = 30
148150 
149-let av = valueOrElse(getInteger(this, at), au)
151+let aw = valueOrElse(getInteger(this, au), av)
150152 
151-func aw () = "%s__factoryConfig"
153+func ax () = "%s__factoryConfig"
152154 
153155 
154-func ax () = "%s%s__matcher__publicKey"
156+func ay () = "%s%s__matcher__publicKey"
155157 
156158 
157-func ay (az,aA) = (((("%d%d%s__" + az) + "__") + aA) + "__config")
159+func az (aA,aB) = (((("%d%d%s__" + aA) + "__") + aB) + "__config")
158160 
159161 
160-func aB (aC) = ("%s%s%s__mappings__baseAsset2internalId__" + aC)
162+func aC (aD) = ("%s%s%s__mappings__baseAsset2internalId__" + aD)
161163 
162164 
163-func aD () = "%s__shutdown"
165+func aE () = "%s__shutdown"
164166 
165167 
166-func aE () = "%s__allowedLpStableScriptHash"
168+func aF () = "%s__allowedLpStableScriptHash"
167169 
168170 
169-func aF () = "%s__feeCollectorAddress"
171+func aG () = "%s__feeCollectorAddress"
170172 
171173 
172-func aG (aH) = ("%s%s__skipOrderValidation__" + aH)
174+func aH (aI) = ("%s%s__skipOrderValidation__" + aI)
173175 
174176 
175-func aI (aJ,aK,aL,aM) = throw((((((((("order validation failed: orderValid=" + toString(aJ)) + " (") + aK) + ")") + " senderValid=") + toString(aL)) + " matcherValid=") + toString(aM)))
177+func aJ (aK,aL,aM,aN) = throw((((((((("order validation failed: orderValid=" + toString(aK)) + " (") + aL) + ")") + " senderValid=") + toString(aM)) + " matcherValid=") + toString(aN)))
176178 
177179 
178-func aN (aO) = {
179-    let aP = addressFromString(aO)
180-    if ($isInstanceOf(aP, "Address"))
180+func aO (aP) = {
181+    let aQ = addressFromString(aP)
182+    if ($isInstanceOf(aQ, "Address"))
181183         then {
182-            let aQ = aP
183-            aQ
184+            let aR = aQ
185+            aR
184186             }
185187         else this
186188     }
187189 
188190 
189-func aR () = {
190-    let aS = {
191-        let aP = getString(Y())
192-        if ($isInstanceOf(aP, "String"))
191+func aS () = {
192+    let aT = {
193+        let aQ = getString(Z())
194+        if ($isInstanceOf(aQ, "String"))
193195             then {
194-                let aT = aP
195-                aN(aT)
196+                let aU = aQ
197+                aO(aU)
196198                 }
197199             else this
198200         }
199-    let aP = getString(aS, aa())
200-    if ($isInstanceOf(aP, "String"))
201+    let aQ = getString(aT, ab())
202+    if ($isInstanceOf(aQ, "String"))
201203         then {
202-            let aU = aP
203-            aN(aU)
204+            let aV = aQ
205+            aO(aV)
204206             }
205207         else this
206208     }
207209 
208210 
209-func aV (aW,aX) = valueOrErrorMessage(getString(aW, aX), makeString(["mandatory ", toString(aW), ".", aX, " not defined"], ""))
211+func aW (aX,aY) = valueOrErrorMessage(getString(aX, aY), makeString(["mandatory ", toString(aX), ".", aY, " not defined"], ""))
210212 
211213 
212-func aY (aW,aX) = valueOrErrorMessage(getInteger(aW, aX), makeString(["mandatory ", toString(aW), ".", aX, " not defined"], ""))
214+func aZ (aX,aY) = valueOrErrorMessage(getInteger(aX, aY), makeString(["mandatory ", toString(aX), ".", aY, " not defined"], ""))
213215 
214216 
215-func aZ (ba) = throw(makeString(["lp_stable.ride:", ba], " "))
217+func ba (bb) = throw(makeString(["lp_stable.ride:", bb], " "))
216218 
217219 
218-func bb (ba) = makeString(["lp_stable.ride:", ba], " ")
220+func bc (bb) = makeString(["lp_stable.ride:", bb], " ")
219221 
220222 
221-let aT = addressFromStringValue(aV(this, Y()))
223+let aU = addressFromStringValue(aW(this, Z()))
222224 
223-let bc = {
224-    let bd = invoke(aT, "getInFeeREADONLY", [toString(this)], nil)
225-    if ($isInstanceOf(bd, "Int"))
226-        then bd
227-        else throw(($getType(bd) + " couldn't be cast to Int"))
225+let bd = {
226+    let be = invoke(aU, "getInFeeREADONLY", [toString(this)], nil)
227+    if ($isInstanceOf(be, "Int"))
228+        then be
229+        else throw(($getType(be) + " couldn't be cast to Int"))
228230     }
229231 
230-let be = {
231-    let bd = invoke(aT, "getOutFeeREADONLY", [toString(this)], nil)
232-    if ($isInstanceOf(bd, "Int"))
233-        then bd
234-        else throw(($getType(bd) + " couldn't be cast to Int"))
232+let bf = {
233+    let be = invoke(aU, "getOutFeeREADONLY", [toString(this)], nil)
234+    if ($isInstanceOf(be, "Int"))
235+        then be
236+        else throw(($getType(be) + " couldn't be cast to Int"))
235237     }
236238 
237-let bf = aV(this, al())
239+let bg = aW(this, am())
238240 
239-func bg () = valueOrElse(getBoolean(aT, aD()), false)
241+func bh () = valueOrElse(getBoolean(aU, aE()), false)
240242 
241243 
242-func bh () = fromBase58String(aV(aT, ax()))
244+func bi () = fromBase58String(aW(aU, ay()))
243245 
244246 
245-let bi = addressFromStringValue(aV(aT, aF()))
247+let bj = addressFromStringValue(aW(aU, aG()))
246248 
247-func bj () = {
248-    let bk = aV(this, aj())
249-    let bl = aV(this, ak())
250-    let bm = aY(aT, aB(bl))
251-    let az = aY(aT, aB(bk))
252-    split(aV(aT, ay(toString(az), toString(bm))), n)
249+func bk () = {
250+    let bl = aW(this, ak())
251+    let bm = aW(this, al())
252+    let bn = aZ(aU, aC(bm))
253+    let aA = aZ(aU, aC(bl))
254+    split(aW(aU, az(toString(aA), toString(bn))), o)
253255     }
254256 
255257 
256-func bn (bo) = if ((bo == k))
258+func bo (bp) = if ((bp == k))
257259     then unit
258-    else fromBase58String(bo)
260+    else fromBase58String(bp)
259261 
260262 
261-func bp (bo) = if ((bo == unit))
263+func bq (bp) = if ((bp == unit))
262264     then k
263-    else toBase58String(value(bo))
265+    else toBase58String(value(bp))
264266 
265267 
266-func bq (br) = $Tuple9(addressFromStringValue(br[t]), parseIntValue(br[u]), fromBase58String(br[v]), bn(br[w]), bn(br[x]), parseIntValue(br[y]), parseIntValue(br[z]), fromBase58String(br[A]), fromBase58String(br[B]))
268+func br (bs) = $Tuple7(addressFromStringValue(bs[u]), parseIntValue(bs[v]), fromBase58String(bs[w]), bo(bs[x]), bo(bs[y]), parseIntValue(bs[z]), parseIntValue(bs[A]))
267269 
268270 
269-let bs = bq(bj())
271+let bt = br(bk())
270272 
271-let bt = bs
273+let bu = bt
272274 
273-let bu = bt._1
275+let bv = bu._1
274276 
275-let bv = bt._2
277+let bw = bu._2
276278 
277-let bw = bt._3
279+let bx = bu._3
278280 
279-let bx = bt._4
281+let by = bu._4
280282 
281-let by = bt._5
283+let bz = bu._5
282284 
283-let bz = bt._6
285+let bA = bu._6
284286 
285-let bA = bt._7
287+let bB = bu._7
286288 
287-let bB = bt._8
288-
289-let bC = bt._9
290-
291-func bD () = split(aV(aT, aw()), n)
289+func bC () = split(aW(aU, ax()), o)
292290 
293291 
294-let bE = bD()
292+let bD = bC()
295293 
296-let bF = valueOrErrorMessage(addressFromString(bE[C]), "Invalid staking contract address")
294+let bE = valueOrErrorMessage(addressFromString(bD[D]), "Invalid staking contract address")
297295 
298-let bG = valueOrErrorMessage(addressFromString(bE[E]), "Invalid slipage contract address")
296+let bF = valueOrErrorMessage(addressFromString(bD[F]), "Invalid slipage contract address")
299297 
300-let bH = valueOrErrorMessage(addressFromString(bE[F]), "Invalid gwx contract address")
298+let bG = valueOrErrorMessage(addressFromString(bD[G]), "Invalid gwx contract address")
301299 
302-let bI = valueOrErrorMessage(addressFromString(bE[D]), "Invalid gwx contract address")
300+let bH = valueOrErrorMessage(addressFromString(bD[E]), "Invalid gwx contract address")
303301 
304-func bJ (bK,bL,bM,bN,bO,bP,bQ,bR,bS,bT) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bK), toString(bL), toString(bM), toString(bN), toString(bO), toString(bP), toString(bQ), toString(bR), toString(bS), toString(bT)], n)
302+func bI (bJ,bK,bL,bM,bN,bO,bP,bQ,bR,bS) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bJ), toString(bK), toString(bL), toString(bM), toString(bN), toString(bO), toString(bP), toString(bQ), toString(bR), toString(bS)], o)
305303 
306304 
307-func bU (bV,bW,bX,bN,bQ,bR) = makeString(["%d%d%d%d%d%d", toString(bV), toString(bW), toString(bX), toString(bN), toString(bQ), toString(bR)], n)
305+func bT (bU,bV,bW,bM,bP,bQ) = makeString(["%d%d%d%d%d%d", toString(bU), toString(bV), toString(bW), toString(bM), toString(bP), toString(bQ)], o)
308306 
309307 
310-func bY (bZ) = if ((bZ == "WAVES"))
308+func bX (bY) = if ((bY == "WAVES"))
311309     then wavesBalance(this).available
312-    else assetBalance(this, fromBase58String(bZ))
310+    else assetBalance(this, fromBase58String(bY))
313311 
314312 
315-func ca (cb,cc) = fraction(cb, c, cc)
313+func bZ (ca,cb) = fraction(ca, c, cb)
316314 
317315 
318-func cd (cb,cc,P) = fraction(cb, c, cc, P)
316+func cc (ca,cb,Q) = fraction(ca, c, cb, Q)
319317 
320318 
321-func ce (cf,cg,ch) = {
322-    let ci = fraction((cf - cg), b, cg)
323-    let cj = ((ch - W(ci)) > d)
324-    if (!(cj))
325-        then throw(("Big slpg: " + toString(ci)))
326-        else $Tuple2(cj, min([cf, cg]))
319+func cd (ce,cf,cg) = {
320+    let ch = fraction((ce - cf), b, cf)
321+    let ci = ((cg - X(ch)) > d)
322+    if (!(ci))
323+        then throw(("Big slpg: " + toString(ch)))
324+        else $Tuple2(ci, min([ce, cf]))
327325     }
328326 
329327 
330-func ck (cl,cm,cn) = {
331-    let ci = fraction(cm, b, cl)
332-    let co = (cn > ci)
333-    if (if (co)
328+func cj (ck,cl,cm) = {
329+    let ch = fraction(cl, b, ck)
330+    let cn = (cm > ch)
331+    if (if (cn)
334332         then true
335-        else (cm > cl))
336-        then throw(((((((toString(cm) + " ") + toString(cl)) + " ") + toString(ci)) + " ") + toString(cn)))
337-        else co
333+        else (cl > ck))
334+        then throw(((((((toString(cl) + " ") + toString(ck)) + " ") + toString(ch)) + " ") + toString(cm)))
335+        else cn
338336     }
339337 
340338 
341-func cp (cq,cr,cs,ct) = {
342-    let cu = H(cs, cq)
343-    let cv = H(ct, cr)
344-    ca(cv, cu)
339+func co (cp,cq,cr,cs) = {
340+    let ct = I(cr, cp)
341+    let cu = I(cs, cq)
342+    bZ(cu, ct)
345343     }
346344 
347345 
348-func cw (cs,ct,cx) = {
349-    let cy = bz
350-    let cz = bA
351-    let cA = cp(cy, cz, cs, ct)
352-    let cc = H(cs, cy)
353-    let cb = H(ct, cz)
354-    let cB = H(cx, a)
355-    let cC = ca(cc, cB)
356-    let cD = ca(cb, cB)
357-[cA, cC, cD]
346+func cv (cr,cs,cw) = {
347+    let cx = bA
348+    let cy = bB
349+    let cz = co(cx, cy, cr, cs)
350+    let cb = I(cr, cx)
351+    let ca = I(cs, cy)
352+    let cA = I(cw, a)
353+    let cB = bZ(cb, cA)
354+    let cC = bZ(ca, cA)
355+[cz, cB, cC]
358356     }
359357 
360358 
361-func cE (cs,ct,cx) = {
362-    let cF = cw(cs, ct, cx)
363-[L(cF[0], a), L(cF[1], a), L(cF[2], a)]
359+func cD (cr,cs,cw) = {
360+    let cE = cv(cr, cs, cw)
361+[M(cE[0], a), M(cE[1], a), M(cE[2], a)]
364362     }
365363 
366364 
367-func cG (cH,aq) = {
368-    let cI = if ((aq == 0))
365+func cF (cG,ar) = {
366+    let cH = if ((ar == 0))
369367         then 0
370-        else fraction(cH, aq, a)
371-    $Tuple2((cH - cI), cI)
368+        else fraction(cG, ar, a)
369+    $Tuple2((cG - cH), cH)
372370     }
373371 
374372 
375-func cJ (cK) = {
376-    let cL = cK[0]
377-    let cM = cK[1]
378-    let aU = (cL + cM)
379-    if ((aU == e))
373+func cI (cJ) = {
374+    let cK = cJ[0]
375+    let cL = cJ[1]
376+    let aV = (cK + cL)
377+    if ((aV == e))
380378         then e
381379         else {
382-            let aQ = parseIntValue(bf)
383-            let cN = (aQ * 2)
384-            let cF = fraction(cL, cM, f)
385-            let cO = fraction(cF, i, f)
386-            let cP = fraction(toBigInt(cN), aU, f)
387-            let cQ = toBigInt((cN - 1))
388-            func cR (cS) =             {
389-                let cT = fraction(cS, cS, f)
390-                let cU = fraction(cT, cS, f)
391-                let cV = fraction(cU, f, cO)
392-                fraction((cP + fraction(cV, g, f)), cS, (fraction(cQ, cS, f) + fraction(h, cV, f)))
380+            let aR = parseIntValue(bg)
381+            let cM = (aR * 2)
382+            let cE = fraction(cK, cL, f)
383+            let cN = fraction(cE, i, f)
384+            let cO = fraction(toBigInt(cM), aV, f)
385+            let cP = toBigInt((cM - 1))
386+            func cQ (cR) =             {
387+                let cS = fraction(cR, cR, f)
388+                let cT = fraction(cS, cR, f)
389+                let cU = fraction(cT, f, cN)
390+                fraction((cO + fraction(cU, g, f)), cR, (fraction(cP, cR, f) + fraction(h, cU, f)))
393391                 }
394392 
395-            func cW (cX,cY) =             if (cX._2)
396-                then cX
393+            func cV (cW,cX) =             if (cW._2)
394+                then cW
397395                 else {
398-                    let cS = cX._1
399-                    let cZ = cR(cS)
400-                    let da = (cZ - value(cS))
401-                    let db = if ((e > da))
402-                        then -(da)
403-                        else da
404-                    if ((f >= db))
405-                        then $Tuple2(cZ, true)
406-                        else $Tuple2(cZ, false)
396+                    let cR = cW._1
397+                    let cY = cQ(cR)
398+                    let cZ = (cY - value(cR))
399+                    let da = if ((e > cZ))
400+                        then -(cZ)
401+                        else cZ
402+                    if ((f >= da))
403+                        then $Tuple2(cY, true)
404+                        else $Tuple2(cY, false)
407405                     }
408406 
409-            let dc = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
410-            let dd = {
411-                let de = dc
412-                let df = size(de)
413-                let dg = $Tuple2(aU, false)
414-                func dh (di,dj) =                 if ((dj >= df))
415-                    then di
416-                    else cW(di, de[dj])
407+            let db = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
408+            let dc = {
409+                let dd = db
410+                let de = size(dd)
411+                let df = $Tuple2(aV, false)
412+                func dg (dh,di) =                 if ((di >= de))
413+                    then dh
414+                    else cV(dh, dd[di])
417415 
418-                func dk (di,dj) =                 if ((dj >= df))
419-                    then di
416+                func dj (dh,di) =                 if ((di >= de))
417+                    then dh
420418                     else throw("List size exceeds 17")
421419 
422-                dk(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dg, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
420+                dj(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(df, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
423421                 }
424-            let cS = dd._1
425-            let dl = dd._2
426-            if (dl)
427-                then cS
428-                else throw(("D calculation error, D = " + toString(cS)))
422+            let cR = dc._1
423+            let dk = dc._2
424+            if (dk)
425+                then cR
426+                else throw(("D calculation error, D = " + toString(cR)))
429427             }
430428     }
431429 
432430 
433-func dm (dn,do,dp,dq) = {
434-    let dr = bw
435-    let ds = toBase58String(value(bx))
436-    let dt = toBase58String(value(by))
437-    let du = bz
438-    let dv = bA
439-    let dw = toString(bv)
440-    let dx = valueOrErrorMessage(assetInfo(dr), "Wrong LP id").quantity
441-    if ((toBase58String(dr) != do))
431+func dl (dm,dn,do,dp) = {
432+    let dq = bx
433+    let dr = toBase58String(value(by))
434+    let ds = toBase58String(value(bz))
435+    let dt = bA
436+    let du = bB
437+    let dv = toString(bw)
438+    let dw = valueOrErrorMessage(assetInfo(dq), "Wrong LP id").quantity
439+    if ((toBase58String(dq) != dn))
442440         then throw("Wrong pmt asset")
443441         else {
444-            let dy = bY(ds)
445-            let dz = H(dy, du)
446-            let dA = bY(dt)
447-            let dB = H(dA, dv)
448-            let dC = ca(dB, dz)
449-            let dD = L(dC, a)
450-            let dE = H(dp, a)
451-            let dF = H(dx, a)
452-            let dG = fraction(dz, dE, dF)
453-            let dH = fraction(dB, dE, dF)
454-            let dI = O(dG, du, FLOOR)
455-            let dJ = O(dH, dv, FLOOR)
456-            let dK = if ((dn == ""))
442+            let dx = bX(dr)
443+            let dy = I(dx, dt)
444+            let dz = bX(ds)
445+            let dA = I(dz, du)
446+            let dB = bZ(dA, dy)
447+            let dC = M(dB, a)
448+            let dD = I(do, a)
449+            let dE = I(dw, a)
450+            let dF = fraction(dy, dD, dE)
451+            let dG = fraction(dA, dD, dE)
452+            let dH = P(dF, dt, FLOOR)
453+            let dI = P(dG, du, FLOOR)
454+            let dJ = if ((dm == ""))
457455                 then nil
458-                else [ScriptTransfer(dq, dI, if ((ds == "WAVES"))
456+                else [ScriptTransfer(dp, dH, if ((dr == "WAVES"))
459457                     then unit
460-                    else fromBase58String(ds)), ScriptTransfer(dq, dJ, if ((dt == "WAVES"))
458+                    else fromBase58String(dr)), ScriptTransfer(dp, dI, if ((ds == "WAVES"))
461459                     then unit
462-                    else fromBase58String(dt)), StringEntry(ai(toString(dq), dn), bU(dI, dJ, dp, dD, height, lastBlock.timestamp)), IntegerEntry(ab(), dD), IntegerEntry(ac(height, lastBlock.timestamp), dD)]
463-            $Tuple10(dI, dJ, ds, dt, dy, dA, dx, dC, dw, dK)
460+                    else fromBase58String(ds)), StringEntry(aj(toString(dp), dm), bT(dH, dI, do, dC, height, lastBlock.timestamp)), IntegerEntry(ac(), dC), IntegerEntry(ad(height, lastBlock.timestamp), dC)]
461+            $Tuple10(dH, dI, dr, ds, dx, dz, dw, dB, dv, dJ)
464462             }
465463     }
466464 
467465 
468-func dL (dn,ch,dM,dN,dO,dP,dq,dQ,dR,dS,dT,dU,dV) = {
469-    let dr = bw
470-    let dW = toBase58String(value(bx))
471-    let dX = toBase58String(value(by))
466+func dK (dm,cg,dL,dM,dN,dO,dp,dP,dQ,dR,dS,dT,dU) = {
467+    let dq = bx
468+    let dV = toBase58String(value(by))
469+    let dW = toBase58String(value(bz))
470+    let dX = bA
472471     let dY = bB
473-    let dZ = bC
474-    let ea = bz
475-    let eb = bA
476-    let dw = toString(bv)
477-    let ec = valueOrErrorMessage(assetInfo(dr), "Wr lp as").quantity
478-    let dy = if (dQ)
479-        then bY(dW)
480-        else if (if (dS)
481-            then (dV == dW)
472+    let dv = toString(bw)
473+    let dZ = valueOrErrorMessage(assetInfo(dq), "Wr lp as").quantity
474+    let dx = if (dP)
475+        then bX(dV)
476+        else if (if (dR)
477+            then (dU == dV)
482478             else false)
483-            then (bY(dW) - dU)
484-            else if (dS)
485-                then bY(dW)
486-                else (bY(dW) - dM)
487-    let dA = if (dQ)
488-        then bY(dX)
489-        else if (if (dS)
490-            then (dV == dX)
479+            then (bX(dV) - dT)
480+            else if (dR)
481+                then bX(dV)
482+                else (bX(dV) - dL)
483+    let dz = if (dP)
484+        then bX(dW)
485+        else if (if (dR)
486+            then (dU == dW)
491487             else false)
492-            then (bY(dX) - dU)
493-            else if (dS)
494-                then bY(dX)
495-                else (bY(dX) - dO)
496-    let ed = H(dM, ea)
497-    let ee = H(dO, eb)
498-    let ef = ca(ee, ed)
499-    let dz = H(dy, ea)
500-    let dB = H(dA, eb)
501-    let cm = cJ([dz, dB])
502-    let eg = if ((ec == 0))
488+            then (bX(dW) - dT)
489+            else if (dR)
490+                then bX(dW)
491+                else (bX(dW) - dN)
492+    let ea = I(dL, dX)
493+    let eb = I(dN, dY)
494+    let ec = bZ(eb, ea)
495+    let dy = I(dx, dX)
496+    let dA = I(dz, dY)
497+    let cl = cI([dy, dA])
498+    let ed = if ((dZ == 0))
503499         then {
504-            let cl = cJ([(dz + ed), (dB + ee)])
505-            let eh = if ((cl > cm))
500+            let ck = cI([(dy + ea), (dA + eb)])
501+            let ee = if ((ck > cl))
506502                 then true
507503                 else throw("D1 should be greater than D0")
508-            if ((eh == eh))
504+            if ((ee == ee))
509505                 then {
510-                    let dC = d
511-                    let ei = d
512-                    let cB = cl
513-                    $Tuple5(L(cB, a), L(ed, ea), L(ee, eb), ca((dB + ee), (dz + ed)), ei)
506+                    let dB = d
507+                    let ef = d
508+                    let cA = ck
509+                    $Tuple5(M(cA, a), M(ea, dX), M(eb, dY), bZ((dA + eb), (dy + ea)), ef)
514510                     }
515511                 else throw("Strict value is not equal to itself.")
516512             }
517513         else {
518-            let dC = ca(dB, dz)
519-            let ej = fraction(W((dC - ef)), c, dC)
520-            let ei = H(ch, a)
521-            if (if (if (dT)
522-                then (dC != d)
514+            let dB = bZ(dA, dy)
515+            let eg = fraction(X((dB - ec)), c, dB)
516+            let ef = I(cg, a)
517+            if (if (if (dS)
518+                then (dB != d)
523519                 else false)
524-                then (ej > ei)
520+                then (eg > ef)
525521                 else false)
526-                then throw(((("Price slippage " + toString(ej)) + " > ") + toString(ei)))
522+                then throw(((("Price slippage " + toString(eg)) + " > ") + toString(ef)))
527523                 else {
528-                    let ek = H(ec, a)
529-                    let el = fraction(ed, cd(dB, dz, CEILING), c, CEILING)
530-                    let em = fraction(ee, c, cd(dB, dz, FLOOR), CEILING)
531-                    let en = if ((el > ee))
532-                        then $Tuple2(em, ee)
533-                        else $Tuple2(ed, el)
534-                    let eo = en._1
535-                    let ep = en._2
536-                    let cl = cJ([(dz + eo), (dB + ep)])
537-                    let eh = if ((cl > cm))
524+                    let eh = I(dZ, a)
525+                    let ei = fraction(ea, cc(dA, dy, CEILING), c, CEILING)
526+                    let ej = fraction(eb, c, cc(dA, dy, FLOOR), CEILING)
527+                    let ek = if ((ei > eb))
528+                        then $Tuple2(ej, eb)
529+                        else $Tuple2(ea, ei)
530+                    let el = ek._1
531+                    let em = ek._2
532+                    let ck = cI([(dy + el), (dA + em)])
533+                    let ee = if ((ck > cl))
538534                         then true
539535                         else throw("D1 should be greater than D0")
540-                    if ((eh == eh))
536+                    if ((ee == ee))
541537                         then {
542-                            let cB = fraction(ek, (cl - cm), cm)
543-                            $Tuple5(O(cB, a, FLOOR), O(eo, ea, CEILING), O(ep, eb, CEILING), dC, ei)
538+                            let cA = fraction(eh, (ck - cl), cl)
539+                            $Tuple5(P(cA, a, FLOOR), P(el, dX, CEILING), P(em, dY, CEILING), dB, ef)
544540                             }
545541                         else throw("Strict value is not equal to itself.")
546542                     }
547543             }
548-    let eq = eg._1
549-    let er = eg._2
550-    let es = eg._3
551-    let dD = L(eg._4, a)
552-    let et = L(eg._5, a)
553-    if ((0 >= eq))
544+    let en = ed._1
545+    let eo = ed._2
546+    let ep = ed._3
547+    let dC = M(ed._4, a)
548+    let eq = M(ed._5, a)
549+    if ((0 >= en))
554550         then throw("LP <= 0")
555551         else {
556-            let eu = if (!(dR))
552+            let er = if (!(dQ))
557553                 then 0
558-                else eq
559-            let ev = (dM - er)
560-            let ew = (dO - es)
561-            let ex = if (if (dS)
562-                then (dV == dW)
554+                else en
555+            let es = (dL - eo)
556+            let et = (dN - ep)
557+            let eu = if (if (dR)
558+                then (dU == dV)
563559                 else false)
564-                then $Tuple2(dU, 0)
565-                else if (if (dS)
566-                    then (dV == dX)
560+                then $Tuple2(dT, 0)
561+                else if (if (dR)
562+                    then (dU == dW)
567563                     else false)
568-                    then $Tuple2(0, dU)
569-                    else $Tuple2(er, es)
570-            let ey = ex._1
571-            let ez = ex._2
572-            let eA = [IntegerEntry(ab(), dD), IntegerEntry(ac(height, lastBlock.timestamp), dD), StringEntry(af(dq, dn), bJ(ey, ez, eu, dD, ch, et, height, lastBlock.timestamp, ev, ew))]
573-            $Tuple13(eq, eu, dD, dy, dA, ec, dr, dw, eA, ev, ew, dN, dP)
564+                    then $Tuple2(0, dT)
565+                    else $Tuple2(eo, ep)
566+            let ev = eu._1
567+            let ew = eu._2
568+            let ex = [IntegerEntry(ac(), dC), IntegerEntry(ad(height, lastBlock.timestamp), dC), StringEntry(ag(dp, dm), bI(ev, ew, er, dC, cg, eq, height, lastBlock.timestamp, es, et))]
569+            $Tuple13(en, er, dC, dx, dz, dZ, dq, dv, ex, es, et, dM, dO)
574570             }
575571     }
576572 
577573 
578-func eB (cK,cY,eC) = {
579-    let eD = g
580-    let eE = cK[if ((cY == 0))
574+func ey (cJ,cX,ez) = {
575+    let eA = g
576+    let eB = cJ[if ((cX == 0))
581577         then 1
582578         else 0]
583-    let eF = parseBigIntValue(l)
584-    let aQ = (parseBigIntValue(bf) * eF)
585-    let aU = eE
586-    let cN = (aQ * eD)
587-    let eG = (((((eC * eC) / (eE * eD)) * eC) * eF) / (cN * eD))
588-    let eH = ((aU + ((eC * eF) / cN)) - eC)
589-    func cW (cX,eI) =     {
590-        let eJ = cX
591-        let eK = eJ._1
592-        let dl = eJ._2
593-        if ((dl != unit))
594-            then cX
579+    let eC = parseBigIntValue(m)
580+    let aR = (parseBigIntValue(bg) * eC)
581+    let aV = eB
582+    let cM = (aR * eA)
583+    let eD = (((((ez * ez) / (eB * eA)) * ez) * eC) / (cM * eA))
584+    let eE = ((aV + ((ez * eC) / cM)) - ez)
585+    func cV (cW,eF) =     {
586+        let eG = cW
587+        let eH = eG._1
588+        let dk = eG._2
589+        if ((dk != unit))
590+            then cW
595591             else {
596-                let eL = (((eK * eK) + eG) / ((g * eK) + eH))
597-                let eM = X((eL - value(eK)))
598-                if ((f >= eM))
599-                    then $Tuple2(eL, eI)
600-                    else $Tuple2(eL, unit)
592+                let eI = (((eH * eH) + eD) / ((g * eH) + eE))
593+                let eJ = Y((eI - value(eH)))
594+                if ((f >= eJ))
595+                    then $Tuple2(eI, eF)
596+                    else $Tuple2(eI, unit)
601597                 }
602598         }
603599 
604-    let dc = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
605-    let eN = {
606-        let de = dc
607-        let df = size(de)
608-        let dg = $Tuple2(eC, unit)
609-        func dh (di,dj) =         if ((dj >= df))
610-            then di
611-            else cW(di, de[dj])
600+    let db = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
601+    let eK = {
602+        let dd = db
603+        let de = size(dd)
604+        let df = $Tuple2(ez, unit)
605+        func dg (dh,di) =         if ((di >= de))
606+            then dh
607+            else cV(dh, dd[di])
612608 
613-        func dk (di,dj) =         if ((dj >= df))
614-            then di
609+        func dj (dh,di) =         if ((di >= de))
610+            then dh
615611             else throw("List size exceeds 15")
616612 
617-        dk(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dg, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
613+        dj(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(df, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
618614         }
619-    let eK = eN._1
620-    let dl = eN._2
621-    if ((dl != unit))
622-        then eK
623-        else throw(("Y calculation error, Y = " + toString(eK)))
615+    let eH = eK._1
616+    let dk = eK._2
617+    if ((dk != unit))
618+        then eH
619+        else throw(("Y calculation error, Y = " + toString(eH)))
624620     }
625621 
626622 
627-func eO (eP,eQ,eR) = {
628-    let eS = fraction(cJ([K(eP, toBigInt(bz)), K(eQ, toBigInt(bA))]), c, eR)
629-    if ((eR == e))
623+func eL (eM,eN,eO) = {
624+    let eP = fraction(cI([L(eM, toBigInt(bA)), L(eN, toBigInt(bB))]), c, eO)
625+    if ((eO == e))
630626         then e
631-        else eS
627+        else eP
632628     }
633629 
634630 
635-func eT (eU,eV,eW) = {
636-    let eX = (toBigInt(bY(bp(bx))) - eU)
637-    let eY = (toBigInt(bY(bp(by))) - eV)
638-    let eZ = (toBigInt(value(assetInfo(bw)).quantity) - eW)
639-    let fa = eO(eX, eY, eZ)
640-    fa
631+func eQ (eR,eS,eT) = {
632+    let eU = (toBigInt(bX(bq(by))) - eR)
633+    let eV = (toBigInt(bX(bq(bz))) - eS)
634+    let eW = (toBigInt(value(assetInfo(bx)).quantity) - eT)
635+    let eX = eL(eU, eV, eW)
636+    eX
641637     }
642638 
643639 
644-func fb (fc,fd,eW) = {
645-    let eX = (bY(bp(bx)) + fc)
646-    let eY = (bY(bp(by)) + fd)
647-    let eZ = (value(assetInfo(bw)).quantity + eW)
648-    let eS = eO(toBigInt(eX), toBigInt(eY), toBigInt(eZ))
649-    let fe = [IntegerEntry(as, height), StringEntry(ar, toString(eS))]
650-    $Tuple2(fe, eS)
640+func eY (eZ,fa,eT) = {
641+    let eU = (bX(bq(by)) + eZ)
642+    let eV = (bX(bq(bz)) + fa)
643+    let eW = (value(assetInfo(bx)).quantity + eT)
644+    let eP = eL(toBigInt(eU), toBigInt(eV), toBigInt(eW))
645+    let fb = [IntegerEntry(at, height), StringEntry(as, toString(eP))]
646+    $Tuple2(fb, eP)
651647     }
652648 
653649 
654-func ff (fg,eS) = if ((eS >= fg))
650+func fc (fd,eP) = if ((eP >= fd))
655651     then true
656-    else aZ("updated DLp lower than current DLp")
652+    else ba("updated DLp lower than current DLp")
657653 
658654 
659-func fh (fi) = {
660-    let eX = bY(bp(bx))
661-    let eY = bY(bp(by))
662-    let fj = fi.amount
663-    let fk = fraction(fi.amount, fi.price, a, FLOOR)
664-    let fl = if ((fi.orderType == Buy))
665-        then $Tuple2(fj, -(fk))
666-        else $Tuple2(-(fj), fk)
667-    let fc = fl._1
668-    let fd = fl._2
669-    if (if (if (bg())
655+func fe (ff) = {
656+    let eU = bX(bq(by))
657+    let eV = bX(bq(bz))
658+    let fg = ff.amount
659+    let fh = fraction(ff.amount, ff.price, a, FLOOR)
660+    let fi = if ((ff.orderType == Buy))
661+        then $Tuple2(fg, -(fh))
662+        else $Tuple2(-(fg), fh)
663+    let eZ = fi._1
664+    let fa = fi._2
665+    if (if (if (bh())
670666         then true
671-        else (bv == r))
667+        else (bw == s))
672668         then true
673-        else (bv == s))
669+        else (bw == t))
674670         then throw("Admin blocked")
675-        else if (if ((fi.assetPair.amountAsset != bx))
671+        else if (if ((ff.assetPair.amountAsset != by))
676672             then true
677-            else (fi.assetPair.priceAsset != by))
673+            else (ff.assetPair.priceAsset != bz))
678674             then throw("Wr assets")
679675             else {
680-                let fm = parseBigIntValue(valueOrElse(getString(this, ar), "0"))
681-                let fn = fb(fc, fd, 0)
682-                let fo = fn._1
683-                let fp = fn._2
684-                let fq = (fp >= fm)
685-                let fr = makeString(["dLp=", toString(fm), " dLpNew=", toString(fp), " amountAssetBalance=", toString(eX), " priceAssetBalance=", toString(eY), " amountAssetBalanceDelta=", toString(fc), " priceAssetBalanceDelta=", toString(fd), " height=", toString(height)], "")
686-                $Tuple2(fq, fr)
676+                let fj = parseBigIntValue(valueOrElse(getString(this, as), "0"))
677+                let fk = eY(eZ, fa, 0)
678+                let fl = fk._1
679+                let fm = fk._2
680+                let fn = (fm >= fj)
681+                let fo = makeString(["dLp=", toString(fj), " dLpNew=", toString(fm), " amountAssetBalance=", toString(eU), " priceAssetBalance=", toString(eV), " amountAssetBalanceDelta=", toString(eZ), " priceAssetBalanceDelta=", toString(fa), " height=", toString(height)], "")
682+                $Tuple2(fn, fo)
687683                 }
688684     }
689685 
690686 
691-func fs (cY) = if ((size(cY.payments) != 1))
687+func fp (cX) = if ((size(cX.payments) != 1))
692688     then throw("1 pmnt exp")
693689     else {
694-        let ft = value(cY.payments[0])
695-        let do = value(ft.assetId)
696-        let dU = ft.amount
697-        let eg = dm(toBase58String(cY.transactionId), toBase58String(do), dU, cY.caller)
698-        let dI = eg._1
699-        let dJ = eg._2
700-        let dw = parseIntValue(eg._9)
701-        let dK = eg._10
702-        if (if (bg())
690+        let fq = value(cX.payments[0])
691+        let dn = value(fq.assetId)
692+        let dT = fq.amount
693+        let ed = dl(toBase58String(cX.transactionId), toBase58String(dn), dT, cX.caller)
694+        let dH = ed._1
695+        let dI = ed._2
696+        let dv = parseIntValue(ed._9)
697+        let dJ = ed._10
698+        if (if (bh())
703699             then true
704-            else (dw == s))
705-            then throw(("Admin blocked: " + toString(dw)))
706-            else $Tuple5(dI, dJ, dU, do, dK)
700+            else (dv == t))
701+            then throw(("Admin blocked: " + toString(dv)))
702+            else $Tuple5(dH, dI, dT, dn, dJ)
707703         }
708704 
709705 
710-func fu (fv,ah,fw,fx,ch,dR,dS,dT,dU,dV) = {
711-    let eg = dL(ah, ch, value(fw).amount, value(fw).assetId, value(fx).amount, value(fx).assetId, fv, (ah == ""), dR, dS, dT, dU, dV)
712-    let dw = parseIntValue(eg._8)
713-    if (if (if (bg())
706+func fr (fs,ai,ft,fu,cg,dQ,dR,dS,dT,dU) = {
707+    let ed = dK(ai, cg, value(ft).amount, value(ft).assetId, value(fu).amount, value(fu).assetId, fs, (ai == ""), dQ, dR, dS, dT, dU)
708+    let dv = parseIntValue(ed._8)
709+    if (if (if (bh())
714710         then true
715-        else (dw == q))
711+        else (dv == r))
716712         then true
717-        else (dw == s))
718-        then throw(("Blocked:" + toString(dw)))
719-        else eg
713+        else (dv == t))
714+        then throw(("Blocked:" + toString(dv)))
715+        else ed
720716     }
721717 
722718 
723-func fy (fz,do,dq,ah,fA) = {
724-    let ds = toBase58String(value(bx))
725-    let dt = toBase58String(value(by))
726-    let dr = bw
727-    let ea = bz
728-    let eb = bA
729-    let eZ = toBigInt(valueOrErrorMessage(assetInfo(dr), "invalid lp asset").quantity)
730-    let fB = if ((eZ > e))
719+func fv (fw,dn,dp,ai,fx) = {
720+    let dr = toBase58String(value(by))
721+    let ds = toBase58String(value(bz))
722+    let dq = bx
723+    let dX = bA
724+    let dY = bB
725+    let eW = toBigInt(valueOrErrorMessage(assetInfo(dq), "invalid lp asset").quantity)
726+    let fy = if ((eW > e))
731727         then true
732728         else throw("initial deposit requires all coins")
733-    if ((fB == fB))
729+    if ((fy == fy))
734730         then {
735-            let dy = bY(ds)
736-            let dA = bY(dt)
737-            let fC = if ((ah == ""))
738-                then $Tuple2(dy, dA)
739-                else if ((do == ds))
740-                    then if ((fz > dy))
731+            let dx = bX(dr)
732+            let dz = bX(ds)
733+            let fz = if ((ai == ""))
734+                then $Tuple2(dx, dz)
735+                else if ((dn == dr))
736+                    then if ((fw > dx))
741737                         then throw("invalid payment amount")
742-                        else $Tuple2((dy - fz), dA)
743-                    else if ((do == dt))
744-                        then if ((fz > dA))
738+                        else $Tuple2((dx - fw), dz)
739+                    else if ((dn == ds))
740+                        then if ((fw > dz))
745741                             then throw("invalid payment amount")
746-                            else $Tuple2(dy, (dA - fz))
742+                            else $Tuple2(dx, (dz - fw))
747743                         else throw("wrong pmtAssetId")
744+            let fA = fz._1
745+            let fB = fz._2
746+            let fC = if ((dn == dr))
747+                then $Tuple2(fw, 0)
748+                else if ((dn == ds))
749+                    then $Tuple2(0, fw)
750+                    else throw("invalid payment")
748751             let fD = fC._1
749752             let fE = fC._2
750-            let fF = if ((do == ds))
751-                then $Tuple2(fz, 0)
752-                else if ((do == dt))
753-                    then $Tuple2(0, fz)
754-                    else throw("invalid payment")
753+            let fF = if (fx)
754+                then $Tuple3(cF(fD, bd)._1, cF(fE, bd)._1, cF(fw, bd)._2)
755+                else $Tuple3(fD, fE, 0)
755756             let fG = fF._1
756757             let fH = fF._2
757-            let fI = if (fA)
758-                then $Tuple3(cG(fG, bc)._1, cG(fH, bc)._1, cG(fz, bc)._2)
759-                else $Tuple3(fG, fH, 0)
760-            let fJ = fI._1
761-            let fK = fI._2
762-            let cI = fI._3
763-            let fL = (fD + fJ)
764-            let fM = (fE + fK)
765-            let cm = cJ([H(fD, bz), H(fE, bA)])
766-            let cl = cJ([H(fL, bz), H(fM, bA)])
767-            let eh = if ((cl > cm))
758+            let cH = fF._3
759+            let fI = (fA + fG)
760+            let fJ = (fB + fH)
761+            let cl = cI([I(fA, bA), I(fB, bB)])
762+            let ck = cI([I(fI, bA), I(fJ, bB)])
763+            let ee = if ((ck > cl))
768764                 then true
769765                 else throw()
770-            if ((eh == eh))
766+            if ((ee == ee))
771767                 then {
772-                    let fN = fraction(eZ, (cl - cm), cm, FLOOR)
773-                    let dD = L(ca(H(fM, eb), H(fL, ea)), a)
774-                    let eA = [IntegerEntry(ab(), dD), IntegerEntry(ac(height, lastBlock.timestamp), dD), StringEntry(af(dq, ah), bJ(fG, fH, toInt(fN), dD, 0, 0, height, lastBlock.timestamp, 0, 0))]
775-                    let fO = fraction(fE, a, fD)
776-                    let fP = fraction(fz, a, (fO + a))
777-                    let fQ = (fz - fP)
778-                    let fR = fraction(eZ, toBigInt(fQ), toBigInt(fE))
779-                    let fS = toInt(fraction((fN - fR), b, fR))
780-                    $Tuple4(toInt(fN), eA, cI, fS)
768+                    let fK = fraction(eW, (ck - cl), cl, FLOOR)
769+                    let dC = M(bZ(I(fJ, dY), I(fI, dX)), a)
770+                    let ex = [IntegerEntry(ac(), dC), IntegerEntry(ad(height, lastBlock.timestamp), dC), StringEntry(ag(dp, ai), bI(fD, fE, toInt(fK), dC, 0, 0, height, lastBlock.timestamp, 0, 0))]
771+                    let fL = fraction(fB, a, fA)
772+                    let fM = fraction(fw, a, (fL + a))
773+                    let fN = (fw - fM)
774+                    let fO = fraction(eW, toBigInt(fN), toBigInt(fB))
775+                    let fP = toInt(fraction((fK - fO), b, fO))
776+                    $Tuple4(toInt(fK), ex, cH, fP)
781777                     }
782778                 else throw("Strict value is not equal to itself.")
783779             }
784780         else throw("Strict value is not equal to itself.")
785781     }
786782 
787783 
788-func fT (fU,fV,fW,fv,fX,fY) = {
789-    let dr = toBase58String(value(bw))
790-    let ds = toBase58String(value(bx))
791-    let dt = toBase58String(value(by))
792-    let fZ = bz
793-    let ga = bA
794-    let gb = bv
795-    let dq = if ((fv == bI))
796-        then fX
797-        else fv
798-    let ft = value(fW[0])
799-    let do = value(ft.assetId)
800-    let dU = ft.amount
801-    let fa = eT(e, e, e)
802-    if ((fa == fa))
784+func fQ (fR,fS,fT,fs,fU,fV) = {
785+    let dq = toBase58String(value(bx))
786+    let dr = toBase58String(value(by))
787+    let ds = toBase58String(value(bz))
788+    let fW = bA
789+    let fX = bB
790+    let fY = bw
791+    let dp = if ((fs == bH))
792+        then fU
793+        else fs
794+    let fq = value(fT[0])
795+    let dn = value(fq.assetId)
796+    let dT = fq.amount
797+    let eX = eQ(e, e, e)
798+    if ((eX == eX))
803799         then {
804-            let dn = toBase58String(fY)
805-            if ((dr != toBase58String(do)))
800+            let dm = toBase58String(fV)
801+            if ((dq != toBase58String(dn)))
806802                 then throw("Wrong LP")
807803                 else {
808-                    let dy = bY(ds)
809-                    let dA = bY(dt)
810-                    let gc = {
811-                        let bd = invoke(this, "getOneTknV2READONLY", [fU, dU], nil)
812-                        if ($isInstanceOf(bd, "(Int, Int)"))
813-                            then bd
814-                            else throw(($getType(bd) + " couldn't be cast to (Int, Int)"))
804+                    let dx = bX(dr)
805+                    let dz = bX(ds)
806+                    let fZ = {
807+                        let be = invoke(this, "getOneTknV2READONLY", [fR, dT], nil)
808+                        if ($isInstanceOf(be, "(Int, Int)"))
809+                            then be
810+                            else throw(($getType(be) + " couldn't be cast to (Int, Int)"))
815811                         }
816-                    if ((gc == gc))
812+                    if ((fZ == fZ))
817813                         then {
818-                            let cI = gc._2
814+                            let cH = fZ._2
815+                            let ga = fZ._1
816+                            let gb = if (if ((fS > 0))
817+                                then (fS > ga)
818+                                else false)
819+                                then ba(makeString(["amount to receive is less than ", toString(fS)], ""))
820+                                else ga
821+                            let gc = if ((fR == dr))
822+                                then $Tuple4(gb, 0, ((dx - gb) - cH), dz)
823+                                else if ((fR == ds))
824+                                    then $Tuple4(0, gb, dx, ((dz - gb) - cH))
825+                                    else throw("invalid out asset id")
819826                             let gd = gc._1
820-                            let ge = if (if ((fV > 0))
821-                                then (fV > gd)
822-                                else false)
823-                                then aZ(makeString(["amount to receive is less than ", toString(fV)], ""))
824-                                else gd
825-                            let gf = if ((fU == ds))
826-                                then $Tuple4(ge, 0, ((dy - ge) - cI), dA)
827-                                else if ((fU == dt))
828-                                    then $Tuple4(0, ge, dy, ((dA - ge) - cI))
829-                                    else throw("invalid out asset id")
830-                            let gg = gf._1
831-                            let gh = gf._2
832-                            let fL = gf._3
833-                            let fM = gf._4
834-                            let gi = ca(H(fM, ga), H(fL, fZ))
835-                            let gj = L(gi, a)
836-                            let gk = if ((fU == "WAVES"))
827+                            let ge = gc._2
828+                            let fI = gc._3
829+                            let fJ = gc._4
830+                            let gf = bZ(I(fJ, fX), I(fI, fW))
831+                            let gg = M(gf, a)
832+                            let gh = if ((fR == "WAVES"))
837833                                 then unit
838-                                else fromBase58String(fU)
839-                            let gl = if ((cI > 0))
840-                                then [ScriptTransfer(bi, cI, gk)]
834+                                else fromBase58String(fR)
835+                            let gi = if ((cH > 0))
836+                                then [ScriptTransfer(bj, cH, gh)]
841837                                 else nil
842-                            let dK = ([ScriptTransfer(dq, ge, gk), StringEntry(ai(toString(dq), dn), bU(gg, gh, dU, gj, height, lastBlock.timestamp)), IntegerEntry(ab(), gj), IntegerEntry(ac(height, lastBlock.timestamp), gj)] ++ gl)
843-                            if ((dK == dK))
838+                            let dJ = ([ScriptTransfer(dp, gb, gh), StringEntry(aj(toString(dp), dm), bT(gd, ge, dT, gg, height, lastBlock.timestamp)), IntegerEntry(ac(), gg), IntegerEntry(ad(height, lastBlock.timestamp), gg)] ++ gi)
839+                            if ((dJ == dJ))
844840                                 then {
845-                                    let gm = invoke(aT, "burn", [dU], [AttachedPayment(do, dU)])
846-                                    if ((gm == gm))
841+                                    let gj = invoke(aU, "burn", [dT], [AttachedPayment(dn, dT)])
842+                                    if ((gj == gj))
847843                                         then {
848-                                            let gn = {
849-                                                let go = if ((this == bi))
844+                                            let gk = {
845+                                                let gl = if ((this == bj))
850846                                                     then 0
851-                                                    else cI
852-                                                let gp = if ((bn(fU) == bx))
847+                                                    else cH
848+                                                let gm = if ((bo(fR) == by))
853849                                                     then true
854850                                                     else false
855-                                                if (gp)
856-                                                    then $Tuple2(-((gd + go)), 0)
857-                                                    else $Tuple2(0, -((gd + go)))
851+                                                if (gm)
852+                                                    then $Tuple2(-((ga + gl)), 0)
853+                                                    else $Tuple2(0, -((ga + gl)))
858854                                                 }
859-                                            let fc = gn._1
860-                                            let fd = gn._2
861-                                            let gq = fb(fc, fd, 0)
862-                                            let gr = gq._1
863-                                            let eS = gq._2
864-                                            let gs = ff(fa, eS)
865-                                            if ((gs == gs))
866-                                                then $Tuple2((dK ++ gr), ge)
855+                                            let eZ = gk._1
856+                                            let fa = gk._2
857+                                            let gn = eY(eZ, fa, 0)
858+                                            let go = gn._1
859+                                            let eP = gn._2
860+                                            let gp = fc(eX, eP)
861+                                            if ((gp == gp))
862+                                                then $Tuple2((dJ ++ go), gb)
867863                                                 else throw("Strict value is not equal to itself.")
868864                                             }
869865                                         else throw("Strict value is not equal to itself.")
870866                                     }
871867                                 else throw("Strict value is not equal to itself.")
872868                             }
873869                         else throw("Strict value is not equal to itself.")
874870                     }
875871             }
876872         else throw("Strict value is not equal to itself.")
877873     }
878874 
879875 
880-func gt () = {
881-    let gu = aR()
882-    let aP = getString(gu, Z())
883-    if ($isInstanceOf(aP, "String"))
876+func gq () = {
877+    let gr = aS()
878+    let aQ = getString(gr, aa())
879+    if ($isInstanceOf(aQ, "String"))
884880         then {
885-            let aU = aP
886-            fromBase58String(aU)
881+            let aV = aQ
882+            fromBase58String(aV)
887883             }
888-        else if ($isInstanceOf(aP, "Unit"))
884+        else if ($isInstanceOf(aQ, "Unit"))
889885             then unit
890886             else throw("Match error")
891887     }
892888 
893889 
894-let gv = throw("Permission denied")
890+let gs = throw("Permission denied")
895891 
896-func gw (cY) = {
897-    let aP = gt()
898-    if ($isInstanceOf(aP, "ByteVector"))
892+func gt (cX) = {
893+    let aQ = gq()
894+    if ($isInstanceOf(aQ, "ByteVector"))
899895         then {
900-            let gx = aP
901-            (cY.callerPublicKey == gx)
896+            let gu = aQ
897+            (cX.callerPublicKey == gu)
902898             }
903-        else if ($isInstanceOf(aP, "Unit"))
904-            then (cY.caller == this)
899+        else if ($isInstanceOf(aQ, "Unit"))
900+            then (cX.caller == this)
905901             else throw("Match error")
906902     }
907903 
908904 
909-func gy (cY) = {
910-    let aP = gt()
911-    if ($isInstanceOf(aP, "ByteVector"))
905+func gv (cX) = {
906+    let aQ = gq()
907+    if ($isInstanceOf(aQ, "ByteVector"))
912908         then {
913-            let gx = aP
914-            if ((cY.callerPublicKey == gx))
909+            let gu = aQ
910+            if ((cX.callerPublicKey == gu))
915911                 then true
916-                else gv
912+                else gs
917913             }
918-        else if ($isInstanceOf(aP, "Unit"))
919-            then if ((cY.caller == this))
914+        else if ($isInstanceOf(aQ, "Unit"))
915+            then if ((cX.caller == this))
920916                 then true
921-                else gv
917+                else gs
922918             else throw("Match error")
923919     }
924920 
925921 
926-func gz (gA,eC,gB) = {
927-    let br = bj()
928-    let ds = br[w]
929-    let dt = br[x]
930-    let eD = g
931-    let eF = parseBigIntValue(l)
932-    let aQ = (parseBigIntValue(bf) * eF)
933-    let cK = if ((gA == false))
934-        then [(toBigInt(bY(ds)) + gB), toBigInt(bY(dt))]
935-        else [(toBigInt(bY(dt)) + gB), toBigInt(bY(ds))]
936-    let eE = cK[0]
937-    let aU = eE
938-    let cN = (aQ * eD)
939-    let eG = (((((eC * eC) / (eE * eD)) * eC) * eF) / (cN * eD))
940-    let eH = ((aU + ((eC * eF) / cN)) - eC)
941-    func cW (cX,eI) =     {
942-        let gC = cX
943-        let eK = gC._1
944-        let dl = gC._2
945-        if ((dl != unit))
946-            then cX
922+func gw (gx,ez,gy) = {
923+    let bs = bk()
924+    let dr = bs[x]
925+    let ds = bs[y]
926+    let eA = g
927+    let eC = parseBigIntValue(m)
928+    let aR = (parseBigIntValue(bg) * eC)
929+    let cJ = if ((gx == false))
930+        then [(toBigInt(bX(dr)) + gy), toBigInt(bX(ds))]
931+        else [(toBigInt(bX(ds)) + gy), toBigInt(bX(dr))]
932+    let eB = cJ[0]
933+    let aV = eB
934+    let cM = (aR * eA)
935+    let eD = (((((ez * ez) / (eB * eA)) * ez) * eC) / (cM * eA))
936+    let eE = ((aV + ((ez * eC) / cM)) - ez)
937+    func cV (cW,eF) =     {
938+        let gz = cW
939+        let eH = gz._1
940+        let dk = gz._2
941+        if ((dk != unit))
942+            then cW
947943             else {
948-                let eL = (((eK * eK) + eG) / ((g * eK) + eH))
949-                let eM = X((eL - value(eK)))
950-                if ((f >= eM))
951-                    then $Tuple2(eL, eI)
952-                    else $Tuple2(eL, unit)
944+                let eI = (((eH * eH) + eD) / ((g * eH) + eE))
945+                let eJ = Y((eI - value(eH)))
946+                if ((f >= eJ))
947+                    then $Tuple2(eI, eF)
948+                    else $Tuple2(eI, unit)
953949                 }
954950         }
955951 
956-    let dc = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
957-    let gD = {
958-        let de = dc
959-        let df = size(de)
960-        let dg = $Tuple2(eC, unit)
961-        func dh (di,dj) =         if ((dj >= df))
962-            then di
963-            else cW(di, de[dj])
952+    let db = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
953+    let gA = {
954+        let dd = db
955+        let de = size(dd)
956+        let df = $Tuple2(ez, unit)
957+        func dg (dh,di) =         if ((di >= de))
958+            then dh
959+            else cV(dh, dd[di])
964960 
965-        func dk (di,dj) =         if ((dj >= df))
966-            then di
961+        func dj (dh,di) =         if ((di >= de))
962+            then dh
967963             else throw("List size exceeds 15")
968964 
969-        dk(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dh(dg, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
965+        dj(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(dg(df, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
970966         }
971-    let eK = gD._1
972-    let dl = gD._2
973-    if ((dl != unit))
974-        then eK
975-        else throw(("Y calculation error, Y = " + toString(eK)))
967+    let eH = gA._1
968+    let dk = gA._2
969+    if ((dk != unit))
970+        then eH
971+        else throw(("Y calculation error, Y = " + toString(eH)))
976972     }
977973 
978974 
979-func gE () = valueOrElse(getBoolean(aT, aG(toString(this))), false)
975+func gB () = valueOrElse(getBoolean(aU, aH(toString(this))), false)
980976 
981977 
982-@Callable(cY)
983-func calculateAmountOutForSwapREADONLY (gF,gA,gG) = {
984-    let gH = if ((gA == false))
978+@Callable(cX)
979+func calculateAmountOutForSwapREADONLY (gC,gx,gD) = {
980+    let gE = if ((gx == false))
985981         then {
986-            let gI = aV(this, ak())
987-            let gB = (toBigInt(bY(aV(this, aj()))) + toBigInt(gF))
988-            $Tuple2(gI, gB)
982+            let gF = aW(this, al())
983+            let gy = (toBigInt(bX(aW(this, ak()))) + toBigInt(gC))
984+            $Tuple2(gF, gy)
989985             }
990986         else {
991-            let gI = aV(this, aj())
992-            let gB = (toBigInt(bY(aV(this, ak()))) + toBigInt(gF))
993-            $Tuple2(gI, gB)
987+            let gF = aW(this, ak())
988+            let gy = (toBigInt(bX(aW(this, al()))) + toBigInt(gC))
989+            $Tuple2(gF, gy)
994990             }
995-    let gI = gH._1
996-    let gB = gH._2
997-    let br = bj()
998-    let ds = br[w]
999-    let dt = br[x]
1000-    let cK = [toBigInt(bY(ds)), toBigInt(bY(dt))]
1001-    let eC = cJ(cK)
1002-    let eK = gz(gA, eC, toBigInt(gF))
1003-    let gJ = ((toBigInt(bY(gI)) - eK) - toBigInt(1))
1004-    let gK = max([0, toInt(gJ)])
1005-    let gL = if ((gA == false))
1006-        then [((toBigInt(bY(ds)) + toBigInt(gF)) + toBigInt(gG)), (toBigInt(bY(dt)) - gJ)]
1007-        else [(toBigInt(bY(ds)) - gJ), ((toBigInt(bY(dt)) + toBigInt(gF)) + toBigInt(gG))]
1008-    let gM = cJ(gL)
1009-    let eh = if ((gM >= eC))
991+    let gF = gE._1
992+    let gy = gE._2
993+    let bs = bk()
994+    let dr = bs[x]
995+    let ds = bs[y]
996+    let cJ = [toBigInt(bX(dr)), toBigInt(bX(ds))]
997+    let ez = cI(cJ)
998+    let eH = gw(gx, ez, toBigInt(gC))
999+    let gG = ((toBigInt(bX(gF)) - eH) - toBigInt(1))
1000+    let gH = max([0, toInt(gG)])
1001+    let gI = if ((gx == false))
1002+        then [((toBigInt(bX(dr)) + toBigInt(gC)) + toBigInt(gD)), (toBigInt(bX(ds)) - gG)]
1003+        else [(toBigInt(bX(dr)) - gG), ((toBigInt(bX(ds)) + toBigInt(gC)) + toBigInt(gD))]
1004+    let gJ = cI(gI)
1005+    let ee = if ((gJ >= ez))
10101006         then true
1011-        else throw(makeString(["new D is fewer error", toString(eC), toString(gM)], "__"))
1012-    if ((eh == eh))
1013-        then $Tuple2(nil, gK)
1007+        else throw(makeString(["new D is fewer error", toString(ez), toString(gJ)], "__"))
1008+    if ((ee == ee))
1009+        then $Tuple2(nil, gH)
10141010         else throw("Strict value is not equal to itself.")
10151011     }
10161012 
10171013 
10181014 
1019-@Callable(cY)
1020-func calculateAmountOutForSwapAndSendTokens (gF,gA,gN,gO,gG) = {
1021-    let gP = {
1022-        let bd = invoke(aT, "getSwapContractREADONLY", nil, nil)
1023-        if ($isInstanceOf(bd, "String"))
1024-            then bd
1025-            else throw(($getType(bd) + " couldn't be cast to String"))
1015+@Callable(cX)
1016+func calculateAmountOutForSwapAndSendTokens (gC,gx,gK,gL,gD) = {
1017+    let gM = {
1018+        let be = invoke(aU, "getSwapContractREADONLY", nil, nil)
1019+        if ($isInstanceOf(be, "String"))
1020+            then be
1021+            else throw(($getType(be) + " couldn't be cast to String"))
10261022         }
1027-    let gQ = [if ((value(cY.payments[0]).amount >= gF))
1023+    let gN = [if ((value(cX.payments[0]).amount >= gC))
10281024         then true
1029-        else aZ("Wrong amount"), if ((cY.caller == addressFromStringValue(gP)))
1025+        else ba("Wrong amount"), if ((cX.caller == addressFromStringValue(gM)))
10301026         then true
1031-        else aZ("Permission denied")]
1032-    if ((gQ == gQ))
1027+        else ba("Permission denied")]
1028+    if ((gN == gN))
10331029         then {
1034-            let ft = value(cY.payments[0])
1035-            let gR = bp(ft.assetId)
1036-            let gS = if ((gA == false))
1030+            let fq = value(cX.payments[0])
1031+            let gO = bq(fq.assetId)
1032+            let gP = if ((gx == false))
10371033                 then {
1038-                    let gI = aV(this, ak())
1039-                    let gB = (bY(gR) - value(cY.payments[0]).amount)
1040-                    $Tuple2(gI, gB)
1034+                    let gF = aW(this, al())
1035+                    let gy = (bX(gO) - value(cX.payments[0]).amount)
1036+                    $Tuple2(gF, gy)
10411037                     }
10421038                 else {
1043-                    let gI = aV(this, aj())
1044-                    let gB = (bY(gR) - value(cY.payments[0]).amount)
1045-                    $Tuple2(gI, gB)
1039+                    let gF = aW(this, ak())
1040+                    let gy = (bX(gO) - value(cX.payments[0]).amount)
1041+                    $Tuple2(gF, gy)
10461042                     }
1047-            let gI = gS._1
1048-            let gB = gS._2
1049-            let br = bj()
1050-            let ds = br[w]
1051-            let dt = br[x]
1052-            let cK = if ((gA == false))
1053-                then [(toBigInt(bY(ds)) - toBigInt(value(cY.payments[0]).amount)), toBigInt(bY(dt))]
1054-                else [toBigInt(bY(ds)), (toBigInt(bY(dt)) - toBigInt(value(cY.payments[0]).amount))]
1055-            let eC = cJ(cK)
1056-            let eK = gz(gA, eC, toBigInt(0))
1057-            let gJ = ((toBigInt(bY(gI)) - eK) - toBigInt(1))
1058-            let gK = max([0, toInt(gJ)])
1059-            let gT = if ((gK >= gN))
1043+            let gF = gP._1
1044+            let gy = gP._2
1045+            let bs = bk()
1046+            let dr = bs[x]
1047+            let ds = bs[y]
1048+            let cJ = if ((gx == false))
1049+                then [(toBigInt(bX(dr)) - toBigInt(value(cX.payments[0]).amount)), toBigInt(bX(ds))]
1050+                else [toBigInt(bX(dr)), (toBigInt(bX(ds)) - toBigInt(value(cX.payments[0]).amount))]
1051+            let ez = cI(cJ)
1052+            let eH = gw(gx, ez, toBigInt(0))
1053+            let gG = ((toBigInt(bX(gF)) - eH) - toBigInt(1))
1054+            let gH = max([0, toInt(gG)])
1055+            let gQ = if ((gH >= gK))
10601056                 then true
10611057                 else throw("Exchange result is fewer coins than expected")
1062-            if ((gT == gT))
1058+            if ((gQ == gQ))
10631059                 then {
1064-                    let gL = if ((gA == false))
1065-                        then [(toBigInt(bY(ds)) + toBigInt(gG)), (toBigInt(bY(dt)) - gJ)]
1066-                        else [(toBigInt(bY(ds)) - gJ), (toBigInt(bY(dt)) + toBigInt(gG))]
1067-                    let gM = cJ(gL)
1068-                    let eh = if ((gM >= eC))
1060+                    let gI = if ((gx == false))
1061+                        then [(toBigInt(bX(dr)) + toBigInt(gD)), (toBigInt(bX(ds)) - gG)]
1062+                        else [(toBigInt(bX(dr)) - gG), (toBigInt(bX(ds)) + toBigInt(gD))]
1063+                    let gJ = cI(gI)
1064+                    let ee = if ((gJ >= ez))
10691065                         then true
10701066                         else throw("new D is fewer error")
1071-                    if ((eh == eh))
1072-                        then $Tuple2([ScriptTransfer(addressFromStringValue(gO), gK, bn(gI))], gK)
1067+                    if ((ee == ee))
1068+                        then $Tuple2([ScriptTransfer(addressFromStringValue(gL), gH, bo(gF))], gH)
10731069                         else throw("Strict value is not equal to itself.")
10741070                     }
10751071                 else throw("Strict value is not equal to itself.")
10761072             }
10771073         else throw("Strict value is not equal to itself.")
10781074     }
10791075 
10801076 
10811077 
1082-@Callable(cY)
1083-func constructor (Y) = {
1084-    let eG = gy(cY)
1085-    if ((eG == eG))
1086-        then [StringEntry(Y(), Y)]
1078+@Callable(cX)
1079+func constructor (Z) = {
1080+    let eD = gv(cX)
1081+    if ((eD == eD))
1082+        then [StringEntry(Z(), Z)]
10871083         else throw("Strict value is not equal to itself.")
10881084     }
10891085 
10901086 
10911087 
1092-@Callable(cY)
1093-func put (gU,gV) = {
1094-    let gW = bD()
1095-    let gX = valueOrErrorMessage(addressFromString(gW[C]), "Wr st addr")
1096-    let gY = valueOrErrorMessage(addressFromString(gW[E]), "Wr sl addr")
1097-    if ((0 > gU))
1088+@Callable(cX)
1089+func put (gR,gS) = {
1090+    let gT = bC()
1091+    let gU = valueOrErrorMessage(addressFromString(gT[D]), "Wr st addr")
1092+    let gV = valueOrErrorMessage(addressFromString(gT[F]), "Wr sl addr")
1093+    if ((0 > gR))
10981094         then throw("Wrong slippage")
1099-        else if ((size(cY.payments) != 2))
1095+        else if ((size(cX.payments) != 2))
11001096             then throw("2 pmnts expd")
11011097             else {
1102-                let gZ = toBigInt(value(cY.payments[0]).amount)
1103-                let ha = toBigInt(value(cY.payments[1]).amount)
1104-                let eX = (toBigInt(bY(bp(bx))) - gZ)
1105-                if ((eX == eX))
1098+                let gW = toBigInt(value(cX.payments[0]).amount)
1099+                let gX = toBigInt(value(cX.payments[1]).amount)
1100+                let eU = (toBigInt(bX(bq(by))) - gW)
1101+                if ((eU == eU))
11061102                     then {
1107-                        let eY = (toBigInt(bY(bp(by))) - ha)
1108-                        if ((eY == eY))
1103+                        let eV = (toBigInt(bX(bq(bz))) - gX)
1104+                        if ((eV == eV))
11091105                             then {
1110-                                let eZ = toBigInt(value(assetInfo(bw)).quantity)
1111-                                if ((eZ == eZ))
1106+                                let eW = toBigInt(value(assetInfo(bx)).quantity)
1107+                                if ((eW == eW))
11121108                                     then {
1113-                                        let fa = eT(gZ, ha, toBigInt(0))
1114-                                        if ((fa == fa))
1109+                                        let eX = eQ(gW, gX, toBigInt(0))
1110+                                        if ((eX == eX))
11151111                                             then {
1116-                                                let hb = fu(toString(cY.caller), toBase58String(cY.transactionId), AttachedPayment(value(cY.payments[0]).assetId, value(cY.payments[0]).amount), cY.payments[1], gU, true, false, true, 0, "")
1117-                                                let eu = hb._2
1118-                                                let hc = hb._7
1119-                                                let dK = hb._9
1120-                                                let ev = hb._10
1121-                                                let ew = hb._11
1122-                                                let ds = hb._12
1123-                                                let dt = hb._13
1124-                                                let eg = invoke(aT, "emit", [eu], nil)
1125-                                                if ((eg == eg))
1112+                                                let gY = fr(toString(cX.caller), toBase58String(cX.transactionId), AttachedPayment(value(cX.payments[0]).assetId, value(cX.payments[0]).amount), cX.payments[1], gR, true, false, true, 0, "")
1113+                                                let er = gY._2
1114+                                                let gZ = gY._7
1115+                                                let dJ = gY._9
1116+                                                let es = gY._10
1117+                                                let et = gY._11
1118+                                                let dr = gY._12
1119+                                                let ds = gY._13
1120+                                                let ed = invoke(aU, "emit", [er], nil)
1121+                                                if ((ed == ed))
11261122                                                     then {
1127-                                                        let hd = {
1128-                                                            let aP = eg
1129-                                                            if ($isInstanceOf(aP, "Address"))
1123+                                                        let ha = {
1124+                                                            let aQ = ed
1125+                                                            if ($isInstanceOf(aQ, "Address"))
11301126                                                                 then {
1131-                                                                    let he = aP
1132-                                                                    invoke(he, "emit", [eu], nil)
1127+                                                                    let hb = aQ
1128+                                                                    invoke(hb, "emit", [er], nil)
11331129                                                                     }
11341130                                                                 else unit
11351131                                                             }
1136-                                                        if ((hd == hd))
1132+                                                        if ((ha == ha))
11371133                                                             then {
1138-                                                                let hf = if ((ev > 0))
1139-                                                                    then invoke(gY, "put", nil, [AttachedPayment(ds, ev)])
1134+                                                                let hc = if ((es > 0))
1135+                                                                    then invoke(gV, "put", nil, [AttachedPayment(dr, es)])
11401136                                                                     else nil
1141-                                                                if ((hf == hf))
1137+                                                                if ((hc == hc))
11421138                                                                     then {
1143-                                                                        let hg = if ((ew > 0))
1144-                                                                            then invoke(gY, "put", nil, [AttachedPayment(dt, ew)])
1139+                                                                        let hd = if ((et > 0))
1140+                                                                            then invoke(gV, "put", nil, [AttachedPayment(ds, et)])
11451141                                                                             else nil
1146-                                                                        if ((hg == hg))
1142+                                                                        if ((hd == hd))
11471143                                                                             then {
1148-                                                                                let hh = if (gV)
1144+                                                                                let he = if (gS)
11491145                                                                                     then {
1150-                                                                                        let hi = invoke(gX, "stake", nil, [AttachedPayment(hc, eu)])
1151-                                                                                        if ((hi == hi))
1146+                                                                                        let hf = invoke(gU, "stake", nil, [AttachedPayment(gZ, er)])
1147+                                                                                        if ((hf == hf))
11521148                                                                                             then nil
11531149                                                                                             else throw("Strict value is not equal to itself.")
11541150                                                                                         }
1155-                                                                                    else [ScriptTransfer(cY.caller, eu, hc)]
1156-                                                                                let hj = fb(0, 0, 0)
1157-                                                                                let gr = hj._1
1158-                                                                                let eS = hj._2
1159-                                                                                let hk = if ((eS >= fa))
1151+                                                                                    else [ScriptTransfer(cX.caller, er, gZ)]
1152+                                                                                let hg = eY(0, 0, 0)
1153+                                                                                let go = hg._1
1154+                                                                                let eP = hg._2
1155+                                                                                let hh = if ((eP >= eX))
11601156                                                                                     then true
1161-                                                                                    else aZ(makeString(["updated DLp lower than current DLp", toString(eX), toString(eY), toString(eZ), toString(fa), toString(eS), toString(ev), toString(ew)], " "))
1162-                                                                                if ((hk == hk))
1157+                                                                                    else ba(makeString(["updated DLp lower than current DLp", toString(eU), toString(eV), toString(eW), toString(eX), toString(eP), toString(es), toString(et)], " "))
1158+                                                                                if ((hh == hh))
11631159                                                                                     then {
1164-                                                                                        let hl = value(assetInfo(bw)).quantity
1165-                                                                                        if ((hl == hl))
1166-                                                                                            then ((dK ++ hh) ++ gr)
1160+                                                                                        let hi = value(assetInfo(bx)).quantity
1161+                                                                                        if ((hi == hi))
1162+                                                                                            then ((dJ ++ he) ++ go)
11671163                                                                                             else throw("Strict value is not equal to itself.")
11681164                                                                                         }
11691165                                                                                     else throw("Strict value is not equal to itself.")
11701166                                                                                 }
11711167                                                                             else throw("Strict value is not equal to itself.")
11721168                                                                         }
11731169                                                                     else throw("Strict value is not equal to itself.")
11741170                                                                 }
11751171                                                             else throw("Strict value is not equal to itself.")
11761172                                                         }
11771173                                                     else throw("Strict value is not equal to itself.")
11781174                                                 }
11791175                                             else throw("Strict value is not equal to itself.")
11801176                                         }
11811177                                     else throw("Strict value is not equal to itself.")
11821178                                 }
11831179                             else throw("Strict value is not equal to itself.")
11841180                         }
11851181                     else throw("Strict value is not equal to itself.")
11861182                 }
11871183     }
11881184 
11891185 
11901186 
1191-@Callable(cY)
1192-func putOneTknV2 (fV,gV) = {
1193-    let hm = {
1194-        let bd = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1195-        if ($isInstanceOf(bd, "Boolean"))
1196-            then bd
1197-            else throw(($getType(bd) + " couldn't be cast to Boolean"))
1187+@Callable(cX)
1188+func putOneTknV2 (fS,gS) = {
1189+    let hj = {
1190+        let be = invoke(aU, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1191+        if ($isInstanceOf(be, "Boolean"))
1192+            then be
1193+            else throw(($getType(be) + " couldn't be cast to Boolean"))
11981194         }
1199-    let hn = if (if (if (bg())
1195+    let hk = if (if (if (bh())
12001196         then true
1201-        else (bv == q))
1197+        else (bw == r))
12021198         then true
1203-        else (bv == s))
1199+        else (bw == t))
12041200         then true
1205-        else hm
1206-    let gQ = [if (if (!(hn))
1201+        else hj
1202+    let gN = [if (if (!(hk))
12071203         then true
1208-        else gw(cY))
1204+        else gt(cX))
12091205         then true
1210-        else aZ("put operation is blocked by admin"), if ((size(cY.payments) == 1))
1206+        else ba("put operation is blocked by admin"), if ((size(cX.payments) == 1))
12111207         then true
1212-        else aZ("exactly 1 payment are expected")]
1213-    if ((gQ == gQ))
1208+        else ba("exactly 1 payment are expected")]
1209+    if ((gN == gN))
12141210         then {
1215-            let ds = toBase58String(value(bx))
1216-            let dt = toBase58String(value(by))
1217-            let dr = bw
1218-            let fZ = bz
1219-            let ga = bA
1220-            let dq = if ((cY.caller == this))
1221-                then cY.originCaller
1222-                else cY.caller
1223-            let ft = value(cY.payments[0])
1224-            let do = toBase58String(value(ft.assetId))
1225-            let dU = ft.amount
1226-            let fa = if ((ft.assetId == bx))
1227-                then eT(toBigInt(dU), toBigInt(0), toBigInt(0))
1228-                else eT(toBigInt(0), toBigInt(dU), toBigInt(0))
1229-            if ((fa == fa))
1211+            let dr = toBase58String(value(by))
1212+            let ds = toBase58String(value(bz))
1213+            let dq = bx
1214+            let fW = bA
1215+            let fX = bB
1216+            let dp = if ((cX.caller == this))
1217+                then cX.originCaller
1218+                else cX.caller
1219+            let fq = value(cX.payments[0])
1220+            let dn = toBase58String(value(fq.assetId))
1221+            let dT = fq.amount
1222+            let eX = if ((fq.assetId == by))
1223+                then eQ(toBigInt(dT), toBigInt(0), toBigInt(0))
1224+                else eQ(toBigInt(0), toBigInt(dT), toBigInt(0))
1225+            if ((eX == eX))
12301226                 then {
1231-                    let ho = fy(dU, do, toString(dq), toBase58String(cY.transactionId), true)
1232-                    if ((ho == ho))
1227+                    let hl = fv(dT, dn, toString(dp), toBase58String(cX.transactionId), true)
1228+                    if ((hl == hl))
12331229                         then {
1234-                            let cI = ho._3
1235-                            let dK = ho._2
1236-                            let hp = ho._1
1237-                            let eu = if (if ((fV > 0))
1238-                                then (fV > hp)
1230+                            let cH = hl._3
1231+                            let dJ = hl._2
1232+                            let hm = hl._1
1233+                            let er = if (if ((fS > 0))
1234+                                then (fS > hm)
12391235                                 else false)
1240-                                then aZ(makeString(["amount to receive is less than ", toString(fV)], ""))
1241-                                else hp
1242-                            let hb = invoke(aT, "emit", [eu], nil)
1243-                            if ((hb == hb))
1236+                                then ba(makeString(["amount to receive is less than ", toString(fS)], ""))
1237+                                else hm
1238+                            let gY = invoke(aU, "emit", [er], nil)
1239+                            if ((gY == gY))
12441240                                 then {
1245-                                    let hd = {
1246-                                        let aP = hb
1247-                                        if ($isInstanceOf(aP, "Address"))
1241+                                    let ha = {
1242+                                        let aQ = gY
1243+                                        if ($isInstanceOf(aQ, "Address"))
12481244                                             then {
1249-                                                let he = aP
1250-                                                invoke(he, "emit", [eu], nil)
1245+                                                let hb = aQ
1246+                                                invoke(hb, "emit", [er], nil)
12511247                                                 }
12521248                                             else unit
12531249                                         }
1254-                                    if ((hd == hd))
1250+                                    if ((ha == ha))
12551251                                         then {
1256-                                            let hh = if (gV)
1252+                                            let he = if (gS)
12571253                                                 then {
1258-                                                    let hi = invoke(bF, "stakeFor", [toString(cY.caller)], [AttachedPayment(dr, eu)])
1259-                                                    if ((hi == hi))
1254+                                                    let hf = invoke(bE, "stakeFor", [toString(cX.caller)], [AttachedPayment(dq, er)])
1255+                                                    if ((hf == hf))
12601256                                                         then nil
12611257                                                         else throw("Strict value is not equal to itself.")
12621258                                                     }
1263-                                                else [ScriptTransfer(cY.caller, eu, dr)]
1264-                                            let gl = if ((cI > 0))
1265-                                                then [ScriptTransfer(bi, cI, fromBase58String(do))]
1259+                                                else [ScriptTransfer(cX.caller, er, dq)]
1260+                                            let gi = if ((cH > 0))
1261+                                                then [ScriptTransfer(bj, cH, fromBase58String(dn))]
12661262                                                 else nil
1267-                                            let hq = if ((this == bi))
1263+                                            let hn = if ((this == bj))
12681264                                                 then $Tuple2(0, 0)
12691265                                                 else {
1270-                                                    let hr = if ((ft.assetId == bx))
1266+                                                    let ho = if ((fq.assetId == by))
12711267                                                         then true
12721268                                                         else false
1273-                                                    if (hr)
1274-                                                        then $Tuple2(-(cI), 0)
1275-                                                        else $Tuple2(0, -(cI))
1269+                                                    if (ho)
1270+                                                        then $Tuple2(-(cH), 0)
1271+                                                        else $Tuple2(0, -(cH))
12761272                                                     }
1277-                                            let fc = hq._1
1278-                                            let fd = hq._2
1279-                                            let hs = fb(fc, fd, 0)
1280-                                            let gr = hs._1
1281-                                            let eS = hs._2
1282-                                            let gs = ff(fa, eS)
1283-                                            if ((gs == gs))
1284-                                                then $Tuple2((((dK ++ hh) ++ gl) ++ gr), eu)
1273+                                            let eZ = hn._1
1274+                                            let fa = hn._2
1275+                                            let hp = eY(eZ, fa, 0)
1276+                                            let go = hp._1
1277+                                            let eP = hp._2
1278+                                            let gp = fc(eX, eP)
1279+                                            if ((gp == gp))
1280+                                                then $Tuple2((((dJ ++ he) ++ gi) ++ go), er)
12851281                                                 else throw("Strict value is not equal to itself.")
12861282                                             }
12871283                                         else throw("Strict value is not equal to itself.")
12881284                                     }
12891285                                 else throw("Strict value is not equal to itself.")
12901286                             }
12911287                         else throw("Strict value is not equal to itself.")
12921288                     }
12931289                 else throw("Strict value is not equal to itself.")
12941290             }
12951291         else throw("Strict value is not equal to itself.")
12961292     }
12971293 
12981294 
12991295 
1300-@Callable(cY)
1301-func putForFree (ht) = if ((0 > ht))
1296+@Callable(cX)
1297+func putForFree (hq) = if ((0 > hq))
13021298     then throw("Wrong slpg")
1303-    else if ((size(cY.payments) != 2))
1299+    else if ((size(cX.payments) != 2))
13041300         then throw("2 pmnts expd")
13051301         else {
1306-            let hu = fu(toString(cY.caller), toBase58String(cY.transactionId), AttachedPayment(value(cY.payments[0]).assetId, value(cY.payments[0]).amount), cY.payments[1], ht, false, false, true, 0, "")
1307-            let dK = hu._9
1308-            let gZ = toBigInt(value(cY.payments[0]).amount)
1309-            let ha = toBigInt(value(cY.payments[1]).amount)
1310-            let fa = eT(gZ, ha, toBigInt(0))
1311-            if ((fa == fa))
1302+            let hr = fr(toString(cX.caller), toBase58String(cX.transactionId), AttachedPayment(value(cX.payments[0]).assetId, value(cX.payments[0]).amount), cX.payments[1], hq, false, false, true, 0, "")
1303+            let dJ = hr._9
1304+            let gW = toBigInt(value(cX.payments[0]).amount)
1305+            let gX = toBigInt(value(cX.payments[1]).amount)
1306+            let eX = eQ(gW, gX, toBigInt(0))
1307+            if ((eX == eX))
13121308                 then {
1313-                    let hv = fb(0, 0, 0)
1314-                    let gr = hv._1
1315-                    let eS = hv._2
1316-                    let gs = ff(fa, eS)
1317-                    if ((gs == gs))
1318-                        then (dK ++ gr)
1309+                    let hs = eY(0, 0, 0)
1310+                    let go = hs._1
1311+                    let eP = hs._2
1312+                    let gp = fc(eX, eP)
1313+                    if ((gp == gp))
1314+                        then (dJ ++ go)
13191315                         else throw("Strict value is not equal to itself.")
13201316                     }
13211317                 else throw("Strict value is not equal to itself.")
13221318             }
13231319 
13241320 
13251321 
1326-@Callable(cY)
1322+@Callable(cX)
13271323 func get () = {
1328-    let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1329-    if ((fa == fa))
1324+    let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1325+    if ((eX == eX))
13301326         then {
1331-            let eg = fs(cY)
1332-            let hw = eg._1
1333-            let dJ = eg._2
1334-            let dU = eg._3
1335-            let do = eg._4
1336-            let dK = eg._5
1337-            let eH = invoke(aT, "burn", [dU], [AttachedPayment(do, dU)])
1338-            if ((eH == eH))
1327+            let ed = fp(cX)
1328+            let ht = ed._1
1329+            let dI = ed._2
1330+            let dT = ed._3
1331+            let dn = ed._4
1332+            let dJ = ed._5
1333+            let eE = invoke(aU, "burn", [dT], [AttachedPayment(dn, dT)])
1334+            if ((eE == eE))
13391335                 then {
1340-                    let hx = fb(-(hw), -(dJ), 0)
1341-                    let gr = hx._1
1342-                    let eS = hx._2
1343-                    let gs = ff(fa, eS)
1344-                    if ((gs == gs))
1345-                        then (dK ++ gr)
1336+                    let hu = eY(-(ht), -(dI), 0)
1337+                    let go = hu._1
1338+                    let eP = hu._2
1339+                    let gp = fc(eX, eP)
1340+                    if ((gp == gp))
1341+                        then (dJ ++ go)
13461342                         else throw("Strict value is not equal to itself.")
13471343                     }
13481344                 else throw("Strict value is not equal to itself.")
13491345             }
13501346         else throw("Strict value is not equal to itself.")
13511347     }
13521348 
13531349 
13541350 
1355-@Callable(cY)
1356-func getOneTknV2 (fU,fV) = {
1357-    let hm = {
1358-        let bd = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1359-        if ($isInstanceOf(bd, "Boolean"))
1360-            then bd
1361-            else throw(($getType(bd) + " couldn't be cast to Boolean"))
1351+@Callable(cX)
1352+func getOneTknV2 (fR,fS) = {
1353+    let hj = {
1354+        let be = invoke(aU, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1355+        if ($isInstanceOf(be, "Boolean"))
1356+            then be
1357+            else throw(($getType(be) + " couldn't be cast to Boolean"))
13621358         }
1363-    let hy = if (if (bg())
1359+    let hv = if (if (bh())
13641360         then true
1365-        else (bv == s))
1361+        else (bw == t))
13661362         then true
1367-        else hm
1368-    let gQ = [if (if (!(hy))
1363+        else hj
1364+    let gN = [if (if (!(hv))
13691365         then true
1370-        else gw(cY))
1366+        else gt(cX))
13711367         then true
1372-        else aZ("get operation is blocked by admin"), if ((size(cY.payments) == 1))
1368+        else ba("get operation is blocked by admin"), if ((size(cX.payments) == 1))
13731369         then true
1374-        else aZ("exactly 1 payment are expected")]
1375-    if ((gQ == gQ))
1370+        else ba("exactly 1 payment are expected")]
1371+    if ((gN == gN))
13761372         then {
1377-            let hz = fT(fU, fV, cY.payments, cY.caller, cY.originCaller, cY.transactionId)
1378-            let dK = hz._1
1379-            let ge = hz._2
1380-            $Tuple2(dK, ge)
1373+            let hw = fQ(fR, fS, cX.payments, cX.caller, cX.originCaller, cX.transactionId)
1374+            let dJ = hw._1
1375+            let gb = hw._2
1376+            $Tuple2(dJ, gb)
13811377             }
13821378         else throw("Strict value is not equal to itself.")
13831379     }
13841380 
13851381 
13861382 
1387-@Callable(cY)
1383+@Callable(cX)
13881384 func refreshDLp () = {
1389-    let hA = valueOrElse(getInteger(as), 0)
1390-    let hB = if (((height - hA) >= av))
1385+    let hx = valueOrElse(getInteger(at), 0)
1386+    let hy = if (((height - hx) >= aw))
13911387         then unit
1392-        else aZ(makeString([toString(av), " blocks have not passed since the previous call"], ""))
1393-    if ((hB == hB))
1388+        else ba(makeString([toString(aw), " blocks have not passed since the previous call"], ""))
1389+    if ((hy == hy))
13941390         then {
1395-            let fm = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, ar), "0")), bb("invalid dLp"))
1396-            let hC = fb(0, 0, 0)
1397-            let hD = hC._1
1398-            let eS = hC._2
1399-            let fe = if ((fm != eS))
1400-                then hD
1401-                else aZ("nothing to refresh")
1402-            $Tuple2(fe, toString(eS))
1391+            let fj = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, as), "0")), bc("invalid dLp"))
1392+            let hz = eY(0, 0, 0)
1393+            let hA = hz._1
1394+            let eP = hz._2
1395+            let fb = if ((fj != eP))
1396+                then hA
1397+                else ba("nothing to refresh")
1398+            $Tuple2(fb, toString(eP))
14031399             }
14041400         else throw("Strict value is not equal to itself.")
14051401     }
14061402 
14071403 
14081404 
1409-@Callable(cY)
1410-func getOneTknV2READONLY (fU,hE) = {
1411-    let ds = toBase58String(value(bx))
1412-    let dt = toBase58String(value(by))
1413-    let dr = toBase58String(value(bw))
1414-    let cK = [toBigInt(bY(ds)), toBigInt(bY(dt))]
1415-    let eR = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(dr)), "invalid lp asset").quantity)
1416-    let cm = cJ(cK)
1417-    let cl = (cm - fraction(toBigInt(hE), cm, eR))
1418-    let hF = if ((fU == ds))
1405+@Callable(cX)
1406+func getOneTknV2READONLY (fR,hB) = {
1407+    let dr = toBase58String(value(by))
1408+    let ds = toBase58String(value(bz))
1409+    let dq = toBase58String(value(bx))
1410+    let cJ = [toBigInt(bX(dr)), toBigInt(bX(ds))]
1411+    let eO = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(dq)), "invalid lp asset").quantity)
1412+    let cl = cI(cJ)
1413+    let ck = (cl - fraction(toBigInt(hB), cl, eO))
1414+    let hC = if ((fR == dr))
14191415         then 0
1420-        else if ((fU == dt))
1416+        else if ((fR == ds))
14211417             then 1
14221418             else throw("invalid out asset id")
1423-    let hG = eB(cK, hF, cl)
1424-    let gJ = (cK[hF] - hG)
1425-    let gK = max([0, toInt((gJ - f))])
1426-    let hH = cG(gK, be)
1427-    let gd = hH._1
1428-    let cI = hH._2
1429-    $Tuple2(nil, $Tuple2(gd, cI))
1419+    let hD = ey(cJ, hC, ck)
1420+    let gG = (cJ[hC] - hD)
1421+    let gH = max([0, toInt((gG - f))])
1422+    let hE = cF(gH, bf)
1423+    let ga = hE._1
1424+    let cH = hE._2
1425+    $Tuple2(nil, $Tuple2(ga, cH))
14301426     }
14311427 
14321428 
14331429 
1434-@Callable(cY)
1435-func getOneTknV2WithBonusREADONLY (fU,hE) = {
1436-    let ds = toBase58String(value(bx))
1437-    let dt = toBase58String(value(by))
1438-    let dr = toBase58String(value(bw))
1439-    let dy = bY(ds)
1440-    let dA = bY(dt)
1441-    let hI = {
1442-        let bd = invoke(this, "getOneTknV2READONLY", [fU, hE], nil)
1443-        if ($isInstanceOf(bd, "(Int, Int)"))
1444-            then bd
1445-            else throw(($getType(bd) + " couldn't be cast to (Int, Int)"))
1430+@Callable(cX)
1431+func getOneTknV2WithBonusREADONLY (fR,hB) = {
1432+    let dr = toBase58String(value(by))
1433+    let ds = toBase58String(value(bz))
1434+    let dq = toBase58String(value(bx))
1435+    let dx = bX(dr)
1436+    let dz = bX(ds)
1437+    let hF = {
1438+        let be = invoke(this, "getOneTknV2READONLY", [fR, hB], nil)
1439+        if ($isInstanceOf(be, "(Int, Int)"))
1440+            then be
1441+            else throw(($getType(be) + " couldn't be cast to (Int, Int)"))
14461442         }
1447-    let gd = hI._1
1448-    let cI = hI._2
1449-    let eg = dm("", dr, hE, this)
1450-    let dI = eg._1
1451-    let dJ = eg._2
1452-    let hJ = (dI + dJ)
1453-    let fS = if ((hJ == 0))
1454-        then if ((gd == 0))
1443+    let ga = hF._1
1444+    let cH = hF._2
1445+    let ed = dl("", dq, hB, this)
1446+    let dH = ed._1
1447+    let dI = ed._2
1448+    let hG = (dH + dI)
1449+    let fP = if ((hG == 0))
1450+        then if ((ga == 0))
14551451             then 0
14561452             else throw("bonus calculation error")
1457-        else fraction((gd - hJ), a, hJ)
1458-    $Tuple2(nil, $Tuple3(gd, cI, fS))
1453+        else fraction((ga - hG), a, hG)
1454+    $Tuple2(nil, $Tuple3(ga, cH, fP))
14591455     }
14601456 
14611457 
14621458 
1463-@Callable(cY)
1464-func getNoLess (hK,hL) = {
1465-    let eg = fs(cY)
1466-    let dI = eg._1
1467-    let dJ = eg._2
1468-    let dU = eg._3
1469-    let do = eg._4
1470-    let dK = eg._5
1471-    if ((hK > dI))
1472-        then throw(((("Failed:  " + toString(dI)) + " < ") + toString(hK)))
1473-        else if ((hL > dJ))
1474-            then throw(((("Failed: " + toString(dJ)) + " < ") + toString(hL)))
1459+@Callable(cX)
1460+func getNoLess (hH,hI) = {
1461+    let ed = fp(cX)
1462+    let dH = ed._1
1463+    let dI = ed._2
1464+    let dT = ed._3
1465+    let dn = ed._4
1466+    let dJ = ed._5
1467+    if ((hH > dH))
1468+        then throw(((("Failed:  " + toString(dH)) + " < ") + toString(hH)))
1469+        else if ((hI > dI))
1470+            then throw(((("Failed: " + toString(dI)) + " < ") + toString(hI)))
14751471             else {
1476-                let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1477-                if ((fa == fa))
1472+                let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1473+                if ((eX == eX))
14781474                     then {
1479-                        let hM = invoke(aT, "burn", [dU], [AttachedPayment(do, dU)])
1480-                        if ((hM == hM))
1475+                        let hJ = invoke(aU, "burn", [dT], [AttachedPayment(dn, dT)])
1476+                        if ((hJ == hJ))
14811477                             then {
1482-                                let hN = fb(-(dI), -(dJ), 0)
1483-                                let gr = hN._1
1484-                                let eS = hN._2
1485-                                let gs = ff(fa, eS)
1486-                                if ((gs == gs))
1487-                                    then (dK ++ gr)
1478+                                let hK = eY(-(dH), -(dI), 0)
1479+                                let go = hK._1
1480+                                let eP = hK._2
1481+                                let gp = fc(eX, eP)
1482+                                if ((gp == gp))
1483+                                    then (dJ ++ go)
14881484                                     else throw("Strict value is not equal to itself.")
14891485                                 }
14901486                             else throw("Strict value is not equal to itself.")
14911487                         }
14921488                     else throw("Strict value is not equal to itself.")
14931489                 }
14941490     }
14951491 
14961492 
14971493 
1498-@Callable(cY)
1499-func unstakeAndGet (cH) = {
1500-    let hO = if ((size(cY.payments) != 0))
1494+@Callable(cX)
1495+func unstakeAndGet (cG) = {
1496+    let hL = if ((size(cX.payments) != 0))
15011497         then throw("No pmnts expd")
15021498         else true
1503-    if ((hO == hO))
1499+    if ((hL == hL))
15041500         then {
1505-            let hP = bD()
1506-            let hc = bw
1507-            let hQ = valueOrErrorMessage(addressFromString(hP[C]), "Wr st addr")
1508-            let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1509-            if ((fa == fa))
1501+            let hM = bC()
1502+            let gZ = bx
1503+            let hN = valueOrErrorMessage(addressFromString(hM[D]), "Wr st addr")
1504+            let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1505+            if ((eX == eX))
15101506                 then {
1511-                    let hR = invoke(hQ, "unstake", [toBase58String(hc), cH], nil)
1512-                    if ((hR == hR))
1507+                    let hO = invoke(hN, "unstake", [toBase58String(gZ), cG], nil)
1508+                    if ((hO == hO))
15131509                         then {
1514-                            let eg = dm(toBase58String(cY.transactionId), toBase58String(hc), cH, cY.caller)
1515-                            let dI = eg._1
1516-                            let dJ = eg._2
1517-                            let dw = parseIntValue(eg._9)
1518-                            let dK = eg._10
1519-                            let hS = if (if (bg())
1510+                            let ed = dl(toBase58String(cX.transactionId), toBase58String(gZ), cG, cX.caller)
1511+                            let dH = ed._1
1512+                            let dI = ed._2
1513+                            let dv = parseIntValue(ed._9)
1514+                            let dJ = ed._10
1515+                            let hP = if (if (bh())
15201516                                 then true
1521-                                else (dw == s))
1522-                                then throw(("Blocked: " + toString(dw)))
1517+                                else (dv == t))
1518+                                then throw(("Blocked: " + toString(dv)))
15231519                                 else true
1524-                            if ((hS == hS))
1520+                            if ((hP == hP))
15251521                                 then {
1526-                                    let hT = invoke(aT, "burn", [cH], [AttachedPayment(hc, cH)])
1527-                                    if ((hT == hT))
1522+                                    let hQ = invoke(aU, "burn", [cG], [AttachedPayment(gZ, cG)])
1523+                                    if ((hQ == hQ))
15281524                                         then {
1529-                                            let hU = fb(-(dI), -(dJ), 0)
1530-                                            let gr = hU._1
1531-                                            let eS = hU._2
1532-                                            let gs = ff(fa, eS)
1533-                                            if ((gs == gs))
1534-                                                then (dK ++ gr)
1525+                                            let hR = eY(-(dH), -(dI), 0)
1526+                                            let go = hR._1
1527+                                            let eP = hR._2
1528+                                            let gp = fc(eX, eP)
1529+                                            if ((gp == gp))
1530+                                                then (dJ ++ go)
15351531                                                 else throw("Strict value is not equal to itself.")
15361532                                             }
15371533                                         else throw("Strict value is not equal to itself.")
15381534                                     }
15391535                                 else throw("Strict value is not equal to itself.")
15401536                             }
15411537                         else throw("Strict value is not equal to itself.")
15421538                     }
15431539                 else throw("Strict value is not equal to itself.")
15441540             }
15451541         else throw("Strict value is not equal to itself.")
15461542     }
15471543 
15481544 
15491545 
1550-@Callable(cY)
1551-func unstakeAndGetNoLess (hV,hW,hL) = {
1552-    let hy = if (bg())
1546+@Callable(cX)
1547+func unstakeAndGetNoLess (hS,hT,hI) = {
1548+    let hv = if (bh())
15531549         then true
1554-        else (bv == s)
1555-    let gQ = [if (!(hy))
1550+        else (bw == t)
1551+    let gN = [if (!(hv))
15561552         then true
1557-        else throw("get operation is blocked by admin"), if ((size(cY.payments) == 0))
1553+        else throw("get operation is blocked by admin"), if ((size(cX.payments) == 0))
15581554         then true
15591555         else throw("no payments are expected")]
1560-    if ((gQ == gQ))
1556+    if ((gN == gN))
15611557         then {
1562-            let fa = eT(toBigInt(0), toBigInt(0), toBigInt(0))
1563-            if ((fa == fa))
1558+            let eX = eQ(toBigInt(0), toBigInt(0), toBigInt(0))
1559+            if ((eX == eX))
15641560                 then {
1565-                    let hR = invoke(bF, "unstake", [toBase58String(bw), hV], nil)
1566-                    if ((hR == hR))
1561+                    let hO = invoke(bE, "unstake", [toBase58String(bx), hS], nil)
1562+                    if ((hO == hO))
15671563                         then {
1568-                            let hX = dm(toBase58String(cY.transactionId), toBase58String(bw), hV, cY.caller)
1569-                            let dI = hX._1
1570-                            let dJ = hX._2
1571-                            let dK = hX._10
1572-                            let hY = [if ((dI >= hW))
1564+                            let hU = dl(toBase58String(cX.transactionId), toBase58String(bx), hS, cX.caller)
1565+                            let dH = hU._1
1566+                            let dI = hU._2
1567+                            let dJ = hU._10
1568+                            let hV = [if ((dH >= hT))
15731569                                 then true
1574-                                else throw(makeString(["amount asset amount to receive is less than ", toString(hW)], "")), if ((dJ >= hL))
1570+                                else throw(makeString(["amount asset amount to receive is less than ", toString(hT)], "")), if ((dI >= hI))
15751571                                 then true
1576-                                else throw(makeString(["price asset amount to receive is less than ", toString(hL)], ""))]
1577-                            if ((hY == hY))
1572+                                else throw(makeString(["price asset amount to receive is less than ", toString(hI)], ""))]
1573+                            if ((hV == hV))
15781574                                 then {
1579-                                    let hM = invoke(aT, "burn", [hV], [AttachedPayment(bw, hV)])
1580-                                    if ((hM == hM))
1575+                                    let hJ = invoke(aU, "burn", [hS], [AttachedPayment(bx, hS)])
1576+                                    if ((hJ == hJ))
15811577                                         then {
1582-                                            let hZ = fb(-(dI), -(dJ), 0)
1583-                                            let gr = hZ._1
1584-                                            let eS = hZ._2
1585-                                            let gs = ff(fa, eS)
1586-                                            if ((gs == gs))
1587-                                                then (dK ++ gr)
1578+                                            let hW = eY(-(dH), -(dI), 0)
1579+                                            let go = hW._1
1580+                                            let eP = hW._2
1581+                                            let gp = fc(eX, eP)
1582+                                            if ((gp == gp))
1583+                                                then (dJ ++ go)
15881584                                                 else throw("Strict value is not equal to itself.")
15891585                                             }
15901586                                         else throw("Strict value is not equal to itself.")
15911587                                     }
15921588                                 else throw("Strict value is not equal to itself.")
15931589                             }
15941590                         else throw("Strict value is not equal to itself.")
15951591                     }
15961592                 else throw("Strict value is not equal to itself.")
15971593             }
15981594         else throw("Strict value is not equal to itself.")
15991595     }
16001596 
16011597 
16021598 
1603-@Callable(cY)
1604-func unstakeAndGetOneTknV2 (hV,fU,fV) = {
1605-    let hm = {
1606-        let bd = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1607-        if ($isInstanceOf(bd, "Boolean"))
1608-            then bd
1609-            else throw(($getType(bd) + " couldn't be cast to Boolean"))
1599+@Callable(cX)
1600+func unstakeAndGetOneTknV2 (hS,fR,fS) = {
1601+    let hj = {
1602+        let be = invoke(aU, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1603+        if ($isInstanceOf(be, "Boolean"))
1604+            then be
1605+            else throw(($getType(be) + " couldn't be cast to Boolean"))
16101606         }
1611-    let hy = if (if (bg())
1607+    let hv = if (if (bh())
16121608         then true
1613-        else (bv == s))
1609+        else (bw == t))
16141610         then true
1615-        else hm
1616-    let gQ = [if (if (!(hy))
1611+        else hj
1612+    let gN = [if (if (!(hv))
16171613         then true
1618-        else gw(cY))
1614+        else gt(cX))
16191615         then true
1620-        else aZ("get operation is blocked by admin"), if ((size(cY.payments) == 0))
1616+        else ba("get operation is blocked by admin"), if ((size(cX.payments) == 0))
16211617         then true
1622-        else aZ("no payments are expected")]
1623-    if ((gQ == gQ))
1618+        else ba("no payments are expected")]
1619+    if ((gN == gN))
16241620         then {
1625-            let hP = bD()
1626-            let hc = bw
1627-            let hQ = valueOrErrorMessage(addressFromString(hP[C]), "Wr st addr")
1628-            let dq = cY.caller
1629-            let ia = this
1630-            let hR = invoke(hQ, "unstakeINTERNAL", [hc, hV, dq.bytes, ia.bytes], nil)
1631-            if ((hR == hR))
1621+            let hM = bC()
1622+            let gZ = bx
1623+            let hN = valueOrErrorMessage(addressFromString(hM[D]), "Wr st addr")
1624+            let dp = cX.caller
1625+            let hX = this
1626+            let hO = invoke(hN, "unstakeINTERNAL", [gZ, hS, dp.bytes, hX.bytes], nil)
1627+            if ((hO == hO))
16321628                 then {
1633-                    let ib = fT(fU, fV, [AttachedPayment(hc, hV)], cY.caller, cY.originCaller, cY.transactionId)
1634-                    let dK = ib._1
1635-                    let ge = ib._2
1636-                    $Tuple2(dK, ge)
1629+                    let hY = fQ(fR, fS, [AttachedPayment(gZ, hS)], cX.caller, cX.originCaller, cX.transactionId)
1630+                    let dJ = hY._1
1631+                    let gb = hY._2
1632+                    $Tuple2(dJ, gb)
16371633                     }
16381634                 else throw("Strict value is not equal to itself.")
16391635             }
16401636         else throw("Strict value is not equal to itself.")
16411637     }
16421638 
16431639 
16441640 
1645-@Callable(cY)
1646-func putOneTknV2WithBonusREADONLY (ic,id) = {
1647-    let ie = fy(ic, id, "", "", true)
1648-    let fN = ie._1
1649-    let dK = ie._2
1650-    let cI = ie._3
1651-    let fS = ie._4
1652-    $Tuple2(nil, $Tuple3(fN, cI, fS))
1641+@Callable(cX)
1642+func putOneTknV2WithBonusREADONLY (hZ,ia) = {
1643+    let ib = fv(hZ, ia, "", "", true)
1644+    let fK = ib._1
1645+    let dJ = ib._2
1646+    let cH = ib._3
1647+    let fP = ib._4
1648+    $Tuple2(nil, $Tuple3(fK, cH, fP))
16531649     }
16541650 
16551651 
16561652 
1657-@Callable(cY)
1658-func putOneTknV2WithoutTakeFeeREADONLY (ic,id) = {
1659-    let if = fy(ic, id, "", "", false)
1660-    let fN = if._1
1661-    let dK = if._2
1662-    let cI = if._3
1663-    let fS = if._4
1664-    $Tuple2(nil, $Tuple3(fN, cI, fS))
1653+@Callable(cX)
1654+func putOneTknV2WithoutTakeFeeREADONLY (hZ,ia) = {
1655+    let ic = fv(hZ, ia, "", "", false)
1656+    let fK = ic._1
1657+    let dJ = ic._2
1658+    let cH = ic._3
1659+    let fP = ic._4
1660+    $Tuple2(nil, $Tuple3(fK, cH, fP))
16651661     }
16661662 
16671663 
16681664 
1669-@Callable(cY)
1670-func activate (ig,ih) = if ((toString(cY.caller) != toString(aT)))
1665+@Callable(cX)
1666+func activate (id,ie) = if ((toString(cX.caller) != toString(aU)))
16711667     then throw("denied")
1672-    else $Tuple2([StringEntry(aj(), ig), StringEntry(ak(), ih)], "success")
1668+    else $Tuple2([StringEntry(ak(), id), StringEntry(al(), ie), StringEntry(am(), toString(l))], "success")
16731669 
16741670 
16751671 
1676-@Callable(cY)
1677-func getPoolConfigWrapperREADONLY () = $Tuple2(nil, bj())
1672+@Callable(cX)
1673+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, bk())
16781674 
16791675 
16801676 
1681-@Callable(cY)
1682-func getAccBalanceWrapperREADONLY (bZ) = $Tuple2(nil, bY(bZ))
1677+@Callable(cX)
1678+func getAccBalanceWrapperREADONLY (bY) = $Tuple2(nil, bX(bY))
16831679 
16841680 
16851681 
1686-@Callable(cY)
1687-func calcPricesWrapperREADONLY (cs,ct,cx) = {
1688-    let ii = cw(cs, ct, cx)
1689-    $Tuple2(nil, [toString(ii[0]), toString(ii[1]), toString(ii[2])])
1682+@Callable(cX)
1683+func calcPricesWrapperREADONLY (cr,cs,cw) = {
1684+    let if = cv(cr, cs, cw)
1685+    $Tuple2(nil, [toString(if[0]), toString(if[1]), toString(if[2])])
16901686     }
16911687 
16921688 
16931689 
1694-@Callable(cY)
1695-func fromX18WrapperREADONLY (M,ij) = $Tuple2(nil, L(parseBigIntValue(M), ij))
1690+@Callable(cX)
1691+func fromX18WrapperREADONLY (N,ig) = $Tuple2(nil, M(parseBigIntValue(N), ig))
16961692 
16971693 
16981694 
1699-@Callable(cY)
1700-func toX18WrapperREADONLY (I,J) = $Tuple2(nil, toString(H(I, J)))
1695+@Callable(cX)
1696+func toX18WrapperREADONLY (J,K) = $Tuple2(nil, toString(I(J, K)))
17011697 
17021698 
17031699 
1704-@Callable(cY)
1705-func calcPriceBigIntWrapperREADONLY (cb,cc) = $Tuple2(nil, toString(ca(parseBigIntValue(cb), parseBigIntValue(cc))))
1700+@Callable(cX)
1701+func calcPriceBigIntWrapperREADONLY (ca,cb) = $Tuple2(nil, toString(bZ(parseBigIntValue(ca), parseBigIntValue(cb))))
17061702 
17071703 
17081704 
1709-@Callable(cY)
1710-func estimatePutOperationWrapperREADONLY (dn,ch,dM,dN,dO,dP,ik,dQ,dR) = $Tuple2(nil, dL(dn, ch, dM, dN, dO, dP, ik, dQ, dR, true, false, 0, ""))
1705+@Callable(cX)
1706+func estimatePutOperationWrapperREADONLY (dm,cg,dL,dM,dN,dO,ih,dP,dQ) = $Tuple2(nil, dK(dm, cg, dL, dM, dN, dO, ih, dP, dQ, true, false, 0, ""))
17111707 
17121708 
17131709 
1714-@Callable(cY)
1715-func estimateGetOperationWrapperREADONLY (dn,il,dp,ik) = {
1716-    let eg = dm(dn, il, dp, addressFromStringValue(ik))
1717-    $Tuple2(nil, $Tuple10(eg._1, eg._2, eg._3, eg._4, eg._5, eg._6, eg._7, toString(eg._8), eg._9, eg._10))
1710+@Callable(cX)
1711+func estimateGetOperationWrapperREADONLY (dm,ii,do,ih) = {
1712+    let ed = dl(dm, ii, do, addressFromStringValue(ih))
1713+    $Tuple2(nil, $Tuple10(ed._1, ed._2, ed._3, ed._4, ed._5, ed._6, ed._7, toString(ed._8), ed._9, ed._10))
17181714     }
17191715 
17201716 
17211717 
1722-@Callable(cY)
1718+@Callable(cX)
17231719 func changeAmp () = {
1724-    let im = invoke(aT, "getChangeAmpConfigREADONLY", [toString(this)], nil)
1725-    let in = {
1726-        let aP = im
1727-        if ($isInstanceOf(aP, "List[Any]"))
1720+    let ij = invoke(aU, "getChangeAmpConfigREADONLY", [toString(this)], nil)
1721+    let ik = {
1722+        let aQ = ij
1723+        if ($isInstanceOf(aQ, "List[Any]"))
17281724             then {
1729-                let io = aP
1725+                let il = aQ
17301726                 $Tuple3({
1731-                    let bd = io[0]
1732-                    if ($isInstanceOf(bd, "Int"))
1733-                        then bd
1734-                        else throw(($getType(bd) + " couldn't be cast to Int"))
1727+                    let be = il[0]
1728+                    if ($isInstanceOf(be, "Int"))
1729+                        then be
1730+                        else throw(($getType(be) + " couldn't be cast to Int"))
17351731                     }, {
1736-                    let bd = io[1]
1737-                    if ($isInstanceOf(bd, "Int"))
1738-                        then bd
1739-                        else throw(($getType(bd) + " couldn't be cast to Int"))
1732+                    let be = il[1]
1733+                    if ($isInstanceOf(be, "Int"))
1734+                        then be
1735+                        else throw(($getType(be) + " couldn't be cast to Int"))
17401736                     }, {
1741-                    let bd = io[2]
1742-                    if ($isInstanceOf(bd, "Int"))
1743-                        then bd
1744-                        else throw(($getType(bd) + " couldn't be cast to Int"))
1737+                    let be = il[2]
1738+                    if ($isInstanceOf(be, "Int"))
1739+                        then be
1740+                        else throw(($getType(be) + " couldn't be cast to Int"))
17451741                     })
17461742                 }
1747-            else aZ("invalid entry type")
1743+            else ba("invalid entry type")
17481744         }
1749-    let ip = in._1
1750-    let iq = in._2
1751-    let ir = in._3
1752-    let is = parseIntValue(getStringValue(al()))
1753-    let it = (is + iq)
1754-    let iu = if ((0 > iq))
1755-        then if ((ir > it))
1756-            then ir
1757-            else it
1758-        else if ((it > ir))
1759-            then ir
1760-            else it
1761-    let iv = valueOrElse(getInteger(ao()), 0)
1762-    let iw = (iv + ip)
1763-    let gQ = [if ((height > iw))
1745+    let im = ik._1
1746+    let in = ik._2
1747+    let io = ik._3
1748+    let ip = parseIntValue(getStringValue(am()))
1749+    let iq = (ip + in)
1750+    let ir = if ((0 > in))
1751+        then if ((io > iq))
1752+            then io
1753+            else iq
1754+        else if ((iq > io))
1755+            then io
1756+            else iq
1757+    let is = valueOrElse(getInteger(ap()), 0)
1758+    let it = (is + im)
1759+    let gN = [if ((height > it))
17641760         then true
1765-        else aZ("try again in few blocks"), if ((is != iu))
1761+        else ba("try again in few blocks"), if ((ip != ir))
17661762         then true
1767-        else aZ("already reached target")]
1768-    if ((gQ == gQ))
1769-        then [IntegerEntry(ao(), height), StringEntry(al(), toString(iu)), StringEntry(am(height), toString(iu))]
1763+        else ba("already reached target")]
1764+    if ((gN == gN))
1765+        then [IntegerEntry(ap(), height), StringEntry(am(), toString(ir)), StringEntry(an(height), toString(ir))]
17701766         else throw("Strict value is not equal to itself.")
17711767     }
17721768 
17731769 
1774-@Verifier(ix)
1775-func iy () = {
1776-    let iz = {
1777-        let aP = gt()
1778-        if ($isInstanceOf(aP, "ByteVector"))
1770+@Verifier(iu)
1771+func iv () = {
1772+    let iw = {
1773+        let aQ = gq()
1774+        if ($isInstanceOf(aQ, "ByteVector"))
17791775             then {
1780-                let gx = aP
1781-                gx
1776+                let gu = aQ
1777+                gu
17821778                 }
1783-            else if ($isInstanceOf(aP, "Unit"))
1784-                then ix.senderPublicKey
1779+            else if ($isInstanceOf(aQ, "Unit"))
1780+                then iu.senderPublicKey
17851781                 else throw("Match error")
17861782         }
1787-    let aP = ix
1788-    if ($isInstanceOf(aP, "Order"))
1783+    let aQ = iu
1784+    if ($isInstanceOf(aQ, "Order"))
17891785         then {
1790-            let fi = aP
1791-            let iA = bh()
1792-            let iB = if (gE())
1786+            let ff = aQ
1787+            let ix = bi()
1788+            let iy = if (gB())
17931789                 then $Tuple2(true, "")
1794-                else fh(fi)
1795-            let aJ = iB._1
1796-            let aK = iB._2
1797-            let aL = sigVerify(fi.bodyBytes, fi.proofs[0], fi.senderPublicKey)
1798-            let aM = sigVerify(fi.bodyBytes, fi.proofs[1], iA)
1799-            if (if (if (aJ)
1800-                then aL
1801-                else false)
1790+                else fe(ff)
1791+            let aK = iy._1
1792+            let aL = iy._2
1793+            let aM = sigVerify(ff.bodyBytes, ff.proofs[0], ff.senderPublicKey)
1794+            let aN = sigVerify(ff.bodyBytes, ff.proofs[1], ix)
1795+            if (if (if (aK)
18021796                 then aM
18031797                 else false)
1798+                then aN
1799+                else false)
18041800                 then true
1805-                else aI(aJ, aK, aL, aM)
1801+                else aJ(aK, aL, aM, aN)
18061802             }
1807-        else if ($isInstanceOf(aP, "SetScriptTransaction"))
1803+        else if ($isInstanceOf(aQ, "SetScriptTransaction"))
18081804             then {
1809-                let aU = aP
1810-                if (sigVerify(ix.bodyBytes, ix.proofs[0], iz))
1805+                let aV = aQ
1806+                if (sigVerify(iu.bodyBytes, iu.proofs[0], iw))
18111807                     then true
18121808                     else {
1813-                        let iC = blake2b256(value(aU.script))
1814-                        let iD = fromBase64String(value(getString(aT, aE())))
1815-                        let iE = scriptHash(this)
1816-                        if ((iD == iC))
1817-                            then (iE != iC)
1809+                        let iz = blake2b256(value(aV.script))
1810+                        let iA = fromBase64String(value(getString(aU, aF())))
1811+                        let iB = scriptHash(this)
1812+                        if ((iA == iz))
1813+                            then (iB != iz)
18181814                             else false
18191815                         }
18201816                 }
1821-            else sigVerify(ix.bodyBytes, ix.proofs[0], iz)
1817+            else sigVerify(iu.bodyBytes, iu.proofs[0], iw)
18221818     }
18231819 
github/deemru/w8io/026f985 
741.29 ms ◑