w8 · tx · 78S···KCH

tx · 78SJsx9GinbQ4f6HYDRxUotTKAnukUbwzskrFRWM5KCH

3MtP3m8hWMxYcyDxXB6n299KrsLLyT8ehni:  -0.04000000 Waves

2023.02.09 22:45 [2442518] smart account 3MtP3m8hWMxYcyDxXB6n299KrsLLyT8ehni > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "78SJsx9GinbQ4f6HYDRxUotTKAnukUbwzskrFRWM5KCH",
    "fee": 4000000,
    "feeAssetId": null,
    "timestamp": 1675971963372,
    "version": 2,
    "chainId": 84,
    "sender": "3MtP3m8hWMxYcyDxXB6n299KrsLLyT8ehni",
    "senderPublicKey": "BRyVaCURUMe7ssUbXucteig1g44bGwWirJQzugKahUQ1",
    "proofs": [
        "4ihpKWfszwW2GCdFjAWKsLE2iBq6K1B9dsEn7c8cXh4LBEC8efGH1ART2ZPZTMSozfKw9JYCZGvWWLURAcnYPoDW"
    ],
    "script": "base64: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",
    "height": 2442518,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8k2tLttoL5Ros45FUs2RkN1aukqGJvL4TuJD8u52djY1
Next: DtMjm4JbbD7ppDFv4UmhMcEQagkEyrkyFpEsSqvsqawX

