tx · A7zanoJC2fEYY6cy9AXVfpdxg4RBzQWEdmVKvNPDoAH8

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.06000000 Waves

2023.06.12 13:52 [2619354] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "A7zanoJC2fEYY6cy9AXVfpdxg4RBzQWEdmVKvNPDoAH8",
    "fee": 6000000,
    "feeAssetId": null,
    "timestamp": 1686567152431,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "4nVo3tdGCsMgThhu3BX1LeZ7o8ywoQFMof7Y5gkjhqm8fE6DdXzDZiVQ5GrR3DSXea9Wp2XPcHayGL7EVv2DkvKf"
    ],
    "script": "base64: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",
    "height": 2619354,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2itSbVvun4jSqtkuWqxCohFFg7Kd5Eyq5eNToj1hFBKc
Next: Ed63WpXi1FNqHkWg9QNgNft5jied7EsXiSaSJ5inpyxs

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

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