BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • stXTZ pool 1.0
Delegatable
operations (1.1K)Storage Code Interact Tokens Metadata Fork Views Statistics Details
Latest
​x
445
1823
 
1
{ parameter (or
2
              (or
3
                (or (or (unit %cancel_deposit) (unit %cancel_request_withdrawal))
4
                    (or (nat %claim) (or (address %claim_outstanding) (unit %default))))
5
                (or
6
                  (or (address %deposit)
7
                      (or (lambda %execute unit (list operation))
8
                          (unit %finalize_withdrawal)))
9
                  (or (nat %pending_withdrawal)
10
                      (or (address %propose_administrator)
11
                          (address %remove_administrator)))))
12
              (or
13
                (or
14
                  (or (address %remove_manager)
15
                      (or (nat %request_withdrawal) (unit %set_administrator)))
16
                  (or
17
                    (pair %set_blocks_per_cycle (nat %blocks_per_cycle)
18
                                                (nat %blocks_offset))
19
                    (or (option %set_delegate key_hash) (nat %set_finalize_balance))))
20
                (or
21
                  (or
22
                    (pair %set_manager (key %consensus_key)
23
                                       (pair (bool %isActive) (address %manager)))
24
                    (or (nat %set_max_queue_size) (int %set_min_amount)))
25
                  (or (pair %set_pool_fee (nat %denominator) (nat %numerator))
26
                      (or (address %set_reward_recipient) (nat %update_balance)))))) ;
27
  storage (pair (big_map %administrators address int)
28
                (pair (nat %blocks_offset)
29
                      (pair (nat %blocks_per_cycle)
30
                            (pair
31
                              (list %deposit_queue (pair (address %owner) (nat %amount)))
32
                              (pair (nat %finalize_outstanding_balance)
33
                                    (pair (nat %global_balance)
34
                                          (pair
35
                                            (big_map %managers address
36
                                                               (pair (nat %balance)
37
                                                                     (pair
38
                                                                       (bool %isActive)
39
                                                                       (key %consensus_key))))
40
                                            (pair (nat %max_queue_size)
41
                                                  (pair (big_map %metadata string bytes)
42
                                                        (pair (nat %min_amount)
43
                                                              (pair
44
                                                                (big_map %outstanding_balances
45
                                                                  address
46
                                                                  (pair
47
                                                                    (nat %xtz_amount)
48
                                                                    (pair
49
                                                                      (nat %stxtz_amount)
50
                                                                      (nat %price))))
51
                                                                (pair
52
                                                                  (list %pending_queue (pair
53
                                                                                        (address %recipient)
54
                                                                                        (pair
55
                                                                                          (nat %xtz_amount)
56
                                                                                          (pair
57
                                                                                            (nat %stxtz_amount)
58
                                                                                            (pair
59
                                                                                              (nat %price)
60
                                                                                              (nat %block_level))))))
61
                                                                  (pair
62
                                                                    (pair %pool_fee
63
                                                                      (nat %numerator)
64
                                                                      (nat %denominator))
65
                                                                    (pair
66
                                                                      (nat %precision_factor)
67
                                                                      (pair
68
                                                                        (address %reward_recipient)
69
                                                                        (pair
70
                                                                          (address %token_address)
71
                                                                          (pair
72
                                                                            (nat %token_id)
73
                                                                            (list %withdrawal_queue (pair
74
                                                                                                     (address %recipient)
75
                                                                                                     (pair
76
                                                                                                       (nat %xtz_amount)
77
                                                                                                       (pair
78
                                                                                                         (nat %stxtz_amount)
79
                                                                                                         (pair
80
                                                                                                           (nat %price)
81
                                                                                                           (nat %block_level))))))))))))))))))))))) ;
82
  code { LAMBDA
83
           (pair (pair nat (map address nat))
84
                 (pair (list operation)
85
                       (pair (big_map address int)
86
                             (pair nat
87
                                   (pair nat
88
                                         (pair (list (pair address nat))
89
                                               (pair nat
90
                                                     (pair nat
91
                                                           (pair
92
                                                             (big_map address
93
                                                                      (pair nat
94
                                                                            (pair bool
95
                                                                                  key)))
96
                                                             (pair nat
97
                                                                   (pair
98
                                                                     (big_map string
99
                                                                              bytes)
100
                                                                     (pair nat
101
                                                                           (pair
102
                                                                             (big_map
103
                                                                               address
104
                                                                               (pair nat
105
                                                                                     (pair
106
                                                                                       nat
107
                                                                                       nat)))
108
                                                                             (pair
109
                                                                               (list (pair
110
                                                                                      address
111
                                                                                      (pair
112
                                                                                        nat
113
                                                                                        (pair
114
                                                                                          nat
115
                                                                                          (pair
116
                                                                                            nat
117
                                                                                            nat)))))
118
                                                                               (pair
119
                                                                                 (pair
120
                                                                                   nat
121
                                                                                   nat)
122
                                                                                 (pair
123
                                                                                   nat
124
                                                                                   (pair
125
                                                                                     address
126
                                                                                     (pair
127
                                                                                       address
128
                                                                                       (pair
129
                                                                                         nat
130
                                                                                         (list (pair
131
                                                                                                address
132
                                                                                                (pair
133
                                                                                                  nat
134
                                                                                                  (pair
135
                                                                                                    nat
136
                                                                                                    (pair
137
                                                                                                      nat
138
                                                                                                      nat))))))))))))))))))))))))
139
           (pair unit
140
                 (pair (list operation)
141
                       (pair (big_map address int)
142
                             (pair nat
143
                                   (pair nat
144
                                         (pair (list (pair address nat))
145
                                               (pair nat
146
                                                     (pair nat
147
                                                           (pair
148
                                                             (big_map address
149
                                                                      (pair nat
150
                                                                            (pair bool
151
                                                                                  key)))
152
                                                             (pair nat
153
                                                                   (pair
154
                                                                     (big_map string
155
                                                                              bytes)
156
                                                                     (pair nat
157
                                                                           (pair
158
                                                                             (big_map
159
                                                                               address
160
                                                                               (pair nat
161
                                                                                     (pair
162
                                                                                       nat
163
                                                                                       nat)))
164
                                                                             (pair
165
                                                                               (list (pair
166
                                                                                      address
167
                                                                                      (pair
168
                                                                                        nat
169
                                                                                        (pair
170
                                                                                          nat
171
                                                                                          (pair
172
                                                                                            nat
173
                                                                                            nat)))))
174
                                                                               (pair
175
                                                                                 (pair
176
                                                                                   nat
177
                                                                                   nat)
178
                                                                                 (pair
179
                                                                                   nat
180
                                                                                   (pair
181
                                                                                     address
182
                                                                                     (pair
183
                                                                                       address
184
                                                                                       (pair
185
                                                                                         nat
186
                                                                                         (list (pair
187
                                                                                                address
188
                                                                                                (pair
189
                                                                                                  nat
190
                                                                                                  (pair
191
                                                                                                    nat
192
                                                                                                    (pair
193
                                                                                                      nat
194
                                                                                                      nat))))))))))))))))))))))))
195
           { UNPAIR 3 ;
196
             SWAP ;
197
             DUP 3 ;
198
             GET 31 ;
199
             CONTRACT %bulk_mint (pair (nat %token_id) (map %operations address nat)) ;
200
             IF_NONE { PUSH int 196 ; FAILWITH } {} ;
201
             PUSH mutez 0 ;
202
             DIG 3 ;
203
             TRANSFER_TOKENS ;
204
             CONS ;
205
             UNIT ;
206
             PAIR 3 } ;
207
         SWAP ;
208
         LAMBDA
209
           (pair (pair address nat)
210
                 (pair (list operation)
211
                       (pair (big_map address int)
212
                             (pair nat
213
                                   (pair nat
214
                                         (pair (list (pair address nat))
215
                                               (pair nat
216
                                                     (pair nat
217
                                                           (pair
218
                                                             (big_map address
219
                                                                      (pair nat
220
                                                                            (pair bool
221
                                                                                  key)))
222
                                                             (pair nat
223
                                                                   (pair
224
                                                                     (big_map string
225
                                                                              bytes)
226
                                                                     (pair nat
227
                                                                           (pair
228
                                                                             (big_map
229
                                                                               address
230
                                                                               (pair nat
231
                                                                                     (pair
232
                                                                                       nat
233
                                                                                       nat)))
234
                                                                             (pair
235
                                                                               (list (pair
236
                                                                                      address
237
                                                                                      (pair
238
                                                                                        nat
239
                                                                                        (pair
240
                                                                                          nat
241
                                                                                          (pair
242
                                                                                            nat
243
                                                                                            nat)))))
244
                                                                               (pair
245
                                                                                 (pair
246
                                                                                   nat
247
                                                                                   nat)
248
                                                                                 (pair
249
                                                                                   nat
250
                                                                                   (pair
251
                                                                                     address
252
                                                                                     (pair
253
                                                                                       address
254
                                                                                       (pair
255
                                                                                         nat
256
                                                                                         (list (pair
257
                                                                                                address
258
                                                                                                (pair
259
                                                                                                  nat
260
                                                                                                  (pair
261
                                                                                                    nat
262
                                                                                                    (pair
263
                                                                                                      nat
264
                                                                                                      nat))))))))))))))))))))))))
265
           (pair unit
266
                 (pair (list operation)
267
                       (pair (big_map address int)
268
                             (pair nat
269
                                   (pair nat
270
                                         (pair (list (pair address nat))
271
                                               (pair nat
272
                                                     (pair nat
273
                                                           (pair
274
                                                             (big_map address
275
                                                                      (pair nat
276
                                                                            (pair bool
277
                                                                                  key)))
278
                                                             (pair nat
279
                                                                   (pair
280
                                                                     (big_map string
281
                                                                              bytes)
282
                                                                     (pair nat
283
                                                                           (pair
284
                                                                             (big_map
285
                                                                               address
286
                                                                               (pair nat
287
                                                                                     (pair
288
                                                                                       nat
289
                                                                                       nat)))
290
                                                                             (pair
291
                                                                               (list (pair
292
                                                                                      address
293
                                                                                      (pair
294
                                                                                        nat
295
                                                                                        (pair
296
                                                                                          nat
297
                                                                                          (pair
298
                                                                                            nat
299
                                                                                            nat)))))
300
                                                                               (pair
301
                                                                                 (pair
302
                                                                                   nat
303
                                                                                   nat)
304
                                                                                 (pair
305
                                                                                   nat
306
                                                                                   (pair
307
                                                                                     address
308
                                                                                     (pair
309
                                                                                       address
310
                                                                                       (pair
311
                                                                                         nat
312
                                                                                         (list (pair
313
                                                                                                address
314
                                                                                                (pair
315
                                                                                                  nat
316
                                                                                                  (pair
317
                                                                                                    nat
318
                                                                                                    (pair
319
                                                                                                      nat
320
                                                                                                      nat))))))))))))))))))))))))
321
           { UNPAIR 3 ;
322
             UNPAIR ;
323
             DUP 4 ;
324
             GET 31 ;
325
             CONTRACT %burn (pair (address %owner)
326
                                  (pair (nat %token_id) (nat %token_amount))) ;
327
             IF_NONE { PUSH int 205 ; FAILWITH } {} ;
328
             DIG 2 ;
329
             DUP 5 ;
330
             GET 33 ;
331
             DIG 3 ;
332
             PAIR 3 ;
333
             DUG 2 ;
334
             PUSH mutez 0 ;
335
             DIG 3 ;
336
             TRANSFER_TOKENS ;
337
             CONS ;
338
             UNIT ;
339
             PAIR 3 } ;
340
         SWAP ;
341
         LAMBDA
342
           (pair (pair address nat)
343
                 (pair (list operation)
344
                       (pair (big_map address int)
345
                             (pair nat
346
                                   (pair nat
347
                                         (pair (list (pair address nat))
348
                                               (pair nat
349
                                                     (pair nat
350
                                                           (pair
351
                                                             (big_map address
352
                                                                      (pair nat
353
                                                                            (pair bool
354
                                                                                  key)))
355
                                                             (pair nat
356
                                                                   (pair
357
                                                                     (big_map string
358
                                                                              bytes)
359
                                                                     (pair nat
360
                                                                           (pair
361
                                                                             (big_map
362
                                                                               address
363
                                                                               (pair nat
364
                                                                                     (pair
365
                                                                                       nat
366
                                                                                       nat)))
367
                                                                             (pair
368
                                                                               (list (pair
369
                                                                                      address
370
                                                                                      (pair
371
                                                                                        nat
372
                                                                                        (pair
373
                                                                                          nat
374
                                                                                          (pair
375
                                                                                            nat
376
                                                                                            nat)))))
377
                                                                               (pair
378
                                                                                 (pair
379
                                                                                   nat
380
                                                                                   nat)
381
                                                                                 (pair
382
                                                                                   nat
383
                                                                                   (pair
384
                                                                                     address
385
                                                                                     (pair
386
                                                                                       address
387
                                                                                       (pair
388
                                                                                         nat
389
                                                                                         (list (pair
390
                                                                                                address
391
                                                                                                (pair
392
                                                                                                  nat
393
                                                                                                  (pair
394
                                                                                                    nat
395
                                                                                                    (pair
396
                                                                                                      nat
397
                                                                                                      nat))))))))))))))))))))))))
398
           (pair unit
399
                 (pair (list operation)
400
                       (pair (big_map address int)
401
                             (pair nat
402
                                   (pair nat
403
                                         (pair (list (pair address nat))
404
                                               (pair nat
405
                                                     (pair nat
406
                                                           (pair
407
                                                             (big_map address
408
                                                                      (pair nat
409
                                                                            (pair bool
410
                                                                                  key)))
411
                                                             (pair nat
412
                                                                   (pair
413
                                                                     (big_map string
414
                                                                              bytes)
415
                                                                     (pair nat
416
                                                                           (pair
417
                                                                             (big_map
418
                                                                               address
419
                                                                               (pair nat
420
                                                                                     (pair
421
                                                                                       nat
422
                                                                                       nat)))
423
                                                                             (pair
424
                                                                               (list (pair
425
                                                                                      address
426
                                                                                      (pair
427
                                                                                        nat
428
                                                                                        (pair
429
                                                                                          nat
430
                                                                                          (pair
431
                                                                                            nat
432
                                                                                            nat)))))
433
                                                                               (pair
434
                                                                                 (pair
435
                                                                                   nat
436
                                                                                   nat)
437
                                                                                 (pair
438
                                                                                   nat
439
                                                                                   (pair
440
                                                                                     address
441
                                                                                     (pair
442
                                                                                       address
443
                                                                                       (pair
444
                                                                                         nat
445
                                                                                         (list (pair
446
                                                                                                address
447
                                                                                                (pair
448
                                                                                                  nat
449
                                                                                                  (pair
450
                                                                                                    nat
451
                                                                                                    (pair
452
                                                                                                      nat
453
                                                                                                      nat))))))))))))))))))))))))
454
           { UNPAIR 3 ;
455
             UNPAIR ;
456
             DUP 4 ;
457
             GET 31 ;
458
             CONTRACT %mint (pair (address %owner)
459
                                  (pair (nat %token_id) (nat %token_amount))) ;
460
             IF_NONE { PUSH int 159 ; FAILWITH } {} ;
461
             DIG 2 ;
462
             DUP 5 ;
463
             GET 33 ;
464
             DIG 3 ;
465
             PAIR 3 ;
466
             DUG 2 ;
467
             PUSH mutez 0 ;
468
             DIG 3 ;
469
             TRANSFER_TOKENS ;
470
             CONS ;
471
             UNIT ;
472
             PAIR 3 } ;
473
         SWAP ;
474
         LAMBDA
475
           (pair (pair address (pair address nat))
476
                 (pair (list operation)
477
                       (pair (big_map address int)
478
                             (pair nat
479
                                   (pair nat
480
                                         (pair (list (pair address nat))
481
                                               (pair nat
482
                                                     (pair nat
483
                                                           (pair
484
                                                             (big_map address
485
                                                                      (pair nat
486
                                                                            (pair bool
487
                                                                                  key)))
488
                                                             (pair nat
489
                                                                   (pair
490
                                                                     (big_map string
491
                                                                              bytes)
492
                                                                     (pair nat
493
                                                                           (pair
494
                                                                             (big_map
495
                                                                               address
496
                                                                               (pair nat
497
                                                                                     (pair
498
                                                                                       nat
499
                                                                                       nat)))
500
                                                                             (pair
501
                                                                               (list (pair
502
                                                                                      address
503
                                                                                      (pair
504
                                                                                        nat
505
                                                                                        (pair
506
                                                                                          nat
507
                                                                                          (pair
508
                                                                                            nat
509
                                                                                            nat)))))
510
                                                                               (pair
511
                                                                                 (pair
512
                                                                                   nat
513
                                                                                   nat)
514
                                                                                 (pair
515
                                                                                   nat
516
                                                                                   (pair
517
                                                                                     address
518
                                                                                     (pair
519
                                                                                       address
520
                                                                                       (pair
521
                                                                                         nat
522
                                                                                         (list (pair
523
                                                                                                address
524
                                                                                                (pair
525
                                                                                                  nat
526
                                                                                                  (pair
527
                                                                                                    nat
528
                                                                                                    (pair
529
                                                                                                      nat
530
                                                                                                      nat))))))))))))))))))))))))
531
           (pair unit
532
                 (pair (list operation)
533
                       (pair (big_map address int)
534
                             (pair nat
535
                                   (pair nat
536
                                         (pair (list (pair address nat))
537
                                               (pair nat
538
                                                     (pair nat
539
                                                           (pair
540
                                                             (big_map address
541
                                                                      (pair nat
542
                                                                            (pair bool
543
                                                                                  key)))
544
                                                             (pair nat
545
                                                                   (pair
546
                                                                     (big_map string
547
                                                                              bytes)
548
                                                                     (pair nat
549
                                                                           (pair
550
                                                                             (big_map
551
                                                                               address
552
                                                                               (pair nat
553
                                                                                     (pair
554
                                                                                       nat
555
                                                                                       nat)))
556
                                                                             (pair
557
                                                                               (list (pair
558
                                                                                      address
559
                                                                                      (pair
560
                                                                                        nat
561
                                                                                        (pair
562
                                                                                          nat
563
                                                                                          (pair
564
                                                                                            nat
565
                                                                                            nat)))))
566
                                                                               (pair
567
                                                                                 (pair
568
                                                                                   nat
569
                                                                                   nat)
570
                                                                                 (pair
571
                                                                                   nat
572
                                                                                   (pair
573
                                                                                     address
574
                                                                                     (pair
575
                                                                                       address
576
                                                                                       (pair
577
                                                                                         nat
578
                                                                                         (list (pair
579
                                                                                                address
580
                                                                                                (pair
581
                                                                                                  nat
582
                                                                                                  (pair
583
                                                                                                    nat
584
                                                                                                    (pair
585
                                                                                                      nat
586
                                                                                                      nat))))))))))))))))))))))))
587
           { UNPAIR 3 ;
588
             UNPAIR 3 ;
589
             DUP 5 ;
590
             GET 31 ;
591
             CONTRACT %transfer (list (pair (address %from_)
592
                                           (list %txs (pair (address %to_)
593
                                                           (pair (nat %token_id)
594
                                                                 (nat %amount)))))) ;
595
             IF_NONE { PUSH int 171 ; FAILWITH } {} ;
596
             DIG 4 ;
597
             SWAP ;
598
             PUSH mutez 0 ;
599
             NIL (pair address (list (pair address (pair nat nat)))) ;
600
             NIL (pair address (pair nat nat)) ;
601
             DIG 7 ;
602
             DUP 9 ;
603
             GET 33 ;
604
             DIG 8 ;
605
             PAIR 3 ;
606
             CONS ;
607
             DIG 5 ;
608
             PAIR ;
609
             CONS ;
610
             TRANSFER_TOKENS ;
611
             CONS ;
612
             UNIT ;
613
             PAIR 3 } ;
614
         SWAP ;
615
         LAMBDA
616
           (pair unit
617
                 (pair (big_map address int)
618
                       (pair nat
619
                             (pair nat
620
                                   (pair (list (pair address nat))
621
                                         (pair nat
622
                                               (pair nat
623
                                                     (pair
624
                                                       (big_map address
625
                                                                (pair nat
626
                                                                      (pair bool key)))
627
                                                       (pair nat
628
                                                             (pair
629
                                                               (big_map string bytes)
630
                                                               (pair nat
631
                                                                     (pair
632
                                                                       (big_map address
633
                                                                                (pair
634
                                                                                  nat
635
                                                                                  (pair
636
                                                                                    nat
637
                                                                                    nat)))
638
                                                                       (pair
639
                                                                         (list (pair
640
                                                                                address
641
                                                                                (pair
642
                                                                                  nat
643
                                                                                  (pair
644
                                                                                    nat
645
                                                                                    (pair
646
                                                                                      nat
647
                                                                                      nat)))))
648
                                                                         (pair
649
                                                                           (pair nat nat)
650
                                                                           (pair nat
651
                                                                                 (pair
652
                                                                                   address
653
                                                                                   (pair
654
                                                                                     address
655
                                                                                     (pair
656
                                                                                       nat
657
                                                                                       (list (pair
658
                                                                                              address
659
                                                                                              (pair
660
                                                                                                nat
661
                                                                                                (pair
662
                                                                                                  nat
663
                                                                                                  (pair
664
                                                                                                    nat
665
                                                                                                    nat)))))))))))))))))))))))
666
           (pair unit
667
                 (pair (big_map address int)
668
                       (pair nat
669
                             (pair nat
670
                                   (pair (list (pair address nat))
671
                                         (pair nat
672
                                               (pair nat
673
                                                     (pair
674
                                                       (big_map address
675
                                                                (pair nat
676
                                                                      (pair bool key)))
677
                                                       (pair nat
678
                                                             (pair
679
                                                               (big_map string bytes)
680
                                                               (pair nat
681
                                                                     (pair
682
                                                                       (big_map address
683
                                                                                (pair
684
                                                                                  nat
685
                                                                                  (pair
686
                                                                                    nat
687
                                                                                    nat)))
688
                                                                       (pair
689
                                                                         (list (pair
690
                                                                                address
691
                                                                                (pair
692
                                                                                  nat
693
                                                                                  (pair
694
                                                                                    nat
695
                                                                                    (pair
696
                                                                                      nat
697
                                                                                      nat)))))
698
                                                                         (pair
699
                                                                           (pair nat nat)
700
                                                                           (pair nat
701
                                                                                 (pair
702
                                                                                   address
703
                                                                                   (pair
704
                                                                                     address
705
                                                                                     (pair
706
                                                                                       nat
707
                                                                                       (list (pair
708
                                                                                              address
709
                                                                                              (pair
710
                                                                                                nat
711
                                                                                                (pair
712
                                                                                                  nat
713
                                                                                                  (pair
714
                                                                                                    nat
715
                                                                                                    nat)))))))))))))))))))))))
716
           { CDR ;
717
             DUP ;
718
             CAR ;
719
             SENDER ;
720
             MEM ;
721
             IF {} { PUSH string "Unauthorized" ; FAILWITH } ;
722
             PUSH int 1 ;
723
             DUP 2 ;
724
             CAR ;
725
             SENDER ;
726
             GET ;
727
             IF_NONE { PUSH int 19 ; FAILWITH } {} ;
728
             COMPARE ;
729
             EQ ;
730
             IF
731
               {}
732
               { PUSH string "Unauthorized. Proposal is still pending." ; FAILWITH } ;
733
             UNIT ;
734
             PAIR } ;
735
         SWAP ;
736
         LAMBDA
737
           (pair unit
738
                 (pair (big_map address int)
739
                       (pair nat
740
                             (pair nat
741
                                   (pair (list (pair address nat))
742
                                         (pair nat
743
                                               (pair nat
744
                                                     (pair
745
                                                       (big_map address
746
                                                                (pair nat
747
                                                                      (pair bool key)))
748
                                                       (pair nat
749
                                                             (pair
750
                                                               (big_map string bytes)
751
                                                               (pair nat
752
                                                                     (pair
753
                                                                       (big_map address
754
                                                                                (pair
755
                                                                                  nat
756
                                                                                  (pair
757
                                                                                    nat
758
                                                                                    nat)))
759
                                                                       (pair
760
                                                                         (list (pair
761
                                                                                address
762
                                                                                (pair
763
                                                                                  nat
764
                                                                                  (pair
765
                                                                                    nat
766
                                                                                    (pair
767
                                                                                      nat
768
                                                                                      nat)))))
769
                                                                         (pair
770
                                                                           (pair nat nat)
771
                                                                           (pair nat
772
                                                                                 (pair
773
                                                                                   address
774
                                                                                   (pair
775
                                                                                     address
776
                                                                                     (pair
777
                                                                                       nat
778
                                                                                       (list (pair
779
                                                                                              address
780
                                                                                              (pair
781
                                                                                                nat
782
                                                                                                (pair
783
                                                                                                  nat
784
                                                                                                  (pair
785
                                                                                                    nat
786
                                                                                                    nat)))))))))))))))))))))))
787
           (pair unit
788
                 (pair (big_map address int)
789
                       (pair nat
790
                             (pair nat
791
                                   (pair (list (pair address nat))
792
                                         (pair nat
793
                                               (pair nat
794
                                                     (pair
795
                                                       (big_map address
796
                                                                (pair nat
797
                                                                      (pair bool key)))
798
                                                       (pair nat
799
                                                             (pair
800
                                                               (big_map string bytes)
801
                                                               (pair nat
802
                                                                     (pair
803
                                                                       (big_map address
804
                                                                                (pair
805
                                                                                  nat
806
                                                                                  (pair
807
                                                                                    nat
808
                                                                                    nat)))
809
                                                                       (pair
810
                                                                         (list (pair
811
                                                                                address
812
                                                                                (pair
813
                                                                                  nat
814
                                                                                  (pair
815
                                                                                    nat
816
                                                                                    (pair
817
                                                                                      nat
818
                                                                                      nat)))))
819
                                                                         (pair
820
                                                                           (pair nat nat)
821
                                                                           (pair nat
822
                                                                                 (pair
823
                                                                                   address
824
                                                                                   (pair
825
                                                                                     address
826
                                                                                     (pair
827
                                                                                       nat
828
                                                                                       (list (pair
829
                                                                                              address
830
                                                                                              (pair
831
                                                                                                nat
832
                                                                                                (pair
833
                                                                                                  nat
834
                                                                                                  (pair
835
                                                                                                    nat
836
                                                                                                    nat)))))))))))))))))))))))
837
           { CDR ;
838
             DUP ;
839
             GET 13 ;
840
             SENDER ;
841
             MEM ;
842
             IF {} { PUSH string "Unauthorized" ; FAILWITH } ;
843
             UNIT ;
844
             PAIR } ;
845
         SWAP ;
846
         UNPAIR ;
847
         IF_LEFT
848
           { IF_LEFT
849
               { IF_LEFT
850
                   { IF_LEFT
851
                       { DROP ;
852
                         SWAP ;
853
                         DROP ;
854
                         SWAP ;
855
                         DROP ;
856
                         SWAP ;
857
                         DROP ;
858
                         SWAP ;
859
                         DROP ;
860
                         SWAP ;
861
                         DROP ;
862
                         SWAP ;
863
                         DROP ;
864
                         PUSH mutez 0 ;
865
                         AMOUNT ;
866
                         COMPARE ;
867
                         EQ ;
868
                         IF
869
                           {}
870
                           { PUSH string "[pool.update_balance]: No tez accepted." ;
871
                             FAILWITH } ;
872
                         DUP ;
873
                         GET 7 ;
874
                         NIL (pair address nat) ;
875
                         SWAP ;
876
                         ITER { CONS } ;
877
                         NIL (pair address nat) ;
878
                         PUSH nat 0 ;
879
                         DIG 2 ;
880
                         ITER { SENDER ;
881
                                DUP 2 ;
882
                                CAR ;
883
                                COMPARE ;
884
                                EQ ;
885
                                IF { CDR ; ADD } { DIG 2 ; SWAP ; CONS ; SWAP } } ;
886
                         DUP ;
887
                         INT ;
888
                         GT ;
889
                         IF
890
                           {}
891
                           { PUSH string "[pool.cancel_deposit]: No request found." ;
892
                             FAILWITH } ;
893
                         DUG 2 ;
894
                         UPDATE 7 ;
895
                         SWAP ;
896
                         NIL operation ;
897
                         SENDER ;
898
                         CONTRACT unit ;
899
                         IF_NONE { PUSH int 150 ; FAILWITH } {} ;
900
                         LAMBDA nat mutez { PUSH mutez 1 ; SWAP ; MUL } ;
901
                         DIG 3 ;
902
                         EXEC ;
903
                         UNIT ;
904
                         TRANSFER_TOKENS ;
905
                         CONS }
906
                       { DROP ;
907
                         SWAP ;
908
                         DROP ;
909
                         SWAP ;
910
                         DROP ;
911
                         DIG 2 ;
912
                         DROP ;
913
                         DIG 2 ;
914
                         DROP ;
915
                         DIG 2 ;
916
                         DROP ;
917
                         DUP ;
918
                         GET 34 ;
919
                         NIL (pair address (pair nat (pair nat (pair nat nat)))) ;
920
                         SWAP ;
921
                         ITER { CONS } ;
922
                         NIL (pair address (pair nat (pair nat (pair nat nat)))) ;
923
                         PUSH nat 0 ;
924
                         DIG 2 ;
925
                         ITER { SENDER ;
926
                                DUP 2 ;
927
                                CAR ;
928
                                COMPARE ;
929
                                EQ ;
930
                                IF { GET 5 ; ADD } { DIG 2 ; SWAP ; CONS ; SWAP } } ;
931
                         DUP ;
932
                         INT ;
933
                         GT ;
934
                         IF
935
                           {}
936
                           { PUSH string "[pool.cancel_request_withdrawal]: No request found." ;
937
                             FAILWITH } ;
938
                         DUG 2 ;
939
                         UPDATE 34 ;
940
                         SWAP ;
941
                         NIL operation ;
942
                         DIG 3 ;
943
                         DIG 2 ;
944
                         SENDER ;
945
                         SELF_ADDRESS ;
946
                         PAIR 3 ;
947
                         SWAP ;
948
                         DUG 3 ;
949
                         PAIR 3 ;
950
                         EXEC ;
951
                         CDR ;
952
                         UNPAIR } }
953
                   { IF_LEFT
954
                       { DUP 3 ;
955
                         UNIT ;
956
                         SWAP ;
957
                         DIG 3 ;
958
                         DIG 2 ;
959
                         PAIR ;
960
                         EXEC ;
961
                         CDR ;
962
                         DUG 7 ;
963
                         DUG 7 ;
964
                         DIG 6 ;
965
                         DIG 7 ;
966
                         DUP 2 ;
967
                         GET 19 ;
968
                         DUP 2 ;
969
                         COMPARE ;
970
                         GE ;
971
                         IF
972
                           {}
973
                           { PUSH string "[pool.claim]: Invalid amount requested." ;
974
                             FAILWITH } ;
975
                         PUSH mutez 0 ;
976
                         AMOUNT ;
977
                         COMPARE ;
978
                         EQ ;
979
                         IF
980
                           {}
981
                           { PUSH string "[pool.claim]: No tez accepted." ; FAILWITH } ;
982
                         DUP ;
983
                         EMPTY_MAP address nat ;
984
                         NIL (pair address nat) ;
985
                         SELF_ADDRESS ;
986
                         UNIT ;
987
                         VIEW "fetch_price" nat ;
988
                         IF_NONE { PUSH int 277 ; FAILWITH } {} ;
989
                         DUP 6 ;
990
                         GET 7 ;
991
                         NIL (pair address nat) ;
992
                         SWAP ;
993
                         ITER { CONS } ;
994
                         DUP ;
995
                         ITER { DUP 6 ;
996
                                INT ;
997
                                GT ;
998
                                IF
999
                                  { DUP ;
1000
                                    CDR ;
1001
                                    DUP 7 ;
1002
                                    COMPARE ;
1003
                                    LT ;
1004
                                    IF
1005
                                      { LAMBDA
1006
                                          int
1007
                                          nat
1008
                                          { PUSH int 0 ;
1009
                                            ISNAT ;
1010
                                            IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1011
                                            DUP 2 ;
1012
                                            GT ;
1013
                                            IF
1014
                                              { DROP ;
1015
                                                ISNAT ;
1016
                                                IF_NONE { PUSH int 65 ; FAILWITH } {} }
1017
                                              { SWAP ; DROP } } ;
1018
                                        DUP 7 ;
1019
                                        DUP 3 ;
1020
                                        CDR ;
1021
                                        SUB ;
1022
                                        EXEC ;
1023
                                        DUP 2 ;
1024
                                        CAR ;
1025
                                        PAIR ;
1026
                                        DIG 4 ;
1027
                                        SWAP ;
1028
                                        CONS ;
1029
                                        DUG 3 ;
1030
                                        DIG 5 ;
1031
                                        PUSH nat 0 ;
1032
                                        DUG 6 }
1033
                                      { LAMBDA
1034
                                          int
1035
                                          nat
1036
                                          { PUSH int 0 ;
1037
                                            ISNAT ;
1038
                                            IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1039
                                            DUP 2 ;
1040
                                            GT ;
1041
                                            IF
1042
                                              { DROP ;
1043
                                                ISNAT ;
1044
                                                IF_NONE { PUSH int 65 ; FAILWITH } {} }
1045
                                              { SWAP ; DROP } } ;
1046
                                        DUP 2 ;
1047
                                        CDR ;
1048
                                        DIG 7 ;
1049
                                        SUB ;
1050
                                        EXEC ;
1051
                                        DUG 5 ;
1052
                                        DUP ;
1053
                                        CDR } ;
1054
                                    DUP 4 ;
1055
                                    DUP 10 ;
1056
                                    GET 27 ;
1057
                                    DIG 2 ;
1058
                                    MUL ;
1059
                                    EDIV ;
1060
                                    IF_NONE { PUSH int 301 ; FAILWITH } { CAR } ;
1061
                                    DUP 6 ;
1062
                                    DUP 3 ;
1063
                                    CAR ;
1064
                                    MEM ;
1065
                                    IF
1066
                                      { DIG 5 ;
1067
                                        DUP ;
1068
                                        DIG 3 ;
1069
                                        CAR ;
1070
                                        DUP ;
1071
                                        DUG 2 ;
1072
                                        GET ;
1073
                                        IF_NONE { PUSH int 306 ; FAILWITH } {} ;
1074
                                        DIG 3 ;
1075
                                        ADD ;
1076
                                        SOME ;
1077
                                        SWAP ;
1078
                                        UPDATE ;
1079
                                        DUG 3 }
1080
                                      { DIG 5 ; SWAP ; SOME ; DIG 2 ; CAR ; UPDATE ; DUG 3 } }
1081
                                  { DIG 3 ; SWAP ; CONS ; DUG 2 } } ;
1082
                         DROP 2 ;
1083
                         DIG 5 ;
1084
                         DROP ;
1085
                         DIG 5 ;
1086
                         DROP ;
1087
                         DIG 5 ;
1088
                         DROP ;
1089
                         DIG 5 ;
1090
                         DROP ;
1091
                         DIG 5 ;
1092
                         DROP ;
1093
                         DIG 2 ;
1094
                         INT ;
1095
                         EQ ;
1096
                         IF
1097
                           {}
1098
                           { PUSH string "[pool.claim]: The requested amount is too large." ;
1099
                             FAILWITH } ;
1100
                         NIL operation ;
1101
                         DIG 5 ;
1102
                         DIG 3 ;
1103
                         DUP 6 ;
1104
                         GET 33 ;
1105
                         PAIR ;
1106
                         SWAP ;
1107
                         DIG 5 ;
1108
                         DIG 3 ;
1109
                         DIG 3 ;
1110
                         PAIR 3 ;
1111
                         EXEC ;
1112
                         CDR ;
1113
                         UNPAIR ;
1114
                         SWAP ;
1115
                         DIG 2 ;
1116
                         UPDATE 7 ;
1117
                         DUG 2 ;
1118
                         DUP 2 ;
1119
                         DUP 4 ;
1120
                         GET 13 ;
1121
                         SENDER ;
1122
                         GET ;
1123
                         IF_NONE { PUSH int 322 ; FAILWITH } {} ;
1124
                         CAR ;
1125
                         ADD ;
1126
                         DUP 4 ;
1127
                         DUP ;
1128
                         GET 13 ;
1129
                         DUP 6 ;
1130
                         GET 13 ;
1131
                         SENDER ;
1132
                         GET ;
1133
                         IF_NONE { PUSH int 326 ; FAILWITH } {} ;
1134
                         GET 4 ;
1135
                         DIG 6 ;
1136
                         GET 13 ;
1137
                         SENDER ;
1138
                         GET ;
1139
                         IF_NONE { PUSH int 325 ; FAILWITH } {} ;
1140
                         GET 3 ;
1141
                         DIG 4 ;
1142
                         PAIR 3 ;
1143
                         SOME ;
1144
                         SENDER ;
1145
                         UPDATE ;
1146
                         UPDATE 13 ;
1147
                         DUP ;
1148
                         GET 11 ;
1149
                         DUP 4 ;
1150
                         ADD ;
1151
                         UPDATE 11 ;
1152
                         DUG 2 ;
1153
                         SENDER ;
1154
                         CONTRACT unit ;
1155
                         IF_NONE { PUSH int 329 ; FAILWITH } {} ;
1156
                         LAMBDA nat mutez { PUSH mutez 1 ; SWAP ; MUL } ;
1157
                         DIG 3 ;
1158
                         EXEC ;
1159
                         UNIT ;
1160
                         TRANSFER_TOKENS ;
1161
                         CONS }
1162
                       { DIG 3 ;
1163
                         DROP ;
1164
                         DIG 3 ;
1165
                         DROP ;
1166
                         DIG 3 ;
1167
                         DROP ;
1168
                         DIG 3 ;
1169
                         DROP ;
1170
                         DIG 3 ;
1171
                         DROP ;
1172
                         IF_LEFT
1173
                           { PUSH mutez 0 ;
1174
                             AMOUNT ;
1175
                             COMPARE ;
1176
                             EQ ;
1177
                             IF
1178
                               {}
1179
                               { PUSH string "[pool.claim_outstanding]: No tez accepted." ;
1180
                                 FAILWITH } ;
1181
                             DUP 2 ;
1182
                             GET 21 ;
1183
                             SENDER ;
1184
                             MEM ;
1185
                             IF
1186
                               {}
1187
                               { PUSH string "[pool.claim_outstanding]: Nothing to withdraw." ;
1188
                                 FAILWITH } ;
1189
                             DUP 2 ;
1190
                             GET 21 ;
1191
                             SENDER ;
1192
                             GET ;
1193
                             IF_NONE { PUSH int 566 ; FAILWITH } {} ;
1194
                             SELF_ADDRESS ;
1195
                             UNIT ;
1196
                             VIEW "fetch_price" nat ;
1197
                             IF_NONE { PUSH int 568 ; FAILWITH } {} ;
1198
                             DUP 4 ;
1199
                             GET 21 ;
1200
                             SENDER ;
1201
                             GET ;
1202
                             IF_NONE { PUSH int 575 ; FAILWITH } {} ;
1203
                             CAR ;
1204
                             DUP 2 ;
1205
                             DUP 4 ;
1206
                             GET 4 ;
1207
                             COMPARE ;
1208
                             GT ;
1209
                             IF
1210
                               { DROP ;
1211
                                 DIG 4 ;
1212
                                 DROP ;
1213
                                 DUP 4 ;
1214
                                 GET 27 ;
1215
                                 SWAP ;
1216
                                 DIG 2 ;
1217
                                 GET 3 ;
1218
                                 MUL ;
1219
                                 EDIV ;
1220
                                 IF_NONE { PUSH int 579 ; FAILWITH } { CAR } }
1221
                               { SWAP ; DROP ; SWAP ; DROP ; DIG 3 ; DROP } ;
1222
                             DUP ;
1223
                             LAMBDA
1224
                               mutez
1225
                               nat
1226
                               { PUSH mutez 1 ;
1227
                                 SWAP ;
1228
                                 EDIV ;
1229
                                 IF_NONE { PUSH int 34 ; FAILWITH } {} ;
1230
                                 CAR } ;
1231
                             BALANCE ;
1232
                             EXEC ;
1233
                             COMPARE ;
1234
                             GE ;
1235
                             IF
1236
                               {}
1237
                               { PUSH string "[pool.claim_outstanding]: The requested amount is to large." ;
1238
                                 FAILWITH } ;
1239
                             NIL operation ;
1240
                             DIG 2 ;
1241
                             CONTRACT unit ;
1242
                             IF_NONE { PUSH int 585 ; FAILWITH } {} ;
1243
                             LAMBDA nat mutez { PUSH mutez 1 ; SWAP ; MUL } ;
1244
                             DIG 3 ;
1245
                             EXEC ;
1246
                             UNIT ;
1247
                             TRANSFER_TOKENS ;
1248
                             CONS ;
1249
                             SWAP ;
1250
                             DUP ;
1251
                             GET 21 ;
1252
                             NONE (pair nat (pair nat nat)) ;
1253
                             SENDER ;
1254
                             UPDATE ;
1255
                             UPDATE 21 ;
1256
                             SWAP }
1257
                           { DROP ;
1258
                             SWAP ;
1259
                             DROP ;
1260
                             NIL operation ;
1261
                             DUP 2 ;
1262
                             GET 29 ;
1263
                             CONTRACT unit ;
1264
                             IF_NONE { PUSH int 717 ; FAILWITH } {} ;
1265
                             AMOUNT ;
1266
                             UNIT ;
1267
                             TRANSFER_TOKENS ;
1268
                             CONS } } } }
1269
               { IF_LEFT
1270
                   { IF_LEFT
1271
                       { LAMBDA nat mutez { PUSH mutez 1 ; SWAP ; MUL } ;
1272
                         DUP 3 ;
1273
                         GET 19 ;
1274
                         EXEC ;
1275
                         AMOUNT ;
1276
                         COMPARE ;
1277
                         GE ;
1278
                         IF
1279
                           {}
1280
                           { PUSH string "[pool.deposit]: Invalid amount." ; FAILWITH } ;
1281
                         DUP 2 ;
1282
                         GET 15 ;
1283
                         DUP 3 ;
1284
                         GET 7 ;
1285
                         SIZE ;
1286
                         COMPARE ;
1287
                         LE ;
1288
                         IF
1289
                           {}
1290
                           { PUSH string "[pool.deposit]: The queue is full." ; FAILWITH } ;
1291
                         LAMBDA
1292
                           mutez
1293
                           nat
1294
                           { PUSH mutez 1 ;
1295
                             SWAP ;
1296
                             EDIV ;
1297
                             IF_NONE { PUSH int 34 ; FAILWITH } {} ;
1298
                             CAR } ;
1299
                         AMOUNT ;
1300
                         EXEC ;
1301
                         PUSH int 1 ;
1302
                         DUP 4 ;
1303
                         GET 7 ;
1304
                         ITER { DUP 4 ; SWAP ; CAR ; COMPARE ; EQ ; IF { PUSH int -1 ; ADD } {} } ;
1305
                         DIG 4 ;
1306
                         DROP ;
1307
                         DIG 4 ;
1308
                         DROP ;
1309
                         DIG 4 ;
1310
                         DROP ;
1311
                         DIG 4 ;
1312
                         DROP ;
1313
                         DIG 4 ;
1314
                         DROP ;
1315
                         DIG 4 ;
1316
                         DROP ;
1317
                         PUSH int 0 ;
1318
                         COMPARE ;
1319
                         LT ;
1320
                         IF
1321
                           {}
1322
                           { PUSH string "[pool.deposit]: Too many requests." ; FAILWITH } ;
1323
                         DUP 3 ;
1324
                         GET 7 ;
1325
                         SWAP ;
1326
                         DIG 2 ;
1327
                         PAIR ;
1328
                         CONS ;
1329
                         UPDATE 7 ;
1330
                         NIL operation }
1331
                       { IF_LEFT
1332
                           { DIG 2 ;
1333
                             DROP ;
1334
                             DIG 3 ;
1335
                             DROP ;
1336
                             DIG 3 ;
1337
                             DROP ;
1338
                             DIG 3 ;
1339
                             DROP ;
1340
                             DIG 3 ;
1341
                             DROP ;
1342
                             DIG 2 ;
1343
                             UNIT ;
1344
                             SWAP ;
1345
                             DIG 3 ;
1346
                             DIG 2 ;
1347
                             PAIR ;
1348
                             EXEC ;
1349
                             CDR ;
1350
                             SWAP ;
1351
                             UNIT ;
1352
                             EXEC ;
1353
                             NIL operation ;
1354
                             SWAP ;
1355
                             ITER { CONS } ;
1356
                             NIL operation ;
1357
                             SWAP ;
1358
                             ITER { CONS } }
1359
                           { DUP 3 ;
1360
                             UNIT ;
1361
                             SWAP ;
1362
                             DIG 3 ;
1363
                             DIG 2 ;
1364
                             PAIR ;
1365
                             EXEC ;
1366
                             CDR ;
1367
                             DUG 7 ;
1368
                             DUG 7 ;
1369
                             DIG 6 ;
1370
                             DIG 7 ;
1371
                             DUP 2 ;
1372
                             GET 9 ;
1373
                             LAMBDA
1374
                               mutez
1375
                               nat
1376
                               { PUSH mutez 1 ;
1377
                                 SWAP ;
1378
                                 EDIV ;
1379
                                 IF_NONE { PUSH int 34 ; FAILWITH } {} ;
1380
                                 CAR } ;
1381
                             AMOUNT ;
1382
                             EXEC ;
1383
                             ADD ;
1384
                             NIL (pair address (pair nat (pair nat (pair nat nat)))) ;
1385
                             DUP 4 ;
1386
                             GET 5 ;
1387
                             LAMBDA
1388
                               int
1389
                               nat
1390
                               { PUSH int 0 ;
1391
                                 ISNAT ;
1392
                                 IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1393
                                 DUP 2 ;
1394
                                 GT ;
1395
                                 IF
1396
                                   { DROP ; ISNAT ; IF_NONE { PUSH int 65 ; FAILWITH } {} }
1397
                                   { SWAP ; DROP } } ;
1398
                             DUP 6 ;
1399
                             GET 3 ;
1400
                             LEVEL ;
1401
                             SUB ;
1402
                             EXEC ;
1403
                             EDIV ;
1404
                             IF_NONE { PUSH int 512 ; FAILWITH } { CAR } ;
1405
                             DUP 5 ;
1406
                             GET 23 ;
1407
                             NIL (pair address (pair nat (pair nat (pair nat nat)))) ;
1408
                             SWAP ;
1409
                             ITER { CONS } ;
1410
                             DUP ;
1411
                             ITER { DUP 7 ;
1412
                                    GET 5 ;
1413
                                    LAMBDA
1414
                                      int
1415
                                      nat
1416
                                      { PUSH int 0 ;
1417
                                        ISNAT ;
1418
                                        IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1419
                                        DUP 2 ;
1420
                                        GT ;
1421
                                        IF
1422
                                          { DROP ;
1423
                                            ISNAT ;
1424
                                            IF_NONE { PUSH int 65 ; FAILWITH } {} }
1425
                                          { SWAP ; DROP } } ;
1426
                                    DUP 9 ;
1427
                                    GET 3 ;
1428
                                    DUP 4 ;
1429
                                    GET 8 ;
1430
                                    SUB ;
1431
                                    EXEC ;
1432
                                    EDIV ;
1433
                                    IF_NONE { PUSH int 517 ; FAILWITH } { CAR } ;
1434
                                    DUP 6 ;
1435
                                    INT ;
1436
                                    GT ;
1437
                                    IF
1438
                                      { PUSH nat 4 ; ADD ; DUP 4 ; COMPARE ; GT }
1439
                                      { DROP ; PUSH bool False } ;
1440
                                    IF
1441
                                      { DUP 5 ; DUP 2 ; GET 3 ; COMPARE ; LE }
1442
                                      { PUSH bool False } ;
1443
                                    IF
1444
                                      { LAMBDA
1445
                                          int
1446
                                          nat
1447
                                          { PUSH int 0 ;
1448
                                            ISNAT ;
1449
                                            IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1450
                                            DUP 2 ;
1451
                                            GT ;
1452
                                            IF
1453
                                              { DROP ;
1454
                                                ISNAT ;
1455
                                                IF_NONE { PUSH int 65 ; FAILWITH } {} }
1456
                                              { SWAP ; DROP } } ;
1457
                                        DUP 2 ;
1458
                                        GET 3 ;
1459
                                        DIG 6 ;
1460
                                        SUB ;
1461
                                        EXEC ;
1462
                                        DUG 4 ;
1463
                                        DUP 7 ;
1464
                                        GET 21 ;
1465
                                        DUP 2 ;
1466
                                        CAR ;
1467
                                        MEM ;
1468
                                        IF
1469
                                          { DUP 7 ;
1470
                                            GET 21 ;
1471
                                            DUP 2 ;
1472
                                            CAR ;
1473
                                            GET ;
1474
                                            IF_NONE { PUSH int 529 ; FAILWITH } {} ;
1475
                                            DIG 7 ;
1476
                                            DUP ;
1477
                                            GET 21 ;
1478
                                            DUP 4 ;
1479
                                            GET 7 ;
1480
                                            DUP 5 ;
1481
                                            GET 5 ;
1482
                                            DUP 5 ;
1483
                                            GET 3 ;
1484
                                            ADD ;
1485
                                            DUP 6 ;
1486
                                            GET 3 ;
1487
                                            DIG 5 ;
1488
                                            CAR ;
1489
                                            ADD ;
1490
                                            PAIR 3 ;
1491
                                            SOME ;
1492
                                            DIG 3 ;
1493
                                            CAR ;
1494
                                            UPDATE ;
1495
                                            UPDATE 21 ;
1496
                                            DUG 5 }
1497
                                          { DIG 6 ;
1498
                                            DUP ;
1499
                                            GET 21 ;
1500
                                            DUP 3 ;
1501
                                            GET 7 ;
1502
                                            DUP 4 ;
1503
                                            GET 5 ;
1504
                                            DUP 5 ;
1505
                                            GET 3 ;
1506
                                            PAIR 3 ;
1507
                                            SOME ;
1508
                                            DIG 3 ;
1509
                                            CAR ;
1510
                                            UPDATE ;
1511
                                            UPDATE 21 ;
1512
                                            DUG 5 } }
1513
                                      { DIG 3 ; SWAP ; CONS ; DUG 2 } } ;
1514
                             DROP 2 ;
1515
                             DIG 2 ;
1516
                             DROP ;
1517
                             DIG 3 ;
1518
                             DROP ;
1519
                             DIG 3 ;
1520
                             DROP ;
1521
                             DIG 3 ;
1522
                             DROP ;
1523
                             DIG 3 ;
1524
                             DROP ;
1525
                             DIG 3 ;
1526
                             DROP ;
1527
                             DIG 3 ;
1528
                             DROP ;
1529
                             DUG 2 ;
1530
                             UPDATE 9 ;
1531
                             SWAP ;
1532
                             UPDATE 23 ;
1533
                             NIL operation } } }
1534
                   { IF_LEFT
1535
                       { DUP 3 ;
1536
                         UNIT ;
1537
                         SWAP ;
1538
                         DIG 3 ;
1539
                         DIG 2 ;
1540
                         PAIR ;
1541
                         EXEC ;
1542
                         CDR ;
1543
                         DUG 7 ;
1544
                         DUG 7 ;
1545
                         DIG 6 ;
1546
                         DIG 7 ;
1547
                         DUP 2 ;
1548
                         GET 19 ;
1549
                         DUP 2 ;
1550
                         COMPARE ;
1551
                         GE ;
1552
                         IF
1553
                           {}
1554
                           { PUSH string "[pool.pending_withdrawal]: Invalid amount requested." ;
1555
                             FAILWITH } ;
1556
                         PUSH mutez 0 ;
1557
                         AMOUNT ;
1558
                         COMPARE ;
1559
                         EQ ;
1560
                         IF
1561
                           {}
1562
                           { PUSH string "[pool.pending_withdrawal]: No tez accepted." ;
1563
                             FAILWITH } ;
1564
                         DUP ;
1565
                         PUSH nat 0 ;
1566
                         NIL (pair address (pair nat (pair nat (pair nat nat)))) ;
1567
                         DUP 5 ;
1568
                         GET 34 ;
1569
                         NIL (pair address (pair nat (pair nat (pair nat nat)))) ;
1570
                         SWAP ;
1571
                         ITER { CONS } ;
1572
                         DUP ;
1573
                         ITER { DUP 7 ;
1574
                                GET 15 ;
1575
                                DUP 8 ;
1576
                                GET 23 ;
1577
                                SIZE ;
1578
                                COMPARE ;
1579
                                LE ;
1580
                                IF { DUP 5 ; INT ; GT } { PUSH bool False } ;
1581
                                IF
1582
                                  { DUP 5 ; DUP 2 ; GET 3 ; COMPARE ; LE }
1583
                                  { PUSH bool False } ;
1584
                                IF
1585
                                  { LAMBDA
1586
                                      int
1587
                                      nat
1588
                                      { PUSH int 0 ;
1589
                                        ISNAT ;
1590
                                        IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1591
                                        DUP 2 ;
1592
                                        GT ;
1593
                                        IF
1594
                                          { DROP ;
1595
                                            ISNAT ;
1596
                                            IF_NONE { PUSH int 65 ; FAILWITH } {} }
1597
                                          { SWAP ; DROP } } ;
1598
                                    DUP 2 ;
1599
                                    GET 3 ;
1600
                                    DIG 6 ;
1601
                                    SUB ;
1602
                                    EXEC ;
1603
                                    DUG 4 ;
1604
                                    DUP 7 ;
1605
                                    GET 23 ;
1606
                                    LEVEL ;
1607
                                    DUP 3 ;
1608
                                    GET 7 ;
1609
                                    DUP 4 ;
1610
                                    GET 5 ;
1611
                                    DUP 5 ;
1612
                                    GET 3 ;
1613
                                    DUP 6 ;
1614
                                    CAR ;
1615
                                    PAIR 5 ;
1616
                                    CONS ;
1617
                                    DIG 7 ;
1618
                                    SWAP ;
1619
                                    UPDATE 23 ;
1620
                                    DUG 6 ;
1621
                                    DIG 3 ;
1622
                                    SWAP ;
1623
                                    GET 5 ;
1624
                                    ADD ;
1625
                                    DUG 2 }
1626
                                  { DIG 2 ; SWAP ; CONS ; SWAP } } ;
1627
                         DROP ;
1628
                         DIG 5 ;
1629
                         DROP ;
1630
                         DIG 5 ;
1631
                         DROP ;
1632
                         DIG 5 ;
1633
                         DROP ;
1634
                         DIG 5 ;
1635
                         DROP ;
1636
                         DIG 6 ;
1637
                         DROP ;
1638
                         DIG 2 ;
1639
                         INT ;
1640
                         EQ ;
1641
                         IF
1642
                           {}
1643
                           { PUSH string "[pool.pending_withdrawal]: Invalid amount requested." ;
1644
                             FAILWITH } ;
1645
                         DIG 3 ;
1646
                         SWAP ;
1647
                         UPDATE 34 ;
1648
                         DUG 2 ;
1649
                         LAMBDA
1650
                           int
1651
                           nat
1652
                           { PUSH int 0 ;
1653
                             ISNAT ;
1654
                             IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1655
                             DUP 2 ;
1656
                             GT ;
1657
                             IF
1658
                               { DROP ; ISNAT ; IF_NONE { PUSH int 65 ; FAILWITH } {} }
1659
                               { SWAP ; DROP } } ;
1660
                         DUP 3 ;
1661
                         DUP 5 ;
1662
                         GET 11 ;
1663
                         SUB ;
1664
                         EXEC ;
1665
                         DIG 3 ;
1666
                         SWAP ;
1667
                         UPDATE 11 ;
1668
                         DUG 2 ;
1669
                         SWAP ;
1670
                         DUP 3 ;
1671
                         GET 13 ;
1672
                         SENDER ;
1673
                         GET ;
1674
                         IF_NONE { PUSH int 478 ; FAILWITH } {} ;
1675
                         CAR ;
1676
                         SUB ;
1677
                         DUP ;
1678
                         GE ;
1679
                         IF
1680
                           {}
1681
                           { PUSH string "[pool.update_balance]: The manager balance is negative." ;
1682
                             FAILWITH } ;
1683
                         DUP 3 ;
1684
                         DUP ;
1685
                         GET 13 ;
1686
                         DUP 5 ;
1687
                         GET 13 ;
1688
                         SENDER ;
1689
                         GET ;
1690
                         IF_NONE { PUSH int 487 ; FAILWITH } {} ;
1691
                         GET 4 ;
1692
                         DIG 5 ;
1693
                         GET 13 ;
1694
                         SENDER ;
1695
                         GET ;
1696
                         IF_NONE { PUSH int 486 ; FAILWITH } {} ;
1697
                         GET 3 ;
1698
                         LAMBDA
1699
                           int
1700
                           nat
1701
                           { PUSH int 0 ;
1702
                             ISNAT ;
1703
                             IF_NONE { PUSH int 62 ; FAILWITH } {} ;
1704
                             DUP 2 ;
1705
                             GT ;
1706
                             IF
1707
                               { DROP ; ISNAT ; IF_NONE { PUSH int 65 ; FAILWITH } {} }
1708
                               { SWAP ; DROP } } ;
1709
                         DIG 5 ;
1710
                         EXEC ;
1711
                         PAIR 3 ;
1712
                         SOME ;
1713
                         SENDER ;
1714
                         UPDATE ;
1715
                         UPDATE 13 ;
1716
                         SWAP ;
1717
                         NIL operation ;
1718
                         DIG 3 ;
1719
                         DIG 2 ;
1720
                         SELF_ADDRESS ;
1721
                         PAIR ;
1722
                         SWAP ;
1723
                         DUG 3 ;
1724
                         PAIR 3 ;
1725
                         EXEC ;
1726
                         CDR ;
1727
                         UNPAIR }
1728
                       { IF_LEFT
1729
                           { DIG 2 ;
1730
                             DROP ;
1731
                             DIG 3 ;
1732
                             DROP ;
1733
                             DIG 3 ;
1734
                             DROP ;
1735
                             DIG 3 ;
1736
                             DROP ;
1737
                             DIG 3 ;
1738
                             DROP ;
1739
                             PUSH mutez 0 ;
1740
                             AMOUNT ;
1741
                             COMPARE ;
1742
                             EQ ;
1743
                             IF {} { PUSH string "No tez accepted" ; FAILWITH } ;
1744
                             DIG 2 ;
1745
                             UNIT ;
1746
                             SWAP ;
1747
                             DIG 3 ;
1748
                             DIG 2 ;
1749
                             PAIR ;
1750
                             EXEC ;
1751
                             CDR ;
1752
                             DUP ;
1753
                             CAR ;
1754
                             PUSH (option int) (Some 0) ;
1755
                             DIG 3 ;
1756
                             UPDATE ;
1757
                             UPDATE 1 }
1758
                           { DIG 2 ;
1759
                             DROP ;
1760
                             DIG 3 ;
1761
                             DROP ;
1762
                             DIG 3 ;
1763
                             DROP ;
1764
                             DIG 3 ;
1765
                             DROP ;
1766
                             DIG 3 ;
1767
                             DROP ;
1768
                             PUSH mutez 0 ;
1769
                             AMOUNT ;
1770
                             COMPARE ;
1771
                             EQ ;
1772
                             IF {} { PUSH string "No tez accepted" ; FAILWITH } ;
1773
                             DIG 2 ;
1774
                             UNIT ;
1775
                             SWAP ;
1776
                             DIG 3 ;
1777
                             DIG 2 ;
1778
                             PAIR ;
1779
                             EXEC ;
1780
                             CDR ;
1781
                             DUP ;
1782
                             CAR ;
1783
                             NONE int ;
1784
                             DIG 3 ;
1785
                             UPDATE ;
1786
                             UPDATE 1 } ;
1787
                         NIL operation } } } }
1788
           { IF_LEFT
1789
               { IF_LEFT
1790
                   { IF_LEFT
1791
                       { DIG 2 ;
1792
                         DROP ;
1793
                         DIG 3 ;
1794
                         DROP ;
1795
                         DIG 3 ;
1796
                         DROP ;
1797
                         DIG 3 ;
1798
                         DROP ;
1799
                         DIG 3 ;
1800
                         DROP ;
1801
                         PUSH mutez 0 ;
1802
                         AMOUNT ;
1803
                         COMPARE ;
1804
                         EQ ;
1805
                         IF {} { PUSH string "No tez accepted" ; FAILWITH } ;
1806
                         DIG 2 ;
1807
                         UNIT ;
1808
                         SWAP ;
1809
                         DIG 3 ;
1810
                         DIG 2 ;
1811
                         PAIR ;
1812
                         EXEC ;
1813
                         CDR ;
1814
                         SWAP ;
1815
                         DUP 2 ;
1816
                         GET 13 ;
1817
                         DUP 2 ;
1818
                         MEM ;
1819
                         IF {} { PUSH string "Manager not found." ; FAILWITH } ;
1820
                         PUSH nat 0 ;
1821
                         DUP 3 ;
1822
                         GET 13 ;
1823
                         DUP 3 ;
1824
                         GET ;
1825
                         IF_NONE { PUSH int 56 ; FAILWITH } {} ;
1826
                         CAR ;
1827
                         COMPARE ;
1828
                         EQ ;
1829
                         IF
1830
                           {}
1831
                           { PUSH string "The manager still has a balance." ; FAILWITH } ;
1832
                         SWAP ;
1833
                         DUP ;
1834
                         GET 13 ;
1835
                         NONE (pair nat (pair bool key)) ;
1836
                         DIG 3 ;
1837
                         UPDATE ;
1838
                         UPDATE 13 ;
1839
                         NIL operation }
1840
                       { IF_LEFT
1841
                           { DUP 2 ;
1842
                             GET 19 ;
1843
                             DUP 2 ;
1844
                             COMPARE ;
1845
                             GE ;
1846
                             IF
1847
                               {}
1848
                               { PUSH string "[pool.request_withdrawal]: Invalid amount requested." ;
1849
                                 FAILWITH } ;
1850
                             PUSH mutez 0 ;
1851
                             AMOUNT ;
1852
                             COMPARE ;
1853
                             EQ ;
1854
                             IF
1855
                               {}
1856
                               { PUSH string "[pool.request_withdrawal]: No tez accepted." ;
1857
                                 FAILWITH } ;
1858
                             DUP 2 ;
1859
                             GET 15 ;
1860
                             DUP 3 ;
1861
                             GET 34 ;
1862
                             SIZE ;
1863
                             COMPARE ;
1864
                             LE ;
1865
                             IF
1866
                               {}
1867
                               { PUSH string "[pool.deposit]: Too many requests." ;
1868
                                 FAILWITH } ;
1869
                             DUP 2 ;
1870
                             GET 31 ;
1871
                             DUP 3 ;
1872
                             GET 33 ;
1873
                             SENDER ;
1874
                             PAIR ;
1875
                             VIEW "get_balance" nat ;
1876
                             IF_NONE { PUSH int 350 ; FAILWITH } {} ;
1877
                             DUP ;
1878
                             INT ;
1879
                             GT ;
1880
                             IF
1881
                               {}
1882
                               { PUSH string "[pool.request_withdrawal]: Nothing staked." ;
1883
                                 FAILWITH } ;
1884
                             DUP ;
1885
                             DUP 3 ;
1886
                             COMPARE ;
1887
                             LE ;
1888
                             IF
1889
                               {}
1890
                               { PUSH string "[pool.request_withdrawal]: The requested amount is greater than the amount staked." ;
1891
                                 FAILWITH } ;
1892
                             DUP ;
1893
                             INT ;
1894
                             PUSH int 1 ;
1895
                             DUP 5 ;
1896
                             GET 34 ;
1897
                             ITER { CAR ; SENDER ; COMPARE ; EQ ; IF { PUSH int -1 ; ADD } {} } ;
1898
                             DUP ;
1899
                             GT ;
1900
                             IF
1901
                               {}
1902
                               { PUSH string "[pool.request_withdrawal]: You have sent too many requests." ;
1903
                                 FAILWITH } ;
1904
                             SWAP ;
1905
                             DUP 4 ;
1906
                             INT ;
1907
                             SWAP ;
1908
                             SUB ;
1909
                             SWAP ;
1910
                             DUP 2 ;
1911
                             GE ;
1912
                             IF
1913
                               {}
1914
                               { PUSH string "[pool.request_withdrawal]: You are requesting too much." ;
1915
                                 FAILWITH } ;
1916
                             SELF_ADDRESS ;
1917
                             UNIT ;
1918
                             VIEW "fetch_price" nat ;
1919
                             IF_NONE { PUSH int 383 ; FAILWITH } {} ;
1920
                             DUP 6 ;
1921
                             GET 27 ;
1922
                             DUP 2 ;
1923
                             DUP 7 ;
1924
                             MUL ;
1925
                             EDIV ;
1926
                             IF_NONE { PUSH int 390 ; FAILWITH } { CAR } ;
1927
                             DUP 7 ;
1928
                             GET 34 ;
1929
                             LEVEL ;
1930
                             DUP 4 ;
1931
                             DUP 9 ;
1932
                             DUP 5 ;
1933
                             SENDER ;
1934
                             PAIR 5 ;
1935
                             DIG 2 ;
1936
                             DROP ;
1937
                             DIG 2 ;
1938
                             DROP ;
1939
                             DIG 2 ;
1940
                             DROP ;
1941
                             DIG 2 ;
1942
                             DROP ;
1943
                             DIG 2 ;
1944
                             DROP ;
1945
                             DIG 4 ;
1946
                             DROP ;
1947
                             DIG 4 ;
1948
                             DROP ;
1949
                             DIG 5 ;
1950
                             DROP ;
1951
                             DIG 5 ;
1952
                             DROP ;
1953
                             DIG 5 ;
1954
                             DROP ;
1955
                             CONS ;
1956
                             DIG 2 ;
1957
                             SWAP ;
1958
                             UPDATE 34 ;
1959
                             SWAP ;
1960
                             NIL operation ;
1961
                             DIG 3 ;
1962
                             DIG 2 ;
1963
                             SELF_ADDRESS ;
1964
                             SENDER ;
1965
                             PAIR 3 ;
1966
                             SWAP ;
1967
                             DUG 3 ;
1968
                             PAIR 3 ;
1969
                             EXEC ;
1970
                             CDR ;
1971
                             UNPAIR }
1972
                           { DROP ;
1973
                             SWAP ;
1974
                             DROP ;
1975
                             SWAP ;
1976
                             DROP ;
1977
                             SWAP ;
1978
                             DROP ;
1979
                             SWAP ;
1980
                             DROP ;
1981
                             SWAP ;
1982
                             DROP ;
1983
                             SWAP ;
1984
                             DROP ;
1985
                             PUSH mutez 0 ;
1986
                             AMOUNT ;
1987
                             COMPARE ;
1988
                             EQ ;
1989
                             IF {} { PUSH string "No tez accepted" ; FAILWITH } ;
1990
                             DUP ;
1991
                             CAR ;
1992
                             SENDER ;
1993
                             MEM ;
1994
                             IF {} { PUSH string "Unauthorized" ; FAILWITH } ;
1995
                             PUSH int 0 ;
1996
                             DUP 2 ;
1997
                             CAR ;
1998
                             SENDER ;
1999
                             GET ;
2000
                             IF_NONE { PUSH int 42 ; FAILWITH } {} ;
2001
                             COMPARE ;
2002
                             EQ ;
2003
                             IF
2004
                               {}
2005
                               { PUSH string "Not a proposed administrator" ; FAILWITH } ;
2006
                             DUP ;
2007
                             CAR ;
2008
                             PUSH (option int) (Some 1) ;
2009
                             SENDER ;
2010
                             UPDATE ;
2011
                             UPDATE 1 ;
2012
                             NIL operation } } }
2013
                   { IF_LEFT
2014
                       { DIG 2 ;
2015
                         DROP ;
2016
                         DIG 3 ;
2017
                         DROP ;
2018
                         DIG 3 ;
2019
                         DROP ;
2020
                         DIG 3 ;
2021
                         DROP ;
2022
                         DIG 3 ;
2023
                         DROP ;
2024
                         DIG 2 ;
2025
                         UNIT ;
2026
                         SWAP ;
2027
                         DIG 3 ;
2028
                         DIG 2 ;
2029
                         PAIR ;
2030
                         EXEC ;
2031
                         CDR ;
2032
                         DUP 2 ;
2033
                         CAR ;
2034
                         UPDATE 5 ;
2035
                         SWAP ;
2036
                         CDR ;
2037
                         UPDATE 3 ;
2038
                         NIL operation }
2039
                       { IF_LEFT
2040
                           { DIG 2 ;
2041
                             DROP ;
2042
                             DIG 3 ;
2043
                             DROP ;
2044
                             DIG 3 ;
2045
                             DROP ;
2046
                             DIG 3 ;
2047
                             DROP ;
2048
                             DIG 3 ;
2049
                             DROP ;
2050
                             DIG 2 ;
2051
                             UNIT ;
2052
                             SWAP ;
2053
                             DIG 3 ;
2054
                             DIG 2 ;
2055
                             PAIR ;
2056
                             EXEC ;
2057
                             CDR ;
2058
                             SWAP ;
2059
                             SET_DELEGATE ;
2060
                             NIL operation ;
2061
                             SWAP ;
2062
                             CONS }
2063
                           { DIG 2 ;
2064
                             DROP ;
2065
                             DIG 3 ;
2066
                             DROP ;
2067
                             DIG 3 ;
2068
                             DROP ;
2069
                             DIG 3 ;
2070
                             DROP ;
2071
                             DIG 3 ;
2072
                             DROP ;
2073
                             DIG 2 ;
2074
                             UNIT ;
2075
                             SWAP ;
2076
                             DIG 3 ;
2077
                             DIG 2 ;
2078
                             PAIR ;
2079
                             EXEC ;
2080
                             CDR ;
2081
                             SWAP ;
2082
                             UPDATE 9 ;
2083
                             NIL operation } } } }
2084
               { IF_LEFT
2085
                   { IF_LEFT
2086
                       { DIG 2 ;
2087
                         DROP ;
2088
                         DIG 3 ;
2089
                         DROP ;
2090
                         DIG 3 ;
2091
                         DROP ;
2092
                         DIG 3 ;
2093
                         DROP ;
2094
                         DIG 3 ;
2095
                         DROP ;
2096
                         PUSH mutez 0 ;
2097
                         AMOUNT ;
2098
                         COMPARE ;
2099
                         EQ ;
2100
                         IF {} { PUSH string "No tez accepted" ; FAILWITH } ;
2101
                         DIG 2 ;
2102
                         UNIT ;
2103
                         SWAP ;
2104
                         DIG 3 ;
2105
                         DIG 2 ;
2106
                         PAIR ;
2107
                         EXEC ;
2108
                         CDR ;
2109
                         SWAP ;
2110
                         DUP 2 ;
2111
                         GET 13 ;
2112
                         DUP 2 ;
2113
                         GET 4 ;
2114
                         MEM ;
2115
                         IF
2116
                           { DUP 2 ;
2117
                             GET 13 ;
2118
                             DUP 2 ;
2119
                             GET 4 ;
2120
                             GET ;
2121
                             IF_NONE { PUSH int 40 ; FAILWITH } {} ;
2122
                             DIG 2 ;
2123
                             DUP ;
2124
                             GET 13 ;
2125
                             DUP 4 ;
2126
                             CAR ;
2127
                             DUP 5 ;
2128
                             GET 3 ;
2129
                             DIG 4 ;
2130
                             CAR ;
2131
                             PAIR 3 ;
2132
                             SOME ;
2133
                             DIG 3 ;
2134
                             GET 4 ;
2135
                             UPDATE ;
2136
                             UPDATE 13 }
2137
                           { SWAP ;
2138
                             DUP ;
2139
                             GET 13 ;
2140
                             DUP 3 ;
2141
                             CAR ;
2142
                             DUP 4 ;
2143
                             GET 3 ;
2144
                             PUSH int 0 ;
2145
                             ISNAT ;
2146
                             IF_NONE { PUSH int 37 ; FAILWITH } {} ;
2147
                             PAIR 3 ;
2148
                             SOME ;
2149
                             DIG 3 ;
2150
                             GET 4 ;
2151
                             UPDATE ;
2152
                             UPDATE 13 } }
2153
                       { IF_LEFT
2154
                           { DIG 2 ;
2155
                             DROP ;
2156
                             DIG 3 ;
2157
                             DROP ;
2158
                             DIG 3 ;
2159
                             DROP ;
2160
                             DIG 3 ;
2161
                             DROP ;
2162
                             DIG 3 ;
2163
                             DROP ;
2164
                             DIG 2 ;
2165
                             UNIT ;
2166
                             SWAP ;
2167
                             DIG 3 ;
2168
                             DIG 2 ;
2169
                             PAIR ;
2170
                             EXEC ;
2171
                             CDR ;
2172
                             SWAP ;
2173
                             UPDATE 15 }
2174
                           { DIG 2 ;
2175
                             DROP ;
2176
                             DIG 3 ;
2177
                             DROP ;
2178
                             DIG 3 ;
2179
                             DROP ;
2180
                             DIG 3 ;
2181
                             DROP ;
2182
                             DIG 3 ;
2183
                             DROP ;
2184
                             DIG 2 ;
2185
                             UNIT ;
2186
                             SWAP ;
2187
                             DIG 3 ;
2188
                             DIG 2 ;
2189
                             PAIR ;
2190
                             EXEC ;
2191
                             CDR ;
2192
                             SWAP ;
2193
                             DUP ;
2194
                             GT ;
2195
                             IF
2196
                               {}
2197
                               { PUSH string "[pool.min_allowed_mutez]: The requested minimum cannot be negatve." ;
2198
                                 FAILWITH } ;
2199
                             SWAP ;
2200
                             LAMBDA
2201
                               int
2202
                               nat
2203
                               { PUSH int 0 ;
2204
                                 ISNAT ;
2205
                                 IF_NONE { PUSH int 62 ; FAILWITH } {} ;
2206
                                 DUP 2 ;
2207
                                 GT ;
2208
                                 IF
2209
                                   { DROP ; ISNAT ; IF_NONE { PUSH int 65 ; FAILWITH } {} }
2210
                                   { SWAP ; DROP } } ;
2211
                             DIG 2 ;
2212
                             EXEC ;
2213
                             UPDATE 19 } } ;
2214
                     NIL operation }
2215
                   { IF_LEFT
2216
                       { DIG 2 ;
2217
                         DROP ;
2218
                         DIG 3 ;
2219
                         DROP ;
2220
                         DIG 3 ;
2221
                         DROP ;
2222
                         DIG 3 ;
2223
                         DROP ;
2224
                         DIG 3 ;
2225
                         DROP ;
2226
                         DIG 2 ;
2227
                         UNIT ;
2228
                         SWAP ;
2229
                         DIG 3 ;
2230
                         DIG 2 ;
2231
                         PAIR ;
2232
                         EXEC ;
2233
                         CDR ;
2234
                         SWAP ;
2235
                         PUSH nat 0 ;
2236
                         DUP 2 ;
2237
                         CDR ;
2238
                         COMPARE ;
2239
                         GT ;
2240
                         IF
2241
                           {}
2242
                           { PUSH string "The fee cannot be negative." ; FAILWITH } ;
2243
                         PUSH nat 0 ;
2244
                         DUP 2 ;
2245
                         CAR ;
2246
                         COMPARE ;
2247
                         GT ;
2248
                         IF
2249
                           {}
2250
                           { PUSH string "The denominator must be greater than 0." ;
2251
                             FAILWITH } ;
2252
                         UNPAIR ;
2253
                         SWAP ;
2254
                         PAIR ;
2255
                         UPDATE 25 ;
2256
                         NIL operation }
2257
                       { IF_LEFT
2258
                           { DIG 2 ;
2259
                             DROP ;
2260
                             DIG 3 ;
2261
                             DROP ;
2262
                             DIG 3 ;
2263
                             DROP ;
2264
                             DIG 3 ;
2265
                             DROP ;
2266
                             DIG 3 ;
2267
                             DROP ;
2268
                             DIG 2 ;
2269
                             UNIT ;
2270
                             SWAP ;
2271
                             DIG 3 ;
2272
                             DIG 2 ;
2273
                             PAIR ;
2274
                             EXEC ;
2275
                             CDR ;
2276
                             SWAP ;
2277
                             UPDATE 29 ;
2278
                             NIL operation }
2279
                           { DUP 3 ;
2280
                             UNIT ;
2281
                             SWAP ;
2282
                             DIG 3 ;
2283
                             DIG 2 ;
2284
                             PAIR ;
2285
                             EXEC ;
2286
                             CDR ;
2287
                             DUG 7 ;
2288
                             DUG 7 ;
2289
                             DIG 6 ;
2290
                             DIG 7 ;
2291
                             PUSH mutez 0 ;
2292
                             AMOUNT ;
2293
                             COMPARE ;
2294
                             EQ ;
2295
                             IF
2296
                               {}
2297
                               { PUSH string "[pool.update_balance]: No tez accepted." ;
2298
                                 FAILWITH } ;
2299
                             SELF_ADDRESS ;
2300
                             UNIT ;
2301
                             VIEW "fetch_price" nat ;
2302
                             IF_NONE { PUSH int 225 ; FAILWITH } {} ;
2303
                             DUP 3 ;
2304
                             GET 13 ;
2305
                             SENDER ;
2306
                             GET ;
2307
                             IF_NONE { PUSH int 232 ; FAILWITH } {} ;
2308
                             CAR ;
2309
                             DUP 3 ;
2310
                             SUB ;
2311
                             DIG 3 ;
2312
                             DUP ;
2313
                             GET 13 ;
2314
                             DUP ;
2315
                             SENDER ;
2316
                             DUP ;
2317
                             DUG 2 ;
2318
                             GET ;
2319
                             IF_NONE { PUSH int 233 ; FAILWITH } {} ;
2320
                             DIG 6 ;
2321
                             UPDATE 1 ;
2322
                             SOME ;
2323
                             SWAP ;
2324
                             UPDATE ;
2325
                             UPDATE 13 ;
2326
                             DUG 2 ;
2327
                             DUP ;
2328
                             GT ;
2329
                             IF
2330
                               { DIG 3 ;
2331
                                 DROP ;
2332
                                 DIG 3 ;
2333
                                 DROP ;
2334
                                 DIG 3 ;
2335
                                 DROP ;
2336
                                 DIG 4 ;
2337
                                 DROP ;
2338
                                 DIG 4 ;
2339
                                 DROP ;
2340
                                 LAMBDA
2341
                                   int
2342
                                   nat
2343
                                   { PUSH int 0 ;
2344
                                     ISNAT ;
2345
                                     IF_NONE { PUSH int 62 ; FAILWITH } {} ;
2346
                                     DUP 2 ;
2347
                                     GT ;
2348
                                     IF
2349
                                       { DROP ;
2350
                                         ISNAT ;
2351
                                         IF_NONE { PUSH int 65 ; FAILWITH } {} }
2352
                                       { SWAP ; DROP } } ;
2353
                                 DUP 2 ;
2354
                                 EXEC ;
2355
                                 DUP 4 ;
2356
                                 GET 25 ;
2357
                                 CDR ;
2358
                                 DUP 5 ;
2359
                                 GET 25 ;
2360
                                 CAR ;
2361
                                 DIG 2 ;
2362
                                 MUL ;
2363
                                 EDIV ;
2364
                                 IF_NONE { PUSH int 238 ; FAILWITH } { CAR } ;
2365
                                 DIG 2 ;
2366
                                 DUP 4 ;
2367
                                 GET 27 ;
2368
                                 DIG 2 ;
2369
                                 MUL ;
2370
                                 EDIV ;
2371
                                 IF_NONE { PUSH int 242 ; FAILWITH } { CAR } ;
2372
                                 NIL operation ;
2373
                                 DIG 4 ;
2374
                                 DIG 2 ;
2375
                                 DUP 5 ;
2376
                                 GET 29 ;
2377
                                 PAIR ;
2378
                                 SWAP ;
2379
                                 DIG 4 ;
2380
                                 DIG 3 ;
2381
                                 DIG 3 ;
2382
                                 PAIR 3 ;
2383
                                 EXEC ;
2384
                                 CDR ;
2385
                                 UNPAIR ;
2386
                                 SWAP ;
2387
                                 DUG 2 }
2388
                               { SWAP ;
2389
                                 DROP ;
2390
                                 DIG 2 ;
2391
                                 DROP ;
2392
                                 DIG 2 ;
2393
                                 DROP ;
2394
                                 DIG 2 ;
2395
                                 DROP ;
2396
                                 DIG 2 ;
2397
                                 DROP ;
2398
                                 DIG 2 ;
2399
                                 DROP ;
2400
                                 DIG 2 ;
2401
                                 DROP ;
2402
                                 NIL operation } ;
2403
                             LAMBDA
2404
                               int
2405
                               nat
2406
                               { PUSH int 0 ;
2407
                                 ISNAT ;
2408
                                 IF_NONE { PUSH int 62 ; FAILWITH } {} ;
2409
                                 DUP 2 ;
2410
                                 GT ;
2411
                                 IF
2412
                                   { DROP ; ISNAT ; IF_NONE { PUSH int 65 ; FAILWITH } {} }
2413
                                   { SWAP ; DROP } } ;
2414
                             DIG 2 ;
2415
                             DUP 4 ;
2416
                             GET 11 ;
2417
                             INT ;
2418
                             ADD ;
2419
                             EXEC ;
2420
                             DIG 2 ;
2421
                             SWAP ;
2422
                             UPDATE 11 ;
2423
                             SWAP } } } } } ;
2424
         NIL operation ;
2425
         SWAP ;
2426
         ITER { CONS } ;
2427
         PAIR } ;
2428
  view "fetch_price" unit nat
2429
        { UNPAIR ;
2430
          DUP 2 ;
2431
          GET 31 ;
2432
          DUP 3 ;
2433
          GET 33 ;
2434
          VIEW "get_total_supply" nat ;
2435
          IF_NONE { PUSH int 697 ; FAILWITH } {} ;
2436
          DUP 3 ;
2437
          GET 27 ;
2438
          DUP 2 ;
2439
          INT ;
2440
          NEQ ;
2441
          IF
2442
            { DROP ;
2443
              SWAP ;
2444
              DROP ;
2445
              DUP 2 ;
2446
              GET 27 ;
2447
              DIG 2 ;
2448
              GET 11 ;
2449
              MUL ;
2450
              EDIV ;
2451
              IF_NONE { PUSH int 707 ; FAILWITH } { CAR } }
2452
            { SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP } } }