tx · BDWz5N7ntXe63Yugr3RJtRLBKW9UrBz3xR8TB8MQ3Seh

3N8rRK2qY9gks7UiTZbno3oU9ZxHsjf6Nxg:  -0.03200000 Waves

2022.09.01 20:39 [2210377] smart account 3N8rRK2qY9gks7UiTZbno3oU9ZxHsjf6Nxg > SELF 0.00000000 Waves

{ "type": 13, "id": "BDWz5N7ntXe63Yugr3RJtRLBKW9UrBz3xR8TB8MQ3Seh", "fee": 3200000, "feeAssetId": null, "timestamp": 1662054011163, "version": 2, "chainId": 84, "sender": "3N8rRK2qY9gks7UiTZbno3oU9ZxHsjf6Nxg", "senderPublicKey": "BGaHqWWh2PA55UDpG3EMuoSRrrPo348kqpXax829kygz", "proofs": [ "3CkTVyWjUiTq4nr7AJ3X4sHSS6S3aa2mCwHsZh6sUCBYd19AG4au2CvLn55gqZdHYJqxbw3sD4hhvhDx19fhi1ZT" ], "script": "base64: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", "height": 2210377, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: 5YdwjdmbsLb2JEDf8wDCL6akoENR8wpxrPuiSRFpuTWC Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 1000000
5+
6+let b = 1000000
7+
8+let c = 10
9+
10+let d = 6
11+
12+let e = (86400 / 60)
13+
14+let f = "asset_ids"
15+
16+let g = "_balance"
17+
18+let h = "active"
19+
20+let i = "shutdown_cause"
21+
22+let j = "share_asset_id"
23+
24+let k = "share_asset_supply"
25+
26+let l = "commission"
27+
28+let m = "dAppThresholdCoef"
29+
30+let n = "staking_usdnnsbt_address"
31+
32+let o = "discounts"
33+
34+let p = "discount_values"
35+
36+let q = "_SWOP_amount"
37+
38+let r = "first_harvest"
39+
40+let s = "first_harvest_height"
41+
42+let t = "share_limit_on_first_harvest"
43+
44+let u = "base_period"
45+
46+let v = "period_length"
47+
48+let w = "start_height"
49+
50+let x = "admin_pub_1"
51+
52+let y = "admin_pub_2"
53+
54+let z = "admin_pub_3"
55+
56+let B = "admin_invoke_pub"
57+
58+let C = "money_box_address"
59+
60+let E = "governance_address"
61+
62+let F = "voting_address"
63+
64+let G = "farming_address"
65+
66+let H = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
67+
68+func I (J) = {
69+ let K = getString(H, J)
70+ if ($isInstanceOf(K, "String"))
71+ then {
72+ let L = K
73+ fromBase58String(L)
74+ }
75+ else {
76+ let M = K
77+ throw((J + "is empty"))
78+ }
79+ }
80+
81+
82+let N = I(x)
83+
84+let O = I(y)
85+
86+let P = I(z)
87+
88+let Q = I(B)
89+
90+let R = Address(I(C))
91+
92+let S = Address(I(E))
93+
94+let T = Address(I(n))
95+
96+let U = Address(I(F))
97+
98+let V = Address(I(G))
99+
100+let W = Address(base58'3MxXHaGvmKQHH3kNrPBunhve1sDXf7M5RZt')
101+
102+let X = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
103+
104+let Y = [toBase58String(X)]
105+
106+let Z = valueOrErrorMessage(getInteger(U, u), "Empty kBasePeriod")
107+
108+let aa = valueOrErrorMessage(getInteger(U, w), "Empty kStartHeight")
109+
110+let ab = valueOrErrorMessage(getInteger(U, v), "Empty kPeriodLength")
111+
112+let ac = ((Z + ((height - aa) / ab)) + 3)
113+
114+let ad = getBooleanValue(this, h)
115+
116+let ae = fromBase58String(getStringValue(this, j))
117+
118+let af = getIntegerValue(this, k)
119+
120+let ag = 1000000
121+
122+let ah = getIntegerValue(this, l)
123+
124+let ai = fraction(40, ag, 100)
125+
126+let aj = getIntegerValue(this, "initial_A")
127+
128+let ak = getIntegerValue(this, "future_A")
129+
130+let al = valueOrElse(getInteger(this, "initial_A_time"), 0)
131+
132+let am = valueOrElse(getInteger(this, "future_A_time"), 0)
133+
134+let an = split(getStringValue(this, f), ",")
135+
136+let ao = size(an)
137+
138+func ap (aq) = [BooleanEntry(h, false), StringEntry(i, aq)]
139+
140+
141+func ar () = throw("DApp is already active")
142+
143+
144+func as () = if (ad)
145+ then unit
146+ else throw("DApp is inactive at this moment")
147+
148+
149+func at (au) = if (containsElement([N, O, P], au.callerPublicKey))
150+ then unit
151+ else throw("Only admin can call this function")
152+
153+
154+func av (au) = if ((this == au.caller))
155+ then unit
156+ else throw("Only contract itself can call this function")
157+
158+
159+let aw = toBigInt(2)
160+
161+let ax = height
162+
163+func ay (az) = if (az)
164+ then false
165+ else true
166+
167+
168+func aA (aB) = {
169+ let aC = valueOrElse(getInteger(S, (toString(aB) + q)), 0)
170+ let aD = split(getStringValue(H, p), ",")
171+ let aE = split(getStringValue(H, o), ",")
172+ if (if ((aC >= parseIntValue(aD[0])))
173+ then (parseIntValue(aD[1]) > aC)
174+ else false)
175+ then (ag - parseIntValue(aE[0]))
176+ else if (if ((aC >= parseIntValue(aD[1])))
177+ then (parseIntValue(aD[2]) > aC)
178+ else false)
179+ then (ag - parseIntValue(aE[1]))
180+ else if (if ((aC >= parseIntValue(aD[2])))
181+ then (parseIntValue(aD[3]) > aC)
182+ else false)
183+ then (ag - parseIntValue(aE[2]))
184+ else if (if ((aC >= parseIntValue(aD[3])))
185+ then (parseIntValue(aD[4]) > aC)
186+ else false)
187+ then (ag - parseIntValue(aE[3]))
188+ else if ((aC >= parseIntValue(aD[4])))
189+ then (ag - parseIntValue(aE[4]))
190+ else ag
191+ }
192+
193+
194+func aF () = {
195+ let aG = am
196+ let aH = ak
197+ if ((aG > ax))
198+ then {
199+ let aI = aj
200+ let aJ = al
201+ if ((aH > aI))
202+ then (aI + (((aH - aI) * (ax - aJ)) / (aG - aJ)))
203+ else (aI - (((aI - aH) * (ax - aJ)) / (aG - aJ)))
204+ }
205+ else aH
206+ }
207+
208+
209+func aK () = {
210+ func aL (aM,aN) = (aM :+ valueOrElse(getInteger(this, (aN + g)), 0))
211+
212+ let aO = an
213+ let aP = size(aO)
214+ let aQ = nil
215+ func aR (aS,aT) = if ((aT >= aP))
216+ then aS
217+ else aL(aS, aO[aT])
218+
219+ func aU (aS,aT) = if ((aT >= aP))
220+ then aS
221+ else throw("List size exceeds 15")
222+
223+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
224+ }
225+
226+
227+func aV (aW) = aW
228+
229+
230+func aX (aM,aY) = (aM + aY)
231+
232+
233+func aZ (aW,ba) = {
234+ let bb = invoke(this, "D", [aW, ba], nil)
235+ if ($isInstanceOf(bb, "Int"))
236+ then bb
237+ else throw(($getType(invoke(this, "D", [aW, ba], nil)) + " couldn't be cast to Int"))
238+ }
239+
240+
241+func bc (aW,ba) = {
242+ let bd = {
243+ let aO = aW
244+ let aP = size(aO)
245+ let aQ = 0
246+ func aR (aS,aT) = if ((aT >= aP))
247+ then aS
248+ else aX(aS, aO[aT])
249+
250+ func aU (aS,aT) = if ((aT >= aP))
251+ then aS
252+ else throw("List size exceeds 15")
253+
254+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
255+ }
256+ if ((bd == 0))
257+ then 0
258+ else {
259+ let be = (ba * ao)
260+ let bf = (toBigInt(be) * toBigInt(bd))
261+ let bg = toBigInt((be - 1))
262+ func bh (aM,au) = if ((aM._2 == true))
263+ then aM
264+ else {
265+ let bi = aM._1
266+ func bj (bk,au) = if ((ao > au))
267+ then ((bk * bi) / (toBigInt(aW[au]) * toBigInt(ao)))
268+ else bk
269+
270+ let bk = {
271+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
272+ let aP = size(aO)
273+ let aQ = bi
274+ func bl (aS,aT) = if ((aT >= aP))
275+ then aS
276+ else bj(aS, aO[aT])
277+
278+ func bm (aS,aT) = if ((aT >= aP))
279+ then aS
280+ else throw("List size exceeds 15")
281+
282+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
283+ }
284+ let bn = fraction((bf + (toBigInt(ao) * bk)), bi, ((bg * bi) + (toBigInt((ao + 1)) * bk)))
285+ if ((bn > bi))
286+ then if ((1 >= toInt((bn - bi))))
287+ then $Tuple2(bn, true)
288+ else $Tuple2(bn, false)
289+ else if ((1 >= toInt((bi - bn))))
290+ then $Tuple2(bn, true)
291+ else $Tuple2(bn, false)
292+ }
293+
294+ let bo = {
295+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
296+ let aP = size(aO)
297+ let aQ = $Tuple2(toBigInt(bd), false)
298+ func bl (aS,aT) = if ((aT >= aP))
299+ then aS
300+ else bh(aS, aO[aT])
301+
302+ func bm (aS,aT) = if ((aT >= aP))
303+ then aS
304+ else throw("List size exceeds 15")
305+
306+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
307+ }
308+ let bn = bo._1
309+ let bp = bo._2
310+ if ((bp == false))
311+ then throw(("get_D() not finished with " + toString(bn)))
312+ else toInt(bn)
313+ }
314+ }
315+
316+
317+func bq (aW,ba) = aZ(aV(aW), ba)
318+
319+
320+func br (bs,bt,bu,bv) = if (ay((bs != bt)))
321+ then throw("same coin")
322+ else if (ay(if ((bt >= 0))
323+ then (bs >= 0)
324+ else false))
325+ then throw("below zero")
326+ else if (ay(if ((ao > bt))
327+ then (ao > bs)
328+ else false))
329+ then throw("above N_COINS")
330+ else {
331+ let ba = aF()
332+ let bn = aZ(bv, ba)
333+ let be = (ba * ao)
334+ func bw (aM,au) = {
335+ let bx = aM
336+ let by = bx._1
337+ let bz = bx._2
338+ let bA = if ((bs == au))
339+ then bu
340+ else bv[au]
341+ if (if ((au != bt))
342+ then (ao > au)
343+ else false)
344+ then $Tuple2((by + bA), fraction(bz, toBigInt(bn), toBigInt((bA * ao))))
345+ else $Tuple2(by, bz)
346+ }
347+
348+ let bB = {
349+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
350+ let aP = size(aO)
351+ let aQ = $Tuple2(0, toBigInt(bn))
352+ func aR (aS,aT) = if ((aT >= aP))
353+ then aS
354+ else bw(aS, aO[aT])
355+
356+ func aU (aS,aT) = if ((aT >= aP))
357+ then aS
358+ else throw("List size exceeds 15")
359+
360+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
361+ }
362+ let by = bB._1
363+ let bC = bB._2
364+ let bz = fraction(bC, toBigInt(bn), toBigInt((be * ao)))
365+ let bD = toBigInt(((by + (bn / be)) - bn))
366+ func bE (aM,bF) = if ((aM._2 == true))
367+ then aM
368+ else {
369+ let bG = aM._1
370+ let bH = (((bG * bG) + bz) / ((aw * bG) + bD))
371+ if ((bH > bG))
372+ then if ((1 >= toInt((bH - bG))))
373+ then $Tuple2(bH, true)
374+ else $Tuple2(bH, false)
375+ else if ((1 >= toInt((bG - bH))))
376+ then $Tuple2(bH, true)
377+ else $Tuple2(bH, false)
378+ }
379+
380+ let bI = {
381+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
382+ let aP = size(aO)
383+ let aQ = $Tuple2(toBigInt(bn), false)
384+ func bl (aS,aT) = if ((aT >= aP))
385+ then aS
386+ else bE(aS, aO[aT])
387+
388+ func bm (aS,aT) = if ((aT >= aP))
389+ then aS
390+ else throw("List size exceeds 16")
391+
392+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
393+ }
394+ let bH = bI._1
395+ let bp = bI._2
396+ if ((bp == false))
397+ then throw(("getY() not finished with " + toString(bH)))
398+ else toInt(bH)
399+ }
400+
401+
402+func bJ (bK,bs,aW,bn) = if (ay((bs >= 0)))
403+ then throw("i below zero")
404+ else if (ay((ao > bs)))
405+ then throw("i above N_COINS")
406+ else {
407+ let be = (bK * ao)
408+ func bw (aM,au) = {
409+ let bL = aM
410+ let by = bL._1
411+ let bz = bL._2
412+ let bA = if (if ((bs != au))
413+ then (ao > au)
414+ else false)
415+ then aW[au]
416+ else 0
417+ if (if ((ao > au))
418+ then (bs != au)
419+ else false)
420+ then $Tuple2((by + bA), fraction(bz, toBigInt(bn), toBigInt((bA * ao))))
421+ else $Tuple2(by, bz)
422+ }
423+
424+ let bM = {
425+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
426+ let aP = size(aO)
427+ let aQ = $Tuple2(0, toBigInt(bn))
428+ func aR (aS,aT) = if ((aT >= aP))
429+ then aS
430+ else bw(aS, aO[aT])
431+
432+ func aU (aS,aT) = if ((aT >= aP))
433+ then aS
434+ else throw("List size exceeds 15")
435+
436+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
437+ }
438+ let by = bM._1
439+ let bC = bM._2
440+ let bz = fraction(bC, toBigInt(bn), toBigInt((be * ao)))
441+ let bD = toBigInt(((by + (bn / be)) - bn))
442+ func bN (aM,au) = if ((aM._2 == true))
443+ then aM
444+ else {
445+ let bG = aM._1
446+ let bH = (((bG * bG) + bz) / ((aw * bG) + bD))
447+ if ((bH > bG))
448+ then if ((1 >= toInt((bH - bG))))
449+ then $Tuple2(bH, true)
450+ else $Tuple2(bH, false)
451+ else if ((1 >= toInt((bG - bH))))
452+ then $Tuple2(bH, true)
453+ else $Tuple2(bH, false)
454+ }
455+
456+ let bO = {
457+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
458+ let aP = size(aO)
459+ let aQ = $Tuple2(toBigInt(bn), false)
460+ func bl (aS,aT) = if ((aT >= aP))
461+ then aS
462+ else bN(aS, aO[aT])
463+
464+ func bm (aS,aT) = if ((aT >= aP))
465+ then aS
466+ else throw("List size exceeds 16")
467+
468+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
469+ }
470+ let bH = bO._1
471+ let bp = bO._2
472+ if ((bp == false))
473+ then throw(("get_y_D() not finished with " + toString(bH)))
474+ else toInt(bH)
475+ }
476+
477+
478+func bP (aW,bQ,au,bR) = {
479+ let bS = aA(bR)
480+ let ba = aF()
481+ let bT = ((fraction(ah, bS, ag, CEILING) * ao) / (4 * (ao - 1)))
482+ let bU = af
483+ let bV = aZ(aW, ba)
484+ let bW = (bV - fraction(bQ, bV, bU))
485+ let bX = bJ(ba, au, aW, bW)
486+ let bY = (aW[au] - bX)
487+ func bZ (aM,ca) = {
488+ let cb = aM
489+ let cc = cb._1
490+ let cd = cb._2
491+ let ce = if ((cd == au))
492+ then (fraction(ca, bW, bV) - bX)
493+ else (ca - fraction(ca, bW, bV))
494+ $Tuple2((cc :+ (ca - fraction(bT, ce, ag))), (cd + 1))
495+ }
496+
497+ let cf = {
498+ let aO = aW
499+ let aP = size(aO)
500+ let aQ = $Tuple2(nil, 0)
501+ func aR (aS,aT) = if ((aT >= aP))
502+ then aS
503+ else bZ(aS, aO[aT])
504+
505+ func aU (aS,aT) = if ((aT >= aP))
506+ then aS
507+ else throw("List size exceeds 15")
508+
509+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
510+ }
511+ let cc = cf._1
512+ let cd = cf._2
513+ let cg = cc[au]
514+ let ch = ((cg - bJ(ba, au, cc, bW)) - 1)
515+ $Tuple2(ch, (bY - ch))
516+ }
517+
518+
519+func ci (aN) = {
520+ let K = aN
521+ if ($isInstanceOf(K, "ByteVector"))
522+ then {
523+ let cj = K
524+ toBase58String(cj)
525+ }
526+ else if ($isInstanceOf(K, "Unit"))
527+ then {
528+ let ck = K
529+ "WAVES"
530+ }
531+ else throw("Match error")
532+ }
533+
534+
535+func cl (cm,aN) = if (cm)
536+ then $Tuple2("lockNeutrino", T)
537+ else $Tuple2("unlockNeutrino", T)
538+
539+
540+func cn (cm,co,aN) = if (cm)
541+ then {
542+ let cp = cl(cm, aN)
543+ let cq = cp._1
544+ let cr = cp._2
545+ $Tuple4(cq, cr, nil, [AttachedPayment(aN, co)])
546+ }
547+ else {
548+ let cs = cl(cm, aN)
549+ let cq = cs._1
550+ let cr = cs._2
551+ $Tuple4(cq, cr, [co, toBase58String(aN)], nil)
552+ }
553+
554+
555+func cm (co,ct) = if (containsElement(Y, ct))
556+ then {
557+ let cu = cn(true, co, fromBase58String(ct))
558+ let cq = cu._1
559+ let cv = cu._2
560+ let cw = cu._3
561+ let cx = cu._4
562+ invoke(cv, cq, cw, cx)
563+ }
564+ else 0
565+
566+
567+func cy (co,ct) = if (containsElement(Y, ct))
568+ then {
569+ let cz = cn(false, co, fromBase58String(ct))
570+ let cq = cz._1
571+ let cv = cz._2
572+ let cw = cz._3
573+ let cx = cz._4
574+ invoke(cv, cq, cw, cx)
575+ }
576+ else 0
577+
578+
579+func cA (aN) = {
580+ let cB = {
581+ let K = aN
582+ if ($isInstanceOf(K, "ByteVector"))
583+ then {
584+ let cC = K
585+ if ((cC == X))
586+ then getInteger(T, ((("rpd_balance_" + toBase58String(cC)) + "_") + toString(this)))
587+ else 0
588+ }
589+ else if ($isInstanceOf(K, "Unit"))
590+ then 0
591+ else throw("Match error")
592+ }
593+ let K = cB
594+ if ($isInstanceOf(K, "Int"))
595+ then {
596+ let au = K
597+ au
598+ }
599+ else 0
600+ }
601+
602+
603+func cD () = {
604+ let cE = aK()
605+ func cF (aM,aN) = {
606+ let cG = aM
607+ let cH = cG._1
608+ let au = cG._2
609+ if (cH)
610+ then $Tuple2(cH, au)
611+ else {
612+ let cI = (assetBalance(this, fromBase58String(aN)) + cA(fromBase58String(aN)))
613+ if ((cE[au] > cI))
614+ then $Tuple2(true, au)
615+ else $Tuple2(false, (au + 1))
616+ }
617+ }
618+
619+ let aO = an
620+ let aP = size(aO)
621+ let aQ = $Tuple2(false, 0)
622+ func aR (aS,aT) = if ((aT >= aP))
623+ then aS
624+ else cF(aS, aO[aT])
625+
626+ func aU (aS,aT) = if ((aT >= aP))
627+ then aS
628+ else throw("List size exceeds 15")
629+
630+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
631+ }
632+
633+
634+func cJ (au) = ap(("Suspicious state with asset: " + an[au]))
635+
636+
637+func cK (bR,cx) = {
638+ func cL (aM,cM) = (aM :+ ScriptTransfer(bR, cM.amount, cM.assetId))
639+
640+ let aO = cx
641+ let aP = size(aO)
642+ let aQ = nil
643+ func aR (aS,aT) = if ((aT >= aP))
644+ then aS
645+ else cL(aS, aO[aT])
646+
647+ func aU (aS,aT) = if ((aT >= aP))
648+ then aS
649+ else throw("List size exceeds 15")
650+
651+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
652+ }
653+
654+
655+func cN (cO) = {
656+ let cP = valueOrErrorMessage(getInteger(this, m), "No dAppThresholdCoef key")
657+ let cQ = 10000
658+ let cR = max(cO)
659+ let cS = min(cO)
660+ let cT = fraction(cR, cQ, cS)
661+ if ((cT > (cP * cQ)))
662+ then throw("New balance in assets of the DApp is less than threshold")
663+ else false
664+ }
665+
666+
667+func cU (an) = {
668+ let cV = split(an, ",")
669+ func cW (cX,aN) = {
670+ let cY = valueOrErrorMessage(fromBase58String(aN), ("fromBase58String: " + aN))
671+ let cZ = valueOrErrorMessage(assetInfo(cY), ("assetInfo: " + aN)).decimals
672+ if ((cZ != d))
673+ then throw("wrong decimals")
674+ else false
675+ }
676+
677+ let aO = cV
678+ let aP = size(aO)
679+ let aQ = false
680+ func aR (aS,aT) = if ((aT >= aP))
681+ then aS
682+ else cW(aS, aO[aT])
683+
684+ func aU (aS,aT) = if ((aT >= aP))
685+ then aS
686+ else throw("List size exceeds 15")
687+
688+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
689+ }
690+
691+
692+@Callable(da)
693+func D (aW,ba) = {
694+ let bn = bc(aW, ba)
695+ $Tuple2([IntegerEntry("D", bn)], bn)
696+ }
697+
698+
699+
700+@Callable(da)
701+func init (an,aF,db) = if (!(isDataStorageUntouched(this)))
702+ then throw("Already initialized")
703+ else {
704+ let dc = "s_Multi_USD"
705+ let dd = ("ShareToken of SwopFi protocol for MultiStable USD pool at address " + toString(this))
706+ let de = Issue(dc, dd, 0, 6, true)
707+ let df = calculateAssetId(de)
708+ if (cU(an))
709+ then throw()
710+ else {
711+ let dg = [StringEntry(f, an), IntegerEntry("initial_A", aF), IntegerEntry("future_A", aF), IntegerEntry(l, getIntegerValue(H, "base_fee_flat")), StringEntry(j, toBase58String(df)), IntegerEntry(k, 0), IntegerEntry(m, 15), BooleanEntry(h, true), de]
712+ if (db)
713+ then (dg ++ [BooleanEntry(r, db), IntegerEntry(s, (aa + (ac * ab)))])
714+ else dg
715+ }
716+ }
717+
718+
719+
720+@Callable(da)
721+func addLiquidity (dh,di) = valueOrElse(as(), {
722+ let ba = aF()
723+ let aW = aK()
724+ let bV = if ((af == 0))
725+ then 0
726+ else bq(aW, ba)
727+ let cx = da.payments
728+ let dj = size(cx)
729+ func dk (dl) = if ((dj > ao))
730+ then throw(("payments size > " + toString(ao)))
731+ else if ((1 > dj))
732+ then throw("payments size < 1")
733+ else if (if ((af == 0))
734+ then (ao != dj)
735+ else false)
736+ then throw("initial deposit requires all coins")
737+ else {
738+ func dm (aM,cM) = if (containsElement(an, ci(cM.assetId)))
739+ then true
740+ else throw("Invalid asset in payment")
741+
742+ let aO = cx
743+ let aP = size(aO)
744+ let aQ = false
745+ func aR (aS,aT) = if ((aT >= aP))
746+ then aS
747+ else dm(aS, aO[aT])
748+
749+ func aU (aS,aT) = if ((aT >= aP))
750+ then aS
751+ else throw("List size exceeds 15")
752+
753+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
754+ }
755+
756+ if (!(dk(dj)))
757+ then throw()
758+ else {
759+ let cH = cD()
760+ if (cH._1)
761+ then (cJ(cH._2) ++ cK(da.caller, cx))
762+ else {
763+ func cL (aM,aN) = {
764+ let dn = aM
765+ let cO = dn._1
766+ let au = dn._2
767+ let do = dn._3
768+ if (if ((dj > do))
769+ then (ci(cx[do].assetId) == aN)
770+ else false)
771+ then $Tuple3((cO :+ (aW[au] + cx[do].amount)), (au + 1), (do + 1))
772+ else $Tuple3((cO :+ aW[au]), (au + 1), do)
773+ }
774+
775+ let dp = {
776+ let aO = an
777+ let aP = size(aO)
778+ let aQ = $Tuple3(nil, 0, 0)
779+ func aR (aS,aT) = if ((aT >= aP))
780+ then aS
781+ else cL(aS, aO[aT])
782+
783+ func aU (aS,aT) = if ((aT >= aP))
784+ then aS
785+ else throw("List size exceeds 15")
786+
787+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
788+ }
789+ let cO = dp._1
790+ let dq = dp._2
791+ let dr = dp._3
792+ if ((dj > dr))
793+ then throw("Incorect payments order")
794+ else if (cN(cO))
795+ then throw()
796+ else {
797+ let bW = bq(cO, ba)
798+ if (ay((bW > bV)))
799+ then throw("D1 > D0")
800+ else {
801+ let bS = aA(da.caller)
802+ func ds (aM,dt) = {
803+ let du = aM
804+ let dv = du._1
805+ let dw = du._2
806+ let au = du._3
807+ if ((af > 0))
808+ then {
809+ let bT = ((fraction(ah, bS, ag, CEILING) * ao) / (4 * (ao - 1)))
810+ let dx = {
811+ let dy = fraction(bW, aW[au], bV)
812+ let dz = if ((dy > dt))
813+ then (dy - dt)
814+ else (dt - dy)
815+ fraction(bT, dz, ag)
816+ }
817+ let dA = fraction(dx, ai, ag)
818+ let dB = (dt - dx)
819+ let dC = (dt - dx)
820+ let dD = (dt - aW[au])
821+ let dE = if ((dD > 0))
822+ then cm((dD - dx), an[au])
823+ else cy(dx, an[au])
824+ $Tuple3((dv :+ dC), (dw ++ [ScriptTransfer(W, (dx - dA), fromBase58String(an[au])), ScriptTransfer(R, dA, fromBase58String(an[au])), IntegerEntry((an[au] + g), dB)]), (au + 1))
825+ }
826+ else $Tuple3((dv :+ dt), (dw :+ IntegerEntry((an[au] + g), dt)), (au + 1))
827+ }
828+
829+ let dF = {
830+ let aO = cO
831+ let aP = size(aO)
832+ let aQ = $Tuple3(nil, nil, 0)
833+ func bl (aS,aT) = if ((aT >= aP))
834+ then aS
835+ else ds(aS, aO[aT])
836+
837+ func bm (aS,aT) = if ((aT >= aP))
838+ then aS
839+ else throw("List size exceeds 15")
840+
841+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
842+ }
843+ let dv = dF._1
844+ let dw = dF._2
845+ let dG = bq(dv, ba)
846+ let dH = if ((af == 0))
847+ then bW
848+ else fraction(af, (dG - bV), bV)
849+ if (ay((dH >= dh)))
850+ then throw("Slippage screwed you")
851+ else if (di)
852+ then {
853+ let dI = invoke(this, "reissueShare", [dH], nil)
854+ if ((dI == dI))
855+ then {
856+ let dJ = invoke(V, "lockShareTokens", [toString(this)], [AttachedPayment(ae, dH)])
857+ if ((dJ == dJ))
858+ then (dw :+ IntegerEntry(k, (af + dH)))
859+ else throw("Strict value is not equal to itself.")
860+ }
861+ else throw("Strict value is not equal to itself.")
862+ }
863+ else (dw ++ [Reissue(ae, dH, true), ScriptTransfer(da.caller, dH, ae), IntegerEntry(k, (af + dH))])
864+ }
865+ }
866+ }
867+ }
868+ })
869+
870+
871+
872+@Callable(da)
873+func reissueShare (co) = valueOrElse(av(da), [Reissue(ae, co, true)])
874+
875+
876+
877+@Callable(da)
878+func getDy (dK,dL,dM,dN) = {
879+ let aW = aK()
880+ let dO = valueOrErrorMessage(indexOf(an, dK), "unknown token in")
881+ let dP = valueOrErrorMessage(indexOf(an, dL), "unknown token out")
882+ let bu = (aW[dO] + dM)
883+ let bH = br(dO, dP, bu, aW)
884+ let ch = ((aW[dP] - bH) - 1)
885+ let bS = aA(Address(fromBase58String(dN)))
886+ let bT = fraction(fraction(ah, bS, ag, CEILING), ch, ag)
887+ $Tuple2(nil, $Tuple2((ch - bT), bT))
888+ }
889+
890+
891+
892+@Callable(da)
893+func exchange (dQ,dR) = valueOrElse(as(), if ((size(da.payments) != 1))
894+ then throw("size(payments) != 1")
895+ else {
896+ let cH = cD()
897+ if (cH._1)
898+ then (cJ(cH._2) ++ cK(da.caller, da.payments))
899+ else {
900+ let cM = da.payments[0]
901+ let dS = ci(cM.assetId)
902+ let dT = fromBase58String(dQ)
903+ let dM = cM.amount
904+ let dO = valueOrErrorMessage(indexOf(an, dS), "unknown token in")
905+ let dP = valueOrErrorMessage(indexOf(an, dQ), "unknown token out")
906+ let aW = aK()
907+ let bu = (aW[dO] + dM)
908+ let bH = br(dO, dP, bu, aW)
909+ let dU = ((aW[dP] - bH) - 1)
910+ let bS = aA(da.caller)
911+ let bT = fraction(dU, fraction(ah, bS, ag, CEILING), ag)
912+ let ch = (dU - bT)
913+ let dA = fraction(bT, ai, ag)
914+ if (ay((ch >= dR)))
915+ then throw("Exchange resulted in fewer coins than expected")
916+ else {
917+ func dV (aM,dW) = {
918+ let dX = aM
919+ let cO = dX._1
920+ let au = dX._2
921+ if ((au == dO))
922+ then $Tuple2((cO :+ (dW + dM)), (au + 1))
923+ else if ((au == dP))
924+ then $Tuple2((cO :+ (dW - dU)), (au + 1))
925+ else $Tuple2((cO :+ dW), (au + 1))
926+ }
927+
928+ let dY = {
929+ let aO = aW
930+ let aP = size(aO)
931+ let aQ = $Tuple2(nil, 0)
932+ func aR (aS,aT) = if ((aT >= aP))
933+ then aS
934+ else dV(aS, aO[aT])
935+
936+ func aU (aS,aT) = if ((aT >= aP))
937+ then aS
938+ else throw("List size exceeds 15")
939+
940+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
941+ }
942+ let cO = dY._1
943+ let au = dY._2
944+ if (cN(cO))
945+ then throw()
946+ else {
947+ let dJ = cm(cM.amount, ci(cM.assetId))
948+ if ((dJ == dJ))
949+ then {
950+ let dZ = cy(dU, dQ)
951+ if ((dZ == dZ))
952+ then $Tuple2([IntegerEntry((dS + g), bu), IntegerEntry((dQ + g), (aW[dP] - dU)), ScriptTransfer(da.caller, ch, dT), ScriptTransfer(R, dA, dT), ScriptTransfer(W, (bT - dA), dT)], $Tuple2(ch, dT))
953+ else throw("Strict value is not equal to itself.")
954+ }
955+ else throw("Strict value is not equal to itself.")
956+ }
957+ }
958+ }
959+ })
960+
961+
962+
963+@Callable(da)
964+func withdraw (ea) = valueOrElse(as(), if ((size(da.payments) != 1))
965+ then throw("size(payments) != 1")
966+ else {
967+ let eb = da.payments[0].amount
968+ let ec = da.payments[0].assetId
969+ if ((ae != ec))
970+ then throw("unknown payment token")
971+ else {
972+ let cH = cD()
973+ if (cH._1)
974+ then (cJ(cH._2) ++ cK(da.originCaller, da.payments))
975+ else {
976+ func ds (aM,ed) = {
977+ let ee = aM
978+ let dw = ee._1
979+ let au = ee._2
980+ let ef = fraction(ed, eb, af)
981+ if (ay((ef >= ea[au])))
982+ then throw("Withdrawal resulted in fewer coins than expected")
983+ else {
984+ let dZ = cy(ef, an[au])
985+ if ((dZ == dZ))
986+ then $Tuple2((dw ++ [IntegerEntry((an[au] + g), (ed - ef)), ScriptTransfer(da.originCaller, ef, fromBase58String(an[au]))]), (au + 1))
987+ else throw("Strict value is not equal to itself.")
988+ }
989+ }
990+
991+ let eg = {
992+ let aO = aK()
993+ let aP = size(aO)
994+ let aQ = $Tuple2(nil, 0)
995+ func aR (aS,aT) = if ((aT >= aP))
996+ then aS
997+ else ds(aS, aO[aT])
998+
999+ func aU (aS,aT) = if ((aT >= aP))
1000+ then aS
1001+ else throw("List size exceeds 15")
1002+
1003+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1004+ }
1005+ let dw = eg._1
1006+ let au = eg._2
1007+ (dw ++ [Burn(ae, eb), IntegerEntry(k, (af - eb))])
1008+ }
1009+ }
1010+ })
1011+
1012+
1013+
1014+@Callable(da)
1015+func withdrawWithUnlock (ea,eh) = valueOrElse(as(), if ((0 >= eh))
1016+ then throw("Unlock amount must be positive")
1017+ else {
1018+ let cH = cD()
1019+ if (cH._1)
1020+ then (cJ(cH._2) ++ cK(da.caller, da.payments))
1021+ else {
1022+ let eb = if ((size(da.payments) > 0))
1023+ then if ((size(da.payments) != 1))
1024+ then throw("size(payments) != 1")
1025+ else {
1026+ let ec = da.payments[0].assetId
1027+ if ((ae != ec))
1028+ then throw("unknown payment token")
1029+ else da.payments[0].amount
1030+ }
1031+ else 0
1032+ let ei = invoke(V, "withdrawShareTokens", [toString(this), eh], nil)
1033+ if ((ei == ei))
1034+ then {
1035+ let ej = (eb + eh)
1036+ let dE = invoke(this, "withdraw", [ea], [AttachedPayment(ae, ej)])
1037+ if ((dE == dE))
1038+ then nil
1039+ else throw("Strict value is not equal to itself.")
1040+ }
1041+ else throw("Strict value is not equal to itself.")
1042+ }
1043+ })
1044+
1045+
1046+
1047+@Callable(da)
1048+func calcWithdrawOneCoin (ek,dQ,el) = {
1049+ let au = valueOrErrorMessage(indexOf(an, dQ), "unknown token out")
1050+ $Tuple2(nil, bP(aK(), ek, au, Address(fromBase58String(el)))._1)
1051+ }
1052+
1053+
1054+
1055+@Callable(da)
1056+func withdrawOneCoin (dQ,em) = valueOrElse(as(), if ((size(da.payments) != 1))
1057+ then throw("size(payments) != 1")
1058+ else {
1059+ let cH = cD()
1060+ if (cH._1)
1061+ then (cJ(cH._2) ++ cK(da.originCaller, da.payments))
1062+ else {
1063+ let eb = da.payments[0].amount
1064+ let ec = da.payments[0].assetId
1065+ if ((ec != ae))
1066+ then throw("unknown token")
1067+ else {
1068+ let en = valueOrErrorMessage(indexOf(an, dQ), "unknown token out")
1069+ let aW = aK()
1070+ let eo = bP(aW, eb, en, da.originCaller)
1071+ let ch = eo._1
1072+ let ep = eo._2
1073+ if (ay((ch >= em)))
1074+ then throw("Not enough coins removed")
1075+ else {
1076+ let dA = fraction(ep, ai, ag)
1077+ let eq = (ch + ep)
1078+ func dV (aM,dW) = {
1079+ let er = aM
1080+ let cO = er._1
1081+ let au = er._2
1082+ if ((au == en))
1083+ then $Tuple2((cO :+ (dW - eq)), (au + 1))
1084+ else $Tuple2((cO :+ dW), (au + 1))
1085+ }
1086+
1087+ let es = {
1088+ let aO = aW
1089+ let aP = size(aO)
1090+ let aQ = $Tuple2(nil, 0)
1091+ func aR (aS,aT) = if ((aT >= aP))
1092+ then aS
1093+ else dV(aS, aO[aT])
1094+
1095+ func aU (aS,aT) = if ((aT >= aP))
1096+ then aS
1097+ else throw("List size exceeds 15")
1098+
1099+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1100+ }
1101+ let cO = es._1
1102+ let et = es._2
1103+ if (cN(cO))
1104+ then throw()
1105+ else {
1106+ let dZ = cy(eq, dQ)
1107+ if ((dZ == dZ))
1108+ then [ScriptTransfer(da.originCaller, ch, fromBase58String(dQ)), IntegerEntry((an[en] + g), (aW[en] - eq)), Burn(ae, eb), ScriptTransfer(R, dA, fromBase58String(dQ)), ScriptTransfer(W, (ep - dA), fromBase58String(dQ)), IntegerEntry(k, (af - eb))]
1109+ else throw("Strict value is not equal to itself.")
1110+ }
1111+ }
1112+ }
1113+ }
1114+ })
1115+
1116+
1117+
1118+@Callable(da)
1119+func withdrawOneCoinWithUnlock (dQ,em,eh) = valueOrElse(as(), if ((0 >= eh))
1120+ then throw("Unlock amount must be positive")
1121+ else {
1122+ let cH = cD()
1123+ if (cH._1)
1124+ then (cJ(cH._2) ++ cK(da.caller, da.payments))
1125+ else {
1126+ let eb = if ((size(da.payments) > 0))
1127+ then if ((size(da.payments) != 1))
1128+ then throw("size(payments) != 1")
1129+ else {
1130+ let ec = da.payments[0].assetId
1131+ if ((ae != ec))
1132+ then throw("unknown payment token")
1133+ else da.payments[0].amount
1134+ }
1135+ else 0
1136+ let ei = invoke(V, "withdrawShareTokens", [toString(this), eh], nil)
1137+ if ((ei == ei))
1138+ then {
1139+ let ej = (eb + eh)
1140+ let dE = invoke(this, "withdrawOneCoin", [dQ, em], [AttachedPayment(ae, ej)])
1141+ if ((dE == dE))
1142+ then nil
1143+ else throw("Strict value is not equal to itself.")
1144+ }
1145+ else throw("Strict value is not equal to itself.")
1146+ }
1147+ })
1148+
1149+
1150+
1151+@Callable(da)
1152+func A () = $Tuple2(nil, aF())
1153+
1154+
1155+
1156+@Callable(da)
1157+func getVirtualPrice () = {
1158+ let bn = aZ(aK(), aF())
1159+ $Tuple2(nil, fraction(bn, a, af))
1160+ }
1161+
1162+
1163+
1164+@Callable(da)
1165+func calcTokenAmount (eu,ev) = {
1166+ let ba = aF()
1167+ let ew = aK()
1168+ let bV = bq(ew, ba)
1169+ func ex (aM,ed) = {
1170+ let ey = aM
1171+ let cO = ey._1
1172+ let au = ey._2
1173+ let dt = (ed + (if (ev)
1174+ then eu[au]
1175+ else -(eu[au])))
1176+ $Tuple2((cO :+ dt), (au + 1))
1177+ }
1178+
1179+ let cO = ( let aO = ew
1180+ let aP = size(aO)
1181+ let aQ = $Tuple2(nil, 0)
1182+ func aR (aS,aT) = if ((aT >= aP))
1183+ then aS
1184+ else ex(aS, aO[aT])
1185+
1186+ func aU (aS,aT) = if ((aT >= aP))
1187+ then aS
1188+ else throw("List size exceeds 15")
1189+
1190+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15))._1
1191+ let bW = bq(cO, ba)
1192+ let ez = if (ev)
1193+ then (bW - bV)
1194+ else (bV - bW)
1195+ $Tuple2(nil, fraction(ez, af, bV))
1196+ }
1197+
1198+
1199+
1200+@Callable(da)
1201+func rampA (eA,eB) = valueOrElse(as(), valueOrElse(at(da), if (ay((ax >= (al + e))))
1202+ then throw("too often")
1203+ else if (ay((eB >= (ax + e))))
1204+ then throw("insufficient time")
1205+ else {
1206+ let eC = aF()
1207+ if (ay(if ((eA > 0))
1208+ then (b > eA)
1209+ else false))
1210+ then throw("out of base range")
1211+ else if (ay(if (if ((eA >= eC))
1212+ then ((eC * c) >= eA)
1213+ else false)
1214+ then true
1215+ else if ((eC > eA))
1216+ then ((eA * c) >= eC)
1217+ else false))
1218+ then throw("out of range")
1219+ else [IntegerEntry("initial_A", eC), IntegerEntry("future_A", eA), IntegerEntry("initial_A_time", ax), IntegerEntry("future_A_time", eB)]
1220+ }))
1221+
1222+
1223+
1224+@Callable(da)
1225+func stopRampA () = valueOrElse(as(), valueOrElse(at(da), {
1226+ let eD = aF()
1227+[IntegerEntry("initial_A", eD), IntegerEntry("future_A", eD), IntegerEntry("initial_A_time", ax), IntegerEntry("future_A_time", ax)]
1228+ }))
1229+
1230+
1231+
1232+@Callable(da)
1233+func shutdown () = valueOrElse(at(da), if (!(ad))
1234+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, i), "the cause wasn't specified")))
1235+ else ap("Paused by admin"))
1236+
1237+
1238+
1239+@Callable(da)
1240+func activate () = valueOrElse(at(da), if (ad)
1241+ then ar()
1242+ else [BooleanEntry(h, true), DeleteEntry(i)])
1243+
1244+
1245+
1246+@Callable(da)
1247+func keepLimitForFirstHarvest (eE) = valueOrElse(as(), valueOrElse(at(da), [IntegerEntry(t, eE)]))
1248+
1249+
1250+@Verifier(eF)
1251+func eG () = {
1252+ let eH = {
1253+ let eI = if (sigVerify(eF.bodyBytes, eF.proofs[0], N))
1254+ then 1
1255+ else 0
1256+ let eJ = if (sigVerify(eF.bodyBytes, eF.proofs[1], O))
1257+ then 1
1258+ else 0
1259+ let eK = if (sigVerify(eF.bodyBytes, eF.proofs[2], P))
1260+ then 1
1261+ else 0
1262+ (((eI + eJ) + eK) >= 2)
1263+ }
1264+ let K = eF
1265+ if ($isInstanceOf(K, "InvokeScriptTransaction"))
1266+ then {
1267+ let dE = K
1268+ let eL = if ((dE.dApp == this))
1269+ then (dE.function == "takeIntoAccountExtraFunds")
1270+ else false
1271+ let eM = if (if (if (sigVerify(eF.bodyBytes, eF.proofs[0], N))
1272+ then true
1273+ else sigVerify(eF.bodyBytes, eF.proofs[0], O))
1274+ then true
1275+ else sigVerify(eF.bodyBytes, eF.proofs[0], P))
1276+ then true
1277+ else sigVerify(eF.bodyBytes, eF.proofs[0], Q)
1278+ if (if (eL)
1279+ then eM
1280+ else false)
1281+ then true
1282+ else eH
1283+ }
1284+ else eH
1285+ }
1286+

github/deemru/w8io/169f3d6 
55.27 ms