Diff: 
Old New Differences
23 23  
24 24  let k = "WAVES"
25 25  
26 - let l = 1
26 + let l = "100"
27 27  
28 - let m = "100"
28 + let m = "1"
29 29  
30 - let n = "1"
30 + let n = "__"
31 31  
32 - let o = "__"
32 + let o = ""
33 33  
34 - let p = ""
34 + let p = 1
35 35  
36 - let q = 1
36 + let q = 2
37 37  
38 - let r = 2
38 + let r = 3
39 39  
40 - let s = 3
40 + let s = 4
41 41  
42 - let t = 4
42 + let t = 1
43 43  
44 - let u = 1
44 + let u = 2
45 45  
46 - let v = 2
46 + let v = 3
47 47  
48 - let w = 3
48 + let w = 4
49 49  
50 - let x = 4
50 + let x = 5
51 51  
52 - let y = 5
52 + let y = 6
53 53  
54 - let z = 6
54 + let z = 7
55 55  
56 - let A = 7
56 + let A = 8
57 57  
58 - let B = 8
58 + let B = 9
59 59  
60 - let C = 9
60 + let C = 1
61 61  
62 - let D = 1
62 + let D = 6
63 63  
64 - let E = 6
64 + let E = 7
65 65  
66 - let F = 7
66 + let F = 10
67 67  
68 - let G = 10
68 + let G = fraction(10, a, 10000)
69 69  
70 - let H = fraction(10, a, 10000)
71 - 
72 - func I (J,K) = fraction(toBigInt(J), c, toBigInt(K))
70 + func H (I,J) = fraction(toBigInt(I), c, toBigInt(J))
73 71  
74 72  
75 - func L (J,K) = fraction(J, c, K)
73 + func K (I,J) = fraction(I, c, J)
76 74  
77 75  
78 - func M (N,O) = toInt(fraction(N, toBigInt(O), c))
76 + func L (M,N) = toInt(fraction(M, toBigInt(N), c))
79 77  
80 78  
81 - func P (N,O,Q) = toInt(fraction(N, toBigInt(O), c, Q))
79 + func O (M,N,P) = toInt(fraction(M, toBigInt(N), c, P))
82 80  
83 81  
84 - func R (J,K) = fraction(J, c, toBigInt(K))
82 + func Q (I,J) = fraction(I, c, toBigInt(J))
85 83  
86 84  
87 - func S (N,O) = fraction(N, toBigInt(O), c)
85 + func R (M,N) = fraction(M, toBigInt(N), c)
88 86  
89 87  
90 - func T (U,V,W) = fraction(U, V, W)
88 + func S (T,U,V) = fraction(T, U, V)
91 89  
92 90  
93 - func X (N) = if ((d > N))
94 -     then -(N)
95 -     else N
91 + func W (M) = if ((d > M))
92 +     then -(M)
93 +     else M
96 94  
97 95  
98 - func Y (N) = if ((d > N))
99 -     then -(N)
100 -     else N
96 + func X (M) = if ((d > M))
97 +     then -(M)
98 +     else M
101 99  
102 100  
103 - func Z () = "%s__factoryContract"
101 + func Y () = "%s__factoryContract"
104 102  
105 103  
106 - func aa () = "%s__managerPublicKey"
104 + func Z () = "%s__managerPublicKey"
107 105  
108 106  
109 - func ab () = "%s__pendingManagerPublicKey"
107 + func aa () = "%s__pendingManagerPublicKey"
110 108  
111 109  
112 - func ac () = "%s%s__price__last"
110 + func ab () = "%s%s__price__last"
113 111  
114 112  
115 - func ad (ae,af) = makeString(["%s%s%d%d__price__history", toString(ae), toString(af)], o)
113 + func ac (ad,ae) = makeString(["%s%s%d%d__price__history", toString(ad), toString(ae)], n)
116 114  
117 115  
118 - func ag (ah,ai) = ((("%s%s%s__P__" + ah) + "__") + ai)
116 + func af (ag,ah) = ((("%s%s%s__P__" + ag) + "__") + ah)
119 117  
120 118  
121 - func aj (ah,ai) = ((("%s%s%s__G__" + ah) + "__") + ai)
119 + func ai (ag,ah) = ((("%s%s%s__G__" + ag) + "__") + ah)
122 120  
123 121  
124 - func ak () = "%s__amountAsset"
122 + func aj () = "%s__amountAsset"
125 123  
126 124  
127 - func al () = "%s__priceAsset"
125 + func ak () = "%s__priceAsset"
128 126  
129 127  
130 - func am () = "%s__amp"
128 + func al () = "%s__amp"
131 129  
132 130  
133 - func an () = "%s__addonAddr"
131 + func am () = "%s__addonAddr"
134 132  
135 133  
136 - let ao = "%s__fee"
134 + let an = "%s__fee"
137 135  
138 - let ap = valueOrElse(getInteger(this, ao), H)
136 + let ao = valueOrElse(getInteger(this, an), G)
139 137  
140 - let aq = makeString(["%s", "dLp"], o)
138 + let ap = makeString(["%s", "dLp"], n)
141 139  
142 - let ar = makeString(["%s", "dLpRefreshedHeight"], o)
140 + let aq = makeString(["%s", "dLpRefreshedHeight"], n)
143 141  
144 - let as = makeString(["%s", "refreshDLpDelay"], o)
142 + let ar = makeString(["%s", "refreshDLpDelay"], n)
145 143  
146 - let at = 30
144 + let as = 30
147 145  
148 - let au = valueOrElse(getInteger(this, as), at)
146 + let at = valueOrElse(getInteger(this, ar), as)
149 147  
150 - func av () = "%s__factoryConfig"
148 + func au () = "%s__factoryConfig"
151 149  
152 150  
153 - func aw () = "%s%s__matcher__publicKey"
151 + func av () = "%s%s__matcher__publicKey"
154 152  
155 153  
156 - func ax (ay,az) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
154 + func aw (ax,ay) = (((("%d%d%s__" + ax) + "__") + ay) + "__config")
157 155  
158 156  
159 - func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
157 + func az (aA) = ("%s%s%s__mappings__baseAsset2internalId__" + aA)
160 158  
161 159  
162 - func aC () = "%s__shutdown"
160 + func aB () = "%s__shutdown"
163 161  
164 162  
165 - func aD () = "%s__allowedLpStableScriptHash"
163 + func aC () = "%s__allowedLpStableScriptHash"
166 164  
167 165  
168 - func aE () = "%s__feeCollectorAddress"
166 + func aD () = "%s__feeCollectorAddress"
169 167  
170 168  
171 - func aF (aG,aH,aI,aJ) = throw((((((((("order validation failed: orderValid=" + toString(aG)) + " (") + aH) + ")") + " senderValid=") + toString(aI)) + " matcherValid=") + toString(aJ)))
169 + func aE (aF,aG,aH,aI) = throw((((((((("order validation failed: orderValid=" + toString(aF)) + " (") + aG) + ")") + " senderValid=") + toString(aH)) + " matcherValid=") + toString(aI)))
172 170  
173 171  
174 - func aK (aL,aM) = valueOrErrorMessage(getString(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
172 + func aJ (aK,aL) = valueOrErrorMessage(getString(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
175 173  
176 174  
177 - func aN (aL,aM) = valueOrErrorMessage(getInteger(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
175 + func aM (aK,aL) = valueOrErrorMessage(getInteger(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
178 176  
179 177  
180 - func aO (aP) = throw(makeString(["lp_stable.ride:", aP], " "))
178 + func aN (aO) = throw(makeString(["lp_stable.ride:", aO], " "))
181 179  
182 180  
183 - func aQ (aP) = makeString(["lp_stable.ride:", aP], " ")
181 + func aP (aO) = makeString(["lp_stable.ride:", aO], " ")
184 182  
185 183  
186 - let aR = addressFromStringValue(aK(this, Z()))
184 + let aQ = addressFromStringValue(aJ(this, Y()))
187 185  
188 - let aS = {
189 -     let aT = invoke(aR, "getInFeeREADONLY", [toString(this)], nil)
190 -     if ($isInstanceOf(aT, "Int"))
191 -         then aT
192 -         else throw(($getType(aT) + " couldn't be cast to Int"))
186 + let aR = {
187 +     let aS = invoke(aQ, "getInFeeREADONLY", [toString(this)], nil)
188 +     if ($isInstanceOf(aS, "Int"))
189 +         then aS
190 +         else throw(($getType(aS) + " couldn't be cast to Int"))
193 191      }
194 192  
195 - let aU = {
196 -     let aT = invoke(aR, "getOutFeeREADONLY", [toString(this)], nil)
197 -     if ($isInstanceOf(aT, "Int"))
198 -         then aT
199 -         else throw(($getType(aT) + " couldn't be cast to Int"))
193 + let aT = {
194 +     let aS = invoke(aQ, "getOutFeeREADONLY", [toString(this)], nil)
195 +     if ($isInstanceOf(aS, "Int"))
196 +         then aS
197 +         else throw(($getType(aS) + " couldn't be cast to Int"))
200 198      }
201 199  
202 - let aV = aK(this, am())
200 + let aU = aJ(this, al())
203 201  
204 - func aW () = valueOrElse(getBoolean(aR, aC()), false)
202 + func aV () = valueOrElse(getBoolean(aQ, aB()), false)
205 203  
206 204  
207 - func aX () = fromBase58String(aK(aR, aw()))
205 + func aW () = fromBase58String(aJ(aQ, av()))
208 206  
209 207  
210 - let aY = addressFromStringValue(aK(aR, aE()))
208 + let aX = addressFromStringValue(aJ(aQ, aD()))
211 209  
212 - func aZ () = {
213 -     let ba = aK(this, ak())
214 -     let bb = aK(this, al())
215 -     let bc = aN(aR, aA(bb))
216 -     let ay = aN(aR, aA(ba))
217 -     split(aK(aR, ax(toString(ay), toString(bc))), o)
210 + func aY () = {
211 +     let aZ = aJ(this, aj())
212 +     let ba = aJ(this, ak())
213 +     let bb = aM(aQ, az(ba))
214 +     let ax = aM(aQ, az(aZ))
215 +     split(aJ(aQ, aw(toString(ax), toString(bb))), n)
218 216      }
219 217  
220 218  
221 - func bd (be) = if ((be == k))
219 + func bc (bd) = if ((bd == k))
222 220      then unit
223 -     else fromBase58String(be)
221 +     else fromBase58String(bd)
224 222  
225 223  
226 - func bf (be) = if ((be == unit))
224 + func be (bd) = if ((bd == unit))
227 225      then k
228 -     else toBase58String(value(be))
226 +     else toBase58String(value(bd))
229 227  
230 228  
231 - func bg (bh) = $Tuple9(addressFromStringValue(bh[u]), parseIntValue(bh[v]), fromBase58String(bh[w]), bd(bh[x]), bd(bh[y]), parseIntValue(bh[z]), parseIntValue(bh[A]), fromBase58String(bh[B]), fromBase58String(bh[C]))
229 + func bf (bg) = $Tuple9(addressFromStringValue(bg[t]), parseIntValue(bg[u]), fromBase58String(bg[v]), bc(bg[w]), bc(bg[x]), parseIntValue(bg[y]), parseIntValue(bg[z]), fromBase58String(bg[A]), fromBase58String(bg[B]))
232 230  
233 231  
234 - let bi = bg(aZ())
232 + let bh = bf(aY())
235 233  
236 - let bj = bi
234 + let bi = bh
237 235  
238 - let bk = bj._1
236 + let bj = bi._1
239 237  
240 - let bl = bj._2
238 + let bk = bi._2
241 239  
242 - let bm = bj._3
240 + let bl = bi._3
243 241  
244 - let bn = bj._4
242 + let bm = bi._4
245 243  
246 - let bo = bj._5
244 + let bn = bi._5
247 245  
248 - let bp = bj._6
246 + let bo = bi._6
249 247  
250 - let bq = bj._7
248 + let bp = bi._7
251 249  
252 - let br = bj._8
250 + let bq = bi._8
253 251  
254 - let bs = bj._9
252 + let br = bi._9
255 253  
256 - func bt () = split(aK(aR, av()), o)
254 + func bs () = split(aJ(aQ, au()), n)
257 255  
258 256  
259 - let bu = bt()
257 + let bt = bs()
260 258  
261 - let bv = valueOrErrorMessage(addressFromString(bu[D]), "Invalid staking contract address")
259 + let bu = valueOrErrorMessage(addressFromString(bt[C]), "Invalid staking contract address")
262 260  
263 - let bw = valueOrErrorMessage(addressFromString(bu[F]), "Invalid slipage contract address")
261 + let bv = valueOrErrorMessage(addressFromString(bt[E]), "Invalid slipage contract address")
264 262  
265 - let bx = valueOrErrorMessage(addressFromString(bu[G]), "Invalid gwx contract address")
263 + let bw = valueOrErrorMessage(addressFromString(bt[F]), "Invalid gwx contract address")
266 264  
267 - let by = valueOrErrorMessage(addressFromString(bu[E]), "Invalid gwx contract address")
265 + let bx = valueOrErrorMessage(addressFromString(bt[D]), "Invalid gwx contract address")
268 266  
269 - func bz (bA,bB,bC,bD,bE,bF,bG,bH,bI,bJ) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI), toString(bJ)], o)
267 + func by (bz,bA,bB,bC,bD,bE,bF,bG,bH,bI) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI)], n)
270 268  
271 269  
272 - func bK (bL,bM,bN,bD,bG,bH) = makeString(["%d%d%d%d%d%d", toString(bL), toString(bM), toString(bN), toString(bD), toString(bG), toString(bH)], o)
270 + func bJ (bK,bL,bM,bC,bF,bG) = makeString(["%d%d%d%d%d%d", toString(bK), toString(bL), toString(bM), toString(bC), toString(bF), toString(bG)], n)
273 271  
274 272  
275 - func bO (bP) = if ((bP == "WAVES"))
273 + func bN (bO) = if ((bO == "WAVES"))
276 274      then wavesBalance(this).available
277 -     else assetBalance(this, fromBase58String(bP))
275 +     else assetBalance(this, fromBase58String(bO))
278 276  
279 277  
280 - func bQ (bR,bS) = fraction(bR, c, bS)
278 + func bP (bQ,bR) = fraction(bQ, c, bR)
281 279  
282 280  
283 - func bT (bR,bS,Q) = fraction(bR, c, bS, Q)
281 + func bS (bQ,bR,P) = fraction(bQ, c, bR, P)
284 282  
285 283  
286 - func bU (bV,bW,bX) = {
287 -     let bY = fraction((bV - bW), b, bW)
288 -     let bZ = ((bX - X(bY)) > d)
289 -     if (!(bZ))
290 -         then throw(("Big slpg: " + toString(bY)))
291 -         else $Tuple2(bZ, min([bV, bW]))
284 + func bT (bU,bV,bW) = {
285 +     let bX = fraction((bU - bV), b, bV)
286 +     let bY = ((bW - W(bX)) > d)
287 +     if (!(bY))
288 +         then throw(("Big slpg: " + toString(bX)))
289 +         else $Tuple2(bY, min([bU, bV]))
292 290      }
293 291  
294 292  
295 - func ca (cb,cc,cd) = {
296 -     let bY = fraction(cc, b, cb)
297 -     let ce = (cd > bY)
298 -     if (if (ce)
293 + func bZ (ca,cb,cc) = {
294 +     let bX = fraction(cb, b, ca)
295 +     let cd = (cc > bX)
296 +     if (if (cd)
299 297          then true
300 -         else (cc > cb))
301 -         then throw(((((((toString(cc) + " ") + toString(cb)) + " ") + toString(bY)) + " ") + toString(cd)))
302 -         else ce
298 +         else (cb > ca))
299 +         then throw(((((((toString(cb) + " ") + toString(ca)) + " ") + toString(bX)) + " ") + toString(cc)))
300 +         else cd
303 301      }
304 302  
305 303  
306 - func cf (cg,ch,ci,cj) = {
307 -     let ck = I(ci, cg)
308 -     let cl = I(cj, ch)
309 -     bQ(cl, ck)
304 + func ce (cf,cg,ch,ci) = {
305 +     let cj = H(ch, cf)
306 +     let ck = H(ci, cg)
307 +     bP(ck, cj)
310 308      }
311 309  
312 310  
313 - func cm (ci,cj,cn) = {
311 + func cl (ch,ci,cm) = {
312 +     let cn = bo
314 313      let co = bp
315 -     let cp = bq
316 -     let cq = cf(co, cp, ci, cj)
317 -     let bS = I(ci, co)
318 -     let bR = I(cj, cp)
319 -     let cr = I(cn, a)
320 -     let cs = bQ(bS, cr)
321 -     let ct = bQ(bR, cr)
322 - [cq, cs, ct]
314 +     let cp = ce(cn, co, ch, ci)
315 +     let bR = H(ch, cn)
316 +     let bQ = H(ci, co)
317 +     let cq = H(cm, a)
318 +     let cr = bP(bR, cq)
319 +     let cs = bP(bQ, cq)
320 + [cp, cr, cs]
323 321      }
324 322  
325 323  
326 - func cu (ci,cj,cn) = {
327 -     let cv = cm(ci, cj, cn)
328 - [M(cv[0], a), M(cv[1], a), M(cv[2], a)]
324 + func ct (ch,ci,cm) = {
325 +     let cu = cl(ch, ci, cm)
326 + [L(cu[0], a), L(cu[1], a), L(cu[2], a)]
329 327      }
330 328  
331 329  
332 - func cw (cx,ap) = {
333 -     let cy = if ((ap == 0))
330 + func cv (cw,ao) = {
331 +     let cx = if ((ao == 0))
334 332          then 0
335 -         else fraction(cx, ap, a)
336 -     $Tuple2((cx - cy), cy)
333 +         else fraction(cw, ao, a)
334 +     $Tuple2((cw - cx), cx)
337 335      }
338 336  
339 337  
340 - func cz (cA) = {
341 -     let cB = cA[0]
342 -     let cC = cA[1]
343 -     let cD = (cB + cC)
344 -     if ((cD == e))
338 + func cy (cz) = {
339 +     let cA = cz[0]
340 +     let cB = cz[1]
341 +     let cC = (cA + cB)
342 +     if ((cC == e))
345 343          then e
346 344          else {
347 -             let cE = parseIntValue(aV)
348 -             let cF = (cE * 2)
349 -             let cv = fraction(cB, cC, f)
350 -             let cG = fraction(cv, i, f)
351 -             let cH = fraction(toBigInt(cF), cD, f)
352 -             let cI = toBigInt((cF - 1))
353 -             func cJ (cK) =             {
354 -                 let cL = fraction(cK, cK, f)
355 -                 let cM = fraction(cL, cK, f)
356 -                 let cN = fraction(cM, f, cG)
357 -                 fraction((cH + fraction(cN, g, f)), cK, (fraction(cI, cK, f) + fraction(h, cN, f)))
345 +             let cD = parseIntValue(aU)
346 +             let cE = (cD * 2)
347 +             let cu = fraction(cA, cB, f)
348 +             let cF = fraction(cu, i, f)
349 +             let cG = fraction(toBigInt(cE), cC, f)
350 +             let cH = toBigInt((cE - 1))
351 +             func cI (cJ) =             {
352 +                 let cK = fraction(cJ, cJ, f)
353 +                 let cL = fraction(cK, cJ, f)
354 +                 let cM = fraction(cL, f, cF)
355 +                 fraction((cG + fraction(cM, g, f)), cJ, (fraction(cH, cJ, f) + fraction(h, cM, f)))
358 356                  }
359 357  
360 -             func cO (cP,cQ) =             if (cP._2)
361 -                 then cP
358 +             func cN (cO,cP) =             if (cO._2)
359 +                 then cO
362 360                  else {
363 -                     let cK = cP._1
364 -                     let cR = cJ(cK)
365 -                     let cS = (cR - value(cK))
366 -                     let cT = if ((e > cS))
367 -                         then -(cS)
368 -                         else cS
369 -                     if ((f >= cT))
370 -                         then $Tuple2(cR, true)
371 -                         else $Tuple2(cR, false)
361 +                     let cJ = cO._1
362 +                     let cQ = cI(cJ)
363 +                     let cR = (cQ - value(cJ))
364 +                     let cS = if ((e > cR))
365 +                         then -(cR)
366 +                         else cR
367 +                     if ((f >= cS))
368 +                         then $Tuple2(cQ, true)
369 +                         else $Tuple2(cQ, false)
372 370                      }
373 371  
374 -             let cU = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
375 -             let cV = {
376 -                 let cW = cU
377 -                 let cX = size(cW)
378 -                 let cY = $Tuple2(cD, false)
379 -                 func cZ (da,db) =                 if ((db >= cX))
380 -                     then da
381 -                     else cO(da, cW[db])
372 +             let cT = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
373 +             let cU = {
374 +                 let cV = cT
375 +                 let cW = size(cV)
376 +                 let cX = $Tuple2(cC, false)
377 +                 func cY (cZ,da) =                 if ((da >= cW))
378 +                     then cZ
379 +                     else cN(cZ, cV[da])
382 380  
383 -                 func dc (da,db) =                 if ((db >= cX))
384 -                     then da
381 +                 func db (cZ,da) =                 if ((da >= cW))
382 +                     then cZ
385 383                      else throw("List size exceeds 15")
386 384  
387 -                 dc(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
385 +                 db(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cX, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
388 386                  }
389 -             let cK = cV._1
390 -             let dd = cV._2
391 -             if (dd)
392 -                 then cK
393 -                 else throw(("D calculation error, D = " + toString(cK)))
387 +             let cJ = cU._1
388 +             let dc = cU._2
389 +             if (dc)
390 +                 then cJ
391 +                 else throw(("D calculation error, D = " + toString(cJ)))
394 392              }
395 393      }
396 394  
397 395  
398 - func de (df,dg,dh,di) = {
399 -     let dj = bm
396 + func dd (de,df,dg,dh) = {
397 +     let di = bl
398 +     let dj = toBase58String(value(bm))
400 399      let dk = toBase58String(value(bn))
401 -     let dl = toBase58String(value(bo))
400 +     let dl = bo
402 401      let dm = bp
403 -     let dn = bq
404 -     let do = toString(bl)
405 -     let dp = valueOrErrorMessage(assetInfo(dj), "Wrong LP id").quantity
406 -     if ((toBase58String(dj) != dg))
402 +     let dn = toString(bk)
403 +     let do = valueOrErrorMessage(assetInfo(di), "Wrong LP id").quantity
404 +     if ((toBase58String(di) != df))
407 405          then throw("Wrong pmt asset")
408 406          else {
409 -             let dq = bO(dk)
410 -             let dr = I(dq, dm)
411 -             let ds = bO(dl)
412 -             let dt = I(ds, dn)
413 -             let du = bQ(dt, dr)
414 -             let dv = M(du, a)
415 -             let dw = I(dh, a)
416 -             let dx = I(dp, a)
417 -             let dy = fraction(dr, dw, dx)
418 -             let dz = fraction(dt, dw, dx)
419 -             let dA = P(dy, dm, FLOOR)
420 -             let dB = P(dz, dn, FLOOR)
421 -             let dC = if ((df == ""))
407 +             let dp = bN(dj)
408 +             let dq = H(dp, dl)
409 +             let dr = bN(dk)
410 +             let ds = H(dr, dm)
411 +             let dt = bP(ds, dq)
412 +             let du = L(dt, a)
413 +             let dv = H(dg, a)
414 +             let dw = H(do, a)
415 +             let dx = fraction(dq, dv, dw)
416 +             let dy = fraction(ds, dv, dw)
417 +             let dz = O(dx, dl, FLOOR)
418 +             let dA = O(dy, dm, FLOOR)
419 +             let dB = if ((de == ""))
422 420                  then nil
423 -                 else [ScriptTransfer(di, dA, if ((dk == "WAVES"))
421 +                 else [ScriptTransfer(dh, dz, if ((dj == "WAVES"))
424 422                      then unit
425 -                     else fromBase58String(dk)), ScriptTransfer(di, dB, if ((dl == "WAVES"))
423 +                     else fromBase58String(dj)), ScriptTransfer(dh, dA, if ((dk == "WAVES"))
426 424                      then unit
427 -                     else fromBase58String(dl)), StringEntry(aj(toString(di), df), bK(dA, dB, dh, dv, height, lastBlock.timestamp)), IntegerEntry(ac(), dv), IntegerEntry(ad(height, lastBlock.timestamp), dv)]
428 -             $Tuple10(dA, dB, dk, dl, dq, ds, dp, du, do, dC)
425 +                     else fromBase58String(dk)), StringEntry(ai(toString(dh), de), bJ(dz, dA, dg, du, height, lastBlock.timestamp)), IntegerEntry(ab(), du), IntegerEntry(ac(height, lastBlock.timestamp), du)]
426 +             $Tuple10(dz, dA, dj, dk, dp, dr, do, dt, dn, dB)
429 427              }
430 428      }
431 429  
432 430  
433 - func dD (df,bX,dE,dF,dG,dH,di,dI,dJ,dK,dL,dM,dN) = {
434 -     let dj = bm
431 + func dC (de,bW,dD,dE,dF,dG,dh,dH,dI,dJ,dK,dL,dM) = {
432 +     let di = bl
433 +     let dN = toBase58String(value(bm))
435 434      let dO = toBase58String(value(bn))
436 -     let dP = toBase58String(value(bo))
435 +     let dP = bq
437 436      let dQ = br
438 -     let dR = bs
437 +     let dR = bo
439 438      let dS = bp
440 -     let dT = bq
441 -     let do = toString(bl)
442 -     let dU = valueOrErrorMessage(assetInfo(dj), "Wr lp as").quantity
443 -     let dq = if (dI)
444 -         then bO(dO)
445 -         else if (if (dK)
446 -             then (dN == dO)
439 +     let dn = toString(bk)
440 +     let dT = valueOrErrorMessage(assetInfo(di), "Wr lp as").quantity
441 +     let dp = if (dH)
442 +         then bN(dN)
443 +         else if (if (dJ)
444 +             then (dM == dN)
447 445              else false)
448 -             then (bO(dO) - dM)
449 -             else if (dK)
450 -                 then bO(dO)
451 -                 else (bO(dO) - dE)
452 -     let ds = if (dI)
453 -         then bO(dP)
454 -         else if (if (dK)
455 -             then (dN == dP)
446 +             then (bN(dN) - dL)
447 +             else if (dJ)
448 +                 then bN(dN)
449 +                 else (bN(dN) - dD)
450 +     let dr = if (dH)
451 +         then bN(dO)
452 +         else if (if (dJ)
453 +             then (dM == dO)
456 454              else false)
457 -             then (bO(dP) - dM)
458 -             else if (dK)
459 -                 then bO(dP)
460 -                 else (bO(dP) - dG)
461 -     let dV = I(dE, dS)
462 -     let dW = I(dG, dT)
463 -     let dX = bQ(dW, dV)
464 -     let dr = I(dq, dS)
465 -     let dt = I(ds, dT)
466 -     let cc = cz([dr, dt])
467 -     let dY = if ((dU == 0))
455 +             then (bN(dO) - dL)
456 +             else if (dJ)
457 +                 then bN(dO)
458 +                 else (bN(dO) - dF)
459 +     let dU = H(dD, dR)
460 +     let dV = H(dF, dS)
461 +     let dW = bP(dV, dU)
462 +     let dq = H(dp, dR)
463 +     let ds = H(dr, dS)
464 +     let cb = cy([dq, ds])
465 +     let dX = if ((dT == 0))
468 466          then {
469 -             let cb = cz([(dr + dV), (dt + dW)])
470 -             let dZ = if ((cb > cc))
467 +             let ca = cy([(dq + dU), (ds + dV)])
468 +             let dY = if ((ca > cb))
471 469                  then true
472 470                  else throw("D1 should be greater than D0")
473 -             if ((dZ == dZ))
471 +             if ((dY == dY))
474 472                  then {
475 -                     let du = d
476 -                     let ea = d
477 -                     let cr = cb
478 -                     $Tuple5(M(cr, a), M(dV, dS), M(dW, dT), bQ((dt + dW), (dr + dV)), ea)
473 +                     let dt = d
474 +                     let dZ = d
475 +                     let cq = ca
476 +                     $Tuple5(L(cq, a), L(dU, dR), L(dV, dS), bP((ds + dV), (dq + dU)), dZ)
479 477                      }
480 478                  else throw("Strict value is not equal to itself.")
481 479              }
482 480          else {
483 -             let du = bQ(dt, dr)
484 -             let eb = fraction(X((du - dX)), c, du)
485 -             let ea = I(bX, a)
486 -             if (if (if (dL)
487 -                 then (du != d)
481 +             let dt = bP(ds, dq)
482 +             let ea = fraction(W((dt - dW)), c, dt)
483 +             let dZ = H(bW, a)
484 +             if (if (if (dK)
485 +                 then (dt != d)
488 486                  else false)
489 -                 then (eb > ea)
487 +                 then (ea > dZ)
490 488                  else false)
491 -                 then throw(((("Price slippage " + toString(eb)) + " > ") + toString(ea)))
489 +                 then throw(((("Price slippage " + toString(ea)) + " > ") + toString(dZ)))
492 490                  else {
493 -                     let ec = I(dU, a)
494 -                     let ed = fraction(dV, bT(dt, dr, CEILING), c, CEILING)
495 -                     let ee = fraction(dW, c, bT(dt, dr, FLOOR), CEILING)
496 -                     let ef = if ((ed > dW))
497 -                         then $Tuple2(ee, dW)
498 -                         else $Tuple2(dV, ed)
499 -                     let eg = ef._1
500 -                     let eh = ef._2
501 -                     let cb = cz([(dr + eg), (dt + eh)])
502 -                     let dZ = if ((cb > cc))
491 +                     let eb = H(dT, a)
492 +                     let ec = fraction(dU, bS(ds, dq, CEILING), c, CEILING)
493 +                     let ed = fraction(dV, c, bS(ds, dq, FLOOR), CEILING)
494 +                     let ee = if ((ec > dV))
495 +                         then $Tuple2(ed, dV)
496 +                         else $Tuple2(dU, ec)
497 +                     let ef = ee._1
498 +                     let eg = ee._2
499 +                     let ca = cy([(dq + ef), (ds + eg)])
500 +                     let dY = if ((ca > cb))
503 501                          then true
504 502                          else throw("D1 should be greater than D0")
505 -                     if ((dZ == dZ))
503 +                     if ((dY == dY))
506 504                          then {
507 -                             let cr = fraction(ec, (cb - cc), cc)
508 -                             $Tuple5(P(cr, a, FLOOR), P(eg, dS, CEILING), P(eh, dT, CEILING), du, ea)
505 +                             let cq = fraction(eb, (ca - cb), cb)
506 +                             $Tuple5(O(cq, a, FLOOR), O(ef, dR, CEILING), O(eg, dS, CEILING), dt, dZ)
509 507                              }
510 508                          else throw("Strict value is not equal to itself.")
511 509                      }
512 510              }
513 -     let ei = dY._1
514 -     let ej = dY._2
515 -     let ek = dY._3
516 -     let dv = M(dY._4, a)
517 -     let el = M(dY._5, a)
518 -     if ((0 >= ei))
511 +     let eh = dX._1
512 +     let ei = dX._2
513 +     let ej = dX._3
514 +     let du = L(dX._4, a)
515 +     let ek = L(dX._5, a)
516 +     if ((0 >= eh))
519 517          then throw("LP <= 0")
520 518          else {
521 -             let em = if (!(dJ))
519 +             let el = if (!(dI))
522 520                  then 0
523 -                 else ei
524 -             let en = (dE - ej)
525 -             let eo = (dG - ek)
526 -             let ep = if (if (dK)
527 -                 then (dN == dO)
521 +                 else eh
522 +             let em = (dD - ei)
523 +             let en = (dF - ej)
524 +             let eo = if (if (dJ)
525 +                 then (dM == dN)
528 526                  else false)
529 -                 then $Tuple2(dM, 0)
530 -                 else if (if (dK)
531 -                     then (dN == dP)
527 +                 then $Tuple2(dL, 0)
528 +                 else if (if (dJ)
529 +                     then (dM == dO)
532 530                      else false)
533 -                     then $Tuple2(0, dM)
534 -                     else $Tuple2(ej, ek)
535 -             let eq = ep._1
536 -             let er = ep._2
537 -             let es = [IntegerEntry(ac(), dv), IntegerEntry(ad(height, lastBlock.timestamp), dv), StringEntry(ag(di, df), bz(eq, er, em, dv, bX, el, height, lastBlock.timestamp, en, eo))]
538 -             $Tuple13(ei, em, dv, dq, ds, dU, dj, do, es, en, eo, dF, dH)
531 +                     then $Tuple2(0, dL)
532 +                     else $Tuple2(ei, ej)
533 +             let ep = eo._1
534 +             let eq = eo._2
535 +             let er = [IntegerEntry(ab(), du), IntegerEntry(ac(height, lastBlock.timestamp), du), StringEntry(af(dh, de), by(ep, eq, el, du, bW, ek, height, lastBlock.timestamp, em, en))]
536 +             $Tuple13(eh, el, du, dp, dr, dT, di, dn, er, em, en, dE, dG)
539 537              }
540 538      }
541 539  
542 540  
543 - func et (cA,cQ,eu) = {
544 -     let ev = g
545 -     let ew = cA[if ((cQ == 0))
541 + func es (cz,cP,et) = {
542 +     let eu = g
543 +     let ev = cz[if ((cP == 0))
546 544          then 1
547 545          else 0]
548 -     let ex = parseBigIntValue(m)
549 -     let cE = (parseBigIntValue(aV) * ex)
550 -     let cD = ew
551 -     let cF = (cE * ev)
552 -     let ey = (((((eu * eu) / (ew * ev)) * eu) * ex) / (cF * ev))
553 -     let ez = ((cD + ((eu * ex) / cF)) - eu)
554 -     func cO (cP,eA) =     {
555 -         let eB = cP
556 -         let eC = eB._1
557 -         let dd = eB._2
558 -         if ((dd != unit))
559 -             then cP
546 +     let ew = parseBigIntValue(l)
547 +     let cD = (parseBigIntValue(aU) * ew)
548 +     let cC = ev
549 +     let cE = (cD * eu)
550 +     let ex = (((((et * et) / (ev * eu)) * et) * ew) / (cE * eu))
551 +     let ey = ((cC + ((et * ew) / cE)) - et)
552 +     func cN (cO,ez) =     {
553 +         let eA = cO
554 +         let eB = eA._1
555 +         let dc = eA._2
556 +         if ((dc != unit))
557 +             then cO
560 558              else {
561 -                 let eD = (((eC * eC) + ey) / ((g * eC) + ez))
562 -                 let eE = Y((eD - value(eC)))
563 -                 if ((f >= eE))
564 -                     then $Tuple2(eD, eA)
565 -                     else $Tuple2(eD, unit)
559 +                 let eC = (((eB * eB) + ex) / ((g * eB) + ey))
560 +                 let eD = X((eC - value(eB)))
561 +                 if ((f >= eD))
562 +                     then $Tuple2(eC, ez)
563 +                     else $Tuple2(eC, unit)
566 564                  }
567 565          }
568 566  
569 -     let cU = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
570 -     let eF = {
571 -         let cW = cU
572 -         let cX = size(cW)
573 -         let cY = $Tuple2(eu, unit)
574 -         func cZ (da,db) =         if ((db >= cX))
575 -             then da
576 -             else cO(da, cW[db])
567 +     let cT = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
568 +     let eE = {
569 +         let cV = cT
570 +         let cW = size(cV)
571 +         let cX = $Tuple2(et, unit)
572 +         func cY (cZ,da) =         if ((da >= cW))
573 +             then cZ
574 +             else cN(cZ, cV[da])
577 575  
578 -         func dc (da,db) =         if ((db >= cX))
579 -             then da
576 +         func db (cZ,da) =         if ((da >= cW))
577 +             then cZ
580 578              else throw("List size exceeds 15")
581 579  
582 -         dc(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
580 +         db(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cX, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
583 581          }
584 -     let eC = eF._1
585 -     let dd = eF._2
586 -     if ((dd != unit))
587 -         then eC
588 -         else throw(("Y calculation error, Y = " + toString(eC)))
582 +     let eB = eE._1
583 +     let dc = eE._2
584 +     if ((dc != unit))
585 +         then eB
586 +         else throw(("Y calculation error, Y = " + toString(eB)))
589 587      }
590 588  
591 589  
592 - func eG (eH,eI,eJ) = {
593 -     let eK = fraction(cz([L(eH, toBigInt(bp)), L(eI, toBigInt(bq))]), c, eJ)
594 -     if ((eJ == e))
590 + func eF (eG,eH,eI) = {
591 +     let eJ = fraction(cy([K(eG, toBigInt(bo)), K(eH, toBigInt(bp))]), c, eI)
592 +     if ((eI == e))
595 593          then e
596 -         else eK
594 +         else eJ
597 595      }
598 596  
599 597  
600 - func eL (eM,eN,eO) = {
601 -     let eP = (toBigInt(bO(bf(bn))) - eM)
602 -     let eQ = (toBigInt(bO(bf(bo))) - eN)
603 -     let eR = (toBigInt(value(assetInfo(bm)).quantity) - eO)
604 -     let eS = eG(eP, eQ, eR)
605 -     eS
598 + func eK (eL,eM,eN) = {
599 +     let eO = (toBigInt(bN(be(bm))) - eL)
600 +     let eP = (toBigInt(bN(be(bn))) - eM)
601 +     let eQ = (toBigInt(value(assetInfo(bl)).quantity) - eN)
602 +     let eR = eF(eO, eP, eQ)
603 +     eR
606 604      }
607 605  
608 606  
609 - func eT (eU,eV,eO) = {
610 -     let eP = (bO(bf(bn)) + eU)
611 -     let eQ = (bO(bf(bo)) + eV)
612 -     let eR = (value(assetInfo(bm)).quantity + eO)
613 -     let eK = eG(toBigInt(eP), toBigInt(eQ), toBigInt(eR))
614 -     let eW = [IntegerEntry(ar, height), StringEntry(aq, toString(eK))]
615 -     $Tuple2(eW, eK)
607 + func eS (eT,eU,eN) = {
608 +     let eO = (bN(be(bm)) + eT)
609 +     let eP = (bN(be(bn)) + eU)
610 +     let eQ = (value(assetInfo(bl)).quantity + eN)
611 +     let eJ = eF(toBigInt(eO), toBigInt(eP), toBigInt(eQ))
612 +     let eV = [IntegerEntry(aq, height), StringEntry(ap, toString(eJ))]
613 +     $Tuple2(eV, eJ)
616 614      }
617 615  
618 616  
619 - func eX (eY,eK) = if ((eK >= eY))
617 + func eW (eX,eJ) = if ((eJ >= eX))
620 618      then true
621 -     else aO("updated DLp lower than current DLp")
619 +     else aN("updated DLp lower than current DLp")
622 620  
623 621  
624 - func eZ (fa) = {
625 -     let eP = bO(bf(bn))
626 -     let eQ = bO(bf(bo))
627 -     let fb = fa.amount
628 -     let fc = fraction(fa.amount, fa.price, a, FLOOR)
629 -     let fd = if ((fa.orderType == Buy))
630 -         then $Tuple2(fb, -(fc))
631 -         else $Tuple2(-(fb), fc)
632 -     let eU = fd._1
633 -     let eV = fd._2
634 -     if (if (if (aW())
622 + func eY (eZ) = {
623 +     let eO = bN(be(bm))
624 +     let eP = bN(be(bn))
625 +     let fa = eZ.amount
626 +     let fb = fraction(eZ.amount, eZ.price, a, FLOOR)
627 +     let fc = if ((eZ.orderType == Buy))
628 +         then $Tuple2(fa, -(fb))
629 +         else $Tuple2(-(fa), fb)
630 +     let eT = fc._1
631 +     let eU = fc._2
632 +     if (if (if (aV())
635 633          then true
636 -         else (bl == s))
634 +         else (bk == r))
637 635          then true
638 -         else (bl == t))
636 +         else (bk == s))
639 637          then throw("Admin blocked")
640 -         else if (if ((fa.assetPair.amountAsset != bn))
638 +         else if (if ((eZ.assetPair.amountAsset != bm))
641 639              then true
642 -             else (fa.assetPair.priceAsset != bo))
640 +             else (eZ.assetPair.priceAsset != bn))
643 641              then throw("Wr assets")
644 642              else {
645 -                 let fe = parseBigIntValue(valueOrElse(getString(this, aq), "0"))
646 -                 let ff = eT(eU, eV, 0)
647 -                 let fg = ff._1
648 -                 let fh = ff._2
649 -                 let fi = (fh >= fe)
650 -                 let fj = makeString(["dLp=", toString(fe), " dLpNew=", toString(fh), " amountAssetBalance=", toString(eP), " priceAssetBalance=", toString(eQ), " amountAssetBalanceDelta=", toString(eU), " priceAssetBalanceDelta=", toString(eV), " height=", toString(height)], "")
651 -                 $Tuple2(fi, fj)
643 +                 let fd = parseBigIntValue(valueOrElse(getString(this, ap), "0"))
644 +                 let fe = eS(eT, eU, 0)
645 +                 let ff = fe._1
646 +                 let fg = fe._2
647 +                 let fh = (fg >= fd)
648 +                 let fi = makeString(["dLp=", toString(fd), " dLpNew=", toString(fg), " amountAssetBalance=", toString(eO), " priceAssetBalance=", toString(eP), " amountAssetBalanceDelta=", toString(eT), " priceAssetBalanceDelta=", toString(eU), " height=", toString(height)], "")
649 +                 $Tuple2(fh, fi)
652 650                  }
653 651      }
654 652  
655 653  
656 - func fk (cQ) = if ((size(cQ.payments) != 1))
654 + func fj (cP) = if ((size(cP.payments) != 1))
657 655      then throw("1 pmnt exp")
658 656      else {
659 -         let fl = value(cQ.payments[0])
660 -         let dg = value(fl.assetId)
661 -         let dM = fl.amount
662 -         let dY = de(toBase58String(cQ.transactionId), toBase58String(dg), dM, cQ.caller)
663 -         let dA = dY._1
664 -         let dB = dY._2
665 -         let do = parseIntValue(dY._9)
666 -         let dC = dY._10
667 -         if (if (aW())
657 +         let fk = value(cP.payments[0])
658 +         let df = value(fk.assetId)
659 +         let dL = fk.amount
660 +         let dX = dd(toBase58String(cP.transactionId), toBase58String(df), dL, cP.caller)
661 +         let dz = dX._1
662 +         let dA = dX._2
663 +         let dn = parseIntValue(dX._9)
664 +         let dB = dX._10
665 +         if (if (aV())
668 666              then true
669 -             else (do == t))
670 -             then throw(("Admin blocked: " + toString(do)))
671 -             else $Tuple5(dA, dB, dM, dg, dC)
667 +             else (dn == s))
668 +             then throw(("Admin blocked: " + toString(dn)))
669 +             else $Tuple5(dz, dA, dL, df, dB)
672 670          }
673 671  
674 672  
675 - func fm (fn,ai,fo,fp,bX,dJ,dK,dL,dM,dN) = {
676 -     let dY = dD(ai, bX, value(fo).amount, value(fo).assetId, value(fp).amount, value(fp).assetId, fn, (ai == ""), dJ, dK, dL, dM, dN)
677 -     let do = parseIntValue(dY._8)
678 -     if (if (if (aW())
673 + func fl (fm,ah,fn,fo,bW,dI,dJ,dK,dL,dM) = {
674 +     let dX = dC(ah, bW, value(fn).amount, value(fn).assetId, value(fo).amount, value(fo).assetId, fm, (ah == ""), dI, dJ, dK, dL, dM)
675 +     let dn = parseIntValue(dX._8)
676 +     if (if (if (aV())
679 677          then true
680 -         else (do == r))
678 +         else (dn == q))
681 679          then true
682 -         else (do == t))
683 -         then throw(("Blocked:" + toString(do)))
684 -         else dY
680 +         else (dn == s))
681 +         then throw(("Blocked:" + toString(dn)))
682 +         else dX
685 683      }
686 684  
687 685  
688 - func fq (fr,dg,di,ai,fs) = {
686 + func fp (fq,df,dh,ah,fr) = {
687 +     let dj = toBase58String(value(bm))
689 688      let dk = toBase58String(value(bn))
690 -     let dl = toBase58String(value(bo))
691 -     let dj = bm
689 +     let di = bl
690 +     let dR = bo
692 691      let dS = bp
693 -     let dT = bq
694 -     let eR = toBigInt(valueOrErrorMessage(assetInfo(dj), "invalid lp asset").quantity)
695 -     let ft = if ((eR > e))
692 +     let eQ = toBigInt(valueOrErrorMessage(assetInfo(di), "invalid lp asset").quantity)
693 +     let fs = if ((eQ > e))
696 694          then true
697 695          else throw("initial deposit requires all coins")
698 -     if ((ft == ft))
696 +     if ((fs == fs))
699 697          then {
700 -             let dq = bO(dk)
701 -             let ds = bO(dl)
702 -             let fu = if ((ai == ""))
703 -                 then $Tuple2(dq, ds)
704 -                 else if ((dg == dk))
705 -                     then if ((fr > dq))
698 +             let dp = bN(dj)
699 +             let dr = bN(dk)
700 +             let ft = if ((ah == ""))
701 +                 then $Tuple2(dp, dr)
702 +                 else if ((df == dj))
703 +                     then if ((fq > dp))
706 704                          then throw("invalid payment amount")
707 -                         else $Tuple2((dq - fr), ds)
708 -                     else if ((dg == dl))
709 -                         then if ((fr > ds))
705 +                         else $Tuple2((dp - fq), dr)
706 +                     else if ((df == dk))
707 +                         then if ((fq > dr))
710 708                              then throw("invalid payment amount")
711 -                             else $Tuple2(dq, (ds - fr))
709 +                             else $Tuple2(dp, (dr - fq))
712 710                          else throw("wrong pmtAssetId")
713 -             let fv = fu._1
714 -             let fw = fu._2
715 -             let fx = if ((dg == dk))
716 -                 then $Tuple2(fr, 0)
717 -                 else if ((dg == dl))
718 -                     then $Tuple2(0, fr)
711 +             let fu = ft._1
712 +             let fv = ft._2
713 +             let fw = if ((df == dj))
714 +                 then $Tuple2(fq, 0)
715 +                 else if ((df == dk))
716 +                     then $Tuple2(0, fq)
719 717                      else throw("invalid payment")
720 -             let fy = fx._1
721 -             let fz = fx._2
722 -             let fA = if (fs)
723 -                 then $Tuple3(cw(fy, aS)._1, cw(fz, aS)._1, cw(fr, aS)._2)
724 -                 else $Tuple3(fy, fz, 0)
725 -             let fB = fA._1
726 -             let fC = fA._2
727 -             let cy = fA._3
718 +             let fx = fw._1
719 +             let fy = fw._2
720 +             let fz = if (fr)
721 +                 then $Tuple3(cv(fx, aR)._1, cv(fy, aR)._1, cv(fq, aR)._2)
722 +                 else $Tuple3(fx, fy, 0)
723 +             let fA = fz._1
724 +             let fB = fz._2
725 +             let cx = fz._3
726 +             let fC = (fu + fA)
728 727              let fD = (fv + fB)
729 -             let fE = (fw + fC)
730 -             let cc = cz([I(fv, bp), I(fw, bq)])
731 -             let cb = cz([I(fD, bp), I(fE, bq)])
732 -             let dZ = if ((cb > cc))
728 +             let cb = cy([H(fu, bo), H(fv, bp)])
729 +             let ca = cy([H(fC, bo), H(fD, bp)])
730 +             let dY = if ((ca > cb))
733 731                  then true
734 732                  else throw()
735 -             if ((dZ == dZ))
733 +             if ((dY == dY))
736 734                  then {
737 -                     let fF = fraction(eR, (cb - cc), cc, FLOOR)
738 -                     let dv = M(bQ(I(fE, dT), I(fD, dS)), a)
739 -                     let es = [IntegerEntry(ac(), dv), IntegerEntry(ad(height, lastBlock.timestamp), dv), StringEntry(ag(di, ai), bz(fy, fz, toInt(fF), dv, 0, 0, height, lastBlock.timestamp, 0, 0))]
740 -                     let fG = fraction(fw, a, fv)
741 -                     let fH = fraction(fr, a, (fG + a))
742 -                     let fI = (fr - fH)
743 -                     let fJ = fraction(eR, toBigInt(fI), toBigInt(fw))
744 -                     let fK = toInt(fraction((fF - fJ), b, fJ))
745 -                     $Tuple4(toInt(fF), es, cy, fK)
735 +                     let fE = fraction(eQ, (ca - cb), cb, FLOOR)
736 +                     let du = L(bP(H(fD, dS), H(fC, dR)), a)
737 +                     let er = [IntegerEntry(ab(), du), IntegerEntry(ac(height, lastBlock.timestamp), du), StringEntry(af(dh, ah), by(fx, fy, toInt(fE), du, 0, 0, height, lastBlock.timestamp, 0, 0))]
738 +                     let fF = fraction(fv, a, fu)
739 +                     let fG = fraction(fq, a, (fF + a))
740 +                     let fH = (fq - fG)
741 +                     let fI = fraction(eQ, toBigInt(fH), toBigInt(fv))
742 +                     let fJ = toInt(fraction((fE - fI), b, fI))
743 +                     $Tuple4(toInt(fE), er, cx, fJ)
746 744                      }
747 745                  else throw("Strict value is not equal to itself.")
748 746              }
750 748      }
751 749  
752 750  
753 - func fL (fM,fN,fO,fn,fP,fQ) = {
751 + func fK (fL,fM,fN,fm,fO,fP) = {
752 +     let di = toBase58String(value(bl))
754 753      let dj = toBase58String(value(bm))
755 754      let dk = toBase58String(value(bn))
756 -     let dl = toBase58String(value(bo))
755 +     let fQ = bo
757 756      let fR = bp
758 -     let fS = bq
759 -     let fT = bl
760 -     let di = if ((fn == by))
761 -         then fP
762 -         else fn
763 -     let fl = value(fO[0])
764 -     let dg = value(fl.assetId)
765 -     let dM = fl.amount
766 -     let eS = eL(e, e, e)
767 -     if ((eS == eS))
757 +     let fS = bk
758 +     let dh = if ((fm == bx))
759 +         then fO
760 +         else fm
761 +     let fk = value(fN[0])
762 +     let df = value(fk.assetId)
763 +     let dL = fk.amount
764 +     let eR = eK(e, e, e)
765 +     if ((eR == eR))
768 766          then {
769 -             let df = toBase58String(fQ)
770 -             if ((dj != toBase58String(dg)))
767 +             let de = toBase58String(fP)
768 +             if ((di != toBase58String(df)))
771 769                  then throw("Wrong LP")
772 770                  else {
773 -                     let dq = bO(dk)
774 -                     let ds = bO(dl)
775 -                     let fU = {
776 -                         let aT = invoke(this, "getOneTknV2READONLY", [fM, dM], nil)
777 -                         if ($isInstanceOf(aT, "(Int, Int)"))
778 -                             then aT
779 -                             else throw(($getType(aT) + " couldn't be cast to (Int, Int)"))
771 +                     let dp = bN(dj)
772 +                     let dr = bN(dk)
773 +                     let fT = {
774 +                         let aS = invoke(this, "getOneTknV2READONLY", [fL, dL], nil)
775 +                         if ($isInstanceOf(aS, "(Int, Int)"))
776 +                             then aS
777 +                             else throw(($getType(aS) + " couldn't be cast to (Int, Int)"))
780 778                          }
781 -                     if ((fU == fU))
779 +                     if ((fT == fT))
782 780                          then {
783 -                             let cy = fU._2
784 -                             let fV = fU._1
785 -                             let fW = if (if ((fN > 0))
786 -                                 then (fN > fV)
781 +                             let cx = fT._2
782 +                             let fU = fT._1
783 +                             let fV = if (if ((fM > 0))
784 +                                 then (fM > fU)
787 785                                  else false)
788 -                                 then aO(makeString(["amount to receive is less than ", toString(fN)], ""))
789 -                                 else fV
790 -                             let fX = if ((fM == dk))
791 -                                 then $Tuple4(fW, 0, ((dq - fW) - cy), ds)
792 -                                 else if ((fM == dl))
793 -                                     then $Tuple4(0, fW, dq, ((ds - fW) - cy))
786 +                                 then aN(makeString(["amount to receive is less than ", toString(fM)], ""))
787 +                                 else fU
788 +                             let fW = if ((fL == dj))
789 +                                 then $Tuple4(fV, 0, ((dp - fV) - cx), dr)
790 +                                 else if ((fL == dk))
791 +                                     then $Tuple4(0, fV, dp, ((dr - fV) - cx))
794 792                                      else throw("invalid out asset id")
795 -                             let fY = fX._1
796 -                             let fZ = fX._2
797 -                             let fD = fX._3
798 -                             let fE = fX._4
799 -                             let ga = bQ(I(fE, fS), I(fD, fR))
800 -                             let gb = M(ga, a)
801 -                             let gc = if ((fM == "WAVES"))
793 +                             let fX = fW._1
794 +                             let fY = fW._2
795 +                             let fC = fW._3
796 +                             let fD = fW._4
797 +                             let fZ = bP(H(fD, fR), H(fC, fQ))
798 +                             let ga = L(fZ, a)
799 +                             let gb = if ((fL == "WAVES"))
802 800                                  then unit
803 -                                 else fromBase58String(fM)
804 -                             let gd = if ((cy > 0))
805 -                                 then [ScriptTransfer(aY, cy, gc)]
801 +                                 else fromBase58String(fL)
802 +                             let gc = if ((cx > 0))
803 +                                 then [ScriptTransfer(aX, cx, gb)]
806 804                                  else nil
807 -                             let dC = ([ScriptTransfer(di, fW, gc), StringEntry(aj(toString(di), df), bK(fY, fZ, dM, gb, height, lastBlock.timestamp)), IntegerEntry(ac(), gb), IntegerEntry(ad(height, lastBlock.timestamp), gb)] ++ gd)
808 -                             if ((dC == dC))
805 +                             let dB = ([ScriptTransfer(dh, fV, gb), StringEntry(ai(toString(dh), de), bJ(fX, fY, dL, ga, height, lastBlock.timestamp)), IntegerEntry(ab(), ga), IntegerEntry(ac(height, lastBlock.timestamp), ga)] ++ gc)
806 +                             if ((dB == dB))
809 807                                  then {
810 -                                     let ge = invoke(aR, "burn", [dM], [AttachedPayment(dg, dM)])
811 -                                     if ((ge == ge))
808 +                                     let gd = invoke(aQ, "burn", [dL], [AttachedPayment(df, dL)])
809 +                                     if ((gd == gd))
812 810                                          then {
813 -                                             let gf = {
814 -                                                 let gg = if ((this == aY))
811 +                                             let ge = {
812 +                                                 let gf = if ((this == aX))
815 813                                                      then 0
816 -                                                     else cy
817 -                                                 let gh = if ((bd(fM) == bn))
814 +                                                     else cx
815 +                                                 let gg = if ((bc(fL) == bm))
818 816                                                      then true
819 817                                                      else false
820 -                                                 if (gh)
821 -                                                     then $Tuple2(-((fV + gg)), 0)
822 -                                                     else $Tuple2(0, -((fV + gg)))
818 +                                                 if (gg)
819 +                                                     then $Tuple2(-((fU + gf)), 0)
820 +                                                     else $Tuple2(0, -((fU + gf)))
823 821                                                  }
824 -                                             let eU = gf._1
825 -                                             let eV = gf._2
826 -                                             let gi = eT(eU, eV, 0)
827 -                                             let gj = gi._1
828 -                                             let eK = gi._2
829 -                                             let gk = eX(eS, eK)
830 -                                             if ((gk == gk))
831 -                                                 then $Tuple2((dC ++ gj), fW)
822 +                                             let eT = ge._1
823 +                                             let eU = ge._2
824 +                                             let gh = eS(eT, eU, 0)
825 +                                             let gi = gh._1
826 +                                             let eJ = gh._2
827 +                                             let gj = eW(eR, eJ)
828 +                                             if ((gj == gj))
829 +                                                 then $Tuple2((dB ++ gi), fV)
832 830                                                  else throw("Strict value is not equal to itself.")
833 831                                              }
834 832                                          else throw("Strict value is not equal to itself.")
842 840      }
843 841  
844 842  
845 - func gl () = {
846 -     let gm = getString(aa())
847 -     if ($isInstanceOf(gm, "String"))
843 + func gk () = {
844 +     let gl = getString(Z())
845 +     if ($isInstanceOf(gl, "String"))
848 846          then {
849 -             let cD = gm
850 -             fromBase58String(cD)
847 +             let cC = gl
848 +             fromBase58String(cC)
851 849              }
852 -         else if ($isInstanceOf(gm, "Unit"))
850 +         else if ($isInstanceOf(gl, "Unit"))
853 851              then unit
854 852              else throw("Match error")
855 853      }
856 854  
857 855  
858 - func gn () = {
859 -     let gm = getString(ab())
860 -     if ($isInstanceOf(gm, "String"))
856 + func gm () = {
857 +     let gl = getString(aa())
858 +     if ($isInstanceOf(gl, "String"))
861 859          then {
862 -             let cD = gm
863 -             fromBase58String(cD)
860 +             let cC = gl
861 +             fromBase58String(cC)
864 862              }
865 -         else if ($isInstanceOf(gm, "Unit"))
863 +         else if ($isInstanceOf(gl, "Unit"))
866 864              then unit
867 865              else throw("Match error")
868 866      }
869 867  
870 868  
871 - let go = throw("Permission denied")
869 + let gn = throw("Permission denied")
872 870  
873 - func gp (cQ) = {
874 -     let gm = gl()
875 -     if ($isInstanceOf(gm, "ByteVector"))
871 + func go (cP) = {
872 +     let gl = gk()
873 +     if ($isInstanceOf(gl, "ByteVector"))
876 874          then {
877 -             let gq = gm
878 -             (cQ.callerPublicKey == gq)
875 +             let gp = gl
876 +             (cP.callerPublicKey == gp)
879 877              }
880 -         else if ($isInstanceOf(gm, "Unit"))
881 -             then (cQ.caller == this)
878 +         else if ($isInstanceOf(gl, "Unit"))
879 +             then (cP.caller == this)
882 880              else throw("Match error")
883 881      }
884 882  
885 883  
886 - func gr (cQ) = {
887 -     let gm = gl()
888 -     if ($isInstanceOf(gm, "ByteVector"))
884 + func gq (cP) = {
885 +     let gl = gk()
886 +     if ($isInstanceOf(gl, "ByteVector"))
889 887          then {
890 -             let gq = gm
891 -             if ((cQ.callerPublicKey == gq))
888 +             let gp = gl
889 +             if ((cP.callerPublicKey == gp))
892 890                  then true
893 -                 else go
891 +                 else gn
894 892              }
895 -         else if ($isInstanceOf(gm, "Unit"))
896 -             then if ((cQ.caller == this))
893 +         else if ($isInstanceOf(gl, "Unit"))
894 +             then if ((cP.caller == this))
897 895                  then true
898 -                 else go
896 +                 else gn
899 897              else throw("Match error")
900 898      }
901 899  
902 900  
903 - func gs (gt,eu,gu) = {
904 -     let bh = aZ()
905 -     let dk = bh[x]
906 -     let dl = bh[y]
907 -     let ev = g
908 -     let ex = parseBigIntValue(m)
909 -     let cE = (parseBigIntValue(aV) * ex)
910 -     let cA = if ((gt == false))
911 -         then [(toBigInt(bO(dk)) + gu), toBigInt(bO(dl))]
912 -         else [(toBigInt(bO(dl)) + gu), toBigInt(bO(dk))]
913 -     let ew = cA[0]
914 -     let cD = ew
915 -     let cF = (cE * ev)
916 -     let ey = (((((eu * eu) / (ew * ev)) * eu) * ex) / (cF * ev))
917 -     let ez = ((cD + ((eu * ex) / cF)) - eu)
918 -     func cO (cP,eA) =     {
919 -         let gv = cP
920 -         let eC = gv._1
921 -         let dd = gv._2
922 -         if ((dd != unit))
923 -             then cP
901 + func gr (gs,et,gt) = {
902 +     let bg = aY()
903 +     let dj = bg[w]
904 +     let dk = bg[x]
905 +     let eu = g
906 +     let ew = parseBigIntValue(l)
907 +     let cD = (parseBigIntValue(aU) * ew)
908 +     let cz = if ((gs == false))
909 +         then [(toBigInt(bN(dj)) + gt), toBigInt(bN(dk))]
910 +         else [(toBigInt(bN(dk)) + gt), toBigInt(bN(dj))]
911 +     let ev = cz[0]
912 +     let cC = ev
913 +     let cE = (cD * eu)
914 +     let ex = (((((et * et) / (ev * eu)) * et) * ew) / (cE * eu))
915 +     let ey = ((cC + ((et * ew) / cE)) - et)
916 +     func cN (cO,ez) =     {
917 +         let gu = cO
918 +         let eB = gu._1
919 +         let dc = gu._2
920 +         if ((dc != unit))
921 +             then cO
924 922              else {
925 -                 let eD = (((eC * eC) + ey) / ((g * eC) + ez))
926 -                 let eE = Y((eD - value(eC)))
927 -                 if ((f >= eE))
928 -                     then $Tuple2(eD, eA)
929 -                     else $Tuple2(eD, unit)
923 +                 let eC = (((eB * eB) + ex) / ((g * eB) + ey))
924 +                 let eD = X((eC - value(eB)))
925 +                 if ((f >= eD))
926 +                     then $Tuple2(eC, ez)
927 +                     else $Tuple2(eC, unit)
930 928                  }
931 929          }
932 930  
933 -     let cU = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
934 -     let gw = {
935 -         let cW = cU
936 -         let cX = size(cW)
937 -         let cY = $Tuple2(eu, unit)
938 -         func cZ (da,db) =         if ((db >= cX))
939 -             then da
940 -             else cO(da, cW[db])
931 +     let cT = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
932 +     let gv = {
933 +         let cV = cT
934 +         let cW = size(cV)
935 +         let cX = $Tuple2(et, unit)
936 +         func cY (cZ,da) =         if ((da >= cW))
937 +             then cZ
938 +             else cN(cZ, cV[da])
941 939  
942 -         func dc (da,db) =         if ((db >= cX))
943 -             then da
940 +         func db (cZ,da) =         if ((da >= cW))
941 +             then cZ
944 942              else throw("List size exceeds 15")
945 943  
946 -         dc(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
944 +         db(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cX, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
947 945          }
948 -     let eC = gw._1
949 -     let dd = gw._2
950 -     if ((dd != unit))
951 -         then eC
952 -         else throw(("Y calculation error, Y = " + toString(eC)))
946 +     let eB = gv._1
947 +     let dc = gv._2
948 +     if ((dc != unit))
949 +         then eB
950 +         else throw(("Y calculation error, Y = " + toString(eB)))
953 951      }
954 952  
955 953  
956 - @Callable(cQ)
957 - func calculateAmountOutForSwapREADONLY (gx,gt) = {
958 -     let gy = if ((gt == false))
954 + @Callable(cP)
955 + func calculateAmountOutForSwapREADONLY (gw,gs) = {
956 +     let gx = if ((gs == false))
959 957          then {
960 -             let gz = aK(this, al())
961 -             let gu = (toBigInt(bO(aK(this, ak()))) + toBigInt(gx))
962 -             $Tuple2(gz, gu)
958 +             let gy = aJ(this, ak())
959 +             let gt = (toBigInt(bN(aJ(this, aj()))) + toBigInt(gw))
960 +             $Tuple2(gy, gt)
963 961              }
964 962          else {
965 -             let gz = aK(this, ak())
966 -             let gu = (toBigInt(bO(aK(this, al()))) + toBigInt(gx))
967 -             $Tuple2(gz, gu)
963 +             let gy = aJ(this, aj())
964 +             let gt = (toBigInt(bN(aJ(this, ak()))) + toBigInt(gw))
965 +             $Tuple2(gy, gt)
968 966              }
969 -     let gz = gy._1
970 -     let gu = gy._2
971 -     let bh = aZ()
972 -     let dk = bh[x]
973 -     let dl = bh[y]
974 -     let cA = [toBigInt(bO(dk)), toBigInt(bO(dl))]
975 -     let eu = cz(cA)
976 -     let eC = gs(gt, eu, toBigInt(gx))
977 -     let gA = ((toBigInt(bO(gz)) - eC) - toBigInt(1))
978 -     let gB = max([0, toInt(gA)])
979 -     let gC = if ((gt == false))
980 -         then [(toBigInt(bO(dk)) + toBigInt(gx)), (toBigInt(bO(dl)) - gA)]
981 -         else [(toBigInt(bO(dk)) - gA), (toBigInt(bO(dl)) + toBigInt(gx))]
982 -     let gD = cz(gC)
983 -     let dZ = if ((gD >= eu))
967 +     let gy = gx._1
968 +     let gt = gx._2
969 +     let bg = aY()
970 +     let dj = bg[w]
971 +     let dk = bg[x]
972 +     let cz = [toBigInt(bN(dj)), toBigInt(bN(dk))]
973 +     let et = cy(cz)
974 +     let eB = gr(gs, et, toBigInt(gw))
975 +     let gz = ((toBigInt(bN(gy)) - eB) - toBigInt(1))
976 +     let gA = max([0, toInt(gz)])
977 +     let gB = if ((gs == false))
978 +         then [(toBigInt(bN(dj)) + toBigInt(gw)), (toBigInt(bN(dk)) - gz)]
979 +         else [(toBigInt(bN(dj)) - gz), (toBigInt(bN(dk)) + toBigInt(gw))]
980 +     let gC = cy(gB)
981 +     let dY = if ((gC >= et))
984 982          then true
985 -         else throw(makeString(["new D is fewer error", toString(eu), toString(gD)], "__"))
986 -     if ((dZ == dZ))
987 -         then $Tuple2(nil, gB)
983 +         else throw(makeString(["new D is fewer error", toString(et), toString(gC)], "__"))
984 +     if ((dY == dY))
985 +         then $Tuple2(nil, gA)
988 986          else throw("Strict value is not equal to itself.")
989 987      }
990 988  
991 989  
992 990  
993 - @Callable(cQ)
994 - func calculateAmountOutForSwapAndSendTokens (gx,gt,gE,gF) = {
995 -     let gG = {
996 -         let aT = invoke(aR, "getSwapContractREADONLY", nil, nil)
997 -         if ($isInstanceOf(aT, "String"))
998 -             then aT
999 -             else throw(($getType(aT) + " couldn't be cast to String"))
991 + @Callable(cP)
992 + func calculateAmountOutForSwapAndSendTokens (gw,gs,gD,gE) = {
993 +     let gF = {
994 +         let aS = invoke(aQ, "getSwapContractREADONLY", nil, nil)
995 +         if ($isInstanceOf(aS, "String"))
996 +             then aS
997 +             else throw(($getType(aS) + " couldn't be cast to String"))
1000 998          }
1001 -     let gH = [if ((value(cQ.payments[0]).amount >= gx))
999 +     let gG = [if ((value(cP.payments[0]).amount >= gw))
1002 1000          then true
1003 -         else aO("Wrong amount"), if ((cQ.caller == addressFromStringValue(gG)))
1001 +         else aN("Wrong amount"), if ((cP.caller == addressFromStringValue(gF)))
1004 1002          then true
1005 -         else aO("Permission denied")]
1006 -     if ((gH == gH))
1003 +         else aN("Permission denied")]
1004 +     if ((gG == gG))
1007 1005          then {
1008 -             let fl = value(cQ.payments[0])
1009 -             let gI = if ((fl.assetId == unit))
1006 +             let fk = value(cP.payments[0])
1007 +             let gH = if ((fk.assetId == unit))
1010 1008                  then toBase58String(toBytes("WAVES"))
1011 -                 else toBase58String(value(fl.assetId))
1012 -             let gJ = if ((gt == false))
1009 +                 else toBase58String(value(fk.assetId))
1010 +             let gI = if ((gs == false))
1013 1011                  then {
1014 -                     let gz = aK(this, al())
1015 -                     let gu = (bO(gI) - value(cQ.payments[0]).amount)
1016 -                     $Tuple2(gz, gu)
1012 +                     let gy = aJ(this, ak())
1013 +                     let gt = (bN(gH) - value(cP.payments[0]).amount)
1014 +                     $Tuple2(gy, gt)
1017 1015                      }
1018 1016                  else {
1019 -                     let gz = aK(this, ak())
1020 -                     let gu = (bO(gI) - value(cQ.payments[0]).amount)
1021 -                     $Tuple2(gz, gu)
1017 +                     let gy = aJ(this, aj())
1018 +                     let gt = (bN(gH) - value(cP.payments[0]).amount)
1019 +                     $Tuple2(gy, gt)
1022 1020                      }
1023 -             let gz = gJ._1
1024 -             let gu = gJ._2
1025 -             let bh = aZ()
1026 -             let dk = bh[x]
1027 -             let dl = bh[y]
1028 -             let cA = if ((gt == false))
1029 -                 then [(toBigInt(bO(dk)) - toBigInt(value(cQ.payments[0]).amount)), toBigInt(bO(dl))]
1030 -                 else [toBigInt(bO(dk)), (toBigInt(bO(dl)) - toBigInt(value(cQ.payments[0]).amount))]
1031 -             let eu = cz(cA)
1032 -             let eC = gs(gt, eu, toBigInt(0))
1033 -             let gA = ((toBigInt(bO(gz)) - eC) - toBigInt(1))
1034 -             let gB = max([0, toInt(gA)])
1035 -             let gK = if ((gB >= gE))
1021 +             let gy = gI._1
1022 +             let gt = gI._2
1023 +             let bg = aY()
1024 +             let dj = bg[w]
1025 +             let dk = bg[x]
1026 +             let cz = if ((gs == false))
1027 +                 then [(toBigInt(bN(dj)) - toBigInt(value(cP.payments[0]).amount)), toBigInt(bN(dk))]
1028 +                 else [toBigInt(bN(dj)), (toBigInt(bN(dk)) - toBigInt(value(cP.payments[0]).amount))]
1029 +             let et = cy(cz)
1030 +             let eB = gr(gs, et, toBigInt(0))
1031 +             let gz = ((toBigInt(bN(gy)) - eB) - toBigInt(1))
1032 +             let gA = max([0, toInt(gz)])
1033 +             let gJ = if ((gA >= gD))
1036 1034                  then true
1037 1035                  else throw("Exchange result is fewer coins than expected")
1038 -             if ((gK == gK))
1036 +             if ((gJ == gJ))
1039 1037                  then {
1040 -                     let gC = if ((gt == false))
1041 -                         then [toBigInt(bO(dk)), (toBigInt(bO(dl)) - gA)]
1042 -                         else [(toBigInt(bO(dk)) - gA), toBigInt(bO(dl))]
1043 -                     let gD = cz(gC)
1044 -                     let dZ = if ((gD >= eu))
1038 +                     let gB = if ((gs == false))
1039 +                         then [toBigInt(bN(dj)), (toBigInt(bN(dk)) - gz)]
1040 +                         else [(toBigInt(bN(dj)) - gz), toBigInt(bN(dk))]
1041 +                     let gC = cy(gB)
1042 +                     let dY = if ((gC >= et))
1045 1043                          then true
1046 1044                          else throw("new D is fewer error")
1047 -                     if ((dZ == dZ))
1048 -                         then $Tuple2([ScriptTransfer(addressFromStringValue(gF), gB, bd(gz))], gB)
1045 +                     if ((dY == dY))
1046 +                         then $Tuple2([ScriptTransfer(addressFromStringValue(gE), gA, bc(gy))], gA)
1049 1047                          else throw("Strict value is not equal to itself.")
1050 1048                      }
1051 1049                  else throw("Strict value is not equal to itself.")
1055 1053  
1056 1054  
1057 1055  
1058 - @Callable(cQ)
1059 - func constructor (Z) = {
1060 -     let ey = gr(cQ)
1061 -     if ((ey == ey))
1062 -         then [StringEntry(Z(), Z)]
1056 + @Callable(cP)
1057 + func constructor (Y) = {
1058 +     let ex = gq(cP)
1059 +     if ((ex == ex))
1060 +         then [StringEntry(Y(), Y)]
1063 1061          else throw("Strict value is not equal to itself.")
1064 1062      }
1065 1063  
1066 1064  
1067 1065  
1068 - @Callable(cQ)
1069 - func setManager (gL) = {
1070 -     let ey = gr(cQ)
1071 -     if ((ey == ey))
1066 + @Callable(cP)
1067 + func setManager (gK) = {
1068 +     let ex = gq(cP)
1069 +     if ((ex == ex))
1072 1070          then {
1073 -             let gM = fromBase58String(gL)
1074 -             if ((gM == gM))
1075 -                 then [StringEntry(ab(), gL)]
1071 +             let gL = fromBase58String(gK)
1072 +             if ((gL == gL))
1073 +                 then [StringEntry(aa(), gK)]
1076 1074                  else throw("Strict value is not equal to itself.")
1077 1075              }
1078 1076          else throw("Strict value is not equal to itself.")
1080 1078  
1081 1079  
1082 1080  
1083 - @Callable(cQ)
1081 + @Callable(cP)
1084 1082  func confirmManager () = {
1085 -     let cv = gn()
1086 -     let gN = if (isDefined(cv))
1083 +     let cu = gm()
1084 +     let gM = if (isDefined(cu))
1087 1085          then true
1088 1086          else throw("No pending manager")
1089 -     if ((gN == gN))
1087 +     if ((gM == gM))
1090 1088          then {
1091 -             let gO = if ((cQ.callerPublicKey == value(cv)))
1089 +             let gN = if ((cP.callerPublicKey == value(cu)))
1092 1090                  then true
1093 1091                  else throw("You are not pending manager")
1094 -             if ((gO == gO))
1095 -                 then [StringEntry(aa(), toBase58String(value(cv))), DeleteEntry(ab())]
1092 +             if ((gN == gN))
1093 +                 then [StringEntry(Z(), toBase58String(value(cu))), DeleteEntry(aa())]
1096 1094                  else throw("Strict value is not equal to itself.")
1097 1095              }
1098 1096          else throw("Strict value is not equal to itself.")
1100 1098  
1101 1099  
1102 1100  
1103 - @Callable(cQ)
1104 - func put (gP,gQ) = {
1105 -     let gR = bt()
1106 -     let gS = valueOrErrorMessage(addressFromString(gR[D]), "Wr st addr")
1107 -     let gT = valueOrErrorMessage(addressFromString(gR[F]), "Wr sl addr")
1108 -     if ((0 > gP))
1101 + @Callable(cP)
1102 + func put (gO,gP) = {
1103 +     let gQ = bs()
1104 +     let gR = valueOrErrorMessage(addressFromString(gQ[C]), "Wr st addr")
1105 +     let gS = valueOrErrorMessage(addressFromString(gQ[E]), "Wr sl addr")
1106 +     if ((0 > gO))
1109 1107          then throw("Wrong slippage")
1110 -         else if ((size(cQ.payments) != 2))
1108 +         else if ((size(cP.payments) != 2))
1111 1109              then throw("2 pmnts expd")
1112 1110              else {
1113 -                 let gU = toBigInt(value(cQ.payments[0]).amount)
1114 -                 let gV = toBigInt(value(cQ.payments[1]).amount)
1115 -                 let eP = (toBigInt(bO(bf(bn))) - gU)
1116 -                 if ((eP == eP))
1111 +                 let gT = toBigInt(value(cP.payments[0]).amount)
1112 +                 let gU = toBigInt(value(cP.payments[1]).amount)
1113 +                 let eO = (toBigInt(bN(be(bm))) - gT)
1114 +                 if ((eO == eO))
1117 1115                      then {
1118 -                         let eQ = (toBigInt(bO(bf(bo))) - gV)
1119 -                         if ((eQ == eQ))
1116 +                         let eP = (toBigInt(bN(be(bn))) - gU)
1117 +                         if ((eP == eP))
1120 1118                              then {
1121 -                                 let eR = toBigInt(value(assetInfo(bm)).quantity)
1122 -                                 if ((eR == eR))
1119 +                                 let eQ = toBigInt(value(assetInfo(bl)).quantity)
1120 +                                 if ((eQ == eQ))
1123 1121                                      then {
1124 -                                         let eS = eL(gU, gV, toBigInt(0))
1125 -                                         if ((eS == eS))
1122 +                                         let eR = eK(gT, gU, toBigInt(0))
1123 +                                         if ((eR == eR))
1126 1124                                              then {
1127 -                                                 let gW = fm(toString(cQ.caller), toBase58String(cQ.transactionId), AttachedPayment(value(cQ.payments[0]).assetId, value(cQ.payments[0]).amount), cQ.payments[1], gP, true, false, true, 0, "")
1128 -                                                 let em = gW._2
1129 -                                                 let gX = gW._7
1130 -                                                 let dC = gW._9
1131 -                                                 let en = gW._10
1132 -                                                 let eo = gW._11
1133 -                                                 let dk = gW._12
1134 -                                                 let dl = gW._13
1135 -                                                 let dY = invoke(aR, "emit", [em], nil)
1136 -                                                 if ((dY == dY))
1125 +                                                 let gV = fl(toString(cP.caller), toBase58String(cP.transactionId), AttachedPayment(value(cP.payments[0]).assetId, value(cP.payments[0]).amount), cP.payments[1], gO, true, false, true, 0, "")
1126 +                                                 let el = gV._2
1127 +                                                 let gW = gV._7
1128 +                                                 let dB = gV._9
1129 +                                                 let em = gV._10
1130 +                                                 let en = gV._11
1131 +                                                 let dj = gV._12
1132 +                                                 let dk = gV._13
1133 +                                                 let dX = invoke(aQ, "emit", [el], nil)
1134 +                                                 if ((dX == dX))
1137 1135                                                      then {
1138 -                                                         let gY = {
1139 -                                                             let gm = dY
1140 -                                                             if ($isInstanceOf(gm, "Address"))
1136 +                                                         let gX = {
1137 +                                                             let gl = dX
1138 +                                                             if ($isInstanceOf(gl, "Address"))
1141 1139                                                                  then {
1142 -                                                                     let gZ = gm
1143 -                                                                     invoke(gZ, "emit", [em], nil)
1140 +                                                                     let gY = gl
1141 +                                                                     invoke(gY, "emit", [el], nil)
1144 1142                                                                      }
1145 1143                                                                  else unit
1146 1144                                                              }
1147 -                                                         if ((gY == gY))
1145 +                                                         if ((gX == gX))
1148 1146                                                              then {
1149 -                                                                 let ha = if ((en > 0))
1150 -                                                                     then invoke(gT, "put", nil, [AttachedPayment(dk, en)])
1147 +                                                                 let gZ = if ((em > 0))
1148 +                                                                     then invoke(gS, "put", nil, [AttachedPayment(dj, em)])
1151 1149                                                                      else nil
1152 -                                                                 if ((ha == ha))
1150 +                                                                 if ((gZ == gZ))
1153 1151                                                                      then {
1154 -                                                                         let hb = if ((eo > 0))
1155 -                                                                             then invoke(gT, "put", nil, [AttachedPayment(dl, eo)])
1152 +                                                                         let ha = if ((en > 0))
1153 +                                                                             then invoke(gS, "put", nil, [AttachedPayment(dk, en)])
1156 1154                                                                              else nil
1157 -                                                                         if ((hb == hb))
1155 +                                                                         if ((ha == ha))
1158 1156                                                                              then {
1159 -                                                                                 let hc = if (gQ)
1157 +                                                                                 let hb = if (gP)
1160 1158                                                                                      then {
1161 -                                                                                         let hd = invoke(gS, "stake", nil, [AttachedPayment(gX, em)])
1162 -                                                                                         if ((hd == hd))
1159 +                                                                                         let hc = invoke(gR, "stake", nil, [AttachedPayment(gW, el)])
1160 +                                                                                         if ((hc == hc))
1163 1161                                                                                              then nil
1164 1162                                                                                              else throw("Strict value is not equal to itself.")
1165 1163                                                                                          }
1166 -                                                                                     else [ScriptTransfer(cQ.caller, em, gX)]
1167 -                                                                                 let he = eT(0, 0, 0)
1168 -                                                                                 let gj = he._1
1169 -                                                                                 let eK = he._2
1170 -                                                                                 let hf = if ((eK >= eS))
1164 +                                                                                     else [ScriptTransfer(cP.caller, el, gW)]
1165 +                                                                                 let hd = eS(0, 0, 0)
1166 +                                                                                 let gi = hd._1
1167 +                                                                                 let eJ = hd._2
1168 +                                                                                 let he = if ((eJ >= eR))
1171 1169                                                                                      then true
1172 -                                                                                     else aO(makeString(["updated DLp lower than current DLp", toString(eP), toString(eQ), toString(eR), toString(eS), toString(eK), toString(en), toString(eo)], " "))
1173 -                                                                                 if ((hf == hf))
1170 +                                                                                     else aN(makeString(["updated DLp lower than current DLp", toString(eO), toString(eP), toString(eQ), toString(eR), toString(eJ), toString(em), toString(en)], " "))
1171 +                                                                                 if ((he == he))
1174 1172                                                                                      then {
1175 -                                                                                         let hg = value(assetInfo(bm)).quantity
1176 -                                                                                         if ((hg == hg))
1177 -                                                                                             then ((dC ++ hc) ++ gj)
1173 +                                                                                         let hf = value(assetInfo(bl)).quantity
1174 +                                                                                         if ((hf == hf))
1175 +                                                                                             then ((dB ++ hb) ++ gi)
1178 1176                                                                                              else throw("Strict value is not equal to itself.")
1179 1177                                                                                          }
1180 1178                                                                                      else throw("Strict value is not equal to itself.")
1199 1197  
1200 1198  
1201 1199  
1202 - @Callable(cQ)
1203 - func putOneTknV2 (fN,gQ) = {
1204 -     let hh = {
1205 -         let aT = invoke(aR, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1206 -         if ($isInstanceOf(aT, "Boolean"))
1207 -             then aT
1208 -             else throw(($getType(aT) + " couldn't be cast to Boolean"))
1200 + @Callable(cP)
1201 + func putOneTknV2 (fM,gP) = {
1202 +     let hg = {
1203 +         let aS = invoke(aQ, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1204 +         if ($isInstanceOf(aS, "Boolean"))
1205 +             then aS
1206 +             else throw(($getType(aS) + " couldn't be cast to Boolean"))
1209 1207          }
1210 -     let hi = if (if (if (aW())
1208 +     let hh = if (if (if (aV())
1211 1209          then true
1212 -         else (bl == r))
1210 +         else (bk == q))
1213 1211          then true
1214 -         else (bl == t))
1212 +         else (bk == s))
1215 1213          then true
1216 -         else hh
1217 -     let gH = [if (if (!(hi))
1214 +         else hg
1215 +     let gG = [if (if (!(hh))
1218 1216          then true
1219 -         else gp(cQ))
1217 +         else go(cP))
1220 1218          then true
1221 -         else aO("put operation is blocked by admin"), if ((size(cQ.payments) == 1))
1219 +         else aN("put operation is blocked by admin"), if ((size(cP.payments) == 1))
1222 1220          then true
1223 -         else aO("exactly 1 payment are expected")]
1224 -     if ((gH == gH))
1221 +         else aN("exactly 1 payment are expected")]
1222 +     if ((gG == gG))
1225 1223          then {
1224 +             let dj = toBase58String(value(bm))
1226 1225              let dk = toBase58String(value(bn))
1227 -             let dl = toBase58String(value(bo))
1228 -             let dj = bm
1226 +             let di = bl
1227 +             let fQ = bo
1229 1228              let fR = bp
1230 -             let fS = bq
1231 -             let di = if ((cQ.caller == this))
1232 -                 then cQ.originCaller
1233 -                 else cQ.caller
1234 -             let fl = value(cQ.payments[0])
1235 -             let dg = toBase58String(value(fl.assetId))
1236 -             let dM = fl.amount
1237 -             let eS = if ((fl.assetId == bn))
1238 -                 then eL(toBigInt(dM), toBigInt(0), toBigInt(0))
1239 -                 else eL(toBigInt(0), toBigInt(dM), toBigInt(0))
1240 -             if ((eS == eS))
1229 +             let dh = if ((cP.caller == this))
1230 +                 then cP.originCaller
1231 +                 else cP.caller
1232 +             let fk = value(cP.payments[0])
1233 +             let df = toBase58String(value(fk.assetId))
1234 +             let dL = fk.amount
1235 +             let eR = if ((fk.assetId == bm))
1236 +                 then eK(toBigInt(dL), toBigInt(0), toBigInt(0))
1237 +                 else eK(toBigInt(0), toBigInt(dL), toBigInt(0))
1238 +             if ((eR == eR))
1241 1239                  then {
1242 -                     let hj = fq(dM, dg, toString(di), toBase58String(cQ.transactionId), true)
1243 -                     if ((hj == hj))
1240 +                     let hi = fp(dL, df, toString(dh), toBase58String(cP.transactionId), true)
1241 +                     if ((hi == hi))
1244 1242                          then {
1245 -                             let cy = hj._3
1246 -                             let dC = hj._2
1247 -                             let hk = hj._1
1248 -                             let em = if (if ((fN > 0))
1249 -                                 then (fN > hk)
1243 +                             let cx = hi._3
1244 +                             let dB = hi._2
1245 +                             let hj = hi._1
1246 +                             let el = if (if ((fM > 0))
1247 +                                 then (fM > hj)
1250 1248                                  else false)
1251 -                                 then aO(makeString(["amount to receive is less than ", toString(fN)], ""))
1252 -                                 else hk
1253 -                             let gW = invoke(aR, "emit", [em], nil)
1254 -                             if ((gW == gW))
1249 +                                 then aN(makeString(["amount to receive is less than ", toString(fM)], ""))
1250 +                                 else hj
1251 +                             let gV = invoke(aQ, "emit", [el], nil)
1252 +                             if ((gV == gV))
1255 1253                                  then {
1256 -                                     let gY = {
1257 -                                         let gm = gW
1258 -                                         if ($isInstanceOf(gm, "Address"))
1254 +                                     let gX = {
1255 +                                         let gl = gV
1256 +                                         if ($isInstanceOf(gl, "Address"))
1259 1257                                              then {
1260 -                                                 let gZ = gm
1261 -                                                 invoke(gZ, "emit", [em], nil)
1258 +                                                 let gY = gl
1259 +                                                 invoke(gY, "emit", [el], nil)
1262 1260                                                  }
1263 1261                                              else unit
1264 1262                                          }
1265 -                                     if ((gY == gY))
1263 +                                     if ((gX == gX))
1266 1264                                          then {
1267 -                                             let hc = if (gQ)
1265 +                                             let hb = if (gP)
1268 1266                                                  then {
1269 -                                                     let hd = invoke(bv, "stake", nil, [AttachedPayment(dj, em)])
1270 -                                                     if ((hd == hd))
1267 +                                                     let hc = invoke(bu, "stake", nil, [AttachedPayment(di, el)])
1268 +                                                     if ((hc == hc))
1271 1269                                                          then nil
1272 1270                                                          else throw("Strict value is not equal to itself.")
1273 1271                                                      }
1274 -                                                 else [ScriptTransfer(cQ.caller, em, dj)]
1275 -                                             let gd = if ((cy > 0))
1276 -                                                 then [ScriptTransfer(aY, cy, fromBase58String(dg))]
1272 +                                                 else [ScriptTransfer(cP.caller, el, di)]
1273 +                                             let gc = if ((cx > 0))
1274 +                                                 then [ScriptTransfer(aX, cx, fromBase58String(df))]
1277 1275                                                  else nil
1278 -                                             let hl = if ((this == aY))
1276 +                                             let hk = if ((this == aX))
1279 1277                                                  then $Tuple2(0, 0)
1280 1278                                                  else {
1281 -                                                     let hm = if ((fl.assetId == bn))
1279 +                                                     let hl = if ((fk.assetId == bm))
1282 1280                                                          then true
1283 1281                                                          else false
1284 -                                                     if (hm)
1285 -                                                         then $Tuple2(-(cy), 0)
1286 -                                                         else $Tuple2(0, -(cy))
1282 +                                                     if (hl)
1283 +                                                         then $Tuple2(-(cx), 0)
1284 +                                                         else $Tuple2(0, -(cx))
1287 1285                                                      }
1288 -                                             let eU = hl._1
1289 -                                             let eV = hl._2
1290 -                                             let hn = eT(eU, eV, 0)
1291 -                                             let gj = hn._1
1292 -                                             let eK = hn._2
1293 -                                             let gk = eX(eS, eK)
1294 -                                             if ((gk == gk))
1295 -                                                 then $Tuple2((((dC ++ hc) ++ gd) ++ gj), em)
1286 +                                             let eT = hk._1
1287 +                                             let eU = hk._2
1288 +                                             let hm = eS(eT, eU, 0)
1289 +                                             let gi = hm._1
1290 +                                             let eJ = hm._2
1291 +                                             let gj = eW(eR, eJ)
1292 +                                             if ((gj == gj))
1293 +                                                 then $Tuple2((((dB ++ hb) ++ gc) ++ gi), el)
1296 1294                                                  else throw("Strict value is not equal to itself.")
1297 1295                                              }
1298 1296                                          else throw("Strict value is not equal to itself.")
1308 1306  
1309 1307  
1310 1308  
1311 - @Callable(cQ)
1312 - func putForFree (ho) = if ((0 > ho))
1309 + @Callable(cP)
1310 + func putForFree (hn) = if ((0 > hn))
1313 1311      then throw("Wrong slpg")
1314 -     else if ((size(cQ.payments) != 2))
1312 +     else if ((size(cP.payments) != 2))
1315 1313          then throw("2 pmnts expd")
1316 1314          else {
1317 -             let hp = fm(toString(cQ.caller), toBase58String(cQ.transactionId), AttachedPayment(value(cQ.payments[0]).assetId, value(cQ.payments[0]).amount), cQ.payments[1], ho, false, false, true, 0, "")
1318 -             let dC = hp._9
1319 -             let gU = toBigInt(value(cQ.payments[0]).amount)
1320 -             let gV = toBigInt(value(cQ.payments[1]).amount)
1321 -             let eS = eL(gU, gV, toBigInt(0))
1322 -             if ((eS == eS))
1315 +             let ho = fl(toString(cP.caller), toBase58String(cP.transactionId), AttachedPayment(value(cP.payments[0]).assetId, value(cP.payments[0]).amount), cP.payments[1], hn, false, false, true, 0, "")
1316 +             let dB = ho._9
1317 +             let gT = toBigInt(value(cP.payments[0]).amount)
1318 +             let gU = toBigInt(value(cP.payments[1]).amount)
1319 +             let eR = eK(gT, gU, toBigInt(0))
1320 +             if ((eR == eR))
1323 1321                  then {
1324 -                     let hq = eT(0, 0, 0)
1325 -                     let gj = hq._1
1326 -                     let eK = hq._2
1327 -                     let gk = eX(eS, eK)
1328 -                     if ((gk == gk))
1329 -                         then (dC ++ gj)
1322 +                     let hp = eS(0, 0, 0)
1323 +                     let gi = hp._1
1324 +                     let eJ = hp._2
1325 +                     let gj = eW(eR, eJ)
1326 +                     if ((gj == gj))
1327 +                         then (dB ++ gi)
1330 1328                          else throw("Strict value is not equal to itself.")
1331 1329                      }
1332 1330                  else throw("Strict value is not equal to itself.")
1334 1332  
1335 1333  
1336 1334  
1337 - @Callable(cQ)
1335 + @Callable(cP)
1338 1336  func get () = {
1339 -     let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1340 -     if ((eS == eS))
1337 +     let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1338 +     if ((eR == eR))
1341 1339          then {
1342 -             let dY = fk(cQ)
1343 -             let hr = dY._1
1344 -             let dB = dY._2
1345 -             let dM = dY._3
1346 -             let dg = dY._4
1347 -             let dC = dY._5
1348 -             let ez = invoke(aR, "burn", [dM], [AttachedPayment(dg, dM)])
1349 -             if ((ez == ez))
1340 +             let dX = fj(cP)
1341 +             let hq = dX._1
1342 +             let dA = dX._2
1343 +             let dL = dX._3
1344 +             let df = dX._4
1345 +             let dB = dX._5
1346 +             let ey = invoke(aQ, "burn", [dL], [AttachedPayment(df, dL)])
1347 +             if ((ey == ey))
1350 1348                  then {
1351 -                     let hs = eT(-(hr), -(dB), 0)
1352 -                     let gj = hs._1
1353 -                     let eK = hs._2
1354 -                     let gk = eX(eS, eK)
1355 -                     if ((gk == gk))
1356 -                         then (dC ++ gj)
1349 +                     let hr = eS(-(hq), -(dA), 0)
1350 +                     let gi = hr._1
1351 +                     let eJ = hr._2
1352 +                     let gj = eW(eR, eJ)
1353 +                     if ((gj == gj))
1354 +                         then (dB ++ gi)
1357 1355                          else throw("Strict value is not equal to itself.")
1358 1356                      }
1359 1357                  else throw("Strict value is not equal to itself.")
1363 1361  
1364 1362  
1365 1363  
1366 - @Callable(cQ)
1367 - func getOneTknV2 (fM,fN) = {
1368 -     let hh = {
1369 -         let aT = invoke(aR, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1370 -         if ($isInstanceOf(aT, "Boolean"))
1371 -             then aT
1372 -             else throw(($getType(aT) + " couldn't be cast to Boolean"))
1364 + @Callable(cP)
1365 + func getOneTknV2 (fL,fM) = {
1366 +     let hg = {
1367 +         let aS = invoke(aQ, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1368 +         if ($isInstanceOf(aS, "Boolean"))
1369 +             then aS
1370 +             else throw(($getType(aS) + " couldn't be cast to Boolean"))
1373 1371          }
1374 -     let ht = if (if (aW())
1372 +     let hs = if (if (aV())
1375 1373          then true
1376 -         else (bl == t))
1374 +         else (bk == s))
1377 1375          then true
1378 -         else hh
1379 -     let gH = [if (if (!(ht))
1376 +         else hg
1377 +     let gG = [if (if (!(hs))
1380 1378          then true
1381 -         else gp(cQ))
1379 +         else go(cP))
1382 1380          then true
1383 -         else aO("get operation is blocked by admin"), if ((size(cQ.payments) == 1))
1381 +         else aN("get operation is blocked by admin"), if ((size(cP.payments) == 1))
1384 1382          then true
1385 -         else aO("exactly 1 payment are expected")]
1386 -     if ((gH == gH))
1383 +         else aN("exactly 1 payment are expected")]
1384 +     if ((gG == gG))
1387 1385          then {
1388 -             let hu = fL(fM, fN, cQ.payments, cQ.caller, cQ.originCaller, cQ.transactionId)
1389 -             let dC = hu._1
1390 -             let fW = hu._2
1391 -             $Tuple2(dC, fW)
1386 +             let ht = fK(fL, fM, cP.payments, cP.caller, cP.originCaller, cP.transactionId)
1387 +             let dB = ht._1
1388 +             let fV = ht._2
1389 +             $Tuple2(dB, fV)
1392 1390              }
1393 1391          else throw("Strict value is not equal to itself.")
1394 1392      }
1395 1393  
1396 1394  
1397 1395  
1398 - @Callable(cQ)
1396 + @Callable(cP)
1399 1397  func refreshDLp () = {
1400 -     let hv = valueOrElse(getInteger(ar), 0)
1401 -     let hw = if (((height - hv) >= au))
1398 +     let hu = valueOrElse(getInteger(aq), 0)
1399 +     let hv = if (((height - hu) >= at))
1402 1400          then unit
1403 -         else aO(makeString([toString(au), " blocks have not passed since the previous call"], ""))
1404 -     if ((hw == hw))
1401 +         else aN(makeString([toString(at), " blocks have not passed since the previous call"], ""))
1402 +     if ((hv == hv))
1405 1403          then {
1406 -             let fe = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aq), "0")), aQ("invalid dLp"))
1407 -             let hx = eT(0, 0, 0)
1408 -             let hy = hx._1
1409 -             let eK = hx._2
1410 -             let eW = if ((fe != eK))
1411 -                 then hy
1412 -                 else aO("nothing to refresh")
1413 -             $Tuple2(eW, toString(eK))
1404 +             let fd = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, ap), "0")), aP("invalid dLp"))
1405 +             let hw = eS(0, 0, 0)
1406 +             let hx = hw._1
1407 +             let eJ = hw._2
1408 +             let eV = if ((fd != eJ))
1409 +                 then hx
1410 +                 else aN("nothing to refresh")
1411 +             $Tuple2(eV, toString(eJ))
1414 1412              }
1415 1413          else throw("Strict value is not equal to itself.")
1416 1414      }
1417 1415  
1418 1416  
1419 1417  
1420 - @Callable(cQ)
1421 - func getOneTknV2READONLY (fM,hz) = {
1418 + @Callable(cP)
1419 + func getOneTknV2READONLY (fL,hy) = {
1420 +     let dj = toBase58String(value(bm))
1422 1421      let dk = toBase58String(value(bn))
1423 -     let dl = toBase58String(value(bo))
1424 -     let dj = toBase58String(value(bm))
1425 -     let cA = [toBigInt(bO(dk)), toBigInt(bO(dl))]
1426 -     let eJ = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(dj)), "invalid lp asset").quantity)
1427 -     let cc = cz(cA)
1428 -     let cb = (cc - fraction(toBigInt(hz), cc, eJ))
1429 -     let hA = if ((fM == dk))
1422 +     let di = toBase58String(value(bl))
1423 +     let cz = [toBigInt(bN(dj)), toBigInt(bN(dk))]
1424 +     let eI = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(di)), "invalid lp asset").quantity)
1425 +     let cb = cy(cz)
1426 +     let ca = (cb - fraction(toBigInt(hy), cb, eI))
1427 +     let hz = if ((fL == dj))
1430 1428          then 0
1431 -         else if ((fM == dl))
1429 +         else if ((fL == dk))
1432 1430              then 1
1433 1431              else throw("invalid out asset id")
1434 -     let hB = et(cA, hA, cb)
1435 -     let gA = (cA[hA] - hB)
1436 -     let gB = max([0, toInt((gA - f))])
1437 -     let hC = cw(gB, aU)
1438 -     let fV = hC._1
1439 -     let cy = hC._2
1440 -     $Tuple2(nil, $Tuple2(fV, cy))
1432 +     let hA = es(cz, hz, ca)
1433 +     let gz = (cz[hz] - hA)
1434 +     let gA = max([0, toInt((gz - f))])
1435 +     let hB = cv(gA, aT)
1436 +     let fU = hB._1
1437 +     let cx = hB._2
1438 +     $Tuple2(nil, $Tuple2(fU, cx))
1441 1439      }
1442 1440  
1443 1441  
1444 1442  
1445 - @Callable(cQ)
1446 - func getOneTknV2WithBonusREADONLY (fM,hz) = {
1443 + @Callable(cP)
1444 + func getOneTknV2WithBonusREADONLY (fL,hy) = {
1445 +     let dj = toBase58String(value(bm))
1447 1446      let dk = toBase58String(value(bn))
1448 -     let dl = toBase58String(value(bo))
1449 -     let dj = toBase58String(value(bm))
1450 -     let dq = bO(dk)
1451 -     let ds = bO(dl)
1452 -     let hD = {
1453 -         let aT = invoke(this, "getOneTknV2READONLY", [fM, hz], nil)
1454 -         if ($isInstanceOf(aT, "(Int, Int)"))
1455 -             then aT
1456 -             else throw(($getType(aT) + " couldn't be cast to (Int, Int)"))
1447 +     let di = toBase58String(value(bl))
1448 +     let dp = bN(dj)
1449 +     let dr = bN(dk)
1450 +     let hC = {
1451 +         let aS = invoke(this, "getOneTknV2READONLY", [fL, hy], nil)
1452 +         if ($isInstanceOf(aS, "(Int, Int)"))
1453 +             then aS
1454 +             else throw(($getType(aS) + " couldn't be cast to (Int, Int)"))
1457 1455          }
1458 -     let fV = hD._1
1459 -     let cy = hD._2
1460 -     let dY = de("", dj, hz, this)
1461 -     let dA = dY._1
1462 -     let dB = dY._2
1463 -     let hE = (dA + dB)
1464 -     let fK = if ((hE == 0))
1465 -         then if ((fV == 0))
1456 +     let fU = hC._1
1457 +     let cx = hC._2
1458 +     let dX = dd("", di, hy, this)
1459 +     let dz = dX._1
1460 +     let dA = dX._2
1461 +     let hD = (dz + dA)
1462 +     let fJ = if ((hD == 0))
1463 +         then if ((fU == 0))
1466 1464              then 0
1467 1465              else throw("bonus calculation error")
1468 -         else fraction((fV - hE), a, hE)
1469 -     $Tuple2(nil, $Tuple3(fV, cy, fK))
1466 +         else fraction((fU - hD), a, hD)
1467 +     $Tuple2(nil, $Tuple3(fU, cx, fJ))
1470 1468      }
1471 1469  
1472 1470  
1473 1471  
1474 - @Callable(cQ)
1475 - func getNoLess (hF,hG) = {
1476 -     let dY = fk(cQ)
1477 -     let dA = dY._1
1478 -     let dB = dY._2
1479 -     let dM = dY._3
1480 -     let dg = dY._4
1481 -     let dC = dY._5
1482 -     if ((hF > dA))
1483 -         then throw(((("Failed:  " + toString(dA)) + " < ") + toString(hF)))
1484 -         else if ((hG > dB))
1485 -             then throw(((("Failed: " + toString(dB)) + " < ") + toString(hG)))
1472 + @Callable(cP)
1473 + func getNoLess (hE,hF) = {
1474 +     let dX = fj(cP)
1475 +     let dz = dX._1
1476 +     let dA = dX._2
1477 +     let dL = dX._3
1478 +     let df = dX._4
1479 +     let dB = dX._5
1480 +     if ((hE > dz))
1481 +         then throw(((("Failed:  " + toString(dz)) + " < ") + toString(hE)))
1482 +         else if ((hF > dA))
1483 +             then throw(((("Failed: " + toString(dA)) + " < ") + toString(hF)))
1486 1484              else {
1487 -                 let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1488 -                 if ((eS == eS))
1485 +                 let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1486 +                 if ((eR == eR))
1489 1487                      then {
1490 -                         let hH = invoke(aR, "burn", [dM], [AttachedPayment(dg, dM)])
1491 -                         if ((hH == hH))
1488 +                         let hG = invoke(aQ, "burn", [dL], [AttachedPayment(df, dL)])
1489 +                         if ((hG == hG))
1492 1490                              then {
1493 -                                 let hI = eT(-(dA), -(dB), 0)
1494 -                                 let gj = hI._1
1495 -                                 let eK = hI._2
1496 -                                 let gk = eX(eS, eK)
1497 -                                 if ((gk == gk))
1498 -                                     then (dC ++ gj)
1491 +                                 let hH = eS(-(dz), -(dA), 0)
1492 +                                 let gi = hH._1
1493 +                                 let eJ = hH._2
1494 +                                 let gj = eW(eR, eJ)
1495 +                                 if ((gj == gj))
1496 +                                     then (dB ++ gi)
1499 1497                                      else throw("Strict value is not equal to itself.")
1500 1498                                  }
1501 1499                              else throw("Strict value is not equal to itself.")
1506 1504  
1507 1505  
1508 1506  
1509 - @Callable(cQ)
1510 - func unstakeAndGet (cx) = {
1511 -     let hJ = if ((size(cQ.payments) != 0))
1507 + @Callable(cP)
1508 + func unstakeAndGet (cw) = {
1509 +     let hI = if ((size(cP.payments) != 0))
1512 1510          then throw("No pmnts expd")
1513 1511          else true
1514 -     if ((hJ == hJ))
1512 +     if ((hI == hI))
1515 1513          then {
1516 -             let hK = bt()
1517 -             let gX = bm
1518 -             let hL = valueOrErrorMessage(addressFromString(hK[D]), "Wr st addr")
1519 -             let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1520 -             if ((eS == eS))
1514 +             let hJ = bs()
1515 +             let gW = bl
1516 +             let hK = valueOrErrorMessage(addressFromString(hJ[C]), "Wr st addr")
1517 +             let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1518 +             if ((eR == eR))
1521 1519                  then {
1522 -                     let hM = invoke(hL, "unstake", [toBase58String(gX), cx], nil)
1523 -                     if ((hM == hM))
1520 +                     let hL = invoke(hK, "unstake", [toBase58String(gW), cw], nil)
1521 +                     if ((hL == hL))
1524 1522                          then {
1525 -                             let dY = de(toBase58String(cQ.transactionId), toBase58String(gX), cx, cQ.caller)
1526 -                             let dA = dY._1
1527 -                             let dB = dY._2
1528 -                             let do = parseIntValue(dY._9)
1529 -                             let dC = dY._10
1530 -                             let hN = if (if (aW())
1523 +                             let dX = dd(toBase58String(cP.transactionId), toBase58String(gW), cw, cP.caller)
1524 +                             let dz = dX._1
1525 +                             let dA = dX._2
1526 +                             let dn = parseIntValue(dX._9)
1527 +                             let dB = dX._10
1528 +                             let hM = if (if (aV())
1531 1529                                  then true
1532 -                                 else (do == t))
1533 -                                 then throw(("Blocked: " + toString(do)))
1530 +                                 else (dn == s))
1531 +                                 then throw(("Blocked: " + toString(dn)))
1534 1532                                  else true
1535 -                             if ((hN == hN))
1533 +                             if ((hM == hM))
1536 1534                                  then {
1537 -                                     let hO = invoke(aR, "burn", [cx], [AttachedPayment(gX, cx)])
1538 -                                     if ((hO == hO))
1535 +                                     let hN = invoke(aQ, "burn", [cw], [AttachedPayment(gW, cw)])
1536 +                                     if ((hN == hN))
1539 1537                                          then {
1540 -                                             let hP = eT(-(dA), -(dB), 0)
1541 -                                             let gj = hP._1
1542 -                                             let eK = hP._2
1543 -                                             let gk = eX(eS, eK)
1544 -                                             if ((gk == gk))
1545 -                                                 then (dC ++ gj)
1538 +                                             let hO = eS(-(dz), -(dA), 0)
1539 +                                             let gi = hO._1
1540 +                                             let eJ = hO._2
1541 +                                             let gj = eW(eR, eJ)
1542 +                                             if ((gj == gj))
1543 +                                                 then (dB ++ gi)
1546 1544                                                  else throw("Strict value is not equal to itself.")
1547 1545                                              }
1548 1546                                          else throw("Strict value is not equal to itself.")
1558 1556  
1559 1557  
1560 1558  
1561 - @Callable(cQ)
1562 - func unstakeAndGetNoLess (hQ,hR,hG) = {
1563 -     let ht = if (aW())
1559 + @Callable(cP)
1560 + func unstakeAndGetNoLess (hP,hQ,hF) = {
1561 +     let hs = if (aV())
1564 1562          then true
1565 -         else (bl == t)
1566 -     let gH = [if (!(ht))
1563 +         else (bk == s)
1564 +     let gG = [if (!(hs))
1567 1565          then true
1568 -         else throw("get operation is blocked by admin"), if ((size(cQ.payments) == 0))
1566 +         else throw("get operation is blocked by admin"), if ((size(cP.payments) == 0))
1569 1567          then true
1570 1568          else throw("no payments are expected")]
1571 -     if ((gH == gH))
1569 +     if ((gG == gG))
1572 1570          then {
1573 -             let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1574 -             if ((eS == eS))
1571 +             let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1572 +             if ((eR == eR))
1575 1573                  then {
1576 -                     let hM = invoke(bv, "unstake", [toBase58String(bm), hQ], nil)
1577 -                     if ((hM == hM))
1574 +                     let hL = invoke(bu, "unstake", [toBase58String(bl), hP], nil)
1575 +                     if ((hL == hL))
1578 1576                          then {
1579 -                             let hS = de(toBase58String(cQ.transactionId), toBase58String(bm), hQ, cQ.caller)
1580 -                             let dA = hS._1
1581 -                             let dB = hS._2
1582 -                             let dC = hS._10
1583 -                             let hT = [if ((dA >= hR))
1577 +                             let hR = dd(toBase58String(cP.transactionId), toBase58String(bl), hP, cP.caller)
1578 +                             let dz = hR._1
1579 +                             let dA = hR._2
1580 +                             let dB = hR._10
1581 +                             let hS = [if ((dz >= hQ))
1584 1582                                  then true
1585 -                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hR)], "")), if ((dB >= hG))
1583 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hQ)], "")), if ((dA >= hF))
1586 1584                                  then true
1587 -                                 else throw(makeString(["price asset amount to receive is less than ", toString(hG)], ""))]
1588 -                             if ((hT == hT))
1585 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(hF)], ""))]
1586 +                             if ((hS == hS))
1589 1587                                  then {
1590 -                                     let hH = invoke(aR, "burn", [hQ], [AttachedPayment(bm, hQ)])
1591 -                                     if ((hH == hH))
1588 +                                     let hG = invoke(aQ, "burn", [hP], [AttachedPayment(bl, hP)])
1589 +                                     if ((hG == hG))
1592 1590                                          then {
1593 -                                             let hU = eT(-(dA), -(dB), 0)
1594 -                                             let gj = hU._1
1595 -                                             let eK = hU._2
1596 -                                             let gk = eX(eS, eK)
1597 -                                             if ((gk == gk))
1598 -                                                 then (dC ++ gj)
1591 +                                             let hT = eS(-(dz), -(dA), 0)
1592 +                                             let gi = hT._1
1593 +                                             let eJ = hT._2
1594 +                                             let gj = eW(eR, eJ)
1595 +                                             if ((gj == gj))
1596 +                                                 then (dB ++ gi)
1599 1597                                                  else throw("Strict value is not equal to itself.")
1600 1598                                              }
1601 1599                                          else throw("Strict value is not equal to itself.")
1611 1609  
1612 1610  
1613 1611  
1614 - @Callable(cQ)
1615 - func unstakeAndGetOneTknV2 (hQ,fM,fN) = {
1616 -     let hh = {
1617 -         let aT = invoke(aR, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1618 -         if ($isInstanceOf(aT, "Boolean"))
1619 -             then aT
1620 -             else throw(($getType(aT) + " couldn't be cast to Boolean"))
1612 + @Callable(cP)
1613 + func unstakeAndGetOneTknV2 (hP,fL,fM) = {
1614 +     let hg = {
1615 +         let aS = invoke(aQ, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1616 +         if ($isInstanceOf(aS, "Boolean"))
1617 +             then aS
1618 +             else throw(($getType(aS) + " couldn't be cast to Boolean"))
1621 1619          }
1622 -     let ht = if (if (aW())
1620 +     let hs = if (if (aV())
1623 1621          then true
1624 -         else (bl == t))
1622 +         else (bk == s))
1625 1623          then true
1626 -         else hh
1627 -     let gH = [if (if (!(ht))
1624 +         else hg
1625 +     let gG = [if (if (!(hs))
1628 1626          then true
1629 -         else gp(cQ))
1627 +         else go(cP))
1630 1628          then true
1631 -         else aO("get operation is blocked by admin"), if ((size(cQ.payments) == 0))
1629 +         else aN("get operation is blocked by admin"), if ((size(cP.payments) == 0))
1632 1630          then true
1633 -         else aO("no payments are expected")]
1634 -     if ((gH == gH))
1631 +         else aN("no payments are expected")]
1632 +     if ((gG == gG))
1635 1633          then {
1636 -             let hK = bt()
1637 -             let gX = bm
1638 -             let hL = valueOrErrorMessage(addressFromString(hK[D]), "Wr st addr")
1639 -             let hM = invoke(hL, "unstake", [toBase58String(gX), hQ], nil)
1640 -             if ((hM == hM))
1634 +             let hJ = bs()
1635 +             let gW = bl
1636 +             let hK = valueOrErrorMessage(addressFromString(hJ[C]), "Wr st addr")
1637 +             let hL = invoke(hK, "unstake", [toBase58String(gW), hP], nil)
1638 +             if ((hL == hL))
1641 1639                  then {
1642 -                     let hV = fL(fM, fN, [AttachedPayment(gX, hQ)], cQ.caller, cQ.originCaller, cQ.transactionId)
1643 -                     let dC = hV._1
1644 -                     let fW = hV._2
1645 -                     $Tuple2(dC, fW)
1640 +                     let hU = fK(fL, fM, [AttachedPayment(gW, hP)], cP.caller, cP.originCaller, cP.transactionId)
1641 +                     let dB = hU._1
1642 +                     let fV = hU._2
1643 +                     $Tuple2(dB, fV)
1646 1644                      }
1647 1645                  else throw("Strict value is not equal to itself.")
1648 1646              }
1651 1649  
1652 1650  
1653 1651  
1654 - @Callable(cQ)
1655 - func putOneTknV2WithBonusREADONLY (hW,hX) = {
1656 -     let hY = fq(hW, hX, "", "", true)
1657 -     let fF = hY._1
1658 -     let dC = hY._2
1659 -     let cy = hY._3
1660 -     let fK = hY._4
1661 -     $Tuple2(nil, $Tuple3(fF, cy, fK))
1652 + @Callable(cP)
1653 + func putOneTknV2WithBonusREADONLY (hV,hW) = {
1654 +     let hX = fp(hV, hW, "", "", true)
1655 +     let fE = hX._1
1656 +     let dB = hX._2
1657 +     let cx = hX._3
1658 +     let fJ = hX._4
1659 +     $Tuple2(nil, $Tuple3(fE, cx, fJ))
1662 1660      }
1663 1661  
1664 1662  
1665 1663  
1666 - @Callable(cQ)
1667 - func putOneTknV2WithoutTakeFeeREADONLY (hW,hX) = {
1668 -     let hZ = fq(hW, hX, "", "", false)
1669 -     let fF = hZ._1
1670 -     let dC = hZ._2
1671 -     let cy = hZ._3
1672 -     let fK = hZ._4
1673 -     $Tuple2(nil, $Tuple3(fF, cy, fK))
1664 + @Callable(cP)
1665 + func putOneTknV2WithoutTakeFeeREADONLY (hV,hW) = {
1666 +     let hY = fp(hV, hW, "", "", false)
1667 +     let fE = hY._1
1668 +     let dB = hY._2
1669 +     let cx = hY._3
1670 +     let fJ = hY._4
1671 +     $Tuple2(nil, $Tuple3(fE, cx, fJ))
1674 1672      }
1675 1673  
1676 1674  
1677 1675  
1678 - @Callable(cQ)
1679 - func activate (ia,ib) = if ((toString(cQ.caller) != toString(aR)))
1676 + @Callable(cP)
1677 + func activate (hZ,ia) = if ((toString(cP.caller) != toString(aQ)))
1680 1678      then throw("denied")
1681 -     else $Tuple2([StringEntry(ak(), ia), StringEntry(al(), ib)], "success")
1679 +     else $Tuple2([StringEntry(aj(), hZ), StringEntry(ak(), ia)], "success")
1682 1680  
1683 1681  
1684 1682  
1685 - @Callable(cQ)
1686 - func setS (ic,hN) = if ((toString(cQ.caller) != aK(this, an())))
1687 -     then go
1688 -     else [StringEntry(ic, hN)]
1683 + @Callable(cP)
1684 + func setS (ib,hM) = if ((toString(cP.caller) != aJ(this, am())))
1685 +     then gn
1686 +     else [StringEntry(ib, hM)]
1689 1687  
1690 1688  
1691 1689  
1692 - @Callable(cQ)
1693 - func setI (ic,hN) = if ((toString(cQ.caller) != aK(this, an())))
1694 -     then go
1695 -     else [IntegerEntry(ic, hN)]
1690 + @Callable(cP)
1691 + func setI (ib,hM) = if ((toString(cP.caller) != aJ(this, am())))
1692 +     then gn
1693 +     else [IntegerEntry(ib, hM)]
1696 1694  
1697 1695  
1698 1696  
1699 - @Callable(cQ)
1700 - func getPoolConfigWrapperREADONLY () = $Tuple2(nil, aZ())
1697 + @Callable(cP)
1698 + func getPoolConfigWrapperREADONLY () = $Tuple2(nil, aY())
1701 1699  
1702 1700  
1703 1701  
1704 - @Callable(cQ)
1705 - func getAccBalanceWrapperREADONLY (bP) = $Tuple2(nil, bO(bP))
1702 + @Callable(cP)
1703 + func getAccBalanceWrapperREADONLY (bO) = $Tuple2(nil, bN(bO))
1706 1704  
1707 1705  
1708 1706  
1709 - @Callable(cQ)
1710 - func calcPricesWrapperREADONLY (ci,cj,cn) = {
1711 -     let id = cm(ci, cj, cn)
1712 -     $Tuple2(nil, [toString(id[0]), toString(id[1]), toString(id[2])])
1707 + @Callable(cP)
1708 + func calcPricesWrapperREADONLY (ch,ci,cm) = {
1709 +     let ic = cl(ch, ci, cm)
1710 +     $Tuple2(nil, [toString(ic[0]), toString(ic[1]), toString(ic[2])])
1713 1711      }
1714 1712  
1715 1713  
1716 1714  
1717 - @Callable(cQ)
1718 - func fromX18WrapperREADONLY (N,ie) = $Tuple2(nil, M(parseBigIntValue(N), ie))
1715 + @Callable(cP)
1716 + func fromX18WrapperREADONLY (M,id) = $Tuple2(nil, L(parseBigIntValue(M), id))
1719 1717  
1720 1718  
1721 1719  
1722 - @Callable(cQ)
1723 - func toX18WrapperREADONLY (J,K) = $Tuple2(nil, toString(I(J, K)))
1720 + @Callable(cP)
1721 + func toX18WrapperREADONLY (I,J) = $Tuple2(nil, toString(H(I, J)))
1724 1722  
1725 1723  
1726 1724  
1727 - @Callable(cQ)
1728 - func calcPriceBigIntWrapperREADONLY (bR,bS) = $Tuple2(nil, toString(bQ(parseBigIntValue(bR), parseBigIntValue(bS))))
1725 + @Callable(cP)
1726 + func calcPriceBigIntWrapperREADONLY (bQ,bR) = $Tuple2(nil, toString(bP(parseBigIntValue(bQ), parseBigIntValue(bR))))
1729 1727  
1730 1728  
1731 1729  
1732 - @Callable(cQ)
1733 - func estimatePutOperationWrapperREADONLY (df,bX,dE,dF,dG,dH,if,dI,dJ) = $Tuple2(nil, dD(df, bX, dE, dF, dG, dH, if, dI, dJ, true, false, 0, ""))
1730 + @Callable(cP)
1731 + func estimatePutOperationWrapperREADONLY (de,bW,dD,dE,dF,dG,ie,dH,dI) = $Tuple2(nil, dC(de, bW, dD, dE, dF, dG, ie, dH, dI, true, false, 0, ""))
1734 1732  
1735 1733  
1736 1734  
1737 - @Callable(cQ)
1738 - func estimateGetOperationWrapperREADONLY (df,ig,dh,if) = {
1739 -     let dY = de(df, ig, dh, addressFromStringValue(if))
1740 -     $Tuple2(nil, $Tuple10(dY._1, dY._2, dY._3, dY._4, dY._5, dY._6, dY._7, toString(dY._8), dY._9, dY._10))
1735 + @Callable(cP)
1736 + func estimateGetOperationWrapperREADONLY (de,if,dg,ie) = {
1737 +     let dX = dd(de, if, dg, addressFromStringValue(ie))
1738 +     $Tuple2(nil, $Tuple10(dX._1, dX._2, dX._3, dX._4, dX._5, dX._6, dX._7, toString(dX._8), dX._9, dX._10))
1741 1739      }
1742 1740  
1743 1741  
1744 - @Verifier(ih)
1745 - func ii () = {
1746 -     let ij = {
1747 -         let gm = gl()
1748 -         if ($isInstanceOf(gm, "ByteVector"))
1742 + @Verifier(ig)
1743 + func ih () = {
1744 +     let ii = {
1745 +         let gl = gk()
1746 +         if ($isInstanceOf(gl, "ByteVector"))
1749 1747              then {
1750 -                 let gq = gm
1751 -                 gq
1748 +                 let gp = gl
1749 +                 gp
1752 1750                  }
1753 -             else if ($isInstanceOf(gm, "Unit"))
1754 -                 then ih.senderPublicKey
1751 +             else if ($isInstanceOf(gl, "Unit"))
1752 +                 then ig.senderPublicKey
1755 1753                  else throw("Match error")
1756 1754          }
1757 -     let gm = ih
1758 -     if ($isInstanceOf(gm, "Order"))
1755 +     let gl = ig
1756 +     if ($isInstanceOf(gl, "Order"))
1759 1757          then {
1760 -             let fa = gm
1761 -             let ik = aX()
1762 -             let il = eZ(fa)
1763 -             let aG = il._1
1764 -             let aH = il._2
1765 -             let aI = sigVerify(fa.bodyBytes, fa.proofs[0], fa.senderPublicKey)
1766 -             let aJ = sigVerify(fa.bodyBytes, fa.proofs[1], ik)
1767 -             if (if (if (aG)
1758 +             let eZ = gl
1759 +             let ij = aW()
1760 +             let ik = eY(eZ)
1761 +             let aF = ik._1
1762 +             let aG = ik._2
1763 +             let aH = sigVerify(eZ.bodyBytes, eZ.proofs[0], eZ.senderPublicKey)
1764 +             let aI = sigVerify(eZ.bodyBytes, eZ.proofs[1], ij)
1765 +             if (if (if (aF)
1766 +                 then aH
1767 +                 else false)
1768 1768                  then aI
1769 1769                  else false)
1770 -                 then aJ
1771 -                 else false)
1772 1770                  then true
1773 -                 else aF(aG, aH, aI, aJ)
1771 +                 else aE(aF, aG, aH, aI)
1774 1772              }
1775 -         else if ($isInstanceOf(gm, "SetScriptTransaction"))
1773 +         else if ($isInstanceOf(gl, "SetScriptTransaction"))
1776 1774              then {
1777 -                 let cD = gm
1778 -                 if (sigVerify(ih.bodyBytes, ih.proofs[0], ij))
1775 +                 let cC = gl
1776 +                 if (sigVerify(ig.bodyBytes, ig.proofs[0], ii))
1779 1777                      then true
1780 1778                      else {
1781 -                         let im = blake2b256(value(cD.script))
1782 -                         let in = fromBase64String(value(getString(aR, aD())))
1783 -                         let io = scriptHash(this)
1784 -                         if ((in == im))
1785 -                             then (io != im)
1779 +                         let il = blake2b256(value(cC.script))
1780 +                         let im = fromBase64String(value(getString(aQ, aC())))
1781 +                         let in = scriptHash(this)
1782 +                         if ((im == il))
1783 +                             then (in != il)
1786 1784                              else false
1787 1785                          }
1788 1786                  }
1789 -             else sigVerify(ih.bodyBytes, ih.proofs[0], ij)
1787 +             else sigVerify(ig.bodyBytes, ig.proofs[0], ii)
1790 1788      }
1791 1789  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let a = 100000000
5 5  
6 6  let b = toBigInt(100000000)
7 7  
8 8  let c = toBigInt(1000000000000000000)
9 9  
10 10  let d = toBigInt(0)
11 11  
12 12  let e = toBigInt(0)
13 13  
14 14  let f = toBigInt(1)
15 15  
16 16  let g = toBigInt(2)
17 17  
18 18  let h = toBigInt(3)
19 19  
20 20  let i = toBigInt(4)
21 21  
22 22  let j = toBigInt((a - ((a * 1) / a)))
23 23  
24 24  let k = "WAVES"
25 25  
26 - let l = 1
26 + let l = "100"
27 27  
28 - let m = "100"
28 + let m = "1"
29 29  
30 - let n = "1"
30 + let n = "__"
31 31  
32 - let o = "__"
32 + let o = ""
33 33  
34 - let p = ""
34 + let p = 1
35 35  
36 - let q = 1
36 + let q = 2
37 37  
38 - let r = 2
38 + let r = 3
39 39  
40 - let s = 3
40 + let s = 4
41 41  
42 - let t = 4
42 + let t = 1
43 43  
44 - let u = 1
44 + let u = 2
45 45  
46 - let v = 2
46 + let v = 3
47 47  
48 - let w = 3
48 + let w = 4
49 49  
50 - let x = 4
50 + let x = 5
51 51  
52 - let y = 5
52 + let y = 6
53 53  
54 - let z = 6
54 + let z = 7
55 55  
56 - let A = 7
56 + let A = 8
57 57  
58 - let B = 8
58 + let B = 9
59 59  
60 - let C = 9
60 + let C = 1
61 61  
62 - let D = 1
62 + let D = 6
63 63  
64 - let E = 6
64 + let E = 7
65 65  
66 - let F = 7
66 + let F = 10
67 67  
68 - let G = 10
68 + let G = fraction(10, a, 10000)
69 69  
70 - let H = fraction(10, a, 10000)
71 - 
72 - func I (J,K) = fraction(toBigInt(J), c, toBigInt(K))
70 + func H (I,J) = fraction(toBigInt(I), c, toBigInt(J))
73 71  
74 72  
75 - func L (J,K) = fraction(J, c, K)
73 + func K (I,J) = fraction(I, c, J)
76 74  
77 75  
78 - func M (N,O) = toInt(fraction(N, toBigInt(O), c))
76 + func L (M,N) = toInt(fraction(M, toBigInt(N), c))
79 77  
80 78  
81 - func P (N,O,Q) = toInt(fraction(N, toBigInt(O), c, Q))
79 + func O (M,N,P) = toInt(fraction(M, toBigInt(N), c, P))
82 80  
83 81  
84 - func R (J,K) = fraction(J, c, toBigInt(K))
82 + func Q (I,J) = fraction(I, c, toBigInt(J))
85 83  
86 84  
87 - func S (N,O) = fraction(N, toBigInt(O), c)
85 + func R (M,N) = fraction(M, toBigInt(N), c)
88 86  
89 87  
90 - func T (U,V,W) = fraction(U, V, W)
88 + func S (T,U,V) = fraction(T, U, V)
91 89  
92 90  
93 - func X (N) = if ((d > N))
94 -     then -(N)
95 -     else N
91 + func W (M) = if ((d > M))
92 +     then -(M)
93 +     else M
96 94  
97 95  
98 - func Y (N) = if ((d > N))
99 -     then -(N)
100 -     else N
96 + func X (M) = if ((d > M))
97 +     then -(M)
98 +     else M
101 99  
102 100  
103 - func Z () = "%s__factoryContract"
101 + func Y () = "%s__factoryContract"
104 102  
105 103  
106 - func aa () = "%s__managerPublicKey"
104 + func Z () = "%s__managerPublicKey"
107 105  
108 106  
109 - func ab () = "%s__pendingManagerPublicKey"
107 + func aa () = "%s__pendingManagerPublicKey"
110 108  
111 109  
112 - func ac () = "%s%s__price__last"
110 + func ab () = "%s%s__price__last"
113 111  
114 112  
115 - func ad (ae,af) = makeString(["%s%s%d%d__price__history", toString(ae), toString(af)], o)
113 + func ac (ad,ae) = makeString(["%s%s%d%d__price__history", toString(ad), toString(ae)], n)
116 114  
117 115  
118 - func ag (ah,ai) = ((("%s%s%s__P__" + ah) + "__") + ai)
116 + func af (ag,ah) = ((("%s%s%s__P__" + ag) + "__") + ah)
119 117  
120 118  
121 - func aj (ah,ai) = ((("%s%s%s__G__" + ah) + "__") + ai)
119 + func ai (ag,ah) = ((("%s%s%s__G__" + ag) + "__") + ah)
122 120  
123 121  
124 - func ak () = "%s__amountAsset"
122 + func aj () = "%s__amountAsset"
125 123  
126 124  
127 - func al () = "%s__priceAsset"
125 + func ak () = "%s__priceAsset"
128 126  
129 127  
130 - func am () = "%s__amp"
128 + func al () = "%s__amp"
131 129  
132 130  
133 - func an () = "%s__addonAddr"
131 + func am () = "%s__addonAddr"
134 132  
135 133  
136 - let ao = "%s__fee"
134 + let an = "%s__fee"
137 135  
138 - let ap = valueOrElse(getInteger(this, ao), H)
136 + let ao = valueOrElse(getInteger(this, an), G)
139 137  
140 - let aq = makeString(["%s", "dLp"], o)
138 + let ap = makeString(["%s", "dLp"], n)
141 139  
142 - let ar = makeString(["%s", "dLpRefreshedHeight"], o)
140 + let aq = makeString(["%s", "dLpRefreshedHeight"], n)
143 141  
144 - let as = makeString(["%s", "refreshDLpDelay"], o)
142 + let ar = makeString(["%s", "refreshDLpDelay"], n)
145 143  
146 - let at = 30
144 + let as = 30
147 145  
148 - let au = valueOrElse(getInteger(this, as), at)
146 + let at = valueOrElse(getInteger(this, ar), as)
149 147  
150 - func av () = "%s__factoryConfig"
148 + func au () = "%s__factoryConfig"
151 149  
152 150  
153 - func aw () = "%s%s__matcher__publicKey"
151 + func av () = "%s%s__matcher__publicKey"
154 152  
155 153  
156 - func ax (ay,az) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
154 + func aw (ax,ay) = (((("%d%d%s__" + ax) + "__") + ay) + "__config")
157 155  
158 156  
159 - func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
157 + func az (aA) = ("%s%s%s__mappings__baseAsset2internalId__" + aA)
160 158  
161 159  
162 - func aC () = "%s__shutdown"
160 + func aB () = "%s__shutdown"
163 161  
164 162  
165 - func aD () = "%s__allowedLpStableScriptHash"
163 + func aC () = "%s__allowedLpStableScriptHash"
166 164  
167 165  
168 - func aE () = "%s__feeCollectorAddress"
166 + func aD () = "%s__feeCollectorAddress"
169 167  
170 168  
171 - func aF (aG,aH,aI,aJ) = throw((((((((("order validation failed: orderValid=" + toString(aG)) + " (") + aH) + ")") + " senderValid=") + toString(aI)) + " matcherValid=") + toString(aJ)))
169 + func aE (aF,aG,aH,aI) = throw((((((((("order validation failed: orderValid=" + toString(aF)) + " (") + aG) + ")") + " senderValid=") + toString(aH)) + " matcherValid=") + toString(aI)))
172 170  
173 171  
174 - func aK (aL,aM) = valueOrErrorMessage(getString(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
172 + func aJ (aK,aL) = valueOrErrorMessage(getString(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
175 173  
176 174  
177 - func aN (aL,aM) = valueOrErrorMessage(getInteger(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
175 + func aM (aK,aL) = valueOrErrorMessage(getInteger(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
178 176  
179 177  
180 - func aO (aP) = throw(makeString(["lp_stable.ride:", aP], " "))
178 + func aN (aO) = throw(makeString(["lp_stable.ride:", aO], " "))
181 179  
182 180  
183 - func aQ (aP) = makeString(["lp_stable.ride:", aP], " ")
181 + func aP (aO) = makeString(["lp_stable.ride:", aO], " ")
184 182  
185 183  
186 - let aR = addressFromStringValue(aK(this, Z()))
184 + let aQ = addressFromStringValue(aJ(this, Y()))
187 185  
188 - let aS = {
189 -     let aT = invoke(aR, "getInFeeREADONLY", [toString(this)], nil)
190 -     if ($isInstanceOf(aT, "Int"))
191 -         then aT
192 -         else throw(($getType(aT) + " couldn't be cast to Int"))
186 + let aR = {
187 +     let aS = invoke(aQ, "getInFeeREADONLY", [toString(this)], nil)
188 +     if ($isInstanceOf(aS, "Int"))
189 +         then aS
190 +         else throw(($getType(aS) + " couldn't be cast to Int"))
193 191      }
194 192  
195 - let aU = {
196 -     let aT = invoke(aR, "getOutFeeREADONLY", [toString(this)], nil)
197 -     if ($isInstanceOf(aT, "Int"))
198 -         then aT
199 -         else throw(($getType(aT) + " couldn't be cast to Int"))
193 + let aT = {
194 +     let aS = invoke(aQ, "getOutFeeREADONLY", [toString(this)], nil)
195 +     if ($isInstanceOf(aS, "Int"))
196 +         then aS
197 +         else throw(($getType(aS) + " couldn't be cast to Int"))
200 198      }
201 199  
202 - let aV = aK(this, am())
200 + let aU = aJ(this, al())
203 201  
204 - func aW () = valueOrElse(getBoolean(aR, aC()), false)
202 + func aV () = valueOrElse(getBoolean(aQ, aB()), false)
205 203  
206 204  
207 - func aX () = fromBase58String(aK(aR, aw()))
205 + func aW () = fromBase58String(aJ(aQ, av()))
208 206  
209 207  
210 - let aY = addressFromStringValue(aK(aR, aE()))
208 + let aX = addressFromStringValue(aJ(aQ, aD()))
211 209  
212 - func aZ () = {
213 -     let ba = aK(this, ak())
214 -     let bb = aK(this, al())
215 -     let bc = aN(aR, aA(bb))
216 -     let ay = aN(aR, aA(ba))
217 -     split(aK(aR, ax(toString(ay), toString(bc))), o)
210 + func aY () = {
211 +     let aZ = aJ(this, aj())
212 +     let ba = aJ(this, ak())
213 +     let bb = aM(aQ, az(ba))
214 +     let ax = aM(aQ, az(aZ))
215 +     split(aJ(aQ, aw(toString(ax), toString(bb))), n)
218 216      }
219 217  
220 218  
221 - func bd (be) = if ((be == k))
219 + func bc (bd) = if ((bd == k))
222 220      then unit
223 -     else fromBase58String(be)
221 +     else fromBase58String(bd)
224 222  
225 223  
226 - func bf (be) = if ((be == unit))
224 + func be (bd) = if ((bd == unit))
227 225      then k
228 -     else toBase58String(value(be))
226 +     else toBase58String(value(bd))
229 227  
230 228  
231 - func bg (bh) = $Tuple9(addressFromStringValue(bh[u]), parseIntValue(bh[v]), fromBase58String(bh[w]), bd(bh[x]), bd(bh[y]), parseIntValue(bh[z]), parseIntValue(bh[A]), fromBase58String(bh[B]), fromBase58String(bh[C]))
229 + func bf (bg) = $Tuple9(addressFromStringValue(bg[t]), parseIntValue(bg[u]), fromBase58String(bg[v]), bc(bg[w]), bc(bg[x]), parseIntValue(bg[y]), parseIntValue(bg[z]), fromBase58String(bg[A]), fromBase58String(bg[B]))
232 230  
233 231  
234 - let bi = bg(aZ())
232 + let bh = bf(aY())
235 233  
236 - let bj = bi
234 + let bi = bh
237 235  
238 - let bk = bj._1
236 + let bj = bi._1
239 237  
240 - let bl = bj._2
238 + let bk = bi._2
241 239  
242 - let bm = bj._3
240 + let bl = bi._3
243 241  
244 - let bn = bj._4
242 + let bm = bi._4
245 243  
246 - let bo = bj._5
244 + let bn = bi._5
247 245  
248 - let bp = bj._6
246 + let bo = bi._6
249 247  
250 - let bq = bj._7
248 + let bp = bi._7
251 249  
252 - let br = bj._8
250 + let bq = bi._8
253 251  
254 - let bs = bj._9
252 + let br = bi._9
255 253  
256 - func bt () = split(aK(aR, av()), o)
254 + func bs () = split(aJ(aQ, au()), n)
257 255  
258 256  
259 - let bu = bt()
257 + let bt = bs()
260 258  
261 - let bv = valueOrErrorMessage(addressFromString(bu[D]), "Invalid staking contract address")
259 + let bu = valueOrErrorMessage(addressFromString(bt[C]), "Invalid staking contract address")
262 260  
263 - let bw = valueOrErrorMessage(addressFromString(bu[F]), "Invalid slipage contract address")
261 + let bv = valueOrErrorMessage(addressFromString(bt[E]), "Invalid slipage contract address")
264 262  
265 - let bx = valueOrErrorMessage(addressFromString(bu[G]), "Invalid gwx contract address")
263 + let bw = valueOrErrorMessage(addressFromString(bt[F]), "Invalid gwx contract address")
266 264  
267 - let by = valueOrErrorMessage(addressFromString(bu[E]), "Invalid gwx contract address")
265 + let bx = valueOrErrorMessage(addressFromString(bt[D]), "Invalid gwx contract address")
268 266  
269 - func bz (bA,bB,bC,bD,bE,bF,bG,bH,bI,bJ) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI), toString(bJ)], o)
267 + func by (bz,bA,bB,bC,bD,bE,bF,bG,bH,bI) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI)], n)
270 268  
271 269  
272 - func bK (bL,bM,bN,bD,bG,bH) = makeString(["%d%d%d%d%d%d", toString(bL), toString(bM), toString(bN), toString(bD), toString(bG), toString(bH)], o)
270 + func bJ (bK,bL,bM,bC,bF,bG) = makeString(["%d%d%d%d%d%d", toString(bK), toString(bL), toString(bM), toString(bC), toString(bF), toString(bG)], n)
273 271  
274 272  
275 - func bO (bP) = if ((bP == "WAVES"))
273 + func bN (bO) = if ((bO == "WAVES"))
276 274      then wavesBalance(this).available
277 -     else assetBalance(this, fromBase58String(bP))
275 +     else assetBalance(this, fromBase58String(bO))
278 276  
279 277  
280 - func bQ (bR,bS) = fraction(bR, c, bS)
278 + func bP (bQ,bR) = fraction(bQ, c, bR)
281 279  
282 280  
283 - func bT (bR,bS,Q) = fraction(bR, c, bS, Q)
281 + func bS (bQ,bR,P) = fraction(bQ, c, bR, P)
284 282  
285 283  
286 - func bU (bV,bW,bX) = {
287 -     let bY = fraction((bV - bW), b, bW)
288 -     let bZ = ((bX - X(bY)) > d)
289 -     if (!(bZ))
290 -         then throw(("Big slpg: " + toString(bY)))
291 -         else $Tuple2(bZ, min([bV, bW]))
284 + func bT (bU,bV,bW) = {
285 +     let bX = fraction((bU - bV), b, bV)
286 +     let bY = ((bW - W(bX)) > d)
287 +     if (!(bY))
288 +         then throw(("Big slpg: " + toString(bX)))
289 +         else $Tuple2(bY, min([bU, bV]))
292 290      }
293 291  
294 292  
295 - func ca (cb,cc,cd) = {
296 -     let bY = fraction(cc, b, cb)
297 -     let ce = (cd > bY)
298 -     if (if (ce)
293 + func bZ (ca,cb,cc) = {
294 +     let bX = fraction(cb, b, ca)
295 +     let cd = (cc > bX)
296 +     if (if (cd)
299 297          then true
300 -         else (cc > cb))
301 -         then throw(((((((toString(cc) + " ") + toString(cb)) + " ") + toString(bY)) + " ") + toString(cd)))
302 -         else ce
298 +         else (cb > ca))
299 +         then throw(((((((toString(cb) + " ") + toString(ca)) + " ") + toString(bX)) + " ") + toString(cc)))
300 +         else cd
303 301      }
304 302  
305 303  
306 - func cf (cg,ch,ci,cj) = {
307 -     let ck = I(ci, cg)
308 -     let cl = I(cj, ch)
309 -     bQ(cl, ck)
304 + func ce (cf,cg,ch,ci) = {
305 +     let cj = H(ch, cf)
306 +     let ck = H(ci, cg)
307 +     bP(ck, cj)
310 308      }
311 309  
312 310  
313 - func cm (ci,cj,cn) = {
311 + func cl (ch,ci,cm) = {
312 +     let cn = bo
314 313      let co = bp
315 -     let cp = bq
316 -     let cq = cf(co, cp, ci, cj)
317 -     let bS = I(ci, co)
318 -     let bR = I(cj, cp)
319 -     let cr = I(cn, a)
320 -     let cs = bQ(bS, cr)
321 -     let ct = bQ(bR, cr)
322 - [cq, cs, ct]
314 +     let cp = ce(cn, co, ch, ci)
315 +     let bR = H(ch, cn)
316 +     let bQ = H(ci, co)
317 +     let cq = H(cm, a)
318 +     let cr = bP(bR, cq)
319 +     let cs = bP(bQ, cq)
320 + [cp, cr, cs]
323 321      }
324 322  
325 323  
326 - func cu (ci,cj,cn) = {
327 -     let cv = cm(ci, cj, cn)
328 - [M(cv[0], a), M(cv[1], a), M(cv[2], a)]
324 + func ct (ch,ci,cm) = {
325 +     let cu = cl(ch, ci, cm)
326 + [L(cu[0], a), L(cu[1], a), L(cu[2], a)]
329 327      }
330 328  
331 329  
332 - func cw (cx,ap) = {
333 -     let cy = if ((ap == 0))
330 + func cv (cw,ao) = {
331 +     let cx = if ((ao == 0))
334 332          then 0
335 -         else fraction(cx, ap, a)
336 -     $Tuple2((cx - cy), cy)
333 +         else fraction(cw, ao, a)
334 +     $Tuple2((cw - cx), cx)
337 335      }
338 336  
339 337  
340 - func cz (cA) = {
341 -     let cB = cA[0]
342 -     let cC = cA[1]
343 -     let cD = (cB + cC)
344 -     if ((cD == e))
338 + func cy (cz) = {
339 +     let cA = cz[0]
340 +     let cB = cz[1]
341 +     let cC = (cA + cB)
342 +     if ((cC == e))
345 343          then e
346 344          else {
347 -             let cE = parseIntValue(aV)
348 -             let cF = (cE * 2)
349 -             let cv = fraction(cB, cC, f)
350 -             let cG = fraction(cv, i, f)
351 -             let cH = fraction(toBigInt(cF), cD, f)
352 -             let cI = toBigInt((cF - 1))
353 -             func cJ (cK) =             {
354 -                 let cL = fraction(cK, cK, f)
355 -                 let cM = fraction(cL, cK, f)
356 -                 let cN = fraction(cM, f, cG)
357 -                 fraction((cH + fraction(cN, g, f)), cK, (fraction(cI, cK, f) + fraction(h, cN, f)))
345 +             let cD = parseIntValue(aU)
346 +             let cE = (cD * 2)
347 +             let cu = fraction(cA, cB, f)
348 +             let cF = fraction(cu, i, f)
349 +             let cG = fraction(toBigInt(cE), cC, f)
350 +             let cH = toBigInt((cE - 1))
351 +             func cI (cJ) =             {
352 +                 let cK = fraction(cJ, cJ, f)
353 +                 let cL = fraction(cK, cJ, f)
354 +                 let cM = fraction(cL, f, cF)
355 +                 fraction((cG + fraction(cM, g, f)), cJ, (fraction(cH, cJ, f) + fraction(h, cM, f)))
358 356                  }
359 357  
360 -             func cO (cP,cQ) =             if (cP._2)
361 -                 then cP
358 +             func cN (cO,cP) =             if (cO._2)
359 +                 then cO
362 360                  else {
363 -                     let cK = cP._1
364 -                     let cR = cJ(cK)
365 -                     let cS = (cR - value(cK))
366 -                     let cT = if ((e > cS))
367 -                         then -(cS)
368 -                         else cS
369 -                     if ((f >= cT))
370 -                         then $Tuple2(cR, true)
371 -                         else $Tuple2(cR, false)
361 +                     let cJ = cO._1
362 +                     let cQ = cI(cJ)
363 +                     let cR = (cQ - value(cJ))
364 +                     let cS = if ((e > cR))
365 +                         then -(cR)
366 +                         else cR
367 +                     if ((f >= cS))
368 +                         then $Tuple2(cQ, true)
369 +                         else $Tuple2(cQ, false)
372 370                      }
373 371  
374 -             let cU = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
375 -             let cV = {
376 -                 let cW = cU
377 -                 let cX = size(cW)
378 -                 let cY = $Tuple2(cD, false)
379 -                 func cZ (da,db) =                 if ((db >= cX))
380 -                     then da
381 -                     else cO(da, cW[db])
372 +             let cT = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
373 +             let cU = {
374 +                 let cV = cT
375 +                 let cW = size(cV)
376 +                 let cX = $Tuple2(cC, false)
377 +                 func cY (cZ,da) =                 if ((da >= cW))
378 +                     then cZ
379 +                     else cN(cZ, cV[da])
382 380  
383 -                 func dc (da,db) =                 if ((db >= cX))
384 -                     then da
381 +                 func db (cZ,da) =                 if ((da >= cW))
382 +                     then cZ
385 383                      else throw("List size exceeds 15")
386 384  
387 -                 dc(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
385 +                 db(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cX, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
388 386                  }
389 -             let cK = cV._1
390 -             let dd = cV._2
391 -             if (dd)
392 -                 then cK
393 -                 else throw(("D calculation error, D = " + toString(cK)))
387 +             let cJ = cU._1
388 +             let dc = cU._2
389 +             if (dc)
390 +                 then cJ
391 +                 else throw(("D calculation error, D = " + toString(cJ)))
394 392              }
395 393      }
396 394  
397 395  
398 - func de (df,dg,dh,di) = {
399 -     let dj = bm
396 + func dd (de,df,dg,dh) = {
397 +     let di = bl
398 +     let dj = toBase58String(value(bm))
400 399      let dk = toBase58String(value(bn))
401 -     let dl = toBase58String(value(bo))
400 +     let dl = bo
402 401      let dm = bp
403 -     let dn = bq
404 -     let do = toString(bl)
405 -     let dp = valueOrErrorMessage(assetInfo(dj), "Wrong LP id").quantity
406 -     if ((toBase58String(dj) != dg))
402 +     let dn = toString(bk)
403 +     let do = valueOrErrorMessage(assetInfo(di), "Wrong LP id").quantity
404 +     if ((toBase58String(di) != df))
407 405          then throw("Wrong pmt asset")
408 406          else {
409 -             let dq = bO(dk)
410 -             let dr = I(dq, dm)
411 -             let ds = bO(dl)
412 -             let dt = I(ds, dn)
413 -             let du = bQ(dt, dr)
414 -             let dv = M(du, a)
415 -             let dw = I(dh, a)
416 -             let dx = I(dp, a)
417 -             let dy = fraction(dr, dw, dx)
418 -             let dz = fraction(dt, dw, dx)
419 -             let dA = P(dy, dm, FLOOR)
420 -             let dB = P(dz, dn, FLOOR)
421 -             let dC = if ((df == ""))
407 +             let dp = bN(dj)
408 +             let dq = H(dp, dl)
409 +             let dr = bN(dk)
410 +             let ds = H(dr, dm)
411 +             let dt = bP(ds, dq)
412 +             let du = L(dt, a)
413 +             let dv = H(dg, a)
414 +             let dw = H(do, a)
415 +             let dx = fraction(dq, dv, dw)
416 +             let dy = fraction(ds, dv, dw)
417 +             let dz = O(dx, dl, FLOOR)
418 +             let dA = O(dy, dm, FLOOR)
419 +             let dB = if ((de == ""))
422 420                  then nil
423 -                 else [ScriptTransfer(di, dA, if ((dk == "WAVES"))
421 +                 else [ScriptTransfer(dh, dz, if ((dj == "WAVES"))
424 422                      then unit
425 -                     else fromBase58String(dk)), ScriptTransfer(di, dB, if ((dl == "WAVES"))
423 +                     else fromBase58String(dj)), ScriptTransfer(dh, dA, if ((dk == "WAVES"))
426 424                      then unit
427 -                     else fromBase58String(dl)), StringEntry(aj(toString(di), df), bK(dA, dB, dh, dv, height, lastBlock.timestamp)), IntegerEntry(ac(), dv), IntegerEntry(ad(height, lastBlock.timestamp), dv)]
428 -             $Tuple10(dA, dB, dk, dl, dq, ds, dp, du, do, dC)
425 +                     else fromBase58String(dk)), StringEntry(ai(toString(dh), de), bJ(dz, dA, dg, du, height, lastBlock.timestamp)), IntegerEntry(ab(), du), IntegerEntry(ac(height, lastBlock.timestamp), du)]
426 +             $Tuple10(dz, dA, dj, dk, dp, dr, do, dt, dn, dB)
429 427              }
430 428      }
431 429  
432 430  
433 - func dD (df,bX,dE,dF,dG,dH,di,dI,dJ,dK,dL,dM,dN) = {
434 -     let dj = bm
431 + func dC (de,bW,dD,dE,dF,dG,dh,dH,dI,dJ,dK,dL,dM) = {
432 +     let di = bl
433 +     let dN = toBase58String(value(bm))
435 434      let dO = toBase58String(value(bn))
436 -     let dP = toBase58String(value(bo))
435 +     let dP = bq
437 436      let dQ = br
438 -     let dR = bs
437 +     let dR = bo
439 438      let dS = bp
440 -     let dT = bq
441 -     let do = toString(bl)
442 -     let dU = valueOrErrorMessage(assetInfo(dj), "Wr lp as").quantity
443 -     let dq = if (dI)
444 -         then bO(dO)
445 -         else if (if (dK)
446 -             then (dN == dO)
439 +     let dn = toString(bk)
440 +     let dT = valueOrErrorMessage(assetInfo(di), "Wr lp as").quantity
441 +     let dp = if (dH)
442 +         then bN(dN)
443 +         else if (if (dJ)
444 +             then (dM == dN)
447 445              else false)
448 -             then (bO(dO) - dM)
449 -             else if (dK)
450 -                 then bO(dO)
451 -                 else (bO(dO) - dE)
452 -     let ds = if (dI)
453 -         then bO(dP)
454 -         else if (if (dK)
455 -             then (dN == dP)
446 +             then (bN(dN) - dL)
447 +             else if (dJ)
448 +                 then bN(dN)
449 +                 else (bN(dN) - dD)
450 +     let dr = if (dH)
451 +         then bN(dO)
452 +         else if (if (dJ)
453 +             then (dM == dO)
456 454              else false)
457 -             then (bO(dP) - dM)
458 -             else if (dK)
459 -                 then bO(dP)
460 -                 else (bO(dP) - dG)
461 -     let dV = I(dE, dS)
462 -     let dW = I(dG, dT)
463 -     let dX = bQ(dW, dV)
464 -     let dr = I(dq, dS)
465 -     let dt = I(ds, dT)
466 -     let cc = cz([dr, dt])
467 -     let dY = if ((dU == 0))
455 +             then (bN(dO) - dL)
456 +             else if (dJ)
457 +                 then bN(dO)
458 +                 else (bN(dO) - dF)
459 +     let dU = H(dD, dR)
460 +     let dV = H(dF, dS)
461 +     let dW = bP(dV, dU)
462 +     let dq = H(dp, dR)
463 +     let ds = H(dr, dS)
464 +     let cb = cy([dq, ds])
465 +     let dX = if ((dT == 0))
468 466          then {
469 -             let cb = cz([(dr + dV), (dt + dW)])
470 -             let dZ = if ((cb > cc))
467 +             let ca = cy([(dq + dU), (ds + dV)])
468 +             let dY = if ((ca > cb))
471 469                  then true
472 470                  else throw("D1 should be greater than D0")
473 -             if ((dZ == dZ))
471 +             if ((dY == dY))
474 472                  then {
475 -                     let du = d
476 -                     let ea = d
477 -                     let cr = cb
478 -                     $Tuple5(M(cr, a), M(dV, dS), M(dW, dT), bQ((dt + dW), (dr + dV)), ea)
473 +                     let dt = d
474 +                     let dZ = d
475 +                     let cq = ca
476 +                     $Tuple5(L(cq, a), L(dU, dR), L(dV, dS), bP((ds + dV), (dq + dU)), dZ)
479 477                      }
480 478                  else throw("Strict value is not equal to itself.")
481 479              }
482 480          else {
483 -             let du = bQ(dt, dr)
484 -             let eb = fraction(X((du - dX)), c, du)
485 -             let ea = I(bX, a)
486 -             if (if (if (dL)
487 -                 then (du != d)
481 +             let dt = bP(ds, dq)
482 +             let ea = fraction(W((dt - dW)), c, dt)
483 +             let dZ = H(bW, a)
484 +             if (if (if (dK)
485 +                 then (dt != d)
488 486                  else false)
489 -                 then (eb > ea)
487 +                 then (ea > dZ)
490 488                  else false)
491 -                 then throw(((("Price slippage " + toString(eb)) + " > ") + toString(ea)))
489 +                 then throw(((("Price slippage " + toString(ea)) + " > ") + toString(dZ)))
492 490                  else {
493 -                     let ec = I(dU, a)
494 -                     let ed = fraction(dV, bT(dt, dr, CEILING), c, CEILING)
495 -                     let ee = fraction(dW, c, bT(dt, dr, FLOOR), CEILING)
496 -                     let ef = if ((ed > dW))
497 -                         then $Tuple2(ee, dW)
498 -                         else $Tuple2(dV, ed)
499 -                     let eg = ef._1
500 -                     let eh = ef._2
501 -                     let cb = cz([(dr + eg), (dt + eh)])
502 -                     let dZ = if ((cb > cc))
491 +                     let eb = H(dT, a)
492 +                     let ec = fraction(dU, bS(ds, dq, CEILING), c, CEILING)
493 +                     let ed = fraction(dV, c, bS(ds, dq, FLOOR), CEILING)
494 +                     let ee = if ((ec > dV))
495 +                         then $Tuple2(ed, dV)
496 +                         else $Tuple2(dU, ec)
497 +                     let ef = ee._1
498 +                     let eg = ee._2
499 +                     let ca = cy([(dq + ef), (ds + eg)])
500 +                     let dY = if ((ca > cb))
503 501                          then true
504 502                          else throw("D1 should be greater than D0")
505 -                     if ((dZ == dZ))
503 +                     if ((dY == dY))
506 504                          then {
507 -                             let cr = fraction(ec, (cb - cc), cc)
508 -                             $Tuple5(P(cr, a, FLOOR), P(eg, dS, CEILING), P(eh, dT, CEILING), du, ea)
505 +                             let cq = fraction(eb, (ca - cb), cb)
506 +                             $Tuple5(O(cq, a, FLOOR), O(ef, dR, CEILING), O(eg, dS, CEILING), dt, dZ)
509 507                              }
510 508                          else throw("Strict value is not equal to itself.")
511 509                      }
512 510              }
513 -     let ei = dY._1
514 -     let ej = dY._2
515 -     let ek = dY._3
516 -     let dv = M(dY._4, a)
517 -     let el = M(dY._5, a)
518 -     if ((0 >= ei))
511 +     let eh = dX._1
512 +     let ei = dX._2
513 +     let ej = dX._3
514 +     let du = L(dX._4, a)
515 +     let ek = L(dX._5, a)
516 +     if ((0 >= eh))
519 517          then throw("LP <= 0")
520 518          else {
521 -             let em = if (!(dJ))
519 +             let el = if (!(dI))
522 520                  then 0
523 -                 else ei
524 -             let en = (dE - ej)
525 -             let eo = (dG - ek)
526 -             let ep = if (if (dK)
527 -                 then (dN == dO)
521 +                 else eh
522 +             let em = (dD - ei)
523 +             let en = (dF - ej)
524 +             let eo = if (if (dJ)
525 +                 then (dM == dN)
528 526                  else false)
529 -                 then $Tuple2(dM, 0)
530 -                 else if (if (dK)
531 -                     then (dN == dP)
527 +                 then $Tuple2(dL, 0)
528 +                 else if (if (dJ)
529 +                     then (dM == dO)
532 530                      else false)
533 -                     then $Tuple2(0, dM)
534 -                     else $Tuple2(ej, ek)
535 -             let eq = ep._1
536 -             let er = ep._2
537 -             let es = [IntegerEntry(ac(), dv), IntegerEntry(ad(height, lastBlock.timestamp), dv), StringEntry(ag(di, df), bz(eq, er, em, dv, bX, el, height, lastBlock.timestamp, en, eo))]
538 -             $Tuple13(ei, em, dv, dq, ds, dU, dj, do, es, en, eo, dF, dH)
531 +                     then $Tuple2(0, dL)
532 +                     else $Tuple2(ei, ej)
533 +             let ep = eo._1
534 +             let eq = eo._2
535 +             let er = [IntegerEntry(ab(), du), IntegerEntry(ac(height, lastBlock.timestamp), du), StringEntry(af(dh, de), by(ep, eq, el, du, bW, ek, height, lastBlock.timestamp, em, en))]
536 +             $Tuple13(eh, el, du, dp, dr, dT, di, dn, er, em, en, dE, dG)
539 537              }
540 538      }
541 539  
542 540  
543 - func et (cA,cQ,eu) = {
544 -     let ev = g
545 -     let ew = cA[if ((cQ == 0))
541 + func es (cz,cP,et) = {
542 +     let eu = g
543 +     let ev = cz[if ((cP == 0))
546 544          then 1
547 545          else 0]
548 -     let ex = parseBigIntValue(m)
549 -     let cE = (parseBigIntValue(aV) * ex)
550 -     let cD = ew
551 -     let cF = (cE * ev)
552 -     let ey = (((((eu * eu) / (ew * ev)) * eu) * ex) / (cF * ev))
553 -     let ez = ((cD + ((eu * ex) / cF)) - eu)
554 -     func cO (cP,eA) =     {
555 -         let eB = cP
556 -         let eC = eB._1
557 -         let dd = eB._2
558 -         if ((dd != unit))
559 -             then cP
546 +     let ew = parseBigIntValue(l)
547 +     let cD = (parseBigIntValue(aU) * ew)
548 +     let cC = ev
549 +     let cE = (cD * eu)
550 +     let ex = (((((et * et) / (ev * eu)) * et) * ew) / (cE * eu))
551 +     let ey = ((cC + ((et * ew) / cE)) - et)
552 +     func cN (cO,ez) =     {
553 +         let eA = cO
554 +         let eB = eA._1
555 +         let dc = eA._2
556 +         if ((dc != unit))
557 +             then cO
560 558              else {
561 -                 let eD = (((eC * eC) + ey) / ((g * eC) + ez))
562 -                 let eE = Y((eD - value(eC)))
563 -                 if ((f >= eE))
564 -                     then $Tuple2(eD, eA)
565 -                     else $Tuple2(eD, unit)
559 +                 let eC = (((eB * eB) + ex) / ((g * eB) + ey))
560 +                 let eD = X((eC - value(eB)))
561 +                 if ((f >= eD))
562 +                     then $Tuple2(eC, ez)
563 +                     else $Tuple2(eC, unit)
566 564                  }
567 565          }
568 566  
569 -     let cU = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
570 -     let eF = {
571 -         let cW = cU
572 -         let cX = size(cW)
573 -         let cY = $Tuple2(eu, unit)
574 -         func cZ (da,db) =         if ((db >= cX))
575 -             then da
576 -             else cO(da, cW[db])
567 +     let cT = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
568 +     let eE = {
569 +         let cV = cT
570 +         let cW = size(cV)
571 +         let cX = $Tuple2(et, unit)
572 +         func cY (cZ,da) =         if ((da >= cW))
573 +             then cZ
574 +             else cN(cZ, cV[da])
577 575  
578 -         func dc (da,db) =         if ((db >= cX))
579 -             then da
576 +         func db (cZ,da) =         if ((da >= cW))
577 +             then cZ
580 578              else throw("List size exceeds 15")
581 579  
582 -         dc(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
580 +         db(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cX, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
583 581          }
584 -     let eC = eF._1
585 -     let dd = eF._2
586 -     if ((dd != unit))
587 -         then eC
588 -         else throw(("Y calculation error, Y = " + toString(eC)))
582 +     let eB = eE._1
583 +     let dc = eE._2
584 +     if ((dc != unit))
585 +         then eB
586 +         else throw(("Y calculation error, Y = " + toString(eB)))
589 587      }
590 588  
591 589  
592 - func eG (eH,eI,eJ) = {
593 -     let eK = fraction(cz([L(eH, toBigInt(bp)), L(eI, toBigInt(bq))]), c, eJ)
594 -     if ((eJ == e))
590 + func eF (eG,eH,eI) = {
591 +     let eJ = fraction(cy([K(eG, toBigInt(bo)), K(eH, toBigInt(bp))]), c, eI)
592 +     if ((eI == e))
595 593          then e
596 -         else eK
594 +         else eJ
597 595      }
598 596  
599 597  
600 - func eL (eM,eN,eO) = {
601 -     let eP = (toBigInt(bO(bf(bn))) - eM)
602 -     let eQ = (toBigInt(bO(bf(bo))) - eN)
603 -     let eR = (toBigInt(value(assetInfo(bm)).quantity) - eO)
604 -     let eS = eG(eP, eQ, eR)
605 -     eS
598 + func eK (eL,eM,eN) = {
599 +     let eO = (toBigInt(bN(be(bm))) - eL)
600 +     let eP = (toBigInt(bN(be(bn))) - eM)
601 +     let eQ = (toBigInt(value(assetInfo(bl)).quantity) - eN)
602 +     let eR = eF(eO, eP, eQ)
603 +     eR
606 604      }
607 605  
608 606  
609 - func eT (eU,eV,eO) = {
610 -     let eP = (bO(bf(bn)) + eU)
611 -     let eQ = (bO(bf(bo)) + eV)
612 -     let eR = (value(assetInfo(bm)).quantity + eO)
613 -     let eK = eG(toBigInt(eP), toBigInt(eQ), toBigInt(eR))
614 -     let eW = [IntegerEntry(ar, height), StringEntry(aq, toString(eK))]
615 -     $Tuple2(eW, eK)
607 + func eS (eT,eU,eN) = {
608 +     let eO = (bN(be(bm)) + eT)
609 +     let eP = (bN(be(bn)) + eU)
610 +     let eQ = (value(assetInfo(bl)).quantity + eN)
611 +     let eJ = eF(toBigInt(eO), toBigInt(eP), toBigInt(eQ))
612 +     let eV = [IntegerEntry(aq, height), StringEntry(ap, toString(eJ))]
613 +     $Tuple2(eV, eJ)
616 614      }
617 615  
618 616  
619 - func eX (eY,eK) = if ((eK >= eY))
617 + func eW (eX,eJ) = if ((eJ >= eX))
620 618      then true
621 -     else aO("updated DLp lower than current DLp")
619 +     else aN("updated DLp lower than current DLp")
622 620  
623 621  
624 - func eZ (fa) = {
625 -     let eP = bO(bf(bn))
626 -     let eQ = bO(bf(bo))
627 -     let fb = fa.amount
628 -     let fc = fraction(fa.amount, fa.price, a, FLOOR)
629 -     let fd = if ((fa.orderType == Buy))
630 -         then $Tuple2(fb, -(fc))
631 -         else $Tuple2(-(fb), fc)
632 -     let eU = fd._1
633 -     let eV = fd._2
634 -     if (if (if (aW())
622 + func eY (eZ) = {
623 +     let eO = bN(be(bm))
624 +     let eP = bN(be(bn))
625 +     let fa = eZ.amount
626 +     let fb = fraction(eZ.amount, eZ.price, a, FLOOR)
627 +     let fc = if ((eZ.orderType == Buy))
628 +         then $Tuple2(fa, -(fb))
629 +         else $Tuple2(-(fa), fb)
630 +     let eT = fc._1
631 +     let eU = fc._2
632 +     if (if (if (aV())
635 633          then true
636 -         else (bl == s))
634 +         else (bk == r))
637 635          then true
638 -         else (bl == t))
636 +         else (bk == s))
639 637          then throw("Admin blocked")
640 -         else if (if ((fa.assetPair.amountAsset != bn))
638 +         else if (if ((eZ.assetPair.amountAsset != bm))
641 639              then true
642 -             else (fa.assetPair.priceAsset != bo))
640 +             else (eZ.assetPair.priceAsset != bn))
643 641              then throw("Wr assets")
644 642              else {
645 -                 let fe = parseBigIntValue(valueOrElse(getString(this, aq), "0"))
646 -                 let ff = eT(eU, eV, 0)
647 -                 let fg = ff._1
648 -                 let fh = ff._2
649 -                 let fi = (fh >= fe)
650 -                 let fj = makeString(["dLp=", toString(fe), " dLpNew=", toString(fh), " amountAssetBalance=", toString(eP), " priceAssetBalance=", toString(eQ), " amountAssetBalanceDelta=", toString(eU), " priceAssetBalanceDelta=", toString(eV), " height=", toString(height)], "")
651 -                 $Tuple2(fi, fj)
643 +                 let fd = parseBigIntValue(valueOrElse(getString(this, ap), "0"))
644 +                 let fe = eS(eT, eU, 0)
645 +                 let ff = fe._1
646 +                 let fg = fe._2
647 +                 let fh = (fg >= fd)
648 +                 let fi = makeString(["dLp=", toString(fd), " dLpNew=", toString(fg), " amountAssetBalance=", toString(eO), " priceAssetBalance=", toString(eP), " amountAssetBalanceDelta=", toString(eT), " priceAssetBalanceDelta=", toString(eU), " height=", toString(height)], "")
649 +                 $Tuple2(fh, fi)
652 650                  }
653 651      }
654 652  
655 653  
656 - func fk (cQ) = if ((size(cQ.payments) != 1))
654 + func fj (cP) = if ((size(cP.payments) != 1))
657 655      then throw("1 pmnt exp")
658 656      else {
659 -         let fl = value(cQ.payments[0])
660 -         let dg = value(fl.assetId)
661 -         let dM = fl.amount
662 -         let dY = de(toBase58String(cQ.transactionId), toBase58String(dg), dM, cQ.caller)
663 -         let dA = dY._1
664 -         let dB = dY._2
665 -         let do = parseIntValue(dY._9)
666 -         let dC = dY._10
667 -         if (if (aW())
657 +         let fk = value(cP.payments[0])
658 +         let df = value(fk.assetId)
659 +         let dL = fk.amount
660 +         let dX = dd(toBase58String(cP.transactionId), toBase58String(df), dL, cP.caller)
661 +         let dz = dX._1
662 +         let dA = dX._2
663 +         let dn = parseIntValue(dX._9)
664 +         let dB = dX._10
665 +         if (if (aV())
668 666              then true
669 -             else (do == t))
670 -             then throw(("Admin blocked: " + toString(do)))
671 -             else $Tuple5(dA, dB, dM, dg, dC)
667 +             else (dn == s))
668 +             then throw(("Admin blocked: " + toString(dn)))
669 +             else $Tuple5(dz, dA, dL, df, dB)
672 670          }
673 671  
674 672  
675 - func fm (fn,ai,fo,fp,bX,dJ,dK,dL,dM,dN) = {
676 -     let dY = dD(ai, bX, value(fo).amount, value(fo).assetId, value(fp).amount, value(fp).assetId, fn, (ai == ""), dJ, dK, dL, dM, dN)
677 -     let do = parseIntValue(dY._8)
678 -     if (if (if (aW())
673 + func fl (fm,ah,fn,fo,bW,dI,dJ,dK,dL,dM) = {
674 +     let dX = dC(ah, bW, value(fn).amount, value(fn).assetId, value(fo).amount, value(fo).assetId, fm, (ah == ""), dI, dJ, dK, dL, dM)
675 +     let dn = parseIntValue(dX._8)
676 +     if (if (if (aV())
679 677          then true
680 -         else (do == r))
678 +         else (dn == q))
681 679          then true
682 -         else (do == t))
683 -         then throw(("Blocked:" + toString(do)))
684 -         else dY
680 +         else (dn == s))
681 +         then throw(("Blocked:" + toString(dn)))
682 +         else dX
685 683      }
686 684  
687 685  
688 - func fq (fr,dg,di,ai,fs) = {
686 + func fp (fq,df,dh,ah,fr) = {
687 +     let dj = toBase58String(value(bm))
689 688      let dk = toBase58String(value(bn))
690 -     let dl = toBase58String(value(bo))
691 -     let dj = bm
689 +     let di = bl
690 +     let dR = bo
692 691      let dS = bp
693 -     let dT = bq
694 -     let eR = toBigInt(valueOrErrorMessage(assetInfo(dj), "invalid lp asset").quantity)
695 -     let ft = if ((eR > e))
692 +     let eQ = toBigInt(valueOrErrorMessage(assetInfo(di), "invalid lp asset").quantity)
693 +     let fs = if ((eQ > e))
696 694          then true
697 695          else throw("initial deposit requires all coins")
698 -     if ((ft == ft))
696 +     if ((fs == fs))
699 697          then {
700 -             let dq = bO(dk)
701 -             let ds = bO(dl)
702 -             let fu = if ((ai == ""))
703 -                 then $Tuple2(dq, ds)
704 -                 else if ((dg == dk))
705 -                     then if ((fr > dq))
698 +             let dp = bN(dj)
699 +             let dr = bN(dk)
700 +             let ft = if ((ah == ""))
701 +                 then $Tuple2(dp, dr)
702 +                 else if ((df == dj))
703 +                     then if ((fq > dp))
706 704                          then throw("invalid payment amount")
707 -                         else $Tuple2((dq - fr), ds)
708 -                     else if ((dg == dl))
709 -                         then if ((fr > ds))
705 +                         else $Tuple2((dp - fq), dr)
706 +                     else if ((df == dk))
707 +                         then if ((fq > dr))
710 708                              then throw("invalid payment amount")
711 -                             else $Tuple2(dq, (ds - fr))
709 +                             else $Tuple2(dp, (dr - fq))
712 710                          else throw("wrong pmtAssetId")
713 -             let fv = fu._1
714 -             let fw = fu._2
715 -             let fx = if ((dg == dk))
716 -                 then $Tuple2(fr, 0)
717 -                 else if ((dg == dl))
718 -                     then $Tuple2(0, fr)
711 +             let fu = ft._1
712 +             let fv = ft._2
713 +             let fw = if ((df == dj))
714 +                 then $Tuple2(fq, 0)
715 +                 else if ((df == dk))
716 +                     then $Tuple2(0, fq)
719 717                      else throw("invalid payment")
720 -             let fy = fx._1
721 -             let fz = fx._2
722 -             let fA = if (fs)
723 -                 then $Tuple3(cw(fy, aS)._1, cw(fz, aS)._1, cw(fr, aS)._2)
724 -                 else $Tuple3(fy, fz, 0)
725 -             let fB = fA._1
726 -             let fC = fA._2
727 -             let cy = fA._3
718 +             let fx = fw._1
719 +             let fy = fw._2
720 +             let fz = if (fr)
721 +                 then $Tuple3(cv(fx, aR)._1, cv(fy, aR)._1, cv(fq, aR)._2)
722 +                 else $Tuple3(fx, fy, 0)
723 +             let fA = fz._1
724 +             let fB = fz._2
725 +             let cx = fz._3
726 +             let fC = (fu + fA)
728 727              let fD = (fv + fB)
729 -             let fE = (fw + fC)
730 -             let cc = cz([I(fv, bp), I(fw, bq)])
731 -             let cb = cz([I(fD, bp), I(fE, bq)])
732 -             let dZ = if ((cb > cc))
728 +             let cb = cy([H(fu, bo), H(fv, bp)])
729 +             let ca = cy([H(fC, bo), H(fD, bp)])
730 +             let dY = if ((ca > cb))
733 731                  then true
734 732                  else throw()
735 -             if ((dZ == dZ))
733 +             if ((dY == dY))
736 734                  then {
737 -                     let fF = fraction(eR, (cb - cc), cc, FLOOR)
738 -                     let dv = M(bQ(I(fE, dT), I(fD, dS)), a)
739 -                     let es = [IntegerEntry(ac(), dv), IntegerEntry(ad(height, lastBlock.timestamp), dv), StringEntry(ag(di, ai), bz(fy, fz, toInt(fF), dv, 0, 0, height, lastBlock.timestamp, 0, 0))]
740 -                     let fG = fraction(fw, a, fv)
741 -                     let fH = fraction(fr, a, (fG + a))
742 -                     let fI = (fr - fH)
743 -                     let fJ = fraction(eR, toBigInt(fI), toBigInt(fw))
744 -                     let fK = toInt(fraction((fF - fJ), b, fJ))
745 -                     $Tuple4(toInt(fF), es, cy, fK)
735 +                     let fE = fraction(eQ, (ca - cb), cb, FLOOR)
736 +                     let du = L(bP(H(fD, dS), H(fC, dR)), a)
737 +                     let er = [IntegerEntry(ab(), du), IntegerEntry(ac(height, lastBlock.timestamp), du), StringEntry(af(dh, ah), by(fx, fy, toInt(fE), du, 0, 0, height, lastBlock.timestamp, 0, 0))]
738 +                     let fF = fraction(fv, a, fu)
739 +                     let fG = fraction(fq, a, (fF + a))
740 +                     let fH = (fq - fG)
741 +                     let fI = fraction(eQ, toBigInt(fH), toBigInt(fv))
742 +                     let fJ = toInt(fraction((fE - fI), b, fI))
743 +                     $Tuple4(toInt(fE), er, cx, fJ)
746 744                      }
747 745                  else throw("Strict value is not equal to itself.")
748 746              }
749 747          else throw("Strict value is not equal to itself.")
750 748      }
751 749  
752 750  
753 - func fL (fM,fN,fO,fn,fP,fQ) = {
751 + func fK (fL,fM,fN,fm,fO,fP) = {
752 +     let di = toBase58String(value(bl))
754 753      let dj = toBase58String(value(bm))
755 754      let dk = toBase58String(value(bn))
756 -     let dl = toBase58String(value(bo))
755 +     let fQ = bo
757 756      let fR = bp
758 -     let fS = bq
759 -     let fT = bl
760 -     let di = if ((fn == by))
761 -         then fP
762 -         else fn
763 -     let fl = value(fO[0])
764 -     let dg = value(fl.assetId)
765 -     let dM = fl.amount
766 -     let eS = eL(e, e, e)
767 -     if ((eS == eS))
757 +     let fS = bk
758 +     let dh = if ((fm == bx))
759 +         then fO
760 +         else fm
761 +     let fk = value(fN[0])
762 +     let df = value(fk.assetId)
763 +     let dL = fk.amount
764 +     let eR = eK(e, e, e)
765 +     if ((eR == eR))
768 766          then {
769 -             let df = toBase58String(fQ)
770 -             if ((dj != toBase58String(dg)))
767 +             let de = toBase58String(fP)
768 +             if ((di != toBase58String(df)))
771 769                  then throw("Wrong LP")
772 770                  else {
773 -                     let dq = bO(dk)
774 -                     let ds = bO(dl)
775 -                     let fU = {
776 -                         let aT = invoke(this, "getOneTknV2READONLY", [fM, dM], nil)
777 -                         if ($isInstanceOf(aT, "(Int, Int)"))
778 -                             then aT
779 -                             else throw(($getType(aT) + " couldn't be cast to (Int, Int)"))
771 +                     let dp = bN(dj)
772 +                     let dr = bN(dk)
773 +                     let fT = {
774 +                         let aS = invoke(this, "getOneTknV2READONLY", [fL, dL], nil)
775 +                         if ($isInstanceOf(aS, "(Int, Int)"))
776 +                             then aS
777 +                             else throw(($getType(aS) + " couldn't be cast to (Int, Int)"))
780 778                          }
781 -                     if ((fU == fU))
779 +                     if ((fT == fT))
782 780                          then {
783 -                             let cy = fU._2
784 -                             let fV = fU._1
785 -                             let fW = if (if ((fN > 0))
786 -                                 then (fN > fV)
781 +                             let cx = fT._2
782 +                             let fU = fT._1
783 +                             let fV = if (if ((fM > 0))
784 +                                 then (fM > fU)
787 785                                  else false)
788 -                                 then aO(makeString(["amount to receive is less than ", toString(fN)], ""))
789 -                                 else fV
790 -                             let fX = if ((fM == dk))
791 -                                 then $Tuple4(fW, 0, ((dq - fW) - cy), ds)
792 -                                 else if ((fM == dl))
793 -                                     then $Tuple4(0, fW, dq, ((ds - fW) - cy))
786 +                                 then aN(makeString(["amount to receive is less than ", toString(fM)], ""))
787 +                                 else fU
788 +                             let fW = if ((fL == dj))
789 +                                 then $Tuple4(fV, 0, ((dp - fV) - cx), dr)
790 +                                 else if ((fL == dk))
791 +                                     then $Tuple4(0, fV, dp, ((dr - fV) - cx))
794 792                                      else throw("invalid out asset id")
795 -                             let fY = fX._1
796 -                             let fZ = fX._2
797 -                             let fD = fX._3
798 -                             let fE = fX._4
799 -                             let ga = bQ(I(fE, fS), I(fD, fR))
800 -                             let gb = M(ga, a)
801 -                             let gc = if ((fM == "WAVES"))
793 +                             let fX = fW._1
794 +                             let fY = fW._2
795 +                             let fC = fW._3
796 +                             let fD = fW._4
797 +                             let fZ = bP(H(fD, fR), H(fC, fQ))
798 +                             let ga = L(fZ, a)
799 +                             let gb = if ((fL == "WAVES"))
802 800                                  then unit
803 -                                 else fromBase58String(fM)
804 -                             let gd = if ((cy > 0))
805 -                                 then [ScriptTransfer(aY, cy, gc)]
801 +                                 else fromBase58String(fL)
802 +                             let gc = if ((cx > 0))
803 +                                 then [ScriptTransfer(aX, cx, gb)]
806 804                                  else nil
807 -                             let dC = ([ScriptTransfer(di, fW, gc), StringEntry(aj(toString(di), df), bK(fY, fZ, dM, gb, height, lastBlock.timestamp)), IntegerEntry(ac(), gb), IntegerEntry(ad(height, lastBlock.timestamp), gb)] ++ gd)
808 -                             if ((dC == dC))
805 +                             let dB = ([ScriptTransfer(dh, fV, gb), StringEntry(ai(toString(dh), de), bJ(fX, fY, dL, ga, height, lastBlock.timestamp)), IntegerEntry(ab(), ga), IntegerEntry(ac(height, lastBlock.timestamp), ga)] ++ gc)
806 +                             if ((dB == dB))
809 807                                  then {
810 -                                     let ge = invoke(aR, "burn", [dM], [AttachedPayment(dg, dM)])
811 -                                     if ((ge == ge))
808 +                                     let gd = invoke(aQ, "burn", [dL], [AttachedPayment(df, dL)])
809 +                                     if ((gd == gd))
812 810                                          then {
813 -                                             let gf = {
814 -                                                 let gg = if ((this == aY))
811 +                                             let ge = {
812 +                                                 let gf = if ((this == aX))
815 813                                                      then 0
816 -                                                     else cy
817 -                                                 let gh = if ((bd(fM) == bn))
814 +                                                     else cx
815 +                                                 let gg = if ((bc(fL) == bm))
818 816                                                      then true
819 817                                                      else false
820 -                                                 if (gh)
821 -                                                     then $Tuple2(-((fV + gg)), 0)
822 -                                                     else $Tuple2(0, -((fV + gg)))
818 +                                                 if (gg)
819 +                                                     then $Tuple2(-((fU + gf)), 0)
820 +                                                     else $Tuple2(0, -((fU + gf)))
823 821                                                  }
824 -                                             let eU = gf._1
825 -                                             let eV = gf._2
826 -                                             let gi = eT(eU, eV, 0)
827 -                                             let gj = gi._1
828 -                                             let eK = gi._2
829 -                                             let gk = eX(eS, eK)
830 -                                             if ((gk == gk))
831 -                                                 then $Tuple2((dC ++ gj), fW)
822 +                                             let eT = ge._1
823 +                                             let eU = ge._2
824 +                                             let gh = eS(eT, eU, 0)
825 +                                             let gi = gh._1
826 +                                             let eJ = gh._2
827 +                                             let gj = eW(eR, eJ)
828 +                                             if ((gj == gj))
829 +                                                 then $Tuple2((dB ++ gi), fV)
832 830                                                  else throw("Strict value is not equal to itself.")
833 831                                              }
834 832                                          else throw("Strict value is not equal to itself.")
835 833                                      }
836 834                                  else throw("Strict value is not equal to itself.")
837 835                              }
838 836                          else throw("Strict value is not equal to itself.")
839 837                      }
840 838              }
841 839          else throw("Strict value is not equal to itself.")
842 840      }
843 841  
844 842  
845 - func gl () = {
846 -     let gm = getString(aa())
847 -     if ($isInstanceOf(gm, "String"))
843 + func gk () = {
844 +     let gl = getString(Z())
845 +     if ($isInstanceOf(gl, "String"))
848 846          then {
849 -             let cD = gm
850 -             fromBase58String(cD)
847 +             let cC = gl
848 +             fromBase58String(cC)
851 849              }
852 -         else if ($isInstanceOf(gm, "Unit"))
850 +         else if ($isInstanceOf(gl, "Unit"))
853 851              then unit
854 852              else throw("Match error")
855 853      }
856 854  
857 855  
858 - func gn () = {
859 -     let gm = getString(ab())
860 -     if ($isInstanceOf(gm, "String"))
856 + func gm () = {
857 +     let gl = getString(aa())
858 +     if ($isInstanceOf(gl, "String"))
861 859          then {
862 -             let cD = gm
863 -             fromBase58String(cD)
860 +             let cC = gl
861 +             fromBase58String(cC)
864 862              }
865 -         else if ($isInstanceOf(gm, "Unit"))
863 +         else if ($isInstanceOf(gl, "Unit"))
866 864              then unit
867 865              else throw("Match error")
868 866      }
869 867  
870 868  
871 - let go = throw("Permission denied")
869 + let gn = throw("Permission denied")
872 870  
873 - func gp (cQ) = {
874 -     let gm = gl()
875 -     if ($isInstanceOf(gm, "ByteVector"))
871 + func go (cP) = {
872 +     let gl = gk()
873 +     if ($isInstanceOf(gl, "ByteVector"))
876 874          then {
877 -             let gq = gm
878 -             (cQ.callerPublicKey == gq)
875 +             let gp = gl
876 +             (cP.callerPublicKey == gp)
879 877              }
880 -         else if ($isInstanceOf(gm, "Unit"))
881 -             then (cQ.caller == this)
878 +         else if ($isInstanceOf(gl, "Unit"))
879 +             then (cP.caller == this)
882 880              else throw("Match error")
883 881      }
884 882  
885 883  
886 - func gr (cQ) = {
887 -     let gm = gl()
888 -     if ($isInstanceOf(gm, "ByteVector"))
884 + func gq (cP) = {
885 +     let gl = gk()
886 +     if ($isInstanceOf(gl, "ByteVector"))
889 887          then {
890 -             let gq = gm
891 -             if ((cQ.callerPublicKey == gq))
888 +             let gp = gl
889 +             if ((cP.callerPublicKey == gp))
892 890                  then true
893 -                 else go
891 +                 else gn
894 892              }
895 -         else if ($isInstanceOf(gm, "Unit"))
896 -             then if ((cQ.caller == this))
893 +         else if ($isInstanceOf(gl, "Unit"))
894 +             then if ((cP.caller == this))
897 895                  then true
898 -                 else go
896 +                 else gn
899 897              else throw("Match error")
900 898      }
901 899  
902 900  
903 - func gs (gt,eu,gu) = {
904 -     let bh = aZ()
905 -     let dk = bh[x]
906 -     let dl = bh[y]
907 -     let ev = g
908 -     let ex = parseBigIntValue(m)
909 -     let cE = (parseBigIntValue(aV) * ex)
910 -     let cA = if ((gt == false))
911 -         then [(toBigInt(bO(dk)) + gu), toBigInt(bO(dl))]
912 -         else [(toBigInt(bO(dl)) + gu), toBigInt(bO(dk))]
913 -     let ew = cA[0]
914 -     let cD = ew
915 -     let cF = (cE * ev)
916 -     let ey = (((((eu * eu) / (ew * ev)) * eu) * ex) / (cF * ev))
917 -     let ez = ((cD + ((eu * ex) / cF)) - eu)
918 -     func cO (cP,eA) =     {
919 -         let gv = cP
920 -         let eC = gv._1
921 -         let dd = gv._2
922 -         if ((dd != unit))
923 -             then cP
901 + func gr (gs,et,gt) = {
902 +     let bg = aY()
903 +     let dj = bg[w]
904 +     let dk = bg[x]
905 +     let eu = g
906 +     let ew = parseBigIntValue(l)
907 +     let cD = (parseBigIntValue(aU) * ew)
908 +     let cz = if ((gs == false))
909 +         then [(toBigInt(bN(dj)) + gt), toBigInt(bN(dk))]
910 +         else [(toBigInt(bN(dk)) + gt), toBigInt(bN(dj))]
911 +     let ev = cz[0]
912 +     let cC = ev
913 +     let cE = (cD * eu)
914 +     let ex = (((((et * et) / (ev * eu)) * et) * ew) / (cE * eu))
915 +     let ey = ((cC + ((et * ew) / cE)) - et)
916 +     func cN (cO,ez) =     {
917 +         let gu = cO
918 +         let eB = gu._1
919 +         let dc = gu._2
920 +         if ((dc != unit))
921 +             then cO
924 922              else {
925 -                 let eD = (((eC * eC) + ey) / ((g * eC) + ez))
926 -                 let eE = Y((eD - value(eC)))
927 -                 if ((f >= eE))
928 -                     then $Tuple2(eD, eA)
929 -                     else $Tuple2(eD, unit)
923 +                 let eC = (((eB * eB) + ex) / ((g * eB) + ey))
924 +                 let eD = X((eC - value(eB)))
925 +                 if ((f >= eD))
926 +                     then $Tuple2(eC, ez)
927 +                     else $Tuple2(eC, unit)
930 928                  }
931 929          }
932 930  
933 -     let cU = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
934 -     let gw = {
935 -         let cW = cU
936 -         let cX = size(cW)
937 -         let cY = $Tuple2(eu, unit)
938 -         func cZ (da,db) =         if ((db >= cX))
939 -             then da
940 -             else cO(da, cW[db])
931 +     let cT = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
932 +     let gv = {
933 +         let cV = cT
934 +         let cW = size(cV)
935 +         let cX = $Tuple2(et, unit)
936 +         func cY (cZ,da) =         if ((da >= cW))
937 +             then cZ
938 +             else cN(cZ, cV[da])
941 939  
942 -         func dc (da,db) =         if ((db >= cX))
943 -             then da
940 +         func db (cZ,da) =         if ((da >= cW))
941 +             then cZ
944 942              else throw("List size exceeds 15")
945 943  
946 -         dc(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cZ(cY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
944 +         db(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cY(cX, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
947 945          }
948 -     let eC = gw._1
949 -     let dd = gw._2
950 -     if ((dd != unit))
951 -         then eC
952 -         else throw(("Y calculation error, Y = " + toString(eC)))
946 +     let eB = gv._1
947 +     let dc = gv._2
948 +     if ((dc != unit))
949 +         then eB
950 +         else throw(("Y calculation error, Y = " + toString(eB)))
953 951      }
954 952  
955 953  
956 - @Callable(cQ)
957 - func calculateAmountOutForSwapREADONLY (gx,gt) = {
958 -     let gy = if ((gt == false))
954 + @Callable(cP)
955 + func calculateAmountOutForSwapREADONLY (gw,gs) = {
956 +     let gx = if ((gs == false))
959 957          then {
960 -             let gz = aK(this, al())
961 -             let gu = (toBigInt(bO(aK(this, ak()))) + toBigInt(gx))
962 -             $Tuple2(gz, gu)
958 +             let gy = aJ(this, ak())
959 +             let gt = (toBigInt(bN(aJ(this, aj()))) + toBigInt(gw))
960 +             $Tuple2(gy, gt)
963 961              }
964 962          else {
965 -             let gz = aK(this, ak())
966 -             let gu = (toBigInt(bO(aK(this, al()))) + toBigInt(gx))
967 -             $Tuple2(gz, gu)
963 +             let gy = aJ(this, aj())
964 +             let gt = (toBigInt(bN(aJ(this, ak()))) + toBigInt(gw))
965 +             $Tuple2(gy, gt)
968 966              }
969 -     let gz = gy._1
970 -     let gu = gy._2
971 -     let bh = aZ()
972 -     let dk = bh[x]
973 -     let dl = bh[y]
974 -     let cA = [toBigInt(bO(dk)), toBigInt(bO(dl))]
975 -     let eu = cz(cA)
976 -     let eC = gs(gt, eu, toBigInt(gx))
977 -     let gA = ((toBigInt(bO(gz)) - eC) - toBigInt(1))
978 -     let gB = max([0, toInt(gA)])
979 -     let gC = if ((gt == false))
980 -         then [(toBigInt(bO(dk)) + toBigInt(gx)), (toBigInt(bO(dl)) - gA)]
981 -         else [(toBigInt(bO(dk)) - gA), (toBigInt(bO(dl)) + toBigInt(gx))]
982 -     let gD = cz(gC)
983 -     let dZ = if ((gD >= eu))
967 +     let gy = gx._1
968 +     let gt = gx._2
969 +     let bg = aY()
970 +     let dj = bg[w]
971 +     let dk = bg[x]
972 +     let cz = [toBigInt(bN(dj)), toBigInt(bN(dk))]
973 +     let et = cy(cz)
974 +     let eB = gr(gs, et, toBigInt(gw))
975 +     let gz = ((toBigInt(bN(gy)) - eB) - toBigInt(1))
976 +     let gA = max([0, toInt(gz)])
977 +     let gB = if ((gs == false))
978 +         then [(toBigInt(bN(dj)) + toBigInt(gw)), (toBigInt(bN(dk)) - gz)]
979 +         else [(toBigInt(bN(dj)) - gz), (toBigInt(bN(dk)) + toBigInt(gw))]
980 +     let gC = cy(gB)
981 +     let dY = if ((gC >= et))
984 982          then true
985 -         else throw(makeString(["new D is fewer error", toString(eu), toString(gD)], "__"))
986 -     if ((dZ == dZ))
987 -         then $Tuple2(nil, gB)
983 +         else throw(makeString(["new D is fewer error", toString(et), toString(gC)], "__"))
984 +     if ((dY == dY))
985 +         then $Tuple2(nil, gA)
988 986          else throw("Strict value is not equal to itself.")
989 987      }
990 988  
991 989  
992 990  
993 - @Callable(cQ)
994 - func calculateAmountOutForSwapAndSendTokens (gx,gt,gE,gF) = {
995 -     let gG = {
996 -         let aT = invoke(aR, "getSwapContractREADONLY", nil, nil)
997 -         if ($isInstanceOf(aT, "String"))
998 -             then aT
999 -             else throw(($getType(aT) + " couldn't be cast to String"))
991 + @Callable(cP)
992 + func calculateAmountOutForSwapAndSendTokens (gw,gs,gD,gE) = {
993 +     let gF = {
994 +         let aS = invoke(aQ, "getSwapContractREADONLY", nil, nil)
995 +         if ($isInstanceOf(aS, "String"))
996 +             then aS
997 +             else throw(($getType(aS) + " couldn't be cast to String"))
1000 998          }
1001 -     let gH = [if ((value(cQ.payments[0]).amount >= gx))
999 +     let gG = [if ((value(cP.payments[0]).amount >= gw))
1002 1000          then true
1003 -         else aO("Wrong amount"), if ((cQ.caller == addressFromStringValue(gG)))
1001 +         else aN("Wrong amount"), if ((cP.caller == addressFromStringValue(gF)))
1004 1002          then true
1005 -         else aO("Permission denied")]
1006 -     if ((gH == gH))
1003 +         else aN("Permission denied")]
1004 +     if ((gG == gG))
1007 1005          then {
1008 -             let fl = value(cQ.payments[0])
1009 -             let gI = if ((fl.assetId == unit))
1006 +             let fk = value(cP.payments[0])
1007 +             let gH = if ((fk.assetId == unit))
1010 1008                  then toBase58String(toBytes("WAVES"))
1011 -                 else toBase58String(value(fl.assetId))
1012 -             let gJ = if ((gt == false))
1009 +                 else toBase58String(value(fk.assetId))
1010 +             let gI = if ((gs == false))
1013 1011                  then {
1014 -                     let gz = aK(this, al())
1015 -                     let gu = (bO(gI) - value(cQ.payments[0]).amount)
1016 -                     $Tuple2(gz, gu)
1012 +                     let gy = aJ(this, ak())
1013 +                     let gt = (bN(gH) - value(cP.payments[0]).amount)
1014 +                     $Tuple2(gy, gt)
1017 1015                      }
1018 1016                  else {
1019 -                     let gz = aK(this, ak())
1020 -                     let gu = (bO(gI) - value(cQ.payments[0]).amount)
1021 -                     $Tuple2(gz, gu)
1017 +                     let gy = aJ(this, aj())
1018 +                     let gt = (bN(gH) - value(cP.payments[0]).amount)
1019 +                     $Tuple2(gy, gt)
1022 1020                      }
1023 -             let gz = gJ._1
1024 -             let gu = gJ._2
1025 -             let bh = aZ()
1026 -             let dk = bh[x]
1027 -             let dl = bh[y]
1028 -             let cA = if ((gt == false))
1029 -                 then [(toBigInt(bO(dk)) - toBigInt(value(cQ.payments[0]).amount)), toBigInt(bO(dl))]
1030 -                 else [toBigInt(bO(dk)), (toBigInt(bO(dl)) - toBigInt(value(cQ.payments[0]).amount))]
1031 -             let eu = cz(cA)
1032 -             let eC = gs(gt, eu, toBigInt(0))
1033 -             let gA = ((toBigInt(bO(gz)) - eC) - toBigInt(1))
1034 -             let gB = max([0, toInt(gA)])
1035 -             let gK = if ((gB >= gE))
1021 +             let gy = gI._1
1022 +             let gt = gI._2
1023 +             let bg = aY()
1024 +             let dj = bg[w]
1025 +             let dk = bg[x]
1026 +             let cz = if ((gs == false))
1027 +                 then [(toBigInt(bN(dj)) - toBigInt(value(cP.payments[0]).amount)), toBigInt(bN(dk))]
1028 +                 else [toBigInt(bN(dj)), (toBigInt(bN(dk)) - toBigInt(value(cP.payments[0]).amount))]
1029 +             let et = cy(cz)
1030 +             let eB = gr(gs, et, toBigInt(0))
1031 +             let gz = ((toBigInt(bN(gy)) - eB) - toBigInt(1))
1032 +             let gA = max([0, toInt(gz)])
1033 +             let gJ = if ((gA >= gD))
1036 1034                  then true
1037 1035                  else throw("Exchange result is fewer coins than expected")
1038 -             if ((gK == gK))
1036 +             if ((gJ == gJ))
1039 1037                  then {
1040 -                     let gC = if ((gt == false))
1041 -                         then [toBigInt(bO(dk)), (toBigInt(bO(dl)) - gA)]
1042 -                         else [(toBigInt(bO(dk)) - gA), toBigInt(bO(dl))]
1043 -                     let gD = cz(gC)
1044 -                     let dZ = if ((gD >= eu))
1038 +                     let gB = if ((gs == false))
1039 +                         then [toBigInt(bN(dj)), (toBigInt(bN(dk)) - gz)]
1040 +                         else [(toBigInt(bN(dj)) - gz), toBigInt(bN(dk))]
1041 +                     let gC = cy(gB)
1042 +                     let dY = if ((gC >= et))
1045 1043                          then true
1046 1044                          else throw("new D is fewer error")
1047 -                     if ((dZ == dZ))
1048 -                         then $Tuple2([ScriptTransfer(addressFromStringValue(gF), gB, bd(gz))], gB)
1045 +                     if ((dY == dY))
1046 +                         then $Tuple2([ScriptTransfer(addressFromStringValue(gE), gA, bc(gy))], gA)
1049 1047                          else throw("Strict value is not equal to itself.")
1050 1048                      }
1051 1049                  else throw("Strict value is not equal to itself.")
1052 1050              }
1053 1051          else throw("Strict value is not equal to itself.")
1054 1052      }
1055 1053  
1056 1054  
1057 1055  
1058 - @Callable(cQ)
1059 - func constructor (Z) = {
1060 -     let ey = gr(cQ)
1061 -     if ((ey == ey))
1062 -         then [StringEntry(Z(), Z)]
1056 + @Callable(cP)
1057 + func constructor (Y) = {
1058 +     let ex = gq(cP)
1059 +     if ((ex == ex))
1060 +         then [StringEntry(Y(), Y)]
1063 1061          else throw("Strict value is not equal to itself.")
1064 1062      }
1065 1063  
1066 1064  
1067 1065  
1068 - @Callable(cQ)
1069 - func setManager (gL) = {
1070 -     let ey = gr(cQ)
1071 -     if ((ey == ey))
1066 + @Callable(cP)
1067 + func setManager (gK) = {
1068 +     let ex = gq(cP)
1069 +     if ((ex == ex))
1072 1070          then {
1073 -             let gM = fromBase58String(gL)
1074 -             if ((gM == gM))
1075 -                 then [StringEntry(ab(), gL)]
1071 +             let gL = fromBase58String(gK)
1072 +             if ((gL == gL))
1073 +                 then [StringEntry(aa(), gK)]
1076 1074                  else throw("Strict value is not equal to itself.")
1077 1075              }
1078 1076          else throw("Strict value is not equal to itself.")
1079 1077      }
1080 1078  
1081 1079  
1082 1080  
1083 - @Callable(cQ)
1081 + @Callable(cP)
1084 1082  func confirmManager () = {
1085 -     let cv = gn()
1086 -     let gN = if (isDefined(cv))
1083 +     let cu = gm()
1084 +     let gM = if (isDefined(cu))
1087 1085          then true
1088 1086          else throw("No pending manager")
1089 -     if ((gN == gN))
1087 +     if ((gM == gM))
1090 1088          then {
1091 -             let gO = if ((cQ.callerPublicKey == value(cv)))
1089 +             let gN = if ((cP.callerPublicKey == value(cu)))
1092 1090                  then true
1093 1091                  else throw("You are not pending manager")
1094 -             if ((gO == gO))
1095 -                 then [StringEntry(aa(), toBase58String(value(cv))), DeleteEntry(ab())]
1092 +             if ((gN == gN))
1093 +                 then [StringEntry(Z(), toBase58String(value(cu))), DeleteEntry(aa())]
1096 1094                  else throw("Strict value is not equal to itself.")
1097 1095              }
1098 1096          else throw("Strict value is not equal to itself.")
1099 1097      }
1100 1098  
1101 1099  
1102 1100  
1103 - @Callable(cQ)
1104 - func put (gP,gQ) = {
1105 -     let gR = bt()
1106 -     let gS = valueOrErrorMessage(addressFromString(gR[D]), "Wr st addr")
1107 -     let gT = valueOrErrorMessage(addressFromString(gR[F]), "Wr sl addr")
1108 -     if ((0 > gP))
1101 + @Callable(cP)
1102 + func put (gO,gP) = {
1103 +     let gQ = bs()
1104 +     let gR = valueOrErrorMessage(addressFromString(gQ[C]), "Wr st addr")
1105 +     let gS = valueOrErrorMessage(addressFromString(gQ[E]), "Wr sl addr")
1106 +     if ((0 > gO))
1109 1107          then throw("Wrong slippage")
1110 -         else if ((size(cQ.payments) != 2))
1108 +         else if ((size(cP.payments) != 2))
1111 1109              then throw("2 pmnts expd")
1112 1110              else {
1113 -                 let gU = toBigInt(value(cQ.payments[0]).amount)
1114 -                 let gV = toBigInt(value(cQ.payments[1]).amount)
1115 -                 let eP = (toBigInt(bO(bf(bn))) - gU)
1116 -                 if ((eP == eP))
1111 +                 let gT = toBigInt(value(cP.payments[0]).amount)
1112 +                 let gU = toBigInt(value(cP.payments[1]).amount)
1113 +                 let eO = (toBigInt(bN(be(bm))) - gT)
1114 +                 if ((eO == eO))
1117 1115                      then {
1118 -                         let eQ = (toBigInt(bO(bf(bo))) - gV)
1119 -                         if ((eQ == eQ))
1116 +                         let eP = (toBigInt(bN(be(bn))) - gU)
1117 +                         if ((eP == eP))
1120 1118                              then {
1121 -                                 let eR = toBigInt(value(assetInfo(bm)).quantity)
1122 -                                 if ((eR == eR))
1119 +                                 let eQ = toBigInt(value(assetInfo(bl)).quantity)
1120 +                                 if ((eQ == eQ))
1123 1121                                      then {
1124 -                                         let eS = eL(gU, gV, toBigInt(0))
1125 -                                         if ((eS == eS))
1122 +                                         let eR = eK(gT, gU, toBigInt(0))
1123 +                                         if ((eR == eR))
1126 1124                                              then {
1127 -                                                 let gW = fm(toString(cQ.caller), toBase58String(cQ.transactionId), AttachedPayment(value(cQ.payments[0]).assetId, value(cQ.payments[0]).amount), cQ.payments[1], gP, true, false, true, 0, "")
1128 -                                                 let em = gW._2
1129 -                                                 let gX = gW._7
1130 -                                                 let dC = gW._9
1131 -                                                 let en = gW._10
1132 -                                                 let eo = gW._11
1133 -                                                 let dk = gW._12
1134 -                                                 let dl = gW._13
1135 -                                                 let dY = invoke(aR, "emit", [em], nil)
1136 -                                                 if ((dY == dY))
1125 +                                                 let gV = fl(toString(cP.caller), toBase58String(cP.transactionId), AttachedPayment(value(cP.payments[0]).assetId, value(cP.payments[0]).amount), cP.payments[1], gO, true, false, true, 0, "")
1126 +                                                 let el = gV._2
1127 +                                                 let gW = gV._7
1128 +                                                 let dB = gV._9
1129 +                                                 let em = gV._10
1130 +                                                 let en = gV._11
1131 +                                                 let dj = gV._12
1132 +                                                 let dk = gV._13
1133 +                                                 let dX = invoke(aQ, "emit", [el], nil)
1134 +                                                 if ((dX == dX))
1137 1135                                                      then {
1138 -                                                         let gY = {
1139 -                                                             let gm = dY
1140 -                                                             if ($isInstanceOf(gm, "Address"))
1136 +                                                         let gX = {
1137 +                                                             let gl = dX
1138 +                                                             if ($isInstanceOf(gl, "Address"))
1141 1139                                                                  then {
1142 -                                                                     let gZ = gm
1143 -                                                                     invoke(gZ, "emit", [em], nil)
1140 +                                                                     let gY = gl
1141 +                                                                     invoke(gY, "emit", [el], nil)
1144 1142                                                                      }
1145 1143                                                                  else unit
1146 1144                                                              }
1147 -                                                         if ((gY == gY))
1145 +                                                         if ((gX == gX))
1148 1146                                                              then {
1149 -                                                                 let ha = if ((en > 0))
1150 -                                                                     then invoke(gT, "put", nil, [AttachedPayment(dk, en)])
1147 +                                                                 let gZ = if ((em > 0))
1148 +                                                                     then invoke(gS, "put", nil, [AttachedPayment(dj, em)])
1151 1149                                                                      else nil
1152 -                                                                 if ((ha == ha))
1150 +                                                                 if ((gZ == gZ))
1153 1151                                                                      then {
1154 -                                                                         let hb = if ((eo > 0))
1155 -                                                                             then invoke(gT, "put", nil, [AttachedPayment(dl, eo)])
1152 +                                                                         let ha = if ((en > 0))
1153 +                                                                             then invoke(gS, "put", nil, [AttachedPayment(dk, en)])
1156 1154                                                                              else nil
1157 -                                                                         if ((hb == hb))
1155 +                                                                         if ((ha == ha))
1158 1156                                                                              then {
1159 -                                                                                 let hc = if (gQ)
1157 +                                                                                 let hb = if (gP)
1160 1158                                                                                      then {
1161 -                                                                                         let hd = invoke(gS, "stake", nil, [AttachedPayment(gX, em)])
1162 -                                                                                         if ((hd == hd))
1159 +                                                                                         let hc = invoke(gR, "stake", nil, [AttachedPayment(gW, el)])
1160 +                                                                                         if ((hc == hc))
1163 1161                                                                                              then nil
1164 1162                                                                                              else throw("Strict value is not equal to itself.")
1165 1163                                                                                          }
1166 -                                                                                     else [ScriptTransfer(cQ.caller, em, gX)]
1167 -                                                                                 let he = eT(0, 0, 0)
1168 -                                                                                 let gj = he._1
1169 -                                                                                 let eK = he._2
1170 -                                                                                 let hf = if ((eK >= eS))
1164 +                                                                                     else [ScriptTransfer(cP.caller, el, gW)]
1165 +                                                                                 let hd = eS(0, 0, 0)
1166 +                                                                                 let gi = hd._1
1167 +                                                                                 let eJ = hd._2
1168 +                                                                                 let he = if ((eJ >= eR))
1171 1169                                                                                      then true
1172 -                                                                                     else aO(makeString(["updated DLp lower than current DLp", toString(eP), toString(eQ), toString(eR), toString(eS), toString(eK), toString(en), toString(eo)], " "))
1173 -                                                                                 if ((hf == hf))
1170 +                                                                                     else aN(makeString(["updated DLp lower than current DLp", toString(eO), toString(eP), toString(eQ), toString(eR), toString(eJ), toString(em), toString(en)], " "))
1171 +                                                                                 if ((he == he))
1174 1172                                                                                      then {
1175 -                                                                                         let hg = value(assetInfo(bm)).quantity
1176 -                                                                                         if ((hg == hg))
1177 -                                                                                             then ((dC ++ hc) ++ gj)
1173 +                                                                                         let hf = value(assetInfo(bl)).quantity
1174 +                                                                                         if ((hf == hf))
1175 +                                                                                             then ((dB ++ hb) ++ gi)
1178 1176                                                                                              else throw("Strict value is not equal to itself.")
1179 1177                                                                                          }
1180 1178                                                                                      else throw("Strict value is not equal to itself.")
1181 1179                                                                                  }
1182 1180                                                                              else throw("Strict value is not equal to itself.")
1183 1181                                                                          }
1184 1182                                                                      else throw("Strict value is not equal to itself.")
1185 1183                                                                  }
1186 1184                                                              else throw("Strict value is not equal to itself.")
1187 1185                                                          }
1188 1186                                                      else throw("Strict value is not equal to itself.")
1189 1187                                                  }
1190 1188                                              else throw("Strict value is not equal to itself.")
1191 1189                                          }
1192 1190                                      else throw("Strict value is not equal to itself.")
1193 1191                                  }
1194 1192                              else throw("Strict value is not equal to itself.")
1195 1193                          }
1196 1194                      else throw("Strict value is not equal to itself.")
1197 1195                  }
1198 1196      }
1199 1197  
1200 1198  
1201 1199  
1202 - @Callable(cQ)
1203 - func putOneTknV2 (fN,gQ) = {
1204 -     let hh = {
1205 -         let aT = invoke(aR, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1206 -         if ($isInstanceOf(aT, "Boolean"))
1207 -             then aT
1208 -             else throw(($getType(aT) + " couldn't be cast to Boolean"))
1200 + @Callable(cP)
1201 + func putOneTknV2 (fM,gP) = {
1202 +     let hg = {
1203 +         let aS = invoke(aQ, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1204 +         if ($isInstanceOf(aS, "Boolean"))
1205 +             then aS
1206 +             else throw(($getType(aS) + " couldn't be cast to Boolean"))
1209 1207          }
1210 -     let hi = if (if (if (aW())
1208 +     let hh = if (if (if (aV())
1211 1209          then true
1212 -         else (bl == r))
1210 +         else (bk == q))
1213 1211          then true
1214 -         else (bl == t))
1212 +         else (bk == s))
1215 1213          then true
1216 -         else hh
1217 -     let gH = [if (if (!(hi))
1214 +         else hg
1215 +     let gG = [if (if (!(hh))
1218 1216          then true
1219 -         else gp(cQ))
1217 +         else go(cP))
1220 1218          then true
1221 -         else aO("put operation is blocked by admin"), if ((size(cQ.payments) == 1))
1219 +         else aN("put operation is blocked by admin"), if ((size(cP.payments) == 1))
1222 1220          then true
1223 -         else aO("exactly 1 payment are expected")]
1224 -     if ((gH == gH))
1221 +         else aN("exactly 1 payment are expected")]
1222 +     if ((gG == gG))
1225 1223          then {
1224 +             let dj = toBase58String(value(bm))
1226 1225              let dk = toBase58String(value(bn))
1227 -             let dl = toBase58String(value(bo))
1228 -             let dj = bm
1226 +             let di = bl
1227 +             let fQ = bo
1229 1228              let fR = bp
1230 -             let fS = bq
1231 -             let di = if ((cQ.caller == this))
1232 -                 then cQ.originCaller
1233 -                 else cQ.caller
1234 -             let fl = value(cQ.payments[0])
1235 -             let dg = toBase58String(value(fl.assetId))
1236 -             let dM = fl.amount
1237 -             let eS = if ((fl.assetId == bn))
1238 -                 then eL(toBigInt(dM), toBigInt(0), toBigInt(0))
1239 -                 else eL(toBigInt(0), toBigInt(dM), toBigInt(0))
1240 -             if ((eS == eS))
1229 +             let dh = if ((cP.caller == this))
1230 +                 then cP.originCaller
1231 +                 else cP.caller
1232 +             let fk = value(cP.payments[0])
1233 +             let df = toBase58String(value(fk.assetId))
1234 +             let dL = fk.amount
1235 +             let eR = if ((fk.assetId == bm))
1236 +                 then eK(toBigInt(dL), toBigInt(0), toBigInt(0))
1237 +                 else eK(toBigInt(0), toBigInt(dL), toBigInt(0))
1238 +             if ((eR == eR))
1241 1239                  then {
1242 -                     let hj = fq(dM, dg, toString(di), toBase58String(cQ.transactionId), true)
1243 -                     if ((hj == hj))
1240 +                     let hi = fp(dL, df, toString(dh), toBase58String(cP.transactionId), true)
1241 +                     if ((hi == hi))
1244 1242                          then {
1245 -                             let cy = hj._3
1246 -                             let dC = hj._2
1247 -                             let hk = hj._1
1248 -                             let em = if (if ((fN > 0))
1249 -                                 then (fN > hk)
1243 +                             let cx = hi._3
1244 +                             let dB = hi._2
1245 +                             let hj = hi._1
1246 +                             let el = if (if ((fM > 0))
1247 +                                 then (fM > hj)
1250 1248                                  else false)
1251 -                                 then aO(makeString(["amount to receive is less than ", toString(fN)], ""))
1252 -                                 else hk
1253 -                             let gW = invoke(aR, "emit", [em], nil)
1254 -                             if ((gW == gW))
1249 +                                 then aN(makeString(["amount to receive is less than ", toString(fM)], ""))
1250 +                                 else hj
1251 +                             let gV = invoke(aQ, "emit", [el], nil)
1252 +                             if ((gV == gV))
1255 1253                                  then {
1256 -                                     let gY = {
1257 -                                         let gm = gW
1258 -                                         if ($isInstanceOf(gm, "Address"))
1254 +                                     let gX = {
1255 +                                         let gl = gV
1256 +                                         if ($isInstanceOf(gl, "Address"))
1259 1257                                              then {
1260 -                                                 let gZ = gm
1261 -                                                 invoke(gZ, "emit", [em], nil)
1258 +                                                 let gY = gl
1259 +                                                 invoke(gY, "emit", [el], nil)
1262 1260                                                  }
1263 1261                                              else unit
1264 1262                                          }
1265 -                                     if ((gY == gY))
1263 +                                     if ((gX == gX))
1266 1264                                          then {
1267 -                                             let hc = if (gQ)
1265 +                                             let hb = if (gP)
1268 1266                                                  then {
1269 -                                                     let hd = invoke(bv, "stake", nil, [AttachedPayment(dj, em)])
1270 -                                                     if ((hd == hd))
1267 +                                                     let hc = invoke(bu, "stake", nil, [AttachedPayment(di, el)])
1268 +                                                     if ((hc == hc))
1271 1269                                                          then nil
1272 1270                                                          else throw("Strict value is not equal to itself.")
1273 1271                                                      }
1274 -                                                 else [ScriptTransfer(cQ.caller, em, dj)]
1275 -                                             let gd = if ((cy > 0))
1276 -                                                 then [ScriptTransfer(aY, cy, fromBase58String(dg))]
1272 +                                                 else [ScriptTransfer(cP.caller, el, di)]
1273 +                                             let gc = if ((cx > 0))
1274 +                                                 then [ScriptTransfer(aX, cx, fromBase58String(df))]
1277 1275                                                  else nil
1278 -                                             let hl = if ((this == aY))
1276 +                                             let hk = if ((this == aX))
1279 1277                                                  then $Tuple2(0, 0)
1280 1278                                                  else {
1281 -                                                     let hm = if ((fl.assetId == bn))
1279 +                                                     let hl = if ((fk.assetId == bm))
1282 1280                                                          then true
1283 1281                                                          else false
1284 -                                                     if (hm)
1285 -                                                         then $Tuple2(-(cy), 0)
1286 -                                                         else $Tuple2(0, -(cy))
1282 +                                                     if (hl)
1283 +                                                         then $Tuple2(-(cx), 0)
1284 +                                                         else $Tuple2(0, -(cx))
1287 1285                                                      }
1288 -                                             let eU = hl._1
1289 -                                             let eV = hl._2
1290 -                                             let hn = eT(eU, eV, 0)
1291 -                                             let gj = hn._1
1292 -                                             let eK = hn._2
1293 -                                             let gk = eX(eS, eK)
1294 -                                             if ((gk == gk))
1295 -                                                 then $Tuple2((((dC ++ hc) ++ gd) ++ gj), em)
1286 +                                             let eT = hk._1
1287 +                                             let eU = hk._2
1288 +                                             let hm = eS(eT, eU, 0)
1289 +                                             let gi = hm._1
1290 +                                             let eJ = hm._2
1291 +                                             let gj = eW(eR, eJ)
1292 +                                             if ((gj == gj))
1293 +                                                 then $Tuple2((((dB ++ hb) ++ gc) ++ gi), el)
1296 1294                                                  else throw("Strict value is not equal to itself.")
1297 1295                                              }
1298 1296                                          else throw("Strict value is not equal to itself.")
1299 1297                                      }
1300 1298                                  else throw("Strict value is not equal to itself.")
1301 1299                              }
1302 1300                          else throw("Strict value is not equal to itself.")
1303 1301                      }
1304 1302                  else throw("Strict value is not equal to itself.")
1305 1303              }
1306 1304          else throw("Strict value is not equal to itself.")
1307 1305      }
1308 1306  
1309 1307  
1310 1308  
1311 - @Callable(cQ)
1312 - func putForFree (ho) = if ((0 > ho))
1309 + @Callable(cP)
1310 + func putForFree (hn) = if ((0 > hn))
1313 1311      then throw("Wrong slpg")
1314 -     else if ((size(cQ.payments) != 2))
1312 +     else if ((size(cP.payments) != 2))
1315 1313          then throw("2 pmnts expd")
1316 1314          else {
1317 -             let hp = fm(toString(cQ.caller), toBase58String(cQ.transactionId), AttachedPayment(value(cQ.payments[0]).assetId, value(cQ.payments[0]).amount), cQ.payments[1], ho, false, false, true, 0, "")
1318 -             let dC = hp._9
1319 -             let gU = toBigInt(value(cQ.payments[0]).amount)
1320 -             let gV = toBigInt(value(cQ.payments[1]).amount)
1321 -             let eS = eL(gU, gV, toBigInt(0))
1322 -             if ((eS == eS))
1315 +             let ho = fl(toString(cP.caller), toBase58String(cP.transactionId), AttachedPayment(value(cP.payments[0]).assetId, value(cP.payments[0]).amount), cP.payments[1], hn, false, false, true, 0, "")
1316 +             let dB = ho._9
1317 +             let gT = toBigInt(value(cP.payments[0]).amount)
1318 +             let gU = toBigInt(value(cP.payments[1]).amount)
1319 +             let eR = eK(gT, gU, toBigInt(0))
1320 +             if ((eR == eR))
1323 1321                  then {
1324 -                     let hq = eT(0, 0, 0)
1325 -                     let gj = hq._1
1326 -                     let eK = hq._2
1327 -                     let gk = eX(eS, eK)
1328 -                     if ((gk == gk))
1329 -                         then (dC ++ gj)
1322 +                     let hp = eS(0, 0, 0)
1323 +                     let gi = hp._1
1324 +                     let eJ = hp._2
1325 +                     let gj = eW(eR, eJ)
1326 +                     if ((gj == gj))
1327 +                         then (dB ++ gi)
1330 1328                          else throw("Strict value is not equal to itself.")
1331 1329                      }
1332 1330                  else throw("Strict value is not equal to itself.")
1333 1331              }
1334 1332  
1335 1333  
1336 1334  
1337 - @Callable(cQ)
1335 + @Callable(cP)
1338 1336  func get () = {
1339 -     let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1340 -     if ((eS == eS))
1337 +     let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1338 +     if ((eR == eR))
1341 1339          then {
1342 -             let dY = fk(cQ)
1343 -             let hr = dY._1
1344 -             let dB = dY._2
1345 -             let dM = dY._3
1346 -             let dg = dY._4
1347 -             let dC = dY._5
1348 -             let ez = invoke(aR, "burn", [dM], [AttachedPayment(dg, dM)])
1349 -             if ((ez == ez))
1340 +             let dX = fj(cP)
1341 +             let hq = dX._1
1342 +             let dA = dX._2
1343 +             let dL = dX._3
1344 +             let df = dX._4
1345 +             let dB = dX._5
1346 +             let ey = invoke(aQ, "burn", [dL], [AttachedPayment(df, dL)])
1347 +             if ((ey == ey))
1350 1348                  then {
1351 -                     let hs = eT(-(hr), -(dB), 0)
1352 -                     let gj = hs._1
1353 -                     let eK = hs._2
1354 -                     let gk = eX(eS, eK)
1355 -                     if ((gk == gk))
1356 -                         then (dC ++ gj)
1349 +                     let hr = eS(-(hq), -(dA), 0)
1350 +                     let gi = hr._1
1351 +                     let eJ = hr._2
1352 +                     let gj = eW(eR, eJ)
1353 +                     if ((gj == gj))
1354 +                         then (dB ++ gi)
1357 1355                          else throw("Strict value is not equal to itself.")
1358 1356                      }
1359 1357                  else throw("Strict value is not equal to itself.")
1360 1358              }
1361 1359          else throw("Strict value is not equal to itself.")
1362 1360      }
1363 1361  
1364 1362  
1365 1363  
1366 - @Callable(cQ)
1367 - func getOneTknV2 (fM,fN) = {
1368 -     let hh = {
1369 -         let aT = invoke(aR, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1370 -         if ($isInstanceOf(aT, "Boolean"))
1371 -             then aT
1372 -             else throw(($getType(aT) + " couldn't be cast to Boolean"))
1364 + @Callable(cP)
1365 + func getOneTknV2 (fL,fM) = {
1366 +     let hg = {
1367 +         let aS = invoke(aQ, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1368 +         if ($isInstanceOf(aS, "Boolean"))
1369 +             then aS
1370 +             else throw(($getType(aS) + " couldn't be cast to Boolean"))
1373 1371          }
1374 -     let ht = if (if (aW())
1372 +     let hs = if (if (aV())
1375 1373          then true
1376 -         else (bl == t))
1374 +         else (bk == s))
1377 1375          then true
1378 -         else hh
1379 -     let gH = [if (if (!(ht))
1376 +         else hg
1377 +     let gG = [if (if (!(hs))
1380 1378          then true
1381 -         else gp(cQ))
1379 +         else go(cP))
1382 1380          then true
1383 -         else aO("get operation is blocked by admin"), if ((size(cQ.payments) == 1))
1381 +         else aN("get operation is blocked by admin"), if ((size(cP.payments) == 1))
1384 1382          then true
1385 -         else aO("exactly 1 payment are expected")]
1386 -     if ((gH == gH))
1383 +         else aN("exactly 1 payment are expected")]
1384 +     if ((gG == gG))
1387 1385          then {
1388 -             let hu = fL(fM, fN, cQ.payments, cQ.caller, cQ.originCaller, cQ.transactionId)
1389 -             let dC = hu._1
1390 -             let fW = hu._2
1391 -             $Tuple2(dC, fW)
1386 +             let ht = fK(fL, fM, cP.payments, cP.caller, cP.originCaller, cP.transactionId)
1387 +             let dB = ht._1
1388 +             let fV = ht._2
1389 +             $Tuple2(dB, fV)
1392 1390              }
1393 1391          else throw("Strict value is not equal to itself.")
1394 1392      }
1395 1393  
1396 1394  
1397 1395  
1398 - @Callable(cQ)
1396 + @Callable(cP)
1399 1397  func refreshDLp () = {
1400 -     let hv = valueOrElse(getInteger(ar), 0)
1401 -     let hw = if (((height - hv) >= au))
1398 +     let hu = valueOrElse(getInteger(aq), 0)
1399 +     let hv = if (((height - hu) >= at))
1402 1400          then unit
1403 -         else aO(makeString([toString(au), " blocks have not passed since the previous call"], ""))
1404 -     if ((hw == hw))
1401 +         else aN(makeString([toString(at), " blocks have not passed since the previous call"], ""))
1402 +     if ((hv == hv))
1405 1403          then {
1406 -             let fe = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aq), "0")), aQ("invalid dLp"))
1407 -             let hx = eT(0, 0, 0)
1408 -             let hy = hx._1
1409 -             let eK = hx._2
1410 -             let eW = if ((fe != eK))
1411 -                 then hy
1412 -                 else aO("nothing to refresh")
1413 -             $Tuple2(eW, toString(eK))
1404 +             let fd = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, ap), "0")), aP("invalid dLp"))
1405 +             let hw = eS(0, 0, 0)
1406 +             let hx = hw._1
1407 +             let eJ = hw._2
1408 +             let eV = if ((fd != eJ))
1409 +                 then hx
1410 +                 else aN("nothing to refresh")
1411 +             $Tuple2(eV, toString(eJ))
1414 1412              }
1415 1413          else throw("Strict value is not equal to itself.")
1416 1414      }
1417 1415  
1418 1416  
1419 1417  
1420 - @Callable(cQ)
1421 - func getOneTknV2READONLY (fM,hz) = {
1418 + @Callable(cP)
1419 + func getOneTknV2READONLY (fL,hy) = {
1420 +     let dj = toBase58String(value(bm))
1422 1421      let dk = toBase58String(value(bn))
1423 -     let dl = toBase58String(value(bo))
1424 -     let dj = toBase58String(value(bm))
1425 -     let cA = [toBigInt(bO(dk)), toBigInt(bO(dl))]
1426 -     let eJ = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(dj)), "invalid lp asset").quantity)
1427 -     let cc = cz(cA)
1428 -     let cb = (cc - fraction(toBigInt(hz), cc, eJ))
1429 -     let hA = if ((fM == dk))
1422 +     let di = toBase58String(value(bl))
1423 +     let cz = [toBigInt(bN(dj)), toBigInt(bN(dk))]
1424 +     let eI = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(di)), "invalid lp asset").quantity)
1425 +     let cb = cy(cz)
1426 +     let ca = (cb - fraction(toBigInt(hy), cb, eI))
1427 +     let hz = if ((fL == dj))
1430 1428          then 0
1431 -         else if ((fM == dl))
1429 +         else if ((fL == dk))
1432 1430              then 1
1433 1431              else throw("invalid out asset id")
1434 -     let hB = et(cA, hA, cb)
1435 -     let gA = (cA[hA] - hB)
1436 -     let gB = max([0, toInt((gA - f))])
1437 -     let hC = cw(gB, aU)
1438 -     let fV = hC._1
1439 -     let cy = hC._2
1440 -     $Tuple2(nil, $Tuple2(fV, cy))
1432 +     let hA = es(cz, hz, ca)
1433 +     let gz = (cz[hz] - hA)
1434 +     let gA = max([0, toInt((gz - f))])
1435 +     let hB = cv(gA, aT)
1436 +     let fU = hB._1
1437 +     let cx = hB._2
1438 +     $Tuple2(nil, $Tuple2(fU, cx))
1441 1439      }
1442 1440  
1443 1441  
1444 1442  
1445 - @Callable(cQ)
1446 - func getOneTknV2WithBonusREADONLY (fM,hz) = {
1443 + @Callable(cP)
1444 + func getOneTknV2WithBonusREADONLY (fL,hy) = {
1445 +     let dj = toBase58String(value(bm))
1447 1446      let dk = toBase58String(value(bn))
1448 -     let dl = toBase58String(value(bo))
1449 -     let dj = toBase58String(value(bm))
1450 -     let dq = bO(dk)
1451 -     let ds = bO(dl)
1452 -     let hD = {
1453 -         let aT = invoke(this, "getOneTknV2READONLY", [fM, hz], nil)
1454 -         if ($isInstanceOf(aT, "(Int, Int)"))
1455 -             then aT
1456 -             else throw(($getType(aT) + " couldn't be cast to (Int, Int)"))
1447 +     let di = toBase58String(value(bl))
1448 +     let dp = bN(dj)
1449 +     let dr = bN(dk)
1450 +     let hC = {
1451 +         let aS = invoke(this, "getOneTknV2READONLY", [fL, hy], nil)
1452 +         if ($isInstanceOf(aS, "(Int, Int)"))
1453 +             then aS
1454 +             else throw(($getType(aS) + " couldn't be cast to (Int, Int)"))
1457 1455          }
1458 -     let fV = hD._1
1459 -     let cy = hD._2
1460 -     let dY = de("", dj, hz, this)
1461 -     let dA = dY._1
1462 -     let dB = dY._2
1463 -     let hE = (dA + dB)
1464 -     let fK = if ((hE == 0))
1465 -         then if ((fV == 0))
1456 +     let fU = hC._1
1457 +     let cx = hC._2
1458 +     let dX = dd("", di, hy, this)
1459 +     let dz = dX._1
1460 +     let dA = dX._2
1461 +     let hD = (dz + dA)
1462 +     let fJ = if ((hD == 0))
1463 +         then if ((fU == 0))
1466 1464              then 0
1467 1465              else throw("bonus calculation error")
1468 -         else fraction((fV - hE), a, hE)
1469 -     $Tuple2(nil, $Tuple3(fV, cy, fK))
1466 +         else fraction((fU - hD), a, hD)
1467 +     $Tuple2(nil, $Tuple3(fU, cx, fJ))
1470 1468      }
1471 1469  
1472 1470  
1473 1471  
1474 - @Callable(cQ)
1475 - func getNoLess (hF,hG) = {
1476 -     let dY = fk(cQ)
1477 -     let dA = dY._1
1478 -     let dB = dY._2
1479 -     let dM = dY._3
1480 -     let dg = dY._4
1481 -     let dC = dY._5
1482 -     if ((hF > dA))
1483 -         then throw(((("Failed:  " + toString(dA)) + " < ") + toString(hF)))
1484 -         else if ((hG > dB))
1485 -             then throw(((("Failed: " + toString(dB)) + " < ") + toString(hG)))
1472 + @Callable(cP)
1473 + func getNoLess (hE,hF) = {
1474 +     let dX = fj(cP)
1475 +     let dz = dX._1
1476 +     let dA = dX._2
1477 +     let dL = dX._3
1478 +     let df = dX._4
1479 +     let dB = dX._5
1480 +     if ((hE > dz))
1481 +         then throw(((("Failed:  " + toString(dz)) + " < ") + toString(hE)))
1482 +         else if ((hF > dA))
1483 +             then throw(((("Failed: " + toString(dA)) + " < ") + toString(hF)))
1486 1484              else {
1487 -                 let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1488 -                 if ((eS == eS))
1485 +                 let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1486 +                 if ((eR == eR))
1489 1487                      then {
1490 -                         let hH = invoke(aR, "burn", [dM], [AttachedPayment(dg, dM)])
1491 -                         if ((hH == hH))
1488 +                         let hG = invoke(aQ, "burn", [dL], [AttachedPayment(df, dL)])
1489 +                         if ((hG == hG))
1492 1490                              then {
1493 -                                 let hI = eT(-(dA), -(dB), 0)
1494 -                                 let gj = hI._1
1495 -                                 let eK = hI._2
1496 -                                 let gk = eX(eS, eK)
1497 -                                 if ((gk == gk))
1498 -                                     then (dC ++ gj)
1491 +                                 let hH = eS(-(dz), -(dA), 0)
1492 +                                 let gi = hH._1
1493 +                                 let eJ = hH._2
1494 +                                 let gj = eW(eR, eJ)
1495 +                                 if ((gj == gj))
1496 +                                     then (dB ++ gi)
1499 1497                                      else throw("Strict value is not equal to itself.")
1500 1498                                  }
1501 1499                              else throw("Strict value is not equal to itself.")
1502 1500                          }
1503 1501                      else throw("Strict value is not equal to itself.")
1504 1502                  }
1505 1503      }
1506 1504  
1507 1505  
1508 1506  
1509 - @Callable(cQ)
1510 - func unstakeAndGet (cx) = {
1511 -     let hJ = if ((size(cQ.payments) != 0))
1507 + @Callable(cP)
1508 + func unstakeAndGet (cw) = {
1509 +     let hI = if ((size(cP.payments) != 0))
1512 1510          then throw("No pmnts expd")
1513 1511          else true
1514 -     if ((hJ == hJ))
1512 +     if ((hI == hI))
1515 1513          then {
1516 -             let hK = bt()
1517 -             let gX = bm
1518 -             let hL = valueOrErrorMessage(addressFromString(hK[D]), "Wr st addr")
1519 -             let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1520 -             if ((eS == eS))
1514 +             let hJ = bs()
1515 +             let gW = bl
1516 +             let hK = valueOrErrorMessage(addressFromString(hJ[C]), "Wr st addr")
1517 +             let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1518 +             if ((eR == eR))
1521 1519                  then {
1522 -                     let hM = invoke(hL, "unstake", [toBase58String(gX), cx], nil)
1523 -                     if ((hM == hM))
1520 +                     let hL = invoke(hK, "unstake", [toBase58String(gW), cw], nil)
1521 +                     if ((hL == hL))
1524 1522                          then {
1525 -                             let dY = de(toBase58String(cQ.transactionId), toBase58String(gX), cx, cQ.caller)
1526 -                             let dA = dY._1
1527 -                             let dB = dY._2
1528 -                             let do = parseIntValue(dY._9)
1529 -                             let dC = dY._10
1530 -                             let hN = if (if (aW())
1523 +                             let dX = dd(toBase58String(cP.transactionId), toBase58String(gW), cw, cP.caller)
1524 +                             let dz = dX._1
1525 +                             let dA = dX._2
1526 +                             let dn = parseIntValue(dX._9)
1527 +                             let dB = dX._10
1528 +                             let hM = if (if (aV())
1531 1529                                  then true
1532 -                                 else (do == t))
1533 -                                 then throw(("Blocked: " + toString(do)))
1530 +                                 else (dn == s))
1531 +                                 then throw(("Blocked: " + toString(dn)))
1534 1532                                  else true
1535 -                             if ((hN == hN))
1533 +                             if ((hM == hM))
1536 1534                                  then {
1537 -                                     let hO = invoke(aR, "burn", [cx], [AttachedPayment(gX, cx)])
1538 -                                     if ((hO == hO))
1535 +                                     let hN = invoke(aQ, "burn", [cw], [AttachedPayment(gW, cw)])
1536 +                                     if ((hN == hN))
1539 1537                                          then {
1540 -                                             let hP = eT(-(dA), -(dB), 0)
1541 -                                             let gj = hP._1
1542 -                                             let eK = hP._2
1543 -                                             let gk = eX(eS, eK)
1544 -                                             if ((gk == gk))
1545 -                                                 then (dC ++ gj)
1538 +                                             let hO = eS(-(dz), -(dA), 0)
1539 +                                             let gi = hO._1
1540 +                                             let eJ = hO._2
1541 +                                             let gj = eW(eR, eJ)
1542 +                                             if ((gj == gj))
1543 +                                                 then (dB ++ gi)
1546 1544                                                  else throw("Strict value is not equal to itself.")
1547 1545                                              }
1548 1546                                          else throw("Strict value is not equal to itself.")
1549 1547                                      }
1550 1548                                  else throw("Strict value is not equal to itself.")
1551 1549                              }
1552 1550                          else throw("Strict value is not equal to itself.")
1553 1551                      }
1554 1552                  else throw("Strict value is not equal to itself.")
1555 1553              }
1556 1554          else throw("Strict value is not equal to itself.")
1557 1555      }
1558 1556  
1559 1557  
1560 1558  
1561 - @Callable(cQ)
1562 - func unstakeAndGetNoLess (hQ,hR,hG) = {
1563 -     let ht = if (aW())
1559 + @Callable(cP)
1560 + func unstakeAndGetNoLess (hP,hQ,hF) = {
1561 +     let hs = if (aV())
1564 1562          then true
1565 -         else (bl == t)
1566 -     let gH = [if (!(ht))
1563 +         else (bk == s)
1564 +     let gG = [if (!(hs))
1567 1565          then true
1568 -         else throw("get operation is blocked by admin"), if ((size(cQ.payments) == 0))
1566 +         else throw("get operation is blocked by admin"), if ((size(cP.payments) == 0))
1569 1567          then true
1570 1568          else throw("no payments are expected")]
1571 -     if ((gH == gH))
1569 +     if ((gG == gG))
1572 1570          then {
1573 -             let eS = eL(toBigInt(0), toBigInt(0), toBigInt(0))
1574 -             if ((eS == eS))
1571 +             let eR = eK(toBigInt(0), toBigInt(0), toBigInt(0))
1572 +             if ((eR == eR))
1575 1573                  then {
1576 -                     let hM = invoke(bv, "unstake", [toBase58String(bm), hQ], nil)
1577 -                     if ((hM == hM))
1574 +                     let hL = invoke(bu, "unstake", [toBase58String(bl), hP], nil)
1575 +                     if ((hL == hL))
1578 1576                          then {
1579 -                             let hS = de(toBase58String(cQ.transactionId), toBase58String(bm), hQ, cQ.caller)
1580 -                             let dA = hS._1
1581 -                             let dB = hS._2
1582 -                             let dC = hS._10
1583 -                             let hT = [if ((dA >= hR))
1577 +                             let hR = dd(toBase58String(cP.transactionId), toBase58String(bl), hP, cP.caller)
1578 +                             let dz = hR._1
1579 +                             let dA = hR._2
1580 +                             let dB = hR._10
1581 +                             let hS = [if ((dz >= hQ))
1584 1582                                  then true
1585 -                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hR)], "")), if ((dB >= hG))
1583 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hQ)], "")), if ((dA >= hF))
1586 1584                                  then true
1587 -                                 else throw(makeString(["price asset amount to receive is less than ", toString(hG)], ""))]
1588 -                             if ((hT == hT))
1585 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(hF)], ""))]
1586 +                             if ((hS == hS))
1589 1587                                  then {
1590 -                                     let hH = invoke(aR, "burn", [hQ], [AttachedPayment(bm, hQ)])
1591 -                                     if ((hH == hH))
1588 +                                     let hG = invoke(aQ, "burn", [hP], [AttachedPayment(bl, hP)])
1589 +                                     if ((hG == hG))
1592 1590                                          then {
1593 -                                             let hU = eT(-(dA), -(dB), 0)
1594 -                                             let gj = hU._1
1595 -                                             let eK = hU._2
1596 -                                             let gk = eX(eS, eK)
1597 -                                             if ((gk == gk))
1598 -                                                 then (dC ++ gj)
1591 +                                             let hT = eS(-(dz), -(dA), 0)
1592 +                                             let gi = hT._1
1593 +                                             let eJ = hT._2
1594 +                                             let gj = eW(eR, eJ)
1595 +                                             if ((gj == gj))
1596 +                                                 then (dB ++ gi)
1599 1597                                                  else throw("Strict value is not equal to itself.")
1600 1598                                              }
1601 1599                                          else throw("Strict value is not equal to itself.")
1602 1600                                      }
1603 1601                                  else throw("Strict value is not equal to itself.")
1604 1602                              }
1605 1603                          else throw("Strict value is not equal to itself.")
1606 1604                      }
1607 1605                  else throw("Strict value is not equal to itself.")
1608 1606              }
1609 1607          else throw("Strict value is not equal to itself.")
1610 1608      }
1611 1609  
1612 1610  
1613 1611  
1614 - @Callable(cQ)
1615 - func unstakeAndGetOneTknV2 (hQ,fM,fN) = {
1616 -     let hh = {
1617 -         let aT = invoke(aR, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1618 -         if ($isInstanceOf(aT, "Boolean"))
1619 -             then aT
1620 -             else throw(($getType(aT) + " couldn't be cast to Boolean"))
1612 + @Callable(cP)
1613 + func unstakeAndGetOneTknV2 (hP,fL,fM) = {
1614 +     let hg = {
1615 +         let aS = invoke(aQ, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1616 +         if ($isInstanceOf(aS, "Boolean"))
1617 +             then aS
1618 +             else throw(($getType(aS) + " couldn't be cast to Boolean"))
1621 1619          }
1622 -     let ht = if (if (aW())
1620 +     let hs = if (if (aV())
1623 1621          then true
1624 -         else (bl == t))
1622 +         else (bk == s))
1625 1623          then true
1626 -         else hh
1627 -     let gH = [if (if (!(ht))
1624 +         else hg
1625 +     let gG = [if (if (!(hs))
1628 1626          then true
1629 -         else gp(cQ))
1627 +         else go(cP))
1630 1628          then true
1631 -         else aO("get operation is blocked by admin"), if ((size(cQ.payments) == 0))
1629 +         else aN("get operation is blocked by admin"), if ((size(cP.payments) == 0))
1632 1630          then true
1633 -         else aO("no payments are expected")]
1634 -     if ((gH == gH))
1631 +         else aN("no payments are expected")]
1632 +     if ((gG == gG))
1635 1633          then {
1636 -             let hK = bt()
1637 -             let gX = bm
1638 -             let hL = valueOrErrorMessage(addressFromString(hK[D]), "Wr st addr")
1639 -             let hM = invoke(hL, "unstake", [toBase58String(gX), hQ], nil)
1640 -             if ((hM == hM))
1634 +             let hJ = bs()
1635 +             let gW = bl
1636 +             let hK = valueOrErrorMessage(addressFromString(hJ[C]), "Wr st addr")
1637 +             let hL = invoke(hK, "unstake", [toBase58String(gW), hP], nil)
1638 +             if ((hL == hL))
1641 1639                  then {
1642 -                     let hV = fL(fM, fN, [AttachedPayment(gX, hQ)], cQ.caller, cQ.originCaller, cQ.transactionId)
1643 -                     let dC = hV._1
1644 -                     let fW = hV._2
1645 -                     $Tuple2(dC, fW)
1640 +                     let hU = fK(fL, fM, [AttachedPayment(gW, hP)], cP.caller, cP.originCaller, cP.transactionId)
1641 +                     let dB = hU._1
1642 +                     let fV = hU._2
1643 +                     $Tuple2(dB, fV)
1646 1644                      }
1647 1645                  else throw("Strict value is not equal to itself.")
1648 1646              }
1649 1647          else throw("Strict value is not equal to itself.")
1650 1648      }
1651 1649  
1652 1650  
1653 1651  
1654 - @Callable(cQ)
1655 - func putOneTknV2WithBonusREADONLY (hW,hX) = {
1656 -     let hY = fq(hW, hX, "", "", true)
1657 -     let fF = hY._1
1658 -     let dC = hY._2
1659 -     let cy = hY._3
1660 -     let fK = hY._4
1661 -     $Tuple2(nil, $Tuple3(fF, cy, fK))
1652 + @Callable(cP)
1653 + func putOneTknV2WithBonusREADONLY (hV,hW) = {
1654 +     let hX = fp(hV, hW, "", "", true)
1655 +     let fE = hX._1
1656 +     let dB = hX._2
1657 +     let cx = hX._3
1658 +     let fJ = hX._4
1659 +     $Tuple2(nil, $Tuple3(fE, cx, fJ))
1662 1660      }
1663 1661  
1664 1662  
1665 1663  
1666 - @Callable(cQ)
1667 - func putOneTknV2WithoutTakeFeeREADONLY (hW,hX) = {
1668 -     let hZ = fq(hW, hX, "", "", false)
1669 -     let fF = hZ._1
1670 -     let dC = hZ._2
1671 -     let cy = hZ._3
1672 -     let fK = hZ._4
1673 -     $Tuple2(nil, $Tuple3(fF, cy, fK))
1664 + @Callable(cP)
1665 + func putOneTknV2WithoutTakeFeeREADONLY (hV,hW) = {
1666 +     let hY = fp(hV, hW, "", "", false)
1667 +     let fE = hY._1
1668 +     let dB = hY._2
1669 +     let cx = hY._3
1670 +     let fJ = hY._4
1671 +     $Tuple2(nil, $Tuple3(fE, cx, fJ))
1674 1672      }
1675 1673  
1676 1674  
1677 1675  
1678 - @Callable(cQ)
1679 - func activate (ia,ib) = if ((toString(cQ.caller) != toString(aR)))
1676 + @Callable(cP)
1677 + func activate (hZ,ia) = if ((toString(cP.caller) != toString(aQ)))
1680 1678      then throw("denied")
1681 -     else $Tuple2([StringEntry(ak(), ia), StringEntry(al(), ib)], "success")
1679 +     else $Tuple2([StringEntry(aj(), hZ), StringEntry(ak(), ia)], "success")
1682 1680  
1683 1681  
1684 1682  
1685 - @Callable(cQ)
1686 - func setS (ic,hN) = if ((toString(cQ.caller) != aK(this, an())))
1687 -     then go
1688 -     else [StringEntry(ic, hN)]
1683 + @Callable(cP)
1684 + func setS (ib,hM) = if ((toString(cP.caller) != aJ(this, am())))
1685 +     then gn
1686 +     else [StringEntry(ib, hM)]
1689 1687  
1690 1688  
1691 1689  
1692 - @Callable(cQ)
1693 - func setI (ic,hN) = if ((toString(cQ.caller) != aK(this, an())))
1694 -     then go
1695 -     else [IntegerEntry(ic, hN)]
1690 + @Callable(cP)
1691 + func setI (ib,hM) = if ((toString(cP.caller) != aJ(this, am())))
1692 +     then gn
1693 +     else [IntegerEntry(ib, hM)]
1696 1694  
1697 1695  
1698 1696  
1699 - @Callable(cQ)
1700 - func getPoolConfigWrapperREADONLY () = $Tuple2(nil, aZ())
1697 + @Callable(cP)
1698 + func getPoolConfigWrapperREADONLY () = $Tuple2(nil, aY())
1701 1699  
1702 1700  
1703 1701  
1704 - @Callable(cQ)
1705 - func getAccBalanceWrapperREADONLY (bP) = $Tuple2(nil, bO(bP))
1702 + @Callable(cP)
1703 + func getAccBalanceWrapperREADONLY (bO) = $Tuple2(nil, bN(bO))
1706 1704  
1707 1705  
1708 1706  
1709 - @Callable(cQ)
1710 - func calcPricesWrapperREADONLY (ci,cj,cn) = {
1711 -     let id = cm(ci, cj, cn)
1712 -     $Tuple2(nil, [toString(id[0]), toString(id[1]), toString(id[2])])
1707 + @Callable(cP)
1708 + func calcPricesWrapperREADONLY (ch,ci,cm) = {
1709 +     let ic = cl(ch, ci, cm)
1710 +     $Tuple2(nil, [toString(ic[0]), toString(ic[1]), toString(ic[2])])
1713 1711      }
1714 1712  
1715 1713  
1716 1714  
1717 - @Callable(cQ)
1718 - func fromX18WrapperREADONLY (N,ie) = $Tuple2(nil, M(parseBigIntValue(N), ie))
1715 + @Callable(cP)
1716 + func fromX18WrapperREADONLY (M,id) = $Tuple2(nil, L(parseBigIntValue(M), id))
1719 1717  
1720 1718  
1721 1719  
1722 - @Callable(cQ)
1723 - func toX18WrapperREADONLY (J,K) = $Tuple2(nil, toString(I(J, K)))
1720 + @Callable(cP)
1721 + func toX18WrapperREADONLY (I,J) = $Tuple2(nil, toString(H(I, J)))
1724 1722  
1725 1723  
1726 1724  
1727 - @Callable(cQ)
1728 - func calcPriceBigIntWrapperREADONLY (bR,bS) = $Tuple2(nil, toString(bQ(parseBigIntValue(bR), parseBigIntValue(bS))))
1725 + @Callable(cP)
1726 + func calcPriceBigIntWrapperREADONLY (bQ,bR) = $Tuple2(nil, toString(bP(parseBigIntValue(bQ), parseBigIntValue(bR))))
1729 1727  
1730 1728  
1731 1729  
1732 - @Callable(cQ)
1733 - func estimatePutOperationWrapperREADONLY (df,bX,dE,dF,dG,dH,if,dI,dJ) = $Tuple2(nil, dD(df, bX, dE, dF, dG, dH, if, dI, dJ, true, false, 0, ""))
1730 + @Callable(cP)
1731 + func estimatePutOperationWrapperREADONLY (de,bW,dD,dE,dF,dG,ie,dH,dI) = $Tuple2(nil, dC(de, bW, dD, dE, dF, dG, ie, dH, dI, true, false, 0, ""))
1734 1732  
1735 1733  
1736 1734  
1737 - @Callable(cQ)
1738 - func estimateGetOperationWrapperREADONLY (df,ig,dh,if) = {
1739 -     let dY = de(df, ig, dh, addressFromStringValue(if))
1740 -     $Tuple2(nil, $Tuple10(dY._1, dY._2, dY._3, dY._4, dY._5, dY._6, dY._7, toString(dY._8), dY._9, dY._10))
1735 + @Callable(cP)
1736 + func estimateGetOperationWrapperREADONLY (de,if,dg,ie) = {
1737 +     let dX = dd(de, if, dg, addressFromStringValue(ie))
1738 +     $Tuple2(nil, $Tuple10(dX._1, dX._2, dX._3, dX._4, dX._5, dX._6, dX._7, toString(dX._8), dX._9, dX._10))
1741 1739      }
1742 1740  
1743 1741  
1744 - @Verifier(ih)
1745 - func ii () = {
1746 -     let ij = {
1747 -         let gm = gl()
1748 -         if ($isInstanceOf(gm, "ByteVector"))
1742 + @Verifier(ig)
1743 + func ih () = {
1744 +     let ii = {
1745 +         let gl = gk()
1746 +         if ($isInstanceOf(gl, "ByteVector"))
1749 1747              then {
1750 -                 let gq = gm
1751 -                 gq
1748 +                 let gp = gl
1749 +                 gp
1752 1750                  }
1753 -             else if ($isInstanceOf(gm, "Unit"))
1754 -                 then ih.senderPublicKey
1751 +             else if ($isInstanceOf(gl, "Unit"))
1752 +                 then ig.senderPublicKey
1755 1753                  else throw("Match error")
1756 1754          }
1757 -     let gm = ih
1758 -     if ($isInstanceOf(gm, "Order"))
1755 +     let gl = ig
1756 +     if ($isInstanceOf(gl, "Order"))
1759 1757          then {
1760 -             let fa = gm
1761 -             let ik = aX()
1762 -             let il = eZ(fa)
1763 -             let aG = il._1
1764 -             let aH = il._2
1765 -             let aI = sigVerify(fa.bodyBytes, fa.proofs[0], fa.senderPublicKey)
1766 -             let aJ = sigVerify(fa.bodyBytes, fa.proofs[1], ik)
1767 -             if (if (if (aG)
1758 +             let eZ = gl
1759 +             let ij = aW()
1760 +             let ik = eY(eZ)
1761 +             let aF = ik._1
1762 +             let aG = ik._2
1763 +             let aH = sigVerify(eZ.bodyBytes, eZ.proofs[0], eZ.senderPublicKey)
1764 +             let aI = sigVerify(eZ.bodyBytes, eZ.proofs[1], ij)
1765 +             if (if (if (aF)
1766 +                 then aH
1767 +                 else false)
1768 1768                  then aI
1769 1769                  else false)
1770 -                 then aJ
1771 -                 else false)
1772 1770                  then true
1773 -                 else aF(aG, aH, aI, aJ)
1771 +                 else aE(aF, aG, aH, aI)
1774 1772              }
1775 -         else if ($isInstanceOf(gm, "SetScriptTransaction"))
1773 +         else if ($isInstanceOf(gl, "SetScriptTransaction"))
1776 1774              then {
1777 -                 let cD = gm
1778 -                 if (sigVerify(ih.bodyBytes, ih.proofs[0], ij))
1775 +                 let cC = gl
1776 +                 if (sigVerify(ig.bodyBytes, ig.proofs[0], ii))
1779 1777                      then true
1780 1778                      else {
1781 -                         let im = blake2b256(value(cD.script))
1782 -                         let in = fromBase64String(value(getString(aR, aD())))
1783 -                         let io = scriptHash(this)
1784 -                         if ((in == im))
1785 -                             then (io != im)
1779 +                         let il = blake2b256(value(cC.script))
1780 +                         let im = fromBase64String(value(getString(aQ, aC())))
1781 +                         let in = scriptHash(this)
1782 +                         if ((im == il))
1783 +                             then (in != il)
1786 1784                              else false
1787 1785                          }
1788 1786                  }
1789 -             else sigVerify(ih.bodyBytes, ih.proofs[0], ij)
1787 +             else sigVerify(ig.bodyBytes, ig.proofs[0], ii)
1790 1788      }
1791 1789

Old	New		Differences
23	23
24	24		let k = "WAVES"
25	25
26		-	let l = 1
	26	+	let l = "100"
27	27
28		-	let m = "~~100~~"
	28	+	let m = "1"
29	29
30		-	let n = "1"
	30	+	let n = "__"
31	31
32		-	let o = "__"
	32	+	let o = ""
33	33
34		-	let p = ""
	34	+	let p = 1
35	35
36		-	let q = 1
	36	+	let q = 2
37	37
38		-	let r = 2
	38	+	let r = 3
39	39
40		-	let s = 3
	40	+	let s = 4
41	41
42		-	let t = 4
	42	+	let t = 1
43	43
44		-	let u = 1
	44	+	let u = 2
45	45
46		-	let v = 2
	46	+	let v = 3
47	47
48		-	let w = 3
	48	+	let w = 4
49	49
50		-	let x = 4
	50	+	let x = 5
51	51
52		-	let y = 5
	52	+	let y = 6
53	53
54		-	let z = 6
	54	+	let z = 7
55	55
56		-	let A = 7
	56	+	let A = 8
57	57
58		-	let B = 8
	58	+	let B = 9
59	59
60		-	let C = 9
	60	+	let C = 1
61	61
62		-	let D = 1
	62	+	let D = 6
63	63
64		-	let E = 6
	64	+	let E = 7
65	65
66		-	let F = 7
	66	+	let F = 10
67	67
68		-	let G = 10
	68	+	let G = fraction(10, a, 10000)
69	69
70		-	let H = fraction(10, a, 10000)
71		-
72		-	func I (J,K) = fraction(toBigInt(J), c, toBigInt(K))
	70	+	func H (I,J) = fraction(toBigInt(I), c, toBigInt(J))
73	71
74	72
75		-	func L (J,K) = fraction(J, c, K)
	73	+	func K (I,J) = fraction(I, c, J)
76	74
77	75
78		-	func M (N,O) = toInt(fraction(N, toBigInt(O), c))
	76	+	func L (M,N) = toInt(fraction(M, toBigInt(N), c))
79	77
80	78
81		-	func P (N,~~O,Q~~) = toInt(fraction(N, toBigInt(O), c, Q))
	79	+	func O (M,N,P) = toInt(fraction(M, toBigInt(N), c, P))
82	80
83	81
84		-	func R (J,K) = fraction(J, c, toBigInt(K))
	82	+	func Q (I,J) = fraction(I, c, toBigInt(J))
85	83
86	84
87		-	func S (N,O) = fraction(N, toBigInt(O), c)
	85	+	func R (M,N) = fraction(M, toBigInt(N), c)
88	86
89	87
90		-	func T (U,V,W) = fraction(U, V~~, W~~)
	88	+	func S (T,U,V) = fraction(T, U, V)
91	89
92	90
93		-	func X (N) = if ((d > N))
94		-	then -(N)
95		-	else N
	91	+	func W (M) = if ((d > M))
	92	+	then -(M)
	93	+	else M
96	94
97	95
98		-	func Y (N) = if ((d > N))
99		-	then -(N)
100		-	else N
	96	+	func X (M) = if ((d > M))
	97	+	then -(M)
	98	+	else M
101	99
102	100
103		-	func Z () = "%s__factoryContract"
	101	+	func Y () = "%s__factoryContract"
104	102
105	103
106		-	func aa () = "%s__managerPublicKey"
	104	+	func Z () = "%s__managerPublicKey"
107	105
108	106
109		-	func ab () = "%s__pendingManagerPublicKey"
	107	+	func aa () = "%s__pendingManagerPublicKey"
110	108
111	109
112		-	func ac () = "%s%s__price__last"
	110	+	func ab () = "%s%s__price__last"
113	111
114	112
115		-	func ad (ae~~,af~~) = makeString(["%s%s%d%d__price__history", toString(ae), toString(af)], o)
	113	+	func ac (ad,ae) = makeString(["%s%s%d%d__price__history", toString(ad), toString(ae)], n)
116	114
117	115
118		-	func ag (ah~~,ai~~) = ((("%s%s%s__P__" + ah) + "__") + ai)
	116	+	func af (ag,ah) = ((("%s%s%s__P__" + ag) + "__") + ah)
119	117
120	118
121		-	func aj (ah~~,ai~~) = ((("%s%s%s__G__" + ah) + "__") + ai)
	119	+	func ai (ag,ah) = ((("%s%s%s__G__" + ag) + "__") + ah)
122	120
123	121
124		-	func ak () = "%s__amountAsset"
	122	+	func aj () = "%s__amountAsset"
125	123
126	124
127		-	func al () = "%s__priceAsset"
	125	+	func ak () = "%s__priceAsset"
128	126
129	127
130		-	func am () = "%s__amp"
	128	+	func al () = "%s__amp"
131	129
132	130
133		-	func an () = "%s__addonAddr"
	131	+	func am () = "%s__addonAddr"
134	132
135	133
136		-	let ao = "%s__fee"
	134	+	let an = "%s__fee"
137	135
138		-	let ap = valueOrElse(getInteger(this, ao), H)
	136	+	let ao = valueOrElse(getInteger(this, an), G)
139	137
140		-	let aq = makeString(["%s", "dLp"], o)
	138	+	let ap = makeString(["%s", "dLp"], n)
141	139
142		-	let ar = makeString(["%s", "dLpRefreshedHeight"], o)
	140	+	let aq = makeString(["%s", "dLpRefreshedHeight"], n)
143	141
144		-	let as = makeString(["%s", "refreshDLpDelay"], o)
	142	+	let ar = makeString(["%s", "refreshDLpDelay"], n)
145	143
146		-	let at = 30
	144	+	let as = 30
147	145
148		-	let au = valueOrElse(getInteger(this, as), at)
	146	+	let at = valueOrElse(getInteger(this, ar), as)
149	147
150		-	func av () = "%s__factoryConfig"
	148	+	func au () = "%s__factoryConfig"
151	149
152	150
153		-	func aw () = "%s%s__matcher__publicKey"
	151	+	func av () = "%s%s__matcher__publicKey"
154	152
155	153
156		-	func ax (ay~~,az~~) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
	154	+	func aw (ax,ay) = (((("%d%d%s__" + ax) + "__") + ay) + "__config")
157	155
158	156
159		-	func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
	157	+	func az (aA) = ("%s%s%s__mappings__baseAsset2internalId__" + aA)
160	158
161	159
162		-	func aC () = "%s__shutdown"
	160	+	func aB () = "%s__shutdown"
163	161
164	162
165		-	func aD () = "%s__allowedLpStableScriptHash"
	163	+	func aC () = "%s__allowedLpStableScriptHash"
166	164
167	165
168		-	func aE () = "%s__feeCollectorAddress"
	166	+	func aD () = "%s__feeCollectorAddress"
169	167
170	168
171		-	func aF (aG,aH,aI~~,aJ~~) = throw((((((((("order validation failed: orderValid=" + toString(aG)) + " (") + aH) + ")") + " senderValid=") + toString(aI)) + " matcherValid=") + toString(aJ)))
	169	+	func aE (aF,aG,aH,aI) = throw((((((((("order validation failed: orderValid=" + toString(aF)) + " (") + aG) + ")") + " senderValid=") + toString(aH)) + " matcherValid=") + toString(aI)))
172	170
173	171
174		-	func aK (aL~~,aM~~) = valueOrErrorMessage(getString(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
	172	+	func aJ (aK,aL) = valueOrErrorMessage(getString(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
175	173
176	174
177		-	func aN (aL~~,aM~~) = valueOrErrorMessage(getInteger(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
	175	+	func aM (aK,aL) = valueOrErrorMessage(getInteger(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
178	176
179	177
180		-	func aO (aP) = throw(makeString(["lp_stable.ride:", aP], " "))
	178	+	func aN (aO) = throw(makeString(["lp_stable.ride:", aO], " "))
181	179
182	180
183		-	func aQ (aP) = makeString(["lp_stable.ride:", aP], " ")
	181	+	func aP (aO) = makeString(["lp_stable.ride:", aO], " ")
184	182
185	183
186		-	let aR = addressFromStringValue(aK(this, Z()))
	184	+	let aQ = addressFromStringValue(aJ(this, Y()))
187	185
188		-	let aS = {
189		-	let aT = invoke(aR, "getInFeeREADONLY", [toString(this)], nil)
190		-	if ($isInstanceOf(aT, "Int"))
191		-	then aT
192		-	else throw(($getType(aT) + " couldn't be cast to Int"))
	186	+	let aR = {
	187	+	let aS = invoke(aQ, "getInFeeREADONLY", [toString(this)], nil)
	188	+	if ($isInstanceOf(aS, "Int"))
	189	+	then aS
	190	+	else throw(($getType(aS) + " couldn't be cast to Int"))
193	191		}
194	192
195		-	let aU = {
196		-	let aT = invoke(aR, "getOutFeeREADONLY", [toString(this)], nil)
197		-	if ($isInstanceOf(aT, "Int"))
198		-	then aT
199		-	else throw(($getType(aT) + " couldn't be cast to Int"))
	193	+	let aT = {
	194	+	let aS = invoke(aQ, "getOutFeeREADONLY", [toString(this)], nil)
	195	+	if ($isInstanceOf(aS, "Int"))
	196	+	then aS
	197	+	else throw(($getType(aS) + " couldn't be cast to Int"))
200	198		}
201	199
202		-	let aV = aK(this, am())
	200	+	let aU = aJ(this, al())
203	201
204		-	func aW () = valueOrElse(getBoolean(aR, aC()), false)
	202	+	func aV () = valueOrElse(getBoolean(aQ, aB()), false)
205	203
206	204
207		-	func aX () = fromBase58String(aK(aR, aw()))
	205	+	func aW () = fromBase58String(aJ(aQ, av()))
208	206
209	207
210		-	let aY = addressFromStringValue(aK(aR, aE()))
	208	+	let aX = addressFromStringValue(aJ(aQ, aD()))
211	209
212		-	func aZ () = {
213		-	let ba = aK(this, ak())
214		-	let bb = aK(this, al())
215		-	let bc = aN(aR, aA(bb))
216		-	let ay = aN(aR, aA(ba))
217		-	split(aK(aR, ax(toString(ay), toString(bc))), o)
	210	+	func aY () = {
	211	+	let aZ = aJ(this, aj())
	212	+	let ba = aJ(this, ak())
	213	+	let bb = aM(aQ, az(ba))
	214	+	let ax = aM(aQ, az(aZ))
	215	+	split(aJ(aQ, aw(toString(ax), toString(bb))), n)
218	216		}
219	217
220	218
221		-	func bd (be) = if ((be == k))
	219	+	func bc (bd) = if ((bd == k))
222	220		then unit
223		-	else fromBase58String(be)
	221	+	else fromBase58String(bd)
224	222
225	223
226		-	func bf (be) = if ((be == unit))
	224	+	func be (bd) = if ((bd == unit))
227	225		then k
228		-	else toBase58String(value(be))
	226	+	else toBase58String(value(bd))
229	227
230	228
231		-	func bg (bh) = $Tuple9(addressFromStringValue(bh[u]), ~~parseIntValue~~(bh[v]), ~~fromBase58String~~(bh[w]), bd(bh[x]), bd(bh[y]), parseIntValue(bh[z]), ~~parseIntValue~~(bh[A]), fromBase58String(bh[B])~~, fromBase58String(bh[C]~~))
	229	+	func bf (bg) = $Tuple9(addressFromStringValue(bg[t]), parseIntValue(bg[u]), fromBase58String(bg[v]), bc(bg[w]), bc(bg[x]), parseIntValue(bg[y]), parseIntValue(bg[z]), fromBase58String(bg[A]), fromBase58String(bg[B]))
232	230
233	231
234		-	let bi = bg(aZ())
	232	+	let bh = bf(aY())
235	233
236		-	let bj = bi
	234	+	let bi = bh
237	235
238		-	let bk = bj._1
	236	+	let bj = bi._1
239	237
240		-	let bl = bj._2
	238	+	let bk = bi._2
241	239
242		-	let bm = bj._3
	240	+	let bl = bi._3
243	241
244		-	let bn = bj._4
	242	+	let bm = bi._4
245	243
246		-	let bo = bj._5
	244	+	let bn = bi._5
247	245
248		-	let bp = bj._6
	246	+	let bo = bi._6
249	247
250		-	let bq = bj._7
	248	+	let bp = bi._7
251	249
252		-	let br = bj._8
	250	+	let bq = bi._8
253	251
254		-	let bs = bj._9
	252	+	let br = bi._9
255	253
256		-	func bt () = split(aK(aR, av()), o)
	254	+	func bs () = split(aJ(aQ, au()), n)
257	255
258	256
259		-	let bu = bt()
	257	+	let bt = bs()
260	258
261		-	let bv = valueOrErrorMessage(addressFromString(bu[D]), "Invalid staking contract address")
	259	+	let bu = valueOrErrorMessage(addressFromString(bt[C]), "Invalid staking contract address")
262	260
263		-	let bw = valueOrErrorMessage(addressFromString(bu[F]), "Invalid slipage contract address")
	261	+	let bv = valueOrErrorMessage(addressFromString(bt[E]), "Invalid slipage contract address")
264	262
265		-	let bx = valueOrErrorMessage(addressFromString(bu[G]), "Invalid gwx contract address")
	263	+	let bw = valueOrErrorMessage(addressFromString(bt[F]), "Invalid gwx contract address")
266	264
267		-	let by = valueOrErrorMessage(addressFromString(bu[E]), "Invalid gwx contract address")
	265	+	let bx = valueOrErrorMessage(addressFromString(bt[D]), "Invalid gwx contract address")
268	266
269		-	func bz (bA,bB,bC,bD,bE,bF,bG,bH,bI~~,bJ~~) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI)~~, toString(bJ)~~], o)
	267	+	func by (bz,bA,bB,bC,bD,bE,bF,bG,bH,bI) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI)], n)
270	268
271	269
272		-	func bK (bL,bM,bN,bD,bG~~,bH~~) = makeString(["%d%d%d%d%d%d", toString(bL), toString(bM), toString(bN), toString(bD), toString(bG)~~, toString(bH)~~], o)
	270	+	func bJ (bK,bL,bM,bC,bF,bG) = makeString(["%d%d%d%d%d%d", toString(bK), toString(bL), toString(bM), toString(bC), toString(bF), toString(bG)], n)
273	271
274	272
275		-	func bO (bP) = if ((bP == "WAVES"))
	273	+	func bN (bO) = if ((bO == "WAVES"))
276	274		then wavesBalance(this).available
277		-	else assetBalance(this, fromBase58String(bP))
	275	+	else assetBalance(this, fromBase58String(bO))
278	276
279	277
280		-	func bQ (bR~~,bS~~) = fraction(bR, c, bS)
	278	+	func bP (bQ,bR) = fraction(bQ, c, bR)
281	279
282	280
283		-	func bT (bR,~~bS,Q~~) = fraction(bR, c, bS, Q)
	281	+	func bS (bQ,bR,P) = fraction(bQ, c, bR, P)
284	282
285	283
286		-	func bU (bV,bW~~,bX~~) = {
287		-	let bY = fraction((~~bV - bW~~), b, bW)
288		-	let bZ = ((~~bX - X~~(bY)) > d)
289		-	if (!(bZ))
290		-	then throw(("Big slpg: " + toString(bY)))
291		-	else $Tuple2(bZ, min([bV, bW]))
	284	+	func bT (bU,bV,bW) = {
	285	+	let bX = fraction((bU - bV), b, bV)
	286	+	let bY = ((bW - W(bX)) > d)
	287	+	if (!(bY))
	288	+	then throw(("Big slpg: " + toString(bX)))
	289	+	else $Tuple2(bY, min([bU, bV]))
292	290		}
293	291
294	292
295		-	func ca (cb,cc~~,cd~~) = {
296		-	let bY = fraction(cc, b, cb)
297		-	let ce = (cd > bY)
298		-	if (if (ce)
	293	+	func bZ (ca,cb,cc) = {
	294	+	let bX = fraction(cb, b, ca)
	295	+	let cd = (cc > bX)
	296	+	if (if (cd)
299	297		then true
300		-	else (cc > cb))
301		-	then throw(((((((toString(cc) + " ") + toString(cb)) + " ") + toString(bY)) + " ") + toString(cd)))
302		-	else ce
	298	+	else (cb > ca))
	299	+	then throw(((((((toString(cb) + " ") + toString(ca)) + " ") + toString(bX)) + " ") + toString(cc)))
	300	+	else cd
303	301		}
304	302
305	303
306		-	func cf (cg,ch,ci~~,cj~~) = {
307		-	let ck = I(ci, cg)
308		-	let cl = I(cj, ch)
309		-	bQ(cl, ck)
	304	+	func ce (cf,cg,ch,ci) = {
	305	+	let cj = H(ch, cf)
	306	+	let ck = H(ci, cg)
	307	+	bP(ck, cj)
310	308		}
311	309
312	310
313		-	func cm (ci,cj,cn) = {
	311	+	func cl (ch,ci,cm) = {
	312	+	let cn = bo
314	313		let co = bp
315		-	let cp = bq
316		-	let cq = cf(co, cp, ci, cj)
317		-	let bS = I(ci, co)
318		-	let bR = I(cj, cp)
319		-	let cr = I(cn, a)
320		-	let cs = bQ(bS, cr)
321		-	let ct = bQ(bR, cr)
322		-	[cq, cs, ct]
	314	+	let cp = ce(cn, co, ch, ci)
	315	+	let bR = H(ch, cn)
	316	+	let bQ = H(ci, co)
	317	+	let cq = H(cm, a)
	318	+	let cr = bP(bR, cq)
	319	+	let cs = bP(bQ, cq)
	320	+	[cp, cr, cs]
323	321		}
324	322
325	323
326		-	func cu (ci,~~cj,cn~~) = {
327		-	let cv = cm(ci, ~~cj, cn~~)
328		-	[M(cv[0], a), M(cv[1], a), M(cv[2], a)]
	324	+	func ct (ch,ci,cm) = {
	325	+	let cu = cl(ch, ci, cm)
	326	+	[L(cu[0], a), L(cu[1], a), L(cu[2], a)]
329	327		}
330	328
331	329
332		-	func cw (cx,ap) = {
333		-	let cy = if ((ap == 0))
	330	+	func cv (cw,ao) = {
	331	+	let cx = if ((ao == 0))
334	332		then 0
335		-	else fraction(cx, ap, a)
336		-	$Tuple2((~~cx - cy~~), cy)
	333	+	else fraction(cw, ao, a)
	334	+	$Tuple2((cw - cx), cx)
337	335		}
338	336
339	337
340		-	func cz (cA) = {
341		-	let cB = cA[0]
342		-	let cC = cA[1]
343		-	let cD = (cB + cC)
344		-	if ((cD == e))
	338	+	func cy (cz) = {
	339	+	let cA = cz[0]
	340	+	let cB = cz[1]
	341	+	let cC = (cA + cB)
	342	+	if ((cC == e))
345	343		then e
346	344		else {
347		-	let cE = parseIntValue(aV)
348		-	let cF = (cE * 2)
349		-	let cv = fraction(cB, cC, f)
350		-	let cG = fraction(cv, i, f)
351		-	let cH = fraction(toBigInt(cF), cD, f)
352		-	let cI = toBigInt((cF - 1))
353		-	func cJ (cK) = {
354		-	let cL = fraction(cK, cK, f)
355		-	let cM = fraction(cL, cK, f)
356		-	let cN = fraction(cM, f, cG)
357		-	fraction((cH + fraction(cN, g, f)), cK, (fraction(cI, cK, f) + fraction(h, cN, f)))
	345	+	let cD = parseIntValue(aU)
	346	+	let cE = (cD * 2)
	347	+	let cu = fraction(cA, cB, f)
	348	+	let cF = fraction(cu, i, f)
	349	+	let cG = fraction(toBigInt(cE), cC, f)
	350	+	let cH = toBigInt((cE - 1))
	351	+	func cI (cJ) = {
	352	+	let cK = fraction(cJ, cJ, f)
	353	+	let cL = fraction(cK, cJ, f)
	354	+	let cM = fraction(cL, f, cF)
	355	+	fraction((cG + fraction(cM, g, f)), cJ, (fraction(cH, cJ, f) + fraction(h, cM, f)))
358	356		}
359	357

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let a = 100000000
5	5
6	6		let b = toBigInt(100000000)
7	7
8	8		let c = toBigInt(1000000000000000000)
9	9
10	10		let d = toBigInt(0)
11	11
12	12		let e = toBigInt(0)
13	13
14	14		let f = toBigInt(1)
15	15
16	16		let g = toBigInt(2)
17	17
18	18		let h = toBigInt(3)
19	19
20	20		let i = toBigInt(4)
21	21
22	22		let j = toBigInt((a - ((a * 1) / a)))
23	23
24	24		let k = "WAVES"
25	25
26		-	let l = 1
	26	+	let l = "100"
27	27
28		-	let m = "~~100~~"
	28	+	let m = "1"
29	29
30		-	let n = "1"
	30	+	let n = "__"
31	31
32		-	let o = "__"
	32	+	let o = ""
33	33
34		-	let p = ""
	34	+	let p = 1
35	35
36		-	let q = 1
	36	+	let q = 2
37	37
38		-	let r = 2
	38	+	let r = 3
39	39
40		-	let s = 3
	40	+	let s = 4
41	41
42		-	let t = 4
	42	+	let t = 1
43	43
44		-	let u = 1
	44	+	let u = 2
45	45
46		-	let v = 2
	46	+	let v = 3
47	47
48		-	let w = 3
	48	+	let w = 4
49	49
50		-	let x = 4
	50	+	let x = 5
51	51
52		-	let y = 5
	52	+	let y = 6
53	53
54		-	let z = 6
	54	+	let z = 7
55	55
56		-	let A = 7
	56	+	let A = 8
57	57
58		-	let B = 8
	58	+	let B = 9
59	59
60		-	let C = 9
	60	+	let C = 1
61	61
62		-	let D = 1
	62	+	let D = 6
63	63
64		-	let E = 6
	64	+	let E = 7
65	65
66		-	let F = 7
	66	+	let F = 10
67	67
68		-	let G = 10
	68	+	let G = fraction(10, a, 10000)
69	69
70		-	let H = fraction(10, a, 10000)
71		-
72		-	func I (J,K) = fraction(toBigInt(J), c, toBigInt(K))
	70	+	func H (I,J) = fraction(toBigInt(I), c, toBigInt(J))
73	71
74	72
75		-	func L (J,K) = fraction(J, c, K)
	73	+	func K (I,J) = fraction(I, c, J)
76	74
77	75
78		-	func M (N,O) = toInt(fraction(N, toBigInt(O), c))
	76	+	func L (M,N) = toInt(fraction(M, toBigInt(N), c))
79	77
80	78
81		-	func P (N,~~O,Q~~) = toInt(fraction(N, toBigInt(O), c, Q))
	79	+	func O (M,N,P) = toInt(fraction(M, toBigInt(N), c, P))
82	80
83	81
84		-	func R (J,K) = fraction(J, c, toBigInt(K))
	82	+	func Q (I,J) = fraction(I, c, toBigInt(J))
85	83
86	84
87		-	func S (N,O) = fraction(N, toBigInt(O), c)
	85	+	func R (M,N) = fraction(M, toBigInt(N), c)
88	86
89	87
90		-	func T (U,V,W) = fraction(U, V~~, W~~)
	88	+	func S (T,U,V) = fraction(T, U, V)
91	89
92	90
93		-	func X (N) = if ((d > N))
94		-	then -(N)
95		-	else N
	91	+	func W (M) = if ((d > M))
	92	+	then -(M)
	93	+	else M
96	94
97	95
98		-	func Y (N) = if ((d > N))
99		-	then -(N)
100		-	else N
	96	+	func X (M) = if ((d > M))
	97	+	then -(M)
	98	+	else M
101	99
102	100
103		-	func Z () = "%s__factoryContract"
	101	+	func Y () = "%s__factoryContract"
104	102
105	103
106		-	func aa () = "%s__managerPublicKey"
	104	+	func Z () = "%s__managerPublicKey"
107	105
108	106
109		-	func ab () = "%s__pendingManagerPublicKey"
	107	+	func aa () = "%s__pendingManagerPublicKey"
110	108
111	109
112		-	func ac () = "%s%s__price__last"
	110	+	func ab () = "%s%s__price__last"
113	111
114	112
115		-	func ad (ae~~,af~~) = makeString(["%s%s%d%d__price__history", toString(ae), toString(af)], o)
	113	+	func ac (ad,ae) = makeString(["%s%s%d%d__price__history", toString(ad), toString(ae)], n)
116	114
117	115
118		-	func ag (ah~~,ai~~) = ((("%s%s%s__P__" + ah) + "__") + ai)
	116	+	func af (ag,ah) = ((("%s%s%s__P__" + ag) + "__") + ah)
119	117
120	118
121		-	func aj (ah~~,ai~~) = ((("%s%s%s__G__" + ah) + "__") + ai)
	119	+	func ai (ag,ah) = ((("%s%s%s__G__" + ag) + "__") + ah)
122	120
123	121
124		-	func ak () = "%s__amountAsset"
	122	+	func aj () = "%s__amountAsset"
125	123
126	124
127		-	func al () = "%s__priceAsset"
	125	+	func ak () = "%s__priceAsset"
128	126
129	127
130		-	func am () = "%s__amp"
	128	+	func al () = "%s__amp"
131	129
132	130
133		-	func an () = "%s__addonAddr"
	131	+	func am () = "%s__addonAddr"
134	132
135	133
136		-	let ao = "%s__fee"
	134	+	let an = "%s__fee"
137	135
138		-	let ap = valueOrElse(getInteger(this, ao), H)
	136	+	let ao = valueOrElse(getInteger(this, an), G)
139	137
140		-	let aq = makeString(["%s", "dLp"], o)
	138	+	let ap = makeString(["%s", "dLp"], n)
141	139
142		-	let ar = makeString(["%s", "dLpRefreshedHeight"], o)
	140	+	let aq = makeString(["%s", "dLpRefreshedHeight"], n)
143	141
144		-	let as = makeString(["%s", "refreshDLpDelay"], o)
	142	+	let ar = makeString(["%s", "refreshDLpDelay"], n)
145	143
146		-	let at = 30
	144	+	let as = 30
147	145
148		-	let au = valueOrElse(getInteger(this, as), at)
	146	+	let at = valueOrElse(getInteger(this, ar), as)
149	147
150		-	func av () = "%s__factoryConfig"
	148	+	func au () = "%s__factoryConfig"
151	149
152	150
153		-	func aw () = "%s%s__matcher__publicKey"
	151	+	func av () = "%s%s__matcher__publicKey"
154	152
155	153
156		-	func ax (ay~~,az~~) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
	154	+	func aw (ax,ay) = (((("%d%d%s__" + ax) + "__") + ay) + "__config")
157	155
158	156
159		-	func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
	157	+	func az (aA) = ("%s%s%s__mappings__baseAsset2internalId__" + aA)
160	158
161	159
162		-	func aC () = "%s__shutdown"
	160	+	func aB () = "%s__shutdown"
163	161
164	162
165		-	func aD () = "%s__allowedLpStableScriptHash"
	163	+	func aC () = "%s__allowedLpStableScriptHash"
166	164
167	165
168		-	func aE () = "%s__feeCollectorAddress"
	166	+	func aD () = "%s__feeCollectorAddress"
169	167
170	168
171		-	func aF (aG,aH,aI~~,aJ~~) = throw((((((((("order validation failed: orderValid=" + toString(aG)) + " (") + aH) + ")") + " senderValid=") + toString(aI)) + " matcherValid=") + toString(aJ)))
	169	+	func aE (aF,aG,aH,aI) = throw((((((((("order validation failed: orderValid=" + toString(aF)) + " (") + aG) + ")") + " senderValid=") + toString(aH)) + " matcherValid=") + toString(aI)))
172	170
173	171
174		-	func aK (aL~~,aM~~) = valueOrErrorMessage(getString(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
	172	+	func aJ (aK,aL) = valueOrErrorMessage(getString(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
175	173
176	174
177		-	func aN (aL~~,aM~~) = valueOrErrorMessage(getInteger(aL, aM), makeString(["mandatory ", toString(aL), ".", aM, " not defined"], ""))
	175	+	func aM (aK,aL) = valueOrErrorMessage(getInteger(aK, aL), makeString(["mandatory ", toString(aK), ".", aL, " not defined"], ""))
178	176
179	177
180		-	func aO (aP) = throw(makeString(["lp_stable.ride:", aP], " "))
	178	+	func aN (aO) = throw(makeString(["lp_stable.ride:", aO], " "))
181	179
182	180
183		-	func aQ (aP) = makeString(["lp_stable.ride:", aP], " ")
	181	+	func aP (aO) = makeString(["lp_stable.ride:", aO], " ")
184	182
185	183
186		-	let aR = addressFromStringValue(aK(this, Z()))
	184	+	let aQ = addressFromStringValue(aJ(this, Y()))
187	185
188		-	let aS = {
189		-	let aT = invoke(aR, "getInFeeREADONLY", [toString(this)], nil)
190		-	if ($isInstanceOf(aT, "Int"))
191		-	then aT
192		-	else throw(($getType(aT) + " couldn't be cast to Int"))
	186	+	let aR = {
	187	+	let aS = invoke(aQ, "getInFeeREADONLY", [toString(this)], nil)
	188	+	if ($isInstanceOf(aS, "Int"))
	189	+	then aS
	190	+	else throw(($getType(aS) + " couldn't be cast to Int"))
193	191		}
194	192
195		-	let aU = {
196		-	let aT = invoke(aR, "getOutFeeREADONLY", [toString(this)], nil)
197		-	if ($isInstanceOf(aT, "Int"))
198		-	then aT
199		-	else throw(($getType(aT) + " couldn't be cast to Int"))
	193	+	let aT = {
	194	+	let aS = invoke(aQ, "getOutFeeREADONLY", [toString(this)], nil)
	195	+	if ($isInstanceOf(aS, "Int"))
	196	+	then aS
	197	+	else throw(($getType(aS) + " couldn't be cast to Int"))
200	198		}
201	199
202		-	let aV = aK(this, am())
	200	+	let aU = aJ(this, al())
203	201
204		-	func aW () = valueOrElse(getBoolean(aR, aC()), false)
	202	+	func aV () = valueOrElse(getBoolean(aQ, aB()), false)
205	203
206	204
207		-	func aX () = fromBase58String(aK(aR, aw()))
	205	+	func aW () = fromBase58String(aJ(aQ, av()))
208	206
209	207
210		-	let aY = addressFromStringValue(aK(aR, aE()))
	208	+	let aX = addressFromStringValue(aJ(aQ, aD()))
211	209
212		-	func aZ () = {
213		-	let ba = aK(this, ak())
214		-	let bb = aK(this, al())
215		-	let bc = aN(aR, aA(bb))
216		-	let ay = aN(aR, aA(ba))
217		-	split(aK(aR, ax(toString(ay), toString(bc))), o)
	210	+	func aY () = {
	211	+	let aZ = aJ(this, aj())
	212	+	let ba = aJ(this, ak())
	213	+	let bb = aM(aQ, az(ba))
	214	+	let ax = aM(aQ, az(aZ))
	215	+	split(aJ(aQ, aw(toString(ax), toString(bb))), n)
218	216		}
219	217
220	218
221		-	func bd (be) = if ((be == k))
	219	+	func bc (bd) = if ((bd == k))
222	220		then unit
223		-	else fromBase58String(be)
	221	+	else fromBase58String(bd)
224	222
225	223
226		-	func bf (be) = if ((be == unit))
	224	+	func be (bd) = if ((bd == unit))
227	225		then k
228		-	else toBase58String(value(be))
	226	+	else toBase58String(value(bd))
229	227
230	228
231		-	func bg (bh) = $Tuple9(addressFromStringValue(bh[u]), ~~parseIntValue~~(bh[v]), ~~fromBase58String~~(bh[w]), bd(bh[x]), bd(bh[y]), parseIntValue(bh[z]), ~~parseIntValue~~(bh[A]), fromBase58String(bh[B])~~, fromBase58String(bh[C]~~))
	229	+	func bf (bg) = $Tuple9(addressFromStringValue(bg[t]), parseIntValue(bg[u]), fromBase58String(bg[v]), bc(bg[w]), bc(bg[x]), parseIntValue(bg[y]), parseIntValue(bg[z]), fromBase58String(bg[A]), fromBase58String(bg[B]))
232	230
233	231
234		-	let bi = bg(aZ())
	232	+	let bh = bf(aY())
235	233
236		-	let bj = bi
	234	+	let bi = bh
237	235
238		-	let bk = bj._1
	236	+	let bj = bi._1
239	237
240		-	let bl = bj._2
	238	+	let bk = bi._2
241	239
242		-	let bm = bj._3
	240	+	let bl = bi._3
243	241
244		-	let bn = bj._4
	242	+	let bm = bi._4
245	243
246		-	let bo = bj._5
	244	+	let bn = bi._5
247	245
248		-	let bp = bj._6
	246	+	let bo = bi._6
249	247
250		-	let bq = bj._7
	248	+	let bp = bi._7
251	249
252		-	let br = bj._8
	250	+	let bq = bi._8
253	251
254		-	let bs = bj._9
	252	+	let br = bi._9
255	253
256		-	func bt () = split(aK(aR, av()), o)
	254	+	func bs () = split(aJ(aQ, au()), n)
257	255
258	256
259		-	let bu = bt()
	257	+	let bt = bs()
260	258
261		-	let bv = valueOrErrorMessage(addressFromString(bu[D]), "Invalid staking contract address")
	259	+	let bu = valueOrErrorMessage(addressFromString(bt[C]), "Invalid staking contract address")
262	260
263		-	let bw = valueOrErrorMessage(addressFromString(bu[F]), "Invalid slipage contract address")
	261	+	let bv = valueOrErrorMessage(addressFromString(bt[E]), "Invalid slipage contract address")
264	262
265		-	let bx = valueOrErrorMessage(addressFromString(bu[G]), "Invalid gwx contract address")
	263	+	let bw = valueOrErrorMessage(addressFromString(bt[F]), "Invalid gwx contract address")
266	264
267		-	let by = valueOrErrorMessage(addressFromString(bu[E]), "Invalid gwx contract address")
	265	+	let bx = valueOrErrorMessage(addressFromString(bt[D]), "Invalid gwx contract address")
268	266
269		-	func bz (bA,bB,bC,bD,bE,bF,bG,bH,bI~~,bJ~~) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI)~~, toString(bJ)~~], o)
	267	+	func by (bz,bA,bB,bC,bD,bE,bF,bG,bH,bI) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE), toString(bF), toString(bG), toString(bH), toString(bI)], n)
270	268
271	269
272		-	func bK (bL,bM,bN,bD,bG~~,bH~~) = makeString(["%d%d%d%d%d%d", toString(bL), toString(bM), toString(bN), toString(bD), toString(bG)~~, toString(bH)~~], o)
	270	+	func bJ (bK,bL,bM,bC,bF,bG) = makeString(["%d%d%d%d%d%d", toString(bK), toString(bL), toString(bM), toString(bC), toString(bF), toString(bG)], n)
273	271
274	272
275		-	func bO (bP) = if ((bP == "WAVES"))
	273	+	func bN (bO) = if ((bO == "WAVES"))
276	274		then wavesBalance(this).available
277		-	else assetBalance(this, fromBase58String(bP))
	275	+	else assetBalance(this, fromBase58String(bO))
278	276
279	277
280		-	func bQ (bR~~,bS~~) = fraction(bR, c, bS)
	278	+	func bP (bQ,bR) = fraction(bQ, c, bR)
281	279
282	280
283		-	func bT (bR,~~bS,Q~~) = fraction(bR, c, bS, Q)
	281	+	func bS (bQ,bR,P) = fraction(bQ, c, bR, P)
284	282
285	283
286		-	func bU (bV,bW~~,bX~~) = {
287		-	let bY = fraction((~~bV - bW~~), b, bW)
288		-	let bZ = ((~~bX - X~~(bY)) > d)
289		-	if (!(bZ))
290		-	then throw(("Big slpg: " + toString(bY)))
291		-	else $Tuple2(bZ, min([bV, bW]))
	284	+	func bT (bU,bV,bW) = {
	285	+	let bX = fraction((bU - bV), b, bV)
	286	+	let bY = ((bW - W(bX)) > d)
	287	+	if (!(bY))
	288	+	then throw(("Big slpg: " + toString(bX)))
	289	+	else $Tuple2(bY, min([bU, bV]))
292	290		}
293	291
294	292
295		-	func ca (cb,cc~~,cd~~) = {
296		-	let bY = fraction(cc, b, cb)
297		-	let ce = (cd > bY)
298		-	if (if (ce)
	293	+	func bZ (ca,cb,cc) = {
	294	+	let bX = fraction(cb, b, ca)
	295	+	let cd = (cc > bX)
	296	+	if (if (cd)
299	297		then true
300		-	else (cc > cb))
301		-	then throw(((((((toString(cc) + " ") + toString(cb)) + " ") + toString(bY)) + " ") + toString(cd)))
302		-	else ce
	298	+	else (cb > ca))
	299	+	then throw(((((((toString(cb) + " ") + toString(ca)) + " ") + toString(bX)) + " ") + toString(cc)))
	300	+	else cd
303	301		}
304	302
305	303
306		-	func cf (cg,ch,ci~~,cj~~) = {
307		-	let ck = I(ci, cg)
308		-	let cl = I(cj, ch)
309		-	bQ(cl, ck)
	304	+	func ce (cf,cg,ch,ci) = {
	305	+	let cj = H(ch, cf)
	306	+	let ck = H(ci, cg)
	307	+	bP(ck, cj)
310	308		}
311	309
312	310
313		-	func cm (ci,cj,cn) = {
	311	+	func cl (ch,ci,cm) = {
	312	+	let cn = bo
314	313		let co = bp
315		-	let cp = bq
316		-	let cq = cf(co, cp, ci, cj)
317		-	let bS = I(ci, co)
318		-	let bR = I(cj, cp)
319		-	let cr = I(cn, a)
320		-	let cs = bQ(bS, cr)
321		-	let ct = bQ(bR, cr)
322		-	[cq, cs, ct]
	314	+	let cp = ce(cn, co, ch, ci)
	315	+	let bR = H(ch, cn)
	316	+	let bQ = H(ci, co)
	317	+	let cq = H(cm, a)
	318	+	let cr = bP(bR, cq)
	319	+	let cs = bP(bQ, cq)
	320	+	[cp, cr, cs]
323	321		}
324	322
325	323
326		-	func cu (ci,~~cj,cn~~) = {
327		-	let cv = cm(ci, ~~cj, cn~~)
328		-	[M(cv[0], a), M(cv[1], a), M(cv[2], a)]
	324	+	func ct (ch,ci,cm) = {
	325	+	let cu = cl(ch, ci, cm)
	326	+	[L(cu[0], a), L(cu[1], a), L(cu[2], a)]
329	327		}
330	328
331	329
332		-	func cw (cx,ap) = {
333		-	let cy = if ((ap == 0))
	330	+	func cv (cw,ao) = {
	331	+	let cx = if ((ao == 0))
334	332		then 0
335		-	else fraction(cx, ap, a)
336		-	$Tuple2((~~cx - cy~~), cy)
	333	+	else fraction(cw, ao, a)
	334	+	$Tuple2((cw - cx), cx)
337	335		}
338	336
339	337
340		-	func cz (cA) = {
341		-	let cB = cA[0]
342		-	let cC = cA[1]
343		-	let cD = (cB + cC)
344		-	if ((cD == e))
	338	+	func cy (cz) = {
	339	+	let cA = cz[0]
	340	+	let cB = cz[1]
	341	+	let cC = (cA + cB)
	342	+	if ((cC == e))
345	343		then e
346	344		else {
347		-	let cE = parseIntValue(aV)
348		-	let cF = (cE * 2)

github/deemru/w8io/873ac7e 
819.47 ms ◑